『Python』常用内置函数

1. abs()

返回实数的绝对值或者虚数的模

>>> abs(3)
3
>>> abs(-4)
4
>>> abs(3 + 4j)
5.0
>>> abs(5-12j)
13.0

2. all()

接受一个迭代器，如果迭代器(元组或列表)的所有元素都为真，那么返回True，否则返回False，元素除了是 0、空、None、False外都算 True

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

>>> all([1,0,3,6])
False
>>> all([1,9,3,6])
True
>>> all(['a','b','','d'])
False
>>> all([])
True
>>> all(())
True

3. any()

接受一个迭代器，如果迭代器里有一个元素为真，那么返回True，否则返回False，元素除了是 0、空、None、False外都算 True

>>> any([0,0,0,[]])
False
>>> any([0,0,1])
True
>>> any((0,'',False))
False
>>> any([])
False
>>> any(())
False

4. ascii()

ascii()函数返回任何对象（字符串，元组，列表等）的可读版本

ascii() 函数会将所有非 ascii 字符替换为转义字符：å 将替换为 \xe5

>>> ascii('中华人民共和国')
"'\\u4e2d\\u534e\\u4eba\\u6c11\\u5171\\u548c\\u56fd'"
>>> ascii('新冠病毒')
"'\\u65b0\\u51a0\\u75c5\\u6bd2'"
>>> ascii('å')
"'\\xe5'"
>>> ascii((1,2))
'(1, 2)'
>>> type(_)
<class 'str'>
>>> ascii([3,4])
'[3, 4]'
>>> type(_)
<class 'str'>
>>> ascii('￥')
"'\\uffe5'"
>>> ascii({1:2,'age':5})
"{1: 2, 'age': 5}"

5. bin()

bin() 返回一个整数 int或者长整数 long int 的二进制表示。将十进制转换为二进制，以字符串形式表示

>>> bin(2)
'0b10'
>>> bin(20)
'0b10100'
>>> type(_)
<class 'str'>

6. oct()

将十进制转换为八进制，以字符串形式表示

>>> oct(8)
'0o10'
>>> oct(43)
'0o53'
>>> type(_)
<class 'str'>

7. hex()

将十进制整数转换成十六进制，以字符串形式表示

>>> hex(43)
'0x2b'
>>> hex(15)
'0xf'
>>> type(_)
<class 'str'>

8. bool()

测试一个对象是True, 还是False

bool 是 int的子类。

>>> bool([0,0])
True
>>> bool([])
False
>>> bool([None])
True
>>> bool(None)
False
>>> bool('')
False
>>> bool(0)
False
>>> issubclass(bool,int)
True

9. bytes()

将一个字符串转换成字节类型

语法：bytes(value=b'', encoding=None, errors='strict')

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

>>> bytes(5)
b'\x00\x00\x00\x00\x00'
>>> bytes("apple",encoding="utf-8")
b'apple'
>>> bytes("apple",encoding="gbk")
b'apple'
>>> bytes([1,2,3])
b'\x01\x02\x03'
>>> bytes([1,2,3,266])
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: bytes must be in range(0, 256)
>>> bytes()
b''

10. str()

str() 函数将对象转化为适于人阅读的形式。将字符类型、数值类型等转换为字符串类型

>>> i = 100
>>> d = {"baidu":"www.baidu.com","google":"www.google.com"}
>>> str(i)
'100'
>>> str(d)
"{'baidu': 'www.baidu.com', 'google': 'www.google.com'}"

11. callable()

判断对象是否可以被调用，能被调用的对象就是一个callable 对象，对于函数、方法、lambda 表达式、 类以及实现了 __call__ 方法的类实例, 它都返回 True

>>> callable(0)
False
>>> callable(lambda x: x+10)
True
>>> def add(a,b):
...     return a + b
... 
>>> callable(add)
True

12. chr()

chr()用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

>>> chr(32)
' '
>>> chr(48)
'0'
>>> chr(65)
'A'
>>> chr(97)
'a'

13. ord()

查看某个ascii对应的十进制数

>>> ord(' ')
32
>>> ord('0')
48
>>> ord('A')
65
>>> ord('a')
97

14. classmethod()

通常作为装饰器，见面向对象部分 blog

15. compile()

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

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

• source – 字符串或者 AST（Abstract Syntax Trees）对象
• filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值
• mode – 指定编译代码的种类。可以指定为 exec, eval, single
• flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象
• flags 和 dont_inherit 是用来控制编译源码时的标志

>>> # 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
>>> s = "print('hello world!')"
>>> r = compile(s,"<string>", "exec")
>>> r
<code object <module> at 0x00000269252C3240, file "<string>", line 1>
>>> exec(r)
hello world!
>>> str = "for i in range(0,5): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象
>>> c
<code object <module> at 0x00000269252B53A0, file "", line 1>
>>> exec(c)
0
1
2
3
4

16. complex()

创建一个复数

>>> complex(1,2)
(1+2j)
>>> complex(1,0)
(1+0j)
>>> complex(0,2)
2j
>>> complex(0,0)
0j

17. hasattr()

面向对象部分提到的动态属性增删改查

18. getattr()

面向对象部分提到的动态属性增删改查

19. setattr()

面向对象部分提到的动态属性增删改查

20. delattr()

面向对象部分提到的动态属性增删改查

21. dict()

创建数据字典

>>> dict(a='a', b='b', t='t') 
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}

22. dir()

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息

23. divmod()

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

>>> divmod(11,3)
(3, 2)
>>> divmod(20,4)
(5, 0)

24. enumerate()

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

>>> l = "I love you"
>>> for index, c in enumerate(l):
...     print(f"index={index}, char={c}")
...     
index=0, char=I
index=1, char= 
index=2, char=l
index=3, char=o
index=4, char=v
index=5, char=e
index=6, char= 
index=7, char=y
index=8, char=o
index=9, char=u

25. eval()

将字符串 str 当成有效的表达式来求值并返回计算结果取出字符串中内容

>>> s = "1 + 3 + 5"
>>> eval(s)
9
>>> str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"
>>> eval(str1)
['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']
>>> len(str1)
52
>>> len(eval(str1))
2

26. exec()

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

27. filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

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

28. float()

将一个字符串或整数转换为浮点数

29. format()

格式化字符串的函数，现在一般用 fast-string 替代了

30. frozenset()

>>> s = frozenset([1,1,3,2,3])
>>> hasattr(s,"add")
False
>>> t = {1,2,3}
>>> hasattr(t,"add")
True

31. globals()

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

32. hash()

返回对象的哈希值

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

在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关

class Test:
    def __init__(self, i):
        self.i = i
        
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))
    
hash(point1)  # 16294976

hash('返回对象的哈希值')  # 4919828709165481160

hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改 hash 值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。

33. help()

返回对象的帮助文档

34. id()

id() 函数返回对象的唯一标识符，标识符是一个整数。CPython 中 id() 函数用于获取对象的内存地址

35. input()

Python 3.x 中 input() 函数接受一个标准输入数据，返回为 str 类型。获取用户输入内容

36. int()

int() 函数用于将一个字符串或数字转换为整型。 x 可能为字符串或数值，将 x 转换为一个普通整数。如果参数是字符串，那么它可能包含符号和小数点。如果超出了普通整数的表示范围，一个长整数被返回

语法：int(x, base =10)

37. isinstance()

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

语法：isinstance(object, classinfo)

39. issubclass()

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。如果 class是 classinfo类的子类，返回 True

语法：issubclass(class, classinfo)

40. iter()

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

41. len()

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

42. list()

list() 函数创建列表或者用于将元组转换为列表

43. map()

map() 会根据提供的函数对指定序列做映射。返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器

详见函数式编程

44. max()

求最大值

45. min()

求最小值

46. memoryview()

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

>>> v = memoryview(bytearray("abcefg", 'utf-8'))
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x00000210B3C43880>
>>> v[1:4].tobytes()
b'bce'

具体没搞懂

47. next()

用于访问迭代器的下一个元素

48. object()

所有类的父类

49. open()

IO流函数

50. pow()

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

语法：pow(x, y[, z])

51. print()

控制台输出

52. property()

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

详见函数和面向对象部分

53. range()

range() 函数可创建一个整数列表，一般用在 for 循环中

左闭右开

54 reversed()

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

55. round()

四舍五入函数

56. set()

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

57. slice()

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个表示由 range(start, stop, step) 所指定索引集的slice 对象

• class slice(stop)
• class slice(start, stop[, step])

58. sorted()

排序函数，默认升序，传入命名关键字参数reverse=True设置降序

59. staticmethod()

类的静态方法的装饰器

60. str()

转字符串

61. sum()

求和

62. super()

super() 函数是用于调用父类(超类)的一个方法。

详见面向对象

63. tuple()

创建或转换元组

64. type()

可以判定类型，也可以动态创建类型，详见面向对象

65. zip()

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

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

>>> x = [3,2,1]
>>> y = [4,5,6]
>>> list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]

>>> a = range(5)
>>> b = list('abcde')
>>> [str(y) + str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']

>>> list1 = [2,3,4]
>>> list2 = [5,6,7]
>>> for x,y in zip(list1,list2):
...     print(x,y,'--',x*y)
...     
2 5 -- 10
3 6 -- 18
4 7 -- 28

>>> n = [3,2,1]
>>> list(zip(n,b))
[(3, 'a'), (2, 'b'), (1, 'c')]

>>> a1, a2 = zip(*zip(a,b))
>>> a1
(0, 1, 2, 3, 4)
>>> a2
('a', 'b', 'c', 'd', 'e')