1 返回数字的绝对值。参数可以是整数或浮点数。如果参数是复数，则返回其大小。
  2 
  3 all（可迭代）
  4 返回True如果的所有元素迭代是真实的（或者如果可迭代为空）。相当于：
  5 
  6 高清 全（迭代器）：
  7     为 元素 的 迭代：
  8         如果 没有 元素：
  9             返回 假
 10     返回 真
 11 any（可迭代）
 12 True如果iterable的任何元素都为true ，则返回。如果iterable为空，则返回False。相当于：
 13 
 14 DEF  任何（迭代器）：
 15     为 元素 的 迭代：
 16         如果 元素：
 17             返回 真正的
 18     回报 假
 19 ascii（对象）
 20 如repr()，由返回的字符串中返回一个包含对象的可打印表示一个字符串，但逃避非ASCII字符 repr()使用\x，\u或\U逃逸。这将生成一个类似于repr()Python 2 中返回的字符串。
 21 
 22 bin（x ）
 23 将整数转换为以“0b”为前缀的二进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个__index__()返回整数的方法。一些例子：
 24 
 25 >>>
 26 >>> bin （3 ）
 27 '0b11' 
 28 >>> bin （- 10 ）
 29 '-0b1010'
 30 如果希望前缀“0b”，您可以使用以下任一方式。
 31 
 32 >>>
 33 >>> format （14 ， '#b' ）， format （14 ， 'b' ）
 34 （'0b1110'，'1110'）
 35 >>> f ' {14：#b} ' ， f ' {14：' 
 36 （'0b1110'，'1110'）
 37 另请参阅format()更多信息。
 38 
 39 class bool（[ x ] ）
 40 返回一个布尔值，即其中之一True或False。 x使用标准真实测试程序进行转换。如果x为假或省略，则返回False; 否则返回True。的 bool类是的子类int（参见数值类型-整数，浮点，复合）。它不能进一步子类化。它唯一的实例是False和 True（参见布尔值）。
 41 
 42 class bytearray（[ source [，encoding [，errors ] ] ] ）
 43 返回一个新的字节数组。的bytearray类是整数的范围为0 <= X一个可变的序列<256它具有最的可变序列，在所描述的常规方法的可变序列类型，以及大多数方法，该bytes类型已见字节和ByteArray操作。
 44 
 45 可选的源参数可用于以几种不同的方式初始化数组：
 46 
 47 如果是字符串，还必须给出编码（和可选的 错误）参数; bytearray()然后使用字符串转换为字节str.encode()。
 48 如果它是整数，则数组将具有该大小，并且将以空字节初始化。
 49 如果是符合缓冲区接口的对象，则将使用对象的只读缓冲区来初始化字节数组。
 50 如果它是一个可迭代的，它必须是范围内的整数的迭代 ，它们被用作数组的初始内容。0 <= x < 256
 51 没有参数，将创建一个大小为0的数组。
 52 
 53 另请参见二进制序列类型 - 字节，bytearray，memoryview和Bytearray对象。
 54 
 55 class bytes（[ source [，encoding [，errors ] ] ] ）
 56 返回一个新的“bytes”对象，这是一个不可变的整数序列。 是一个不可变的版本 - 它具有相同的非突变方法和相同的索引和切片行为。0 <= x < 256bytesbytearray
 57 
 58 因此，构造函数参数被解释为bytearray()。
 59 
 60 也可以使用文字创建字节对象，请参阅字符串和字节文字。
 61 
 62 另请参见二进制序列类型 - 字节，bytearray，memoryview，Bytes对象和Bytes和Bytearray操作。
 63 
 64 callable（对象）
 65 True如果对象参数出现可调用 False则返回，否则返回。如果这返回true，那么调用失败仍然是可能的，但如果它为false，则调用对象将永远不会成功。注意类可调用（调用一个类返回一个新的实例）; 如果他们的类有一个__call__()方法，则可以调用实例。
 66 
 67 版本3.2中的新功能：此功能在Python 3.0中首先被删除，然后被带回到Python 3.2中。
 68 
 69 chr（i ）
 70 返回表示Unicode代码点为整数i的字符的字符串。例如，chr(97)返回字符串'a'，同时 chr(8364)返回字符串'€'。这是倒数ord()。
 71 
 72 参数的有效范围为0到1,114,111（在16位为0x10FFFF）。 ValueError如果我超出该范围，将会被提高。
 73 
 74 classmethod（功能）
 75 返回函数的类方法。
 76 
 77 类方法接收类作为隐式第一个参数，就像实例方法接收到实例一样。要声明一个类的方法，使用这个成语：
 78 
 79 类 C ：
 80     @classmethod 
 81     def  f （cls ， arg1 ， arg2 ， ... ）： ...
 82 该@classmethod形式是一个函数装饰 -见的功能定义描述函数定义的细节。
 83 
 84 它可以在类（如C.f()）或实例（如C().f()）上调用。实例被忽略，除了它的类。如果为派生类调用了类方法，则派生类对象将作为隐含的第一个参数传递。
 85 
 86 类方法与C ++或Java静态方法不同。如果你想要这些，请参阅staticmethod()本节。
 87 
 88 有关类方法的更多信息，请参阅标准类型层次结构中标准类型层次结构的文档。
 89 
 90 compile（source，filename，mode，flags = 0，dont_inherit = False，optimize = -1 ）
 91 将源编译成代码或AST对象。代码对象可以由exec()或执行eval()。 源可以是普通字符串，字节字符串或AST对象。ast有关如何使用AST对象的信息，请参阅模块文档。
 92 
 93 该文件名参数应该给从代码读取的文件; 如果没有从文件读取（'<string>'通常使用），则传递一些可识别的值。
 94 
 95 该模式参数指定什么样的代码必须进行编译; 它可以是 'exec'，如果源包含的语句序列的，'eval'如果它由一个单一的表达的，或者'single'如果它由单个交互式声明的（在后一种情况下，计算结果为比其他东西表达式语句None将被打印）。
 96 
 97 可选参数flags和dont_inherit控制哪些未来语句（见PEP 236）影响源的编译。如果两者都不存在（或两者均为零），则代码将被编译，并在正在调用的代码中生效compile()。如果指定了 flags参数，并且 dont_inherit不是（或为零），那么除了将要使用的那些之外，还会使用 flags参数指定的将来的语句。如果 dont_inherit是一个非零整数，那么这个 flags参数就是它 - 将会忽略在编译调用期间生效的将来的语句。
 98 
 99 将来的语句由比特来指定，这些比特可以按位OR或一起指定多个语句。指定给定功能所需的位域可以作为模块中实例的compiler_flag属性找到。_Feature__future__
100 
101 参数optimize指定编译器的优化级别; 默认值-1选择由-O选项给出的解释器的优化级别。显式级别为0（不优化; __debug__为真），1（断言被删除，__debug__为假）或2（文档字符串也被删除）。
102 
103 SyntaxError如果编译的源无效，并且ValueError源包含空字节，则此函数将引发。
104 
105 如果您想将Python代码解析成其AST表示，请参阅 ast.parse()。
106 
107 注意 当使用'single'或 'eval'模式中的多行代码编译字符串时，输入必须由至少一个换行符终止。这是为了便于检测code模块中不完整和完整的语句。
108 版本3.2更改：允许使用Windows和Mac换行符。此外，输入'exec'模式也不必再以换行符结尾。添加了优化参数。
109 
110 在版本3.5中更改：以前，TypeError在源中遇到空字节时引发。
111 
112 class complex（[ real [，imag ] ] ）
113 返回复数与价值真正 + IMAG * 1J或者一个字符串或数字转换为复数。如果第一个参数是一个字符串，它将被解释为一个复数，该函数必须在没有第二个参数的情况下被调用。第二个参数永远不能是一个字符串。每个参数可以是任何数字类型（包括复数）。如果IMAG被省略，默认为零，并且构造用作数字转换等 int和float。如果两个参数都被省略，则返回 0j。
114 
115 注意 从字符串转换时，字符串不能包含中央+或-运算符周围的空格。例如， complex('1+2j')不错，但是提高了 。complex('1 + 2j')ValueError
116 复数类型在数值类型 - int，float，complex中描述。
117 
118 在版本3.6中更改：允许使用代码字面值分组带下划线的数字。
119 
120 delattr（对象，名称）
121 这是一个亲戚setattr()。参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。该函数会删除该命名属性，只要该对象允许。例如，相当于。delattr(x, 'foobar')del x.foobar
122 
123 班dict（** kwarg ）
124 类dict（映射，** kwarg ）
125 class dict（iterable，** kwarg ）
126 创建一个新的字典。该dict对象是字典类。查看dict和映射类型 - dict关于此类的文档。
127 
128 对于其他容器看到内置list，set以及 tuple类，还有collections模块。
129 
130 dir（[ object ] ）
131 没有参数，返回当前本地作用域中的名称列表。使用参数，尝试返回该对象的有效属性列表。
132 
133 如果对象具有一个名为的__dir__()方法，则将调用此方法，并返回属性列表。这允许实现自定义__getattr__()或__getattribute__()函数的对象自 定义dir()报告其属性的方式 。
134 
135 如果对象不提供__dir__()，该函数将尽力从对象的__dict__属性（如果已定义）和其类型对象收集信息。生成的列表不一定是完整的，并且当对象具有自定义时可能不准确__getattr__()。
136 
137 默认dir()机制与不同类型的对象的行为不同，因为它尝试生成最相关但不完整的信息：
138 
139 如果对象是模块对象，则该列表包含模块属性的名称。
140 如果对象是类型或类对象，则列表包含其属性的名称，并递归地显示其基础的属性。
141 否则，列表包含对象的属性名称，其类的属性的名称，以及递归类的基类的属性。
142 结果列表按字母顺序排列。例如：
143 
144 >>>
145 >>> import  struct 
146 >>> dir （）   ＃显示模块命名空间中的名称
147 ['__builtins__'，'__name__'，'struct'] 
148 >>> dir （struct ）   ＃显示struct模块中的名称
149 ['Struct ”， '__all__'， '__builtins__'， '__cached__'， '__doc__'， '__file__'，
150 '__initializing__'， '__loader__'， '__name__'， '__PACKAGE__'，
151 '_clearcache'， 'calcsize'， '错误'， 'pack'，'pack_into'，
152 'unpack'，'unpack_from'] 
153 >>> class  Shape ：
154 ...    def  __dir__ （self ）：
155 ...         return  [ 'area' ， 'spacing' ， 'location' ] 
156 >>> s  =  Shape （）
157 >>> dir （s ）
158 ['area'，'location'，'streets']
159 注意 因为dir()主要是为了方便在交互式提示中使用，所以尝试提供一组有趣的名称，而不是尝试提供严格或一致定义的名称集，并且其详细行为可能会在版本中更改。例如，当参数是一个类时，metaclass属性不在结果列表中。
160 divmod（a，b ）
161 以两个（非复数）数字作为参数，并返回一个由他们的商和余数组成的数字，当使用整数除法时。使用混合的操作数类型，二进制算术运算符的规则适用。对于整数，结果与。对于浮点数，结果是，其中q通常可能比其小1。在任何情况下，是非常接近的一个，如果不为零，它具有相同的符号为b，和。(a // b, a % b)(q, a % b)math.floor(a / b)q * b + a % ba % b0 <= abs(a % b) < abs(b)
162 
163 enumerate（iterable，start = 0 ）
164 返回枚举对象。iterable必须是序列， 迭代器或支持迭代的其他对象。__next__()返回的迭代器的方法 enumerate()返回一个包含count（从起始，默认为0）的元组和从迭代迭代获得的值。
165 
166 >>>
167 >>> seasons  =  [ 'Spring' ， 'Summer' ， 'Fall' ， 'Winter' ] 
168 >>> list （enumerate （seasons ））
169 [（0，'Spring'），（1，'Summer'），（ 2，'Fall'），（3，'Winter'）] 
170 >>> list （enumerate （seasons ， start = 1 ））
171 [（1，'Spring'），（2，'Summer'），（3，'秋天'），（4，'冬天'）]
172 相当于：
173 
174 DEF  枚举（序列， 开始= 0 ）：
175     ñ  =  开始
176     为 ELEM  在 序列：
177         收率 Ñ ， ELEM 
178         Ñ  + =  1
179 eval（expression，globals = None，locals = None ）
180 参数是一个字符串和可选的全局变量和当地人。如果提供， 全局变量必须是字典。如果提供，本地人可以是任何映射对象。
181 
182 该表达参数分析，并作为一个Python表达式来使用（从技术上来说，一个条件列表）全局和当地人 的字典作为全局和局部名字空间。如果全局词典存在且缺少“__builtins__”，则 在解析表达式之前，将当前全局变量复制到全局变量中。这意味着表达式通常具有对标准模块的完全访问权限，并且传播受限制的环境。如果省略本地字典，则默认为全局变量builtins 字典。如果省略了两个字典，表达式将在eval()被调用的环境中执行。返回值是评估表达式的结果。语法错误报告为异常。例：
183 
184 >>>
185 >>> x  =  1 
186 >>> eval （'x + 1' ）
187 2
188 此函数也可用于执行任意代码对象（如由compile()）创建的代码对象。在这种情况下，传递代码对象而不是字符串。如果代码对象已经被编译'exec'为 模式参数，那么eval()返回值将是None。
189 
190 提示：该exec() 函数支持语句的动态执行。the globals()和locals()函数分别返回当前的全局和本地字典，这可能有助于传递eval()或使用exec()。
191 
192 查看ast.literal_eval()一个可以安全地使用只包含文字的表达式来计算字符串的函数。
193 
194 exec（object [，globals [，locals ] ] ）
195 此函数支持Python代码的动态执行。对象必须是字符串或代码对象。如果它是一个字符串，则将该字符串解析为一组Python语句，然后执行该语句（除非发生语法错误）。[1]如果它是一个代码对象，它只是被执行。在所有情况下，执行的代码预期作为文件输入有效（参见“参考手册”中的“文件输入”一节）。要知道， return和yield语句可能不是函数定义之外，甚至代码传递给上下文中使用 exec()的功能。返回值为None。
196 
197 在所有情况下，如果可选部分被省略，代码将在当前范围内执行。如果仅提供全局变量，则它必须是字典，将用于全局变量和局部变量。如果全局和 当地人给出，它们分别用于全局和局部变量。如果提供，本地人可以是任何映射对象。记住，在模块级别，全局变量和本地化是相同的字典。如果exec将两个单独的对象作为全局变量和局部变量执行，则代码将被执行，就好像嵌入在类定义中一样。
198 
199 如果全局变量字典不包含该键的值， 则会在该键下插入__builtins__对内置模块的字典的引用 builtins。这样，您可以通过将自己的__builtins__字典插入到全局变量中，然后再传递给执行的代码，来控制哪些内置函数可用 exec()。
200 
201 注意 内置函数globals()并分别locals()返回当前的全局和本地字典，这可能有助于作为第二和第三个参数传递exec()。
202 注意 默认的本地人的作用如locals()下面的功能所述：不要尝试修改默认的本地字典。如果您需要在函数返回后查看本地代码的效果，请传递一个显式的本地字典。exec()
203 filter（函数，可迭代）
204 从可迭代的元素构造一个迭代器，该函数 返回true。 可迭代可以是序列，支持迭代的容器或迭代器。如果函数是None，则假定身份函数，即除以 false的所有可迭代元素。
205 
206 注意，如果函数不是，如果函数是 ，则等效于生成器表达式。filter(function, iterable)(item for item in iterable if function(item))None(item for item in iterable if item)None
207 
208 请参阅itertools.filterfalse()为哪个函数返回false 可以返回iterable的元素的互补函数。
209 
210 class float（[ x ] ）
211 返回从数字或字符串x构造的浮点数。
212 
213 如果参数是一个字符串，它应该包含一个十进制数，可选地带有一个符号，并且可以嵌入到空格中。可选标志可以是'+'或'-'; 一个'+'标志对产生的价值没有影响。参数也可以是表示NaN（不是数字）或正或负无穷大的字符串。更准确地说，在删除前导和尾随空白字符之后，输入必须符合以下语法：
214 
215 sign           :: =“+”| “ - ”
216  infinity       :: =“Infinity”| “inf”
217  nan            :: =“nan”
218  numeric_value :: =   floatnumber| infinity| numeric_string :: = [ ]nan
219 signnumeric_value
220 这floatnumber是浮点文字中描述的Python浮点文字的形式。情况并不重要，因此，例如，“inf”，“Inf”，“INFINITY”和“iNfINity”都是正无穷大的可接受拼写。
221 
222 否则，如果参数是整数或浮点数，则返回具有相同值的浮点数（在Python的浮点精度内）。如果参数超出了Python float的范围，OverflowError则会引发一个参数。
223 
224 对于一般的Python对象x，float(x)委托 x.__float__()。
225 
226 如果没有给出参数，0.0则返回。
227 
228 例子：
229 
230 >>>
231 >>> float （'+ 1E6' ）
232 1.23 
233 >>> float （'-12345 \ n ' ）- 
234 12345.0 
235 >>> float （'1e-003' ）
236 0.001 
237 >>> float （'+ 1E6' ）
238 1000000.0 
239 >> > float （'-Infinity' ）- 
240 inf
241 浮点类型在数值类型 - int，float，complex中描述。
242 
243 在版本3.6中更改：允许使用代码字面值分组带下划线的数字。
244 
245 format（value [，format_spec ] ）
246 将值转换为由format_spec控制的“格式化”表示 。format_spec的解释将取决于值参数的类型，但是还有一种标准的格式化语法，由大多数内置类型使用：格式规范Mini-Language。
247 
248 默认format_spec是一个空字符串通常作为给调用同样的效果str(value)。
249 
250 在搜索该值的方法时，调用转换为 绕过实例字典。一 ，如果该方法搜索到达引发异常 和format_spec非空，或者这两个 format_spec或返回值是不是字符串。format(value, format_spec)type(value).__format__(value, format_spec)__format__()TypeErrorobject
251 
252 在版本3.4中更改： 如果format_spec不是空字符串，则object().__format__(format_spec)引发。TypeError
253 
254 类frozenset（[ iterable ] ）
255 返回一个新frozenset对象，可选择从iterable取得的元素 。 frozenset是一个内置的类。查看frozenset和 设置类型 - 设置，frozenset以获取有关此类的文档。
256 
257 对于其他容器看到内置的set，list， tuple，和dict类，还有collections 模块。
258 
259 getattr（object，name [，default ] ）
260 返回对象的命名属性的值。 name必须是一个字符串。如果字符串是对象属性之一的名称，则该属性的值为该值。例如，相当于 。如果命名属性不存在，则返回默认值，否则生成。getattr(x, 'foobar')x.foobarAttributeError
261 
262 globals（）
263 返回一个表示当前全局符号表的字典。这总是当前模块的字典（在一个函数或方法中，这是定义它的模块，而不是调用它的模块）。
264 
265 hasattr（对象，名称）
266 参数是一个对象和一个字符串。结果是True如果字符串是对象属性之一的名称，False否则。（这是通过调用和看到它是否引起的来实现的。）getattr(object, name)AttributeError
267 
268 hash（对象）
269 返回对象的哈希值（如果有的话）。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较均等的数值具有相同的散列值（即使它们是不同类型，如1和1.0的情况）。
270 注意 对于具有自定义__hash__()方法的对象，请注意，hash() 根据主机的位宽度截断返回值。看__hash__()详情。
271 help（[ object ] ）
272 调用内置的帮助系统。（此功能用于交互式使用。）如果没有给出参数，交互式帮助系统将在解释器控制台上启动。如果参数是字符串，则将字符串作为模块，函数，类，方法，关键字或文档主题的名称进行查找，并在控制台上打印一个帮助页面。如果参数是任何其他类型的对象，则生成对象上的帮助页面。
273 
274 该功能由site模块添加到内置命名空间中。
275 
276 在版本3.4中更改：更改pydoc并inspect意味着报告的电话签名现在更全面和一致。
277 
278 hex（x ）
279 将整数转换为以“0x”为前缀的小写十六进制字符串。如果x不是Python int对象，则必须定义返回一个整数的__index __（）方法。一些例子：
280 
281 >>>
282 >>> hex （255 ）
283 '0xff' 
284 >>> hex （- 42 ）
285 '-0x2a'
286 如果要将整数转换为具有前缀或不带前缀的大写或十六进制字符串，可以使用以下两种方式之一：
287 
288 >>>
289 >>> ' ％＃x '  ％ 255 ， ' ％x '  ％ 255 ， ' ％X '  ％ 255 
290 （'0xff'，'ff'，'FF'）
291 >>> 格式（255 ， ' #x ' ）， 格式（255 ， 'x' ）， 格式（255 ， 'X' ）
292 （'0xff'，'ff'，'FF'）
293 >>> f ' {255：#x} ' ， f ' {255：x} ' ， f ' {255：X}' 
294 （'0xff'，'ff'，'FF'）
295 另请参阅format()更多信息。
296 
297 另请参见int()使用16位的基数将十六进制字符串转换为整数。
298 
299 注意 要获取浮点数的十六进制字符串表示形式，请使用该 float.hex()方法。
300 id（对象）
301 返回一个对象的“身份”。这是一个整数，在整个生命周期中，该对象被保证是唯一的和不变的。具有不重叠寿命的两个对象可能具有相同的id() 值。
302 
303 CPython实现细节：这是内存中对象的地址。
304 input（[ prompt ] ）
305 如果提示参数存在，则将其写入标准输出，而不带尾随的换行符。该函数然后从输入读取一行，将其转换为字符串（剥离尾随的换行符），并返回。当读取EOF时，EOFError被提出。例：
306 
307 >>>
308 >>> s  =  input （' - >' ）  
309 - > Monty Python的飞马场
310 >>> s   
311 “Monty Python's Flying Circus”
312 如果readline模块被加载，那么input()将使用它来提供详细的行编辑和历史记录功能。
313 
314 类int（x = 0 ）
315 类int（x，base = 10 ）
316 返回从数字或字符串x构造的整数对象，0如果没有给出参数，则返回 。如果x是数字，则返回 x.__int__()。对于浮点数，这将截断为零。
317 
318 如果X不是数字或如果基给出，则X必须是一个字符串， bytes或bytearray代表一个实例字面整数在基数基。可选地，文字可以在之前+或之间-（在之间没有空格）并被空格包围。甲基-正文字由数字0到n-1，用a 于z（或A到Z）具有值10〜35的默认碱是10允许的值是0和2-36。Base-2，-8和-16文字可以选择以0b/ 0B， 0o/ 0O或0x/0X，与代码中的整数文字一样。基0意味着精确地解释为文字代码，使得实际碱是2，8，10，或16，并且使得不合法，而 是，以及。int('010', 0)int('010')int('010', 8)
319 
320 整数类型在数值类型中描述- int，float，complex。
321 
322 在版本3.4中更改：如果base不是实例，int并且基础对象具有 base.__index__方法，则调用该方法以获取基数的整数。以前使用的版本 base.__int__代替base.__index__。
323 
324 在版本3.6中更改：允许使用代码字面值分组带下划线的数字。
325 
326 isinstance（object，classinfo ）
327 如果对象参数是classinfo 参数的实例，或者（直接，间接或虚拟）子类的实例，则返回true 。如果对象不是给定类型的对象，则该函数总是返回false。如果classinfo是类型对象（或递归地，其他此类元组）的元组，则如果对象是任何类型的实例，则返回true 。如果classinfo不是类型或元组的类型和元组，TypeError则会引发异常。
328 
329 issubclass（class，classinfo ）
330 如果class是classinfo的子类（直接，间接或虚拟），则返回true 。一个类被认为是一个子类。classinfo可以是类对象的元组，在这种情况下，将会检查classinfo中的每个条目。在任何其他情况下，都会出现异常。TypeError
331 
332 iter（object [，sentinel ] ）
333 返回一个迭代器对象。根据第二个参数的存在，第一个参数被非常不同的解释。没有第二个参数，对象必须是支持迭代协议（该__iter__()方法）的集合对象，或者必须支持序列协议（__getitem__()以整数参数开头的方法0）。如果它不支持这些协议之一， TypeError则被提出。如果给定了第二个参数sentinel，那么对象必须是可调用的对象。在这种情况下创建的迭代器将调用对象，每个对其__next__()方法的调用都不带参数 ; 如果返回的值等于 sentinel，StopIteration 将被提升，否则将返回值。
334 
335 另请参见迭代器类型。
336 
337 第二种形式的一个有用的应用iter()是读取文件的行，直到达到一定的行。以下示例读取文件，直到该readline()方法返回一个空字符串：
338 
339 与 开放（'mydata.txt' ） 作为 FP ：
340     用于 线 在 ITER （FP 。readline的， '' ）：
341         process_line （线）
342 len（s ）
343 返回一个对象的长度（项目数）。参数可以是序列（如字符串，字节，元组，列表或范围）或集合（如字典，集合或冻结集合）。
344 
345 类list（[ iterable ] ）
346 而不是一个函数，list实际上是一个可变序列类型，如列表和序列类型 - 列表，元组，范围中所述。
347 
348 locals（）
349 更新并返回表示当前本地符号表的字典。locals()当函数块调用时，返回自由变量，而不在类块中。
350 
351 注意 本字典的内容不得修改; 更改可能不会影响解释器使用的本地和自由变量的值。
352 map（函数，迭代，... ）
353 返回一个迭代器，它将函数应用于可迭代的每个项目，从而产生结果。如果传递额外的可迭代参数， 函数必须使用许多参数，并且并行地应用于所有迭代的项目。使用多个迭代，当最短的迭代耗尽时，迭代器停止。对于功能输入已经排列成参数元组的情况，请参见itertools.starmap()。
354 
355 max（iterable，* [，key，default ] ）
356 max（arg1，arg2，* args [，key ] ）
357 返回一个可迭代或最大的两个或多个参数中的最大项。
358 
359 如果提供了一个位置参数，它应该是一个可迭代的。返回iterable中最大的项目。如果提供了两个或多个位置参数，则返回最大的位置参数。
360 
361 有两个可选的关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空，并且未提供默认值， ValueError则会引发a。
362 
363 如果多个项目是最大的，该函数将返回遇到的第一个。这与其他分类稳定性保留工具（例如和）一致 。sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc)
364 
365 在新版本3.4：在默认情况下只有关键字的说法。
366 
367 memoryview（obj ）
368 返回从给定的参数创建的“内存视图”对象。有关详细信息，请参阅 内存视图
369 
370 min（iterable，* [，key，default ] ）
371 min（arg1，arg2，* args [，key ] ）
372 以可迭代或最小的两个或多个参数返回最小的项。
373 
374 如果提供了一个位置参数，它应该是一个可迭代的。返回iterable中最小的项。如果提供了两个或多个位置参数，则返回最小的位置参数。
375 
376 有两个可选的关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空，并且未提供默认值， ValueError则会引发a。
377 
378 如果多个项目最小，该函数将返回遇到的第一个。这与其他分类稳定性保留工具（例如和）一致。sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc)
379 
380 在新版本3.4：在默认情况下只有关键字的说法。
381 
382 next（iterator [，default ] ）
383 通过调用其 方法从迭代器获取下一个项目__next__()。如果给定了默认值，则如果迭代器耗尽，则返回，否则将StopIteration被引发。
384 
385 类object
386 返回一个新的无特征对象。 object是所有班级的基地。它具有Python类的所有实例通用的方法。此函数不接受任何参数。
387 
388 注意 object没有不有__dict__，所以你不能指定任意属性的实例object类。
389 oct（x ）
390 将整数转换为前缀为“0o”的八进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个__index__()返回整数的方法。例如：
391 
392 >>>
393 >>> oct （8 ）
394 '0o10' 
395 >>> oct （- 56 ）
396 '-0o70'
397 如果要使用前缀“0o”将整数转换为八进制字符串，则可以使用以下任一方式。
398 
399 >>>
400 >>> ' ％＃o '  ％ 10 ， ' ％o '  ％ 10 
401 （'0o12'，'12'）
402 >>> format （10 ， '#o​​' ）， format （10 ， 'o' ）
403 （'0o12 '，
404 '12 '）>>> f ' {10：#o} ' ， f ' {10：o} ' 
405 （'0o12'，'12'）
406 另请参阅format()更多信息。
407 
408 open（文件，模式= 'R' ，缓冲= -1，编码=无，误差=无，换行符=无，closefd =真，开启器=无）
409 打开文件并返回相应的文件对象。如果文件无法打开，则会生成一个文件OSError。
410 
411 file是一个路径样的对象，给出要打开的文件的路径名（绝对或相对于当前工作目录）或要包装的文件的整数文件描述符。（如果给出了一个文件描述符，则当返回的I / O对象关闭时关闭它，除非将closefd 设置为False。）
412 
413 mode是一个可选字符串，指定文件打开的方式。它默认为'r'打开文本模式阅读。其他常见值是'w'用于写入（截断文件已存在），'x'用于独占创建和'a'附加（在某些 Unix系统上，这意味着所有写入都附加到文件的末尾，而不管当前的查找位置如何）。在文本模式下，如果 编码未指定使用的编码是与平台相关的： locale.getpreferredencoding(False)被称为获取当前的本地编码。（用于读取和写入原始字节使用二进制模式并保留 编码未指定。）可用的模式有：
414 
415 字符    含义
416 'r'    开放阅读（默认）
417 'w'    打开写入，首先截断文件
418 'x'    打开独占创建，如果文件已经存在失败
419 'a'    打开写入，如果存在，则附加到文件的末尾
420 'b'    二进制模式
421 't'    文字模式（默认）
422 '+'    打开一个磁盘文件进行更新（读写）
423 'U'    通用换行模式（不推荐使用）
424 默认模式是'r'（打开阅读文本，同义词'rt'）。对于二进制读写访问，该模式'w+b'将打开文件并将其截断为0个字节。 'r+b'打开文件而不截断。
425 
426 如概述中所述，Python区分二进制和文本I / O。以二进制模式打开的文件（包括'b'在模式 参数中）将内容作为bytes对象返回，无需任何解码。在文本模式（默认值，或't'包含在模式参数中的什么时间）中，文件的内容返回为str，首先使用平台相关编码对字节进行了解码，如果给出，则使用指定的 编码。
427 
428 注意 Python不依赖于底层操作系统的文本文件概念; 所有的处理都是由Python本身完成的，因此是与平台无关的。
429 buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:
430 
431 Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s “block size” and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
432 “Interactive” text files (files for which isatty() returns True) use line buffering. Other text files use the policy described above for binary files.
433 encoding是用于对文件进行解码或编码的编码名称。这只能在文本模式下使用。默认编码是平台依赖（无论locale.getpreferredencoding()返回），但是可以使用Python支持的任何 文本编码。有关codecs支持的编码列表，请参阅模块。
434 
435 错误是一个可选的字符串，指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在错误处理程序下），尽管已注册的任何错误处理名称 codecs.register_error()也是有效的。标准名称包括：
436 
437 'strict'ValueError如果存在编码错误，则引发异常。默认值None具有相同的效果。
438 'ignore'忽略错误。请注意，忽略编码错误可能导致数据丢失。
439 'replace'导致替换标记（例如'?'）插入有畸形数据的地方。
440 'surrogateescape'将代表任何不正确的字节作为Unicode私有使用区域中的代码点，范围从U + DC80到U + DCFF。surrogateescape当编写数据时使用错误处理程序时，这些私有代码点将被转回相同的字节。这对处理未知编码的文件非常有用。
441 'xmlcharrefreplace'仅在写入文件时才受支持。编码不支持的字符将替换为适当的XML字符引用&#nnn;。
442 'backslashreplace' 通过Python的反斜杠转义序列替换格式不正确的数据。
443 'namereplace'（仅在写入时支持）用\N{...}转义序列替换不支持的字符。
444 换行符控制通用换行符模式的工作原理（仅适用于文本模式）。它可以是None，''，'\n'，'\r'，和 '\r\n'。它的工作原理如下：
445 
446 当从流中读取输入，如果换行符是None，启用通用换行模式。在输入线可以结束在'\n'， '\r'或'\r\n'，并且这些被翻译成'\n'被返回给调用者之前。如果是''，则启用通用换行符模式，但行结束将返回给调用者非翻译。如果它具有任何其他合法值，则输入行仅由给定的字符串终止，并且行结束将返回给调用者非翻译。
447 当输出写入到流，如果换行是None，任何'\n' 写入的字符被转换为系统默认在线分离器， os.linesep。如果换行是''或'\n'不进行翻译。如果换行符是任何其他合法值，则'\n' 写入的任何字符都将转换为给定的字符串。
448 如果closefd是False并且文件描述符而不是文件名，则文件关闭时，底层文件描述符将保持打开状态。如果给定文件名，则closefd必须是True（默认），否则会引发错误。
449 
450 通过传递一个可打开的开启者，可以使用自定义的开启者。然后通过使用（file，flags）调用opener获取文件对象的底层文件描述符。开启者必须返回一个打开的文件描述符（ 作为opener结果传递的功能类似于传递 ）。os.openNone
451 
452 新创建的文件是不可继承的。
453 
454 以下示例使用函数的dir_fd参数 os.open()来打开相对于给定目录的文件：
455 
456 >>>
457 >>> import  os 
458 >>> dir_fd  =  os 。开放（'somedir' ， OS 。O_RDONLY ）
459 >>> 高清 开瓶器（路径， 旗）：
460 ...     返回 操作系统。开（路径， 标志， dir_fd = dir_fd ）
461 ... 
462 >>> 与 开放（'spamspam.txt' ， 'W' ， 首战= 开瓶器） 作为 f ：
463 ...     print （'这将被写入somedir / spamspam.txt' ， file = f ）
464 ... 
465 >>> os 。close （dir_fd ）  ＃不要泄漏文件描述符
466 函数返回的文件对象的类型open()取决于模式。当open()使用在文本模式（打开一个文件'w'，'r'，'wt'，'rt'，等等），它返回的一个子类 io.TextIOBase（具体而言io.TextIOWrapper）。当用二进制模式打开缓冲文件时，返回的类是一个子类io.BufferedIOBase。精确的类别有所不同：在读取二进制模式下，它返回一个io.BufferedReader; 在写二进制和附加二进制模式下，它返回一个io.BufferedWriter，在读/写模式下，它返回一个io.BufferedRandom。当缓冲被禁用，原始流，的一个子类io.RawIOBase， io.FileIO，则返回。
467 
468 参见文件处理模块，如，fileinput，io （其中open()被声明）， ，os，os.path，tempfile和shutil。
469 
470 版本3.3更改：
471 在揭幕战中添加参数。
472 在'x'加入模式。
473 IOError曾经被提出来，现在是别名了OSError。
474 FileExistsError如果在独占创建模式（'x'）中打开的文件已经存在，则现在被提升。
475 在版本3.4中更改：
476 该文件现在不可继承。
477 自从3.4版本弃用，将在4.0版本中删除：该'U'模式。
478 
479 版本3.5更改：
480 如果系统调用中断，并且信号处理程序不引发异常，则该函数现在将重试系统调用，而不是引发 InterruptedError异常（请参阅PEP 475为理由）。
481 在'namereplace'加入错误处理程序。
482 版本3.6更改：
483 支持添加接收对象实现os.PathLike。
484 在Windows上，打开控制台缓冲区可能会返回io.RawIOBase除其他子类 io.FileIO。
485 ord（c ）
486 给定一个表示一个Unicode字符的字符串，返回一个整数，表示该字符的Unicode代码点。例如， ord('a')返回整数97和ord('€')（欧元符号）返回8364。这是倒数chr()。
487 
488 pow（x，y [，z ] ）
489 Return x to the power y; if z is present, return x to the power y, modulo z (computed more efficiently than pow(x, y) % z). The two-argument form pow(x, y) is equivalent to using the power operator: x**y.
490 
491 The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, 10**2 returns 100, but 10**-2 returns 0.01. If the second argument is negative, the third argument must be omitted. If z is present, x and y must be of integer types, and y must be non-negative.
492 
493 print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
494 Print objects to the text stream file, separated by sep and followed by end. sep, end, file and flush, if present, must be given as keyword arguments.
495 
496 所有非关键字参数都将转换为字符串str()，并将其写入流，以sep分隔，后跟结尾。无论九月 和年底必须是字符串; 它们也可以None，这意味着使用默认值。如果没有给出对象，print()只会写入 结束。
497 
498 的文件参数必须是与对象write(string)方法; 如果它不存在或None，sys.stdout将被使用。由于打印的参数被转换为文本字符串，print()不能与二进制模式文件对象一起使用。对于这些，请file.write(...)改用。
499 
500 输出缓冲是否通常由文件确定，但如果 flush关键字参数为true，则强制刷新该流。
501 
502 在版本3.3中更改：添加了flush关键字参数。
503 
504 class property（fget = None，fset = None，fdel = None，doc = None ）
505 返回属性属性。
506 
507 fget是获取属性值的函数。 fset是设置属性值的函数。fdel是删除属性值的函数。而doc会为该属性创建一个docstring。
508 
509 典型的用法是定义托管属性x：
510 
511  C 类：
512     def  __init__ （self ）：
513         self 。_x  =  无
514 
515     def  getx （self ）：
516         return  self 。_X
517 
518     def  setx （self ， value ）：
519         self 。_x  =  值
520 
521     def  delx （self ）：
522         del  self 。_X
523 
524     x  =  property （getx ， setx ， delx ， “我是'x'属性。” ）
525 如果c是C的一个实例，c.x将调用getter， 将调用setter和deleter。c.x = valuedel c.x
526 
527 如果给定，doc将是属性属性的docstring。否则，该属性将复制fget的docstring（如果存在）。这使得可以轻松地创建只读属性property()作为装饰器：
528 
529 类 鹦鹉：
530     高清 __init__ （个体经营）：
531         自我。_voltage  =  100000
532 
533     @property 
534     def  voltage （self ）：
535         “”“获得当前电压。”“” 
536         返回 自我。_电压
537 该@property装饰变成的voltage()方法变成“吸”为只读具有相同名称的属性，并将其设置的文档字符串的 电压为“获取当前的电压。”
538 
539 属性对象具有getter，setter和deleter可用作装饰器的方法，用于创建属性的副本，并将相应的访问器函数设置为装饰函数。这最好用一个例子来解释：
540 
541  C 类：
542     def  __init__ （self ）：
543         self 。_x  =  无
544 
545     @property 
546     def  x （self ）：
547         “”“我是'x'属性。”“” 
548         return  self 。_X
549 
550     @x 。setter 
551     def  x （self ， value ）：
552         self 。_x  =  值
553 
554     @x 。删除器
555     高清 X （自）：
556         德尔 自我。_X
557 这段代码完全等同于第一个例子。请确保附加的功能与原始属性相同（x在这种情况下）。
558 
559 返回的属性对象也有属性fget，fset以及 fdel相对应的构造函数的参数。
560 
561 版本3.5更改：属性对象的文本字符串现在可写。
562 
563 range（停）
564 range（开始，停止[，步骤] ）
565 实际上不是一个函数，而是range一个不可变的序列类型，如范围和序列类型 - 列表，元组，范围中所述。
566 
567 repr（对象）
568 返回一个包含对象的可打印表示的字符串。对于许多类型，此函数尝试返回一个字符串，该字符串在传递时将产生具有相同值的对象eval()，否则表示形式是包含在尖括号中的字符串，其中包含对象类型的名称以及附加信息通常包括对象的名称和地址。一个类可以通过定义一个__repr__()方法来控制这个函数返回的实例。
569 
570 reversed（seq ）
571 返回一个反向迭代器。 seq必须是一个具有__reversed__()方法或支持序列协议的对象（以整数参数开头的 __len__()方法和__getitem__()方法0）。
572 
573 round（number [，ndigits ] ）
574 在小数点后，返回数字四舍五入到ndigits精度。如果省略了ndigits，或者None返回最接近整数的输入。
575 
576 对于支持的内置类型round()，值将四舍五入到功率减去ndigits的10的最接近的倍数; 如果两个倍数同样接近，舍入朝向甚至选择完成（因此，例如，这两个round(0.5)和round(-0.5)是0，和round(1.5)是 2）。任何整数值对于ndigits（正，零或负）有效。返回值是一个整数，如果使用一个参数调用，否则与number类型相同。
577 
578 对于一般的Python对象number，委托 。round(number, ndigits)number.__round__(ndigits)
579 
580 注意 的行为round()为花车可奇怪的：例如， 给出而不是预期。这不是一个错误：这是一个事实，大多数小数部分不能完全像浮点表示的结果。有关详细信息，请参阅浮点算术：问题和限制。round(2.675, 2)2.672.68
581 类set（[ iterable ] ）
582 返回一个新set对象，可选择从iterable取得的元素 。 set是一个内置的类。查看set和 设置类型 - 设置，frozenset以获取有关此类的文档。
583 
584 对于其他容器看到内置的frozenset，list， tuple，和dict类，还有collections 模块。
585 
586 setattr（对象，名称，值）
587 这是对应的getattr()。参数是一个对象，一个字符串和一个任意值。字符串可以命名现有属性或新属性。该函数将赋值给该属性，前提是该对象允许该属性。例如，相当于 。setattr(x, 'foobar', 123)x.foobar = 123
588 
589 班slice（停）
590 类slice（开始，停止[，步骤] ）
591 返回表示由其指定的索引集的切片对象 。在启动和步参数默认为 。切片对象具有只读数据属性， 而这仅仅是返回参数值（或它们的默认值）。他们没有其他明确的功能; 然而它们被数字Python和其他第三方扩展所使用。当使用扩展索引语法时，也会生成切片对象。例如：或。查看 返回迭代器的替代版本。range(start, stop, step)Nonestartstopstepa[start:stop:step]a[start:stop, i]itertools.islice()
592 
593 sorted（iterable，*，key = None，reverse = False ）
594 从iterable中的项中返回一个新的排序列表。
595 
596 有两个可选参数必须指定为关键字参数。
597 
598 key指定用于从每个列表元素中提取比较键的一个参数的函数：key=str.lower。默认值为None （直接比较元素）。
599 
600 reverse是一个布尔值。如果设置为True，那么列表元素将被排序，就好像每个比较被颠倒一样。
601 
602 用functools.cmp_to_key()一个老式的转换CMP功能的 关键功能。
603 
604 内置sorted()功能保证稳定。如果它保证不改变比较相等的元素的相对顺序，那么它是稳定的 - 这有助于在多个遍中排序（例如，按部门排序，然后按薪水等级排序）。
605 
606 有关排序示例和简要排序教程，请参阅排序如何。
607 
608 staticmethod（功能）
609 返回静态方法的函数。
610 
611 静态方法不会收到隐式的第一个参数。要声明静态方法，请使用此成语：
612 
613 类 C ：
614     @staticmethod 
615     def  f （arg1 ， arg2 ， ... ）： ...
616 该@staticmethod形式是一个函数装饰 -见的功能定义描述函数定义的细节。
617 
618 它可以在类（如C.f()）或实例（如C().f()）上调用。实例被忽略，除了它的类。
619 
620 Python中的静态方法与Java或C ++中的静态方法类似。另请参见 classmethod()对于创建替代类构造函数的变体。
621 
622 有关静态方法的更多信息，请参阅标准类型层次结构中标准类型层次结构的文档。
623 
624 class str（object =“ ）
625 class str（object = b“，encoding ='utf-8'，errors ='strict' ）
626 返回一个对象的str版本。看详情。str()
627 
628 str是内置的字符串类。有关字符串的一般信息，请参阅文本序列类型 - str。
629 
630 sum（iterable [，start ] ）
631 资金开始和的项目迭代由左到右，并返回总。 开始默认为0。该迭代的项目通常是数字，起始值不允许是一个字符串。
632 
633 对于一些用例，有很好的选择sum()。连接字符串序列的首选方式是快速调用 ''.join(sequence)。要添加具有扩展精度的浮点值，请参见math.fsum()。要连接一系列迭代，请考虑使用 itertools.chain()。
634 
635 super（[ type [，object-or-type ] ] ）
636 返回一个代理对象，将代理对象调用类型的父类或同级类。这对于访问在类中被覆盖的继承方法很有用。搜索顺序与使用的顺序相同， getattr()但跳过类型本身。
637 
638 在__mro__该属性类型列出了两种使用方法分辨率搜索顺序getattr()和super()。属性是动态的，每当更新继承层次结构时，它都可以更改。
639 
640 如果省略第二个参数，则返回的超级对象是未绑定的。如果第二个参数是一个对象，则必须为true。如果第二个参数是一个类型，则必须为true（这对于classmethods很有用）。isinstance(obj, type)issubclass(type2, type)
641 
642 超级用户有两个典型用例。在具有单一继承的类层次结构中，超级可以用于引用父类，而不必明确命名它们，从而使代码更易于维护。这种使用与其他编程语言中的super的使用密切相关。
643 
644 第二个用例是在动态执行环境中支持协作多重继承。这种用例对于Python是独一无二的，在静态编译语言或仅支持单一继承的语言中找不到。这使得可以实现多个基类实现相同方法的“菱形图”。良好的设计规定，这种方法在每种情况下具有相同的呼叫签名（因为在运行时确定了调用顺序，因为该顺序适应类层次结构中的更改，并且因为该顺序可以包括在运行时之前未知的兄弟类）。
645 
646 对于这两种用例，典型的超类调用如下所示：
647 
648 class  C （B ）：
649     def  method （self ， arg ）：
650         super （）。方法（arg ）    ＃这样做同样的事情：
651                                ＃super（C，self）.method（arg）
652 注意，super()作为明确的虚拟属性查找的绑定过程的一部分实现，例如super().__getitem__(name)。它通过实现自己的__getattribute__()方法来以可预测的顺序搜索类，从而支持协作多重继承。因此，super()对于使用诸如此类的语句或运算符的隐式查找是未定义的super()[name]。
653 
654 另请注意，除零参数形式外，super()不限于使用内部方法。两个参数形式精确地指定参数，并进行适当的引用。零参数形式仅适用于类定义，因为编译器填写必要的详细信息以正确检索正在定义的类，以及访问普通方法的当前实例。
655 
656 关于如何设计合作课程的实际建议 super()，请参阅使用super（）的指南。
657 
658 tuple（[ 可迭代] ）
659 而不是一个功能，tuple实际上是不可变的序列的类型，如记录元组和序列类型-列表，元组，范围。
660 
661 类type（对象）
662 类type（名称，基地，字典）
663 使用一个参数，返回一个对象的类型。返回值是一个类型对象，通常与返回的对象相同 object.__class__。
664 
665 isinstance()建议使用内置函数来测试对象的类型，因为它考虑到子类。
666 
667 有三个参数，返回一个新的类型对象。这本质上是class声明的动态形式。该名字符串类名，并成为__name__属性; 所述碱 元组逐条列出的基类和成为__bases__ 属性; 而dict字典是包含类体定义的命名空间，并被复制到标准字典以成为 __dict__属性。例如，以下两个语句创建相同的type对象：
668 
669 >>>
670 >>> class  X ：
671 ...     a  =  1 
672 ... 
673 >>> X  =  type （'X' ， （object ，）， dict （a = 1 ））
674 另请参见键入对象。
675 
676 在版本3.6中更改：type不覆盖的子类type.__new__可能不再使用单参数形式来获取对象的类型。
677 
678 vars（[ object ] ）
679 返回__dict__模块，类，实例或具有__dict__属性的任何其他对象的属性。
680 
681 模块和实例等对象具有可更新__dict__ 属性; 然而，其他对象可能对其__dict__属性具有写入限制 （例如，类使用a types.MappingProxyType来防止直接字典更新）。
682 
683 没有争论，vars()就像locals()。请注意，本地字典仅对读取有用，因为对本地字典的更新将被忽略。
684 
685 zip（* iterables ）
686 做一个迭代器来聚合每个迭代的元素。
687 
688 返回元组的迭代器，其中第i个元组包含来自每个参数序列或迭代的第i个元素。当最短输入iterable耗尽时，迭代器停止。使用单个可迭代参数，它返回1元组的迭代器。没有参数，它返回一个空的迭代器。相当于：
689 
690 def  zip （* iterables ）：
691     ＃zip（'ABCD'，'xy'） - > Ax by 
692     sentinel  =  object （）
693     iterators  =  [ iter （it ） for  it  in  iterables ] 
694     while  iterators ：
695         result  =  [] 
696         for  it  in  迭代器：
697             elem  =  next （it ， sentinel ）
698             如果 elem  是 sentinel ：
699                 return 
700             result 。附加（elem ）
701         yield  tuple （result ）
702 确保迭代的从左到右的评估顺序。这使得使用数字系列成为n个长度组的成语成为可能zip(*[iter(s)]*n)。这将重复相同的迭代器n次数，以便每个输出元组具有n对迭代器的调用结果。这具有将输入划分成n长度块的效果。
703 
704 zip()只有当您不关心较长的迭代中的尾随，不匹配的值时，才应使用不等长的输入。如果这些值很重要，请itertools.zip_longest()改用。
705 
706 zip()结合*操作员可以用来解压缩列表：
707 
708 >>>
709 >>> X  =  [ 1 ， 2 ， 3 ] 
710 >>> Ŷ  =  [ 4 ， 5 ， 6 ] 
711 >>> 压缩 =  拉链（X ， ÿ ）
712 >>> 列表（压缩）
713 [（1，4），（ 2，5），（3，6）] 
714 >>> x2 ， y2  =  zip （* zip （x ， y ））
715 >>> x  ==  list （x2 ） 和 y  ==  list （y2 ）
716 True
717 __import__（name，globals = None，locals = None，fromlist =（），level = 0 ）
718 注意 这是一个在日常Python编程中不需要的高级功能importlib.import_module()。
719 该函数由import语句调用。它可以被替换（通过导入builtins模块和分配给 builtins.__import__）来改变import语句的语义 ，但这样做是非常不鼓励的，因为通常使用导入钩子更简单（参见PEP 302）以达到相同的目标，并且不会导致使用默认导入实现的代码问题。直接使用__import__()也不鼓励importlib.import_module()。
720 
721 该函数导入模块名称，潜在地使用给定的全局变量 和本地人来确定如何解释包上下文中的名称。在fromlist里给出了应该从给出的模块导入的对象或子的名字命名。标准实现根本不使用其locals参数，并且仅使用其全局变量来确定import语句的包上下文。
722 
723 level指定是使用绝对还是相对导入。0（默认值）表示仅执行绝对导入。级别的正值 表示要相对于模块调用的目录搜索的父目录的数量__import__()（见PEP 328详细信息）。
724 
725 当名称变量为形式时package.module，通常会返回顶级包（名称直到第一个点），而不是名称的模块。但是，如果给出非空的fromlist参数，则返回名为name的模块。
726 
727 例如，该语句的字节码类似于以下代码：import spam
728 
729 垃圾邮件 =  __import__ （'垃圾邮件' ， 全局（）， 当地人（）， []， 0 ）
730 该声明导致此电话：import spam.ham
731 
732 垃圾邮件 =  __import__ （'spam.ham' ， 全局（）， 当地人（）， []， 0 ）
733 注意__import__()在这里返回toplevel模块，因为这是由import语句绑定到一个名称的对象。
734 
735 另一方面，声明导致from spam.ham import eggs, sausage as saus
736 
737 _temp  =  __import__ （'spam.ham' ， 全局（）， 当地人（）， [ '鸡蛋' ， '香肠' ]， 0 ）
738 鸡蛋 =  _temp 。鸡蛋
739 saus  =  _temp 。香肠
740 在这里，spam.ham返回模块__import__()。从该对象中，要导入的名称被检索并分配给它们各自的名称。
741 
742 如果您只想按名称导入一个模块（可能在一个包中），请使用importlib.import_module()。
743 
744 版本3.3中更改：不再支持级别的负值（也将默认值更改为0）。
745 
746 脚注