Python——内置库函数_python3.12 内置函数 库函数

内置库函数

基本介绍

内置（也称内建）函数（BIF）运行速度最快，一边在开发项目时，优先选择内置函数，使用时不需要额外导入然后模块即可直接使用，这些内置对象都封装在__builtins__之中，使用C语言实现并且进行了大量优化，__builtins__为一个字典对象，通过print( __builtins__)，可以查看该模块的内容
使用内置函数dir（__builtins__）可以查看所有内置函数
直接运行help（）会进入交互模式，只要输入正确的内置函数名，就可以查看到该函数用途的详细说明，可以使用quit进行退出，函数说明中的"[ ]"表示该参数可选传入，对应函数的形式参数为默认值形参
Python默认启动时仅仅加载了基本模块，再需要的时候再显式地导入和加载标准库和第三方扩展库，这样可以减少程序运行的压力，从"木桶原理"的角度看，这样的设计与安全配置时遵循的"最小权限"和原则是一致的，有助于提高系统的安全性

具体函数讲解

1.locals（）

作用
得到包含当前作用域内所有局部变量和值的字典

返回值
字典类型对象 每一个键值对为局部变量（作为key）及其对应值（作为value）的字典

案例

a = 0
b = 1
def text():
    c = 2
    d = 3
    print(locals())
    return 

text()

#输出结果：{'c': 2, 'd': 3}
1
2
3
4
5
6
7
8
9
10
11

2.globals（）

作用
得到包含当前作用域内所有全局变量和值的字典

返回值
字典类型对象 每一个键值对为全局变量（作为key）及其对应值（作为value）的字典

案例

a = 0
b = 1
def text():
    c = 2
    d = 3
    print(globals())
    return 

text()

#输出结果：过多，不便展示
1
2
3
4
5
6
7
8
9
10
11

3.print（）

作用
将内容输出在显示屏上或者文件中
可以通过参数end来指定输出最后以何种字符结束，默认为\n
可以通过参数sep来指定输出各个值之间用何种字符相分隔，默认为空格
格式化输出可以使用格式化字符串（见Python——字符串？？？）实现
print输出字符串对象的时候，会自动去除最外层的定界符

Python默认情况下使用print函数打印一个对象，会显示
<XXX object at XXXXX>

返回值
空类型对象 None

案例

print("Hello","world",sep = '_', end = '!')

#显示屏输出结果：Hello_world!

with open(r'D:\text.txt', 'w') as fp:
    print("Hello","world",file = fp)

#D:\text.txt中输出结果：Hello world

print("""'12+3'""")

#显示屏输出结果：'12+3'

print('12+3')

#显示屏输出结果：12+3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.input（）

作用
与用户进行交互，实现用户输入数据
以‘\n’为结束符，用户输入‘\n’，即刻停止本次输入
可以传入一个字符串类型对象，作为输入提示语

返回值
字符串类型对象 将使用输入的数据都转化为一个字符串类型对象，相当于使用了str（）函数

案例

data = input('请用户输入数据：')

#输出结果：请用户输入数据：（同时光标闪动等待输入）
1
2
3

5.int（）

作用
将输入的对象强制类型转化为整数类型对象，通过指定base参数，可以实现传入的数据对应的进制的指定，base可以指定为0以及 2-36，默认为10，如果没有给定被转化对象，返回0

对于一个数据，只要带有0o、0x、0b等进制标识，表示该数据自身表明了进制信息

如果给定的被转化对象为一个整数类型对象，会调用方法__int__（）
如果给定的参数为一个浮点类型对象，会直接进行截断，只保留整数部分

• 被转化数据为一个字符串类型的对象
  • 进制指定为0
    • 自身有标识进制，按照自身标识的进制进行解读（如’0xA’表示该字符串为一个十六进制的数据，会被转化为十进制数10）
    • 自身未标识进制，按照十进制进行解读
  • 进制指定为非0（默认就是指定为非0，即10）
    • 自身有标识进制，如果此时字符串自身表明的进制和我们指定的进制不符，会抛出异常；如果相符，按照该进制进行解读
    • 自身未标识进制，根据该指定进制进行解读
• 被转化数据为一个非字符串类型的对象
  • 绝不能指定进制，即使指定的进制和自身标识的进制相同也不行
    • 自身有标识进制，按照自身标识的进制进行解读
    • 自身未标识进制，按照十进制进行解读

返回值
int类型对象 一个十进制整数

案例

data = int('000123')
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 123 <class 'int'>

data = int('123',8)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 83 <class 'int'>

data = int(True)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 1 <class 'int'>

data = int(False)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 1 <class 'int'>

data = int('1.2')
print('数据内容及其类型：',data, type(data))

#输出结果：ValueError: invalid literal for int() with base 10: '1.2'

data = int('0xA',0)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 10 <class 'int'>

data = int('0xA')
print('数据内容及其类型：',data, type(data))

#引发异常：ValueError: invalid literal for int() with base 10: '0xA'

data = int('0o66',10)
print('数据内容及其类型：',data, type(data))

#引发异常：ValueError: invalid literal for int() with base 10: '0o66'

data = int(0o10)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 8 <class 'int'>

data = int(66.5)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 66 <class 'int'>

data = int(10,6)
print('数据内容及其类型：',data, type(data))

#引发异常：TypeError: int() can't convert non-string with explicit base
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

6.float（）

作用
将输入的对象强制类型转化为浮点数类型对象

返回值
float类型对象 一个浮点数

案例

data = float('1')
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 1.0 <class 'float'>

data = float(1)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 1.0 <class 'float'>

data = float(True)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 1.0 <class 'float'>

data = float(False)
print('数据内容及其类型：',data, type(data))

#输出结果：数据内容及其类型： 0.0 <class 'float'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.range（）

作用
用于生成一个整数序列，一般用于指定for循环的次数
可以指定序列区间，为左闭右开的形式，默认从0开始生成整数，序列终止值必须要进行指定，无默认值
可以指定整数的生成步长，默认为1

返回值
range类型对象 一个可迭代对象（Python3）
列表类型对象 一个列表（Python2）

案例

iterable = range(10)
print(list(iterable))

#输出结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

iterable = range(1,10)
print(list(iterable))

#输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

iterable = range(0,10,2)
print(list(iterable))

#输出结果：[0, 2, 4, 6, 8]

iterable = range(10,1)
print(list(iterable))

#输出结果：[]

iterable = range(10,1,-1)
print(list(iterable))

#输出结果：[10, 9, 8, 7, 6, 5, 4, 3, 2]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

8.map（）

作用
传入一个函数和一个或多个可迭代对象，将可迭代对象中的元素作为函数的实参来调用函数（如果有多个可迭代对象，则函数也应该有多个形参与之对应），将函数的返回值作为map类型对象的元素
map函数执行至最短序列的元素耗尽时停止

返回值
map类型对象 一个迭代器对象

案例

iterator = map(int, range(10))
print(list(iterator))

#输出结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

iterator = map(lambda a, b: a+b, range(10),range(10))
print(list(iterator))

#输出结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
1
2
3
4
5
6
7
8
9

9.zip（）

作用
传入多个可迭代对象，进行多个可迭代对象的缝合，将各个可迭代对象的对应元素打包成元组，形成zip类型对象的元素
zip函数执行至最短序列的元素耗尽时停止

返回值
zip类型对象 一个迭代器对象

案例

iterator = zip(range(5),range(7),range(10))
print(list(iterator))

#输出结果：[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)]

iterator = zip(range(5))
print(list(iterator))

#输出结果：[(0,), (1,), (2,), (3,), (4,)]
1
2
3
4
5
6
7
8
9

10.enumerate（）

作用
对一个可迭代对象进行编号，可以指定编号的起点数，默认为0
将可迭代对象的各个元素和对应的编号打包成一个元组，形成enumerate类型对象的元素

返回值
enumerate类型对象 一个迭代器对象

案例

iterator = enumerate(range(1,6))
print(list(iterator))

#输出结果：[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]

iterator = enumerate(range(1,6),5)
print(list(iterator))

#输出结果：[(5, 1), (6, 2), (7, 3), (8, 4), (9, 5)]

iterator = enumerate(zip(range(1,6),range(1,6)),5)
print(list(iterator))

#输出结果：[(5, (1, 1)), (6, (2, 2)), (7, (3, 3)), (8, (4, 4)), (9, (5, 5))]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

11.filter（）

作用
传入一个可迭代对象，取出可迭代对象中布尔值为True的所有元素（可以先经过函数处理，查看函数的返回结果的布尔值，判断该元素是否要取出），将所有取出的元素作为filter类型对象的元素
值得注意的是，如果不想指定函数，也必须传入一个None，否则会抛出异常

返回值
filter类型对象 一个迭代器对象

案例

iterator = filter(None,range(10))
print(list(iterator))

#输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

iterator = filter(lambda item: item%2 ,range(10))
print(list(iterator))

#输出结果：[1, 3, 5, 7, 9]
1
2
3
4
5
6
7
8
9

12.sorted（）

作用
对于一个可迭代对象按照一定规则进行升序（默认）或者降序排列
通过对key参数赋值函数对象可以实现元素按照指定的规则进行排列，排列之前先对要比较的对象调用函数，对于各个元素调用函数后的返回值进行比较，从而确定相应的各个元素次序
如果有元素的返回值相同，则按照原序列中的次序进行排列

返回值
列表类型对象 对传入可迭代对象的元素进行排列后生成的列表对象

案例

lst = sorted([1,4444,22,333])
print(lst)

#输出结果：[1, 22, 333, 4444]

lst = sorted([1,4444,22,333],key = lambda item: -item)
print(lst)

#输出结果：[4444, 333, 22, 1]

lst = sorted({1:11, 2:22, 3:33, 4:44})
print(lst)

#输出结果：[1, 2, 3, 4]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

13.reversed（）

作用
传入一个序列，将该对象的元素次序颠倒过来，形成对应类型对象
实际对于不同类型的对象调用reversed函数，会有不同类型的对象构造出来
比如对于字典为dict_reversekeyiterator类型，对于列表为list_reverseiterator类型，对于元组和字符串则皆为reversed类型

对于集合，不可逆，会抛出异常

reversed函数和sorted函数中的reverse参数置True的效果有所不同，前者为对于序列直接进行逆序，后者为先按照一定的规则进行排列，再进行逆序

返回值
对传入序列的元素进行逆序后生成的对象，为一个迭代器对象

案例

sequence = reversed([1,4,5,2,3])
print(list(sequence))

#输出结果：[3, 2, 5, 4, 1]

sequence = reversed({1,4,5,2,3})
print(list(sequence))

#输出结果：TypeError: 'set' object is not reversible

lst = [1,4,5,2,3]
print(list(reversed(lst)))
print(sorted(lst,reverse = True))

#输出结果：
"""
[3, 2, 5, 4, 1]
[5, 4, 3, 2, 1]
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

14.len（）

作用
计算容器对象（比如五种序列，range对象）中元素个数
一个汉字的长度和一个英文字母一样

返回值
int类型对象 容器中元素的个数

案例

L = len(range(10))
print(L)

#输出结果：10

L = len('你好呀123')
print(L)

#输出结果：6
1
2
3
4
5
6
7
8
9

15.sum（）

作用
传入一个可迭代对象，计算该可迭代对象所有元素之和
通过对start形参赋值，可以设定加和的初始值，但是注意其类型必须要可以和参数中的元素进行加法运算
start形参默认为0，为一个整数类型，这意味着如果不人为指定start，sum函数可以实现加和运算的元素类型会有限制（并不是所有类型的对象都支持和整数类型对象进行加和运算）
不能传入字符串，sum函数不能对字符串进行加和运算，即使start形参同样赋值字符串类型对象

返回值
可迭代对象元素之和

案例

Sum = sum([1,2,3,4,5])
print(Sum)

#输出结果：15

Sum = sum(['1','2','3','4','5'],'')
print(Sum)

#引发异常：TypeError: unsupported operand type(s) for +: 'int' and 'tuple'

Sum = sum([(1,2),(3,4)],())
print(Sum)

#输出结果：(1, 2, 3, 4)

Sum = sum(['1','2','3','4','5'],'')
print(Sum)

#引发异常：TypeError: sum() can't sum strings [use ''.join(seq) instead]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

16.max（）

作用
传入一个可迭代对象，得到其中元素的最大值
通过对key参数赋值函数对象可以实现元素按照指定的规则筛选最大值，筛选之前先对要比较的对象调用函数，对于各个元素调用函数后的返回值进行比较，从而确定最大元素

传入多个可迭代对象，得到可迭代对象的最大值

传入可迭代对象为空时，必须指定参数default，用来返回默认值输出，否则会抛出异常

返回值
可迭代对象中元素的最大值

案例

M = max([1,2,3,4,5])
print(M)

#输出结果：5

M = max([1,2,3,4,5],key = lambda item: -item)
print(M)

#输出结果：1

M = max([],default = -1)
print(M)

#输出结果：-1

M = max([])
print(M)

#引发异常：ValueError: max() arg is an empty sequence

M = max({1,2},{1,2,3},{1,2,3,4})
print(M)

#输出结果：{1, 2, 3, 4}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

17.min（）

作用
传入多个可迭代对象，得到可迭代对象的最小值
通过对key参数赋值函数对象可以实现元素按照指定的规则筛选最小值，筛选之前先对要比较的对象调用函数，对于各个元素调用函数后的返回值进行比较，从而确定最小元素

传入一个可迭代对象，得到其中元素的最小值

传入可迭代对象为空时，必须指定参数default，用来返回默认值输出，否则会抛出异常

返回值
可迭代对象中元素的最小值

案例

m = min([1,2,3,4,5])
print(m)

#输出结果：1

m = min([1,2,3,4,5],key = lambda item: -item)
print(m)

#输出结果：5

m = min([],default = -1)
print(m)

#输出结果：-1

m = min([])
print(m)

#引发异常：ValueError: min() arg is an empty sequence

m = min({1,2},{1,2,3},{1,2,3,4})
print(m)

#输出结果：{1, 2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

18.all（）

作用
传入一个可迭代对象，判断是否该可迭代对象中的元素的布尔值全为True

返回值
布尔类型对象 True 或 False

案例

b = all([1,2,3,4])
print(b)

#输出结果：True

b = all([1,2,3,None])
print(b)

#输出结果：False

b = all([1,2,3,[]])
print(b)

#输出结果：False

b = all([1,2,3,range(1,0)])
print(b)

#输出结果：False

b = all([1,2,3,map(int,range(1,0))])
print(b)

#输出结果：True

b = all([])
print(b)

#输出结果：True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

19.any（）

作用
传入一个可迭代对象，判断是否该可迭代对象中有布尔值为True的元素存在

返回值
布尔类型对象 True 或 False

案例

b = any([None,None,None,None])
print(b)

#输出结果：False

b = any([1,None,None,None])
print(b)

#输出结果：True

b = any([])
print(b)

#输出结果：False
1
2
3
4
5
6
7
8
9
10
11
12
13
14

20.abs（）

作用
求得数值的大小（对于复数来说即为模）

返回值
float类型/int类型对象 数值的大小

案例

data = abs(3+4j)
print(data,type(data))

#输出结果：5.0 <class 'float'>

data = abs(1)
print(data,type(data))

#输出结果：1 <class 'int'>
1
2
3
4
5
6
7
8
9

21.round（）

作用
用于进行数值的精确保留，默认保留到整数位（精度对应的形参值默认为None），可以指定一个负数精度，表示在整数位部分四舍五入

• 被进行精确保留的数据为一个float类型的对象
  • 精度进行指定
    • 保留到指定位，返回一个float类型的对象
  • 精度不进行指定
    • 保留到整数位，返回一个int类型的对象
• 被进行精确保留的数据为一个int类型的对象
  • 无论是否指定精度，都是返回一个int类型的对象

注意，round函数并不总是四舍五入，该函数对于返回的浮点数并不是按照四舍五入的规则来计算，而会受到Python版本和计算机表示精度的影响

• Python版本的影响¹
  • Python2.7 中对round()的介绍中，指出：将保留成距离更近的那一端数值，如果距离两端数值一样远，则保留成更加离远0的那一端数值
    所以Python2.7中，round(0.5)会近似到1，而round(-0.5)会近似到-1，其他情况为四舍六入机制
  • Python3.7 中对round()的介绍中，指出：将保留成距离更近的那一端数值，如果距离两端数值一样远，会保留成数值为偶数的那一端数值
    所以Python3.7中，round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2，其他情况为四舍六入机制
• 计算机表示精度的影响
  • round(2.675, 2) 的结果，不论我们从python2还是3来看，结果都应该是2.68的，而结果却是2.67？我们知道在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67

返回值
float类型/int类型对象 数据进行指定精度保留的结果

案例

data = round(12.34)
print(data)

#输出结果：12

data = round(34.56)
print(data)

#输出结果：35

data = round(34.56,0)
print(data)

#输出结果：35.0

data = round(34.56,1)
print(data)

#输出结果：34.6

data = round(34.56,-1)
print(data)

#输出结果：30.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

22.divmod（）

作用
传入两个数，分别计算这两个数整除和取余的结果，以一个具有两个元素的元组构成

返回值
元组类型对象 一个带有两个数整除和取余的结果的元组

案例

data = divmod(10,-3)
print(data)

#输出结果：(-4, -2)
1
2
3
4

23.pow（）

作用
当只传入两个参数的时候，进行的是乘方运算
当传入三个参数的时候，是先把前两个参数进行乘方运算，再将结果对第三个参数取余数

返回值
元组类型对象 一个带有两个数整除和取余的结果的元组

案例

data = pow(4,0.5)
print(data)

#输出结果：2.0

data = pow(4,2)
print(data)

#输出结果：16

data = pow(4,2,5)
print(data)

#输出结果：1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

24.isinstance（）

作用
传入一个对象，判断该对象的类型是否为某一个指定类型（或者其子类）或者众多指定类型（或者其子类）中的一个

返回值
布尔类型对象 True 或者 False

案例

b = isinstance(10,object)
print(b)

#输出结果：True

b = isinstance(10,int)
print(b)

#输出结果：True

b = isinstance(10,float)
print(b)

#输出结果：False

b = isinstance(10,(float,int))
print(b)

#输出结果：True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

25.ord（）

作用
传入一个字符（当然，在Python中即使是一个字符也是字符串类型对象），返回其对应的ordinal value原始值（Unicode码），支持汉字

返回值
int类型对象 一个字符对应的原始值

案例

Ord = ord('0')
print(Ord)

#输出结果：48

Ord = ord('A')
print(Ord)

#输出结果：65

Ord = ord('a')
print(Ord)

#输出结果：97

Ord = ord('林')
print(Ord)

#输出结果：26519
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

26.chr（）

作用
传入一个整数，根据ordinal value原始值（Unicode码）返回对应的那个字符，支持汉字

返回值
字符串类型对象 一个Unicode码对应的字符

案例

Chr = chr(48)
print(Chr)

#输出结果：0

Chr = chr(65)
print(Chr)

#输出结果：A

Chr = chr(97)
print(Chr)

#输出结果：a

Chr = chr(ord('林'))
print(Chr)

#输出结果：林
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

27.ascii（）

作用
把对象转化为ASCII码表示形式，功能类似于repr函数，二者的区别在于ascii函数会使用转义序列 (\x, \u , \U) 来替换其中的非ASCII码字符，而repr函数则是保持不变
如果对象为字符串，具有在该字符串外层又加了一层定界符的效果

返回值
字符串类型对象 把对象转化为对应的ASCII码表示形式，必要的时候会使用转义字符来表示特定字符

案例

data = ascii('林')
print(data)

#输出结果：'\u6797'

data = ascii('\n123\t')
print(data)

#输出结果：'\n123\t'

data = ascii("""'123'""")
print(data)			#print会自动消除字符串最外层的定界符

#输出结果："'123'"
1
2
3
4
5
6
7
8
9
10
11
12
13
14

28.repr（）

作用
输入一个字符串类型对象，将格式字符，比如换行符、制表符，替换为其相应的转义字符（即进行二次转化，比如\n原来表示换行，为一个字符，二次转义以后的\\n表示两个字符\和n），其他部分不变
如果对象为字符串，具有在该字符串外层又加了一层定界符的效果
对于大多数类型的对象来说，执行 eval(repr(obj)) == obj 结果为True

返回值
字符串类型对象 把对象转化为对应的ASCII码表示形式，必要的时候会使用转义字符来表示特定字符

案例

data = repr('林')
print(data)

#输出结果：'林'

data = repr('\n123\t')
print(data)

#输出结果：'\n123\t'

data = repr("""'123'""")
print(data)			#print会自动消除字符串最外层的定界符

#输出结果："'123'"
1
2
3
4
5
6
7
8
9
10
11
12
13
14

29.hex（）

作用
输入一个可以转化为int类型的对象，得到其十六进制形式的字符串类型对象

返回值
字符串类型对象 传入对象的十六进制形式的字符串类型对象

案例

Hex = hex(True)
print(Hex)

#输出结果：0x1

Hex = hex(12)
print(Hex)

#输出结果：0xc

Hex = hex(0x12)
print(Hex)

#输出结果：0x12

Hex = hex('12')
print(Hex)

#引发异常：TypeError: 'str' object cannot be interpreted as an integer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

30.oct（）

作用
输入一个可以转化为int类型的对象，得到其八进制形式的字符串类型对象

返回值
字符串类型对象 传入对象的八进制形式的字符串类型对象

案例

Oct = oct(True)
print(Oct)

#输出结果：0o1

Oct = oct(12)
print(Oct)

#输出结果：0o14

Oct = oct(0o12)
print(Oct)

#输出结果：0o12

Oct = oct('12')
print(Oct)

#引发异常：TypeError: 'str' object cannot be interpreted as an integer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

31.bin（）

作用
输入一个可以转化为int类型的对象，得到其二进制形式的字符串类型对象

返回值
字符串类型对象 传入对象的二进制形式的字符串类型对象

案例

Bin = bin(True)
print(Bin)

#输出结果：0b1

Bin = bin(12)
print(Bin)

#输出结果：0b1100

Bin = bin(0b10)
print(Bin)

#输出结果：0b10

Bin = bin('10')
print(Bin)

#引发异常：TypeError: 'str' object cannot be interpreted as an integer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

32.bool（）

作用
传入一个对象，得到该对象对应的布尔值

返回值
布尔类型对象 True 或者 False

案例

b = bool(range(2,1))
print(b)

#输出结果：False

b = bool(map(int,range(2,1)))
print(b)

#输出结果：True
1
2
3
4
5
6
7
8
9

33.callable（）

作用
传入一个对象，判断该对象是否可调用，如果返回 True，object 其实仍然可能调用失败；但如果返回 False，调用对象 object 的操作绝对不会成功
对于函数、方法、lambda表达式、 类以及具有__call__ 方法的实例对象, 它都返回True

返回值
布尔类型对象 True 或者 False

案例

b = callable(int)
print(b)

#输出结果：True

b = callable(1)
print(b)

#输出结果：False
1
2
3
4
5
6
7
8
9

34.callable（）

作用
传入一个对象，判断该对象是否可调用，如果返回 True，object 其实仍然可能调用失败；但如果返回 False，调用对象 object 的操作绝对不会成功

返回值
布尔类型对象 True 或者 False

案例

b = callable(int)
print(b)

#输出结果：True

b = callable(1)
print(b)

#输出结果：False
1
2
3
4
5
6
7
8
9

35.eval（）

作用
将字符串转化为表达式，并执行它，可以大概地看作是str函数的逆运算，还可以实现类型转化，对于列表、元组或者其他复杂的结构必须使用eval而不能使用list（）或者tuple（）直接进行转化
支持对字节串进行求值，可以指向内置函数compile（）编译生成的代码对象

eval函数具有三个参数²
source：一个字符串类型对象，即要被进行还原的字符串对象，还原的结果与后两个参数有紧密联系
globals：如果只是提供了自定义的 globals 参数（提供的必须是一个字典对象），而没有提供自定义的模块__builtins__，则系统会默认将当前环境中的内置模块 builtins 复制到自定义的 globals 参数中，然后再开始进行字符串还原
如果连自定义的 globals 参数都没有，则默认使用Python的全局命名空间，即使用内置函数globals函数打印出来的信息进行字符串还原

locals：和 globals 参数的功能类似，只是当它和 globals 中字典的键相同时，以 locals 中字典的值为准，如果自定义的 locals 参数没有被提供（提供的可以是任意一个映射对象），则默认根据 globals 进行字符串还原，如果globals和locals都被忽略，那么将取作用域内的变量值进行计算

返回值
字符串经过还原以后的对象，如果结果为一个表达式，先计算表达式，再得到一个对象

案例

obj = eval('1+4')
print(obj, type(obj))

#输出结果：5 <class 'int'>

obj = eval("""'a'+'b'""")
print(obj, type(obj))

#输出结果：ab <class 'str'>

from os import startfile

eval("""startfile(r'D:\\test.txt')""")

#效果：打开了一个文件名为D:\\test.txt的记事本文件

sr = '[1,2,3,4,5]'
obj1 = eval(sr)
obj2 = list(sr)
print('使用eval函数的效果：',obj1, type(obj1))
print('使用list函数的效果：',obj2, type(obj2))

#输出结果：
"""
使用eval函数的效果： [1, 2, 3, 4, 5] <class 'list'>
使用list函数的效果： ['[', '1', ',', '2', ',', '3', ',', '4', ',', '5', ']'] <class 'list'>
"""

a = 1
b = 2
data = eval('a+b',{'a':3,'b':4})	#传入了自定义 globals 参数
print(data)
#输出结果：7

a = 1
b = 2
data = eval('a+b',{'a':3,'b':4},{'a':5,'b':6})	#传入了自定义 globals 参数和自定义 locals 参数
												#自定义 locals 参数对自定义 globals 参数中"键"相同的"值"进行了覆盖
print(data)

#输出结果：11

func = "def test(item):\n\treturn 1 if item == True else 0"

eval(func)
juge = test(True)
print(juge)

#引发异常：SyntaxError: invalid syntax
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

36.exec（）

作用
eval和exec函数的功能是相似的，都可以执行一个字符串形式的Python代码，相当于一个 Python 的解释器，二者不同之处在于eval函数执行完要返回结果，而exec函数执行完不返回结果；eval函数把传入的字符串还原出来以后，只能是单个运算表达式，不能是赋值操作或复杂的代码逻辑，否则会抛出异常，exec函数则可以执行更复杂的 Python 代码

返回值
空类型对象 None

案例

obj = exec('1+4')
print(obj, type(obj))

#输出结果：None <class 'NoneType'>

func = "def test(item):\n\treturn 1 if item == True else 0"		#定义了一个函数名为test的简单的函数，注意要进行Python的缩进，否则会抛出语法异常

exec(func)
juge = test(True)
print(juge)

#输出结果：1

func = "def test(item):\n\tif item==True:\n\t\t return 1 \n\telse: \n\t\treturn 0"			#定义了一个函数名为test的较为复杂的函数

exec(func)
juge = test(True)
print(juge)

#输出结果：1

expr = """			#传入了自定义 globals 参数和自定义 locals 参数
x = 10				#自定义 locals 参数对自定义 globals 参数中"键"相同的"值"进行了覆盖（'x'的值为4，'y'的值为5）
					#同时由于运行字符串还原以后的代码时，'x'的值为10，又进行了一次覆盖
					#于是运行结果为10+5+3=18
print(x+y+z)

"""

exec(expr,{'x':1, 'y':2, 'z':3},{'x':4, 'y':5})

#输出结果：18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

参考资料：

---

1. 此处关于Python内置库函数round（）的描述参考了wq_0708
   同学的该博客 ↩︎

2. 此处关于Python内置库函数eval（）的描述参考了Kwoky同学的
   该博客 ↩︎