python内置函数

Posted 2021-02-14 pantong

官网链接

1.abs(x)

　　返回绝对值

2.all(iterable)

　　如果 iterable 的所有元素为真（或迭代器为空），返回 True 。等价于:

1 def all(iterable):
2     for element in iterable:
3         if not element:
4             return False
5     return True

3.any(iterable)

　　如果iterable的任一元素为真则返回True。如果迭代器为空，返回False.

4.ascii(object)

　　调用对象的__repr__()方法，获得该方法的返回值.

5.bin(x)

　　转二进制，如需去掉0b可以使用format，详细见format

1 >>> bin(14)
2 ‘0b1110‘
3 >>> format(14,"#b")
4 ‘0b1110‘
5 >>> format(14,"b")
6 ‘1110‘

6.bool()

　　用于测试对象是True或False

7.breakpoint(*args,**kwargs)

　　用于调试，3.7新版功能

8.bytearry([source[, encoding[, errors]]])

　　返回一个新的bytes数组

• 如果它是一个字符串，那么您还必须给出编码(以及可选的错误)参数;bytearray()然后使用str.encode()将字符串转换为字节。
• 如果它是一个整数，那么数组将具有这个大小，并将用null字节初始化。
• 如果它是符合缓冲区接口的对象，则将使用对象的只读缓冲区来初始化字节数组。
• 如果它是可迭代的，那么它必须是range 0 < = x < 256的整数的迭代，它被用作数组的初始内容

9.bytes([source[, encoding[, errors]]])

　　返回一个新的“bytes”对象

10.callable(object)

　　实参object可调用，返回True，否则返回False,如果有__call__()方法，则会被调用

11.chr(i)

　　返回Unicode码为整数 i 对应的字符串格式，为ord() 逆函数

12.classmethod

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

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

　　

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

13.compile

　　可以用来提取Python语句

1 code = "for i in range(10):print(i)"
2 c = compile(code, "", "exec")
3 print(c)
4 exec(c)

namespace = {"name": "root", "data": [18, 24, 30]}
code = "def hello():return ‘name %s ,age %d‘ % (name, data[1])"
func = compile(code, "", "exec")
# 将函数hello添加到namespace中，key为hello，另外将namespace的字段添加到全局变量
exec(func, namespace)
result1 = namespace["hello"]()
print(result1)

14.complex

　　复数

15.delatter(object, name)

　　删除属性 delatter(student, "name") 等价于 del student.name

16.dict()

　　创建字典

17.dir([onject])

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

　　

 1 >>> a = list([1,2,3])
 2 >>> dir()
 3 [‘__annotations__‘, ‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘a‘]
 4 >>> dir(a)
  [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, 
  ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, 
  ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__init_subclass__‘, 
  ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, 
  ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, 
   ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘,
   ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]

18.divmod(a,b)

　　返回元祖  (x//y, x%y)，(整除数,余数)

　　

1 In [1]: divmod(17,4)
2 Out[1]: (4, 1)

19.enumerate(iterable, start=0)

　　返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。

　　

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

等价于

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

20.eval(expression, globals=None, locals=None)

 

　　实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。

　　

1 >>> x = 1
2 >>> eval(‘x+1‘)
3 2
4 >>> eval("3+3")
5 6

21.exec()

　　这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）

22.filter(function, iterable)

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

1 >>> filter(lambda x : x % 2 == 0, [1,2,3,4,5])
2 <filter object at 0x00000215737D1588>
3 >>> list(filter(lambda x : x % 2 == 0, [1,2,3,4,5]))
4 [2, 4]

23.float()

　　浮点数

24.format(value[, format_spec])

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

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

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

25.frozenset()

　　不可变集合

26.getattr(object, name[, default])

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

27.globals()

　　返回当前全局符号表字典，global()

　　- global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。

　　- 你可以使用同一个global语句指定多个全局变量。例如global x, y, z。

28.hasattr(object, name)

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

29.hash(object)

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

30.help([object])

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

31.hex(x)

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

1 >>> hex(255)
2 ‘0xff‘
3 >>> hex(-42)
4 ‘-0x2a‘

 

如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，则可以使用如下方法：

1 >>> ‘%#x‘ % 255, ‘%x‘ % 255, ‘%X‘ % 255
2 (‘0xff‘, ‘ff‘, ‘FF‘)
3 >>> format(255, ‘#x‘), format(255, ‘x‘), format(255, ‘X‘)
4 (‘0xff‘, ‘ff‘, ‘FF‘)
5 >>> f‘{255:#x}‘, f‘{255:x}‘, f‘{255:X}‘
6 (‘0xff‘, ‘ff‘, ‘FF‘)

另见 format() 获取更多信息。

另请参阅 int() 将十六进制字符串转换为以 16 为基数的整数。

注解

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

32.id(object)

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

33.input([prompt])

用于接收用户输入

34.int([x])

返回一个使用数字或字符串 x 生成的整数对象，或者没有实参的时候返回 0 

1 >>> int("10101",2)
2 21
3 >>> int(128)
4 128
5 >>> int("1234",8)
6 668

35.isinstance(object, classinfo)

如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或 虚拟）子类的实例，则返回 true。如果 object 不是给定类型的对象，函数始终返回 false。如果 classinfo 是对象类型（或多个递归元组）的元组，如果 object 是其中的任何一个的实例则返回 true。 如果 classinfo 既不是类型，也不是类型元组或类型的递归元组，那么会触发 TypeError 异常。

36.issubclass(class, classinfo)

如果 class 是 classinfo 的子类（直接、间接或 虚拟 的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。

37.iter(object[, sentinel])

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

另请参阅 Iterator Types。

适合 iter() 的第二种形式的应用之一是构建块读取器。 例如，从二进制数据库文件中读取固定宽度的块，直至到达文件的末尾:

1 from functools import partial
2 with open(‘mydata.db‘, ‘rb‘) as f:
3     for block in iter(partial(f.read, 64), b‘‘):
4         process_block(block)

38.len(s)

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

39.list([iterable])

用于创建列表

40.locals()

更新并返回表示当前本地符号表的字典。在函数块而不是类块中调用 locals() 时会返回自由变量。

注解：

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

41.map(function, iterable, ...)

产生一个将 function 应用于迭代器中所有元素并返回结果的迭代器。如果传递了额外的 iterable 实参，function 必须接受相同个数的实参，并使用所有迭代器中并行获取的元素。当有多个迭代器时，最短的迭代器耗尽则整个迭代结束。

1 >>> map(lambda x:x*x, [1,2,3,4])
2 <map object at 0x000001D8BB9D1860>
3 >>> list(map(lambda x:x*x, [1,2,3,4]))
4 [1, 4, 9, 16]

42.max(iterable, *[, key, default])，max(arg1, arg2, *args[, key])

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

43.memoryview(obj)

返回由给定实参创建的“内存视图”对象。有关详细信息，请参阅 Memory Views。

44.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) 保持一致。

3.4 新版功能: keyword-only 实参 default 。

45.next(iterator[, default])

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

46.class object

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

注解：

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

47.oct(x)

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

1 >>> oct(8)
2 ‘0o10‘
3 >>> oct(-56)
4 ‘-0o70‘

 

如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：

1 >>> ‘%#o‘ % 10, ‘%o‘ % 10
2 (‘0o12‘, ‘12‘)
3 >>> format(10, ‘#o‘), format(10, ‘o‘)
4 (‘0o12‘, ‘12‘)
5 >>> f‘{10:#o}‘, f‘{10:o}‘
6 (‘0o12‘, ‘12‘)

另见 format() 获取更多信息。

48.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+b‘ 模式打开并把文件截断成 0 字节； ‘r+b‘ 则不会截断。

 

 Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。

encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。

errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在 Error Handlers ），但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。

1 >>> import os
2 >>> dir_fd = os.open(‘somedir‘, os.O_RDONLY)
3 >>> def opener(path, flags):
4 ...     return os.open(path, flags, dir_fd=dir_fd)
5 ...
6 >>> with open(‘spamspam.txt‘, ‘w‘, opener=opener) as f:
7 ...     print(‘This will be written to somedir/spamspam.txt‘, file=f)
8 ...
9 >>> os.close(dir_fd)  # don‘t leak a file descriptor

49.ord(c)

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

50.pow(x, y[, z])

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

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

51.print(*objects, sep=‘ ‘, end=‘ ‘, file=sys.stdout, flush=False)

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。 如果没有给出 objects，则 print() 将只写入 end。

file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。 对于这些对象，应改用 file.write(...)。

 

52.class property(fget=None, fset=None, fdel=None, doc=None)

返回 property 属性。

fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。

一个典型的用法是定义一个托管属性 x:

 1 class C:
 2     def __init__(self):
 3         self._x = None
 4 
 5     def getx(self):
 6         return self._x
 7 
 8     def setx(self, value):
 9         self._x = value
10 
11     def delx(self):
12         del self._x
13 
14     x = property(getx, setx, delx, "I‘m the ‘x‘ property.")

 

如果 c 是 C 的实例，c.x 将调用getter，c.x = value 将调用setter， del c.x 将调用deleter。

如果给出，doc 将成为该 property 属性的文档字符串。 否则该 property 将拷贝 fget 的文档字符串（如果存在）。 这令使用 property() 作为 decorator 来创建只读的特征属性可以很容易地实现:

1 class Parrot:
2     def __init__(self):
3         self._voltage = 100000
4 
5     @property
6     def voltage(self):
7         """Get the current voltage."""
8         return self._voltage

以上 @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 "getter"，并将 voltage 的文档字符串设置为 "Get the current voltage."

特征属性对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。 这最好是用一个例子来解释:

 1 class C:
 2     def __init__(self):
 3         self._x = None
 4 
 5     @property
 6     def x(self):
 7         """I‘m the ‘x‘ property."""
 8         return self._x
 9 
10     @x.setter
11     def x(self, value):
12         self._x = value
13 
14     @x.deleter
15     def x(self):
16         del self._x

 

上述代码与第一个例子完全等价。 注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为 x。)

返回的特征属性对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。

在 3.5 版更改: 特性属性对象的文档字符串现在是可写的。

53.range(stop),range(start, stop[, step])

虽然被称为函数，但 range 实际上是一个不可变的序列类型.

54.repr(object)

返回包含一个对象的可打印表示形式的字符串。 对于许多类型来说，该函数会尝试返回的字符串将会与该对象被传递给 eval() 时所生成的对象具有相同的值，在其他情况下表示形式会是一个括在尖括号中的字符串，其中包含对象类型的名称与通常包括对象名称和地址的附加信息。 类可以通过定义 __repr__() 方法来控制此函数为它的实例所返回的内容。

55.reversed(seq)

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

56.round(number[, ndigits])

返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

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

57.class set([iterable])

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。 请查看 set 和 Set Types --- set, frozenset 获取关于这个类的文档。

有关其他容器请参看内置的 frozenset, list, tuple 和 dict 类，以及 collections 模块。

58.setattr(object, name, value)

此函数与 getattr() 两相对应。 其参数为一个对象、一个字符串和一个任意值。 字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性，只要对象允许这种操作。 例如，setattr(x, ‘foobar‘, 123) 等价于 x.foobar = 123。

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

返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。 其中 start 和 step 参数默认为 None。 切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。 它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用。 切片对象也会在使用扩展索引语法时被生成。 例如: a[start:stop:step] 或 a[start:stop, i]。 请参阅 itertools.islice() 了解返回迭代器的一种替代版本。

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

根据 iterable 中的项返回一个新的已排序列表。

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

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

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

使用 functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。

内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序（例如先按部门、再按薪级排序）。

有关排序示例和简要排序教程，请参阅 排序指南 。

[email protected]staticmethod

　　

　　将方法转换为静态方法。

　　静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

1 class C:
2     @staticmethod
3     def f(arg1, arg2, ...): ...

 

　　@staticmethod 形式函数是一个 decorator 函数 - 参阅 函数定义 中的函数定义说明，有更详细的信息。

　　它可以在类（例如 C.f() ）或实例（例如 C().f() ）上调用。实例会被忽略，只需要类本身。

　　Python中的静态方法与Java或C ++中的静态方法类似。另请参阅 classmethod() ，用于创建备用类构造函数的变体。

　　像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。

62.str()

　　返回一个str的object

63.sumiterable[, start]

　　从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为 0。 iterable 的项通常为数字，开始值则不允许为字符串。

64.super([type[, object-or-type]])

　　用于执行父类的方法

1 class C(B):
2     def method(self, arg):
3         super().method(arg)    # This does the same thing as:
4                                # super(C, self).method(arg)

 

65.tuple()

　　返回元祖，元祖不可变

66.type(object)

　　返回对象类型

 1 >>> type("a")
 2 <class ‘str‘>
 3 >>> type(11)
 4 <class ‘int‘>
 5 >>> class Foo:
 6 ...     pass
 7 ...
 8 >>> f = Foo()
 9 >>> type(f)
10 <class ‘__main__.Foo‘>

　　class type(name, bases, dict)

1 >>> class X:
2 ...     a = 1
3 ...
4 >>> X = type(‘X‘, (object,), dict(a=1))
5 # 可用于创建类

 

67.vars[object]

　　返回模块，类，实例，或任何其他类的__dict__ 属性

　　

1 >>> class Foo:
2 ...     a=1
3 ...     pass
4 ...
5 >>> vars(Foo)
6 mappingproxy({‘__module__‘: ‘__main__‘, ‘a‘: 1, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Foo‘ objects>, 
‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Foo‘ objects>, ‘__doc__‘: None})

68.zip(*iterables)

 1 def zip(*iterables):
 2     # zip(‘ABCD‘, ‘xy‘) --> Ax By
 3     sentinel = object()
 4     iterators = [iter(it) for it in iterables]
 5     while iterators:
 6         result = []
 7         for it in iterators:
 8             elem = next(it, sentinel)
 9             if elem is sentinel:
10                 return
11             result.append(elem)
12         yield tuple(result)

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

69.__import__(name, globals=None, locals=None, fromlist=(), level=0)

　　1. 函数功能用于动态的导入模块，主要用于反射或者延迟加载模块。

　　2. __import__(module)相当于import module

index = __import__(‘index‘)
# 等价于
import index