一篇掌握python内置函数详解(全面且有演示)-白红宇

一篇掌握python内置函数详解(全面且有演示)

阅读量：4304 次

发布时间：2019-05-27

本文共 29388 字，大约阅读时间需要 97 分钟。

本编研究下python的内置函数(属性/魔法方法研究)

基于python3的版本来研究，内容虽有点比较多，只要耐心看完必定有所收获。

本文概要

1.staticmehtod和classmethod使用和区别

2.setattr、getattr、delattr、hasattr使用

3.类型转化：int、str、float、list、dict、tuple、iter 的使用

4.isinstance、issubclass、type的使用和区别

5.format、print、open如何使用

6.sorted、reversed、max、min、len、sum使用

7.map、filter、zip使用

8.dir、call使用

如果上面几点问题都能回答上，那么可以跳过本篇文章了。本篇相关文章共三连弹。(端午节在家整理，有帮助记得点个👍，就是对我最大的肯定😘😘😘)

技巧：文章内容太多如何阅读？

先看文章的目录(TOC)，掌握文章整体脉络

然后走马观花式，通篇阅读。如果文章有用，再细细研究；文章没用的直接忽略，找下篇。
- 如果为了解决问题的，解决完了再细读
- 如果学习的，收藏起来，边学习，边敲代码实践 (别copy代码，自己敲)

收藏完，下次用的时候，记不得了，到文章直接CTRL+F查找关键字

这提到链接收藏功能，推荐下里的【我的链接】可以管理自己的链接哦 (个人链接属于私人资产，所以要注册个账户才能使用哦👇👇👇)

浩瀚的网络中，你我的相遇也是种缘分，看你天资聪慧、骨骼精奇，就送你一场大造化吧，能领悟多少就看你自己了。

1.函数表格

这先盗用下菜鸟教程里的内置函数表格，后面会对每个详细介绍，并进行补充

		内置函数







				unicode()






		object()

下面分类来研究下每个函数

2.数学运算类

2-1.abs

abs(x)函数返回数字的绝对值。

x: 数值表达式，可以是整数，浮点数，复数。

参数可以是整型，也可以是复数

若参数是复数，则返回复数的模

演示

class MyTestCase(unittest.TestCase):    def test_abs(self):        a = 3.14        b = -7.36        c = complex(3, 4)  # 创建一个复数        print(abs(a))  # 3.14        print(abs(b))  # 7.36        print(abs(c))  # 5.0

2-2.complex

complex()函数用于创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。

real: int, long, float或字符串；

imag: int, long, float；

演示

class MyTestCase(unittest.TestCase):    def test_complex(self):        a = complex(3, 4)        b = complex(1)        c = complex('3')        d = complex("3+4j")        print(a) # (3+4j)        print(b) # (1+0j)        print(c) # (3+0j)        print(d) # (3+4j)

2-3.divmod

divmod(a, b)函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

a: 数字，非复数。

b: 数字，非复数。

在这里插入图片描述

演示

class MyTestCase(unittest.TestCase):    def test_divmod(self):        print(divmod(3, 2))  # (1, 1)        print(divmod(3, -2))  # (-2, -1),        print(divmod(-3, 2))  # (-2, 1)        print(divmod(-3, -2))  # (1, -1)        print(divmod(3, 1.2))  # (2.0, 0.6000000000000001)

以divmod(3, -2)来分析下：

b=-2是负数，y符号要跟b保持一致，所以y也得是负数。a、b都取正数，3/2的余数为1，所以y=-1

以a=3为目标,现在y=-1了，所以我们计算出b*x=4才能和y=-1相加为3，现在b=-2，要使得b*x=4,那么x得为-2

2-4.类型转化

int、float、long、char、bool、二进制、八进制、十六进制等转化

float()函数用于将整数和字符串转换成浮点数。

int() 函数用于将一个字符串或数字转换为整型。

int(x, base=10):x为字符串或数字；base为进制数，默认十进制。

chr() 用一个整数作参数，返回一个对应的字符。

chr(i): i 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

bin(x): x为int 或者 long int 数字

oct() 函数将一个整数转换成8进制字符串。

oct(x): x为整数。

hex() 函数用于将一个指定数字转换为 16 进制数。

hex(x): x为整数

bool() 函数用于将整数和字符串转换成浮点数。

bool(x): x为要进行转换的参数。不写参数默认是False

更多的ascii码可以查a

演示

class MyTestCase(unittest.TestCase):    def test_float(self):        print(float(1))  # 1.0        print(float(-123.6))  # -123.6        print(float('123'))  # 123.0            def test_int(self):        print(int())  # 默认0        print(int(2))  # 2        print(int(2.5))  # 2        print(int('1',2))  # 1        print(int('10',8))  # 8        print(int('10',10))  # 10        print(int('10',16))  # 16        print(int('0x10',16))  # 16            def test_chr(self):        print(chr(0x30)) # 0        print(chr(97)) # a            def test_bin(self):        print(bin(97)) # 0b1100001         print(bin(88)) # 0b1011000            def test_oct(self):        print(oct(97)) # 0o141        print(oct(88)) # 0o130            def test_hex(self):        print(hex(97)) # 0x61        print(hex(88)) # 0x58             def test_bool(self):        print(bool()) # False        print(bool(True)) # True        print(bool(0)) # False        print(bool(88)) # True        print(issubclass(bool, int)) # True: bool 是 int 子类

2-5.pow

pow()方法返回 x^y（x的y次方）的值。

pow(x, y[, z])

函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

math 模块 pow() 方法的语法:

import mathmath.pow( x, y )

pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

演示

class MyTestCase(unittest.TestCase):    def test_divmod(self):        print(pow(3, 0))  # 1 原生        print(pow(3, 2))  # 9 原生        print(math.pow(3, 2))  # 9.0 math的

2-6.round

round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍五入）。

精度要求高的，不建议使用该函数。

演示

class MyTestCase(unittest.TestCase):    def test_round(self):        print(round(3))  # 3        print(round(70.43456))  # 70        print(round(70.50456))  #  71        print(round(70.23456, 3))  # 70.235        print(round(-100.000056, 3))  # -100.0

2-7.sum

sum()方法对系列进行求和计算。

sum(iterable[, start])

iterable: 可迭代对象，如：列表、元组、集合。

start – 指定相加的参数，如果没有设置这个值，默认为0。

演示

class MyTestCase(unittest.TestCase):    def test_sum(self):        print(sum([1,2,3,4]))  # 10 列表        print(sum((1,2,3,4)))  # 10 元组        print(sum((1,2,3,4),10))  # 20

2-8.range

range()函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。

list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。

range(start, stop[, step])

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

注意

range：左包括，右不包括(从start开始，stop前一个结束)

演示

class MyTestCase(unittest.TestCase):    def test_range(self):        print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]        print(list(range(1, 10)))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]        print(list(range(1, 10, 2)))  # [1, 3, 5, 7, 9]        print(list(range(10, 0, -1)))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

3.集合类操作

3-1.format

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过{}和:来代替以前的% 。

演示

class MyTestCase(unittest.TestCase):    def test_formart(self):        print("{} - {}".format('iworkh', '沐雨云楼'))  # iworkh - 沐雨云楼        print("{1} - {0}".format('iworkh', '沐雨云楼'))  # 沐雨云楼 - iworkh        print("{company} - {name}".format(company='iworkh', name='沐雨云楼'))  # iworkh - 沐雨云楼        # 字典        data_dic = {
   'company': 'iworkh', 'name': '沐雨云楼'}        print("网站：{company} - 名称：{name}".format(**data_dic))  # 网站：iworkh - 名称：沐雨云楼        # 列表: 说明 0[1]中的0代表是data_list，1表示list里第一元素        data_list1 = ['iworkh', '沐雨云楼']        data_list2 = ['test', 'yuxl']        print("网站：{0[0]} - 名称：{1[1]}".format(data_list1, data_list2))  # 网站：iworkh - 名称：沐雨云楼        # 格式化        print("{:.2f}".format(3.1415926))        # {}的转义        print("{
   {}}是表示转移的,{:.2%}".format(0.26))

主要关注几点：

一个{}占位符，两个{}可转义{}

可用通过数字、参数名来格式化，数据值可用是dict、也可以是list

还可以来格式化数字

3-2.转化

str() 函数将对象转化为适于人阅读的形式。

iter() 函数用来生成迭代器。

iter(object[, sentinel]):
object: 支持迭代的集合对象。
sentinel: 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

dict() 函数用于创建一个字典。

三种创建方式

dict(**kwarg)： **kwargs是关键字

dict(mapping, **kwarg)：mapping是元素的容器。

dict(iterable, **kwarg)：iterable是可迭代对象。

list() 函数用于将元组或字符串转换为列表。

元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

tuple()

tuple( iterable ): iterable为要转换为元组的可迭代序列。

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

set([iterable]): iterable是可迭代对象对象(列表、字典、元组等等)；

frozenset()

frozenset([iterable]) : iterable是可迭代对象对象(列表、字典、元组等等)；

sorted() 函数对所有可迭代的对象进行排序操作。

sort 是应用在 list 上的方法（在原有的list上操作）
sorted 可以对所有可迭代的对象进行排序操作。(返回一个新的 list)
sorted(iterable, key=None, reverse=False)

iterable: 可迭代对象。

key:主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse : 排序规则，reverse = True 降序， reverse = False 升序（默认）。

演示

class MyTestCase(unittest.TestCase):    def test_str(self):        dict = {
   'company': 'iworkh', 'name': '沐雨云楼'}        print(str(dict))  # {'company': 'iworkh', 'name': '沐雨云楼'}        list = ['iworkh', '沐雨云楼']        print(str(list))  # ['iworkh', '沐雨云楼']    def test_iter(self):        list = ['iworkh', '沐雨云楼']        print(iter(list))  # 
   
            for item in iter(list):            print(item)        dict = {
   'company': 'iworkh', 'name': '沐雨云楼'}        print(iter(dict))  # 
    
             for item_key in iter(dict):            print("{}-{}".format(item_key, dict[item_key]))    def test_dict(self):        print(dict())  # 空dict {}        print(dict(name='沐雨云楼', age=20, sex='男'))  # {'name': '沐雨云楼', 'age': 20, 'sex': '男'}        list_zip = zip(['name', 'age', 'sex'], ['沐雨云楼', 20, '男'])        print(dict(list_zip))  # {'name': '沐雨云楼', 'age': 20, 'sex': '男'}        tuple_list = [('name', '沐雨云楼'), ('age', 20), ('sex', '男')]        print(dict(tuple_list))  # {'name': '沐雨云楼', 'age': 20, 'sex': '男'}    def test_list(self):        tuple = ('iworkh', 20, '男')        print(list(tuple))  # ['iworkh', 20, '男']        print(list('iowrkh 沐雨云楼'))  # ['i', 'o', 'w', 'r', 'k', 'h', ' ', '沐', '雨', '云', '楼']    def test_tuple(self):        list = ['iworkh', '沐雨云楼']        print(tuple(list))  # ('iworkh', '沐雨云楼')    def test_set(self):        set1 = {
   1, 2, 3}        list = [3, 4, 5]        set2 = set(list)        print(set1 & set2)  # 交集：{3}        print(set1 | set2)  # 并集：{1, 2, 3, 4, 5}        print(set1 - set2)  # 差集：{1, 2}    def test_frozenset(self):        print(frozenset(range(5)))  # frozenset({0, 1, 2, 3, 4})        list = ['iworkh', '沐雨云楼']        print(frozenset(list))  # frozenset({'沐雨云楼', 'iworkh'})    def test_sorted(self):        list = [10, 1, 4, 3, 4]        print(list)        print(sorted(list)) # 返回的新list        print(list)        print(list.sort()) # 在原来的list上操作        print(list)

3-3.最值

min 函数返回给定参数的最小值，参数可以为序列。

max 函数返回给定参数的最大值，参数可以为序列。

演示

class MyTestCase(unittest.TestCase):    def test_min(self):        print(min(10,2,3,4))  # 2        print(min([10,2,3,4]))  # 2    def test_max(self):        print(max(10,2,3,4))  # 10        print(max([10,2,3,4]))  # 10

3-4.enumerate

enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法：enumerate(sequence, [start=0])

sequence: 一个序列、迭代器或其他支持迭代对象。

start: 下标起始位置。

演示

class MyTestCase(unittest.TestCase):    def test_enumerate(self):        list_data = ['a', 'b', 'c']        e = enumerate(list_data, 0)        for index, item in e:            print("{} --- {}".format(index, item))

3-5.reversed

reversed 函数返回一个反转的迭代器。

演示

class MyTestCase(unittest.TestCase):    def test_reversed(self):        list_data = [1, 2, 3, 4]        reversed_iter = reversed(list_data)  # 返回是iter        print(list(reversed_iter)) # [4, 3, 2, 1]        seqString = 'iworkh'        print(list(reversed(seqString))) # ['h', 'k', 'r', 'o', 'w', 'i']

4.逻辑判断

4-1.all

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。

注意

空元组、空列表返回值为True，这里要特别注意。

语法：all(iterable)

iterable: 元组或列表。

演示

class MyTestCase(unittest.TestCase):    def test_all(self):        print(all([]))  # True 空list为true        print(all(()))  # True 空tuple为true        print(all((1,2,3,4)))  #True        print(all([1,0,2])) # False，有0        print(all(['a','','c'])) # False， 有空

4-2.any

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

语法：any(iterable)

iterable – 元组或列表。

演示

class MyTestCase(unittest.TestCase):    def test_any(self):        print(any([]))  # False 空list为False        print(any(()))  # False 空tuple为False        print(any((0,0)))  # False 都0        print(any(['','','']))  # False 都空        print(any((1,2,3,4)))  #True        print(any([0,0,2])) # True，有2        print(any(['a','','c'])) # True， 有值

5.反射

5-1.callable

callable() 函数用于检查一个对象是否是可调用的。

如果返回 True，object 仍然可能调用失败；
但如果返回 False，调用对象 object 绝对不会成功。

对于函数、方法、lambda 函式、类以及实现了__call__方法的类实例, 它都返回 True。

属性为false

演示

#  函数def fun_a():    pass# 没有实现__call__的类Aclass A:    def method(self):        pass# 实现__call__的类Bclass B:    no: str = 1    _sex: str = '男'    def __call__(self, *args, **kwargs):        passclass MyTestCase(unittest.TestCase):    def test_call(self):        # str、list、number        print(callable(0))  # False        print(callable('aaaa'))  # False        print(callable([1, 2, 3]))  # False        print(callable((1, 2, 3)))  # False        # 函数        print(callable(fun_a))  # True        # 类属性        print(callable(B.no))  # False 属性        print(callable(B._sex))  # False 属性        # 方法        print(callable(A.method))  # True        # 类        print(callable(A))  # True        print(callable(B))  # True        # 对象        a = A()        print(callable(a))  # False 没实现`__call__`方法        b = B()        print(callable(b))  # True 实现了`__call__`方法        print(callable(b.no))  # False 属性        print(callable(b._sex))  # False 属性        pass

5-2.classmethod

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数。

但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。

要跟后面介绍的staticmethod区分开。

演示

class A(object):    bar = 1    def func1(self):        print ('foo')    @classmethod    def func2(cls):        print ('func2')        print (cls.bar)        cls().func1()   # 调用 func1 方法class MyTestCase(unittest.TestCase):    def test_classmethod(self):        A.func2()

5-3.compile

compile() 函数将一个字符串编译为字节代码。

语法：compile(source, filename, mode[, flags[, dont_inherit]])

source – 字符串或者AST（Abstract Syntax Trees）对象。

filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

mode – 指定编译代码的种类。可以指定为 exec, eval, single。

flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。

flags和dont_inherit是用来控制编译源码时的标志

演示

class MyTestCase(unittest.TestCase):    def test_compile(self):        # exec        source = "for i in range(1,5): print(i)"        compiled_source = compile(source, '', 'exec')        exec(compiled_source)        # eval        str = "3 * 4 + 5"        compiled_eval = compile(str, '', 'eval')        result = eval(compiled_eval)        print(result)

exec 和eval 后面会讲解

5-4.dir

dir()

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；

带参数时，返回参数的属性、方法列表。

如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

演示

class User:    name: str = 'iworkh'    def say(self):        passclass MyTestCase(unittest.TestCase):    def test_dir(self):        # 空        print(dir())        # list        print(dir([]))        #  str        print(dir('a'))        # 对象        print(dir(User)) #属性和方法都出来)

只贴一个list的结果，其他得不贴了

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',  '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__',  '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',  '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__',  '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert',  'pop', 'remove', 'reverse', 'sort']

5-5.delattr

delattr() 函数用于删除属性。

语法：delattr(object, name)

object: 对象。

name: 必须是对象的属性

delattr(x, 'filedname') 相等于 del x.filename

演示

class MyTestCase(unittest.TestCase):    def test_delattr(self):        user = User()        user.name = 'iworkh'        user.password = 'iworkh123'        user.age = 10        print(user.__dict__)        delattr(user, 'password') # 等价于 del user.password        print(user.__dict__)

5-6.eval

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

语法：eval(expression[, globals[, locals]])

expression – 表达式。

globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

演示

class MyTestCase(unittest.TestCase):    def test_eval(self):        x = 8        print(eval('x+3'))        print(eval('7*3'))

5-7.exec

exec()执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

语法：exec(object[, globals[, locals]])

object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。

如果object是一个字符串，该字符串会先被解析为一组Python语句，然后再执行（除非发生语法错误）。

如果object是一个code对象，那么它只是被简单的执行。

globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。

locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

演示

class MyTestCase(unittest.TestCase):    def test_exec(self):        # 普通字符串        exec('print("Hello World")')        # 有参数，使用dict传入        source = """for i in range(num):                    print ("iter time: %d" % i)            """        exec(source, {
   'num': 5})

5-8.filter

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

语法：filter(function, iterable)

function – 判断函数。

iterable – 可迭代对象。

序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

演示

def is_odd(n):    return n % 2 == 1class MyTestCase(unittest.TestCase):    def test_filter(self):        list_data = list(range(1, 10))        # lambda        result = filter(lambda item: item % 2 == 0, list_data) # 返回的是iter        print(list(result)) # [2, 4, 6, 8]        # func        result2 = filter(is_odd, list_data)        print(list(result2)) # [1, 3, 5, 7, 9]

5-9.getattr

getattr() 函数用于返回一个对象属性值。

语法：getattr(object, name[, default])

object – 对象。

name – 字符串，对象属性。

default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

演示

class MyTestCase(unittest.TestCase):    def test_getattr(self):        user = User()        user.name = 'iworkh'        user.age = 20        getattr(user, 'name')

5-10.globals

globals() 函数会以字典类型返回当前位置的全部全局变量。

演示

global_a = 10global_b = 'iworkh'class MyTestCase(unittest.TestCase):    def test_globals(self):        # globals 函数返回一个全局变量的字典，包括所有导入的变量。        all_globals = globals()        print(all_globals['global_b'])

5-11.hasattr

hasattr() 函数用于判断对象是否包含对应的属性和方法。

语法：hasattr(object, name)

object – 对象。

name – 字符串，属性名。

演示

class User:    name: str    age: int    def say(self):        passclass MyTestCase(unittest.TestCase):    def test_hasattr(self):        user = User()        user.name = 'iworkh'        user.age = 120        print(hasattr(user, 'name'))  # True 属性        print(hasattr(user, 'sex'))  # False        print(hasattr(user, 'say'))  # True 方法

5-12.hash

hash()用于获取一个对象（字符串或者数值等）的哈希值。

函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

演示

class User:    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_hash(self):        print(hash(1))        # 字符串        print(hash("2"))        # tuple        print(hash((1, False, '3')))        # dict要转str        print(hash(str({
   'name': 'iworkh', 'age': 20})))        # 对象        user = User()        user.name = 'iworkh'        user.age = 120        print(hash(user))

5-13.id

id() 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。

演示

class User:    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_id(self):        print(id(1))        # 字符串        print(id("2"))        # tuple        print(id((1, False, '3')))        # list        print(id([1, False, '3']))        # dict        print(id({
   'name': 'iworkh', 'age': 20}))        # 对象        user = User()        user.name = 'iworkh'        user.age = 120        print(id(user))

5-14.isinstance

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。

语法：isinstance(object, classinfo)

object – 实例对象。

classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组(只要一个满足就返回True)。

演示

class People:    sex: strclass User(People):    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_isinstance(self):        a = 10        print(isinstance(a, int))  # True        print(isinstance(a, float))  # False        print(isinstance(a, (int, float, str)))  # True 满足一个即可        # 对象        print(isinstance(User(), User))  # True        print(type(User()) == User)  # True        print(isinstance(User(), People))  # True  isinstance考虑继承        print(type(User()) == People)  # False type不考虑继承

5-15.issubclass

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

语法：issubclass(class, classinfo)

class – 类。

classinfo – 类。

这参数，两个都是类。而前面介绍的isinstance参数，一个是对象，一个是类

演示

class People:    sex: strclass User(People):    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_issubclass(self):        # 对象        print(issubclass(User, People))  # True

5-16.len

len()方法返回对象（字符、列表、元组等）长度或项目个数。

演示

class MyTestCase(unittest.TestCase):    def test_len(self):        # str        print(len('iworkh'))        # list        print(len([1, 2, 3]))        # tuple        print(len((1, 2, 3)))        # dict        dict = {
   'name': 'iworkh', 'age': 10}        print(len(dict))

5-17.locals

locals() 函数会以字典类型返回当前位置的全部局部变量。

演示

def add(a, b):    dict = {
   'name': 'iworkh', 'age': 10}    print(locals()) # {'a': 1, 'b': 3, 'dict': {'name': 'iworkh', 'age': 10}}    return a + bclass MyTestCase(unittest.TestCase):    def test_locals(self):        add(1, 3)

5-18.map

map()会根据提供的函数对指定序列做映射。

语法：map(function, iterable, ...)

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

function – 函数

iterable – 一个或多个序列

演示

class MyTestCase(unittest.TestCase):    def test_map(self):        list_data = [1, 2, 3, 4]        result = map(lambda x: x * 2, list_data) # 返回iter        print(list(result))

5-19.bytearray

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

语法class bytearray([source[, encoding[, errors]]])

如果 source 为整数，则返回一个长度为 source 的初始化数组；

如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

如果 source 为可迭代类型，则元素必须为[0 ,255]中的整数；

如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

如果没有输入任何参数，默认就是初始化数组为0个元素。

演示

class MyTestCase(unittest.TestCase):    def test_bytearray(self):        # str        print(bytearray('abcde', 'utf-8'))        # list        list_data = [1, 2, 3, 4]        print(bytearray(list_data))

5-20.memoryview

memoryview() 函数返回给定参数的内存查看对象(memory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

语法：memoryview(obj)

返回值是元组列表。

演示

class MyTestCase(unittest.TestCase):    def test_memoryview(self):        # str        ba = bytearray('abcde', 'utf-8')        mv = memoryview(ba)        print(mv[1])  # 98        print(mv[1:4])  # 
   
            print(mv[1:4].tobytes())  # b'bcd'        print(mv[-1])  # 101        print("*" * 50)        # list        list_data = [1, 2, 3, 4]        ba_list = bytearray(list_data)        mv_list = memoryview(ba_list)        print(mv_list[0]) # 1

5-21.next

next() 返回迭代器的下一个项目。

next() 函数要和生成迭代器的iter() 函数一起使用。

语法：next(iterator[, default])

iterator – 可迭代对象

default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

演示

class MyTestCase(unittest.TestCase):    def test_next(self):        list_data = [1, 2, 3, 4]        it = iter(list_data)        while (True):            try:                data = next(it)                print(data)            except StopIteration:                break

5-22.property

property() 函数的作用是在新式类中返回属性值。

语法：class property([fget[, fset[, fdel[, doc]]]])

fget – 获取属性值的函数

fset – 设置属性值的函数

fdel – 删除属性值函数

doc – 属性描述信息

演示

对象里有个私有属性，然后通过方法来执行塞值、取值、删除操作

通过方法调用

class User:    _name: str    def get_name(self):        print('call method ... get_name')        return self._name    def set_name(self, value):        print('call method ... set_name')        self._name = value    def del_name(self):        print('call method ... del_name')        del self._nameclass MyTestCase(unittest.TestCase):    def test_method(self):        # 对象.方法        user = User()        user.set_name(value='iworkh')        print(user.get_name())

通过property方式

class User:    _name: str    def get_name(self):        print('call method ... get_name')        return self._name    def set_name(self, value):        print('call method ... set_name')        self._name = value    def del_name(self):        print('call method ... del_name')        del self._name    name = property(get_name, set_name, del_name, '姓名')class MyTestCase(unittest.TestCase):    def test_property(self):        # property        user2 = User()        user2.name='iworkh'        print(user2.name)

添加name = property(get_name, set_name, del_name, '姓名')定义

使用装饰器

class User2:    _name: str    @property    def name(self):        """        姓名        """        print('call2 method ... get_name')        return self._name    @name.setter    def name(self, value):        print('call2 method ... set_name')        self._name = value    @name.deleter    def name(self):        print('call2 method ... del_name')        del self._nameclass MyTestCase(unittest.TestCase):    def test_anno(self):        # property        user2 = User2()        user2.name = 'iworkh'        print(user2.name)

使用@property对应的方法名name就是属性名name，然后再对对应的setter和getter方法设置@name.setter和@name.deleter

5-23.vars

vars()函数返回对象object的属性和属性值的字典对象。

演示

class User:    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_vars(self):        # 对象        user = User()        user.name = 'iworkh'        user.age = 11        print(vars(user)) # {'name': 'iworkh', 'age': 11}

5-24.setattr

setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

语法：setattr(object, name, value)

object – 对象。

name – 字符串，对象属性。

value – 属性值。

演示

class User:    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_setattr(self):        # 对象        user = User()        user.name = 'iworkh'        # 存在属性赋值        setattr(user, 'age', 20)        print(user.age) # 20        # 不存在属性赋值        setattr(user, 'sex', '男')        print(user.sex) # 男

5-25.slice

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

语法： slice(stop)或 slice(start, stop[, step])

演示

class MyTestCase(unittest.TestCase):    def test_type(self):        slice_end = slice(3)        print(slice_end)        data = range(10)        print(data[slice_end])

5-26.staticmethod

staticmethod 返回函数的静态方法。

既实现实例化使用 C().f()，也可以不实例化调用该方法 C.f()。

要跟前面介绍的classmethod区分开。

区别

如果方法不需要访问对象/类的属性或其他方法的话，那么使用staticmethod

如果需要方法类的属性或其他方法的话，那么使用classmethod

classmethod的方法第一个参数是cls

演示

class A(object):    @staticmethod    def add(a, b):        return a + bclass MyTestCase(unittest.TestCase):    def test_staticmethod(self):        # 类调用        print(A.add(2, 4))        # 对象调用        a = A()        print(a.add(2, 6))

5-27.type

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

语法：type(object) 或 type(name, bases, dict)

name – 类的名称。

bases – 基类的元组。

dict – 字典，类内定义的命名空间变量。

演示

class MyTestCase(unittest.TestCase):    def test_type(self):        # int        print(type(10))  # 
   
            # list        print(type([1, 2, 3]))  #

5-28.repr

repr() 函数将对象转化为供解释器读取的形式。

不怎么用

演示

class User:    name: str    age: intclass MyTestCase(unittest.TestCase):    def test_repr(self):        # str        name = 'iwrokh'        print(name)        print(repr(name))        # list        list_data = [1, 2, 3, 4]        print(list_data)        print(repr(list_data))        # dict        dict = {
   'name': 'iworkh', 'age': 19}        print(dict)        print(repr(dict))        # obj        user = User        user.name = 'iworkh'        user.age = 11        print(user)        print(repr(user))

5-29.zip

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

演示

class MyTestCase(unittest.TestCase):    def test_zip(self):        a = [1, 2, 3]        b = [4, 5, 6]        c = [4, 5, 6, 7, 8]        zip_tuple = zip(a, b)        print(list(zip_tuple))        print(list(zip(a, c)))  # 元素个数与最短的列表一致        # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式        x, y = zip(*zip(a, c))  # 可以        print(list(x))        print(list(y))        # m, n = zip(*zip_tuple)  # 报错 not enough values to unpack，上面有调用了list(zip_tuple)就会报错        zip_tuple2 = zip(a, b)        m, n = zip(*zip_tuple2) # 正确，没有对zip(a, b)的结果进行list转化        print(list(m))        print(list(n))

警告

使用zip(*)时候，如果参数是前面定义过的变量的话，那么最好不要对变量做一些操作，可能导致zip(*)失败。可以能原因，在list()的时候，对源对象进行了特殊处理，导致了后面使用zip(*)的时候失败。

这还有一篇stackoverflow也遇到这错。有兴趣的可以取研究下

5-30.xrange

python2 xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。

python3中没有了，就用range

6.IO操作

6-1.input

input() 函数接受一个标准输入数据，返回为 string 类型。

演示

class MyTestCase(unittest.TestCase):    def test_input(self):        a = input("input:")        print(a)

6-2.open

open()函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。

语法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file: 必需，文件路径（相对或者绝对路径）。

mode: 可选，文件打开模式(r: 读；x:写； a:追加；b:二进制； +:打开一个文件进行更新，可读可写)

buffering: 设置缓冲

encoding: 一般使用utf8

errors: 报错级别

newline: 区分换行符

closefd: 传入的file参数类型

opener:

默认为文本模式，如果要以二进制模式打开，加上 b 。

演示

class MyTestCase(unittest.TestCase):    def test_open(self):        f = open('file_buildin_func.py')        try:            data = f.read()            print(data)        except Exception as e:            print(e)        finally:            f.close()

6-3.print

print() 方法用于打印输出，最常见的一个函数。

语法: print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

sep – 用来间隔多个对象，默认值是一个空格。

end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

file – 要写入的文件对象。

flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

演示

class MyTestCase(unittest.TestCase):    def test_print(self):        print("xxx")        print("aaa""bbb")        print("aaa","bbb")        print("https://","www","iworkh","com",sep='.')

7.其他

7-1.help

help() 函数用于查看函数或模块用途的详细说明。

演示

class MyTestCase(unittest.TestCase):    def test_help(self):        help(str)        help(list)        list_data = [1, 2, 3]        help(list_data)        help(list_data.append)

7-2.import

__import__() 函数用于动态加载类和函数。

如果一个模块经常变化就可以使用__import__()来动态载入。

演示

定义两个模块，供不同情况使用时候动态引用

dark类

import osprint('this is a dark theme {}'.format(id(os)))

文件路径: theme/dark/import_dark_buildin_func.py

light类

import osprint('this is a light theme {}'.format(id(os)))

文件路径: theme/light/import_light_buildin_func.py

测试类

class MyTestCase(unittest.TestCase):    def test_import(self):        theme = 'dark'        # theme = 'light'        if theme == 'dark':            __import__('theme.dark.import_dark_buildin_func')        else:            __import__('theme.light.import_light_buildin_func')        print('done')