五、Python的常用的内置函数
Python为我们准备了大量的内置函数，如下图所示
这里我们只讨论红框内的内置函数
abs(x)
返回一个数的绝对值（模），参数可以是真说或浮点数
>>> abs(-10) 10
all(iterable)
如果可迭代对象（列表、元祖等）中所有的元素都是True，则返回True，否则返回False。相当于and
>>> all([1, True, 1 == 1]) True
any(iterable)
如果可迭代对象中任意一个元素是True，则返回True，相当于or
>>> any([None, "", [], (), {}, 0, False])
False
>>> any([None, "", [], (), {}, 0, True])
True
说明：可以看出，通常情况下“空”（None，空字符串、空列表，0等等）都是表示False
bin(x)
返回一个整数的二进制字符串
>>> bin(10) ‘0b1010‘
说明：Python使用0b开头表示这是一个二进制表达式
class bool([x])
返回或者新建一个布尔值对象，如果不传递参数默认返回False
>>> bool() False >>> bool(10) True
chr(i)
返回一个整数所对应的Unicode编码所对应的字符
>>> chr(89999) ‘\U00015f8f‘ >>> chr(97) ‘a‘
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个字典对象，以通过关键字参数，mapping对象，字典对象等参数方式创建
>>> dict()
{}
>>> dict(k1 = ‘v1‘, k2 = ‘v2‘)
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}
>>> dict(([‘k1‘, ‘v1‘], [‘k2‘, ‘v2‘]))
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}
>>> dict({‘k1‘:‘v1‘, ‘k2‘:‘v2‘})
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}
dir([object])
返回当前域或指定模块、对象中的所有变量名和方法名
>>> dir()
[‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘]
>>> dir("")
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘capitalize‘, ‘casefold‘, ‘center‘, ‘count‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘format_map‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdecimal‘, ‘isdigit‘, ‘isidentifier‘, ‘islower‘, ‘isnumeric‘, ‘isprintable‘, ‘isspace‘, ‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘maketrans‘, ‘partition‘, ‘replace‘, ‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]
divmod(a, b)
返回两个数的得商和余数组成的元祖，相当于(a // b, a % b)
>>> divmod(10, 3) (3, 1)
enumerate(iterable, start=0)
返回一个迭代器，每次迭代返回一个元祖包括一个计数器，和对iterable迭代取得的值，iterable可迭代对象，包括列表、元祖等。start表示计数器的开始值，默认是0
1 enu = enumerate([‘abc‘, ‘def‘, ‘ghi‘]) 2 print(enu) 3 for i in enu: 4 print(i)
执行结果
<enumerate object at 0x0000000BE2D53510> # 可以看到返回的是一个enumerate对象 (0, ‘abc‘) (1, ‘def‘) (2, ‘ghi‘)
注意：返回的是是一个迭代器，迭代完了空了，如果需要重复使用，最好转化为一个列表对象保存到变量中，并且计数器是从0开始计数的
>>> li = list(enumerate([‘abc‘, ‘def‘, ‘ghi‘])) >>> li [(0, ‘abc‘), (1, ‘def‘), (2, ‘ghi‘)]
可以指定start的开始值
>>> li = list(enumerate([‘abc‘, ‘def‘, ‘ghi‘], 2)) >>> li [(2, ‘abc‘), (3, ‘def‘), (4, ‘ghi‘)]
eval(expression, globals=None, locals=None)
将的字符串形式的算数表达式进行计算，并返回结果
>>> eval(‘3 + 4 * (1 - 3)‘) -5
filter(function, iterable)
接收一个函数和一个可迭代对象，将可迭代对象的每一个元素都作为参数执行函数，函数返回为真的放到一个新的可迭代对象中，并将新的可迭代对象返回
1 def is_dual(num): 2 if num % 2 == 0: 3 return True 4 else: 5 return False 6 7 nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 8 9 print(list(filter(is_dual, nums))) # 由于返回的是filter对象，所以要转化为list列表对象进行查看
执行结果
[2, 4, 6, 8, 10, 12, 14, 16, 18]
class float([x])
创建一个浮点类型的对象
>>> float(‘0.5‘) 0.5 >>> float(0.5) 0.5
help([object])
返回某个对象的帮助信息
hex(x)
返回一个整数的16进制表达式
>>> hex(23) ‘0x17‘
说明：hex函数只接受整数类型的参数
id(object)
返回对象的id（可以理解为Python为每个对象的编号，或者理解为是Python对象内存地址的表达形式）
>>> id(1) 10455040 >>> id(2) 10455072
input([prompt])
接受用户从控制台的输入，并将用户输入的信息，以字符串的返回，prompt表示输入时前显示的字符串
>>> s = input(‘python>>‘) python>>123 >>> s ‘123‘
class int(x=0)
class int(x, base=10)
创建一个整数类型的对象，默认如果创建的0，如果传递的是字符串类型的，可以把字符串表达式所表示的整数转化为整数类型，base表示的传递的字符串进制，默认是十进制
>>> int() 0 >>> int(‘1‘) 1 >>> int(‘1010‘, base = 2) 10
len(s)
返回一个对象的长度（或者元素的个数）
>>> len(‘abc‘) 3 >>> len([1, 2]) 2
说明：所谓的长度一般只字符串，像整数、浮点数等数据类型没有len方法，会报如下错误
>>> len(10) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type ‘int‘ has no len()
class list([iterable])
将一个可迭代对象转化为列表
>>> list([1, 2, 3])
[1, 2, 3]
>>> list((1, 2, 3))
[1, 2, 3]
>>> list({‘k1‘:‘v1‘, ‘k2‘:‘v2‘})
[‘k2‘, ‘k1‘]
说明：可以看到字典只是把key组成了列表，因为字典真正迭代的是key，value只是与key对应而已
map(function, iterable, ...)
接收一个函数和一个可迭代对象，将可迭代对象里的每一个元素都做作为参数传递到函数中，并把函数的返回结果保存到一个map对象中
>>> map(lambda x: x**2, [1, 2, 3]) <map object at 0x7f0700026518> >>> list(map(lambda x: x**2, [1, 2, 3])) [1, 4, 9]
说明：函数可以是匿名函数，另外函数必须有返回值，如果没有返回值，虽然不会报错，但没有任何意义，例如
>>> def f(x): ... x*2 ... >>> list(map(f, [1, 2, 3])) [None, None, None]
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
返回可迭代对象中（或者2个以上参数中）最大的值
>>> max(1, 2, 3) 3 >>> max([1, 2, 3]) 3
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
返回可迭代对象中（或者2个以上参数中）最大的值
>>> min(1, 2, 3) 1 >>> min([1, 2, 3]) 1
oct(x)
将一个数转化为8进制的表达形式
>>> oct(9) ‘0o11‘
说明：Python中0o表示8进制
open(file, mode=‘r‘, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开文件并返回文件文件对象，file表示文件名（可以是绝对路径，也可以是相对路径），mode表示打开方式，默认的是rt模式，表示只读的文本格式
ord(c)
返回一个字符的Unicode编码
>>> ord(‘a‘) 97 >>> ord(‘中‘) 20013
pow(x,y[,z])
如果只传递两个参数x和y，就计算x的y次方，相当于x ** y
参数z表示将x ** y的结果对z取模，相当于x ** y % z
>>> pow(2, 3) 8 >>> pow(2, 3, 3) 2
print(*objects, sep=‘ ‘, end=‘\n‘, file=sys.stdout, flush=False)
打印函数，object表示要输出的对象，sep表示多个对象之间的分隔符，默认是空格，end表示末尾的字符，默认是回车符，file表示输出的文件，默认为sys.stdout也就是终端（标准输出）
>>> print(‘abc‘) abc >>> print(‘abc‘,‘def‘, sep = ‘*‘) abc*def >>> print(‘abc‘,‘def‘, sep = ‘*‘, end = ‘end‘) abc*defend >>> f = open(‘print.log‘, ‘w‘) >>> print(‘abc‘,‘def‘, sep = ‘*‘, end = ‘end‘, file = f) >>> f = open(‘print.log‘, ‘r‘) >>> f.read() ‘abc*defend‘
range(stop)
range(start, stop[, step])
生成大于等于start，小于stop步长为step的数字序列，start默认是0
>>> list(range(1, 10)) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 10, 2)) [1, 3, 5, 7, 9] >>> list(range(5)) [0, 1, 2, 3, 4]
reversed(seq)
翻转一个序列，序列对象必须是有序的，也就是对象必须包含__reversed__()方法
>>> reversed([0, 1, 2, 3, 4]) <list_reverseiterator object at 0x7fcc954acd68> >>> list(reversed([0, 1, 2, 3, 4])) [4, 3, 2, 1, 0]
round(number[, ndigits])
返回一个浮点数的后面保留ndigits位小数的结果，四舍五入，小数点位数不足，不补0
>>> round(1.236, 2) 1.24 >>> round(1.2, 2) 1.2
class set([iterable])
根据序列对象创建集合对象
>>> set([1, 2, 4, 2])
{1, 2, 4}
sorted(iterable[, key][, reverse])
对一个序列对象进行排序，key接收一个函数，将序列的每一个函数处理返回的结果作为排序的依据，比如字符串都转换成小写排序或字典按照key或value排序等，reverse表示对排序的结果是否排序，默认字符串是先大写后小写的顺序排序的
>>> sorted([‘A‘, ‘b‘, ‘c‘]) [‘A‘, ‘b‘, ‘c‘] >>> sorted([‘A‘, ‘b‘, ‘C‘]) [‘A‘, ‘C‘, ‘b‘] >>> sorted([‘A‘, ‘b‘, ‘C‘], key = lambda x: x.lower()) [‘A‘, ‘b‘, ‘C‘] >>> sorted([‘A‘, ‘b‘, ‘C‘], key = lambda x: x.lower(), reverse = True) [‘C‘, ‘b‘, ‘A‘]
class str(object=‘‘)
创建一个字符串对象，或者将一个对象转化为字符串对象
>>> str(‘abc‘) ‘abc‘ >>> str(1234) ‘1234‘
sum(iterable[, start])
返回一个序列对象的相加的总和在加上start，start默认是0，序列对象要么全是数字要么都是字符串，字符串就相当于把它们都拼接在一起
>>> sum([1, 2, 4]) 7 >>> sum([1, 2, 4], 1) 8
疑惑：说是可以使用字符串，但是报错
>>> sum([‘ab‘, ‘bc‘, ‘cd‘]) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for +: ‘int‘ and ‘str‘
tuple([iterable])
创建一个元祖对象，或将一个对象转化为元祖
>>> tuple() () >>> tuple([1, 2, 4]) (1, 2, 4)
class type(object)
class type(name, bases, dict)
返回一个对象的类型
>>> type(1) <class ‘int‘> >>> type(str) <class ‘type‘>
vars([object])
返回模块，类，实例或者任何其他有__dict__属性的对象的__dict__属性，默认是显示当前环境的
>>> vars()
{‘f‘: <_io.TextIOWrapper name=‘print.log‘ mode=‘r‘ encoding=‘UTF-8‘>, ‘__spec__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__warningregistry__‘: {("unclosed file <_io.TextIOWrapper name=‘print.log‘ mode=‘w‘ encoding=‘UTF-8‘>", <class ‘ResourceWarning‘>, 1): True}, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>}
>>> import sys
>>> vars(sys)
{‘version_info‘: sys.version_info(major=3, minor=4, micro=0, releaselevel=‘final‘, serial=0), ‘getswitchinterval‘: <built-in function getswitchinterval>, ‘__name__‘: ‘sys‘, ‘path_hooks‘: [<class ‘zipimport.zipimporter‘>, <function FileFinder.path_hook.<locals>.path_hook_for_FileFinder at 0x7fcc97b51ae8>],后面省略n多行
zip(*iterables)
将多个元素组成一个新的zip对象，zip对象的元素个数取决于元素最少的参数
>>> x = [1, 2, 3, 4] >>> y = [‘a‘, ‘b‘, ‘c‘] >>> zip(x, y) <zip object at 0x7fcc954aea08> >>> list(zip(x, y)) [(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]