python基础教程：内置函数（一）

Python解释器内置了很多函数和类型，可以随时随地在编程中使用。其实，我们在前面的学习中已经接触过好多内置函数。

这里把它们总结成下面的表格，方便我们学习它们的使用：

说明：
上面这个表格包含的有“内置函数”和“内置类型”，其中的内置类型可以作为函数使用，把其它类型的对象转变为该类型的对象。比如int是一个内置类型，int('123')就是把字符串转换成整数。两者在使用上没有什么区别，官方文档中也是把内置类型当做内置函数介绍的。

通过ipython，我们可以查看表格中的是函数还是类型。比如：

In [14]: abs?
Signature: abs(x, /)
Docstring: Return the absolute value of the argument.
Type:      builtin_function_or_method

In [15]: int?
Init signature: int(self, /, *args, **kwargs)
Docstring:     
int(x=0) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is a number, return x.__int__().  For floating point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base.  The literal can be preceded by '+' or '-' and be surrounded
by whitespace.  The base defaults to 10\.  Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4
Type:           type
Subclasses:     bool, IntEnum, IntFlag, _NamedIntConstant

在ipython里面通过问号?来查看其对应的说明，其中的Type就是它的类型，可以看到abs是一个内置函数builtin_function_or_method，而int是一个类型type。

我们把这些内置函数（类型）分成几类进行介绍。

数值型操作

abs(x)
求x的绝对值。x可以是整数或浮点数，如果是复数则返回它的模。

bin(x)
将一个整数转变为一个前缀为0b的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 index() 方法返回一个整数。比如：

In [26]: bin(5)
Out[26]: '0b101'

In [27]: bin(-5)
Out[27]: '-0b101'

x 不能是浮点数，否则会报错。
还可以通过format()函数来进行转换：

In [30]: format(5, '#b')
Out[30]: '0b101'

In [31]: format(5, 'b')
Out[31]: '101'

还可以用f-string格式化来转换：

In [32]: f'{5:#b}'
Out[32]: '0b101'

In [33]: f'{5:b}'
Out[33]: '101'

chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 ‘a’，chr(20013) 返回字符串 ‘中’。这是 ord() 的逆函数。

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

divmod(a, b)
它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

format(value[, format_spec])
将 value 转换为 format_spec 控制的“格式化”表示。

hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 index() 方法。

oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 index() 方法返回一个整数。

ord(c)
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。例如 ord(‘a’) 返回整数 97， ord(‘€’) （欧元符合）返回 8364 。这是 chr() 的逆函数。

pow(x, y[, z])
返回 x 的 y 次幂；如果 z 存在，则对 z 取余（比直接 pow(x, y) % z 计算更高效）。两个参数形式的 pow(x, y) 等价于幂运算符： x**y。

round(number[, ndigits])
返回精确到小数点后ndigits精度的数。 如果省略ndigits或者为None，则返回其输入的最接近的整数。

对于支持round()的内置类型，值被舍入离前一位更近的一端（四舍六入）; 如果距离两端相等（5）则保留到偶数一边。（例如，round(0.5)和round(-0.5)均为0，round(1.5)为2）。 任何整数值对ndigits（正数，零或负数）有效。如果省略ndigits或None，则返回值为整数。 否则返回值与number的类型相同。

对于一般的Python对象number，将代理舍入为number.__round__。

注释： round()对于浮点数的行为可能令人惊讶，比如，round(2.675, 2)得出2.67，而不是期望的2.68。这不是bug，这是因为大多数十进制小数不能准确表示为二进制的浮点数。

sum(iterable[, start])

从start开始由左到右累加可迭代的元素并返回总数。start默认为0. iterable的项通常是数字，起始值不允许是字符串。

对于某些用例，sum()有很好的替代方法。 连接字符串序列的首选快速方法是调用''.join(sequence)。 要以扩展精度累加浮点值，就用math.fsum()。要拼接一系列可迭代对象就考虑使用itertools.chain()。

可迭代操作

all(iterable), any(iterable)
这两个函数，我们在前面学习list、dict等数据结构时已经多次学习。
all()： 如果iterable的所有元素都为真（或iterable为空）返回True；等价于：

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

any()：如果iterable的任一个元素为真则返回True。如果iterable为空，则返回False。等价于：

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

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

In [4]: ll = ['a', 'b', 'c', 'd']

In [5]: list(enumerate(ll))
Out[5]: [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

In [6]: list(enumerate(ll, start=1))
Out[6]: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

等价于:

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

filter(function, iterable)
用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。

请注意， filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。
只有 function 返回 false 时才选取 iterable 中元素的补充函数。

map(function, iterable, …)
产生一个将 function 应用于迭代器中所有元素并返回结果的迭代器。如果传递了额外的 iterable 实参，function 必须接受相同个数的实参，并使用所有迭代器中并行获取的元素。当有多个迭代器时，最短的迭代器耗尽则整个迭代结束。如果函数的输入已经是元组实参，请参阅 itertools.starmap()。

zip(*iterables)
创建一个聚合来自每个可迭代的元素的迭代器。

返回元组的迭代器，其中第i个元组包含来自每个参数序列或迭代的第i个元素。当最短输入可迭代用尽时，迭代器停止。使用单个iterable参数，它返回一个1元组的迭代器。没有参数，它返回一个空迭代器。相当于：

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

保证了迭代的从左到右的评估顺序。 这使得使用zip(*[iter(s)]*n)将数据系列聚类成n长度组的习惯成为可能。这会重复相同的迭代器n次，以便每个输出元组具有n次调用迭代器的结果。这具有将输入分成n长度块的效果。

当你不关心较长迭代的尾随，不匹配的值时，zip()只应与不等长度输入一起使用。如果这些值很重要，请改用itertools.zip_longest()。

zip()与*运算符一起用于解压缩列表：

In [80]: a = [1, 2, 3]

In [81]: b = ['a', 'b', 'c']

In [82]: zipped = zip(a, b)

In [83]: list(zipped)
Out[83]: [(1, 'a'), (2, 'b'), (3, 'c')]

In [84]: a2, b2 = zip(*zip(a, b))

In [85]: a == list(a2) and b == list(b2)
Out[86]: True

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

如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

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

如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

reversed(seq)
返回反向迭代器。seq必须是一个具有reversed()方法的对象，或者支持序列协议（len()方法和getitem()方法，整数参数从0开始）。

sorted(iterable, *, key=None, reverse=False)

从iterable中的项返回一个新的排序列表。

有两个可选参数，必须指定为关键字参数。

key指定一个参数的函数，该函数用于从iterable中的每个元素中提取比较键（例如，key = str.lower）。默认值为None（直接比较元素）。

reverse是一个布尔值。 如果设置为True，则列表元素将按照每个比较相反的方式进行排序。

使用functools.cmp_to_key（）将旧式cmp函数转换为键函数。

内置的sorted()函数保证稳定。 如果排序保证不改变比较相等的元素的相对顺序，则排序是稳定的 – 这有助于多次传递排序（例如，按部门排序，然后按工资等级排序）。

iter(object[, sentinel])
返回一个 iterator 对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 iter() 方法）的集合对象，或必须支持序列协议（有 getitem() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError。如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的 next() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

next(iterator[, default])
通过调用 iterator 的 next() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

内置类型

class bool([x])
说明：在文档中，函数的参数用方括号[]括起来表示这个参数可有可无（在参数列表中）。
内置类型，返回一个布尔值：True或者False。x使用标注的真值测试过程来转换，关于真值测试的知识可以再回顾一下前面我们关于布尔值的章节。
bool类是int的子类，这个bool类很特别，它不能被继承，且只有True和False两个实例。

class bytearray([source[, encoding[, errors]]])
返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法，同时有 bytes 类型的大部分方法。
可选形参 source 可以用不同的方式来初始化数组：

如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。

• 如果是一个 integer，会初始化大小为该数字的数组，并使用 null 字节填充。
• 如果是一个符合 buffer 接口的对象，该对象的只读 buffer 会用来初始化字节数组。
• 如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用作数组的初始内容。

如果没有实参，则创建大小为 0 的数组。

class bytes([source[, encoding[, errors]]])
返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本 – 它有其中不改变序列的方法和相同的索引、切片操作。

因此，构造函数的实参和 bytearray() 相同。

class complex([real[, imag]])
返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

注解 当从字符串转换时，字符串在 + 或 – 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的，但 complex(‘1 + 2j’) 会触发 ValueError 异常。
在 3.6 版更改: 您可以使用下划线将代码文字中的数字进行分组。

class float([x])
返回从数字或字符串 x 生成的浮点数。

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 ‘+’ 和 ‘-‘ ； ‘+’ 对创建的值没有影响。实参也可以是 NaN（非数字）、正负无穷大的字符串。

class int([x])
class int(x, base=10)
返回一个使用数字或字符串 x 生成的整数对象，或者没有实参的时候返回 0 。如果 x 定义了 int()，int(x) 返回 x.int() 。如果 x 定义了 trunc()，它返回 x.trunc() 。对于浮点数，它向零舍入。

如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的 整数文字 的 bytearray 实例。该文字前可以有 + 或 – （中间不能有空格），前后可以有空格。一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默认的 base 为 10 ，允许的进制有 0、2-36。2、8、16 进制的数字可以在代码中用 0b/0B 、 0o/0O 、 0x/0X 前缀来表示。进制为 0 将安照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。所以 int(‘010’, 0) 是非法的，但 int(‘010’) 和 int(‘010’, 8) 是合法的。

class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)

返回一个str类型的对象。str是内置字符串类

class list([iterable])
除了是函数，list 也是可变序列类型，详情请参阅 列表 和 Sequence Types — list, tuple, range。

tuple([iterable])
元组是内置的不可变序列类型。tuple()生成一个元组对象，可选参数iterable的元素将被加入到新元组。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个新的字典。dict 对象是一个字典类
其他容器类型，请参见内置的 list、set 和 tuple 类，以及 collections 模块。

class set([iterable])
返回一个set对象。可选参数iterable的元素将被加入新set对象里面。

class frozenset([iterable])
返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。

class object
返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

注解 由于 object 没有 dict，因此无法将任意属性赋给 object 的实例。

class range(stop)
class range(start, stop[, step])
range其实是个不可变数字序列类型而不是一个函数，通常用于在for循环中循环特定次数。
传给range的实参必须是整数（或是内置类型int，或是实现了index这个特殊方法的对象）。如果step参数省略了，则它默认为1.如果start省略了则默认为0。如果step为0，则报错：ValueError。

如果step为整数，range 的内容决定于公式：r[i] = start + step*i，其中i >= 0, r[i] < stop。

如果step是负数，range 的内容仍决定于公式：r[i] = start + step*i，其中i >= 0, r[i] > stop。

如果r[0]不满足值约束，则range对象将为空。 range确实支持负索引，但这些索引被解释为从正索引确定的序列末尾开始的索引。

range被允许包含绝对值大于sys.maxsize的值，但是某些特性（如len()）可能会报错：OverflowError。
参看下面range的例子：

In [32]: list(range(9))
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [33]: list(range(3,9))
Out[33]: [3, 4, 5, 6, 7, 8]

In [34]: list(range(0, 20, 3))
Out[34]: [0, 3, 6, 9, 12, 15, 18]

In [35]: list(range(0, -10, -1))
Out[35]: [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

In [36]: list(range(0))
Out[36]: []

In [37]: list(range(10, 0))
Out[37]: []

range类型比通常的list或tuple的优点是，range对线下总是占用相同（小的）数量的内存，不管它表示的范围有多大。因为它只存储start，stop和step的值，在需要的时候才计算单独的元素或子范围。

range对象实现了类似list或tuple序列的特性，比如包含测试，元素索引查找，切片和对负索引的支持。参见下面的例子：

In [43]: r = range(0, 10, 2)

In [44]: r
Out[44]: range(0, 10, 2)

In [45]: 5 in r
Out[45]: False

In [46]: 6 in r
Out[46]: True

In [47]: r.index(8)
Out[47]: 4

In [48]: r[3]
Out[48]: 6

In [49]: r[:3]
Out[49]: range(0, 6, 2)

In [50]: r[-1]
Out[50]: 8

通过==和!=测试两个range对象的相等性是把它们当做序列进行比较。也就是说，如果两个range对象表示相同的值的序列就认为它们实时相等的。

注意：两个range对象相等但可能含有不同的start，stop和step属性，比如range(0) == range(2, 1, 1)或者range(0, 3, 2) == range(0, 4, 2)。

class slice(stop)
class slice(start, stop[, step])

返回一个切片对象，表示由range(start,stop,step)指定的索引集。start和step参数默认为None。Slice对象具有只读数据属性start，stop和step，它们只返回参数值（或它们的默认值）。他们没有其他明确的功能；但是它们被Numerical Python和其他第三方扩展使用。使用扩展索引语法时也会生成切片对象。例如：a[start:stop:step]或a[start:stop,i]。

class type(object)
class type(name, bases, dict)

传入一个参数object，则返回该对象的类型。返回值是一个type对象，通常和object.__class__返回的一样。
建议使用isinstance（）内置函数来测试对象的类型，因为它需要考虑子类。
使用三个参数，返回一个新类型对象。 这实际上是类语句的动态形式。 名称字符串是类名，并成为name属性; 基元元组列出基类并成为bases属性; 并且dict字典是包含类主体定义的命名空间，并被复制到标准字典以成为dict属性。 例如，以下两个语句创建相同的类型对象：