Python的69个内置函数(更新中）

		内置函数
01.abs()	15.delattr()	29.hash()	43.memoryview()	57.set()
02.all()	16.dict()	30.help()	44.min()	58.setattr()
03.any()	17.dir()	31.hex()	45.next()	59.slice()
04.ascii()	18.divmod()	32.id()	46.object()	60.sorted()
05.bin()	19.enumerate()	33.input()	47.oct()	61.staticmethod()
06.bool()	20.eval()	34.int()	48.open()	62.str()
07.breakpoint()	21.exec()	35.isinstance()	49.ord()	63.sum()
08.bytearray()	22.filter()	36.issubclass()	50.pow()	64.super()
09.bytes()	23.float()	37.iter()	51.print()	65.tuple()
10.callable()	24.format()	38.len()	52.property()	66.type()
11.chr()	25.frozenset()	39.list()	53.range()	67.vars()
12.classmethod()	26.getattr()	40.locals()	54.repr()	68.zip()
13.compile()	27. globals()	41.map()	55.reversed()	69.__import__()
14.complex()	28.hasattr()	42.max()	56.round()

1.abs()

参数形式：abs(x)

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

举例：

>>>abs(-15)
15
>>>abs(3+4j)
5.0

2.all()

参数形式：all(iterable)

如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False。 等价于:

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

举例：

>>> all([1,0,1])
False
>>> all([1,1,1])
True

3.any()

参数形式：any(iterable)

如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False。 等价于:

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

举例:

>>>any([1,0,1])
True
>>>any([0,0,0])
False

4.ascii()

参数形式：ascii(object)

5.bin()

参数形式：bin(x)

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

一些例子：

>>>bin(3)
'0b11'
>>>bin(-10)
'-0b1010'

>>> type(bin(1))
<class 'str'>
>>> eval(bin(1))
1
>>> 0b1111
15

6.bool()

参数形式：bool(x)

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

bool(x)返回一个布尔值———True 或者 False。 x 使用标准的真值测试过程来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True.

例子：

>>> type(False)
<class 'bool'>
>>> bool([1])
True
>>> bool([])
False

7.breakpoint()

参数形式：breakpoint(*args, **kws)

8.bytearray()

参数形式：bytearray([source[, encoding[, errors]]])

9.bytes()

参数形式：bytes([source[, encoding[, errors]]])

10.callable()

参数形式：callable(object)

如果参数 object 是可调用的就返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 则它就是可调用的。

例子：

>>> callable(str)
True
>>> callable(print)
True
>>> callable(False)
False

11.chr()

参数形式：chr(i)

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

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

例子：

>>> chr(65)
'A'
>>> chr(1028)
'Є'

12.classmethod()

参数形式：@classmethod

把一个方法封装成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): 
    ...

@classmethod 这样的形式称为函数的装饰器

类方法的调用可以在类上进行 (例如 C.f()), 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

13.compile()

参数形式：compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

14.complex()

参数形式：class complex([real[, imag]])

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。

第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。 如果 __complex__() 未定义则将回退至 __float__()。 如果 __float__() 未定义则将回退至 __index__()。

注意：
当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j')会触发 ValueError 异常。

举例：

>>> complex()
0j
>>> complex("15")
(15+0j)
>>> complex(15)
(15+0j)

15.delattr()

参数形式：delattr(object, name)

实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如 delattr(x, 'foobar')等价于 del x.foobar。

16.dict()

参数形式：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

创建一个新的字典。dict 对象是一个字典类。

17.dir()

参数形式：dir([object])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为 __dir__() 的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义 __getattr__() 或 __getattribute__() 函数的对象能够自定义 dir() 来报告它们的属性。

如果对象不提供 __dir__()，这个函数会尝试从对象已定义的 __dict__ 属性和类型对象收集信息。结果列表并不总是完整的，如果对象有自定义 __getattr__()，那结果可能不准确。

默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

• 如果对象是模块对象，则列表包含模块的属性名称。
• 如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
• 否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

返回的列表按字母表排序。

举例：

import struct
>>>dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>>dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>>class Shape:
...    def __dir__(self):
...        return ['area', 'perimeter', 'location']
>>>s = Shape()
>>>dir(s)
['area', 'location', 'perimeter']

注意：
因为 dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

18.divmod()

参数形式：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) 。

举例：

>>> divmod(15,2)
(7, 1)
>>> divmod(-15,2)
(-8, 1)
>>> divmod(15,-2)
(-8, -1)
>>> divmod(15.5,2.1)
(7.0, 0.7999999999999994)

19.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(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

20.eval()

参数形式：eval(expression[, globals[, locals]])

简单来说,使用eval()去掉字符串两侧的双引号，从而将其作为Python表达式执行。

expression是一个字符串，可选参数globals是一个字典，而locals是任意映射对象。

expression参数会作为一个 Python 表达式（从技术上说是一个条件列表）被解析并求值，并使用 globals 和 locals 字典作为全局和局部命名空间。 如果 globals 字典存在且不包含以 __builtins__ 为键的值，则会在解析 expression 之前插入以此为键的对内置模块 builtins 的引用。 这意味着 expression 通常具有对标准 builtins 模块的完全访问权限且受限的环境会被传播。 如果省略 locals 字典则其默认值为 globals 字典。 如果两个字典同时省略，则表达式执行时会使用 eval() 被调用的环境中的 globals 和 locals。 请注意，eval() 并没有对外围环境下的 (非局部) 嵌套作用域 的访问权限。

返回值就是表达式的求值结果。 语法错误将作为异常被报告。

举例：

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

这个函数也可以用来执行任何代码对象（如 compile() 创建的）。这种情况下，参数是代码对象，而不是字符串。如果编译该对象时的 mode 实参是 ‘exec’ 那么 eval() 返回值为 None 。

提示： exec() 函数支持动态执行语句。 globals() 和 locals() 函数各自返回当前的全局和本地字典，因此您可以将它们传递给 eval() 或 exec() 来使用。

21.exec()

22.filter()

23.float()

完整形式：class float([x])

返回由数字或字符串生成的浮点数

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 ‘+’ 和 ‘-’ ； ‘+’ 对创建的值没有影响。实参也可以是 NaN（非数字）、正负无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

这里， floatnumber 是 Python 浮点数的字符串形式，详见 浮点数字面值。字母大小写都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正无穷大。

另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。

对于一个普通 Python 对象 x，float(x) 会委托给 x.__float__()。 如果__float__() 未定义则将回退至 __index__()。

如果没有实参，则返回 0.0 。

举例：

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

24.format()

完整形式：format(value[, format_spec])

将 value 转换为 format_spec 控制的“格式化”表示。format_spec 的解释取决于 value 实参的类型，但是大多数内置类型使用标准格式化语法。

默认的 format_spec 是一个空字符串，它通常和调用 str(value) 的结果相同。

调用 format(value, format_spec) 会转换成 type(value).__format__(value, format_spec) ，所以实例字典中的 __format__() 方法将不会调用。如果搜索到 object 有这个方法但 format_spec 不为空，format_spec 或返回值不是字符串，会触发 TypeError 异常。

25.frozenset()

完整形式：class frozenset([iterable])

返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类，即不可变的集合。

26.getattr()

完整形式：getattr(object, name[, default])

返回对象已命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如， getattr(x, 'foobar') 等同于 x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。

27.globals()

完整形式：globals()

返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

28.hasattr()

完整形式：hasattr(object, name)

该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。（此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）

29.hash()

完整形式：hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1和 1.0）。

注意：如果对象实现了自己的 __hash__()方法，hash() 根据机器的字长来截断返回值。

30.help()

完整形式：help([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

请注意如果在函数的形参列表中出现了斜杠 (/)，则它在发起调用 help() 的时候意味着斜杠之前的均为仅限位置形参。

该函数通过 site 模块加入到内置命名空间。

31.hex()

完整形式：hex(x)

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

举例：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

32.id()

完整形式：id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的，表示该对象在内存中的位置。两个生命期不重叠的对象可能具有相同的 id() 值。

33.input()

完整形式：input([prompt])

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

举例：

>>> s = input(请输入：)
请输入：这是一个例子
>>> s
这是一个例子

34.int()

完整形式：
class int([x])
class int(x, base=10)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。 如果 x 定义了 __int__()，int(x) 将返回 x.__int__()。 如果 x 定义了 __index__()，它将返回 x.__index__()。 如果 x 定义了 __trunc__()，它将返回 x.__trunc__()。 对于浮点数，它将向零舍入。

base参数表示x的进制，即将x视为base进制解读并转换为10进制。

如果 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) 是合法的。

举例：

>>> int(2)
2
>>> int('111',2)
7

35.isinstance()

完整形式：isinstance(object, classinfo)

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True。 如果 object 不是给定类型的对象，函数将总是返回 False。 如果 classinfo 是类型对象元组（或由其他此类元组递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。 如果 classinfo 既不是类型，也不是类型元组或类型元组的元组，则将引发 TypeError 异常。

举例：

>>> isinstance(1,int)
True
>>> isinstance(1,(int,str))
True
>>> isinstance(1,str)
False

36.issubclass()

完整形式：issubclass(class, classinfo)

如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True。 类会被视作其自身的子类。 classinfo 也以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。 在任何其他情况下，都将引发 TypeError 异常。

举例：

>>> issubclass(int,object)
True
>>> issubclass(bool,(int,object))
True
>>> issubclass(int,(str,object))
True
>>> issubclass(int,str)
False

37.iter()

完整形式：iter(object[, sentinel])

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

举例：

>>> a = iter([1,2,3])
>>> for i in a:
		print(i,end=',')

1,2,3

38.len()

完整形式：len(s)

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

举例：

>>> len("宇梵文书")
4
>>> len([5,2,1])
3

39.list()

完整形式：class list([iterable])

实参iterable是一个可迭代对象，list()根据iterable生成并返回一个列表list对象。如果参数被省略，则返回一个空列表。

举例：

>>> list()
[]
>>> list((1,2,3))
[1,2,3]

40.locals()

完整形式：locals()

更新并返回表示当前本地符号表的字典。 在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。 请注意在模块层级上，locals() 和 globals() 是同一个字典。

不要更改此字典的内容；更改不会影响解释器使用的局部变量或自由变量的值。

41.map()

完整形式：map(function, iterable, …)

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。 如果传入了多个 iterable 参数，function 每次按顺序从各iterable对象中获取一个值作为参数，即传入几个iterable函数function每次就接受几个参数。 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。

举例：

>>> a = [1,2,3]
>>> [i for i in map(float,a)]
[1.0, 2.0, 3.0]
>>> b = [1,2,3,4,5]
>>> [j for j in map(divmod,a,b)]
[(1, 0), (1, 0), (1, 0)]

42.max()

完整形式：
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)保持一致。

举例：

>>> a
[100, 200, 300]
>>> b
[1, 2, 3, 4, 5]
>>> max(a)
300
>>> max(a,b)
[100, 200, 300]
>>> max(a,b,key=len)
[1, 2, 3, 4, 5]

43.memoryview()

完整形式：class memoryview(obj)

返回由给定实参创建的“内存视图”对象

44.min()

完整形式：
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

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

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

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

举例：

>>> a
[100, 200, 300]
>>> b
[1, 2, 3, 4, 5]
>>> min(a)
100
>>> min(a,b)
[1, 2, 3, 4, 5]
>>> min(a,b,key=len)
[100, 200, 300]

45.next()

完整形式：next(iterator[, default])

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

46.object()

完整形式：class objec()

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

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

47.oct()

完整形式：oct(x)

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

举例：

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

48.open()

完整形式：open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打开 file 并返回对应的 file object。 如果该文件不能被打开，则引发 OSError。 请参阅 读写文件 获取此函数的更多用法示例。

file 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）

mode 是一个可选字符串，用于指定打开文件的模式。默认值是 ‘r’ ，这意味着它以文本模式打开并读取。其他常见模式有：写入 ‘w’ （截断已经存在的文件）；排它性创建 ‘x’ ；追加写 ‘a’ （在 一些 Unix 系统上，无论当前的文件指针在什么位置，所有 写入都会追加到文件末尾）。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）可用的模式有：

字符	意义
'r'	读取（默认）
'w'	写入，并先截断文件
'x'	排它性创建，如果文件已存在则失败
'a'	写入，如果文件存在则在末尾追加
'b'	二进制模式
't'	文本模式（默认）
'+'	打开用于更新（读取与写入）

默认模式为 'r' (打开用于读取文本，与 'rt' 同义)。 模式 'w+' 与 'w+b' 将打开文件并清空内容。 模式 'r+' 与 'r+b' 将打开文件并不清空内容。

49.ord()

完整形式：ord©

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

举例：

>>> ord('a')
97
>>> ord('€')
8364

50.pow()

完整形式：pow(base, exp[, mod])

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

参数必须具有数值类型。 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10**\2 返回 100，但 10**-2 返回 0.01。

51.