内置函数

Python解释器内置了许多始终可用的函数和类型。它们按字母顺序列在此处。

• abs（x ）

• 返回数字的绝对值。参数可以是整数或浮点数。如果参数是复数，则返回其大小。

• all（可迭代的）

• 返回True如果的所有元素迭代是真实的（或者如果可迭代为空）。相当于：

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

• any（可迭代的）

• True如果iterable的任何元素为true ，则返回。如果iterable为空，则返回False。相当于：

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

• ascii（对象）

• 如repr()，由返回的字符串中返回一个包含对象的可打印表示一个字符串，但逃避非ASCII字符 repr()使用\x，\u或\U逃逸。这会生成一个类似于repr()Python 2 中返回的字符串。

• bin（x ）

• 将整数转换为前缀为“0b”的二进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个__index__()返回整数的方法。一些例子：

  >>>

  >>> bin(3)'0b11'

• >>> bin(-10)
  '-0b1010'

  如果需要前缀“0b”，您可以使用以下任一方法。

  >>>

  >>> format(14, '#b'), format(14, 'b')('0b1110', '1110')

• >>> f'{14:#b}', f'{14:b}'('0b1110', '1110')

  另请参阅format()更多信息。

• class bool（[ x ] ）

• 返回一个布尔值，即True或者之一False。 使用标准真值测试程序转换x。如果x为false或省略，则返回; 否则它会返回。的 类是的子类（参见数值类型-整数，浮点，复合）。它不能进一步细分。它的唯一实例是和 （参见布尔值）。FalseTrueboolintFalseTrue

• breakpoint（* args，** kws ）

• 此函数会将您置于调用站点的调试器中。具体来说，它呼叫sys.breakpointhook()，传递args和kws直接通过。默认情况下，sys.breakpointhook()调用 pdb.set_trace()不需要参数。在这种情况下，它纯粹是一个便利功能，因此您无需显式导入 pdb或输入尽可能多的代码即可进入调试器。但是， sys.breakpointhook()可以设置为其他一些功能并 breakpoint()自动调用它，允许您进入选择的调试器。

  版本3.7中的新功能。

• class bytearray（[ source [，encoding [，errors ] ] ] ）

• 返回一个新的字节数组。的bytearray类是整数的范围为0 <= X一个可变的序列<256它具有最的可变序列，在所描述的常规方法的可变序列类型，以及大多数方法，该bytes类型已见字节和ByteArray操作。

  可选的source参数可用于以几种不同的方式初始化数组：

  如果没有参数，则会创建一个大小为0的数组。

  另请参见二进制序列类型 - 字节，bytearray，memoryview和Bytearray对象。

• 如果它是一个字符串，您还必须提供编码（和可选的， 错误）参数; bytearray()然后使用将字符串转换为字节str.encode()。

• 如果它是一个整数，则该数组将具有该大小，并将使用空字节进行初始化。

• 如果它是符合缓冲区接口的对象，则将使用该对象的只读缓冲区来初始化bytes数组。

• 如果它是可迭代的，则它必须是范围内的可迭代整数 ，它们用作数组的初始内容。0 <= x < 256

• class bytes（[ source [，encoding [，errors ] ] ] ）

• 返回一个新的“bytes”对象，该对象是该范围内不可变的整数序列。 是一个不可变的版本 - 它具有相同的非变异方法和相同的索引和切片行为。0 <= x < 256bytesbytearray

  因此，构造函数参数被解释为bytearray()。

  也可以使用文字创建字节对象，请参阅字符串和字节文字。

  另请参见二进制序列类型 - 字节，字节数组，内存视图，字节对象以及字节和字节操作。

• callable（对象）

• True如果object参数显示为可调用 False则返回，否则返回。如果返回true，则调用仍然可能失败，但如果为false，则调用对象将永远不会成功。请注意，类是可调用的（调用类会返回一个新实例）; 如果实例的类有__call__()方法，则它们是可调用的。

  版本3.2中的新功能：此功能首先在Python 3.0中删除，然后在Python 3.2中恢复。

• chr（i ）

• 返回表示Unicode代码点为整数i的字符的字符串。例如，chr(97)返回字符串'a'，同时 chr(8364)返回字符串'€'。这是相反的ord()。

  参数的有效范围是0到1,114,111（基数为16的0x10FFFF）。 ValueError如果我超出该范围，我将被提出。

• @classmethod

• 将方法转换为类方法。

  类方法接收类作为隐式的第一个参数，就像实例方法接收实例一样。要声明一个类方法，请使用此习语：

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

  该@classmethod形式是一个函数装饰 -见的功能定义描述函数定义的细节。

  它可以在类（例如C.f()）或实例（例如C().f()）上调用。除了类之外，该实例被忽略。如果为派生类调用类方法，则派生类对象将作为隐含的第一个参数传递。

  类方法与C ++或Java静态方法不同。如果您需要，请参阅staticmethod()本节。

  有关类方法的更多信息，请参阅标准类型层次结构中标准类型层次结构的文档。

• compile（source，filename，mode，flags = 0，dont_inherit = False，optimize = -1 ）

• 将源代码编译为代码或AST对象。代码对象可以由exec()或执行eval()。 source可以是普通字符串，字节字符串或AST对象。ast有关如何使用AST对象的信息，请参阅模块文档。

  该文件名参数应该给从代码读取的文件; 如果没有从文件中读取（'<string>'通常使用），则传递一些可识别的值。

  该模式参数指定什么样的代码必须进行编译; 它可以是 'exec'，如果源包含的语句序列的，'eval'如果它由一个单一的表达的，或者'single'如果它由单个交互式声明的（在后一种情况下，计算结果为比其他东西表达式语句None将被打印）。

  可选参数flags和dont_inherit控制将来的语句影响源的编译。如果两者都不存在（或者两者都为零），则使用在调用的代码中生效的那些将来的语句来编译代码compile()。如果 给出flags参数且dont_inherit不是（或为零），则除了将要使用的那些语句之外，还使用flags参数指定的future语句。如果dont_inherit是一个非零整数，那么flags参数就是它 - 忽略了对编译调用有效的未来语句。

  将来的语句由位指定，这些位可以按位OR运算以指定多个语句。指定给定特征所需的位域可以作为模块中实例的compiler_flag属性找到。_Feature__future__

  参数optimize指定编译器的优化级别; 默认值-1选择由-O选项给出的解释器的优化级别。显式级别是0（没有优化; __debug__是真的），1（断言被删除，__debug__是假的）或2（文档字符串也被删除）。

  SyntaxError如果编译的源无效，并且ValueError源包含空字节，则此函数会引发。

  如果要将Python代码解析为其AST表示，请参阅 ast.parse()。

  注意

   

  在'single'或 'eval'模式下使用多行代码编译字符串时，输入必须至少由一个换行符终止。这有助于检测code模块中不完整和完整的语句。

  警告

   

  由于Python AST编译器中的堆栈深度限制，在编译为AST对象时，可能会使Python解释器崩溃并使用足够大/复杂的字符串。

  版本3.2中已更改：允许使用Windows和Mac换行符。在'exec'模式中输入也不必再以换行符结尾。添加了optimize参数。

  在3.5版中更改：以前TypeError在源中遇到空字节时引发。

• class complex（[ real [，imag ] ] ）

• 返回值为real + imag * 1j的复数或将字符串或数字转换为复数。如果第一个参数是一个字符串，它将被解释为一个复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数永远不能是字符串。每个参数可以是任何数字类型（包括复数）。如果IMAG被省略，默认为零，并且构造用作数字转换等 int和float。如果省略两个参数，则返回 0j。

  注意

   

  从字符串转换时，字符串不得包含中心+或-运算符周围的空格。例如， complex('1+2j')很好，但提高 。complex('1 + 2j')ValueError

  复杂类型在数值类型中描述- int，float，complex。

  版本3.6中已更改：允许使用下划线对数字进行分组，如代码文字中所示。

• delattr（对象，名称）

• 这是一个亲戚setattr()。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。如果对象允许，该函数将删除命名属性。例如，相当于。delattr(x, 'foobar')del x.foobar

• 上课dict（** kwarg ）

• class dict（mapping，** kwarg ）

• class dict（iterable，** kwarg ）

• 创建一个新词典。该dict对象是字典类。有关此类的文档，请参阅dict和映射类型 - dict。

  对于其他容器看到内置list，set以及 tuple类，还有collections模块。

• dir（[ 对象] ）

• 如果没有参数，则返回当前本地范围中的名称列表。使用参数，尝试返回该对象的有效属性列表。

  如果对象具有名为的__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()它主要是为了方便在交互式提示中使用而提供的，所以它试图提供一组有趣的名称，而不是尝试提供严格或一致定义的名称集，并且其详细行为可能会在不同版本之间发生变化。例如，当参数是类时，元类属性不在结果列表中。

• 如果对象是模块对象，则列表包含模块属性的名称。

• 如果对象是类型或类对象，则列表包含其属性的名称，并递归地包含其基础的属性。

• 否则，该列表包含对象的属性名称，其类的属性的名称，以及其类的基类的属性的递归。

• divmod（a，b ）

• 将两个（非复数）数作为参数，并在使用整数除法时返回由商和余数组成的一对数。对于混合操作数类型，二进制算术运算符的规则适用。对于整数，结果与之相同。对于浮点数，结果是，其中q通常但可能比该值小1。在任何情况下非常接近a，如果非零，则它与b具有相同的符号，并且。(a // b, a % b)(q, a %b)math.floor(a / b)q * b + a % ba % b0 <= abs(a % b) < abs(b)

• enumerate（iterable，start = 0 ）

• 返回一个枚举对象。iterable必须是序列， 迭代器或支持迭代的其他对象。__next__()返回的迭代器的方法enumerate()返回一个包含计数的元组（从start开始，默认为0）和迭代迭代得到的值。

  >>>

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

• eval（表达式，globals = None，locals = None ）

• 参数是一个字符串和可选的全局变量和本地变量。如果提供， globals必须是字典。如果提供，则locals可以是任何映射对象。

  该表达参数分析，并作为一个Python表达式来使用（从技术上来说，一个条件列表）全局和当地人 的字典作为全局和局部名字空间。如果全局字典存在且缺少'__builtins__'，则 在解析表达式之前将当前全局变量复制到全局变量中。这意味着表达式通常具有对标准模块的完全访问权限，并且传播受限制的环境。如果省略locals字典，则默认为全局变量builtins 字典。如果省略两个字典，则表达式在eval()调用的环境中执行。返回值是计算表达式的结果。语法错误报告为异常。例：

  >>>

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

  此函数还可用于执行任意代码对象（例如由其创建的代码对象compile()）。在这种情况下，传递代码对象而不是字符串。如果代码对象已经被编译'exec'为 模式的说法，eval()“返回值会None。

  提示：exec() 函数支持动态执行语句。的globals()和locals()功能返回当前全球和本地词典，分别，其可以是通过以绕过使用有用eval()或exec()。

  请参阅ast.literal_eval()可以安全地使用仅包含文字的表达式来评估字符串的函数。

• exec（object [，globals [，locals ] ] ）

• 此函数支持Python代码的动态执行。object必须是字符串或代码对象。如果它是一个字符串，则将该字符串解析为一组Python语句，然后执行该语句（除非发生语法错误）。[1]如果是代码对象，则只执行它。在所有情况下，执行的代码应该作为文件输入有效（请参见“参考手册”中的“文件输入”部分）。请注意， 即使在传递给函数的代码的上下文中，也不能在函数定义之外使用return和yield语句 exec()。返回值是None。

  在所有情况下，如果省略可选部分，则代码在当前范围内执行。如果只提供全局变量，则它必须是字典，它将用于全局变量和局部变量。如果全局和 当地人给出，它们分别用于全局和局部变量。如果提供，则locals可以是任何映射对象。请记住，在模块级别，全局变量和本地变量是相同的字典。如果exec获得两个单独的对象作为全局变量和局部变量，则代码将被执行，就好像它嵌入在类定义中一样。

  如果全局字典不包含键的值， 则在该键下插入__builtins__对内置模块的字典的引用 builtins。这样，您可以通过在传递给自己的__builtins__字典之前将自己的字典插入到globals中来控制已执行代码可用的内置函数exec()。

  注意

   

  内置函数globals()并分别locals()返回当前的全局和本地字典，这可能有助于传递用作第二个和第三个参数exec()。

  注意

   

  默认的locals的行为如locals()下面的函数所述：不应尝试修改默认的locals字典。如果需要在函数返回后查看代码对locals的影响，请传递显式的locals字典。exec()

• filter（功能，可迭代）

• 从iterable的那些元素构造一个迭代器，函数 返回true。 iterable可以是序列，支持迭代的容器，也可以是迭代器。如果功能是None，同样的函数被假定，那就是，所有的元素迭代是假的被删除。

  需要注意的是相当于发电机表达式，如果功能不和，如果功能 。filter(function, iterable)(item for itemin iterable if function(item))None(item for item in iterable if item)None

  请参阅itertools.filterfalse()补充函数，该函数返回iterable的元素，该函数返回false。

• class float（[ x ] ）

• 返回由数字或字符串x构造的浮点数。

  如果参数是一个字符串，它应该包含一个十进制数字，可选地以符号开头，并且可选地嵌入在空格中。可选标志可以是'+'或'-'; 一个'+'符号具有上产生的值没有影响。参数也可以是表示NaN（非数字）或正或负无穷大的字符串。更准确地说，在删除前导和尾随空格字符后，输入必须符合以下语法：

  sign           :: =“+”| “ - ” infinity       :: =“Infinity”| “inf” nan            :: =“nan” numeric_value :: =   floatnumber| infinity| numeric_string :: = [ ]nansignnumeric_value

  下面floatnumber是浮点文字中描述的Python浮点文字的形式。案例并不重要，因此，例如，“inf”，“Inf”，“INFINITY”和“iNfINity”都是正无穷大的可接受拼写。

  否则，如果参数是整数或浮点数，则返回具有相同值的浮点数（在Python的浮点精度内）。如果参数超出了Python float的范围，OverflowError则会引发一个。

  对于一般Python对象x，float(x)委托给 x.__float__()。

  如果没有给出参数，0.0则返回。

  例子：

  >>>

  >>> float('+1.23')
  1.23

• >>> float('   -12345\n')
  -12345.0

• >>> float('1e-003')
  0.001

• >>> float('+1E6')
  1000000.0

• >>> float('-Infinity')-inf

  float类型在Numeric Types中描述- int，float，complex。

  版本3.6中已更改：允许使用下划线对数字进行分组，如代码文字中所示。

• format（value [，format_spec ] ）

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

  默认的format_spec是一个空字符串，通常与调用具有相同的效果str(value)。

  转换为 在搜索值的方法时绕过实例字典的调用。一 ，如果该方法搜索到达引发异常 和format_spec非空，或者这两个 format_spec或返回值是不是字符串。format(value, format_spec)type(value).__format__(value,format_spec)__format__()TypeErrorobject

  版本3.4中更改： 如果format_spec不是空字符串，则object().__format__(format_spec)引发。TypeError

• class frozenset（[ iterable ] ）

• 返回一个新frozenset对象，可选地包含从iterable中获取的元素 。 frozenset是一个内置的类。有关此类的文档，请参阅frozenset和 设置类型 - set，frozenset。

  对于其他容器看到内置的set，list， tuple，和dict类，还有collections 模块。

• getattr（对象，名称[，默认] ）

• 返回object的named属性的值。 name必须是一个字符串。如果字符串是对象属性之一的名称，则结果是该属性的值。例如，相当于 。如果named属性不存在，则返回default（如果提供），否则引发。getattr(x,'foobar')x.foobarAttributeError

• globals（）

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

• hasattr（对象，名称）

• 参数是一个对象和一个字符串。结果是，True如果字符串是对象属性之一的名称，False如果不是。（这是通过调用并查看它是否会引发来实现的。）getattr(object, name)AttributeError

• hash（对象）

• 返回对象的哈希值（如果有的话）。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较相等的数字值具有相同的哈希值（即使它们具有不同的类型，如1和1.0的情况）。

  注意

   

  对于具有自定义__hash__()方法的对象，请注意hash() 根据主机的位宽截断返回值。详情__hash__()请见。

• help（[ 对象] ）

• 调用内置帮助系统。（此函数用于交互式使用。）如果未给出参数，则交互式帮助系统将在解释器控制台上启动。如果参数是字符串，则查找字符串作为模块，函数，类，方法，关键字或文档主题的名称，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则会生成对象的帮助页面。

  该函数由site模块添加到内置命名空间。

  在版本3.4中更改：更改为pydoc并且inspect表示报告的可调用签名现在更全面和一致。

• hex（x ）

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

  >>>

  >>> hex(255)'0xff'

• >>> hex(-42)'-0x2a'

  如果要将整数转换为带有前缀或不带前缀的大写或小写十六进制字符串，可以使用以下任一方法：

  >>>

  >>> '%#x' % 255, '%x' % 255, '%X' % 255('0xff', 'ff', 'FF')

• >>> format(255, '#x'), format(255, 'x'), format(255, 'X')('0xff', 'ff', 'FF')

• >>> f'{255:#x}', f'{255:x}', f'{255:X}'('0xff', 'ff', 'FF')

  另请参阅format()更多信息。

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

  注意

   

  要获取float的十六进制字符串表示形式，请使用该 float.hex()方法。

• id（对象）

• 返回对象的“身份”。这是一个整数，在该生命周期内保证该对象是唯一且恒定的。具有非重叠寿命的两个对象可以具有相同的id() 值。

  CPython实现细节：这是内存中对象的地址。

• input（[ 提示] ）

• 如果存在prompt参数，则将其写入标准输出而不带尾随换行符。然后该函数从输入中读取一行，将其转换为字符串（剥离尾部换行符），然后返回该行。读取EOF时，EOFError会引发。例：

  >>>

  >>> s = input('--> ')  --> Monty Python's Flying Circus

• >>> s  "Monty Python's Flying Circus"

  如果readline模块已加载，input()则将使用它来提供精细的行编辑和历史记录功能。

• class int（x = 0 ）

• class int（x，base = 10 ）

• 返回由数字或字符串x构造的整数对象，0如果没有给出参数，则返回 。如果x定义__int__()，则 int(x)返回x.__int__()。如果x定义__trunc__()，则返回x.__trunc__()。对于浮点数，这将截断为零。

  如果X不是数字或如果基给出，则X必须是一个字符串， bytes或bytearray代表一个实例字面整数在基数基。可选地，文字可以在+或之前-（在它们之间没有空格）并且由空格包围。base-n文字由数字0到n-1组成，其中a to z（或Ato 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)

  整数类型在数值类型中描述- int，float，complex。

  在版本3.4中更改：如果base不是实例，int并且基础对象具有 base.__index__方法，则调用该方法以获取基础的整数。以前的版本使用 base.__int__而不是base.__index__。

  版本3.6中已更改：允许使用下划线对数字进行分组，如代码文字中所示。

• isinstance（对象，classinfo ）

• 如果object参数是classinfo 参数的实例，或者是（直接，间接或虚拟）子类的实例，则返回true 。如果object不是给定类型的对象，则该函数始终返回false。如果classinfo是类型对象的元组（或递归，其他此类元组），则如果object是任何类型的实例，则返回true 。如果classinfo不是类型和类型元组的类型或元组，TypeError则会引发异常。

• issubclass（class，classinfo ）

• 如果class是classinfo的子类（直接，间接或虚拟），则返回true 。类被认为是其自身的子类。classinfo可以是类对象的元组，在这种情况下，将检查classinfo中的每个条目。在任何其他情况下，都会引发异常。TypeError

• iter（对象[，sentinel ] ）

• 返回一个迭代器对象。根据第二个参数的存在，第一个参数的解释方式非常不同。如果没有第二个参数，对象必须是支持迭代协议（__iter__()方法）的集合对象，或者它必须支持序列协议（从__getitem__()整数参数开始的方法0）。如果它不支持这些协议中的任何一个， TypeError则引发。如果给出第二个参数sentinel，则object必须是可调用对象。在这种情况下创建的迭代器将为每个对其方法的调用调用没有参数的 对象__next__() ; 如果返回的值等于 sentinel，StopIteration 将被提出，否则将返回该值。

  另请参见迭代器类型。

  第二种形式的一个有用的应用iter()是读取文件的行直到达到某一行。以下示例读取文件，直到该readline()方法返回空字符串：

  with open('mydata.txt') as fp:
      for line in iter(fp.readline, ''):
          process_line(line)

• len（s ）

• 返回对象的长度（项数）。参数可以是序列（例如字符串，字节，元组，列表或范围）或集合（例如字典，集合或冻结集合）。

• class list（[ iterable ] ）

• 实际上，它不是一个函数，而是list一个可变序列类型，如列表和序列类型 - list，tuple，range所述。

• locals（）

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

  注意

   

  不应修改此词典的内容; 更改可能不会影响解释器使用的本地和自由变量的值。

• map（功能，可迭代，...... ）

• 返回一个迭代器，它将函数应用于每个iterable项，从而产生结果。如果传递了其他可迭代参数，则 函数必须采用那么多参数，并且并行地应用于所有迭代的项。使用多个iterables时，迭代器会在最短的iterable耗尽时停止。对于函数输入已经排列成参数元组的情况，请参阅itertools.starmap()。

• max（iterable，* [，key，default ] ）

• max（arg1，arg2，* args [，key ] ）

• 返回可迭代中的最大项或两个或多个参数中的最大项。

  如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最大项。如果提供了两个或多个位置参数，则返回最大的位置参数。

  有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空并且未提供default， ValueError则引发a。

  如果多个项目是最大的，则该函数返回遇到的第一个项目。这与其他排序稳定性保留工具（例如和）一致 。sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc)

  在新版本3.4：在默认情况下只有关键字的说法。

• memoryview（obj ）

• 返回从给定参数创建的“内存视图”对象。有关更多信息，请参阅 内存视图

• min（iterable，* [，key，default ] ）

• min（arg1，arg2，* args [，key ] ）

• 返回可迭代中的最小项或两个或多个参数中的最小项。

  如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最小项。如果提供了两个或多个位置参数，则返回最小的位置参数。

  有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空并且未提供default， ValueError则引发a。

  如果多个项目是最小的，则该函数返回遇到的第一个项目。这与其他排序稳定性保留工具（例如和）一致。sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc)

  在新版本3.4：在默认情况下只有关键字的说法。

• next（迭代器[，默认] ）

• 通过调用其 方法从迭代器中检索下一个项目__next__()。如果给定default，则在迭代器耗尽时返回，否则StopIteration引发。

• 类object

• 返回一个新的无特征对象。 object是所有课程的基础。它具有所有Python类实例共有的方法。此函数不接受任何参数。

  注意

   

  object没有不有__dict__，所以你不能指定任意属性的实例object类。

• 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')

  另请参阅format()更多信息。

• open（file，mode ='r'，buffering = -1，encoding = None，errors = None，newline = None，closefd = True，opener = None ）

• 打开文件并返回相应的文件对象。如果无法打开文件，OSError则引发a。

  file是一个类似路径的对象，给出要打开的文件的路径名（绝对或相对于当前工作目录）或要包装的文件的整数文件描述符。（如果给出了文件描述符，则在关闭返回的I / O对象时将关闭它，除非将closefd 设置为False。）

  mode是一个可选字符串，用于指定打开文件的模式。它默认'r'为在文本模式下打开以进行读取。其他常见值'w'用于写入（如果文件已存在则截断文件），'x'独占创建和'a'附加（在某些 Unix系统上，意味着所有写入都附加到文件末尾而不管当前搜索位置）。在文本模式下，如果 编码未指定使用的编码是与平台相关的：locale.getpreferredencoding(False)被称为获取当前的本地编码。（对于读取和写入原始字节，请使用二进制模式并保留 编码未指定。）可用模式为：

  字符	含义
  'r'	开放阅读（默认）
  'w'	打开写入，先截断文件
  'x'	打开以进行独占创建，如果文件已存在则失败
  'a'	打开以进行写入，如果存在则附加到文件的末尾
  'b'	二进制模式
  't'	文字模式（默认）
  '+'	打开磁盘文件进行更新（读写）
  'U'	通用换行模式（已弃用）

  默认模式是'r'（打开以读取文本，同义词'rt'）。对于二进制读写访问，模式'w+b'打开并将文件截断为0字节。 'r+b'打开文件而不截断。

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

  注意

   

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

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

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

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

  换行符控制通用换行模式的工作方式（仅适用于文本模式）。它可以是None，''，'\n'，'\r'，和 '\r\n'。它的工作原理如下：

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

  通过传递可调用的开启者可以使用自定义开启器。然后通过使用（file，flags）调用opener来获取文件对象的基础文件描述符。opener必须返回一个打开的文件描述符（作为opener传递的 结果类似于传递的功能 ）。os.openNone

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

  以下示例使用函数的dir_fd参数 os.open()打开相对于给定目录的文件：

  >>>

  >>> 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()取决于模式。当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中更改：

  版本3.4中已更改：

  自从3.4版本弃用，将在4.0版本中删除：该'U'模式。

  版本3.5中已更改：

  在版本3.6中更改：

• 添加了支持以接受实现的对象os.PathLike。

• 在Windows上，打开控制台缓冲区可能会返回io.RawIOBase除以外的子类 io.FileIO。

• 如果系统调用中断且信号处理程序没有引发异常，则该函数现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。

• 在'namereplace'加入错误处理程序。

• 该文件现在是不可继承的。

• 在揭幕战中添加参数。

• 该'x'模式已添加。

• IOError曾经被提出，它现在是别名OSError。

• FileExistsError如果在独占创建模式（'x'）中打开的文件已存在，则现在引发。

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

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

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

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

• 'replace'导致'?'在有错误数据的地方插入替换标记（例如）。

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

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

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

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

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

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

• ord（c ）

• 给定表示一个Unicode字符的字符串，返回表示该字符的Unicode代码点的整数。例如， ord('a')返回整数97和ord('€')（欧元符号）返回值8364。这是相反的chr()。

• pow（x，y [，z ] ）

• 将x返回到y ; 如果z存在，则将x返回到幂y，模z（比计算得更有效）。双参数形式相当于使用幂运算符：。pow(x, y) % zpow(x, y)x**y

  参数必须具有数字类型。对于混合操作数类型，二进制算术运算符的强制规则适用。对于int 操作数，结果与操作数的类型相同（在强制之后），除非第二个参数是否定的; 在这种情况下，所有参数都转换为float并传递float结果。例如，10**2 返回100，但10**-2返回0.01。如果第二个参数为负数，则必须省略第三个参数。如果存在z，则x和y 必须是整数类型，y必须是非负的。

• print（* objects，sep =''，end ='\ n'，file = sys.stdout，flush = False ）

• 将对象打印到文本流文件，以sep分隔，然后结束。 sep，end，file和flush（如果存在）必须作为关键字参数给出。

  所有非关键字参数都转换为类似于do的字符串str()并写入流中，由sep分隔，然后是end。无论九月 和年底必须是字符串; 它们也可以None，这意味着使用默认值。如果没有给出对象，print()则只写 结束。

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

  输出是否缓冲通常由文件确定，但如果 flush关键字参数为true，则强制刷新流。

  版本3.3中已更改：添加了flush关键字参数。

• class property（fget = None，fset = None，fdel = None，doc = None ）

• 返回属性属性。

  fget是获取属性值的函数。 fset是用于设置属性值的函数。fdel是用于删除属性值的函数。和文档创建的属性的文档字符串。

  典型用法是定义托管属性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， 将调用setter和deleter。c.x = valuedel c.x

  如果给定，doc将是property属性的docstring。否则，该属性将复制fget的docstring（如果存在）。这使得它能够很容易地创建只读属性使用property()作为装饰：

  class Parrot:
      def __init__(self):
          self._voltage = 100000
  
      @property
      def voltage(self):
          """Get the current voltage."""
          return self._voltage

  该@property装饰变成的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中更改：属性对象的文档字符串现在是可写的。

• range（停止）

• range（开始，停止[，步骤] ）

• 实际上，它不是一个函数，而是range一个不可变的序列类型，如范围和序列类型 - list，tuple，range中所述。

• repr（对象）

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

• reversed（seq ）

• 返回反向迭代器。 seq必须是一个具有__reversed__()方法或支持序列协议的对象（ __len__()方法和方法以及从中__getitem__()开始的整数参数0）。

• round（编号[，ndigits ] ）

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

  对于内置类型支持round()，值被舍入到最接近的10的倍数到幂减去ndigits ; 如果两个倍数相等，则向均匀选择进行舍入（例如，两个round(0.5)和round(-0.5)都是0，并且round(1.5)是 2）。任何整数值对ndigits（正数，零或负数）有效。如果省略ndigits，则 返回值为整数None。否则返回值与数字的类型相同。

  对于一般Python对象number，round委托给 number.__round__。

  注意

   

  round()浮动的行为可能会令人惊讶：例如， 给出而不是预期的行为。这不是一个错误：这是因为大多数小数部分不能完全表示为浮点数。有关详细信息，请参阅浮点算术：问题和限制。round(2.675,2)2.672.68

• class set（[ iterable ] ）

• 返回一个新set对象，可选地包含从iterable中获取的元素 。 set是一个内置的类。有关此类的文档，请参阅set和 设置类型 - set，frozenset。

  对于其他容器看到内置的frozenset，list， tuple，和dict类，还有collections 模块。

• setattr（对象，名称，值）

• 这是对应的getattr()。参数是一个对象，一个字符串和一个任意值。该字符串可以命名现有属性或新属性。如果对象允许，该函数会将值分配给属性。例如，相当于 。setattr(x, 'foobar', 123)x.foobar = 123

• class slice（停止）

• class slice（start，stop [，step ] ）

• 返回表示由指定的索引集的切片对象 。在启动和步参数默认为 。切片对象具有只读数据属性， 并且仅返回参数值（或其默认值）。他们没有其他明确的功能; 但是它们被Numerical Python和其他第三方扩展使用。使用扩展索引语法时也会生成切片对象。例如：或。有关返回迭代器的备用版本，请参阅参考资料 。range(start, stop, step)Nonestartstopstepa[start:stop:step]a[start:stop, i]itertools.islice()

• sorted（iterable，*，key = None，reverse = False ）

• 从iterable中的项返回一个新的排序列表。

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

  key指定一个参数的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值为None （直接比较元素）。

  reverse是一个布尔值。如果设置为True，则对列表元素进行排序，就好像每个比较都已反转一样。

  用functools.cmp_to_key()一个老式的转换CMP功能的 关键功能。

  内置sorted()功能保证稳定。如果排序保证不更改比较相等的元素的相对顺序，则排序是稳定的 - 这有助于在多个过程中进行排序（例如，按部门排序，然后按工资等级排序）。

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

• @staticmethod

• 将方法转换为静态方法。

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

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

  该@staticmethod形式是一个函数装饰 -见的功能定义描述函数定义的细节。

  它可以在类（例如C.f()）或实例（例如C().f()）上调用。除了类之外，该实例被忽略。

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

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

  class C:
      builtin_open = staticmethod(open)

  有关静态方法的详细信息，请参阅标准类型层次结构中标准类型层次结构的文档。

• class str（object ='' ）

• class str（object = b''，encoding ='utf-8'，errors ='strict' ）

• 返回一个对象str版本。详情请见。str()

  str是内置的字符串类。有关字符串的一般信息，请参阅文本序列类型 - str。

• sum（iterable [，start ] ）

• Sums 从左到右开始和迭代的项目并返回总数。 开始默认为0。该迭代的项目通常是数字，起始值不允许是一个字符串。

  对于某些用例，有很好的替代方案sum()。连接字符串序列的首选快速方法是调用 ''.join(sequence)。要添加具有扩展精度的浮点值，请参阅math.fsum()。要连接一系列迭代，请考虑使用 itertools.chain()。

• super（[ type [，object-or-type ] ] ）

• 返回将方法调用委托给父类或兄弟类类型的代理对象。这对于访问已在类中重写的继承方法很有用。getattr()除了跳过类型本身之外，搜索顺序与使用的搜索顺序相同 。

  在__mro__该属性类型列出了两种使用方法分辨率搜索顺序getattr()和super()。该属性是动态的，只要更新继承层次结构，就可以更改该属性。

  如果省略第二个参数，则返回的超级对象是未绑定的。如果第二个参数是一个对象，则必须为true。如果第二个参数是一个类型，则必须为true（这对于classmethods很有用）。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()是作为显式点状属性查找的绑定过程的一部分实现的，例如super().__getitem__(name)。它通过实现自己的__getattribute__()方法以可预测的顺序搜索类来支持协作多重继承。因此，super()对于使用语句或运算符（例如）的隐式查找，未定义super()[name]。

  另请注意，除零参数形式外，super()不限于使用内部方法。两个参数形式完全指定参数并进行适当的引用。零参数形式仅适用于类定义，因为编译器填写必要的细节以正确检索正在定义的类，以及访问普通方法的当前实例。

  有关如何设计合作类的实用建议 super()，请参阅使用super（）的指南。

• tuple（[ 可迭代] ）

• 实际上，它不是一个函数，而是tuple一个不可变的序列类型，如元组和序列类型 - list，tuple，range中所述。

• class type（object ）

• 类type（名称，基数，字典）

• 使用一个参数，返回对象的类型。返回值是一个类型对象，通常与返回的对象相同 object.__class__。

  isinstance()建议使用内置函数来测试对象的类型，因为它考虑了子类。

  使用三个参数，返回一个新类型对象。这基本上是class声明的动态形式。该名字符串类名，并成为__name__属性; 所述碱 元组逐条列出的基类和成为__bases__ 属性; 和字典的字典是包含用于类定义体的命名空间和被复制到标准词典成为 __dict__属性。例如，以下两个语句创建相同的type对象：

  >>>

  >>> class X:

• ...     a = 1

• ...

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

  另请参见类型对象。

  在版本3.6中更改：type不覆盖的子类type.__new__可能不再使用单参数形式来获取对象的类型。

• vars（[ 对象] ）

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

  模块和实例等对象具有可更新的__dict__ 属性; 但是，其他对象可能对其__dict__属性具有写入限制 （例如，类使用a types.MappingProxyType来防止直接字典更新）。

  没有争论，vars()行为就像locals()。请注意，locals字典仅对读取有用，因为忽略了对locals字典的更新。

• zip（* iterables ）

• 创建一个聚合来自每个迭代的元素的迭代器。

  返回元组的迭代器，其中第i个元组包含来自每个参数序列或迭代的第i个元素。当最短输入可迭代用尽时，迭代器停止。使用单个iterable参数，它返回一个1元组的迭代器。没有参数，它返回一个空迭代器。相当于：

  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)

  保证了迭代的从左到右的评估顺序。这使得使用数据系列成为n长度组的习惯成为可能zip(*[iter(s)]*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

• __import__（name，globals = None，locals = None，fromlist =（），level = 0 ）

• 注意

   

  这是日常Python编程中不需要的高级函数，不像importlib.import_module()。

  该import语句调用此函数。它可以被替换（通过导入builtins模块并分配给它 builtins.__import__）以便更改import语句的语义 ，但强烈建议不要这样做，因为使用导入钩子通常更简单（参见PEP 302）实现相同的目标，并且不会导致代码假定使用默认导入实现。__import__()也不鼓励直接使用importlib.import_module()。

  该函数可以使用给定的globals 和locals导入模块名称，以确定如何解释包上下文中的名称。在fromlist里给出了应该从给出的模块导入的对象或子的名字命名。标准实现根本不使用其locals参数，并仅使用其全局变量来确定语句的包上下文。import

  level指定是使用绝对导入还是相对导入。0（默认值）表示仅执行绝对导入。level的正值 表示要搜索的父目录相对于模块调用目录的数量__import__()（请参阅PEP 328详情）。

  当name变量属于表单时package.module，通常会返回顶级包（直到第一个点的名称），而不是按名称命名的模块。但是，当给出非空的fromlist参数时，将返回按名称命名的模块。

  例如，语句导致字节码类似于以下代码：import spam

  spam = __import__('spam', globals(), locals(), [], 0)

  该声明导致此调用：import spam.ham

  spam = __import__('spam.ham', globals(), locals(), [], 0)

  注意__import__()这里如何返回toplevel模块，因为这是由import语句绑定到名称的对象。

  另一方面，声明导致from spam.ham import eggs, sausage as saus

  _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)eggs = _temp.eggssaus = _temp.sausage

  这里，spam.ham模块从中返回__import__()。从此对象中，将检索要导入的名称并将其分配给各自的名称。

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

  在版本3.3中更改：不再支持级别的负值（这也将默认值更改为0）。

未经允许不得转载：落叶随风博客 » python内置函数