内置库函数

基本介绍

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

具体函数讲解

1.locals（）

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

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

案例

a = 0
b = 1
def text():c = 2d = 3print(locals())return text()#输出结果：{'c': 2, 'd': 3}

2.globals（）

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

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

案例

a = 0
b = 1
def text():c = 2d = 3print(globals())return text()#输出结果：过多，不便展示

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 worldprint("""'12+3'""")#显示屏输出结果：'12+3'print('12+3')#显示屏输出结果：12+3

4.input（）

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

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

案例

data = input('请用户输入数据：')#输出结果：请用户输入数据：（同时光标闪动等待输入）

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

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'>

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]

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]

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,)]

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))]

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]

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]

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 reversiblelst = [1,4,5,2,3]
print(list(reversed(lst)))
print(sorted(lst,reverse = True))#输出结果：
"""
[3, 2, 5, 4, 1]
[5, 4, 3, 2, 1]
"""

14.len（）

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

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

案例

L = len(range(10))
print(L)#输出结果：10L = len('你好呀123')
print(L)#输出结果：6

15.sum（）

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

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

案例

Sum = sum([1,2,3,4,5])
print(Sum)#输出结果：15Sum = 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]

16.max（）

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

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

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

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

案例

M = max([1,2,3,4,5])
print(M)#输出结果：5M = max([1,2,3,4,5],key = lambda item: -item)
print(M)#输出结果：1M = max([],default = -1)
print(M)#输出结果：-1M = max([])
print(M)#引发异常：ValueError: max() arg is an empty sequenceM = max({1,2},{1,2,3},{1,2,3,4})
print(M)#输出结果：{1, 2, 3, 4}

17.min（）

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

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

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

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

案例

m = min([1,2,3,4,5])
print(m)#输出结果：1m = min([1,2,3,4,5],key = lambda item: -item)
print(m)#输出结果：5m = min([],default = -1)
print(m)#输出结果：-1m = min([])
print(m)#引发异常：ValueError: min() arg is an empty sequencem = min({1,2},{1,2,3},{1,2,3,4})
print(m)#输出结果：{1, 2}

18.all（）

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

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

案例

b = all([1,2,3,4])
print(b)#输出结果：Trueb = all([1,2,3,None])
print(b)#输出结果：Falseb = all([1,2,3,[]])
print(b)#输出结果：Falseb = all([1,2,3,range(1,0)])
print(b)#输出结果：Falseb = all([1,2,3,map(int,range(1,0))])
print(b)#输出结果：Trueb = all([])
print(b)#输出结果：True

19.any（）

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

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

案例

b = any([None,None,None,None])
print(b)#输出结果：Falseb = any([1,None,None,None])
print(b)#输出结果：Trueb = any([])
print(b)#输出结果：False

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'>

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)#输出结果：12data = round(34.56)
print(data)#输出结果：35data = round(34.56,0)
print(data)#输出结果：35.0data = round(34.56,1)
print(data)#输出结果：34.6data = round(34.56,-1)
print(data)#输出结果：30.0

22.divmod（）

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

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

案例

data = divmod(10,-3)
print(data)#输出结果：(-4, -2)

23.pow（）

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

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

案例

data = pow(4,0.5)
print(data)#输出结果：2.0data = pow(4,2)
print(data)#输出结果：16data = pow(4,2,5)
print(data)#输出结果：1

24.isinstance（）

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

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

案例

b = isinstance(10,object)
print(b)#输出结果：Trueb = isinstance(10,int)
print(b)#输出结果：Trueb = isinstance(10,float)
print(b)#输出结果：Falseb = isinstance(10,(float,int))
print(b)#输出结果：True

25.ord（）

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

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

案例

Ord = ord('0')
print(Ord)#输出结果：48Ord = ord('A')
print(Ord)#输出结果：65Ord = ord('a')
print(Ord)#输出结果：97Ord = ord('林')
print(Ord)#输出结果：26519

26.chr（）

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

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

案例

Chr = chr(48)
print(Chr)#输出结果：0Chr = chr(65)
print(Chr)#输出结果：AChr = chr(97)
print(Chr)#输出结果：aChr = chr(ord('林'))
print(Chr)#输出结果：林

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'"

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'"

29.hex（）

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

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

案例

Hex = hex(True)
print(Hex)#输出结果：0x1Hex = hex(12)
print(Hex)#输出结果：0xcHex = hex(0x12)
print(Hex)#输出结果：0x12Hex = hex('12')
print(Hex)#引发异常：TypeError: 'str' object cannot be interpreted as an integer

30.oct（）

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

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

案例

Oct = oct(True)
print(Oct)#输出结果：0o1Oct = oct(12)
print(Oct)#输出结果：0o14Oct = oct(0o12)
print(Oct)#输出结果：0o12Oct = oct('12')
print(Oct)#引发异常：TypeError: 'str' object cannot be interpreted as an integer

31.bin（）

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

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

案例

Bin = bin(True)
print(Bin)#输出结果：0b1Bin = bin(12)
print(Bin)#输出结果：0b1100Bin = bin(0b10)
print(Bin)#输出结果：0b10Bin = bin('10')
print(Bin)#引发异常：TypeError: 'str' object cannot be interpreted as an integer

32.bool（）

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

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

案例

b = bool(range(2,1))
print(b)#输出结果：Falseb = bool(map(int,range(2,1)))
print(b)#输出结果：True

33.callable（）

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

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

案例

b = callable(int)
print(b)#输出结果：Trueb = callable(1)
print(b)#输出结果：False

34.callable（）

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

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

案例

b = callable(int)
print(b)#输出结果：Trueb = callable(1)
print(b)#输出结果：False

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 startfileeval("""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)
#输出结果：7a = 1
b = 2
data = eval('a+b',{'a':3,'b':4},{'a':5,'b':6})  #传入了自定义 globals 参数和自定义 locals 参数#自定义 locals 参数对自定义 globals 参数中"键"相同的"值"进行了覆盖
print(data)#输出结果：11func = "def test(item):\n\treturn 1 if item == True else 0"eval(func)
juge = test(True)
print(juge)#引发异常：SyntaxError: invalid syntax

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)#输出结果：1func = "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)#输出结果：1expr = """         #传入了自定义 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. 此处关于Python内置库函数round（）的描述参考了wq_0708
   同学的该博客 ↩︎

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

Python——内置库函数相关推荐

1. python内置库之学习configparser库(一)

   python内置库之学习configparser库(一) 1.引言 ini文件简介 [节] 键=值 注:节不能重复出现 2.自己封装了一个增删改查的类,可以参考一下 import configpars ...

2. Python培训分享：Python内置标准异常及其解析

   本期小编为大家带来的Python培训教程是关于"Python内置标准异常及其解析"的内容,我们都知道,在Python技术运作下,总会出现一些Python无法正常处理的程序时就会发生 ...

3. python 内置函数

   python 内置函数 Python内置(built-in)函数随着python解释器的运行而创建.在Python的程序中,你 可以随时调用这些函数,不需要定义. abs()     # 求一个数的绝 ...

4. python怎么用函数查看变量类型_查看变量类型的Python内置函数是()。

   [单选题]下列不属于反射的是( ) [判断题]传统通俗史学有普及型和通俗型 [单选题]当前最流行和最受重视的资料分析是( ). [简答题]什么情况下采用斜视图比较合适? [单选题]下列命题正确的是( ...

5. python内置函数可以返回列表元组_Python内置函数()可以返回列表、元组、字典、集合、字符串以及range对象中元素个数....

   Python内置函数()可以返回列表.元组.字典.集合.字符串以及range对象中元素个数. 青岛远洋运输有限公司冷聚吉船长被评为全国十佳海员.()A:错B:对 有源逆变是将直流电逆变成其它频率的交流 ...

6. python内置函数sorted(x)的作用是_Python内置filter与sorted函数

   Python内部提供了序列过滤函数 filter . 接收参数为 一个函数以及一个序列.函数依次作用于序列中的每一个元素,并根据返回值是True 或者 False 判断是否删除该元素. 样例如下 # ...

7. pythonpass函数_有的python内置函数怎么就一个pass?

   你看到的是pass,但可能现实并非如此. 火车上信号太差了,待我移动一下再续-- 先随便扯扯吧-- 既然提到Python内置函数的实现,就涉及到Python本身的实现方式了,也就是这个解释器是怎么实现 ...

8. python内置函数用来返回数值型序列中所有元素之和_Python内置函数______用来返回数值型序列中所有元素之和...

   [填空题]表达式 int(4**0.5) 的值为 [判断题]3+4j不是合法的Python表达式. [填空题]已知列表对象x = ['11', '2', '3'],则表达式 max(x) 的值为 [填 ...

9. 列举5个python内置函数_Python5个内建高阶函数的使用

   描述 本文结合各种实际的例子详细讲解了Python5个内建高阶函数的使用,能够帮助理解Python的数据结构和提高数据处理的效率,这5个函数分别是: map reduce filter sorted/ ...

最新文章

1. 将 iPhone 定位设置在法国，手机速度就能迅速提升？
2. python常用函数-Python小白必备的8个最常用的内置函数（推荐）
3. 【C 语言】字符串 一级指针 内存模型 ( 指定大小字符数组 | 未指定大小字符数组 | 指向常量字符串的指针 | 指向堆内存的指针 )
4. 用Kotlin开发android平台语音识别，语义理解应用（olamisdk）
5. 安卓7.0拍照遇到 Uri暴露错误
6. 深圳华强北三菱服务器维修,三菱电梯GPS维修的故障分析 -解决方案-华强电子网...
7. 读取csv文件 java_Java：逐步读取/流式传输CSV文件
8. matlab wc wp,数字信号处理MATLAB习题.PDF
9. 2021 年 1 月程序员薪资出炉，持续上涨！你过平均线了吗？
10. Linux本地无法登录，远程却可以登录
11. 布林通道参数用20还是26_这样设置均线参数
12. python可以调试吗_python调试的几种方法
13. 让元素固定_49种元素对钢铁性能的影响
14. detectron2 ImportError: cannot import name ‘_C‘ from ‘detectron2‘
15. iOS网络协议_HTTP/TCP/IP浅析
16. 电脑连接了HDMI线，电脑没有声音了，原因和解决办法
17. ubuntu18.04 netplan 设置dns，dns不生效
18. 信息系统分析与设计-信息、管理与信息系统
19. CSS首字母下沉怎么设置?
20. 前端-JS基础之运算符

热门文章

1. 【推荐】有哪些没什么卵用，又很沙雕无聊的网站,沙雕的快乐！你不懂
2. python bottle 上传文件_bottle.py 实现批量文件上传
3. Spring Boot入门三：创建Spring Boot项目；（包括【Spring 官网start.spring.io】方式，【IDEA集成的Spring Initializr】方式）
4. 坚持#第407天~云仓刚换了新系统，现在又要换新仓库了
5. OTFS代码学习记录Ⅰ
6. LaTeX | LaTeX如何在正文中交叉引用
7. WLAN无线技术之旁挂二层组网配置AC+AP+ENSP组网配置
8. 被迫学习自动化的心酸苦累
9. tensorflow2中使用ragged.constant()将非矩形列表转为tensor类型
10. 让我们学习一下快速激怒程序员的十种方法