首页
随机页面
分类
查看“Python/docs/3.8/library/functions”的源代码
来自菜鸟教程
Python/docs/3.8/library/functions / ←
内置函数 — Python 文档
跳转至：
导航
、
搜索
因为以下原因，您没有权限编辑本页：
您请求的操作仅限属于该用户组的用户执行：
用户
您可以查看和复制此页面的源代码。
{{DISPLAYTITLE:内置函数 — Python 文档}} <div id="built-in-functions" class="section"> <span id="built-in-funcs"></span> = 内置函数 = Python 解释器内置了许多始终可用的函数和类型。 它们在此处按字母顺序列出。 {| !width="21%"| !width="18%"| !width="20%"| 内置函数 !width="20%"| !width="22%"| |- | [[#abs|<code>abs()</code>]] | [[#delattr|<code>delattr()</code>]] | [[#hash|<code>hash()</code>]] | [[#func-memoryview|<code>memoryview()</code>]] | [[#func-set|<code>set()</code>]] |- | [[#all|<code>all()</code>]] | [[#func-dict|<code>dict()</code>]] | [[#help|<code>help()</code>]] | [[#min|<code>min()</code>]] | [[#setattr|<code>setattr()</code>]] |- | [[#any|<code>any()</code>]] | [[#dir|<code>dir()</code>]] | [[#hex|<code>hex()</code>]] | [[#next|<code>next()</code>]] | [[#slice|<code>slice()</code>]] |- | [[#ascii|<code>ascii()</code>]] | [[#divmod|<code>divmod()</code>]] | [[#id|<code>id()</code>]] | [[#object|<code>object()</code>]] | [[#sorted|<code>sorted()</code>]] |- | [[#bin|<code>bin()</code>]] | [[#enumerate|<code>enumerate()</code>]] | [[#input|<code>input()</code>]] | [[#oct|<code>oct()</code>]] | [[#staticmethod|<code>staticmethod()</code>]] |- | [[#bool|<code>bool()</code>]] | [[#eval|<code>eval()</code>]] | [[#int|<code>int()</code>]] | [[#open|<code>open()</code>]] | [[#func-str|<code>str()</code>]] |- | [[#breakpoint|<code>breakpoint()</code>]] | [[#exec|<code>exec()</code>]] | [[#isinstance|<code>isinstance()</code>]] | [[#ord|<code>ord()</code>]] | [[#sum|<code>sum()</code>]] |- | [[#func-bytearray|<code>bytearray()</code>]] | [[#filter|<code>filter()</code>]] | [[#issubclass|<code>issubclass()</code>]] | [[#pow|<code>pow()</code>]] | [[#super|<code>super()</code>]] |- | [[#func-bytes|<code>bytes()</code>]] | [[#float|<code>float()</code>]] | [[#iter|<code>iter()</code>]] | [[#print|<code>print()</code>]] | [[#func-tuple|<code>tuple()</code>]] |- | [[#callable|<code>callable()</code>]] | [[#format|<code>format()</code>]] | [[#len|<code>len()</code>]] | [[#property|<code>property()</code>]] | [[#type|<code>type()</code>]] |- | [[#chr|<code>chr()</code>]] | [[#func-frozenset|<code>frozenset()</code>]] | [[#func-list|<code>list()</code>]] | [[#func-range|<code>range()</code>]] | [[#vars|<code>vars()</code>]] |- | [[#classmethod|<code>classmethod()</code>]] | [[#getattr|<code>getattr()</code>]] | [[#locals|<code>locals()</code>]] | [[#repr|<code>repr()</code>]] | [[#zip|<code>zip()</code>]] |- | [[#compile|<code>compile()</code>]] | [[#globals|<code>globals()</code>]] | [[#map|<code>map()</code>]] | [[#reversed|<code>reversed()</code>]] | [[#import__|<code>__import__()</code>]] |- | [[#complex|<code>complex()</code>]] | [[#hasattr|<code>hasattr()</code>]] | [[#max|<code>max()</code>]] | [[#round|<code>round()</code>]] | |} ; <span class="sig-name descname"><span class="pre">abs</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">x</span></span>''<span class="sig-paren">)</span> : 返回数字的绝对值。 参数可以是整数或浮点数。 如果参数是复数，则返回其大小。 如果 ''x'' 定义了 <code>__abs__()</code>，则 <code>abs(x)</code> 返回 <code>x.__abs__()</code>。 <dl> <dt><span class="sig-name descname"><span class="pre">all</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>''<span class="sig-paren">)</span></dt> <dd><p>如果 ''iterable'' 的所有元素都为真（或者如果 iterable 为空），则返回 <code>True</code>。 相当于：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">def all(iterable): for element in iterable: if not element: return False return True</syntaxhighlight> </div> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">any</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>''<span class="sig-paren">)</span></dt> <dd><p>如果 ''iterable'' 的任何元素为真，则返回 <code>True</code>。 如果可迭代对象为空，则返回 <code>False</code>。 相当于：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">def any(iterable): for element in iterable: if element: return True return False</syntaxhighlight> </div> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">ascii</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span> : 作为 [[#repr|repr()]]，返回包含对象的可打印表示的字符串，但使用 <code>\x</code> 转义 [[#repr|repr()]] 返回的字符串中的非 ASCII 字符, <code>\u</code> 或 <code>\U</code> 转义。 这会生成一个类似于 Python 2 中 [[#repr|repr()]] 返回的字符串。 <dl> <dt><span class="sig-name descname"><span class="pre">bin</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">x</span></span>''<span class="sig-paren">)</span></dt> <dd><p>将整数转换为以“0b”为前缀的二进制字符串。 结果是一个有效的 Python 表达式。 如果 ''x'' 不是 Python [[#int|int]] 对象，它必须定义一个返回整数的 <code>__index__()</code> 方法。 一些例子：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> bin(3) '0b11' >>> bin(-10) '-0b1010'</syntaxhighlight> </div> </div> <p>如果需要或不需要前缀“0b”，您可以使用以下任一方式。</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> format(14, '#b'), format(14, 'b') ('0b1110', '1110') >>> f'{14:#b}', f'{14:b}' ('0b1110', '1110')</syntaxhighlight> </div> </div> <p>另见 [[#format|format()]] 了解更多信息。</p></dd></dl> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">bool</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">x</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个布尔值，即 <code>True</code> 或 <code>False</code> 之一。 ''x'' 使用标准的 [[../stdtypes#truth|真值测试程序]] 进行转换。 如果 ''x'' 为假或省略，则返回 <code>False</code>； 否则返回 <code>True</code>。 [[#bool|bool]] 类是 [[#int|int]] 的子类（参见 [[../stdtypes#typesnumeric|Numeric Types - int, float, complex]]）。 它不能被进一步子类化。 它的唯一实例是 <code>False</code> 和 <code>True</code>（请参阅 [[../stdtypes#bltin-boolean-values|布尔值]] ）。</p> <div id="index-0" class="versionchanged"> <p><span class="versionmodified changed"> 在 3.7 版更改：</span>''x'' 现在是仅位置参数。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">breakpoint</span></span><span class="sig-paren">(</span>''<span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span>'', ''<span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kws</span></span>''<span class="sig-paren">)</span></dt> <dd><p>此函数将您带入调用站点的调试器。 具体来说，它调用 [[../sys#sys|sys.breakpointhook()]]，直接传递 <code>args</code> 和 <code>kws</code>。 默认情况下，<code>sys.breakpointhook()</code> 调用 [[../pdb#pdb|pdb.set_trace()]] 不需要参数。 在这种情况下，它纯粹是一个方便的函数，因此您不必显式导入 [[../pdb#module-pdb|pdb]] 或输入尽可能多的代码来进入调试器。 但是，[[../sys#sys|sys.breakpointhook()]] 可以设置为其他一些函数，而 [[#breakpoint|breakpoint()]] 会自动调用它，让您进入选择的调试器。</p> <div class="versionadded"> <p><span class="versionmodified added">3.7 版中的新功能。</span></p> </div></dd></dl> <span id="func-bytearray" class="target"></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">bytearray</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">source</span>''<span class="optional">[</span>, ''<span class="pre">encoding</span>''<span class="optional">[</span>, ''<span class="pre">errors</span>''<span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个新的字节数组。 这[[../stdtypes#bytearray|字节数组]] class 是 0 <= x < 256 范围内的可变整数序列。 它具有可变序列的大多数常用方法，在 [[../stdtypes#typesseq-mutable|可变序列类型]] 中进行了描述，以及 [[../stdtypes#bytes|bytes]] 类型具有的大多数方法，请参阅 [[../stdtypes#bytes-methods|Bytes 和 Bytearray Operations]] ]。</p> <p>可选的 ''source'' 参数可用于以几种不同的方式初始化数组：</p> <ul> <li><p>如果是 ''string''，则还必须给出 ''encoding''（以及可选的 ''errors''）参数； [[../stdtypes#bytearray|bytearray()]] 然后使用 [[../stdtypes#str|str.encode()]] 将字符串转换为字节。</p></li> <li><p>如果它是 ''整数'' ，则数组将具有该大小并使用空字节进行初始化。</p></li> <li><p>如果是符合[[../../c-api/buffer#bufferobjects|buffer接口]]的对象，则使用该对象的只读缓冲区来初始化bytes数组。</p></li> <li><p>如果是 ''iterable''，则必须是 <code>0 <= x < 256</code> 范围内的整数的可迭代对象，用作数组的初始内容。</p></li></ul> <p>如果没有参数，则会创建一个大小为 0 的数组。</p> <p>另请参阅 [[../stdtypes#binaryseq|二进制序列类型 — 字节、字节数组、内存视图]] 和 [[../stdtypes#typebytearray|字节数组对象]] 。</p></dd></dl> <span id="func-bytes" class="target"></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">bytes</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">source</span>''<span class="optional">[</span>, ''<span class="pre">encoding</span>''<span class="optional">[</span>, ''<span class="pre">errors</span>''<span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个新的“字节”对象，它是 <code>0 <= x < 256</code> 范围内的不可变整数序列。 [[../stdtypes#bytes|bytes]] 是 [[../stdtypes#bytearray|bytearray]] 的不可变版本——它具有相同的非变异方法以及相同的索引和切片行为。</p> <p>因此，构造函数参数被解释为 [[../stdtypes#bytearray|bytearray()]]。</p> <p>字节对象也可以用文字创建，请参阅 [[../../reference/lexical_analysis#strings|字符串和字节文字]] 。</p> <p>另请参阅 [[../stdtypes#binaryseq|二进制序列类型 — 字节、字节数组、内存视图]]、[[../stdtypes#typebytes|字节对象]]和[[../stdtypes#bytes-methods|字节和字节数组操作]]。</p></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">callable</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span></dt> <dd><p>如果 ''object'' 参数看起来可调用，则返回 [[../constants#True|True]]，否则返回 [[../constants#False|False]]。 如果这返回<code>True</code>，仍然有可能调用失败，但如果是<code>False</code>，则调用''对象''永远不会成功。 请注意，类是可调用的（调用类会返回一个新实例）； 如果它们的类具有 <code>__call__()</code> 方法，则实例是可调用的。</p> <div class="versionadded"> <p><span class="versionmodified added"> 3.2 版新功能： </span> 该函数首先在 Python 3.0 中被移除，然后在 Python 3.2 中恢复。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">chr</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">i</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回表示 Unicode 代码点为整数 ''i'' 的字符的字符串。 例如，<code>chr(97)</code> 返回字符串 <code>'a'</code>，而 <code>chr(8364)</code> 返回字符串 <code>'€'</code>。 这是 [[#ord|ord()]] 的倒数。</p> <p>参数的有效范围是从 0 到 1,114,111（以 16 为底的 0x10FFFF）。 如果 ''i'' 超出该范围，则会引发 [[../exceptions#ValueError|ValueError]]。</p></dd></dl> <dl> <dt><span class="sig-prename descclassname"><span class="pre">@</span></span><span class="sig-name descname"><span class="pre">classmethod</span></span></dt> <dd><p>将方法转换为类方法。</p> <p>类方法接收类作为隐式第一个参数，就像实例方法接收实例一样。 要声明类方法，请使用以下习惯用法：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">class C: @classmethod def f(cls, arg1, arg2, ...): ...</syntaxhighlight> </div> </div> <p><code>@classmethod</code> 形式是一个函数 [[../../glossary#term-decorator|decorator]]——详见 [[../../reference/compound_stmts#function|函数定义]]。</p> <p>可以在类（例如 <code>C.f()</code>）或实例（例如 <code>C().f()</code>）上调用类方法。 除了它的类之外，该实例被忽略。 如果为派生类调用类方法，则派生类对象将作为隐含的第一个参数传递。</p> <p>类方法不同于 C++ 或 Java 静态方法。 如果你想要这些，请参阅 [[#staticmethod|staticmethod()]]。</p> <p>有关类方法的更多信息，请参阅 [[../../reference/datamodel#types|标准类型层次结构]] 。</p></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">compile</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">source</span></span>'', ''<span class="n"><span class="pre">filename</span></span>'', ''<span class="n"><span class="pre">mode</span></span>'', ''<span class="n"><span class="pre">flags</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span>'', ''<span class="n"><span class="pre">dont_inherit</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span>'', ''<span class="n"><span class="pre">optimize</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">-</span> <span class="pre">1</span></span>''<span class="sig-paren">)</span></dt> <dd><p>将 ''source'' 编译成代码或 AST 对象。 代码对象可以通过 [[#exec|exec()]] 或 [[#eval|eval()]] 执行。 ''source'' 可以是普通字符串、字节字符串或 AST 对象。 有关如何使用 AST 对象的信息，请参阅 [[../ast#module-ast|ast]] 模块文档。</p> <p>''filename'' 参数应该给出读取代码的文件； 如果它不是从文件中读取的，则传递一些可识别的值（通常使用 <code>'<string>'</code>）。</p> <p>''mode'' 参数指定必须编译什么样的代码； 如果 ''source'' 由一系列语句组成，则可以是 <code>'exec'</code>，如果由单个表达式组成，则可以是 <code>'eval'</code>，如果由一个表达式组成，则可以是 <code>'single'</code>单个交互式语句（在后一种情况下，将打印计算结果为 <code>None</code> 以外的值的表达式语句）。</p> <p>可选参数 ''flags'' 和 ''dont_inherit'' 控制哪些 [[../../reference/simple_stmts#future|future statements]] 影响 ''source'' 的编译。 如果两者都不存在（或两者都为零），则使用调用 [[#compile|compile()]] 的代码中有效的未来语句编译代码。 如果给出了 ''flags'' 参数并且 ''dont_inherit'' 不是（或为零），那么除了那些会无论如何都要使用。 如果 ''dont_inherit'' 是一个非零整数，那么 ''flags'' 参数就是它 - 编译调用周围有效的未来语句将被忽略。</p> <p>未来语句由位指定，这些位可以按位或运算在一起以指定多个语句。 指定给定功能所需的位域可以在 [[../__future__#module-__future__|__future__]] 模块中的 <code>_Feature</code> 实例的 <code>compiler_flag</code> 属性中找到。</p> <p>可选参数 ''flags'' 还控制是否允许编译源包含顶级 <code>await</code>、<code>async for</code> 和 <code>async with</code>。 当<code>ast.PyCF_ALLOW_TOP_LEVEL_AWAIT</code>位被设置时，返回码对象在<code>co_code</code>中设置了<code>CO_COROUTINE</code>，并且可以通过<code>await eval(code_object)</code>交互执行。</p> <p>参数 ''optimize'' 指定编译器的优化级别； <code>-1</code> 的默认值选择解释器的优化级别，由 [[../../using/cmdline#cmdoption-O|-O]] 选项给出。 显式级别为 <code>0</code>（无优化；<code>__debug__</code> 为真）、<code>1</code>（断言被移除，<code>__debug__</code> 为假）或 <code>2</code> （文档字符串也被删除）。</p> <p>如果编译源无效，则该函数引发 [[../exceptions#SyntaxError|SyntaxError]]，如果源包含空字节，则引发 [[../exceptions#ValueError|ValueError]]。</p> <p>如果要将 Python 代码解析为其 AST 表示形式，请参阅 [[../ast#ast|ast.parse()]]。</p> <div class="admonition note"> <p>笔记</p> <p>在<code>'single'</code>或<code>'eval'</code>模式下编译多行代码字符串时，输入必须至少以一个换行符结束。 这是为了方便检测[[../code#module-code|code]]模块中不完整和完整的语句。</p> </div> <div class="admonition warning"> <p>警告</p> <p>由于 Python 的 AST 编译器中的堆栈深度限制，在编译为 AST 对象时，可能会使用足够大/复杂的字符串使 Python 解释器崩溃。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.2 版更改： </span> 允许使用 Windows 和 Mac 换行符。 在 <code>'exec'</code> 模式下输入也不必再以换行符结尾。 添加了 ''optimize'' 参数。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.5 版更改： </span> 以前，[[../exceptions#TypeError|TypeError]] 在 ''source'' 中遇到空字节时引发。</p> </div> <div class="versionadded"> <p><span class="versionmodified added">3.8 版新功能：</span><code>ast.PyCF_ALLOW_TOP_LEVEL_AWAIT</code> 现在可以通过标志来支持顶级 <code>await</code>、<code>async for</code> 和 <code>async with</code> ]。</p> </div></dd></dl> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">complex</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">real</span>''<span class="optional">[</span>, ''<span class="pre">imag</span>''<span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回值为 ''real'' + ''imag''*1j 的复数或将字符串或数字转换为复数。 如果第一个参数是一个字符串，它将被解释为一个复数，并且必须在没有第二个参数的情况下调用该函数。 第二个参数永远不能是字符串。 每个参数可以是任何数字类型（包括复数）。 如果省略 ''imag''，则默认为零，并且构造函数用作数字转换，如 [[#int|int]] 和 [[#float|float]]。 如果两个参数都被省略，则返回 <code>0j</code>。</p> <p>对于一般的 Python 对象 <code>x</code>，<code>complex(x)</code> 委托给 <code>x.__complex__()</code>。 如果 <code>__complex__()</code> 未定义，则回退到 <code>__float__()</code>。 如果 <code>__float__()</code> 未定义，则回退到 <code>__index__()</code>。</p> <div class="admonition note"> <p>笔记</p> <p>从字符串转换时，字符串不能在中央 <code>+</code> 或 <code>-</code> 运算符周围包含空格。 例如，<code>complex('1+2j')</code> 很好，但 <code>complex('1 + 2j')</code> 引发 [[../exceptions#ValueError|ValueError]]。</p> </div> <p>复杂类型在 [[../stdtypes#typesnumeric|数字类型 — int、float、complex]] 中进行了描述。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.6 版更改： </span> 允许将数字与代码文字中的下划线分组。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.8 版更改：如果 <code>__complex__()</code> 和 <code>__float__()</code> 未定义，</span>回落到 <code>__index__()</code>。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">delattr</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>'', ''<span class="n"><span class="pre">name</span></span>''<span class="sig-paren">)</span> : 这是 [[#setattr|setattr()]] 的亲戚。 参数是一个对象和一个字符串。 该字符串必须是对象属性之一的名称。 如果对象允许，该函数将删除命名属性。 例如，<code>delattr(x, 'foobar')</code> 等价于 <code>del x.foobar</code>。 <span id="func-dict" class="target"></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">dict</span></span><span class="sig-paren">(</span>''<span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwarg</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">dict</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">mapping</span></span>'', ''<span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwarg</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">dict</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>'', ''<span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwarg</span></span>''<span class="sig-paren">)</span></dt> <dd><p>创建一个新字典。 [[../stdtypes#dict|dict]] 对象是字典类。 有关此类的文档，请参阅 [[../stdtypes#dict|dict]] 和 [[../stdtypes#typesmapping|映射类型 — dict]]。</p> <p>对于其他容器，请参阅内置的 [[../stdtypes#list|list]]、[[../stdtypes#set|set]] 和 [[../stdtypes#tuple|tuple]] 类，以及 [[../collections#module-collections|collections]] 模块。</p></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">dir</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">object</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>不带参数，返回当前本地范围内的名称列表。 使用参数，尝试返回该对象的有效属性列表。</p> <p>如果对象有一个名为 <code>__dir__()</code> 的方法，这个方法将被调用并且必须返回属性列表。 这允许实现自定义 <code>__getattr__()</code> 或 <code>__getattribute__()</code> 函数的对象自定义 [[#dir|dir()]] 报告其属性的方式。</p> <p>如果对象不提供 <code>__dir__()</code>，函数会尽力从对象的 [[../stdtypes#object|__dict__]] 属性（如果已定义）及其类型对象收集信息。 结果列表不一定完整，当对象有自定义<code>__getattr__()</code>时可能不准确。</p> <p>默认的 [[#dir|dir()]] 机制对不同类型的对象表现不同，因为它试图产生最相关的，而不是完整的信息：</p> <ul> <li><p>如果对象是模块对象，则列表包含模块属性的名称。</p></li> <li><p>如果对象是类型或类对象，则列表包含其属性的名称，并递归地包含其基类的属性。</p></li> <li><p>否则，该列表包含对象的属性名称、其类的属性名称以及其类的基类的属性的递归名称。</p></li></ul> <p>结果列表按字母顺序排序。 例如：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> 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']</syntaxhighlight> </div> </div> <div class="admonition note"> <p>笔记</p> <p>因为 [[#dir|dir()]] 主要是为了在交互式提示下使用方便，所以它试图提供一组有趣的名称，而不是尝试提供一组严格或一致定义的名称，并且它的详细信息行为可能会因版本而异。 例如，当参数是类时，元类属性不在结果列表中。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">divmod</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">a</span></span>'', ''<span class="n"><span class="pre">b</span></span>''<span class="sig-paren">)</span> : 当使用整数除法时，将两个（非复数）数作为参数并返回由商和余数组成的一对数。 对于混合操作数类型，二元算术运算符的规则适用。 对于整数，结果与 <code>(a // b, a % b)</code> 相同。 对于浮点数，结果为 <code>(q, a % b)</code>，其中 ''q'' 通常为 <code>math.floor(a / b)</code>，但可能比该值小 1。 在任何情况下，<code>q * b + a % b</code> 与 ''a'' 非常接近，如果 <code>a % b</code> 非零，则它与 ''b'' 和 <code>0 <= abs(a % b) < abs(b)</code>。 <dl> <dt><span class="sig-name descname"><span class="pre">enumerate</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>'', ''<span class="n"><span class="pre">start</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回一个枚举对象。 ''iterable'' 必须是一个序列、一个 [[../../glossary#term-iterator|iterator]] 或其他一些支持迭代的对象。 [[#enumerate|enumerate()]] 返回的迭代器的 [[../stdtypes#iterator|__next__()]] 方法返回一个包含计数的元组（来自 ''start''，默认为 0）和从迭代 ''iterable''。</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> 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')]</syntaxhighlight> </div> </div> <p>相当于：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1</syntaxhighlight> </div> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">eval</span></span><span class="sig-paren">(</span>''<span class="pre">expression</span>''<span class="optional">[</span>, ''<span class="pre">globals</span>''<span class="optional">[</span>, ''<span class="pre">locals</span>''<span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>参数是一个字符串和可选的全局变量和局部变量。 如果提供， ''globals'' 必须是字典。 如果提供，''locals'' 可以是任何映射对象。</p> <p>''expression'' 参数使用 ''globals'' 和 ''locals'' 字典作为全局和局部命名空间作为 Python 表达式（从技术上讲，条件列表）进行解析和评估。 如果 ''globals'' 字典存在并且不包含键 <code>__builtins__</code> 的值，则在该字典下插入对内置模块 [[../builtins#module-builtins|builtins]] 字典的引用解析 ''表达式'' 之前的键。 这意味着 ''expression'' 通常可以完全访问标准的 [[../builtins#module-builtins|builtins]] 模块，并且会传播受限环境。 如果省略 ''locals'' 字典，则默认为 ''globals'' 字典。 如果两个字典都被省略，则在调用 [[#eval|eval()]] 的环境中使用 ''globals'' 和 ''locals'' 执行表达式。 请注意， ''eval()'' 无权访问封闭环境中的 [[../../glossary#term-nested-scope|嵌套作用域]] （非本地）。</p> <p>返回值是计算表达式的结果。 语法错误报告为异常。 例子：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> x = 1 >>> eval('x+1') 2</syntaxhighlight> </div> </div> <p>此函数还可用于执行任意代码对象（例如由 [[#compile|compile()]] 创建的那些）。 在这种情况下，传递代码对象而不是字符串。 如果代码对象已使用 <code>'exec'</code> 作为 ''mode'' 参数进行编译，则 [[#eval|eval()]]' 的返回值将为 <code>None</code>。</p> <p>提示：[[#exec|exec()]] 函数支持语句的动态执行。 [[#globals|globals()]] 和 [[#locals|locals()]] 函数分别返回当前的全局和局部字典，这可能有助于传递给 [[#eval|eval()]]或 [[#exec|exec()]]。</p> <p>请参阅 [[../ast#ast|ast.literal_eval()]] 以获取可以安全地使用仅包含文字的表达式计算字符串的函数。</p></dd></dl> <span id="index-1" class="target"></span> <dl> <dt><span class="sig-name descname"><span class="pre">exec</span></span><span class="sig-paren">(</span>''<span class="pre">object</span>''<span class="optional">[</span>, ''<span class="pre">globals</span>''<span class="optional">[</span>, ''<span class="pre">locals</span>''<span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>该函数支持 Python 代码的动态执行。 ''object'' 必须是字符串或代码对象。 如果是字符串，则该字符串将被解析为一组 Python 语句，然后执行该语句（除非发生语法错误）。 [[#id2|1]] 如果是代码对象，则简单执行。 在所有情况下，执行的代码都应作为文件输入有效（请参阅参考手册中的“文件输入”部分）。 请注意，即使在传递给 [[#exec|exec 的代码上下文中，]][[../../reference/simple_stmts#nonlocal|nonlocal]]、[[../../reference/simple_stmts#yield|yield]] 和 [[../../reference/simple_stmts#return|return]] 语句也不能在函数定义之外使用() 函数。 返回值为<code>None</code>。</p> <p>在所有情况下，如果省略可选部分，代码将在当前范围内执行。 如果只提供了 ''globals''，它必须是一个字典（而不是字典的子类），它将用于全局和局部变量。 如果给出 ''globals'' 和 ''locals''，它们分别用于全局和局部变量。 如果提供，''locals'' 可以是任何映射对象。 请记住，在模块级别，全局变量和本地变量是同一个字典。 如果 exec 获得两个单独的对象，分别为 ''globals'' 和 ''locals''，则代码将被执行，就像它嵌入在类定义中一样。</p> <p>如果 ''globals'' 字典不包含键 <code>__builtins__</code> 的值，则在该键下插入对内置模块 [[../builtins#module-builtins|builtins]] 字典的引用。 这样，您可以通过将您自己的 <code>__builtins__</code> 字典插入到 ''globals'' 中，然后将其传递给 [[#exec|exec()]] 来控制哪些内置函数可用于执行的代码。</p> <div class="admonition note"> <p>笔记</p> <p>内置函数 [[#globals|globals()]] 和 [[#locals|locals()]] 分别返回当前的全局和局部字典，这对于传递用作第二个和第三个参数可能很有用[[#exec|exec()]]。</p> </div> <div class="admonition note"> <p>笔记</p> <p>默认的 ''locals'' 的行为如下面的函数 [[#locals|locals()]] 所述：不应尝试修改默认的 ''locals'' 字典。 如果您需要在函数 [[#exec|exec()]] 返回后查看代码对 ''locals'' 的影响，请传递显式 ''locals'' 字典。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">filter</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">function</span></span>'', ''<span class="n"><span class="pre">iterable</span></span>''<span class="sig-paren">)</span></dt> <dd><p>从 ''iterable'' 中 ''function'' 返回 true 的那些元素构造一个迭代器。 ''iterable'' 可以是一个序列，一个支持迭代的容器，或者一个迭代器。 如果''function''为<code>None</code>，则假定恒等函数，即''iterable''中所有为false的元素都被移除。</p> <p>请注意，如果函数不是 <code>None</code> 和 <code>(item for item in iterable if item)</code>，如果函数是 <code>None</code>，则 <code>filter(function, iterable)</code> 等价于生成器表达式 <code>(item for item in iterable if function(item))</code>。</p> <p>请参阅 [[../itertools#itertools|itertools.filterfalse()]] 以获取返回 ''iterable'' 元素的补充函数，其中 ''函数'' 返回 false。</p></dd></dl> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">float</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">x</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回由数字或字符串 ''x'' 构造的浮点数。</p> <p>如果参数是一个字符串，它应该包含一个十进制数，可选地前面有一个符号，并可选地嵌入空格中。 可选符号可以是<code>'+'</code>或<code>'-'</code>； <code>'+'</code> 符号对产生的值没有影响。 参数也可以是表示 NaN（非数字）或正无穷大或负无穷大的字符串。 更准确地说，删除前导和尾随空白字符后，输入必须符合以下语法：</p> <pre>标志 ::= "+" | "-" 无穷大 ::= "Infinity" | "inf" 南 ::= "nan" numeric_value ::= floatnumber | infinity | nan numeric_string ::= [sign] numeric_value</pre> <p>这里 <code>floatnumber</code> 是 Python 浮点文字的形式，在 [[../../reference/lexical_analysis#floating|浮点文字]] 中进行了描述。 大小写不重要，因此，例如，“inf”、“Inf”、“INFINITY”和“iNfINity”都是正无穷大的可接受拼写。</p> <p>否则，如果参数是整数或浮点数，则返回具有相同值（在 Python 的浮点精度范围内）的浮点数。 如果参数超出 Python 浮点数的范围，则会引发 [[../exceptions#OverflowError|OverflowError]]。</p> <p>对于一般的 Python 对象 <code>x</code>，<code>float(x)</code> 委托给 <code>x.__float__()</code>。 如果 <code>__float__()</code> 未定义，则回退到 <code>__index__()</code>。</p> <p>如果没有给出参数，则返回 <code>0.0</code>。</p> <p>例子：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf</syntaxhighlight> </div> </div> <p>float 类型在 [[../stdtypes#typesnumeric|Numeric Types — int, float, complex]] 中有描述。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.6 版更改： </span> 允许将数字与代码文字中的下划线分组。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 在 3.7 版更改：</span>''x'' 现在是仅位置参数。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.8 版更改：</span>如果未定义 <code>__float__()</code>，则回退到 <code>__index__()</code>。</p> </div></dd></dl> <span id="index-3" class="target"></span> <dl> <dt><span class="sig-name descname"><span class="pre">format</span></span><span class="sig-paren">(</span>''<span class="pre">value</span>''<span class="optional">[</span>, ''<span class="pre">format_spec</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>将 ''值'' 转换为“格式化”表示，由 ''format_spec'' 控制。 ''format_spec'' 的解释将取决于 ''value'' 参数的类型，但是大多数内置类型使用标准格式语法： [[../string#formatspec|Format Specification Mini-语言]]。</p> <p>默认的 ''format_spec'' 是一个空字符串，通常与调用 [[../stdtypes#str|str(value)]] 产生相同的效果。</p> <p>对 <code>format(value, format_spec)</code> 的调用被转换为 <code>type(value).__format__(value, format_spec)</code>，它在搜索值的 <code>__format__()</code> 方法时绕过实例字典。 如果方法搜索到达 [[#object|object]] 并且 ''format_spec'' 非空，或者 ''format_spec'' 或返回值不是字符串。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 在 3.4 版更改：如果 ''format_spec'' 不是空字符串，则 </span><code>object().__format__(format_spec)</code> 引发 [[../exceptions#TypeError|TypeError]]。</p> </div></dd></dl> <span id="func-frozenset" class="target"></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">frozenset</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">iterable</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个新的 [[../stdtypes#frozenset|frozenset]] 对象，可以选择使用取自 ''iterable'' 的元素。 <code>frozenset</code> 是一个内置类。 有关此类的文档，请参阅 [[../stdtypes#frozenset|frozenset]] 和 [[../stdtypes#types-set|Set Types — set、frozenset]]。</p> <p>对于其他容器，请参阅内置的 [[../stdtypes#set|set]]、[[../stdtypes#list|list]]、[[../stdtypes#tuple|tuple]] 和 [[../stdtypes#dict|dict]] 类，以及 [[../collections#module-collections|集合]] 模块。</p></dd></dl> ; <span class="sig-name descname"><span class="pre">getattr</span></span><span class="sig-paren">(</span>''<span class="pre">object</span>'', ''<span class="pre">name</span>''<span class="optional">[</span>, ''<span class="pre">default</span>''<span class="optional">]</span><span class="sig-paren">)</span> : 返回 ''object'' 的命名属性的值。 ''name'' 必须是字符串。 如果字符串是对象属性之一的名称，则结果是该属性的值。 例如，<code>getattr(x, 'foobar')</code> 等价于 <code>x.foobar</code>。 如果命名属性不存在，则返回 ''default''（如果提供），否则会引发 [[../exceptions#AttributeError|AttributeError]]。 ; <span class="sig-name descname"><span class="pre">globals</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> : 返回表示当前全局符号表的字典。 这始终是当前模块的字典（在函数或方法中，这是定义它的模块，而不是调用它的模块）。 ; <span class="sig-name descname"><span class="pre">hasattr</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>'', ''<span class="n"><span class="pre">name</span></span>''<span class="sig-paren">)</span> : 参数是一个对象和一个字符串。 如果字符串是对象属性之一的名称，则结果为 <code>True</code>，否则为 <code>False</code>。 （这是通过调用 <code>getattr(object, name)</code> 并查看它是否引发 [[../exceptions#AttributeError|AttributeError]] 来实现的。） <dl> <dt><span class="sig-name descname"><span class="pre">hash</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回对象的哈希值（如果有）。 哈希值是整数。 它们用于在字典查找期间快速比较字典键。 比较相等的数值具有相同的哈希值（即使它们属于不同类型，如 1 和 1.0 的情况）。</p> <div class="admonition note"> <p>笔记</p> <p>对于具有自定义 <code>__hash__()</code> 方法的对象，请注意 [[#hash|hash()]] 根据主机的位宽截断返回值。 有关详细信息，请参阅 <code>__hash__()</code>。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">help</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">object</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>调用内置的帮助系统。 （此函数旨在用于交互式使用。）如果没有给出参数，交互式帮助系统将在解释器控制台上启动。 如果参数是字符串，则该字符串将作为模块、函数、类、方法、关键字或文档主题的名称进行查找，并在控制台上打印帮助页面。 如果参数是任何其他类型的对象，则会生成有关该对象的帮助页面。</p> <p>请注意，如果函数的参数列表中出现斜杠（/），则在调用 [[#help|help()]] 时，表示斜杠之前的参数仅是位置参数。 有关更多信息，请参阅 [[../../faq/programming#faq-positional-only-arguments|有关仅位置参数的常见问题解答条目]] 。</p> <p>该函数由 [[../site#module-site|site]] 模块添加到内置命名空间中。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.4 版更改： </span> 对 [[../pydoc#module-pydoc|pydoc]] 和 [[../inspect#module-inspect|inspect]] 的更改意味着报告的可调用签名现在更加全面和一致。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">hex</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">x</span></span>''<span class="sig-paren">)</span></dt> <dd><p>将整数转换为以“0x”为前缀的小写十六进制字符串。 如果 ''x'' 不是 Python [[#int|int]] 对象，它必须定义一个返回整数的 <code>__index__()</code> 方法。 一些例子：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> hex(255) '0xff' >>> hex(-42) '-0x2a'</syntaxhighlight> </div> </div> <p>如果要将整数转换为带前缀或不带前缀的大写或小写十六进制字符串，可以使用以下方法之一：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> '%#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')</syntaxhighlight> </div> </div> <p>另见 [[#format|format()]] 了解更多信息。</p> <p>另请参阅 [[#int|int()]] 以使用以 16 为基数将十六进制字符串转换为整数。</p> <div class="admonition note"> <p>笔记</p> <p>要获取浮点数的十六进制字符串表示形式，请使用 [[../stdtypes#float|float.hex()]] 方法。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">id</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span> : 返回对象的“身份”。 这是一个整数，保证在此对象的生命周期内是唯一且恒定的。 生命周期不重叠的两个对象可能具有相同的 [[#id|id()]] 值。 <dl> <dt><span class="sig-name descname"><span class="pre">input</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">prompt</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>如果存在 ''prompt'' 参数，则将其写入标准输出，而没有尾随换行符。 然后该函数从输入中读取一行，将其转换为字符串（去除尾随的换行符），然后返回该字符串。 读取 EOF 时，会引发 [[../exceptions#EOFError|EOFError]]。 例子：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"</syntaxhighlight> </div> </div> <p>如果加载了 [[../readline#module-readline|readline]] 模块，则 [[#input|input()]] 将使用它来提供精细的行编辑和历史功能。</p></dd></dl> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">int</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">x</span>''<span class="optional">]</span><span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">int</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">x</span></span>'', ''<span class="n"><span class="pre">base</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">10</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回由数字或字符串 ''x'' 构造的整数对象，如果没有给出参数，则返回 <code>0</code>。 如果 ''x'' 定义了 <code>__int__()</code>，则 <code>int(x)</code> 返回 <code>x.__int__()</code>。 如果 ''x'' 定义了 <code>__index__()</code>，则返回 <code>x.__index__()</code>。 如果 ''x'' 定义了 <code>__trunc__()</code>，则返回 <code>x.__trunc__()</code>。 对于浮点数，这会向零截断。</p> <p>如果 ''x'' 不是数字或者如果给出了 ''base''，则 ''x'' 必须是一个字符串、[[../stdtypes#bytes|bytes]] 或 [[../stdtypes#bytearray|bytearray]] 实例表示基数 ''基数'' 中的 [[../../reference/lexical_analysis#integers|整数文字]] 。 或者，文字可以在 <code>+</code> 或 <code>-</code> 之前（中间没有空格）并用空格包围。 base-n 字面量由 0 到 n-1 的数字组成，其中 <code>a</code> 到 <code>z</code>（或 <code>A</code> 到 <code>Z</code>）的值为 10 到 35 . 默认 ''基数'' 为 10。 允许的值为 0 和 2–36。 Base-2、-8 和 -16 字面量可以选择性地以 <code>0b</code>/<code>0B</code>、<code>0o</code>/<code>0O</code> 或 <code>0x</code> 作为前缀]/<code>0X</code>，就像代码中的整数文字一样。 基数 0 表示准确解释为代码文字，因此实际基数为 2、8、10 或 16，因此 <code>int('010', 0)</code> 不合法，而 <code>int('010')</code> 也是如此如 <code>int('010', 8)</code>。</p> <p>整数类型在 [[../stdtypes#typesnumeric|Numeric Types — int, float, complex]] 中有描述。</p> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.4 版更改： </span>如果 ''base'' 不是 [[#int|int]] 的实例并且 ''base'' 对象有一个 base.__index__[ X138X] 方法，该方法被调用以获得基数的整数。 以前的版本使用 [[../../reference/datamodel#object|base.__int__]] 而不是 [[../../reference/datamodel#object|base.__index__]]。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.6 版更改： </span> 允许将数字与代码文字中的下划线分组。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 在 3.7 版更改：</span>''x'' 现在是仅位置参数。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.8 版更改：</span>如果未定义 <code>__int__()</code>，则回退到 <code>__index__()</code>。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">isinstance</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>'', ''<span class="n"><span class="pre">classinfo</span></span>''<span class="sig-paren">)</span> : 如果 ''object'' 参数是 ''classinfo'' 参数或其（直接、间接或 [[../../glossary#term-abstract-base-class|virtual]]）子类的实例，则返回 <code>True</code>。 如果 ''object'' 不是给定类型的对象，函数总是返回 <code>False</code>。 如果 ''classinfo'' 是类型对象的元组（或递归地，其他此类元组），如果 ''object'' 是任何类型的实例，则返回 <code>True</code>。 如果 ''classinfo'' 不是类型或类型元组和此类元组，则会引发 [[../exceptions#TypeError|TypeError]] 异常。 ; <span class="sig-name descname"><span class="pre">issubclass</span></span><span class="sig-paren">(</span>''<span class="pre">class</span>'', ''<span class="pre">classinfo</span>''<span class="sig-paren">)</span> : 如果 ''class'' 是 ''classinfo'' 的子类（直接、间接或 [[../../glossary#term-abstract-base-class|virtual]]），则返回 <code>True</code>。 一个类被认为是它自己的一个子类。 ''classinfo'' 可能是一个类对象的元组，在这种情况下，''classinfo'' 中的每个条目都将被检查。 在任何其他情况下，会引发 [[../exceptions#TypeError|TypeError]] 异常。 <dl> <dt><span class="sig-name descname"><span class="pre">iter</span></span><span class="sig-paren">(</span>''<span class="pre">object</span>''<span class="optional">[</span>, ''<span class="pre">sentinel</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个 [[../../glossary#term-iterator|iterator]] 对象。 根据第二个参数的存在，第一个参数的解释非常不同。 如果没有第二个参数，''object'' 必须是一个支持迭代协议（<code>__iter__()</code> 方法）的集合对象，或者它必须支持序列协议（<code>__getitem__()</code> 方法与从 <code>0</code> 开始的整数参数）。 如果它不支持这些协议中的任何一个，则会引发 [[../exceptions#TypeError|TypeError]]。 如果给出了第二个参数 ''sentinel''，则 ''object'' 必须是一个可调用对象。 在这种情况下创建的迭代器将在每次调用 [[../stdtypes#iterator|__next__()]] 方法时不带参数地调用 ''object''； 如果返回的值等于 ''sentinel''，则 [[../exceptions#StopIteration|StopIteration]] 将被引发，否则将返回该值。</p> <p>另见 [[../stdtypes#typeiter|迭代器类型]] 。</p> <p>[[#iter|iter()]] 第二种形式的一个有用应用是构建一个块阅读器。 例如，从二进制数据库文件中读取固定宽度的块，直到到达文件末尾：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">from functools import partial with open('mydata.db', 'rb') as f: for block in iter(partial(f.read, 64), b''): process_block(block)</syntaxhighlight> </div> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">len</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">s</span></span>''<span class="sig-paren">)</span> : 返回对象的长度（项目数）。 参数可以是序列（例如字符串、字节、元组、列表或范围）或集合（例如字典、集合或冻结集合）。 <span id="func-list" class="target"></span> ; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">list</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">iterable</span>''<span class="optional">]</span><span class="sig-paren">)</span> : [[../stdtypes#list|list]] 实际上是一个可变序列类型，而不是一个函数，如 [[../stdtypes#typesseq-list|Lists]] 和 [[../stdtypes#typesseq|序列类型 — 列表、元组、范围]] 中所述。 <dl> <dt><span class="sig-name descname"><span class="pre">locals</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span></dt> <dd><p>更新并返回代表当前本地符号表的字典。 自由变量在功能块中调用时由 [[#locals|locals()]] 返回，但不在类块中调用。 请注意，在模块级别， [[#locals|locals()]] 和 [[#globals|globals()]] 是同一个字典。</p> <div class="admonition note"> <p>笔记</p> <p>本词典内容不得修改； 更改可能不会影响解释器使用的局部变量和自由变量的值。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">map</span></span><span class="sig-paren">(</span>''<span class="pre">function</span>'', ''<span class="pre">iterable</span>'', ''<span class="pre">...</span>''<span class="sig-paren">)</span> : 返回一个迭代器，将 ''function'' 应用于 ''iterable'' 的每一项，产生结果。 如果传递了额外的 ''iterable'' 参数，则 ''function'' 必须采用那么多参数并并行应用于所有可迭代项中的项目。 对于多个可迭代对象，当最短的可迭代对象耗尽时，迭代器将停止。 对于函数输入已经排列成参数元组的情况，请参阅 [[../itertools#itertools|itertools.starmap()]]。 <dl> <dt><span class="sig-name descname"><span class="pre">max</span></span><span class="sig-paren">(</span>''<span class="pre">iterable</span>'', ''<span class="pre">*</span>''<span class="optional">[</span>, ''<span class="pre">key</span>'', ''<span class="pre">default</span>''<span class="optional">]</span><span class="sig-paren">)</span><br /> <span class="sig-name descname"><span class="pre">max</span></span><span class="sig-paren">(</span>''<span class="pre">arg1</span>'', ''<span class="pre">arg2</span>'', ''<span class="pre">*args</span>''<span class="optional">[</span>, ''<span class="pre">key</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回可迭代对象中最大的项或两个或多个参数中最大的项。</p> <p>如果提供了一个位置参数，它应该是一个 [[../../glossary#term-iterable|iterable]]。 返回迭代中最大的项目。 如果提供了两个或更多位置参数，则返回最大的位置参数。</p> <p>有两个可选的仅关键字参数。 ''key'' 参数指定一个单参数排序函数，类似于用于 [[../stdtypes#list|list.sort()]] 的函数。 ''default'' 参数指定在提供的可迭代对象为空时要返回的对象。 如果可迭代对象为空且未提供 ''default''，则会引发 [[../exceptions#ValueError|ValueError]]。</p> <p>如果多个项目是最大的，则该函数返回遇到的第一个项目。 这与其他保持排序稳定性的工具一致，例如 <code>sorted(iterable, key=keyfunc, reverse=True)[0]</code> 和 <code>heapq.nlargest(1, iterable, key=keyfunc)</code>。</p> <div class="versionadded"> <p><span class="versionmodified added">3.4 版新功能：</span>''default'' 仅关键字参数。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">3.8版本变更：</span>''键''可以是<code>None</code>。</p> </div></dd></dl> <span id="func-memoryview" class="target"></span> ; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">memoryview</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">obj</span></span>''<span class="sig-paren">)</span> : 返回从给定参数创建的“内存视图”对象。 有关详细信息，请参阅 [[../stdtypes#typememoryview|内存视图]] 。 <dl> <dt><span class="sig-name descname"><span class="pre">min</span></span><span class="sig-paren">(</span>''<span class="pre">iterable</span>'', ''<span class="pre">*</span>''<span class="optional">[</span>, ''<span class="pre">key</span>'', ''<span class="pre">default</span>''<span class="optional">]</span><span class="sig-paren">)</span><br /> <span class="sig-name descname"><span class="pre">min</span></span><span class="sig-paren">(</span>''<span class="pre">arg1</span>'', ''<span class="pre">arg2</span>'', ''<span class="pre">*args</span>''<span class="optional">[</span>, ''<span class="pre">key</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回可迭代对象中的最小项或两个或多个参数中的最小项。</p> <p>如果提供了一个位置参数，它应该是一个 [[../../glossary#term-iterable|iterable]]。 返回迭代中的最小项。 如果提供了两个或更多位置参数，则返回位置参数中最小的一个。</p> <p>有两个可选的仅关键字参数。 ''key'' 参数指定一个单参数排序函数，类似于用于 [[../stdtypes#list|list.sort()]] 的函数。 ''default'' 参数指定在提供的可迭代对象为空时要返回的对象。 如果可迭代对象为空且未提供 ''default''，则会引发 [[../exceptions#ValueError|ValueError]]。</p> <p>如果多个项目最少，则该函数返回遇到的第一个项目。 这与其他保持排序稳定性的工具一致，例如 <code>sorted(iterable, key=keyfunc)[0]</code> 和 <code>heapq.nsmallest(1, iterable, key=keyfunc)</code>。</p> <div class="versionadded"> <p><span class="versionmodified added">3.4 版新功能：</span>''default'' 仅关键字参数。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">3.8版本变更：</span>''键''可以是<code>None</code>。</p> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">next</span></span><span class="sig-paren">(</span>''<span class="pre">iterator</span>''<span class="optional">[</span>, ''<span class="pre">default</span>''<span class="optional">]</span><span class="sig-paren">)</span> : 通过调用 [[../stdtypes#iterator|__next__()]] 方法从 ''iterator'' 检索下一项。 如果给出 ''default''，则在迭代器耗尽时返回，否则引发 [[../exceptions#StopIteration|StopIteration]]。 <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">object</span></span></dt> <dd><p>返回一个新的无特征对象。 [[#object|object]] 是所有类的基础。 它具有 Python 类的所有实例通用的方法。 此函数不接受任何参数。</p> <div class="admonition note"> <p>笔记</p> <p>[[#object|object]] 确实 ''not'' 有 [[../stdtypes#object|__dict__]]，所以你不能将任意属性分配给 [[#object|object]] 类的实例。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">oct</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">x</span></span>''<span class="sig-paren">)</span></dt> <dd><p>将整数转换为以“0o”为前缀的八进制字符串。 结果是一个有效的 Python 表达式。 如果 ''x'' 不是 Python [[#int|int]] 对象，它必须定义一个返回整数的 <code>__index__()</code> 方法。 例如：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> oct(8) '0o10' >>> oct(-56) '-0o70'</syntaxhighlight> </div> </div> <p>如果要将整数转换为带前缀“0o”或不带前缀的八进制字符串，可以使用以下方法之一。</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> '%#o' % 10, '%o' % 10 ('0o12', '12') >>> format(10, '#o'), format(10, 'o') ('0o12', '12') >>> f'{10:#o}', f'{10:o}' ('0o12', '12')</syntaxhighlight> </div> </div> <p>另见 [[#format|format()]] 了解更多信息。</p> <blockquote><div> <span id="index-4" class="target"></span> </div></blockquote></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">open</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">file</span></span>'', ''<span class="n"><span class="pre">mode</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'r'</span></span>'', ''<span class="n"><span class="pre">buffering</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">-</span> <span class="pre">1</span></span>'', ''<span class="n"><span class="pre">encoding</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">errors</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">newline</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">closefd</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span>'', ''<span class="n"><span class="pre">opener</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>''<span class="sig-paren">)</span></dt> <dd><p>打开''file''并返回一个对应的[[../../glossary#term-file-object|file对象]]。 如果无法打开文件，则会引发 [[../exceptions#OSError|OSError]]。 有关如何使用此功能的更多示例，请参阅 [[../../tutorial/inputoutput#tut-files|读取和写入文件]] 。</p> <p>''file'' 是一个 [[../../glossary#term-path-like-object|类似路径的对象]] ，给出要打开的文件的路径名（绝对或相对于当前工作目录）或要包装的文件的整数文件描述符。 （如果给出了文件描述符，则在返回的 I/O 对象关闭时它也将关闭，除非 ''closefd'' 设置为 <code>False</code>。）</p> <p>''mode'' 是一个可选字符串，用于指定打开文件的模式。 默认为 <code>'r'</code>，表示以文本模式打开阅读。 其他常用值是用于写入的 <code>'w'</code>（如果文件已经存在则截断文件），用于独占创建的 <code>'x'</code> 和用于附加的 <code>'a'</code>（在 ''some'' 上） Unix 系统，意味着 ''all'' 写入追加到文件的末尾而不管当前的查找位置）。 在文本模式下，如果未指定 ''encoding''，则使用的编码取决于平台：调用 <code>locale.getpreferredencoding(False)</code> 以获取当前区域设置编码。 （对于读取和写入原始字节，请使用二进制模式并保留 ''encoding'' 未指定。）可用模式有：</p> <p><span id="filemodes" class="target"></span></p> {| !width="13%"| <p>特点</p> !width="88%"| <p>意义</p> |- | <p><code>'r'</code></p> | <p>开放阅读（默认）</p> |- | <p><code>'w'</code></p> | <p>打开写入，先截断文件</p> |- | <p><code>'x'</code></p> | <p>打开独占创建，如果文件已经存在则失败</p> |- | <p><code>'a'</code></p> | <p>打开以进行写入，如果存在则附加到文件末尾</p> |- | <p><code>'b'</code></p> | <p>二进制模式</p> |- | <p><code>'t'</code></p> | <p>文本模式（默认）</p> |- | <p><code>'+'</code></p> | <p>开放更新（读取和写入）</p> |} <p>默认模式为<code>'r'</code>（打开阅读文本，<code>'rt'</code>的同义词）。 模式 <code>'w+'</code> 和 <code>'w+b'</code> 打开并截断文件。 模式 <code>'r+'</code> 和 <code>'r+b'</code> 不截断地打开文件。</p> <p>正如 [[../io#io-overview|Overview]] 中提到的，Python 区分二进制和文本 I/O。 以二进制模式打开的文件（包括 ''mode'' 参数中的 <code>'b'</code>）返回内容为 [[../stdtypes#bytes|bytes]] 对象，无需任何解码。 在文本模式下（默认情况下，或者当 <code>'t'</code> 包含在 ''mode'' 参数中时），文件的内容作为 [[../stdtypes#str|str]] 返回，字节已在使用依赖于平台的编码或使用指定的 ''encoding'' 解码（如果给定）。</p> <p>允许使用额外的模式字符 <code>'U'</code>，它不再有任何效果，被视为已弃用。 它之前在文本模式下启用了 [[../../glossary#term-universal-newlines|通用换行符]] ，这成为 Python 3.0 中的默认行为。 有关详细信息，请参阅 [[#open-newline-parameter|newline]] 参数的文档。</p> <div class="admonition note"> <p>笔记</p> <p>Python 不依赖于底层操作系统的文本文件概念； 所有处理都由 Python 本身完成，因此与平台无关。</p> </div> <p>''buffering'' 是一个可选整数，用于设置缓冲策略。 传递 0 以关闭缓冲（仅在二进制模式下允许），1 以选择行缓冲（仅在文本模式下可用），以及一个大于 1 的整数以指示固定大小块缓冲区的大小（以字节为单位）。 当没有给出 ''buffering'' 参数时，默认缓冲策略的工作方式如下：</p> <ul> <li><p>二进制文件以固定大小的块缓冲； 缓冲区的大小是通过尝试确定底层设备的“块大小”并回退到 [[../io#io|io.DEFAULT_BUFFER_SIZE]] 的启发式方法来选择的。 在许多系统上，缓冲区通常为 4096 或 8192 字节长。</p></li> <li><p>“交互式”文本文件（[[../io#io.IOBase|isatty()]] 返回 <code>True</code> 的文件）使用行缓冲。 其他文本文件使用上述针对二进制文件的策略。</p></li></ul> <p>''encoding'' 是用于解码或编码文件的编码名称。 这应该只在文本模式下使用。 默认编码取决于平台（无论 [[../locale#locale|locale.getpreferredencoding()]] 返回什么），但可以使用 Python 支持的任何 [[../../glossary#term-text-encoding|文本编码]] 。 有关支持的编码列表，请参阅 [[../codecs#module-codecs|codecs]] 模块。</p> <p>''errors'' 是一个可选字符串，指定如何处理编码和解码错误——这不能在二进制模式下使用。 有多种标准错误处理程序可用（在 [[../codecs#error-handlers|错误处理程序]] 下列出），但已使用 [[../codecs#codecs|codecs.register_error()]] 注册的任何错误处理名称也是有效的。 标准名称包括：</p> <ul> <li><p><code>'strict'</code> 如果存在编码错误，则引发 [[../exceptions#ValueError|ValueError]] 异常。 <code>None</code>的默认值也有同样的效果。</p></li> <li><p><code>'ignore'</code> 忽略错误。 请注意，忽略编码错误会导致数据丢失。</p></li> <li><p><code>'replace'</code> 导致替换标记（例如 <code>'?'</code>）被插入到格式错误的数据中。</p></li> <li><p><code>'surrogateescape'</code> 将任何不正确的字节表示为 Unicode 专用区域中的代码点，范围从 U+DC80 到 U+DCFF。 当写入数据时使用 <code>surrogateescape</code> 错误处理程序时，这些私有代码点将被转换回相同的字节。 这对于处理未知编码的文件很有用。</p></li> <li><p><code>'xmlcharrefreplace'</code> 仅在写入文件时支持。 编码不支持的字符将替换为适当的 XML 字符参考 <code>&#nnn;</code>。</p></li> <li><p><code>'backslashreplace'</code> 用 Python 的反斜杠转义序列替换格式错误的数据。</p></li> <li><p><code>'namereplace'</code>（也仅在写入时支持）用 <code>\N{...}</code> 转义序列替换不受支持的字符。</p></li></ul> <p><span id="index-6"></span>''newline'' 控制 [[../../glossary#term-universal-newlines|universal newlines]] 模式如何工作（它只适用于文本模式）。 它可以是 <code>None</code>、<code>''</code>、<code>'\n'</code>、<code>'\r'</code> 和 <code>'\r\n'</code>。 它的工作原理如下：</p> <ul> <li><p>从流中读取输入时，如果 ''newline'' 为 <code>None</code>，则启用通用换行符模式。 输入中的行可以以 <code>'\n'</code>、<code>'\r'</code> 或 <code>'\r\n'</code> 结尾，这些在返回给调用者之前会被转换为 <code>'\n'</code>。 如果是 <code>''</code>，则启用通用换行符模式，但行尾未翻译返回给调用者。 如果它具有任何其他合法值，则输入行仅由给定的字符串终止，并且行尾未翻译地返回给调用者。</p></li> <li><p>将输出写入流时，如果 ''newline'' 为 <code>None</code>，则写入的任何 <code>'\n'</code> 字符都将转换为系统默认行分隔符 [[../os#os|os.linesep]] . 如果 ''newline'' 是 <code>''</code> 或 <code>'\n'</code>，则不会发生转换。 如果 ''newline'' 是任何其他合法值，则写入的任何 <code>'\n'</code> 字符都将转换为给定的字符串。</p></li></ul> <p>如果 ''closefd'' 是 <code>False</code> 并且给出了文件描述符而不是文件名，则在文件关闭时底层文件描述符将保持打开状态。 如果给定文件名 ''closefd'' 必须是 <code>True</code>（默认值），否则将引发错误。</p> <p>可以通过将可调用对象作为 ''opener'' 传递来使用自定义开启器。 然后通过使用 (''file'', ''flags'') 调用 ''opener'' 来获取文件对象的底层文件描述符。 ''opener'' 必须返回一个打开的文件描述符（将 [[../os#os|os.open]] 作为 ''opener'' 传递会产生类似于传递 <code>None</code> 的功能）。</p> <p>新创建的文件是[[../os#fd-inheritance|不可继承的]]。</p> <p>以下示例使用 [[../os#os|os.open()]] 函数的 [[../os#dir-fd|dir_fd]] 参数打开相对于给定目录的文件：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">>>> 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</syntaxhighlight> </div> </div> <p>[[#open|open()]]函数返回的[[../../glossary#term-file-object|文件对象]]的类型取决于模式。 当使用 [[#open|open()]] 以文本模式打开文件时（<code>'w'</code>、<code>'r'</code>、<code>'wt'</code>、<code>'rt'</code> 等） .)，它返回 [[../io#io|io.TextIOBase]] 的子类（特别是 [[../io#io|io.TextIOWrapper]]）。 当用于以带缓冲的二进制模式打开文件时，返回的类是 [[../io#io|io.BufferedIOBase]] 的子类。 确切的类有所不同：在读取二进制模式下，它返回一个 [[../io#io|io.BufferedReader]]； 在写二进制和追加二进制模式下，它返回一个 [[../io#io|io.BufferedWriter]]，在读/写模式下，它返回一个 [[../io#io|io.BufferedRandom]]。 禁用缓冲时，返回原始流，即 [[../io#io|io.RawIOBase]]、[[../io#io|io.FileIO]] 的子类。</p> <p>另请参阅文件处理模块，例如 [[../fileinput#module-fileinput|fileinput]]、[[../io#module-io|io]]（其中声明了 [[#open|open()]]）、[[../os#module-os|os]]、 [[os.path.html#module-os.path|]os.path]]、[[../tempfile#module-tempfile|tempfile]] 和 [[../shutil#module-shutil|shutil]]。</p> <p><code>mode</code> 和 <code>flags</code> 参数可能已被修改或从原始调用中推断出来。</p> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.3 版中更改： </span></p> <blockquote><div> <ul> <li><p>添加了 ''opener'' 参数。</p></li> <li><p>添加了 <code>'x'</code> 模式。</p></li> <li><p>[[../exceptions#IOError|IOError]] 曾经被提出，现在是 [[../exceptions#OSError|OSError]] 的别名。</p></li> <li><p>[[../exceptions#FileExistsError|FileExistsError]] 如果以独占创建模式打开的文件 (<code>'x'</code>) 已经存在，则会引发。</p></li></ul> </div></blockquote> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.4 版中更改： </span></p> <blockquote><div> <ul> <li><p>该文件现在是不可继承的。</p></li></ul> </div></blockquote> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.5 版中更改： </span></p> <blockquote><div> <ul> <li><p>如果系统调用被中断并且信号处理程序没有引发异常，该函数现在重试系统调用而不是引发 [[../exceptions#InterruptedError|InterruptedError]] 异常（参见 <span id="index-8" class="target"></span>[https://www.python.org/dev/peps/pep-0475 PEP 475] ] 的理由）。</p></li> <li><p>添加了 <code>'namereplace'</code> 错误处理程序。</p></li></ul> </div></blockquote> </div> <div class="versionchanged"> <p><span class="versionmodified changed">在 3.6 版中更改： </span></p> <blockquote><div> <ul> <li><p>添加支持以接受实现 [[../os#os|os.PathLike]] 的对象。</p></li> <li><p>在 Windows 上，打开控制台缓冲区可能会返回 [[../io#io|io.RawIOBase]] 的子类，而不是 [[../io#io|io.FileIO]]。</p></li></ul> </div></blockquote> </div></dd></dl> ; <span class="sig-name descname"><span class="pre">ord</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">c</span></span>''<span class="sig-paren">)</span> : 给定一个表示一个 Unicode 字符的字符串，返回一个表示该字符的 Unicode 代码点的整数。 例如，<code>ord('a')</code> 返回整数 <code>97</code>，<code>ord('€')</code>（欧元符号）返回 <code>8364</code>。 这是 [[#chr|chr()]] 的倒数。 <dl> <dt><span class="sig-name descname"><span class="pre">pow</span></span><span class="sig-paren">(</span>''<span class="pre">base</span>'', ''<span class="pre">exp</span>''<span class="optional">[</span>, ''<span class="pre">mod</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>将''base''返回给''exp''的幂； 如果存在 ''mod''，则返回 ''base'' 的幂 ''exp''，取模 ''mod''（比 <code>pow(base, exp) % mod</code> 计算效率更高） . 双参数形式 <code>pow(base, exp)</code> 相当于使用幂运算符：<code>base**exp</code>。</p> <p>参数必须具有数字类型。 对于混合操作数类型，二元算术运算符的强制规则适用。 对于 [[#int|int]] 操作数，除非第二个参数为负，否则结果与操作数具有相同的类型（强制转换后）； 在这种情况下，所有参数都转换为浮点数，并提供浮点数结果。 例如，<code>10**2</code> 返回 <code>100</code>，而 <code>10**-2</code> 返回 <code>0.01</code>。</p> <p>对于 [[#int|int]] 操作数 ''base'' 和 ''exp''，如果 ''mod'' 存在，''mod'' 也必须是整数类型并且''mod'' 必须非零。 如果存在 ''mod'' 且 ''exp'' 为负，则 ''base'' 必须与 ''mod'' 互质。 在这种情况下，返回 <code>pow(inv_base, -exp, mod)</code>，其中 ''inv_base'' 是 ''base'' 模 ''mod'' 的倒数。</p> <p>以下是计算 <code>38</code> 模 <code>97</code> 的逆的示例：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">>>> pow(38, -1, mod=97) 23 >>> 23 * 38 % 97 == 1 True</syntaxhighlight> </div> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.8 版更改： </span> 对于 [[#int|int]] 操作数，<code>pow</code> 的三参数形式现在允许第二个参数为负数，从而允许计算模逆。</p> </div> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.8 版更改： </span> 允许关键字参数。 以前，只支持位置参数。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">print</span></span><span class="sig-paren">(</span>''<span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">objects</span></span>'', ''<span class="n"><span class="pre">sep</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'</span> <span class="pre">'</span></span>'', ''<span class="n"><span class="pre">end</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'\\n'</span></span>'', ''<span class="n"><span class="pre">file</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">sys.stdout</span></span>'', ''<span class="n"><span class="pre">flush</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span>''<span class="sig-paren">)</span></dt> <dd><p>将 ''objects'' 打印到文本流 ''file''，以 ''sep'' 分隔，后跟 ''end''。 ''sep''、''end''、''file'' 和 ''flush''（如果存在）必须作为关键字参数给出。</p> <p>所有非关键字参数都转换为像 [[../stdtypes#str|str()]] 这样的字符串并写入流，由 ''sep'' 分隔，后跟 ''end''。 ''sep'' 和 ''end'' 都必须是字符串； 它们也可以是 <code>None</code>，即使用默认值。 如果没有给出 ''objects''，[[#print|print()]] 只会写出 ''end''。</p> <p>''file'' 参数必须是具有 <code>write(string)</code> 方法的对象； 如果它不存在或 <code>None</code>，将使用 [[../sys#sys|sys.stdout]]。 由于打印的参数被转换为文本字符串，因此 [[#print|print()]] 不能用于二进制模式文件对象。 对于这些，请改用 <code>file.write(...)</code>。</p> <p>输出是否缓冲通常由''file''决定，但如果''flush''关键字参数为真，则流被强制刷新。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.3 版更改： </span> 添加 ''flush'' 关键字参数。</p> </div></dd></dl> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">property</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">fget</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">fset</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">fdel</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">doc</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回一个属性属性。</p> <p>''fget'' 是获取属性值的函数。 ''fset''是用于设置属性值的函数。 ''fdel''是删除属性值的函数。 ''doc'' 为该属性创建一个文档字符串。</p> <p>一个典型的用途是定义一个托管属性 <code>x</code>：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">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.")</syntaxhighlight> </div> </div> <p>如果 ''c'' 是 ''C'' 的实例，则 <code>c.x</code> 将调用 getter，<code>c.x = value</code> 将调用 setter，而 <code>del c.x</code> 将调用删除器.</p> <p>如果给定，''doc'' 将是属性属性的文档字符串。 否则，该属性将复制 ''fget'' 的文档字符串（如果存在）。 这使得可以使用 [[#property|property()]] 作为 [[../../glossary#term-decorator|装饰器]] 轻松创建只读属性：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage</syntaxhighlight> </div> </div> <p><code>@property</code> 装饰器将 <code>voltage()</code> 方法转换为具有相同名称的只读属性的“getter”，并将 ''voltage'' 的文档字符串设置为“Get the当前电压。”</p> <p>属性对象具有 <code>getter</code>、<code>setter</code> 和 <code>deleter</code> 方法，可用作装饰器，这些方法创建属性的副本，并将相应的访问器函数设置为装饰函数。 这最好用一个例子来解释：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">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</syntaxhighlight> </div> </div> <p>此代码与第一个示例完全等效。 确保为附加功能提供与原始属性相同的名称（在本例中为 <code>x</code>。）</p> <p>返回的属性对象还具有与构造函数参数对应的属性 <code>fget</code>、<code>fset</code> 和 <code>fdel</code>。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.5 版更改： </span> 属性对象的文档字符串现在是可写的。</p> </div></dd></dl> <span id="func-range" class="target"></span> ; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">range</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">stop</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">range</span></span><span class="sig-paren">(</span>''<span class="pre">start</span>'', ''<span class="pre">stop</span>''<span class="optional">[</span>, ''<span class="pre">step</span>''<span class="optional">]</span><span class="sig-paren">)</span> : [[../stdtypes#range|range]] 实际上是一个不可变的序列类型，而不是一个函数，如 [[../stdtypes#typesseq-range|Ranges]] 和 [[../stdtypes#typesseq|Sequence Types — 列表、元组、范围]] 中所述。 ; <span class="sig-name descname"><span class="pre">repr</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span> : 返回一个包含对象的可打印表示的字符串。 对于许多类型，此函数尝试返回一个字符串，该字符串在传递给 [[#eval|eval()]] 时会产生一个具有相同值的对象，否则表示是包含在尖括号中的字符串，其中包含对象的类型以及其他信息，通常包括对象的名称和地址。 类可以通过定义 <code>__repr__()</code> 方法来控制此函数为其实例返回的内容。 ; <span class="sig-name descname"><span class="pre">reversed</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">seq</span></span>''<span class="sig-paren">)</span> : 返回一个反向 [[../../glossary#term-iterator|迭代器]] 。 ''seq'' 必须是具有 <code>__reversed__()</code> 方法或支持序列协议的对象（<code>__len__()</code> 方法和 <code>__getitem__()</code> 方法，整数参数从 [ X176X]）。 <dl> <dt><span class="sig-name descname"><span class="pre">round</span></span><span class="sig-paren">(</span>''<span class="pre">number</span>''<span class="optional">[</span>, ''<span class="pre">ndigits</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回 ''number'' 小数点后四舍五入到 ''ndigits'' 精度。 如果 ''ndigits'' 被省略或者是 <code>None</code>，它返回与其输入最接近的整数。</p> <p>对于支持 [X34X]round() 的内置类型，值四舍五入到最接近的 10 的幂减去 ''ndigits'' 的倍数； 如果两个倍数相等，则向偶数选择舍入（例如，<code>round(0.5)</code> 和 <code>round(-0.5)</code> 都是 <code>0</code>，而 <code>round(1.5)</code> 是<code>2</code>）。 任何整数值都对 ''ndigits'' 有效（正、零或负）。 如果省略 ''ndigits'' 或 <code>None</code>，则返回值为整数。 否则返回值的类型与 ''number'' 相同。</p> <p>对于一般的 Python 对象 <code>number</code>，<code>round</code> 委托给 <code>number.__round__</code>。</p> <div class="admonition note"> <p>笔记</p> <p>[[#round|round()]] 对于浮点数的行为可能令人惊讶：例如，<code>round(2.675, 2)</code> 给出 <code>2.67</code> 而不是预期的 <code>2.68</code>。 这不是错误：这是大多数十进制分数不能完全表示为浮点数的结果。 有关详细信息，请参阅 [[../../tutorial/floatingpoint#tut-fp-issues|浮点运算：问题和限制]] 。</p> </div></dd></dl> <span id="func-set" class="target"></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">set</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">iterable</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个新的 [[../stdtypes#set|set]] 对象，可以选择使用取自 ''iterable'' 的元素。 <code>set</code> 是一个内置类。 有关此类的文档，请参阅 [[../stdtypes#set|set]] 和 [[../stdtypes#types-set|Set Types — set、frozenset]]。</p> <p>对于其他容器，请参阅内置的 [[../stdtypes#frozenset|frozenset]]、[[../stdtypes#list|list]]、[[../stdtypes#tuple|tuple]] 和 [[../stdtypes#dict|dict]] 类，以及 [[../collections#module-collections|集合]] 模块。</p></dd></dl> ; <span class="sig-name descname"><span class="pre">setattr</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>'', ''<span class="n"><span class="pre">name</span></span>'', ''<span class="n"><span class="pre">value</span></span>''<span class="sig-paren">)</span> : 这是 [[#getattr|getattr()]] 的对应物。 参数是一个对象、一个字符串和一个任意值。 该字符串可以命名现有属性或新属性。 如果对象允许，该函数将值分配给属性。 例如，<code>setattr(x, 'foobar', 123)</code> 等价于 <code>x.foobar = 123</code>。 ; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">slice</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">stop</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">slice</span></span><span class="sig-paren">(</span>''<span class="pre">start</span>'', ''<span class="pre">stop</span>''<span class="optional">[</span>, ''<span class="pre">step</span>''<span class="optional">]</span><span class="sig-paren">)</span> : 返回一个 [[../../glossary#term-slice|slice]] 对象，表示由 <code>range(start, stop, step)</code> 指定的索引集。 ''start'' 和 ''step'' 参数默认为 <code>None</code>。 切片对象具有只读数据属性 <code>start</code>、<code>stop</code> 和 <code>step</code>，它们仅返回参数值（或它们的默认值）。 它们没有其他明确的功能； 但是它们被 Numerical Python 和其他第三方扩展使用。 使用扩展索引语法时也会生成切片对象。 例如：<code>a[start:stop:step]</code> 或 <code>a[start:stop, i]</code>。 有关返回迭代器的替代版本，请参阅 [[../itertools#itertools|itertools.islice()]]。 <dl> <dt><span class="sig-name descname"><span class="pre">sorted</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>'', ''<span class="o"><span class="pre">*</span></span>'', ''<span class="n"><span class="pre">key</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">reverse</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span>''<span class="sig-paren">)</span></dt> <dd><p>从 ''iterable'' 中的项目返回一个新的排序列表。</p> <p>有两个可选参数，必须指定为关键字参数。</p> <p>''key'' 指定一个参数的函数，用于从 ''iterable'' 中的每个元素中提取比较键（例如，<code>key=str.lower</code>）。 默认值为 <code>None</code>（直接比较元素）。</p> <p>''reverse'' 是一个布尔值。 如果设置为 <code>True</code>，则列表元素的排序就像每次比较都颠倒了一样。</p> <p>使用 [[../functools#functools|functools.cmp_to_key()]] 将旧式 ''cmp'' 函数转换为 ''key'' 函数。</p> <p>内置的 [[#sorted|sorted()]] 函数保证稳定。 如果排序保证不改变比较相等的元素的相对顺序，则它是稳定的——这有助于多次排序（例如，按部门排序，然后按工资等级排序）。</p> <p>有关排序示例和简短的排序教程，请参阅 [[../../howto/sorting#sortinghowto|Sorting HOW TO]]。</p></dd></dl> <dl> <dt><span class="sig-prename descclassname"><span class="pre">@</span></span><span class="sig-name descname"><span class="pre">staticmethod</span></span></dt> <dd><p>将方法转换为静态方法。</p> <p>静态方法不接收隐式第一个参数。 要声明静态方法，请使用以下习惯用法：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">class C: @staticmethod def f(arg1, arg2, ...): ...</syntaxhighlight> </div> </div> <p><code>@staticmethod</code> 形式是一个函数 [[../../glossary#term-decorator|decorator]]——详见 [[../../reference/compound_stmts#function|函数定义]]。</p> <p>可以在类（例如 <code>C.f()</code>）或实例（例如 <code>C().f()</code>）上调用静态方法。</p> <p>Python 中的静态方法类似于 Java 或 C++ 中的静态方法。 另请参阅 [[#classmethod|classmethod()]] 以获取可用于创建备用类构造函数的变体。</p> <p>与所有装饰器一样，也可以将 <code>staticmethod</code> 作为常规函数调用并对其结果进行处理。 在某些情况下，您需要从类主体引用函数，并且希望避免自动转换为实例方法时需要这样做。 对于这些情况，请使用以下习惯用法：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">class C: builtin_open = staticmethod(open)</syntaxhighlight> </div> </div> <p>有关静态方法的更多信息，请参阅 [[../../reference/datamodel#types|标准类型层次结构]] 。</p></dd></dl> <span id="func-str" class="target"><span id="index-10"></span></span> <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">str</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">''</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">str</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">b''</span></span>'', ''<span class="n"><span class="pre">encoding</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'utf-8'</span></span>'', ''<span class="n"><span class="pre">errors</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'strict'</span></span>''<span class="sig-paren">)</span></dt> <dd><p>返回 ''object'' 的 [[../stdtypes#str|str]] 版本。 有关详细信息，请参阅 [[../stdtypes#str|str()]]。</p> <p><code>str</code> 是内置字符串 [[../../glossary#term-class|class]]。 有关字符串的一般信息，请参阅 [[../stdtypes#textseq|文本序列类型 — str]]。</p></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">sum</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">iterable</span></span>'', ''<span class="o"><span class="pre">/</span></span>'', ''<span class="n"><span class="pre">start</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span>''<span class="sig-paren">)</span></dt> <dd><p>从左到右求和 ''start'' 和 ''iterable'' 的项目并返回总数。 ''iterable'' 的项通常是数字，起始值不允许是字符串。</p> <p>对于某些用例，[[#sum|sum()]] 有很好的替代方案。 连接字符串序列的首选、快速方法是调用 <code>''.join(sequence)</code>。 要添加具有扩展精度的浮点值，请参阅 [[../math#math|math.fsum()]]。 要连接一系列可迭代对象，请考虑使用 [[../itertools#itertools|itertools.chain()]]。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.8 版更改： </span> ''start'' 参数可以指定为关键字参数。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">super</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">type</span>''<span class="optional">[</span>, ''<span class="pre">object-or-type</span>''<span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回一个代理对象，该对象将方法调用委托给 ''类型'' 的父类或兄弟类。 这对于访问在类中被覆盖的继承方法很有用。</p> <p>''object-or-type''决定了要搜索的[[../../glossary#term-method-resolution-order|方法解析顺序]]。 搜索从 ''type'' 之后的类开始。</p> <p>例如，如果 ''object-or-type'' 的 [[../stdtypes#class|__mro__]] 是 <code>D -> B -> C -> A -> object</code> 并且 ''type'' 的值是 <code>B</code>，那么[[#super|super()]] 搜索 <code>C -> A -> object</code>。</p> <p>''object-or-type'' 的 [[../stdtypes#class|__mro__]] 属性列出了 [[#getattr|getattr()]] 和 [[#super|super()]] 使用的方法解析搜索顺序. 该属性是动态的，并且可以在继承层次结构更新时更改。</p> <p>如果省略第二个参数，则返回的超级对象未绑定。 如果第二个参数是一个对象，则 <code>isinstance(obj, type)</code> 必须为真。 如果第二个参数是一个类型，<code>issubclass(type2, type)</code> 必须为真（这对类方法很有用）。</p> <p>''super'' 有两个典型的用例。 在单继承的类层次结构中，可以使用 ''super'' 来引用父类，而无需显式命名它们，从而使代码更易于维护。 这种用法与在其他编程语言中使用 ''super'' 非常相似。</p> <p>第二个用例是在动态执行环境中支持协作多重继承。 这个用例是 Python 独有的，在静态编译语言或仅支持单继承的语言中找不到。 这使得实现“菱形图”成为可能，其中多个基类实现相同的方法。 好的设计要求这样的实现在每种情况下都具有相同的调用签名（因为调用的顺序是在运行时确定的，因为该顺序适应类层次结构的变化，并且因为该顺序可以包括在运行之前未知的兄弟类）。</p> <p>对于这两个用例，典型的超类调用如下所示：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">class C(B): def method(self, arg): super().method(arg) # This does the same thing as: # super(C, self).method(arg)</syntaxhighlight> </div> </div> <p>除了方法查找，[[#super|super()]] 也适用于属性查找。 一个可能的用例是在父类或兄弟类中调用 [[../../glossary#term-descriptor|描述符]] 。</p> <p>请注意，[[#super|super()]] 是作为显式点属性查找（例如 <code>super().__getitem__(name)</code>）的绑定过程的一部分实现的。 它通过实现自己的 <code>__getattribute__()</code> 方法来以支持协作多重继承的可预测顺序搜索类。 因此，[[#super|super()]] 对于使用语句或运算符（例如 <code>super()[name]</code>）的隐式查找是未定义的。</p> <p>另请注意，除了零参数形式外， [[#super|super()]] 不限于使用内部方法。 两个参数形式准确地指定参数并进行适当的引用。 零参数形式仅在类定义中起作用，因为编译器会填写必要的详细信息以正确检索正在定义的类，以及访问普通方法的当前实例。</p> <p>有关如何使用 [[#super|super()]] 设计协作类的实用建议，请参阅 [https://rhettinger.wordpress.com/2011/05/26/super-considered-super/ 使用 super()] 的指南。</p></dd></dl> <span id="func-tuple" class="target"></span> ; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">tuple</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">iterable</span>''<span class="optional">]</span><span class="sig-paren">)</span> : [[../stdtypes#tuple|tuple]] 实际上是一个不可变的序列类型，而不是一个函数，如 [[../stdtypes#typesseq-tuple|Tuples]] 和 [[../stdtypes#typesseq|Sequence Types — list, tuple, range]] 中所述。 <dl> <dt>''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">type</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">object</span></span>''<span class="sig-paren">)</span><br /> ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">type</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">name</span></span>'', ''<span class="n"><span class="pre">bases</span></span>'', ''<span class="n"><span class="pre">dict</span></span>'', ''<span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwds</span></span>''<span class="sig-paren">)</span></dt> <dd><p>使用一个参数，返回 ''对象'' 的类型。 返回值是一个类型对象，通常与 [[../stdtypes#instance|object.__class__]] 返回的对象相同。</p> <p>建议使用 [[#isinstance|isinstance()]] 内置函数来测试对象的类型，因为它考虑了子类。</p> <p>使用三个参数，返回一个新的类型对象。 这本质上是 [[../../reference/compound_stmts#class|class]] 语句的动态形式。 ''name'' 字符串是类名并成为 [[../stdtypes#definition|__name__]] 属性。 ''bases'' 元组包含基类并成为 [[../stdtypes#class|__bases__]] 属性； 如果为空，则添加所有类的最终基类 [[#object|object]]。 ''dict'' 字典包含类主体的属性和方法定义； 它可以在成为 [[../stdtypes#object|__dict__]] 属性之前被复制或包装。 以下两个语句创建相同的 [[#type|type]] 对象：</p> <div class="doctest highlight-default notranslate"> <div class="highlight"> <syntaxhighlight lang="python">>>> class X: ... a = 1 ... >>> X = type('X', (), dict(a=1))</syntaxhighlight> </div> </div> <p>另见 [[../stdtypes#bltin-type-objects|类型对象]] 。</p> <p>提供给三个参数形式的关键字参数以与类定义中的关键字（除了 ''metaclass''）相同的方式传递给适当的元类机制（通常是 [[../../reference/datamodel#object|__init_subclass__()]]）。</p> <p>另见[[../../reference/datamodel#class-customization|自定义类创建]]。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.6 版更改： </span> 不覆盖 <code>type.__new__</code> 的 [[#type|type]] 的子类可能不再使用单参数形式来获取对象的类型。</p> </div></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">vars</span></span><span class="sig-paren">(</span><span class="optional">[</span>''<span class="pre">object</span>''<span class="optional">]</span><span class="sig-paren">)</span></dt> <dd><p>返回具有 [[../stdtypes#object|__dict__]] 属性的模块、类、实例或任何其他对象的 [[../stdtypes#object|__dict__]] 属性。</p> <p>模块和实例等对象具有可更新的 [[../stdtypes#object|__dict__]] 属性； 但是，其他对象可能对其 [[../stdtypes#object|__dict__]] 属性有写限制（例如，类使用 [[../types#types|types.MappingProxyType]] 来防止直接更新字典）。</p> <p>在没有参数的情况下，[[#vars|vars()]] 的行为类似于 [[#locals|locals()]]。 注意，locals 字典仅对读取有用，因为对 locals 字典的更新被忽略。</p> <p>如果指定了对象但它没有 [[../stdtypes#object|__dict__]] 属性（例如，如果其类定义了 [[../../reference/datamodel#object|__slots__]] 属性），则会引发 [[../exceptions#TypeError|TypeError]] 异常。</p></dd></dl> <dl> <dt><span class="sig-name descname"><span class="pre">zip</span></span><span class="sig-paren">(</span>''<span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">iterables</span></span>''<span class="sig-paren">)</span></dt> <dd><p>制作一个迭代器，聚合来自每个可迭代对象的元素。</p> <p>返回元组的迭代器，其中第 ''i'' 元组包含来自每个参数序列或可迭代对象的第 ''i'' 元素。 当最短的输入迭代用完时，迭代器停止。 使用单个可迭代参数，它返回一个 1 元组的迭代器。 没有参数，它返回一个空的迭代器。 相当于：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">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)</syntaxhighlight> </div> </div> <p>可迭代对象的从左到右的评估顺序是有保证的。 这使得使用 <code>zip(*[iter(s)]*n)</code> 将数据系列聚类为 n 长度组的习语成为可能。 这将重复 ''same'' 迭代器 <code>n</code> 次，以便每个输出元组具有对迭代器的 <code>n</code> 调用的结果。 这具有将输入分成 n 个长度的块的效果。</p> <p>[[#zip|zip()]] 仅当您不关心较长迭代中的尾随不匹配值时，才应与不等长输入一起使用。 如果这些值很重要，请改用 [[../itertools#itertools|itertools.zip_longest()]]。</p> <p>[[#zip|zip()]] 结合 <code>*</code> 操作符可用于解压缩列表：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">>>> 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</syntaxhighlight> </div> </div></dd></dl> <dl> <dt><span id="__import__"></span><span class="sig-name descname"><span class="pre">__import__</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">name</span></span>'', ''<span class="n"><span class="pre">globals</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">locals</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>'', ''<span class="n"><span class="pre">fromlist</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">()</span></span>'', ''<span class="n"><span class="pre">level</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">0</span></span>''<span class="sig-paren">)</span></dt> <dd><div id="index-12" class="admonition note"> <p>笔记</p> <p>与 [[../importlib#importlib|importlib.import_module()]] 不同，这是日常 Python 编程中不需要的高级函数。</p> </div> <p>该函数由 [[../../reference/simple_stmts#import|import]] 语句调用。 可以替换它（通过导入 [[../builtins#module-builtins|builtins]] 模块并分配给 <code>builtins.__import__</code>）以更改 <code>import</code> 语句的语义，但这样做是 强烈[ X175X] 不鼓励，因为使用导入钩子通常更简单（参见 <span id="index-13" class="target"></span>[https://www.python.org/dev/peps/pep-0302 PEP 302]）来实现相同的目标并且不会导致代码问题，假设默认导入实现正在使用中. 直接使用 [[#import__|__import__()]] 也不鼓励直接使用 [[../importlib#importlib|importlib.import_module()]]。</p> <p>该函数导入模块 ''name''，可能使用给定的 ''globals'' 和 ''locals'' 来确定如何解释包上下文中的名称。 ''fromlist'' 给出了应该从 ''name'' 给出的模块中导入的对象或子模块的名称。 标准实现根本不使用其 ''locals'' 参数，而仅使用其 ''globals'' 来确定 [[../../reference/simple_stmts#import|import]] 语句的包上下文。</p> <p>''level'' 指定是使用绝对导入还是相对导入。 <code>0</code>（默认）表示只执行绝对导入。 ''level'' 的正值表示相对于调用 [[#import__|__import__()]] 模块的目录要搜索的父目录的数量（参见 <span id="index-14" class="target"></span>[https://www.python.org/dev/peps/pep-0328 PEP 328] ] 了解详情）。</p> <p>当 ''name'' 变量的形式为 <code>package.module</code> 时，通常返回顶层包（直到第一个点的名称），''而不是'' 名为的模块通过 ''名称'' 。 但是，当给出一个非空的 ''fromlist'' 参数时，会返回由 ''name'' 命名的模块。</p> <p>例如，语句 <code>import spam</code> 产生类似于以下代码的字节码：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">spam = __import__('spam', globals(), locals(), [], 0)</syntaxhighlight> </div> </div> <p>语句 <code>import spam.ham</code> 导致此调用：</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">spam = __import__('spam.ham', globals(), locals(), [], 0)</syntaxhighlight> </div> </div> <p>请注意 [[#import__|__import__()]] 如何在此处返回顶层模块，因为这是由 [[../../reference/simple_stmts#import|import]] 语句绑定到名称的对象。</p> <p>另一方面，语句 <code>from spam.ham import eggs, sausage as saus</code> 导致</p> <div class="highlight-python3 notranslate"> <div class="highlight"> <syntaxhighlight lang="python3">_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0) eggs = _temp.eggs saus = _temp.sausage</syntaxhighlight> </div> </div> <p>这里，<code>spam.ham</code> 模块是从 [[#import__|__import__()]] 返回的。 从该对象中，检索要导入的名称并将其分配给它们各自的名称。</p> <p>如果您只想按名称导入模块（可能在包内），请使用 [[../importlib#importlib|importlib.import_module()]]。</p> <div class="versionchanged"> <p><span class="versionmodified changed"> 3.3 版更改： </span> 不再支持 ''级别'' 的负值（这也将默认值更改为 0）。</p> </div></dd></dl> 脚注 ; <span class="brackets">[[#id1|1]]</span> : 请注意，解析器只接受 Unix 风格的行尾约定。 如果您从文件中读取代码，请确保使用换行符转换模式来转换 Windows 或 Mac 样式的换行符。 </div> <div class="clearer"> </div> [[Category:Python 3.8 文档]]
返回至“
内置函数 — Python 文档
”。
