python内置函数总结

Python 解释器内置了很多函数和类型，任何时候都能使用。

截止python 3.10.8, 一共是71个内置函数。

大致分类与简单描述:

一.输入输出: 2个
1. print()  # print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
2. input()  # input([prompt]) # 提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型)  可以配合int / strip
二.和数学运算相关的: 7个
3. abs()  # abs(x) 对传入参数取绝对值.  例: abs(3-5)  # 2
4. divmod() #  divmod(a, b) 返回一个包含商和余数的元组(a // b, a % b)。 例: divmod(10,3)  # (3,1)
5. round() #  round(number[, ndigits]) 四舍五入。这个函数与数学上的四舍五入概念是不一样.  round(5.5) # 6   round(4.5)  # 4  import decimal模块与数学一致.
6. pow()  #  pow(base, exp[, mod]) 第1个作用pow(5,2) = 5 ** 2 , 第2个作用pow(5,2,3) = pow(x,y) %z = 1 
7. sum()  #  sum(iterable, start=0) 求和 例: (sum((1, 2, 3), 1,)  # 7  第一项可以是iterable
8. max()  #  max(iterable, *[, key, default]) / max(arg1, arg2, *args[, key]) 求最大值. 返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。两个最大找第1个.  例: max(5, 11, 4, 11)  # 11
9. min()   # min(iterable, *[, key, default]) / min(arg1, arg2, *args[, key]) 求最小值. 返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。两个最小找第1个.  例: min(range(5)  # 0
三.和进制转换相关的: 3个
10. bin()  # bin(x) 接收一个十进制，转换成二进制.   例:  bin(3)  # 0b11  
11. oct()  # oct(x) 接收一个十进制，转换成八进制.   例:  oct(9)  # 0o11
12. hex()  # hex(x) 接收一个十进制，转换成十六进制.  例:  hex(17) # 0x11
四.和字符串相关的: 9个
13. str()  # class str(object='')  class str(object=b'', encoding='utf-8', errors='strict') 转换为字符串类型   str()主要用来为终端用户输出一些信息，而repr()主要用来调试
14. format() # 格式化字符串,{}作为占位符. 内容可以str的属性,可能左右居中. 例: print(f'{x + y}') , print([f'vec_{i}' for i in range(5)])
15. bytes() # class bytes([source[, encoding[, errors]]]) 字符串转换成字节。第一个传入参数是要转换的字符串，第二个参数按什么编码转换为字节 eg. bytes(s,encoding = 'utf-8') , bytes(s,encoding = 'gbk')    1个字节占8位；utf-8编码1个汉字占3个字节；gbk编码1个汉字占2个字节
16. bytearray() # class bytearray([source[, encoding[, errors]]]) 返回一个新的 bytes 数组. 第1个参数如果是字符串,则须指定encoding,例:bytearray('abcde', encoding='utf-8')  # bytearray(b'abcde') 第1个参数如果是数字,会初始化大小为该数字的数组, 例:bytearray(range(5))  # bytearray(b'\x00\x01\x02\x03\x04')
17. memoryview() # 查看内存地址  memoryview(object)/ a = memoryview(bytearray("aAcde", encoding='utf-8')) / print(a[0])  # 97  对应的ASCII码
18. ord()   # ord('A') = 65 # 字母转数字，查看ASCII码表
19. chr()   # chr(97)  = 97 # 数字转字母，查看ASCII码表
20. ascii()  # 自动执行传入参数的_repr_方法（将对象转换为字符串,会将所有的非ascii字符替换为转义字符.  print(ascii('€€€€&^%$#@!'))  # '\u20ac\u20ac\u20ac\u20ac&^%$#@!'
21. repr() # repr(object) 执行传入对象中的_repr_方法   print(repr(n))  # datetime.datetime(2022, 10, 16, 16, 48, 51, 249093) 调试时用这个函数会显示更详细的信息.
五.和字符串执行相关的: 3个
22. eval()  # eval(expression[, globals[, locals]]) 执行python代码，并返回其执行结果。例: eval("1+2+3")   eval("print(123)").   在接收用户输入时应避免使用eval，因为别有用心的用户可能借此注入恶意代码
23. exec()  # exec(object[, globals[, locals]]) 执行python代码（可以是编译过的，也可以是未编译的），没有返回结果（返回None） 例: exec(compile("print(123)","<string>","exec"))   exec("print(123)")
24. compile()  # compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1) 接收.py文件或字符串作为传入参数，将其编译成python字节码  e.g.  r = compile('hello world', '<string>', "exec") / exec(r)   compile写正则时用的多.
六.和数据结构相关的: 9个
25. set() # class set([iterable]) 转换为集合类型 或者 set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
26. list() # list( iterable ) 创建转换为列表类型.
27. dict() # dict(**kwargs) dict(mapping, **kwargs) dict(iterable, **kwargs)创建转换为字典类型.
28. int()  # int(x, base=10)将字符串转为十进制整数, 结果为十进制, 默认参数base=10
29. float() # float(x) 将一个字符串or整数转换为浮点数
30. tuple() # tuple(iterable) 将列表转换为元组, 可迭代对象.
31. bool()  #  class bool([x]) 对传入参数取布尔值， None, 0, "",[],{},() 这些参数传入bool后，返回False
32. complex() # complex([real[, imag]]) 将字符串或数字转换为复数, 第一个变量是字符串时,不能有第2个参数.实数对应直线上的点a,而复数是其延拓, complex(x,y)大多应用于数学和物理计算.
33. frozenset() #frozenset([iterable]) 转换为冻结的集合
七.和迭代器相关的：3个
34. range() # # 获取随机数或随机字符 eg. range(10) 从0到10的随机数, 多用于for循环
35. next() # next(iterator[, default])   调用 iterator 的 __next__() 方法获取下一个元素。
36. iter()  # iter(object[, sentinel])  返回一个迭代器对象  "发音器函数"
八.和处理序列相关的: 11个
37. len() # len(s)  返回对象的长度，实参可以序列，例如列表，元组，字符串，字节串，也可以是集合，例如字典，set，frozen set。
38. sorted() # sorted(iterable, key=None, reverse=False) 对序列化类型数据正向排序，返回一个新的对象。不仅可以对列表进行排序，对其他的可迭代对象也能排序.注意与对象的sort方法区别，后者是就地改变对象
39. reversed() # reversed(seq) #对序列化类型数据反向排序，返回一个新的对象。注意与对象的reverse方法区别，后者是就地改变对象 .可用于反向遍历列表，元组，字符串，
40. slice() # slice(stop)  slice(start, stop[, step])  /必须和range()组合. range(10)[slice(1,5,2) = 1 3  取一个range()里面的切片.
41. enumerate() enumerate(iterable, start=0) /枚举. 一般在for循环语句中使用，用于遍历可迭代对象，enumerate函数返回一个迭代器，迭代器的__next__方法返回一个元组，元组的第一个元素是从0开始的计数值，第二个元素是计数值所对应的可迭代对象里的元素。
42. isinstance() # isinstance(object, classinfo) 判断对象是否是某个类的实例.classinfo可以是元组 e.g. isinstance([1,2,3],list)
43. all() # all(iterable)  所有传入参数为True，才为True,否则为False
44. any() # any(iterable)  传入参数只要有一个为True，就为True,全为False才返回False,空字符串为False
45. zip()  # zip(*iterables) 接收多个序列化类型的数据，对各序列化数据中的元素，按索引位置分类成一个个元组。可以传入多个可迭代对象.
46. filter() #filter(None/函数或者lambda表达式，可迭代的对象)  # 对可迭代对象中的每一个元素，将其作为实参传入函数（或lambda表达式），如果函数返回False，将该元素丢弃，如果函数返回True，将该元素添加到filter的返回值中。注意filter返回的是一个filter对象，实际应用中往往需要用list或tuple将其转换为列表或元组类型. e.g. list(filter(lambda a:a>1,[1,2,3])) 返回[2,3]
47. map() map(函数或lambda表达式，可迭代的对象)  #对可迭代的每一个元素，将其作为实参传入函数，将每一次调用函数返回的结果都添加到map的返回值中。e.g. tuple(map(lambda a:a+1,(1,2,3))) 返回(2,3,4)
九.查看内置属性: 2个
48. dir()  # dir([object]) 接收对象作为参数，返回该对象的所有属性和方法
49. type()  # 返回对象类型
十.内存相关: 2个
50. id()  # id(object) 返回内存地址，可用于查看两个变量是否指向相同一块内存地址
51. hash()  # 对传入参数取哈希值并返回.  列表，字典，集合这类可变对象就没有哈希值
十一.文件读写: 1个
52. open()  # with open(file, mode='rw', encoding='utf-8') as f:
十二.三.和作用域相关的: 2个
53. locals()   # 没有参数, 返回一个字典，包括所有的局部变量与它的值所组成的键值对   / 当前作用域的变量
54. globals()  # 没有参数, 返回一个字典，包括所有的全局变量与它的值所组成的键值对   / 当前作用域的变量
十三.查看帮助: 1个
55. help()  # 接收对象作为参数，更详细地返回该对象的所有属性和方法
十四.面向对象相关的: 8个
56. object() # 对象类，是最基本的类型。返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。
57. super()   # 用于调用父类的一个方法
58. classmethod() #  类方法装饰器, 把类里面的函数转化为一个类的方法
59. staticmethod()   # 返回静态方法
60. issubclass() issubclass(subclass,class) #查看这个类是否是另一个类的派生类，如果是返回True，否则返回False
61. property()   # 在3.10中,将类本身的查改删功能用property装饰,作用是限制对类本身对象的查改删.
62. vars()  # vars([object]) 返回当前模块中的所有变量,可以返回对象的__dict__ 属性，对象可以是模块，类，示例，只要对象有__dict__ 属性，vars就可以返回。
63. callable() # callable(object) 判断一个对象是否可以被调用，若对象可以被调用则返回True,反之则返回False。所谓可调用，是指代码里可以在对象后面跟上一对小括号，函数，方法，类都是可以被调用，实现了__call__方法的对象也可以被调用。
十五.模块相关: 1个
64. __import__() # 由import发起调用此函数,然后调用name模块. 本函数在日常编程中用不到.
十六.和反射相关的内置函数: 4个
65. setattr()  # setattr(object, name, value)  与getattr()对应, 设置属性值,该属性值不一定是存在的.
66. delattr()  # delattr(object, name)   如果对象允许，该函数将删除对象指定的某个属性。
67. hasattr()  # hasattr(object, name)  用于判断对象是否包含对应的属性
68. getattr()  # getattr(object, name[, default])  与setattr()对应. 返回对象已经命名属性的值. name必须是字符串.
十七.debug相关: 1个
69. breakpoint()  # breakpoint(*args, **kws)  使用此函数可以将程序放⼊调试器中。
十八.异步编程: 2个
70. aiter()  # aiter(async_iterable) 是 Python 3.10 版本中的一个新函数。它返回一个异步可迭代对象的异步迭代器。其中 async_iterable 是一个异步可迭代对象，相当于调用 x.__aiter__()。
71. anext()  # awaitable anext(async_iterator[, default]) 在等待时从异步迭代器返回下一项，如果给定并且迭代器已用尽，则返回默认值。这是 next() 内置的异步变体，行为类似。

一. 输入输出: 2个

print()  
input()

1. print()

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

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

sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

print('hello', 'world!', sep='|', end="...\t\b")  # hello|world!...

2. input()

input([prompt])

描述：Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。获取用户输入内容。

var = input("请输入登录用户名:").strip()
print(var)

二. 和数学运算相关的: 7个

abs()  divmod()  round()  pow()  sum()  max()  min()

3. abs( x )

描述：返回数字绝对值或复数的模

参数：x 数值表达式。

x, y = 11, 23.1
a = abs(x - y)
print(a)  # 12.100000000000001

4. divmod(a, b)

描述：divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

参数：

a: 数字--被除数
b: 数字--除数

print(divmod(10, 3))  # (3, 1)
print(divmod(19.1, 3))  # (6.0, 1.1000000000000014)

5. round(number[, ndigits])

描述：四舍五入。这个函数与数学上的四舍五入概念是不一样的。

如果要求和数学的四舍五八一致,还是要引入import decimal模块。

例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。

参数：

x -- 数值表达式。
n --代表小数点后保留几位

print(round(5.5))  # 6
print(round(4.5))  # 4
print(round(4.555, 2))  # 4.55
print(round(4.556, 2))  # 4.56
print(round(4.565, 2))  # 4.57

6. pow(base, exp[, mod])

描述：pow(x，y) 方法返回x的y次方的值，等价于x**y。函数是计算x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x,y) %z

参数：

x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。

print(pow(5, 2))  # 25
print(pow(5, 2, 3))  # 1

7. sum(iterable, /, start=0)

描述: 从 start 开始自左向右对 iterable 的项求和并返回总计值。iterable 的项通常为数字，而 start 值则不允许为字符串。

参数:

iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。

# 可以加两项,第一项可以是iterable,第2项必须是自然数
print(sum((1, 2, 3), 1,))  # 7 
# 第一项可以是参数传入
list1 = [4, 5, 6]
list2 = [1,2]
print(sum(list1, 1))  # 16  
print(sum(list1, 1))  # 4 

# 字典的key如果是数字,也可以sum 
dict1 = {1: 'a', 2: 'b'} 
print(sum(dict1)) # 3

8. max(iterable, *[, key, default])

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

描述:返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

# 返回最大值
a = 11
b = 12
c = 13
print(max(a, b, c))  # 13   
# 如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素
print(max(range(1, 9)))  # 8  
# 如果有多个最大元素，则此函数将返回第一个找到的。
print(max(5, 11, 14, 11))  # 11 
# 如果iterable为空,且没有设置default的话,会报error
print(max([], default='value error'))  #

9. min(iterable, *[, key, default])

 min(arg1, arg2, *args[, key])

描述:返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

a = 11
b = 12
c = 13
print(min(a, b, c))  # 11   返回最小值
# 如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素
print(min(range(1, 9)))  # 1  
# 如果有多个最大元素，则此函数将返回第一个找到的。
print(min(5, 11, 5, 11))  # 5 
# 如果iterable为空,且没有设置default的话,会报error
print(min([], default='value error'))  #

三. 和进制转换相关的: 3个

bin()  oct()  hex()

10. bin(x)

描述: 将整数转变为以“0b”前缀的二进制字符串。结果是一个合法的 Python 表达式。
PS:将十进制转为二进制。

传入的参数必须为整数。

print(bin(3))  # 0b11
print(bin(-10))  # -0b1010

11. oct(x)

描述: 将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。

PS:将十进制转为八进制。

传入的参数必须为整数。

print(oct(3))  # 0o3
print(oct(-10))  # -0o12

12. hex(x)

描述: 将整数转变为以“0x”前缀的十六进制字符串。结果是一个合法的 Python 表达式。
PS:将十进制转为十六进制。
传入的参数必须为整数。

print(hex(3))  # 0x3
print(hex(-10))  # -0xa

四. 和字符串相关的: 9个

str() format() bytes() bytearray() memoryview() ord() chr() ascii() repr()

13. str(object='')

描述: 将字符类型\数值类型等转换为字符串类型. PS: 强制加上引号
str()主要用来为终端用户输出一些信息，而repr()主要用来调试

integ = 100 + 10
print(str(integ)) # 110
print(type(integ)) # <class 'int'>
list1 = [1, 2, 3]
print(type(123)) # <class 'int'>
print(type(list1)) # <class 'list'>
print(str(list1), type(str(list1))) # [1, 2, 3] <class 'str'>

14. format()

描述: 基本语法是{}。
使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之。format 函数可以接受不限个参数，位置可以不按顺序。把指定的值格式化为指定的格式，也可用于字符串的拼接。

# 1. 占位符
a = format(0.5, "%")
print(a) # 50.000000%
import time
print(f'{time.strftime("%Y")}年的工作任务比去年增加了{a}') # 2022的工作任务比昨天增加了50.000000%
# {}的内容:'<' - 左对齐结果（在可用空间内），'>' - 右对齐结果（在可用空间内），
# '^' - 居中对齐结果（在可用空间内），'=' - 将符号置于最左侧，
# '+' - 使用加号来指示结果是正还是负，'-' - 负号仅用于负值，
# ' ' - 在正数前使用空格，',' - 使用逗号作为千位分隔符，
# '_' - 使用下划线作为千位分隔符，'b' - 二进制格式，
# 'c' - 将值转换为相应的 unicode 字符，'d' - 十进制格式，
# 'e' - 科学格式，使用小写字母 e，'E' - 科学格式，使用大写字母 E，
# 'f' - 定点编号格式，'F' - 定点编号格式，大写，'g' - 通用格式，
# 'G' - 通用格式（将大写 E 用作科学计数法），'o' - 八进制格式，
# 'x' - 十六进制格式，小写，'X' - 十六进制格式，大写，
# 'n' - 数字格式，'%' - 百分百格式
# 2. {}内可以进行计算
x = 1.5
y = 2.345
print(f'{x + y}') # 3.845
print(f'{round((x + y), 2)}') # 3.85
# 3. 批量处理
n_list = ['张三', '李四', '王二麻子', ]
for i in n_list:
print(f'{i}:快递到了,下楼来取!')
# 张三:快递到了,下楼来取!
# 李四:快递到了,下楼来取!
# 王二麻子:快递到了,下楼来取!
# 4. 内容填充, 将上面的内容对齐
n_list = ['aa', 'bbb', 'cccc', ]
for i in n_list:
print(f'{i.rjust(10, "*")}:快递到了,下楼来取!')
# ********aa:快递到了,下楼来取!
# *******bbb:快递到了,下楼来取!
# ******cccc:快递到了,下楼来取!
# 5. 对齐
a = '张三'
print(f'{a:^10}:快递到了,下楼来取!')
print(f'{a:>10}:快递到了,下楼来取!')
print(f'{a:<10}:快递到了,下楼来取!')
# 张三 :快递到了,下楼来取!
# 张三:快递到了,下楼来取!
# 张三 :快递到了,下楼来取!
# 6. 循环命名
print([f'vec_{i}' for i in range(5)])
# ['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']
print({f"F_{i}" for i in "abcde"})
# {'F_e', 'F_b', 'F_c', 'F_d', 'F_a'}

15. bytes(): class bytes([source[, encoding[, errors]]])

描述: 将一个字符串转换成字节类型
参数：

如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

print(bytes('100', encoding='utf-8')) # b'100'
print(bytes('abcde', encoding='utf-8')) # b'abcde'
print(bytes('[1,2,3,4,5]', encoding='utf-8')) # b'[1,2,3,4,5]'
print(bytes()) # b''

16. bytearray(): class bytearray([source[, encoding[, errors]]])

描述: 返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。
参数:

如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。
如果是一个 integer，会初始化大小为该数字的数组，并使用 null 字节填充。
如果是一个遵循缓冲区接口的对象，该对象的只读缓冲区将被用来初始化字节数组。
如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用作数组的初始内容。
如果没有实参，则创建大小为 0 的数组。

print(bytearray('abcde', encoding='utf-8')) # bytearray(b'abcde')
print(bytearray(100)) # bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
print(bytearray(range(5))) # bytearray(b'\x00\x01\x02\x03\x04')
print(bytearray()) # bytearray(b'')

17. memoryview(): memoryview(object)

描述:memoryview() 函数返回给定参数的内存查看对象(Momory view)。返回由给定实参创建的“内存视图”对象， Python 代码访问一个对象的内部数据，只要该对象支持缓冲区协议而无需进行拷贝

a = memoryview(bytearray("aAcde", encoding='utf-8'))
print(a[0]) # 97 对应的ASCII
print(a[1]) # 65
print(a[1:2]) # <memory at 0x000001D147C6F280>
print(a[1:2].tobytes()) # b'A'

18. ord(): ord(c)

描述: 查看某个ascii对应的十进制数
参数:
c必须是单个的字符,多于1个会报错.

print(ord('a')) # 97
print(ord('1')) # 49
print(ord("A")) # 65

19. chr(): chr(i)

描述:返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。
实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

print(chr(97)) # a
print(chr(65)) # A
print(chr(8364)) # €

20. ascii(): ascii(object)

描述: ascii()函数返回返回任何对象的可读版本,会将所有的非ascii字符替换为转义字符.
与 repr() 类似，返回一个字符串，表示对象的可打印形式

print(ascii("a ' ")) # "a ' "
print(ascii(range(5))) # range(0, 5)
print(ascii([5 + 3])) # [8]
print(ascii('å')) # '\xe5'
print(ascii('€€€€&^%$#@!')) # '\u20ac\u20ac\u20ac\u20ac&^%$#@!'

21. repr():

描述: 返回一个对象的string形式
str()主要用来为终端用户输出一些信息，而repr()主要用来调试

from datetime import datetime
n = datetime.now()
print(str(n)) # 2022-10-16 16:48:29.721060
print(repr(n)) # datetime.datetime(2022, 10, 16, 16, 48, 51, 249093)

# 从上面的例子可以看出来,后者repr()打印出来了类型和值,更适合调试。

五. 和字符串执行相关的: 3个

eval() exec() compile()

22. eval(): eval(expression[, globals[, locals]])

描述: 计算字符串里面的表达式,返回计算结果

print(eval(f'{firsts_num}{item}{second_num}')) # 3

23. exec(): exec(object[, globals[, locals]])

描述: 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。
参数：

object-- 要执行的表达式。
globals -- 可选。包含全局参数的字典。
locals -- 可选。包含局部参数的字典。

# 执行字符串或者compile方法编译过的字符串,没有返回值.
s = 'print("hello world!")'
r = compile(s, '<string>', 'exec')
exec(r)  # hello world!
# 执行复杂的python代码
x = 10
expr = '''
y = 20
sum = x + y + z
print(sum)
'''
def func():
z = 30
exec(expr)
func()  # 60

24. compile(): compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)

描述: 将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象。

参数:

source -- 字符串或者AST（Abstract Syntax Trees）对象。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
flags和dont_inherit是用来控制编译源码时的标志。
optimize 实参指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级别为 0 （没有优化；debug 为真）、1 （断言被删除， debug 为假）或 2 （文档字符串也被删除）。
compile编码在写正则时用的较多吧

# 将字符串编译成python能识别或者可以执行的代码
s = "print('hello world')"
r = compile(s, '<string>', "exec")
print(r)   # <code object <module> at 0x000001D807822130, file "<string>", line 1>
exec(r)  # hello world
str = 'for i in range(5):print(i)'
c = compile(str,'<string>', 'exec')
exec(c)
# 0
# 1
# 2
# 3
# 4

六. 和数据结构相关的: 9个

set() list() dict() int() float() tuple() bool() complex() frozenset()

25. set(): class set([iterable])

描述: 转换为集合类型或者 set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

a = set('runoob')
b = set("google")
print(a)  # {'u', 'r', 'o', 'b', 'n'}
print(b)  # {'l', 'g', 'o', 'e'}

26. list(): list( iterable )

描述:# 创建转换为列表类型. 列表是放在方括号中能修改, 元组是放在括号中不能修改。

# 1. 序列为字符串
str = 'hello world'
ls = list(str)
print(ls)  # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
# 2. 序列为元组
tup1 = ('abc', 'def', 'hhh')
ls = list(tup1)
print(ls)  # ['abc', 'def', 'hhh']
# 3. 序列为字典
dic1 = {"a":1, 'b':2, 'c':3}
ls = list(dic1)
print(ls)  # ['a', 'b', 'c']
# 4. 三元表达式
ls = [i for i in range(5)]
print(ls)  # [0, 1, 2, 3, 4]

27. dict(): dict(kwargs) dict(mapping, kwargs) dict(iterable, **kwargs)

描述: 创建或转换为字典类型。

# 1. 创建空字典
dic1 = dict()
print(dic1)  # {}
# 2. 传入关键字
dic2 = dict(a=1, b=2, c=3)
print(dic2)  # {'a': 1, 'b': 2, 'c': 3}
# 3. 映射函数构造字典(拉链函数用处多)
dic3 = dict(zip(['a', 'b', 'c'], range(3)))
print(dic3)  # {'a': 0, 'b': 1, 'c': 2}
# 4. 可迭代对象方式创建
dic4 = dict([('a',1), ('b',2), ('c',3)])
print(dic4)  # {'a': 1, 'b': 2, 'c': 3}
dic4_1 = dict([('a',1), ('b',2), ('c',3)], f='haha')
print(dic4_1)  # {'a': 1, 'b': 2, 'c': 3, 'f': 'haha'}
# 5. 三元表达式方式创建
dic5 = {key:value for key, value in enumerate('abcd')}
print(dic5)  # {0: 'a', 1: 'b', 2: 'c', 3: 'd'}

28. int(): int(x) int(x, base =10)

描述: # 将字符串转换为整型, 结果为十进制, 参数默认为十进制
参数：

x -- 字符串或数字。
base -- 进制数，默认十进制。

print(int('12', 16))  # 18
print(int('12', 10))  # 12
a = '12'
print(int(a, 8))  # 10
b = '2.6'
print(int(b, 10))  # valueerror
print(int(10, 16))  # TypeError: int() can't convert non-string with explicit base

29. float(): float(x)

描述: 将一个字符串 or 整数,转换为浮点数

print(float(7))  # 7.0
print(float("123"))  # 123.0
print(float("123.123"))  # 123.123
print(float('123.123.123'))  # ValueError

30. tuple(): tuple(iterable)

描述: 将列表转换为元组. 可迭代对象。

tu1 = tuple([1, 2, 3])
print(type(tu1), tu1)  # <class 'tuple'> (1, 2, 3)
lis1 = [4, 5, 6]
tu2 = tuple(lis1)
print(tu2)  # (4, 5, 6)
tu3 = tuple(range(3))
print(tu3)  # (0, 1, 2)
tu4 = tuple("abc")
print(tu4)  # ('a', 'b', 'c')

31. bool(): bool(x)

描述: 对传入参数取布尔值， None, 0, "",[],{},() 这些参数传入bool后，返回False

print(bool(0))  # False
print(bool(None))  # False
print(bool([]))  # False
print(bool({}))  # False
print(bool(()))  # False
print(bool(1))  # True
print(bool("a"))  # True

32. complex(): complex([real[, imag]])

描述: 将字符串或数字转换为复数, 第一个变量是字符串时,不能有第2个参数.
实数对应直线上的点a,而复数是其延拓, complex(x,y)大多应用于数学和物理计算.

复数是由一个实数和一个虚数组合构成，表示为：x+yj
一个复数时一对有序浮点数 (x,y)，其中 x 是实数部分，y 是虚数部分。
Python 语言中有关复数的概念：
1、虚数不能单独存在，它们总是和一个值为 0.0 的实数部分一起构成一个复数
2、复数由实数部分和虚数部分构成
3、表示虚数的语法：real+imagej
4、实数部分和虚数部分都是浮点数
5、虚数部分必须有后缀j或J

print(complex(1, 2))  # (1+2j)
print(complex('1'))  # (1+0j)
print(complex("1+2j"))  # (1+2j)
print(complex('abc', 2))  # typeerror

33. frozenset(): frozenset([iterable])

描述: 返回一个冻结的集合,冻结后的集合不能再添加或删除元素.

s = frozenset(['a', 'b', 'c'])  # 冻结后,s集合不再具有普通集合的append,remove等属性

七. 和迭代器相关的：3个

range() next() iter()

34. range(): class range(stop) / class range(start, stop[, step])

描述: # 获取随机数或随机字符 eg. range(10) 从0到10的随机数, range函数多用于for循环和列表推导式。
参数:

start int类型，序列起始值
stop int类型，序列结束值
step int类型，步长，可以为负数

print(list(range(5))) # [0, 1, 2, 3, 4]
print(list(range(1, 5))) # [1, 2, 3, 4]
print(list(range(1, 5, 2))) # [1, 3]
print([i for i in range(5)]) # [0, 1, 2, 3, 4]

35. next(): next(iterator[, default])

描述:调用 iterator 的 next() 方法获取下一个元素。当迭代器耗尽又没有为next函数设置default默认值参数，使用next函数将引发StopIteration异常。
参数:

iterator 迭代器
default 可选参数，当迭代器耗尽时的默认返回值

>>> lst = [1, 2, 3]
>>> lst_iter = iter(lst)
>>> next(lst_iter)
1
>>> next(lst_iter)
2
>>> next(lst_iter)
3
>>> next(lst_iter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> next(lst_iter, 0)
0

36. iter(): iter(object[, sentinel])

描述: 返回一个迭代器对象，iter函数有两个参数，object 和 sentinel，如果没有sentinel实参，那么object必须是可迭代对象即必须实现__iter__() 方法。sentinel ，object必须是可调用对象。
参数:

object 可迭代对象或者可调用对象
sentinel 当传入sentinel实参是，object必须是可调用对象，iter会一直调用object直到返回sentinel

# 不传sentinel , iter返回的是一个迭代器，使用next函数可以从迭代器中取出具体的值。
lst = [1, 2, 3, 4]
lst_iter = iter(lst)
print(next(lst_iter)) # 1
print(next(lst_iter)) # 2
print(next(lst_iter)) # 3
print(next(lst_iter)) # 4
# 传sentinel
from functools import partial
with open('source_id', 'rb') as f:
for block in iter(partial(f.read, 64), b''):
print(len(block))
# partial(f.read, 64) 返回一个偏函数，是可调用对象，一次读取64字节的数据。在for循环中，iter会一直调用这个偏函数，直到偏函数返回的内容是b''，这代表文件内容读取到了末尾。

八. 和处理序列相关的: 11个

len() sorted() reversed() slice() enumerate() isinstance() all() any() zip() filter() map()

37. len(): len(s)

描述:返回对象的长度，实参可以序列，例如列表，元组，字符串，字节串，也可以是集合，例如字典，set，frozen set。

>>> len([1, 3, 4])
3
>>> len("sdfsf")
5
>>> len({'name': 'python'})
1
>>> len(set([3, 4, 5, 6]))
4

38. sorted(): sorted(iterable, key=None, reverse=False)

描述: 根据 iterable 中的项返回一个新的有序的列表，它不仅可以对列表进行排序，对其他的可迭代对象也能排序，因此相比于列表的sort方法有更广的适用范围。
参数

iterable 可迭代对象
key 如果为None，则比较元素大小，key可以是一个函数，函数从每个元素中提取用于比较的键
reverse 默认为False，表示从小到大进行排序

# 比较元素大小
lst = [5, 2, 1, 3]
sort_lst = sorted(lst, reverse=True)
print(sort_lst) # [5, 3, 2, 1]
# 如果列表里的元素无法直接比较大小，可以使用key参数从每个元素中提取用于比较大小的key。
lst = [
{'name': '小明', 'score': 97},
{'name': '小红', 'score': 90},
{'name': '小刚', 'score': 95},
]
sort_lst = sorted(lst, key=lambda x: x['score'])
for item in sort_lst:
print(item)
# 列表里存储的是字典，两个字典之间不能直接比较大小，想要对他们进行排序，就必须指定两个字典之间比较大小时使用哪个具体的值

39. reversed(): reversed(seq)

描述: reversed返回一个反向的迭代器，可用于反向遍历列表，元组，字符串，reversed函数要求传入的实参必须实现__reversed__()方法或者或者是支持该序列协议（具有从 0 开始的整数类型参数的 len() 方法和 getitem() 方法）

lst = [1, 2, 3, 4, 5]
reverse_iter = reversed(lst)
for item in reverse_iter:
print(item) # 54,3,2,1

40. slice(): class slice(stop) / class slice(start, stop[, step])

描述:内置函数slice返回一个 slice 对象，代表range(start, stop, step) 指定索引集的切片，slice函数必须配合range来使用。

# 作用: 从一个range()序列里面取几项
for i in range(11, 20)[slice(2)]:
print(i) # 11 12
for i in range(11, 20)[slice(1, 10, 2)]:
print(i) # 12 14 16 18

41. enumerate(): enumerate(iterable, start=0)

描述: 枚举. enumerate一般是for循环语句中使用，用于遍历可迭代对象，enumerate函数返回一个迭代器，迭代器的__next__方法返回一个元组，元组的第一个元素是从0开始的计数值，第二个元素是计数值所对应的可迭代对象里的元素。
参数

iterable 可迭代对象，如列表，元组，字符串
start 默认从0开始，start不会影响对可迭代对象的遍历过程，只是改变计数值的起始值

lst1 = ['math', 'english', 'ph']
lst2 = enumerate(lst1, start=1)
for num, value in lst2:
print(num, value) # 1 math / 2 english / 3 ph

42. isinstance(): isinstance(object, classinfo) 判断对象是否是某个类的实例. e.g. isinstance([1,2,3],list)

描述: 判断对象是否是某个类的实例. e.g. isinstance([1,2,3],list) 如果是则返回True，反之返回False。classinfo可以是类，也可以是由类组成的元组。

# 基础数据类型
print(isinstance(1, int)) # True
print(isinstance("a", str)) # True
# 自定义类
class A:
pass
class B(A):
pass
b = B()
print(isinstance(b, B)) # True
print(isinstance(b, A)) # True
# classinfo是元组
print(isinstance(1, (int, str))) # True

43. all(): all(iterable)

描述: 判断传入的可迭代参数 iterable 中的所有元素是否都为True，如果是则返回True，反之返回False。
iterable 是可迭代对象，通常传入的是列表或者元组

# 都为True 才是True
print(all([True, 4, 7, ])) # True 都为True, 才是True
print(all([])) # True 空列表为True
print(all({})) # True 空字典为True
print(all(())) # True 空元组为True
# 0\空\None\False 为False
print(all([""])) # False
print(all([0, None, False])) # False

44. any(): any(iterable)

描述:判断传入的可迭代参数 iterable中是否至少有一个元素是True，如果是则返回True，如果一个为True的元素都没有，就返回False。如果iterable 为空，则返回Fasel，判断元素是否为True，0，None，空字符串等价于False，除此以外，等价于True。
any函数只接受一个参数，iterable 是可迭代对象，通常传入列表和元组

print(any([3, 5, 7, False])) # True
print(any([])) # False

45. zip() 拉链函数 zip(*iterables)

描述: zip可以在多个迭代器上并行迭代，从每一个迭代器上返回一个元素组成一个元组，如果迭代器的长度不统一，那么就以最短的那个为准。
zip函数传入的可迭代对象可以是多个

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['一', '二', '三', '四', '五']
info = {}
for item1, item2 in zip(lst1, lst2):
info[item1] = item2
print(info)

46. filter()

描述: 内置函数filter的语法是filter(function, iterable)，它使用function对iterable中的数据进行过滤，只保留那些返回True的元素。
filter(function, iterable)相当于一个生成器表达式，当function参数不为None时，等价于(item for item in iterable if function(item))，当function为None时，等价于(item for item in iterable if item)。
参数

function 必须是函数
iterable iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器

# 1. function为None, 则返回全部为True的对象
lst1 = [1, False, "", 5, True]
for i in filter(None, lst1):
print(i) # 1, 5, True
# 2. function为lambda函数
lst2 = [1, 3, 4, 6, 8, 9]
for i in filter(lambda x:x>5, lst2):
print(i) # 6, 8, 9
# 3. function为普通函数
lst3 = [1,2,3,4,5]
def fun1(x):
if x > 3:
return True
return False
for i in filter(fun1, lst3):
print(i) # 4, 5

47. map(): map(function, iterable, ...)

描述:map函数返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器，map函数的第一个参数可以是lambda函数也可以是自定义函数，第二个参数是可变参数，可以传入多个可迭代对象。
参数

function 函数，可以是lambda函数，也可以是自定义函数
iterable 可迭代对象，当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就结束。

# 1. function 参数是lambda函数
lst1 = [1,2,3]
lst2 = list(map(lambda x:x+2, lst1))
print(lst2) # [3, 4, 5]
# 2. function是自定义函数
list3 = [1,2,3]
list4 = [4,5,6]
def func(x, y):
return x + y
list5 = list(map(func, list3, list4))
print(list5) # [5, 7, 9]
# 3. 传入多个可迭代对象
list6 = [1,2,3]
list7 = [4,5,6]
list8 = list(map(lambda x, y:x*y, list6, list7))
print(list8) # [4, 10, 18]

九. 查看内置属性: 2个

dir() type()

48. dir(): dir([object])

描述: 接收对象作为参数，返回该对象的所有属性和方法
在没有实参时返回当前作用域中的名称列表，有实参时，返回该实参对象的属性列表，通常使用dir函数查看一个对象的属性和方法。

# 不传实参
a = 1
print(dir()) # ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a']
# 列表里有很多变量是双下划线开头，这些变量都是模块的内置变量。
# 传入实参
def func():
pass
d = func
print(dir(d)) # ['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

49. type(): class type(object) / class type(name, bases, dict, **kwds)

描述: type可以返回一个对象的类型，通常与 object.class 所返回的对象相同。type是一个看起来不起眼但是功能和作用十分强大的函数，由于python的变量不需要声明类型，因此在编程时可以通过type函数获取变量的类型，这对于理解程序是十分关键的。

print(type([1, 2, 3])) # <class 'list'>
print(type("123")) # <class 'str'>
print(type("str")) # <class 'str'>
print(type(int)) # <class 'type'>
print(type(type)) # <class 'type'>

十. 内存相关: 2个

id() hash()

50. id(): id(object)

描述:id返回对象的唯一标识符，这个值是一个整数，在对象的整个生命周期中这个值是唯一的而且不变，在cpython实现里，id函数返回的是对象的内存地址。

# 以下表明 a is b
a = 1
b = 1
print(id(a)) # 2335823757552
print(id(b)) # 2335823757552
# 以下表明 a == b
a = []
b = []
print(id(a)) # 1306067988992
print(id(b)) # 1306069297792
# 判断内存地址是否相同可以作为判断两个对象是否是同一个对象的依据。
print(a == b) # True
print(a is b) # False

51. hash(): hash(object)

描述: 返回一个对象的hash值，hash值在字典查找元素用来快速比较字典的键，相同大小的数字例如1和1.0 拥有相同的hash值，尽管他们是不同的类型。
并不是所有的对象都有哈希值，比如列表，字典，集合这类可变对象就没有哈希值。

print(hash(1)) # 1
print(hash(1.0)) # 1
print(hash("1")) # 3912875043100631943

十一. 文件读写: 1个

open()

52. open(): with open(file, mode='rw', encoding='utf-8') as f:

描述: 打开文件,读写文件,关闭文件, 注意模式与编码

with open(file, mode='rw', encoding='utf-8') as f:

十二. 和作用域相关的: 2个

locals() globals()

53. locals():

描述: 没有参数, 返回一个字典，包括所有的局部变量与它的值所组成的键值对 / 当前作用域的变量
在全局作用域中调用locals函数，得到的返回值与调用globals相同。

def test():
a = 4
b = 5
print(locals())
test() # {'a': 4, 'b': 5} 只有两个变量
print(locals()) # 全局变量一大堆
# {'__name__': '__main__', '__doc__': '\nby：PyCharm / python_study / 面向对象-1011 / comli \ndate：2022/10/11 / 11:21\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021F34084820>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:\\software\\python\\project\\python_study\\面向对象1011.py', '__cached__': None, 'test': <function test at 0x0000021F33C13EB0>}

54. globals():

描述: # 没有参数, 返回一个字典，包括所有的全局变量与它的值所组成的键值对 / 当前作用域的变量
在哪里调用全局变量globals(), 都显示一大堆全局的变量.

def test():
a = 4
b = 5
print(globals())
test() # # 全局变量一大堆
print(globals()) # 全局变量一大堆

十三. 查看帮助: 1个

help()

55. help():

描述:# 接收对象作为参数，更详细地返回该对象的所有属性和方法

import sys
help('sys')
# 显示一大串帮助信息
help("str")
# 显示一大串帮助信息

十四. 面向对象相关的: 8个

object() super() classmethod() staticmethod() issubclass() property() vars() callable()

56. object(): object()

描述:对象类，是最基本的类型。返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

print(dir(object))
# 显示一大堆
help(object)
# class object
# | The base class of the class hierarchy.

57. super(): 用于调用父类的一个方法

描述: 用于调用父类的一个方法

class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg)

58. classmethod(): 类装饰器, 把类里面的函数转化为一个类的方法

描述:描述：把方法转化为类方法,一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

class C:
@classmethod
def f(cls, arg1, arg2, ...):
...

@classmethod 这样的形式称为函数的装饰器
类方法的调用可以在类上进行 (例如 C.f()), 也可以在实例上进行 (例如 C().f())。其所属类以外的类实例会被忽略。如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

59. staticmethod():

描述: 返回函数的静态方法
静态方法是指这个类里面的方法与类本身没有关系,是静态的.这时,就可以用类静态装饰器进行装饰.转化为类方法
1.静态方法无需实例化即可调用
2.也可以实例化后调用

class C:
@staticmethod
def f():
print("人类很渺小!")
# 静态方法的()里面没有self
# 1. 静态方法无需实例化即可调用
C.f() # 人类很渺小!
# 2. 也可以实例化后调用
aaa = C()
aaa.f() # 人类很渺小!

60. issubclass(): issubclass(classA, classB)

描述: 判断一个参数是否是另一个参数的子类，如果 classA 是 classB 的 (直接、间接或虚拟) 子类则返回 True。类会被视作其自身的子类。
语法：issubclass(classA, classB)

class A:
@staticmethod
def f():
print("人类很渺小!")
class B:
pass
class C(B):
pass
print(issubclass(B, A)) # False B不是A的子类
print(issubclass(C, B)) # True C是B的子类

61. property(): 类的属性装饰器, 用以限制对实例的查改删

描述: 在3.10中,将类本身的查改删功能用property装饰,作用是限制对类本身对象的查改删.

class A:
def __init__(self, name):
self.name = name
@property
def name(self):
return self.name
@name.setter
def name(self, name):
if self.name not in str:
return "name值必须为str"
self.name = name
@name.deleter
def name(self):
return "实例后的name不能被删除"

经过这样的property装饰后, 实例化的name的查改删就被限制了.

62. vars(): vars([object])

描述: 可以返回对象的__dict__ 属性，对象可以是模块，类，示例，只要对象有__dict__ 属性，vars就可以返回。

class A:
def __init__(self, name):
self.name = name
a = A('张三')
print(vars(a)) # {'name': '张三'}

63. callable(): callable(object)

描述: 判断一个对象是否可以被调用，若对象可以被调用则返回True,反之则返回False。所谓可调用，是指代码里可以在对象后面跟上一对小括号，函数，方法，类都是可以被调用，实现了__call__方法的对象也可以被调用。

class A:
def __init__(self, name):
self.name = name
a = A('张三')
print(vars(a))
print(callable(a)) # 结果为False 实例不能被调用
print(callable(A)) # True 函数/类/方法都可以被调用,即后面加括号

十五. 模块相关: 1个

__import__()

64. import() : import(name, globals=None, locals=None, fromlist=(), level=0)

描述: 此函数会由 import 语句发起调用。会导入模块 name，利用 globals 和 locals 来决定如何在包的上下文中解释该名称。
这是一个日常 Python 编程中不需要用到的高级函数。

#语句 import spam的结果将为与以下代码作用相同的字节码:
spam = __import__('spam.ham', globals(), locals(), [], 0)

十六. 和反射相关的内置函数: 4个

setattr() delattr() hasattr() getattr()

65. setattr(): setattr(object, name, value)

描述:本函数与 getattr() 相对应。其参数为一个对象、一个字符串和一个任意值。字符串可以为某现有属性的名称，或为新属性。只要对象允许，函数会将值赋给属性。如 setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

class A:
bar = 1
a = A()
print(getattr(a, "bar"))
setattr(a, "bar", 5)
print(getattr(a, 'bar'))

66. delattr(): delattr(object, name)

描述: 实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

class A:
bar = 1
a = A()
print(getattr(a, "bar")) # 1
setattr(a, "bar", 5)
print(getattr(a, 'bar')) # 5
delattr(a, 'name') #---------->删除a的name属性
print(getattr(a, "name")) # 报错, AttributeError: name

67. hasattr(): hasattr(object, name)

描述: 用于判断对象是否包含对应的属性

class A:
bar = 1
class B(A):
cup = 2
a = A()
b = B()
print(hasattr(a, "bar")) # True
print(hasattr(a, 'cup')) # False 父类的对象没有子类的属性
print(hasattr(b, "cup")) # True
print(hasattr(b, 'bar')) # True

68. getattr(): getattr(object, name[, default])

描述: 返回对象已经命名属性的值. name必须是字符串.如果name不存在,且提供了default,则返回它,否则触发错误.

class A:
bar = 1
a = A()
print(getattr(a, "bar"))
setattr(a, "bar", 5)
print(getattr(a, 'bar'))

十七. debug相关: 1个

breakpoint()

69. breakpoint(): breakpoint(*args, **kws)

描述:使用此函数可以将程序放⼊调试器中。具体来说，它调⽤sys.breakpointhook()，直接传递args和kws。默认情况下，sys.breakpointhook()调⽤pdb.set_trace()，不需要参数。在这种情况下，它纯粹是⼀个⽅便的函数，因此您不必显式地导⼊pdb或键⼊⾜够多的代码来进⼊调试器。但是，sys.breakpointhook()可以设置为其他函数，breakpoint()将⾃动调⽤该函数，允许您进⼊所选的调试器。

# 使用breakpoint()和pdb调试python代码
https://www.imangodoc.com/425a0f88.html

十八. 异步编程: 2个

aiter() anext()

70. aiter(): aiter(async_iterable)

描述: aiter(async_iterable) 是 Python 3.10 版本中的一个新函数。它返回一个异步可迭代对象的异步迭代器。其中 async_iterable 是一个异步可迭代对象，相当于调用 x.aiter()。
注意：与 iter() 不同，aiter() 没有两个参数的版本。
与常规同步迭代器 iter() 和 next() 内置函数一样，您很少需要直接使用新的内置函数。 async for 循环已经隐式调用了类的 aiter 和 anext 方法。

import asyncio
async def numbers(nums):
for i in range(nums):
yield i
await asyncio.sleep(0.5)
# 隐式使用
[i async for i in numbers(10) if i % 2 == 0]
# 显式使用
[i async for i in aiter(numbers(10)) if i % 2 == 0]
# [0, 2, 4, 6, 8]
a = aiter(numbers(10))
dir(a)
'''
['__aiter__',
'__anext__',
'__class__',
...

在上面的代码中，numbers() 函数是一个异步生成器，它为异步列表理解生成值。

71. anext(): awaitable anext(async_iterator[, default])

描述: anext() 是 Python 3.10 版本中的一个新函数。它在等待时从异步迭代器返回下一项，如果给定并且迭代器已用尽，则返回默认值。这是 next() 内置的异步变体，行为类似。
其中 async_iterator 是一个异步迭代器。它接受一个可选参数，当迭代器耗尽时返回。
当进入 await 状态时，从给定异步迭代器（asynchronous iterator）返回下一数据项，迭代完毕则返回 default。
这是内置函数 next() 的异步版本，类似于调用 async_iterator 的 anext() 方法，返回一个 awaitable，等待返回迭代器的下一个值。若有给出 default，则在迭代完毕后会返回给出的值，否则会触发 StopAsyncIteration。

import asyncio
class CustomAsyncIter:
def __init__(self):
self.iterator = iter(['A', 'B'])
def __aiter__(self):
return self
async def __anext__(self):
try:
x = next(self.iterator)
except StopIteration:
raise StopAsyncIteration from None
await asyncio.sleep(1)
return x
async def main1():
iter1 = CustomAsyncIter()
print(await anext(iter1)) # Prints 'A'
print(await anext(iter1)) # Prints 'B'
print(await anext(iter1)) # Raises StopAsyncIteration
async def main2():
iter1 = CustomAsyncIter()
print('Before') # Prints 'Before'
print(await anext(iter1, 'Z')) # Silently terminates the script!!!
print('After') # This never gets executed
asyncio.run(main1())
'''
A
B
raise StopAsyncIteration
'''
asyncio.run(main2())
'''
Before
A
After
'''

posted @ 2023-01-04 19:54 紫柏之梦阅读(225) 评论(0) 收藏举报

刷新页面返回顶部

紫柏织梦