跳转至

2.12.内置函数

Linux 5.4.0-74-generic
Python 3.9.5 @ GCC 7.3.0
Latest build date 2021.06.20

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()

A

abs(x) - 返回一个数的绝对值

参数可以是一个整数或浮点数。 如果参数是一个复数，则返回它的模。如果 x 定义了 __abs__()，则 abs(x) 将返回 x.__abs__()。

class A:
    def __abs__(self):
        return 10
abs(A())

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

等价于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
any(iterable)：如果 iterable的任一元素为真值则返回 True；如果可迭代对象为空，返回 False

等价于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
ascii(object)：返回对象的ASCII表示形式

类似函数 repr()，返回一个对象可打印的字符串，但是repr() 返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成的字符串和 Python 2 的repr()返回的结果相似。

print(ascii("编码"))
print(repr("编码"))

'\u7f16\u7801'
'编码'

B

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

如果 x 不是 Python 的int对象，那它需要定义 __index__() 方法返回一个整数。

print(bin(2))
print(type(bin(2)))
eval(bin(2)) == 2

0b10
<class 'str'>

True

class B:
    def __index__(self):
        return 10

bin(B())

'0b1010'
class bool([x])：将输入转换为布尔值

bool 是 int 的子类。其他类不能继承自它。它只有 False 和 True 两个实例（参见 布尔值）。

breakpoint(*args, \**kws)：此函数会在调用时进入调试器

具体来说，它调用 sys.breakpointhook() 。默认情况下， sys.breakpointhook() 调用 pdb.set_trace() 且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是， sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用，以允许进入你想用的调试器。

C

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

如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。

def test():
    raise Exception

callable(test)

True
chr(i)：返回 Unicode 码位为整数 i 的字符

这是ord()的逆函数。实参的合法范围是 0 到 1114111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发ValueError异常。

print(chr(97))
print(chr(8364))

a
€

D

delattr(object, name)：如果对象允许，该函数将删除指定的属性

delattr(x, 'foobar') 等价于 del x.foobar。

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

# 整数
print(divmod(10, 5))
print((10//5, 10%5))

# 浮点数
import math

print(divmod(8.5, 5))
print((math.floor(8.5 / 5), 8.5 % 5))

(2, 0)
(2, 0)
(1.0, 3.5)
(1, 3.5)

E

enumerate(iterable, start=0)：返回一个枚举对象

F

filter(function, iterable)：用函数 function 返回真值的 iterable 元素构建一个新的迭代器

该函数相当于一个生成器表达式，当 function 不是 None 的时候，相当于：

(item for item in iterable if function(item))

当 function 是 None 时，相当于：

(item for item in iterable if item)

另外，请参阅 itertools.filterfalse() 了解， 只有 function 返回 false 时才选取 iterable 元素的补充函数。

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

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 '+' 和 '-'。 

float("+5")
float(" +5")
float("NaN")
float("Infinity")
float("inf")
float('+1E6')
class frozenset ([iterable])：返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。有关此类的文档，请参阅 frozenset 和 集合类型 --- set, frozenset。请参阅内建的 set、list、tuple 和 dict 类，以及 collections 模块来了解其它的容器。

G

getattr(object, name[, default])：返回object对象name属性的值

如果指定的属性不存在，且提供了 default 值，则返回default，否则触发 AttributeError。

H

hasattr(object, name)：查看object对象是否具有属性name，如果有则返回 True，否则返回 False

此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。

hash(object)：返回对象的哈希值（如果有的话），哈希值是整数
hex(x)：将整数转换为以“0x”为前缀的小写十六进制字符串

I

id(object)：返回对象的“标识值”

该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id 值。CPython implementation detail: This is the address of the object in memory.

input([prompt])：从标准输出读入用户的输入数据

如果存在 prompt 实参，则将其写入标准输出，并且末尾不带换行符。接着该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。

class int(x, base=10)：返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0

base表示进制，允许的进制有 0、2-36。进制为 0 将安照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。

如果x不是数字类型，则会按以下调用顺序返回值（Python3.8）：

  1. 如果 x 定义了 __int__()，int(x) 将返回 x.__int__()
  2. 如果 x 定义了 __index__()，它将返回 x.__index__()
  3. 如果 x 定义了 __trunc__()，它将返回 x.__trunc__()

如果 x 不是数字，或者传入了 base 参数，那么 x 必须是str、bytes、表示进制为 base 的整数字面值的 bytearray 实例。

isinstance(object, classinfo)：如果object是classinfo的实例或者是其 (直接、间接或 虚拟) 子类则返回 True，否则返回False

如果 classinfo 是类型对象元组（或由其他此类元组递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。如果 classinfo 既不是类型，也不是类型元组或类型元组的元组，则将引发 TypeError 异常。

class A:
    pass

class B(A):
    pass

c = B()
print(isinstance(c, A))
print(isinstance(c, (B, str)))

True
True

try:
    isinstance(c, "C")
except TypeError as e:
    print(e)

isinstance() arg 2 must be a type or tuple of types
issubclass(class, classinfo)：如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True

类会被视作其自身的子类。classinfo 也可以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。在任何其他情况下，都将引发 TypeError 异常。

iter(object[, sentinel])：返回一个iterator对象
  1. 当只传入实参object时，object必须是支持迭代协议（__iter__() 方法）的集合对象，或必须支持序列协议（__getitem__() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError。
  2. 如果传入实参object和第二个实参sentinel，那么 object必须是可调用的对象。在这种情况下生成的迭代器，每次迭代调用它的 __next__() 方法时都会不带参数调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

另请参阅 迭代器类型。适合 iter() 的应用之一是构建块读取器。例如，从二进制数据库文件中读取固定宽度的块，直至到达文件的末尾。

L

len(s)

M

map(function, iterable, ...)：依次将iterable的元素输入函数function，全部输出结果以迭代器的形式返回

如果function需要多个参数，则需要传入多个iterable参数，function从所有可迭代对象中并行获取参数。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。对于函数的输入已经是参数元组的情况，请参阅 itertools.starmap()。

max()：返回可迭代对象中最大的元素，或者返回多个实参中最大的元素 
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
  1. 如果只提供了一个位置参数，它必须是非空 iterable，iterable最大的元素会被返回。
  2. 如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选且只能用关键字的参数：

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

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

class memoryview(object)：返回由给定实参创建的“内存视图”对象

有关详细信息，请参阅 内存视图。

min()：返回可迭代对象中最小的元素，或者返回多个实参中最小的元素 
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value

N

next(iterator[, default])：通过调用 iterator 的 __next__() 方法获取下一个元素

如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

O

oct(x)：将一个整数转变为前缀为“0o”的八进制字符串

结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__() 方法返回一个整数。

ord(c)：返回单个 Unicode 字符的 Unicode 码位，以10进制数表示

例如 ord('a') 返回整数 97， ord('€') 返回 8364 。这是 chr() 的逆函数。

P

pow(base, exp[, mod])
print(objects, sep=' ', end='\n', file=sys.stdout, flush=False)：将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end

如果要传入sep、end、file 和 flush参数，则必须以关键字参数的形式传入。

sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。如果没有给出 objects，则 print() 函数将只写入 end。

file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。

由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。对于二进制模式的文件对象，应改用 file.write(...)。

输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。该参数在 Python 3.3 中增加进来。

Q

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

R

repr(object)：返回object的可打印表示形式的字符串

对于许多类型来说，该函数尝试返回的字符串将会与该对象被传递给 eval() 函数所生成的对象具有相同的值。类可以通过定义 __repr__() 方法来控制此函数为它的实例所返回的内容。

reversed(seq)：返回一个逆序的 iterator

seq必须是一个具有 __reversed__() 方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的 __len__() 方法和 __getitem__() 方法）。

round(number[, ndigits])：返回 number 舍入到小数点后ndigits位精度的值

如果ndigits被省略或为 None，则返回最接近输入值的整数。任何整数值都可作为有效的 ndigits(正数、零或负数)。对于支持 round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits次幂的倍数；如果与两个倍数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而 round(1.5) 为 2)。 对于一般的 Python 对象 number, round 将委托给 number.__round__。

对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅 浮点算术：争议和限制 了解更多信息。

round(2.675, 2)

2.67

S

setattr(object, name, value)：给object设置name属性的值

此函数与 getattr() 相对应。setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

class slice() 
class slice(stop)
class slice(start, stop[, step])
sorted(iterable, key=None, reverse=False)：根据 iterable 中的项返回一个新的已排序列表
  • key：指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。使用 functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。
  • reverse：布尔值。如果设为 True，则每个列表元素将按反向顺序比较进行排序。

内置的 sorted() 确保是稳定的。如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的。稳定排序有利于进行多重排序（例如先按部门、再按薪级排序）。有关排序示例和简要排序教程，请参阅 排序指南 。

a = ["a", "aa", "aaa"]
print(sorted(a, key=len))
print(sorted(a, key=len, reverse=True))

['a', 'aa', 'aaa']
['aaa', 'aa', 'a']
sum(iterable, start=0)

T

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

传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。 推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式。

  • name 字符串即类名并且会成为 __name__ 属性
  • bases 元组列出基类并且会成为 __bases__ 属性
  • dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性

另请参阅 类型对象。

3.6 版更改: type 的子类如果未重载 type.__new__，将不再能使用一个参数的形式来获取对象的类型。

class T:
    pass

print(T.__class__)
print(type(T))

<class 'type'>
<class 'type'>

X = type('X', (object,), dict(a=1))

class X:
    a = 1

V

vars([object])：返回模块、类、实例或任何其它具有__dict__属性的对象的__dict__属性

模块和实例这样的对象具有可更新的__dict__属性，但是其它对象的__dict__属性可能会设为限制写入。例如，类会使用 types.MappingProxyType 来防止直接更新字典。不带参数时，vars() 的行为类似 locals()。 请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。

Z

zip(iterables)：创建一个聚合了来自每个可迭代对象中的元素的迭代器 
a = [1, 2, 3]
b = ["a", "b", "c", "d"]
for i, j in zip(a, b):
    print(i, j)

1 a
2 b
3 c