Python3 常用内置函数

本文罗列了一些自己常用的函数，并添加一些自己的见解。如有纰漏，望不吝赐教，谢谢！
参考资料 https://docs.python.org/zh-cn/3/library/functions.html

abs()

abs(x)
返回一个数的绝对值。参数可以是整数、浮点数或任何实现了__abs__() 的对象。如果参数是一个复数，则返回它的模。

all()

all(iterable)
如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True。

等价于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any()

any(iterable)
如果 iterable 的任一元素为真值则返回 True。如果可迭代对象为空，返回 False。

等价于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

bin()

bin(x)
将一个整数转换为带前缀 “0b” 的二进制数字符串。例如：

> bin(3)
# '0b11'
> bin(-10)
# '-0b1010'
> format(14, '#b'), format(14, 'b')
# ('0b1110', '1110')
> f'{14:#b}', f'{14:b}'
# ('0b1110', '1110')

callable()

callable(object)
如果 object 参数是可调用的则返回 True，否则返回 False。

一般用来判断变量名是否已经声明

chr()

chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。这是 ord()的逆函数。例如：

> chr(97)
# 'a'
> chr(8364)
# '€'

实参 i 的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

dict()

dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)
创建一个新的字典。例如：

> dict()
# {}
> dict(a='a', b='b', c='c')
# {'a': 'a', 'b': 'b', 'c': 'c'}
> dict([('a', 'a'), ('b', 'b'), ('c', 'c')])
# {'a': 'a', 'b': 'b', 'c': 'c'}

enumerate()

enumerate(iterable, start=0)
返回一个枚举对象。iterable 必须是一个序列，或其他支持迭代的对象。enumerate() 返回的迭代器的__next__() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。例如：

> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
> list(enumerate(seasons))
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
> list(enumerate(seasons, start=1))
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等价于:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval()

eval(expression, globals=None, locals=None)
实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。
返回值就是表达式的求值结果。语法错误将作为异常被报告。例如：

1
2
3

> x=1
> eval('x+1')
# 2

官方解释

表达式解析参数 expression 并作为 Python 表达式进行求值（从技术上说是一个条件列表），采用 globals 和 locals 字典作为全局和局部命名空间。如果存在 globals 字典，并且不包含 *__builtins__键的值，则在解析 expression 之前会插入以该字符串为键以对内置模块 builtins 的字典的引用为值的项。这样就可以在将 globals 传给 eval() 之前通过向其传入你自己的__builtins__字典来控制可供被执行代码可以使用哪些内置模块。如果 locals 字典被省略则它默认为 globals 字典。如果两个字典都被省略，则将使用调用 eval() 的环境中的 globals 和 locals * 来执行该表达式。注意，eval() 无法访问闭包环境中的嵌套作用域 (非局部变量)。

提示：

exec() 函数支持语句的动态执行。globals() 和 locals() 函数分别返回当前的全局和本地字典，可供传给 eval () 或 exec () 使用。
如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。

另外可以参阅 ast.literal_eval()，该函数可以安全执行仅包含文字的表达式字符串。

不建议使用此函数，不仅执行效率低，而且可能会使代码存在风险。

float()

float(x=0.0)
返回从数字或字符串 x 生成的浮点数。例如：

> float('+1.23')
# 1.23
> float('   -12345\n')
# -12345.0
> float('1e-003')
# 0.001
> float('+1E6')
# 1000000.0
> float('-Infinity')
# -inf

format()

format(value, format_spec='')
将 value 转换为 “格式化后” 的形式，格式由 format_spec 进行控制。详见 https://docs.python.org/zh-cn/3/library/string.html#formatspec。

现在一般使用 f''，代码会更简洁整齐。

hex()

hex(x)
将整数转换为带前缀 “0x” 前缀的小写十六进制数字符串。例如：

> hex(255)
# '0xff'
> hex(-42)
# '-0x2a'
> %#x' % 255, '%x' % 255, '%X' % 255
# ('0xff', 'ff', 'FF')
> format(255, '#x'), format(255, 'x'), format(255, 'X')
# ('0xff', 'ff', 'FF')
> f'{255:#x}', f'{255:x}', f'{255:X}'
# ('0xff', 'ff', 'FF')

如果要获取浮点数的十六进制字符串形式，请使用 float.hex() 方法。

input()

input()
input(prompt)
如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。

int()

int(x=0)
int(x, base=10)
返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。如果 x 定义了__int__()，则 int (x) 将返回 x.__int__()。如果 x 定义了__index__()，则将返回 x.__int__()。如果 x 定义了__trunc__()，则将返回 x.__trunc__()。对于浮点数，这将向零方向截断。

import

这个说起来有些复杂，参阅 Python 的 Import 陷阱和 python3 中关于 import 的疑难杂症，这里头说的很棒。

isinstance()

isinstance(object, classinfo)
如果 object 参数是 classinfo 参数的实例，或者是其 (直接、间接或虚拟) 子类的实例则返回 True。如果 object 不是给定类型的对象，则该函数总是返回 False。例如：

> a=10
> print(isinstance(a, int))
# True
> print(isinstance(a, str))
# False
> print(isinstance(a, (str, int, list)))
# True

classinfo 基本类型包括 int、float、bool、complex、str、list、dict、set 和 tuple。

len()

len(s)
返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozenset 等）。

map()

map(function, iterable, *iterables)
返回一个将 function 应用于 iterable 的每一项，并产生其结果的迭代器。例如：

> def square(x):
>   return x ** 2
> list(map(square, [1, 2, 3, 4, 5]))
# [1, 4, 9, 16, 25]

max()

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)
返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

min()

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)
返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

oct()

oct(x)
将整数转换为带前缀 “0o” 的八进制数字符串。

> oct(8)
# '0o10'
> oct(-56)
# '-0o70'
> '%#o' % 10, '%o' % 10
# ('0o12', '12')
> format(10, '#o'), format(10, 'o')
# ('0o12', '12')
> f'{10:#o}', f'{10:o}'
# ('0o12', '12')

open()

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开 file 并返回对应的 file object。详见 https://www.runoob.com/python3/python3-func-open.html

建议使用 with open() as... 的形式

ord()

ord(c)
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码的整数。例如 ord('a') 返回整数 97，ord('€') 返回 8364。这是 chr()的逆函数。

pow()

pow(base, exp, mod=None)
返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。两参数形式 pow(base, exp) 等价于乘方运算符 base ** exp。

1 2	> pow(38, -1, mod=97) # 23

range()

range(stop)
range(start, stop, step=1)
返回的结果是一个整数序列的对象，例如：

> list(range(6))
# [0, 1, 2, 3, 4, 5]
> list(range(1, 6))
# [1, 2, 3, 4, 5]
> list(range(6, 1, -1))
# [6, 5, 4, 3, 2]

print()

print(*objects, sep=' ', end='\n', file=None, flush=False)
输出文本至控制台。

拓展：来看看 Python 炫酷的颜色输出与进度条打印

str()

str(object='')
str(object=b'', encoding='utf-8', errors='strict')
返回一个 string 类型的 object。

sum()

sum(iterable, /, start=0)
从 start 开始自左向右对 iterable 的项求和并返回总计值。iterable 为数字，start 值不允许为字符串。

提示：拼接字符串序列的更好更快方式是调用''.join(sequence)。

type()

type(object)
type(name, bases, dict, **kwds)
传入一个参数时，返回其类型。返回值是一个 type 对象，通常与 object.__class__所返回的对象相同。

推荐使用 isinstance()内置函数来检测对象的类型，因为它会考虑子类的情况。

zip()

zip(*iterables, strict=False)
在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。例如：

>for item in zip([1, 2, 3], ['a', 'c', 'c']):
>    print(item)
# (1, 'a')
# (2, 'b')
# (3, 'c')

默认情况下（strict=False），zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略，结果会裁切至最短可迭代对象的长度。

提示：*zip() 运算符相结合可以用来拆解一个列表。

> x = [1, 2, 3]
> y = [4, 5, 6]
> list(zip(x, y))
# [(1, 4), (2, 5), (3, 6)]
> x2, y2 = zip(*zip(x, y))
> x == list(x2) and y == list(y2)
# True