oct(x)

将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__() 方法返回一个整数。一些例子：
>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'
如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

举例：

num = 126
print(oct(num))
num = 100
print(oct(num))
num = 64
print(oct(num))

0o176
0o144
0o100

48.open()

说明：open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

关于open函数，后期会专本出该函数的专题，全面讲解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+b' 模式打开并把文件截断成 0 字节； 'r+b' 则不会截断。

正如在概述中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 'b' ）返回的内容为 bytes`对象，不进行任何解码。在文本模式下（默认情况下，或者在 *mode* 参数中包含 `'t'` ）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

此外还允许使用一个模式字符 'U'，该字符已不再具有任何效果，并被视为已弃用。之前它会在文本模式中启用 universal newlines，这在 Python 3.0 中成为默认行为。请参阅 newline 形参的文档了解更多细节。

注解

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

buffering 是一个可选的整数，用于设置缓冲策略。传递0以切换缓冲关闭（仅允许在二进制模式下），1选择行缓冲（仅在文本模式下可用），并且>1的整数以指示固定大小的块缓冲区的大小（以字节为单位）。如果没有给出 buffering 参数，则默认缓冲策略的工作方式如下:

二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。

“交互式”文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。

encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是依赖于平台的（不管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有关支持的编码列表，请参阅 codecs 模块。

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

如果存在编码错误，'strict' 会引发 ValueError 异常。默认值 None 具有相同的效果。

'ignore' 忽略错误。请注意，忽略编码错误可能会导致数据丢失。

'replace' 会将替换标记（例如 '?' ）插入有错误数据的地方。

'surrogateescape' 将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时，这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。

只有在写入文件时才支持 'xmlcharrefreplace'。编码不支持的字符将替换为相应的XML字符引用 &#nnn;。

'backslashreplace' 用Python的反向转义序列替换格式错误的数据。

'namereplace' （也只在编写时支持）用 \N{...} 转义序列替换不支持的字符。

newline 控制 universal newlines 模式如何生效（它仅适用于文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。它的工作原理:

从流中读取输入时，如果 newline 为 None，则启用通用换行模式。输入中的行可以以 '\n'，'\r' 或 '\r\n' 结尾，这些行被翻译成 '\n' 在返回呼叫者之前。如果它是 ''，则启用通用换行模式，但行结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行结尾将返回给未调用的调用者。

将输出写入流时，如果 newline 为 None，则写入的任何 '\n' 字符都将转换为系统默认行分隔符 os.linesep。如果 newline 是 '' 或 '\n'，则不进行翻译。如果 newline 是任何其他合法值，则写入的任何 '\n' 字符将被转换为给定的字符串。

如果 closefd 是 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出文件名则 closefd 必须为 True （默认值），否则将引发错误。

可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

新创建的文件是不可继承的。

下面的示例使用 os.open() 函数的 dir_fd 的形参，从给定的目录中用相对路径打开文件:

>>>
>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor
open() 函数所返回的 file object 类型取决于所用模式。当使用 open() 以文本模式 ('w', 'r', 'wt', 'rt' 等) 打开文件时，它将返回 io.TextIOBase (特别是 io.TextIOWrapper) 的一个子类。当使用缓冲以二进制模式打开文件时，返回的类是 io.BufferedIOBase 的一个子类。具体的类会有多种：在只读的二进制模式下，它将返回 io.BufferedReader；在写入二进制和追加二进制模式下，它将返回 io.BufferedWriter，而在读/写模式下，它将返回 io.BufferedRandom。当禁用缓冲时，则会返回原始流，即 io.RawIOBase 的一个子类 io.FileIO。

另请参阅文件操作模块，例如 fileinput、io （声明了 open()）、os、os.path、tempfile 和 shutil。

在 3.3 版更改:

增加了 opener 形参。

增加了 'x' 模式。

过去触发的 IOError，现在是 OSError 的别名。

如果文件已存在但使用了排它性创建模式（ 'x' ），现在会触发 FileExistsError。

在 3.4 版更改:

文件现在禁止继承。

Deprecated since version 3.4, will be removed in version 3.9: 'U' 模式。

在 3.5 版更改:

如果系统调用被中断，但信号处理程序没有触发异常，此函数现在会重试系统调用，而不是触发 InterruptedError 异常 (原因详见 PEP 475)。

增加了 'namereplace' 错误处理接口。

在 3.6 版更改:

增加对实现了 os.PathLike 对象的支持。

在 Windows 上，打开一个控制台缓冲区将返回 io.RawIOBase 的子类，而不是 io.FileIO。

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

备注：open函数会在后面章节中单独讲解，这里仅做了解。

49.`ord`()

说明：ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

ord(c)

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

正确使用举例：

print(ord('a'))

错误示范：

print(ord('aa'))

    print(ord('aa'))
TypeError: ord() expected a character, but string of length 2 found

50.`pow`()

说明：pow() 方法返回 xy（x的y次方）的值。

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 必须为非负数。

举例：

print(pow(2,4))

print(pow(5,3))

51.`print`()

说明：打印，python中最为常见最为易懂的内置函数，没有之一。唯一要注意的是print函数的参数用法：

def print(self, *args, sep=' ', end='\n', file=None):

print(*objects, sep=' ', end='\n', 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(...)。

输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。

在 3.3 版更改: 增加了 flush 关键字参数。

举例：

print('hello world')

hello world

52. `property`()

说明：property() 函数的作用是在新式类中返回属性值。

说明：

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

返回 property 属性。

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

一个典型的用法是定义一个托管属性 x:
class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    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 来创建只读的特征属性可以很容易地实现:
class Parrot:
    def __init__(self):
        self._voltage = 100000

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

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

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

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

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

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

备注：类和对象的内置函数会放到后面再统一学习，这里仅了解即可。

53.`range`()

说明：range函数用来表示一个范围,range() 函数可创建一个整数列表，一般用在 for 循环中。和分片概念一样，取左不去右，range(1,10)表示1——9这9个数字，不包含10。

class range(stop)

class range(start, stop[, step])

虽然被称为函数，但 range 实际上是一个不可变的序列类型，参见在 range 对象与序列类型 --- list, tuple, range 中的文档说明。

print(range(1,10))
print(type(range(1,10)))
for i in range(1,10):
    print(i)

range(1, 10)
<class 'range'>
1
2
3
4
5
6
7
8
9

54.repr()

说明：repr() 函数将对象转化为供解释器读取的形式。也就是repr函数会将对象转换为字符串类型。

repr(object)

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

举例：

lst = ['a','b','c']
print(repr(lst))
print(type(repr(lst)))

['a', 'b', 'c']
<class 'str'>

55.`reversed`()

说明：reversed 函数返回一个反转的迭代器。顾名思义，该函数用于反转。

reversed(seq)

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

举例：

lst = ['a','b','c']
print(reversed(lst))
print(type(reversed(lst)))
print(list(reversed(lst)))

<list_reverseiterator object at 0x0000012C14B8E048>
<class 'list_reverseiterator'>
['c', 'b', 'a']

56.`round`()

说明：round() 方法返回浮点数x的四舍五入值。该函数用于四舍五入。

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 的类型相同。

对于一般的 Python 对象 number, round 将委托给 number.__round__。

注解

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

举例：

print(round(1.5))
print(round(-1.5))
print(round(25.9))

2
-2
26

57.`set`()

说明：set类型转换，也就是集合。集合在之前的学习中有讲到，最主要的作用就是排序。

class set([iterable])

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

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

举例：

list = [1,2,3,4,5]
print(set(list))
print(type(set(list)))

{1, 2, 3, 4, 5}
<class 'set'>

排序作用：

list = [1,2,3,4,5,9,8,7,6]
print(set(list))
print(type(set(list)))

{1, 2, 3, 4, 5, 6, 7, 8, 9}
<class 'set'>

58.`setattr`()

说明：setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

setattr(object, name, value)

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

举例：类和对象的内置函数会放到后面再统一学习，这里仅了解即可。

59.`slice`()

说明：slice()函数实际上是切片类的一个构造函数，返回一个切片对象，千万不能把其当作函数使用。

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

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() 了解返回迭代器的一种替代版本。

举例：

rang = range(1,10)
print(rang)
slice = slice(1,6,2)
print(slice)
print(rang[slice])
for i in rang:
    print(i)

range(1, 10)
slice(1, 6, 2)
range(2, 7, 2)
1
2
3
4
5
6
7
8
9

备注：通过举例可以看出，slice得到的就是一个分片对象，这个分片对象可以直接拿来使用。所以最好不要把slice当作一个函数去使用，会产生误解。

60.`sorted`()

说明：sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

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

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

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

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

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

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

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

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

举例：

lst = [5,8,2,4,9,1,3]
print(sorted(lst))
print(lst)
lst.sort()
print(lst)

[1, 2, 3, 4, 5, 8, 9]

[1, 2, 3, 4, 5, 8, 9]
[5, 8, 2, 4, 9, 1, 3]
[1, 2, 3, 4, 5, 8, 9]

备注：简单来说sort()方法会改变原先的内容，而sorted函数会重新返回一个新的排序后的内容。

61.`staticmethod`

说明：@staticmethod将方法转换为静态方法。

@staticmethod

将方法转换为静态方法。

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
@staticmethod 这样的形式称为函数的 decorator -- 详情参阅函数定义。

静态方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。

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

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:
class C:
    builtin_open = staticmethod(open)
想了解更多有关静态方法的信息，请参阅标准类型层级结构。

举例：类和对象相关的内置函数会放到后面再统一学习，这里仅了解即可。

62. `str`()

说明：字符串数据类型转换函数。

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

返回一个 str 版本的 object 。有关详细信息，请参阅 str() 。

str 是内置字符串 class 。更多关于字符串的信息查看文本序列类型 --- str。

举例：

lst = [5,8,2,4,9,1,3]
print(type(lst))
print(str(lst))
print(type(str(lst)))

<class 'list'>
[5, 8, 2, 4, 9, 1, 3]
<class 'str'>

63.sum()

说明：求和函数。sum() 方法对系列进行求和计算。

sum(iterable[, start])

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

对某些用例来说，存在 sum() 的更好替代。拼接字符串序列的更好更快方式是调用 ''.join(sequence)。要以扩展精度对浮点值求和，请参阅 math.fsum()。要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

举例：

lst = [5,8,2,4,9,1,3]
print(sum(lst))

64.`super`()

说明：super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

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

返回一个代理对象，它会将方法调用委托给 type 指定的父类或兄弟类。这对于访问已在类中被重载的继承方法很有用。搜索顺序与 getattr() 所使用的相同，只是 type 指定的类型本身会被跳过。

type 的 __mro__ 属性列出了 getattr() 和 super() 所使用的方法解析顺序。该属性是动态的，可以在继承层级结构更新的时候任意改变。

如果省略第二个参数，则返回的超类对象是未绑定的。如果第二个参数为一个对象，则 isinstance(obj, type) 必须为真值。如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值（这适用于类方法）。

super 有两个典型用例。在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。这种用法与其他编程语言中 super 的用法非常相似。

第二个用例是在动态执行环境中支持协作多重继承。此用例为 Python 所独有，在静态编译语言或仅支持单继承的语言中是不存在的。这使得实现“菱形图”成为可能，在这时会有多个基类实现相同的方法。好的设计强制要求这种方法在每个情况下具有相同的调用签名（因为调用顺序是在运行时确定的，也因为该顺序要适应类层级结构的更改，还因为该顺序可能包含在运行时之前未知的兄弟类）。

对于以上两个用例，典型的超类调用看起来是这样的:
class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)
除了方法查找之外，super() 也可用于属性查找。一个可能的此种用例是在上级或同级类中调用 descriptor。

请注意 super() 是作为显式加点属性查找的绑定过程的一部分来实现的，例如 super().__getitem__(name)。它做到这一点是通过实现自己的 __getattribute__() 方法，这样就能以可预测的顺序搜索类，并且支持协作多重继承。对应地，super() 在像 super()[name] 这样使用语句或操作符进行隐式查找时则未被定义。

还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。两个参数的形式明确指定参数并进行相应的引用。零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。

对于有关如何使用 super() 来如何设计协作类的实用建议，请参阅使用 super() 的指南。

备注：类和对象相关的内置函数会放到后面再统一学习，这里仅了解即可。

65.`tuple`()

说明：元组类型转换函数。

class tuple([iterable])

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型，参见在元组与序列类型 --- list, tuple, range 中的文档说明。

举例：

lst = [1,2,3,4,5]
tpule = (tuple(lst))
print(tpule)
print(type(tpule))

(1, 2, 3, 4, 5)
<class 'tuple'>

66.`type`()

说明：返回数据类型。可以利用该函数去查看值的数据类型。

class type(object)

class type(name, bases, dict)

传入一个参数时，返回 object 的类型。返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。

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

传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式。 name 字符串即类名并且会成为 __name__ 属性；bases 元组列出基类并且会成为 __bases__ 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性。例如，下面两条语句会创建相同的 type 对象:
>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))
另请参阅类型对象。

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

举例：

lst = [1,2,3,4,5]
str = 'Jack'
num = 3.1415926
dict = {'class':'python'}
print(lst,str,num,dict)
print(type(lst),type(str),type(num),type(dict))

[1, 2, 3, 4, 5] Jack 3.1415926 {'class': 'python'}
<class 'list'> <class 'str'> <class 'float'> <class 'dict'>

67.`vars`()

说明：vars() 函数返回对象object的属性和属性值的字典对象。

vars([object])

返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。

模块和实例这样的对象具有可更新的 __dict__ 属性；但是，其它对象的 __dict__ 属性可能会设为限制写入（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。

不带参数时，vars() 的行为类似 locals()。请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。

举例：类和对象的内置函数会放到后面再统一学习，这里仅了解即可。

68.`zip`()

说明：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器。

返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。不带参数时，它将返回一个空迭代器。相当于:
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() 与 * 运算符相结合可以用来拆解一个列表:

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

举例：

各个迭代器的元素个数一致的情况下：

lst = [1,2,3,4]
str = 'Jack'
a = list(zip(lst,str))
print(a)
b = dict(zip(lst,str))
print(b)
print(zip(lst,str))
print(type(zip(lst,str)))

[(1, 'J'), (2, 'a'), (3, 'c'), (4, 'k')]
{1: 'J', 2: 'a', 3: 'c', 4: 'k'}
<zip object at 0x00000214C894E248>
<class 'zip'>

各个迭代器的元素个数不一致的情况下：

lst = [1,2,3,4,5]
str = 'Jack'
a = list(zip(lst,str))
print(a)
b = dict(zip(lst,str))
print(b)

[(1, 'J'), (2, 'a'), (3, 'c'), (4, 'k')]
{1: 'J', 2: 'a', 3: 'c', 4: 'k'}

69.`import`

说明：__import__() 函数用于动态加载类和函数。

如果一个模块经常变化就可以使用 __import__() 来动态载入。

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

注解

与 importlib.import_module() 不同，这是一个日常 Python 编程中不需要用到的高级函数。

此函数会由 import 语句发起调用。它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是强烈不建议这样做，因为使用导入钩子 (参见 PEP 302) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。

该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。标准实现完全不使用其 locals 参数，而仅使用 globals 参数来确定 import 语句的包上下文。

level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 __import__() 的目录，将要搜索的父目录层数 (详情参见 PEP 328)。

当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而不是以 name 命名的模块。但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名的模块。

例如，语句 import spam 的结果将为与以下代码作用相同的字节码:
spam = __import__('spam', globals(), locals(), [], 0)
语句 import spam.ham 的结果将为以下调用:
spam = __import__('spam.ham', globals(), locals(), [], 0)
请注意在这里 __import__() 是如何返回顶层模块的，因为这是通过 import 语句被绑定到特定名称的对象。

另一方面，语句 from spam.ham import eggs, sausage as saus 的结果将为
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
在这里， spam.ham 模块会由 __import__() 返回。要导入的对象将从此对象中提取并赋值给它们对应的名称。

如果您只想按名称导入模块（可能在包中），请使用 importlib.import_module()

在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).

备注：同样的，类和对象相关的内置函数会放到后面再统一学习，这里仅了解即可。

以上便是《Python学习14：内置函数（二）》所有内容，作为内置函数三部曲的最后一篇，69个内置函数已经全部介绍完毕。

而python中经常使用并相对有难度的内置函数会在之后的逐一讲解。类和对象的学习内容会在内置函数的学习中穿插进行。

目前《Python学习》专题正在不断更新，原创不易，如果喜欢请点赞和关注，谢谢大家的支持！

获得更多免费的学习资料请添加微信公众号——风起怨江南，有任何问题可以随时和我交流沟通。

Python学习15：内置函数（三）

Python常用的内置函数

47.`oct`()

48.open()

49.`ord`()

50.`pow`()

51.`print`()

52. `property`()

53.`range`()

54.repr()

55.`reversed`()

56.`round`()

57.`set`()

58.`setattr`()

59.`slice`()

60.`sorted`()

61.`staticmethod`

62. `str`()

63.sum()

64.`super`()

65.`tuple`()

66.`type`()

67.`vars`()

68.`zip`()

69.`import`

Nginx R31 doc 官方文档-01-nginx 如何安装

Qt/C++音视频开发74-合并标签图形/生成yolo运算结果图形/文字和图形合并成一个/水印滤镜

挑战程序设计竞赛 2.2章习题 POJ - 3617 Best Cow Line 贪心

字节面试：MySQL什么时候锁表？如何防止锁表？

.NET8连接SQL SERVER 2008 R2 报：证书链是由不受信任的颁发机构颁发的

golang开发环境搭建(win10)

python计算机视觉学习笔记——PIL库的用法

Golang初学：获取程序内存使用情况，std runtime

Python學習00：不同操作系統的安裝和"Hello World!"

軟件研發模型和軟件測試模型

Jenkins學習01：Jenkins的介紹、下載和安裝

忘記Jenkins登陸密碼怎麼辦？學會這招就夠了

Python學習17：模塊和包的導入

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結