今日主要内容

推导式生成器表达式lambda匿名函数内置函数介绍

一、推导式

（一）列表推导式

先来看一段代码

建立一个空列表，向空列表中添加元素 lst = list() for i in range(5): lst.append(i) print(lst) 运行结果： [0, 1, 2, 3, 4] 利用列表推导式，效果一样 lst = [i for i in range(5)] print(lst) 运行结果： [0, 1, 2, 3, 4]

循环模式：

格式：[元素 for 元素 in 可迭代对象]执行流程：每次for循环将元素添加到列表中 lst = [i for i in range(5)] print(lst) 运行结果： [0, 1, 2, 3, 4]

筛选模式

筛选模式：

格式：[元素 for 变量 in 可迭代对象 if 条件]执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到列表中 lst = [i for i in range(5) if i > 2] print(lst) 运行结果： [3, 4]

（二）字典推导式

同理，先来看一段代码

建立一个空字典，向字典中添加键值对 dic = dict() for i in range(1, 5): dic[f"k{i}"] = i print(dic) 运行结果： {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4} 使用字典推导式，效果一样 dic = {f"k{i}": i for i in range(1, 5)} print(dic) 运行结果： {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

循环模式：

格式：{键值对 for 元素 in 可迭代对象}执行流程：执行for循环利用元素组成键值对添加到字典中 dic = {f"k{i}": i for i in range(1, 5)} print(dic) 运行结果： {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}

筛选模式：

格式：{键值对 for 元素 in 可迭代对象 if 条件}执行流程：执行for循环并判断元素是否符合条件，利用符合条件的元素组成键值对添加到字典中 dic = {f"k{i}": i for i in range(1, 5) if i > 2} print(dic) 运行结果： {'k3': 3, 'k4': 4}

（三）集合推导式

与列表一样，这里就不再举例了

循环模式：

格式：{元素 for 元素 in 可迭代对象}执行流程：每次for循环将元素添加到集合中 st = {i for i in range(5)} print(st) 运行结果： {0, 1, 2, 3, 4}

筛选模式：

格式：{元素 for 变量 in 可迭代对象 if 条件}`执行流程：执行for循环并判断元素是否符合条件，将符合条件的元素添加到集合中 lst = {i for i in range(5) if i > 2} print(st) 运行结果： {3, 4}

（四）推导式应用

来看几个推导式的应用例题

求字符串s = "zxdhnbhnb"中"h"的索引

s = "zxdhnbhnb" lst = [i for i in range(len(s)) if s[i] == "h"] print(lst) 运行结果： [3, 6]

将下列列表中带两个"e"的元素添加到新列表

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'], ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']] lst = [name for i in names for name in i if name.count("e") == 2] print(lst) 运行结果： ['Jefferson', 'Wesley', 'Steven', 'Jennifer']

二、生成器表达式

（一）回顾：通过函数实现生成器

回顾一下通过函数实现生成器

将函数return变成yield就变成了生成器 def func(): yield 1 yield 2 yield 3 g = func() print(next(g)) print(next(g)) print(next(g)) 运行结果： 1 2 3

（二）生成器表达式

通过表达式实现生成器

将列表推导式的方括号[]变成圆括号()，就成了生成器表达式 lst = [i for i in range(5)] print(type(lst)) g = (i for i in range(5)) print(type(g)) 运行结果： <class 'list'> <class 'generator'> 转换成通过函数实现的生成器（二者等价） # g = (i for i in range(5)) def func(): # 二者等价 for i in range(5): yield i g= func() print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) 运行结果： 0 1 2 3 4

生成器表达式结构：

普通模式：

格式：(元素 for 元素 in 可迭代对象)运行机制：惰性机制，不取值不运行，每次取值得到一个结果 g = (i for i in range(5)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) 运行结果： 0 1 2 3 4

筛选模式：

格式：(元素 for 元素 in 可迭代对象 if 条件)运行机制：惰性机制，不取值不运行，每次取值得到一个满足判断条件的结果 g = (i for i in range(5) if i > 2) print(next(g)) print(next(g)) 运行结果： 3 4

生成器的取值方式补充：

之前提到过的最正宗的next(生成器) g = (i for i in range(5)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) 运行结果： 0 1 2 3 4 通过for循环取值 g = (i for i in range(5)) for el in g: print(el) 运行结果： 0 1 2 3 4 通过list()、tuple()、set()取值 g = (i for i in range(5)) print(list(g)) print(tuple(g)) print(set(g)) 运行结果： [0, 1, 2, 3, 4] (0, 1, 2, 3, 4) {0, 1, 2, 3, 4}

真正理解生成器的惰性机制，来看一道例题：

def add(a, b): return a + b def test(): for r_i in range(4): yield r_i g = test() for n in [2, 10]: g = (add(n, i) for i in g) print(list(g)) 运行结果： [20,21,22,23] 解析：生成器只有在取值的时候才会去运行，上述例题只有最后'print(list(g))'取值。 """ g = test() for n in [2, 10]: g = (add(n, i) for i in g) """ 所以上面的for循环可以写成如下代码： """ n = 10 g = (add(n, i) for i in (add(n, i) for i in test())) """ 最终代入得到的列表为：[20, 21, 22, 23]

三、lambda匿名函数

（一）匿名函数定义

python中为了解决一些简单的需求可以使用一句话定义一个函数，这就是lambda匿名函数

lambda语法结构：

函数名 = lambda 形参:返回值 # def func(x, y): # return x + y # print(func(1, 2)) func = lambda x, y: x+y # 两个函数等价 print(func(1, 2)) 运行结果： 3

注意事项：

形参：可以接受多个所有类型参数（位置、动态位置、默认值、动态关键字） func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs print(func(3, 4,c=666,name='zxd')) # 只返回kwargs 运行结果： {'name': 'zxd'} 返回值：只能返回一个数据（任意数据类型），必须写 func = lambda x:(x[0],x[2]) print(func('zxdnb')) 运行结果： ('z', 'd') 返回值也可以是三元表达式 func = lambda x,y: x if x > y else y print(func(3,100)) 运行结果： 100

（二）结合匿名函数的列表推导式

例一：

列表推导式： g = [lambda :i+1 for i in range(3)] print([em() for em in g]) 运行结果： [3, 3, 3] 转换为普通代码 g = list() for i in range(3): def func(): return i + 1 g.append(func) new_g = list() for em in g: new_g.append(em()) print(new_g) 运行结果： [3, 3, 3]

例二：

列表推导式： g = [lambda i:i+1 for i in range(3)] print([em(3) for em in g]) 运行结果： [4, 4, 4] 转换为普通代码 g = list() for i in range(3): def func(i): return i + 1 g.append(func) new_g = list() for em in g: new_g.append(em(3)) print(new_g) 运行结果： [4, 4, 4]

（三）结合匿名函数的生成器表达式

例一：

生成器表达式： g = (lambda i:i+1 for i in range(3)) print([em(3) for em in g]) 运行结果： [4, 4, 4] 转换为函数实现的生成器： def g(): for i in range(3): def func(i): return i + 1 yield func new_g = list() for em in g(): new_g.append(em(3)) print(new_g) 运行结果： [4, 4, 4]

例二：

生成器表达式： g = (lambda :i+1 for i in range(3)) print([em() for em in g]) 运行结果： [1, 2, 3] 转换为函数实现的生成器： def g(): for i in range(3): def func(): return i + 1 yield func new_g = list() for em in g(): new_g.append(em()) print(new_g) 运行结果： [1, 2, 3]

例三：

生成器表达式 g = (lambda x:x*i for i in range(3)) for j in [2,10]: g1 = (em(3) for em in g) print([e+j for e in g1]) 运行结果： [10, 13, 16] 转换为普通代码 def g(): for i in range(3): def func(x): return x * i yield func for j in [2, 10]: def g1(): for em in g(): yield em(3) new_g = list() for e in g1(): new_g.append(e + j) print(new_g) 运行结果： [10, 13, 16]

四、内置函数

查看解释器内置常量和内置函数的方法

dir(__builtins__)

Python3.6.8的内置函数（共72个）

absallanyasciibinboolbytearraybytescallablechrclassmethodcompilecomplexcopyrightcreditsdelattrdictdirdivmodenumerateevalexecexitfilterfloatformatfrozensetgetattrglobalshasattrhashhelphexidinputintisinstanceissubclassiterlenlicenselistlocalsmapmaxmemoryviewminnextobjectoctopenordpowprintpropertyquitrangereprreversedroundsetsetattrslicesortedstaticmethodstrsumsupertupletypevarszip

（一）基础函数（了解）

all()any()bytes()callable()chr()ord()complex()divmid()eval()exec()frozenset()help()globals()locals()hash()id()iter()next()bin()oct()int()hex()pow()repr()round()bool()

all()

函数定义：all(*args, **kwargs)函数说明：填入参数为可迭代对象，如果可迭代对象中每一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True print(all([1, 2, 3, 4, 5])) print(all([0, 1, 2, 3, 4])) print(all([])) 运行结果： True False True

any()

函数定义：any(*args, **kwargs)函数说明：填入参数为可迭代对象，如果可迭代对象中只要有一项元素的布尔值为真，则返回True，若可迭代对象为空，返回True print(any([0, "", 1, False])) print(any([0, "", [], False])) print(any([])) 运行结果： True False False

bytes()

函数定义：bytes(value=b'', encoding=None, errors='strict')函数说明：将填入对象转换为字节形式，需要指定编码方式 print("张旭东".encode("utf-8")) print(bytes("张旭东", encoding="utf-8")) 运行结果： b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c' b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c'

callable()

函数定义：callable(i_e_, some_kind_of_function)函数说明：判断对象是否可以调用（类也是可调用的，类的实例可调用__call__()方法） def func(): print("hello world") print(callable(func)) 运行结果： True

chr()

函数定义：chr(*args, **kwargs)函数说明：返回Unicode对应的字符串 print(chr(65)) 运行结果： A

ord()

函数定义：ord(*args, **kwargs)函数说明：返回一个字符串对应的Unicode编码值 print(ord("A")) 运行结果： 65

complex()

函数定义：complex(real, imag=None)函数说明：返回一个数的复数形式 print(complex(20)) 运行结果： (20+0j)

divmid()

函数定义：divmod(x, y)函数说明：返回元组(x // y, x % y) print(divmod(10, 3)) 运行结果： (3, 1)

eval()（不推荐使用）

函数定义：eval(*args, **kwargs)函数说明：可以计算给定的参数，参数只能是简单表达式 print(eval("5 + 3")) 运行结果： 8

exec()（不推荐使用）

函数定义：exec(*args, **kwargs)函数说明：可以计算给定的参数，参数可以是代码块 exec("for i in range(10):print(i)") 运行结果： 0 1 2 3 4

frozenset()

函数定义：frozenset(obj)函数说明：将对象转换为不可变集合 print(frozenset((1,2,3))) 运行结果： frozenset({1, 2, 3})

help()

函数定义：help(args)函数说明：查看帮助 help(list.append) 运行结果： Help on method_descriptor: append(...) L.append(object) -> None -- append object to end

globals()

函数定义：globals(*args, **kwargs)函数说明：返回包含当前作用域的全局变量的字典 a = 5 b = 10 def func(): print("hello world") print(globals()) 运行结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000221ED9D69E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python_S26/day12/exercise.py', '__cached__': None, 'a': 5, 'b': 10, 'func': <function func at 0x00000221ED8D1EA0>}

locals()

函数定义：locals(*args, **kwargs)函数说明：返回一个包含当前作用域的局部变量的字典 a = 5 def func(): b = 10 print(locals()) func() 运行结果： {'b': 10}

hash()

函数定义：hash(*args, **kwargs)函数说明：返回对象的哈希值 print(hash("zxd")) 运行结果： 5236597812272808709

id()

函数定义：id(*args, **kwargs)函数说明：返回对象的id，在CPython中返回的是对象的内存地址 print(id(10)) 运行结果： 1864728976

iter()

函数定义：iter(iterable, sentinel=None)函数说明：传入可迭代对象，获取迭代器 lst = [1, 2, 3, 4, 5] t = iter(lst) print(t) 运行结果： <list_iterator object at 0x00000181FB2CA9B0>

next()

函数定义：next(iterator, default=None)函数说明：返回迭代器的下一项，若提供了默认值，并且迭代器已耗尽，则返回它而不是引发StopIteration t = iter([1, 2, 3, 4, 5]) print(next(t, None)) print(next(t, None)) print(next(t, None)) print(next(t, None)) print(next(t, None)) print(next(t, None)) 运行结果： 1 2 3 4 5 None

bin()

函数定义：bin(*args, **kwargs)函数说明：返回整数的二进制形式 print(bin(10)) 运行结果： 0b1010

oct()

函数定义：oct(*args, **kwargs)函数说明：返回整数的八进制形式 print(oct(10)) 运行结果： 0o12

int()

函数定义：int(x, base=10)函数说明：返回对应进制的十进制，需填入对应进制数字符串形式，并填入进制数 print(int("0b1010", 2)) print(int("0o12", 8)) 运行结果： 10 10

hex()

函数定义：hex(*args, **kwargs)函数说明：返回整数的十六进制形式 print(hex(20)) 运行结果： 0x14

pow()

函数定义：pow(*args, **kwargs)函数说明：填入两个参数时，求x的y次幂；填入三个参数时，求x的y次幂在与z取余 print(pow(2, 4)) print(pow(2, 4, 3)) 运行结果： 16 1

repr()

函数定义：repr(obj)函数说明：返回规范字符串的表现形式 s = "zxd" print(repr(s)) 运行结果： 'zxd'

round()

函数定义：round(number, ndigits=None)函数说明：将数字四舍五入为十进制整数 print(round(3.5)) 运行结果： 4

（二）常用函数（会用）

abs()format()enumerate()open()range()print()input()len()list()dict()str()set()tuple()float()reversedsum()dir()type()zip()bool()

abs()

函数定义：abs(*args, **kwargs)函数说明：返回参数的绝对值 print(abs(-1)) 运行结果： 1

format()

函数定义：format(*args, **kwargs)函数说明：返回格式化后的字符串 s = "你好" print(format(s, ">20")) # 右对齐20位，多余的部分用空格补齐 print(format(s, "<20")) # 左对齐20位，多余的部分用空格补齐 print(format(s, "^20")) # 居中共20位，多余的部分用空格补齐 运行结果： 你好 你好 你好 s = 18 print(format(s, "08b")) # 共八位，转换为二进制 print(format(s, "08o")) # 共八位，转换为八进制 print(format(s, "08x")) # 共八位，转换为十六进制 print(format(s, "08d")) # 共八位，转换为十进制 运行结果： 00010010 00000022 00000012 00000018

enumerate()

函数定义：enumerate(iterable, start=0)函数说明：枚举，遍历可迭代对象并给定对应遍历的数字，以元组的形式返回，第二个参数可指定遍历数字的起始值 lst = [1, 2, 3, 4, 5] for i in enumerate(lst): print(i) 运行结果： (0, 1) (1, 2) (2, 3) (3, 4) (4, 5) lst = [1, 2, 3, 4, 5] for i in enumerate(lst, 10): # 指定起始值 print(i) 运行结果： (10, 1) (11, 2) (12, 3) (13, 4) (14, 5)

open()

函数定义：open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)函数说明：打开一个文件，指定文件路径file 、文件打开模式mode、文件编码encoding，返回一个文件句柄用于操作文件，其余参数暂时忽略 f = open("text.txt", mode="r", encoding="utf-8") f.read() f.close()

range()

函数定义：range(start, stop[, step])函数说明：返回一个对象，该对象可以从开始一个一个返回一个递增的整数序列一直到结束，如果有步长参数，则按照步长返回 for i in range(5): print(i) 运行结果： 0 1 2 3 4

print()

函数定义：print(self, *args, sep=' ', end='\n', file=None)函数说明：在控制台打印参数，可填入参数sep来替代元素之间的逗号，可填入参数end来控制结尾的换行，可填入参数file将打印的内容写入文件 print("zxd", "znb", sep="-", end="!") 运行结果： zxd-znb!

input()

函数定义：input(*args, **kwargs)函数说明：将输入内容转换为字符串，可填出参数用来提示用户 name = input("请输入姓名:") print(name) 运行结果： zxd

len()

函数定义：len(*args, **kwargs)函数说明：返回容器中的项数 lst = [1, 2, 3, 4, 5] print(len(lst)) 运行结果： 5

list()

函数定义： list()list(iterable) 函数说明： 默认创建空列表将可迭代对象转换为列表 print(list()) print(list(range(5))) 运行结果： [] [0, 1, 2, 3, 4]

dict()

函数定义： dict()dict(mapping)dict(iterable)dict(**kwargs) 函数说明： 默认创建空字典可填入映射创建字典可填入二元组列表创建字典可填入关键字参数常见列表 print(dict()) print(dict({"k1": 1, "k2": 2})) print(dict([("k1", 1), ("k2", 2)])) print(dict(k1=1, k2=2)) 运行结果： {} {'k1': 1, 'k2': 2} {'k1': 1, 'k2': 2} {'k1': 1, 'k2': 2}

str()

函数定义：

str()

str(value='', encoding=None, errors='strict')

函数说明：

默认创建空字符串

可将参数转换为字符串类型，若填入参数为字节类型，需指定编码方式

print(repr(str(123))) print(str(b'\xe5\xbc\xa0\xe6\x97\xad\xe4\xb8\x9c',encoding="utf-8")) 运行结果： 张旭东 '123'

set()

函数定义： set()set(iterable) 函数说明： 默认创建空集合将可迭代对象转换为集合（自动去重） print(set()) print(set([1,2,3,4,5])) 运行结果： set() {1, 2, 3, 4, 5}

tuple()

函数定义： tuple()tuple(iterable) 函数说明： 默认创建空元组将可迭代对象转换为元组 print(tuple()) print(tuple([1, 2, 3, 4, 5])) 运行结果： () (1, 2, 3, 4, 5)

float()

函数定义：float(x)函数说明：将参数转换为浮点型 print(float(123)) 运行结果： 123.0

reversed

函数定义：reversed(sequence)函数说明：将传入的可迭代对象反向迭代，返回一个迭代器 lst = [1, 2, 3, 4, 5] print(reversed(lst)) print(list(reversed(lst))) 运行结果： <list_reverseiterator object at 0x000002043A55A9B0> [5, 4, 3, 2, 1]

sum()

函数定义：sum(*args, **kwargs)函数说明：将填入的参数求和，填入的参数必须是可迭代对象 print(sum([1, 2, 3, 4, 5])) 运行结果： 15

dir()

函数定义：dir([object])函数说明：查看对象的方法 print(dir(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']

type()

函数定义：type(object_or_name, bases, dict)函数说明：查看对象的类型（其实type()既是函数，又是元类(创造类的类)，可以通过type()创建一个类） print(type(list())) 运行结果： <class 'list'>

zip()

函数定义：zip(iter1 [,iter2 [...]])函数说明：拉链函数，返回一个迭代器，将所有可迭代对象的元素按照位置打包成元组，直到耗尽项数最少的可迭代对象 lst1 = [1, 2, 3] lst2 = [1, 2, 3, 4, 5] print(zip(lst1, lst2)) print(list(zip(lst1, lst2))) 运行结果： <zip object at 0x00000204D6E621C8> [(1, 1), (2, 2), (3, 3)]

bool()

函数定义：bool(x)函数说明：将传入的参数转换成布尔值，若不填入参数返回False print(bool()) print(bool(123)) 运行结果： False True

（三）高阶函数（熟练）

高阶函数全部需要结合规则函数，利用lambda匿名函数构造规则函数

filter()筛选过滤map()映射sorted()排序max()求最大值min()求最小值reduce()累计算

filter()

筛选过滤功能函数定义：filter(function or None, iterable)函数说明：返回一个迭代器，该迭代器返回满足规格函数的可迭代对象中的元素，若函数为None，返回可迭代对象中为True的元素 # 规则函数为None，返回可迭代对象中True的元素 print(list(filter(None, [0, 1, 2, 3]))) 运行结果： [1, 2, 3] # 返回满足规则函数可迭代对象中的元素 print(list(filter(lambda x: x > 1, [0, 1, 2, 3]))) 运行结果： [2, 3]

map()

映射功能函数定义：map(func, *iterables)函数说明：创建一个迭代器，它使用可迭代对象中的每个元素当作参数执行规则函数，直到最短的可迭代对象耗尽为止 print(list(map(lambda x: x ** 2, [1, 2, 3]))) 运行结果： [1, 4, 9]

sorted()

排序功能函数定义：sorted(*args, **kwargs)函数说明：返回一个列表，按照可迭代对象中的元素升序排列，还可以指定key=规则函数按照规则函数来排序，还可以指定reverse=True来降序排列与列表中list.sort()的区别： list.sort()改变的是原有列表sorted()建立的新列表 lst = [4, 2, 3, 7, 1] print(sorted(lst)) print(lst) # 不改变原来列表 运行结果： [1, 2, 3, 4, 7] [4, 2, 3, 7, 1] dic = {"k1": 3, "k2": 13, "k3": 1} print(sorted(dic, key=lambda x: dic[x], reverse=True)) 运行结果： ['k2', 'k1', 'k3']

max()

返回最大值

函数定义：

max(iterable, *[, default=obj, key=func])

max(arg1, arg2, *args, *[, key=func])

函数说明：

使用单个可迭代对象，返回其中的最大值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数 lst1 = [1, 2, 3, 4, 5, -6] lst2 = [] print(max(lst1)) print(max(lst1, key=abs)) # 制定规则参数，返回绝对值最大的元素 print(max(lst2, default=1)) # 当lst2为空的时候返回1 运行结果： 5 -6 1 使用两个或更多的参数，返回其中最大的参数 a = 5 b = 10 print(max(a, b)) 运行结果： 10

min()

返回最小值

函数定义：

min(iterable, *[, default=obj, key=func])min(arg1, arg2, *args, *[, key=func])

函数说明：

使用单个可迭代对象，返回其中的最小值，可填入俩个关键字参数，当可迭代对象为空的时候返回default的值，可指定规则函数 lst1 = [1, -2, 3, -4, 5, -6] lst2 = [] print(min(lst1)) print(min(lst1, key=abs)) print(min(lst2, default=1)) 运行结果： -6 1 1 使用两个或更多的参数，返回其中最小的参数 a = 5 b = 10 print(min(a, b)) 运行结果： 5

reduce()

累计算函数定义：reduce(function, sequence, initial=None)函数说明：按照规则函数将序列从左到右累计算，若有initial参数则作为序列的第一项，并在序列为空时作为默认值 from functools import reduce print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])) print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5], 5)) print(reduce(lambda x, y: x * y, [], 5)) 运行结果： 120 600 5

（四）面向对象函数

classmethod()delattr()getattr()hasattr()issubclass()isinstance()object()property()setattr()staticmethod()super()

后续补充…