内置函数（汇总）
内置函数清单：
一共68个内置函数，根据使用方法进行分为下面几类：
思维导图：https://mubu.com/doc/869S9SVWwr
1.数学运算
abs: 返回一个数值的绝对值。
>>> abs(-100) 100 >>> abs(-1.11) 1.11 >>>
div: 接收两个数值（非负数），返回两个数的相除得到的商和余数组成的元组
>>> divmod(10,3) (3, 1) >>> divmod(10,2) (5, 0) >>> divmod(5.5,2) (2.0, 1.5) >>>
max:获取一个可迭代对象的最大元素。
>>> max(1,2,3,4,5) 5 >>> max("123456") '6' >>> max([1,2,3,4,56,6]) 56 >>> max(1,2,-3,4,5,key=abs) 5 >>> max(1,2,-3,4,-5,key=abs) #传入key=abs，元素都取绝对值后再取最大值。 -5 >>>
min：获取一个可迭代对象的最小元素
>>> min(1,2,3,4,5) 1 >>> min("12345") '1' >>> min([-1,2,1,3,4]) -1 >>> min(-3,1,2,3,4,5,key=abs) #将每个元素获取其绝对值，然后取值最小的一个 1 >>>
pow: 获取两个值的幂运算结果，指定第三个参数则是返回幂运算结果与第三个参数在进行取模运算后的结果
>>> pow(2,3) #2**3 8 >>> pow(2,3,2) # (2**3)%2 0 >>> pow(2,3,5) #(2**3)%5 3 >>>
round:对浮点数进行四舍五入取值
>>> round(1.13) 1 >>> round(1.53) 2 >>>
sum: 对元素是数值类型的可迭代对象求和
>>> sum([1,2,3,4,5,6,7,8,10]) #需要元素都是数值的可迭代对象 46 >>> sum([1,2,3,4,5,6,7,8,10],-10) #-10为一个可选参数，在sum开始计算时设置一个初始值。 36 >>> sum([],-10) -10 >>>
2.类型转换
bool: 根据传入的逻辑值创建一个新的布尔值
>>> bool(1) True >>> bool(0) False >>> bool("") False >>> bool(" ") True >>> bool([]) False >>> bool({}) False >>> #0，None和一切空对象("",[],{},..)都为False，其他都是True
int:传入一个参数，创建一个新的整数
>>> int() #不给参数，默认返回0
0
>>> int(1.1) #参数为小数时，取小数的整数部分（非四舍五入） 1 >>> int(1.9) 1 >>> int("123") #传入字符串，需要该字符串能转换为数字，否则会抛出异常 123
# 注意：int("123.1") 这种形式的参数也会报错，字符串只能为整数
float:传入一个参数，创建一个新的浮点型数字
>>> float("123") 123.0 >>> float("123.1") 123.1 >>> float(123) 123.0
>>> float() #不给参数默认返回0.0
complex:传入一个数字，创建一个新的复数
######
str: 返回一个对象的字符串形式
>>> str(123) '123' >>> str([1,2,3,4,5,6]) '[1, 2, 3, 4, 5, 6]' >>> str({"k1":1,"k2":2}) "{'k1': 1, 'k2': 2}" >>>
bytearray: 传入一个参数，返回一个新的字节数组
>>> bytearray("中文", "utf-8") bytearray(b'\xe4\xb8\xad\xe6\x96\x87') >>>
bytes: 传入一个参数，返回一个不可变新的字符数组
>>> bytes(1) #当参数为整数时，不需要字符集，返回的时整数个数的空字节数组， b'\x00' >>> bytes("中文",'utf-8') #参数为字符时，必须指定字符集，返回是字符串对应的字节数组 b'\xe4\xb8\xad\xe6\x96\x87' >>>
ord:返回unicode字符对应的整数
>>> ord("a") 97 >>> ord("x") 120 >>>
chr:返回整数对应的unicode字符
>>> chr(97) 'a' >>> chr(110) 'n'
bin:将整数转换为二进制字符串
>>> bin(10) '0b1010' >>> bin(5) '0b101' >>>
oct:将整数转换为八进制字符串
>>> oct(10) '0o12' >>> oct(20) '0o24' >>>
hex:将整数转换为十六进制字符串
>>> hex(10) '0xa' >>> hex(100) '0x64' >>>
tuple:传入一个可迭代对象，将可迭代对象的每个元素作为元组的元素，返回一个新的元组
>>> tuple() #不传入参数，返回空的元组
()
>>> tuple([1,2,3]) (1, 2, 3) >>> tuple("python") ('p', 'y', 't', 'h', 'o', 'n') >>> tuple({"k1":1,"k2":2}) #传入字典，则是将字典的key取出组成新的列表 ('k1', 'k2')
list:传入一个可迭代对象，将可迭代对象的每个元素作为列表的元素，返回一个新列表
>>> list() #不传入参数则是返回一个空列表 [] >>> list("python") ['p', 'y', 't', 'h', 'o', 'n'] >>> list({"k1":1,"k2":2}) ['k1', 'k2'] >>>
dict:根据传入的参数，返回一个新字典
>>> dict() #不传入参数，返回空字典 {} >>> dict([(1,2),(3,4)]) #传入可迭代对象，可迭代对象的元素为二元组或者两个元素组成的列表 {1: 2, 3: 4} >>> dict([[1,2],[3,4]]) {1: 2, 3: 4} >>> dict(a=1,b=2) #key=value的方式传值，注意这里的a，b不能加引号 {'a': 1, 'b': 2} >>> dict(zip((1,2),(3,4))) #传入映射函数创建字典。 {1: 3, 2: 4} >>>
set：传入一个可迭代对象，返回一个新的集合
>>> set() #不给参数，返回空集合 set() >>> set(range(10)) {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} >>>
frozenset: 传入一个可迭代对象，返回一个新的不可变集合
>>> frozenset() frozenset() >>> frozenset(range(10)) frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
enumerate: 根据可迭代对象创建枚举对象
>>> a = [1,2,3,4,5,6] >>> b = list(enumerate(a)) #默认起始值从0开始 >>> b [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)] >>> b = list(enumerate(a,100)) #设置起始值从100开始 >>> b [(100, 1), (101, 2), (102, 3), (103, 4), (104, 5), (105, 6)] >>>
range: 根据传入参数，创建一个新的range对象
>>> a = range(10) #可接受三个参数，start开始位置，end结束位置，step步长 >>> b = range(1,10)#只给一个参数，则start从0开始，end为给定参数 >>> c = range(1,10,2) >>> a,b,c (range(0, 10), range(1, 10), range(1, 10, 2)) >>> list(a),list(b),list(c) ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 3, 5, 7, 9])
iter: 传入一个可迭代对象，返回优该对象形成的迭代器
>>> a = iter([1,2,3,4,5,6]) >>> a.__next__() 1 >>> a.__next__() 2 >>> a.__next__() 3 >>> a.__next__() 4 >>> a.__next__() 5 >>> a.__next__() 6 >>> a.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>>
super:根据传入的值，定义一个子类和父类之间的关系代理。
class A(object): #定义父类 def __init__(self): print("__init__A") class B(A): #定义子类 def __init__(self): print("__init__B") super().__init__() # 子类调用父类方法 obj = B() __init__B __init__A
object：创建一个新的基类对象。
>>> a = object() >>> a <object object at 0x101bbc270> >>> a.name = "zhangjin" #不能修改属性 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'object' object has no attribute 'name'
3. 序列操作
all: 判断一个可迭代对象的元素是否都为True，返回bool值
>>> all([1,2,3,4]) #只有当可迭代对象中所有的元素都是True结果才是True True >>> all([]) #传入一个空的可迭代对象，返回也是True True >>> all([1,2,3,0]) False >>> all([1,2,3,""]) False >>> all([1,2,3,{}]) False >>> all([1,2,3,False]) False >>>
any：判断可迭代对象是否有元素为True，返回bool值
>>> any([1,2,3,5,6,0,False]) True >>> any("123") True >>> any([0,False,"",{}]) False >>> any([0,False,"",{},123]) #只要可迭代对象中有元素为真则结果为真 True >>> any([]) #可迭代对象为空时返回False False >>>
filter: 使用指定的方法过滤可迭代对象的元素，返回的是一个类生成器对象
>>> a [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> def if_odd(x): ... return x%2==1 #返回bool值 ... >>> filter(if_odd, a) <filter object at 0x10413df28> >>> new_a = filter(if_odd, a) >>> list(new_a) [1, 3, 5, 7, 9]
map: 使用指定的方法作用与可迭代对象的每个元素，返回一个可迭代对象
>>> a = [1,2,3,4,5,6,7,8,9] >>> def add_(x): ... return x+x ... >>> list(map(add_,a)) # 将可迭代对象的每个值都传入到add_方法中进行算，得到的结果组成一个新的可迭代对象 [2, 4, 6, 8, 10, 12, 14, 16, 18] >>>
>>> a = [1,2,3,4,5,6,7] >>> b = [100,101,102,103,104,105,106,107] >>> def sum_(a, b): ... return a+b ... >>> list(map(sum_,a,b)) #当map中的方法需要两个参数，则需要传入同等数量的可迭代对象 [101, 103, 105, 107, 109, 111, 113] >>> >>> a = "abcd" #当传入的可迭代对象长度不一样是，map的运算次数为len(最短长度可迭代对象) >>> b = "efg" >>> list(map(sum_,a,b)) ['ae', 'bf', 'cg'] >>>
next: 返回可迭代对象中的下一个值
>>> a = "1234".__iter__() >>> next(a) '1' >>> next(a) '2' >>> next(a) '3' >>> next(a) '4' >>> next(a) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> next(a,"e") #next传入第二个参数，当迭代器取不到值时，不会抛出异常，而是返回指定的默认值。 'e' >>>
reversed: 反转序列返回新的可迭代对象
>>> a = [1,2,3,4,5,6,7] >>> b = reversed(a) >>> b <list_reverseiterator object at 0x1042dadd8> >>> list(b) [7, 6, 5, 4, 3, 2, 1]
sorted: 对可迭代对象进行排序，返回新的可迭代对象
>>> a = [10,3,2,1,54,6,21,2,3,4] >>> print(sorted(a)) [1, 2, 2, 3, 3, 4, 6, 10, 21, 54] #数字默认升序 >>> b = ["a","A","b","B","c","C"] #字母则以ascii码中的位置进行排序 >>> print(sorted(b)) ['A', 'B', 'C', 'a', 'b', 'c'] >>> print(sorted(b, key=str.lower)) #将字母全部转换为小写后再进行排序， ['a', 'A', 'b', 'B', 'c', 'C'] >>>
zip: 聚合传入的迭代器中的每个元组，返回一个新的迭代器
>>> a = [1,2,3,4,5,6,7] >>> b = ["a","b","c","d","e","f","g"] >>> list(zip(a,b)) [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g')] >>> c = (10,20,30,40,50,60) #如果几个可迭代对象长度不一致，最后结果为取最小长度 >>> zip(a,b,c) <zip object at 0x10414c048> >>> list(zip(a,b,c)) [(1, 'a', 10), (2, 'b', 20), (3, 'c', 30), (4, 'd', 40), (5, 'e', 50), (6, 'f', 60)] >>>
4. 对象操作
help: 查看对象的帮助文档
>>> help(len) Help on built-in function len in module builtins: len(obj, /) Return the number of items in a container. (END)
dir： 返回对象或者当前作用域中的属性列表
>>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'add_', 'b', 'c', 'even', 'if_odd', 'mu', 'new_a', 'sum_'] >>> dir(int) ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] >>>
id： 返回对象的唯一标识符（内存地址）
>>> a = 123 >>> b = 456 >>> id(a) 4305420384 >>> id(b) 4367217200 >>>
hash: 返回可哈希对象的哈希值
>>> hash("abc") 1581979247584122883 >>> hash("456") -6407923365126122286 >>> hash((1,2,3,4)) 485696759010151909 >>> hash([1,2,3]) #列表为可变类型，不可哈希 Traceback (most recent call last): File "<stdin>", line 1, in <module>、 TypeError: unhashable type: 'list' >>>
type: 返回对象的类型
>>> a = 123
>>> b = {1,2,3}
>>> c = [1,2,3]
>>> type(a),type(b),type(c)
(<class 'int'>, <class 'set'>, <class 'list'>)
>>>
len: 返回对象的长度
>>> a = [1,2,3,4,5,6] >>> b = "python" >>> len(a) 6 >>> len(b) 6 >>>
format: 格式化输出
#字符串可以提供的参数 's' None >>> format('some string','s') 'some string' >>> format('some string') 'some string' #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None >>> format(3,'b') #转换成二进制 '11' >>> format(97,'c') #转换unicode成字符 'a' >>> format(11,'d') #转换成10进制 '11' >>> format(11,'o') #转换成8进制 '13' >>> format(11,'x') #转换成16进制 小写字母表示 'b' >>> format(11,'X') #转换成16进制 大写字母表示 'B' >>> format(11,'n') #和d一样 '11' >>> format(11) #默认和d一样 '11' #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None >>> format(314159267,'e') #科学计数法，默认保留6位小数 '3.141593e+08' >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 '3.14e+08' >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 '3.14E+08' >>> format(314159267,'f') #小数点计数法，默认保留6位小数 '314159267.000000' >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 '3.141593' >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 '3.14159267' >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 '3.1415926700' >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 'INF'
5. 反射
__import__：动态加载模块
>>> s = __import__("sys") >>> s.getfilesystemencoding() 'utf-8' >>>
isinstance: 判断对象是否是类或者类型元组中任意元素的实例
>>> a = 1 >>> isinstance(a, int) True >>> b = "python" >>> isinstance(b,(int,str,list)) True >>>
callable: 检测一个对象是否可被调用
>>> def a(): ... pass ... >>> callable(a) True >>> b = 1 >>> callable(b) False >>>
6.变量操作
globals: 返回全局作用域下变量名和值组成的字典
>>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': <function a at 0x10413eea0>, 'even': <function even at 0x10413ebf8>, 'if_odd': <function if_odd at 0x10413ec80>, 'new_a': <filter object at 0x10414b6a0>, 'mu': <function mu at 0x104022ea0>, 'add_': <function add_ at 0x10413ed08>, 'b': 1, 'sum_': <function sum_ at 0x10413ee18>, 'c': [1, 2, 3], 's': <module 'sys' (built-in)>} >>>
locals: 返回当前作用域下变量名和值组成的字典
>>> def a(): ... a=1 ... b="python" ... print(locals()) ... >>> a() {'b': 'python', 'a': 1}
7. 交互操作
input：获取用户输入,返回字符串
NameError: name 'inpue' is not defined >>> a = input("input something!") input something!1233124 >>> a '1233124' >>>
print: 向标准输出打印输出
>>> a '1233124' >>> print("1231423") 1231423 >>> print("python", end="") #end默认为\n换行，end指定为空则不换行 python>>>
8. 文件操作
open: 文件操作
>>> f = open("test.txt", "w", encoding="utf-8") #只写模式 >>> f.write("this is python!") 15 >>> f.close() >>> f = open("test.txt", "r", encoding="utf-8") #只读模式 >>> f.read() 'this is python!' >>>
9.编译执行
eval: 执行动态表达式求值
>>> eval("1+2+3+5") 11 >>> eval('{"k1":"v1","k2":"v2"}') {'k1': 'v1', 'k2': 'v2'}
exec: 执行动态的语句块
>>> exec("a = 10") >>> a 10 >>>
repr：返回一个对象的字符串表现形式(给解释器)
>>> s = 'some test' >>> s1 = repr(s) >>> s1 "'some test'" >>>
