# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.11\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-01-03 15:28+0000\n"

"PO-Revision-Date: 2025-09-22 16:51+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/controlflow.rst:5

msgid "More Control Flow Tools"

msgstr "更多控制流工具"

#: ../../tutorial/controlflow.rst:7

msgid ""

"As well as the :keyword:`while` statement just introduced, Python uses a few"

" more that we will encounter in this chapter."

msgstr "除了刚介绍的 :keyword:`while` 语句，Python 还用了一些别的。我们将在本章中遇到它们。"

#: ../../tutorial/controlflow.rst:14

msgid ":keyword:`!if` Statements"

msgstr ":keyword:`!if` 语句"

#: ../../tutorial/controlflow.rst:16

msgid ""

"Perhaps the most well-known statement type is the :keyword:`if` statement. "

"For example::"

msgstr "最让人耳熟能详的语句应当是 :keyword:`if` 语句："

#: ../../tutorial/controlflow.rst:33

msgid ""

"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "

"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', "

"and is useful to avoid excessive indentation. An :keyword:`!if` ... "

":keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "

"``switch`` or ``case`` statements found in other languages."

msgstr ""

"可有零个或多个 :keyword:`elif` 部分，:keyword:`else` 部分也是可选的。关键字 ':keyword:`!elif`' 是 "

"'else if' 的缩写，用于避免过多的缩进。:keyword:`!if` ... :keyword:`!elif` ... "

":keyword:`!elif` ... 序列可以当作其它语言中 ``switch`` 或 ``case`` 语句的替代品。"

#: ../../tutorial/controlflow.rst:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"如果是把一个值与多个常量进行比较，或者检查特定类型或属性，:keyword:`!match` 语句更有用。详见 :ref:`tut-match`。"

#: ../../tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr ":keyword:`!for` 语句"

#: ../../tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"progression of numbers (like in Pascal), or giving the user the ability to "

"define both the iteration step and halting condition (as C), Python's "

":keyword:`!for` statement iterates over the items of any sequence (a list or"

" a string), in the order that they appear in the sequence. For example (no "

"pun intended):"

msgstr ""

"Python 的 :keyword:`for` 语句与 C 或 Pascal 中的不同。Python 的 :keyword:`!for` "

"语句不迭代算术递增数值（如 Pascal），或是给予用户定义迭代步骤和结束条件的能力（如 "

"C），而是在列表或字符串等任意序列的元素上迭代，按它们在序列中出现的顺序。 例如（这不是有意要暗指什么）："

#: ../../tutorial/controlflow.rst:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to"

" loop over a copy of the collection or to create a new collection::"

msgstr "很难正确地在迭代多项集的同时修改多项集的内容。更简单的方法是迭代多项集的副本或者创建新的多项集："

#: ../../tutorial/controlflow.rst:94

msgid "The :func:`range` Function"

msgstr ":func:`range` 函数"

#: ../../tutorial/controlflow.rst:96

msgid ""

"If you do need to iterate over a sequence of numbers, the built-in function "

":func:`range` comes in handy. It generates arithmetic progressions::"

msgstr "内置函数 :func:`range` 用于生成等差数列："

#: ../../tutorial/controlflow.rst:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length 10."

" It is possible to let the range start at another number, or to specify a "

"different increment (even negative; sometimes this is called the 'step')::"

msgstr ""

"生成的序列绝不会包括给定的终止值；``range(10)`` 生成 10 个值——长度为 10 的序列的所有合法索引。range 可以不从 0 "

"开始，且可以按给定的步长递增（即使是负数步长）："

#: ../../tutorial/controlflow.rst:122

msgid ""

"To iterate over the indices of a sequence, you can combine :func:`range` and"

" :func:`len` as follows::"

msgstr "要按索引迭代序列，可以组合使用 :func:`range` 和 :func:`len`："

#: ../../tutorial/controlflow.rst:135

msgid ""

"In most such cases, however, it is convenient to use the :func:`enumerate` "

"function, see :ref:`tut-loopidioms`."

msgstr "不过大多数情况下 :func:`enumerate` 函数很方便，详见 :ref:`tut-loopidioms`。"

#: ../../tutorial/controlflow.rst:138

msgid "A strange thing happens if you just print a range::"

msgstr "如果直接打印一个 range 会发生意想不到的事情："

#: ../../tutorial/controlflow.rst:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

msgstr ""

":func:`range` "

"返回的对象在很多方面和列表的行为一样，但其实它和列表不一样。该对象只有在被迭代时才一个一个地返回所期望的列表项，并没有真正生成过一个含有全部项的列表，从而节省了空间。"

#: ../../tutorial/controlflow.rst:148

msgid ""

"We say such an object is :term:`iterable`, that is, suitable as a target for"

" functions and constructs that expect something from which they can obtain "

"successive items until the supply is exhausted. We have seen that the "

":keyword:`for` statement is such a construct, while an example of a function"

" that takes an iterable is :func:`sum`::"

msgstr ""

"这种对象称为可迭代对象 :term:`iterable`，适合作为需要获取一系列值的函数或程序构件的参数。:keyword:`for` "

"语句就是这样的程序构件；以可迭代对象作为参数的函数例如 :func:`sum`："

#: ../../tutorial/controlflow.rst:157

msgid ""

"Later we will see more functions that return iterables and take iterables as"

" arguments. In chapter :ref:`tut-structures`, we will discuss in more "

"detail about :func:`list`."

msgstr ""

"之后我们会看到更多返回可迭代对象，或以可迭代对象作为参数的函数。在 :ref:`tut-structures` 这一章中，我们将讨论 "

":func:`list` 的更多细节。"

#: ../../tutorial/controlflow.rst:164

msgid ""

":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "

"Clauses on Loops"

msgstr "循环中的 :keyword:`!break`、:keyword:`!continue` 语句及 :keyword:`!else` 子句"

#: ../../tutorial/controlflow.rst:166

msgid ""

"The :keyword:`break` statement breaks out of the innermost enclosing "

":keyword:`for` or :keyword:`while` loop."

msgstr ":keyword:`break` 语句将跳出最近的一层 :keyword:`for` 或 :keyword:`while` 循环。"

#: ../../tutorial/controlflow.rst:169

msgid ""

"A :keyword:`!for` or :keyword:`!while` loop can include an :keyword:`!else` "

"clause."

msgstr ":keyword:`!for` 或 :keyword:`!while` 循环可以包括 :keyword:`!else` 子句。"

#: ../../tutorial/controlflow.rst:171

msgid ""

"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "

"loop reaches its final iteration."

msgstr "在 :keyword:`for` 循环中，:keyword:`!else` 子句会在循环成功结束最后一次迭代之后执行。"

#: ../../tutorial/controlflow.rst:174

msgid ""

"In a :keyword:`while` loop, it's executed after the loop's condition becomes"

" false."

msgstr "在 :keyword:`while` 循环中，它会在循环条件变为假值后执行。"

#: ../../tutorial/controlflow.rst:176

msgid ""

"In either kind of loop, the :keyword:`!else` clause is **not** executed if "

"the loop was terminated by a :keyword:`break`."

msgstr "无论哪种循环，如果因为 :keyword:`break` 而结束，那么 :keyword:`!else` 子句就 **不会** 执行。"

#: ../../tutorial/controlflow.rst:179

msgid ""

"This is exemplified in the following :keyword:`!for` loop, which searches "

"for prime numbers::"

msgstr "下面的搜索质数的 :keyword:`!for` 循环就是一个例子："

#: ../../tutorial/controlflow.rst:200

msgid ""

"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "

"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"

msgstr ""

"（没错，这段代码就是这么写。仔细看：``else`` 子句属于 :keyword:`for` 循环，**不属于** :keyword:`if` 语句。）"

#: ../../tutorial/controlflow.rst:203

msgid ""

"When used with a loop, the ``else`` clause has more in common with the "

"``else`` clause of a :keyword:`try` statement than it does with that of "

":keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs "

"when no exception occurs, and a loop's ``else`` clause runs when no "

"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, "

"see :ref:`tut-handling`."

msgstr ""

"``else`` 子句用于循环时比起 :keyword:`if` 语句的 ``else`` 子句，更像 :keyword:`try` "

"语句的。:keyword:`try` 语句的 ``else`` 子句在未发生异常时执行，循环的 ``else`` 子句则在未发生 ``break`` "

"时执行。 :keyword:`!try` 语句和异常详见 :ref:`tut-handling`。"

#: ../../tutorial/controlflow.rst:210

msgid ""

"The :keyword:`continue` statement, also borrowed from C, continues with the "

"next iteration of the loop::"

msgstr ":keyword:`continue` 语句，同样借鉴自 C 语言，以执行循环的下一次迭代来继续："

#: ../../tutorial/controlflow.rst:231

msgid ":keyword:`!pass` Statements"

msgstr ":keyword:`!pass` 语句"

#: ../../tutorial/controlflow.rst:233

msgid ""

"The :keyword:`pass` statement does nothing. It can be used when a statement "

"is required syntactically but the program requires no action. For example::"

msgstr ":keyword:`pass` 语句不执行任何动作。语法上需要一个语句，但程序毋需执行任何动作时，可以使用该语句。例如："

#: ../../tutorial/controlflow.rst:240

msgid "This is commonly used for creating minimal classes::"

msgstr "这常用于创建一个最小的类："

#: ../../tutorial/controlflow.rst:246

msgid ""

"Another place :keyword:`pass` can be used is as a place-holder for a "

"function or conditional body when you are working on new code, allowing you "

"to keep thinking at a more abstract level. The :keyword:`!pass` is silently"

" ignored::"

msgstr ""

":keyword:`pass` 还可用作函数或条件语句体的占位符，让你保持在更抽象的层次进行思考。:keyword:`!pass` 会被默默地忽略："

#: ../../tutorial/controlflow.rst:258

msgid ":keyword:`!match` Statements"

msgstr ":keyword:`!match` 语句"

#: ../../tutorial/controlflow.rst:260

msgid ""

"A :keyword:`match` statement takes an expression and compares its value to "

"successive patterns given as one or more case blocks. This is superficially"

" similar to a switch statement in C, Java or JavaScript (and many other "

"languages), but it's more similar to pattern matching in languages like Rust"

" or Haskell. Only the first pattern that matches gets executed and it can "

"also extract components (sequence elements or object attributes) from the "

"value into variables."

msgstr ""

":keyword:`match` 语句接受一个表达式并把它的值与一个或多个 case 块给出的一系列模式进行比较。这表面上像 C、Java 或 "

"JavaScript（以及许多其他程序设计语言）中的 switch 语句，但其实它更像 Rust 或 Haskell "

"中的模式匹配。只有第一个匹配的模式会被执行，并且它还可以提取值的组成部分（序列的元素或对象的属性）赋给变量。"

#: ../../tutorial/controlflow.rst:268

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr "最简单的形式是将一个主语值与一个或多个字面值进行比较："

#: ../../tutorial/controlflow.rst:281

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match. If no case matches, none of the branches is executed."

msgstr "注意最后一个代码块：“变量名” ``_`` 被作为 *通配符* 并必定会匹配成功。如果没有 case 匹配成功，则不会执行任何分支。"

#: ../../tutorial/controlflow.rst:284

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr "你可以使用 ``|`` （“ or ”）在一个模式中组合几个字面值::"

#: ../../tutorial/controlflow.rst:289

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr "形如解包赋值的模式可被用于绑定变量："

#: ../../tutorial/controlflow.rst:305

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next"

" two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values,"

" which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"请仔细学习此代码！第一个模式有两个字面值，可视为前述字面值模式的扩展。接下来的两个模式结合了一个字面值和一个变量，变量 *绑定* "

"了来自主语（``point``）的一个值。第四个模式捕获了两个值，使其在概念上与解包赋值 ``(x, y) = point`` 类似。"

#: ../../tutorial/controlflow.rst:312

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr "如果用类组织数据，可以用“类名后接一个参数列表”这种很像构造器的形式，把属性捕获到变量里："

#: ../../tutorial/controlflow.rst:334

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\","

" \"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"你可以在某些为其属性提供了排序的内置类（例如 dataclass）中使用位置参数。 你也可以通过在你的类中设置 ``__match_args__`` "

"特殊属性来为模式中的属性定义一个专门的位置。 如果它被设为 (\"x\", \"y\")，则以下模式均为等价的（并且都是将 ``y`` 属性绑定到 "

"``var`` 变量）::"

#: ../../tutorial/controlflow.rst:345

msgid ""

"A recommended way to read patterns is to look at them as an extended form of"

" what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like "

"``foo.bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"建议这样来阅读一个模式——通过将其视为赋值语句等号左边的一种扩展形式，来理解各个变量被设为何值。match 语句只会为单一的名称（如上面的 "

"``var``）赋值，而不会赋值给带点号的名称（如 ``foo.bar``）、属性名（如上面的 ``x=`` 和 ``y=``）和类名（是通过其后的 "

"\"(...)\" 来识别的，如上面的 ``Point``）。"

#: ../../tutorial/controlflow.rst:352

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of"

" Points, with ``__match_args__`` added, we could match it like this::"

msgstr ""

"模式可以任意嵌套。举例来说，如果我们有一个由 Point 组成的列表，且 Point 添加了 ``__match_args__`` "

"时，我们可以这样来匹配它："

#: ../../tutorial/controlflow.rst:373

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"我们可以向一个模式添加 ``if`` 子句，称为“约束项”。 如果约束项为假值，则 ``match`` 将继续尝试下一个 case 语句块。 "

"请注意值的捕获发生在约束项被求值之前。::"

#: ../../tutorial/controlflow.rst:383

msgid "Several other key features of this statement:"

msgstr "该语句的一些其它关键特性："

#: ../../tutorial/controlflow.rst:385

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr "与解包赋值类似，元组和列表模式具有完全相同的含义并且实际上都能匹配任意序列，区别是它们不能匹配迭代器或字符串。"

#: ../../tutorial/controlflow.rst:389

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y,"

" *rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"序列模式支持扩展解包：``[x, y, *rest]`` 和 ``(x, y, *rest)`` 和相应的解包赋值做的事是一样的。接在 ``*`` "

"后的名称也可以为 ``_``，所以 ``(x, y, *_)`` 匹配含至少两项的序列，而不必绑定剩余的项。"

#: ../../tutorial/controlflow.rst:394

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "

"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr ""

"映射模式：``{\"bandwidth\": b, \"latency\": l}`` 从字典中捕获 ``\"bandwidth\"`` 和 "

"``\"latency\"`` 的值。额外的键会被忽略，这一点与序列模式不同。``**rest`` 这样的解包也支持。（但 ``**_`` "

"将会是冗余的，故不允许使用。）"

#: ../../tutorial/controlflow.rst:399

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "子模式可使用 ``as`` 关键字来捕获::"

#: ../../tutorial/controlflow.rst:403

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input"

" is a sequence of two points)"

msgstr "将把输入中的第二个元素捕获为 ``p2`` （只要输入是包含两个点的序列）"

#: ../../tutorial/controlflow.rst:406

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr "大多数字面值是按相等性比较的，但是单例对象 ``True``、``False`` 和 ``None`` 则是按 id 比较的。"

#: ../../tutorial/controlflow.rst:409

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variable::"

msgstr "模式可以使用具名常量。它们必须作为带点号的名称出现，以防止它们被解释为用于捕获的变量："

#: ../../tutorial/controlflow.rst:428

msgid ""

"For a more detailed explanation and additional examples, you can look into "

":pep:`636` which is written in a tutorial format."

msgstr "更详细的说明和更多示例，可参阅以教程格式撰写的 :pep:`636`。"

#: ../../tutorial/controlflow.rst:434

msgid "Defining Functions"

msgstr "定义函数"

#: ../../tutorial/controlflow.rst:436

msgid ""

"We can create a function that writes the Fibonacci series to an arbitrary "

"boundary::"

msgstr "下列代码创建一个可以输出限定数值内的斐波那契数列函数："

#: ../../tutorial/controlflow.rst:456

msgid ""

"The keyword :keyword:`def` introduces a function *definition*. It must be "

"followed by the function name and the parenthesized list of formal "

"parameters. The statements that form the body of the function start at the "

"next line, and must be indented."

msgstr "*定义* 函数使用关键字 :keyword:`def`，后跟函数名与括号内的形参列表。函数语句从下一行开始，并且必须缩进。"

#: ../../tutorial/controlflow.rst:461

msgid ""

"The first statement of the function body can optionally be a string literal;"

" this string literal is the function's documentation string, or "

":dfn:`docstring`. (More about docstrings can be found in the section "

":ref:`tut-docstrings`.) There are tools which use docstrings to "

"automatically produce online or printed documentation, or to let the user "

"interactively browse through code; it's good practice to include docstrings "

"in code that you write, so make a habit of it."

msgstr ""

"函数内的第一条语句是字符串时，该字符串就是文档字符串，也称为 :dfn:`docstring`，详见 :ref:`tut-"

"docstrings`。利用文档字符串可以自动生成在线文档或打印版文档，还可以让开发者在浏览代码时直接查阅文档；Python "

"开发者最好养成在代码中加入文档字符串的好习惯。"

#: ../../tutorial/controlflow.rst:468

msgid ""

"The *execution* of a function introduces a new symbol table used for the "

"local variables of the function. More precisely, all variable assignments "

"in a function store the value in the local symbol table; whereas variable "

"references first look in the local symbol table, then in the local symbol "

"tables of enclosing functions, then in the global symbol table, and finally "

"in the table of built-in names. Thus, global variables and variables of "

"enclosing functions cannot be directly assigned a value within a function "

"(unless, for global variables, named in a :keyword:`global` statement, or, "

"for variables of enclosing functions, named in a :keyword:`nonlocal` "

"statement), although they may be referenced."

msgstr ""

"函数在 *执行* "

"时使用函数局部变量符号表，所有函数变量赋值都存在局部符号表中；引用变量时，首先，在局部符号表里查找变量，然后，是外层函数局部符号表，再是全局符号表，最后是内置名称符号表。因此，尽管可以引用全局变量和外层函数的变量，但最好不要在函数内直接赋值（除非是"

" :keyword:`global` 语句定义的全局变量，或 :keyword:`nonlocal` 语句定义的外层函数变量）。"

#: ../../tutorial/controlflow.rst:479

msgid ""

"The actual parameters (arguments) to a function call are introduced in the "

"local symbol table of the called function when it is called; thus, arguments"

" are passed using *call by value* (where the *value* is always an object "

"*reference*, not the value of the object). [#]_ When a function calls "

"another function, or calls itself recursively, a new local symbol table is "

"created for that call."

msgstr ""

"在调用函数时会将实际参数（实参）引入到被调用函数的局部符号表中；因此，实参是使用 *按值调用* 来传递的（其中的 *值* 始终是对象的 *引用* "

"而不是对象的值）。 [#]_ 当一个函数调用另外一个函数时，会为该调用创建一个新的局部符号表。"

#: ../../tutorial/controlflow.rst:486

msgid ""

"A function definition associates the function name with the function object "

"in the current symbol table. The interpreter recognizes the object pointed "

"to by that name as a user-defined function. Other names can also point to "

"that same function object and can also be used to access the function::"

msgstr ""

"函数定义在当前符号表中把函数名与函数对象关联在一起。解释器把函数名指向的对象作为用户自定义函数。还可以使用其他名称指向同一个函数对象，并访问访该函数："

#: ../../tutorial/controlflow.rst:497

msgid ""

"Coming from other languages, you might object that ``fib`` is not a function"

" but a procedure since it doesn't return a value. In fact, even functions "

"without a :keyword:`return` statement do return a value, albeit a rather "

"boring one. This value is called ``None`` (it's a built-in name). Writing "

"the value ``None`` is normally suppressed by the interpreter if it would be "

"the only value written. You can see it if you really want to using "

":func:`print`::"

msgstr ""

"如果你用过其他语言，你可能会认为 ``fib`` 不是函数而是一个过程，因为它没有返回值。 事实上，即使没有 :keyword:`return` "

"语句的函数也有返回值，尽管这个值可能相当无聊。 这个值被称为 ``None`` (是一个内置名称)。 通常解释器会屏蔽单独的返回值 ``None``。 "

"如果你确有需要可以使用 :func:`print` 查看它::"

#: ../../tutorial/controlflow.rst:508

msgid ""

"It is simple to write a function that returns a list of the numbers of the "

"Fibonacci series, instead of printing it::"

msgstr "编写不直接输出斐波那契数列运算结果，而是返回运算结果列表的函数也非常简单："

#: ../../tutorial/controlflow.rst:524

msgid "This example, as usual, demonstrates some new Python features:"

msgstr "本例也新引入了一些 Python 功能："

#: ../../tutorial/controlflow.rst:526

msgid ""

"The :keyword:`return` statement returns with a value from a function. "

":keyword:`!return` without an expression argument returns ``None``. Falling "

"off the end of a function also returns ``None``."

msgstr ""

":keyword:`return` 语句返回函数的值。:keyword:`!return` 语句不带表达式参数时，返回 "

"``None``。函数执行完毕退出也返回 ``None``。"

#: ../../tutorial/controlflow.rst:530

msgid ""

"The statement ``result.append(a)`` calls a *method* of the list object "

"``result``. A method is a function that 'belongs' to an object and is named"

" ``obj.methodname``, where ``obj`` is some object (this may be an "

"expression), and ``methodname`` is the name of a method that is defined by "

"the object's type. Different types define different methods. Methods of "

"different types may have the same name without causing ambiguity. (It is "

"possible to define your own object types and methods, using *classes*, see "

":ref:`tut-classes`) The method :meth:`!append` shown in the example is "

"defined for list objects; it adds a new element at the end of the list. In "

"this example it is equivalent to ``result = result + [a]``, but more "

"efficient."

msgstr ""

"语句 ``result.append(a)`` 调用了列表对象 ``result`` 的 *方法*。 方法是‘从属于’对象的函数，其名称为 "

"``obj.methodname``，其中 ``obj`` 是某个对象（可以是一个表达式），``methodname`` 是由对象的类型定义的方法名称。"

" 不同的类型定义了不同的方法。 不同的类型的方法可以使用相同的名称而不会产生歧义。 （使用 *类* 可以定义自己的对象类型和方法，参见 "

":ref:`tut-classes`。） 在示例中显示的方法 :meth:`!append` 是由列表对象定义的；它会在列表的末尾添加一个新元素。 "

"在本例中它等同于 ``result = result + [a]``，但效率更高。"

#: ../../tutorial/controlflow.rst:545

msgid "More on Defining Functions"

msgstr "函数定义详解"

#: ../../tutorial/controlflow.rst:547

msgid ""

"It is also possible to define functions with a variable number of arguments."

" There are three forms, which can be combined."

msgstr "函数定义支持可变数量的参数。这里列出三种可以组合使用的形式。"

#: ../../tutorial/controlflow.rst:554

msgid "Default Argument Values"

msgstr "默认值参数"

#: ../../tutorial/controlflow.rst:556

msgid ""

"The most useful form is to specify a default value for one or more "

"arguments. This creates a function that can be called with fewer arguments "

"than it is defined to allow. For example::"

msgstr "为参数指定默认值是非常有用的方式。调用函数时，可以使用比定义时更少的参数，例如："

#: ../../tutorial/controlflow.rst:572

msgid "This function can be called in several ways:"

msgstr "该函数可以用以下方式调用："

#: ../../tutorial/controlflow.rst:574

msgid ""

"giving only the mandatory argument: ``ask_ok('Do you really want to "

"quit?')``"

msgstr "只给出必选实参：``ask_ok('Do you really want to quit?')``"

#: ../../tutorial/controlflow.rst:576

msgid ""

"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "

"2)``"

msgstr "给出一个可选实参：``ask_ok('OK to overwrite the file?', 2)``"

#: ../../tutorial/controlflow.rst:578

msgid ""

"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come"

" on, only yes or no!')``"

msgstr ""

"给出所有实参：``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or "

"no!')``"

#: ../../tutorial/controlflow.rst:581

msgid ""

"This example also introduces the :keyword:`in` keyword. This tests whether "

"or not a sequence contains a certain value."

msgstr "本例还使用了关键字 :keyword:`in` ，用于确认序列中是否包含某个值。"

#: ../../tutorial/controlflow.rst:584

msgid ""

"The default values are evaluated at the point of function definition in the "

"*defining* scope, so that ::"

msgstr "默认值在 *定义* 作用域里的函数定义中求值，所以："

#: ../../tutorial/controlflow.rst:595

msgid "will print ``5``."

msgstr "上例输出的是 ``5``。"

#: ../../tutorial/controlflow.rst:597

msgid ""

"**Important warning:** The default value is evaluated only once. This makes"

" a difference when the default is a mutable object such as a list, "

"dictionary, or instances of most classes. For example, the following "

"function accumulates the arguments passed to it on subsequent calls::"

msgstr ""

"**重要警告：** 默认值只计算一次。默认值为列表、字典或类实例等可变对象时，会产生与该规则不同的结果。例如，下面的函数会累积后续调用时传递的参数："

#: ../../tutorial/controlflow.rst:610

msgid "This will print ::"

msgstr "输出结果如下："

#: ../../tutorial/controlflow.rst:616

msgid ""

"If you don't want the default to be shared between subsequent calls, you can"

" write the function like this instead::"

msgstr "不想在后续调用之间共享默认值时，应以如下方式编写函数："

#: ../../tutorial/controlflow.rst:629

msgid "Keyword Arguments"

msgstr "关键字参数"

#: ../../tutorial/controlflow.rst:631

msgid ""

"Functions can also be called using :term:`keyword arguments <keyword "

"argument>` of the form ``kwarg=value``. For instance, the following "

"function::"

msgstr ""

"``kwarg=value`` 形式的 :term:`关键字参数 <keyword argument>` 也可以用于调用函数。函数示例如下："

#: ../../tutorial/controlflow.rst:640

msgid ""

"accepts one required argument (``voltage``) and three optional arguments "

"(``state``, ``action``, and ``type``). This function can be called in any "

"of the following ways::"

msgstr ""

"该函数接受一个必选参数（``voltage``）和三个可选参数（``state``, ``action`` 和 "

"``type``）。该函数可用下列方式调用："

#: ../../tutorial/controlflow.rst:651

msgid "but all the following calls would be invalid::"

msgstr "以下调用函数的方式都无效："

#: ../../tutorial/controlflow.rst:658

msgid ""

"In a function call, keyword arguments must follow positional arguments. All "

"the keyword arguments passed must match one of the arguments accepted by the"

" function (e.g. ``actor`` is not a valid argument for the ``parrot`` "

"function), and their order is not important. This also includes non-"

"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument"

" may receive a value more than once. Here's an example that fails due to "

"this restriction::"

msgstr ""

"函数调用时，关键字参数必须跟在位置参数后面。所有传递的关键字参数都必须匹配一个函数接受的参数（比如，``actor`` 不是函数 ``parrot`` "

"的有效参数），关键字参数的顺序并不重要。这也包括必选参数，（比如，``parrot(voltage=1000)`` "

"也有效）。不能对同一个参数多次赋值，下面就是一个因此限制而失败的例子："

#: ../../tutorial/controlflow.rst:674

msgid ""

"When a final formal parameter of the form ``**name`` is present, it receives"

" a dictionary (see :ref:`typesmapping`) containing all keyword arguments "

"except for those corresponding to a formal parameter. This may be combined "

"with a formal parameter of the form ``*name`` (described in the next "

"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "

"positional arguments beyond the formal parameter list. (``*name`` must "

"occur before ``**name``.) For example, if we define a function like this::"

msgstr ""

"最后一个形参为 ``**name`` 形式时，接收一个字典（详见 "

":ref:`typesmapping`），该字典包含与函数中已定义形参对应之外的所有关键字参数。``**name`` 形参可以与 ``*name`` "

"形参（下一小节介绍）组合使用（``*name`` 必须在 ``**name`` 前面）， ``*name`` 形参接收一个 :ref:`元组 <tut-"

"tuples>`，该元组包含形参列表之外的位置参数。例如，可以定义下面这样的函数："

#: ../../tutorial/controlflow.rst:691

msgid "It could be called like this::"

msgstr "该函数可以用如下方式调用："

#: ../../tutorial/controlflow.rst:699

msgid "and of course it would print:"

msgstr "输出结果如下："

#: ../../tutorial/controlflow.rst:712

msgid ""

"Note that the order in which the keyword arguments are printed is guaranteed"

" to match the order in which they were provided in the function call."

msgstr "注意，关键字参数在输出结果中的顺序与调用函数时的顺序一致。"

#: ../../tutorial/controlflow.rst:716

msgid "Special parameters"

msgstr "特殊参数"

#: ../../tutorial/controlflow.rst:718

msgid ""

"By default, arguments may be passed to a Python function either by position "

"or explicitly by keyword. For readability and performance, it makes sense to"

" restrict the way arguments can be passed so that a developer need only look"

" at the function definition to determine if items are passed by position, by"

" position or keyword, or by keyword."

msgstr ""

"默认情况下，参数可以按位置或显式关键字传递给 Python "

"函数。为了让代码易读、高效，最好限制参数的传递方式，这样，开发者只需查看函数定义，即可确定参数项是仅按位置、按位置或关键字，还是仅按关键字传递。"

#: ../../tutorial/controlflow.rst:724

msgid "A function definition may look like:"

msgstr "函数定义如下："

#: ../../tutorial/controlflow.rst:735

msgid ""

"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind"

" of parameter by how the arguments may be passed to the function: "

"positional-only, positional-or-keyword, and keyword-only. Keyword parameters"

" are also referred to as named parameters."

msgstr "``/`` 和 ``*`` 是可选的。这些符号表明形参如何把参数值传递给函数：位置、位置或关键字、关键字。关键字形参也叫作命名形参。"

#: ../../tutorial/controlflow.rst:742

msgid "Positional-or-Keyword Arguments"

msgstr "位置或关键字参数"

#: ../../tutorial/controlflow.rst:744

msgid ""

"If ``/`` and ``*`` are not present in the function definition, arguments may"

" be passed to a function by position or by keyword."

msgstr "函数定义中未使用 ``/`` 和 ``*`` 时，参数可以按位置或关键字传递给函数。"

#: ../../tutorial/controlflow.rst:749

msgid "Positional-Only Parameters"

msgstr "仅位置参数"

#: ../../tutorial/controlflow.rst:751

msgid ""

"Looking at this in a bit more detail, it is possible to mark certain "

"parameters as *positional-only*. If *positional-only*, the parameters' order"

" matters, and the parameters cannot be passed by keyword. Positional-only "

"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "

"logically separate the positional-only parameters from the rest of the "

"parameters. If there is no ``/`` in the function definition, there are no "

"positional-only parameters."

msgstr ""

"此处再介绍一些细节，特定形参可以标记为 *仅限位置*。*仅限位置* 时，形参的顺序很重要，且这些形参不能用关键字传递。仅限位置形参应放在 ``/`` "

"（正斜杠）前。``/`` 用于在逻辑上分割仅限位置形参与其它形参。如果函数定义中没有 ``/``，则表示没有仅限位置形参。"

#: ../../tutorial/controlflow.rst:759

msgid ""

"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"

"only*."

msgstr "``/`` 后可以是 *位置或关键字* 或 *仅限关键字* 形参。"

#: ../../tutorial/controlflow.rst:763

msgid "Keyword-Only Arguments"

msgstr "仅限关键字参数"

#: ../../tutorial/controlflow.rst:765

msgid ""

"To mark parameters as *keyword-only*, indicating the parameters must be "

"passed by keyword argument, place an ``*`` in the arguments list just before"

" the first *keyword-only* parameter."

msgstr "把形参标记为 *仅限关键字*，表明必须以关键字参数形式传递该形参，应在参数列表中第一个 *仅限关键字* 形参前添加 ``*``。"

#: ../../tutorial/controlflow.rst:771

msgid "Function Examples"

msgstr "函数示例"

#: ../../tutorial/controlflow.rst:773

msgid ""

"Consider the following example function definitions paying close attention "

"to the markers ``/`` and ``*``::"

msgstr "请看下面的函数定义示例，注意 ``/`` 和 ``*`` 标记："

#: ../../tutorial/controlflow.rst:789

msgid ""

"The first function definition, ``standard_arg``, the most familiar form, "

"places no restrictions on the calling convention and arguments may be passed"

" by position or keyword::"

msgstr "第一个函数定义 ``standard_arg`` 是最常见的形式，对调用方式没有任何限制，可以按位置也可以按关键字传递参数："

#: ../../tutorial/controlflow.rst:799

msgid ""

"The second function ``pos_only_arg`` is restricted to only use positional "

"parameters as there is a ``/`` in the function definition::"

msgstr "第二个函数 ``pos_only_arg`` 的函数定义中有 ``/``，仅限使用位置形参："

#: ../../tutorial/controlflow.rst:810

msgid ""

"The third function ``kwd_only_args`` only allows keyword arguments as "

"indicated by a ``*`` in the function definition::"

msgstr "第三个函数 ``kwd_only_args`` 的函数定义通过 ``*`` 表明仅限关键字参数："

#: ../../tutorial/controlflow.rst:821

msgid ""

"And the last uses all three calling conventions in the same function "

"definition::"

msgstr "最后一个函数在同一个函数定义中，使用了全部三种调用惯例："

#: ../../tutorial/controlflow.rst:841

msgid ""

"Finally, consider this function definition which has a potential collision "

"between the positional argument ``name`` and ``**kwds`` which has ``name`` "

"as a key::"

msgstr "下面的函数定义中，``kwds`` 把 ``name`` 当作键，因此，可能与位置参数 ``name`` 产生潜在冲突："

#: ../../tutorial/controlflow.rst:846

msgid ""

"There is no possible call that will make it return ``True`` as the keyword "

"``'name'`` will always bind to the first parameter. For example::"

msgstr "调用该函数不可能返回 ``True``，因为关键字 ``'name'`` 总与第一个形参绑定。例如："

#: ../../tutorial/controlflow.rst:855

msgid ""

"But using ``/`` (positional only arguments), it is possible since it allows "

"``name`` as a positional argument and ``'name'`` as a key in the keyword "

"arguments::"

msgstr ""

"加上 ``/`` （仅限位置参数）后，就可以了。此时，函数定义把 ``name`` 当作位置参数，``'name'`` 也可以作为关键字参数的键："

#: ../../tutorial/controlflow.rst:863

msgid ""

"In other words, the names of positional-only parameters can be used in "

"``**kwds`` without ambiguity."

msgstr "换句话说，仅限位置形参的名称可以在 ``**kwds`` 中使用，而不产生歧义。"

#: ../../tutorial/controlflow.rst:868

msgid "Recap"

msgstr "小结"

#: ../../tutorial/controlflow.rst:870

msgid ""

"The use case will determine which parameters to use in the function "

"definition::"

msgstr "以下用例决定哪些形参可以用于函数定义："

#: ../../tutorial/controlflow.rst:874

msgid "As guidance:"

msgstr "说明："

#: ../../tutorial/controlflow.rst:876

msgid ""

"Use positional-only if you want the name of the parameters to not be "

"available to the user. This is useful when parameter names have no real "

"meaning, if you want to enforce the order of the arguments when the function"

" is called or if you need to take some positional parameters and arbitrary "

"keywords."

msgstr "使用仅限位置形参，可以让用户无法使用形参名。形参名没有实际意义时，强制调用函数的实参顺序时，或同时接收位置形参和关键字时，这种方式很有用。"

#: ../../tutorial/controlflow.rst:881

msgid ""

"Use keyword-only when names have meaning and the function definition is more"

" understandable by being explicit with names or you want to prevent users "

"relying on the position of the argument being passed."

msgstr "当形参名有实际意义，且显式名称可以让函数定义更易理解时，阻止用户依赖传递实参的位置时，才使用关键字。"

#: ../../tutorial/controlflow.rst:884

msgid ""

"For an API, use positional-only to prevent breaking API changes if the "

"parameter's name is modified in the future."

msgstr "对于 API，使用仅限位置形参，可以防止未来修改形参名时造成破坏性的 API 变动。"

#: ../../tutorial/controlflow.rst:890

msgid "Arbitrary Argument Lists"

msgstr "任意实参列表"

#: ../../tutorial/controlflow.rst:895

msgid ""

"Finally, the least frequently used option is to specify that a function can "

"be called with an arbitrary number of arguments. These arguments will be "

"wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number "

"of arguments, zero or more normal arguments may occur. ::"

msgstr ""

"调用函数时，使用任意数量的实参是最少见的选项。这些实参包含在元组中（详见 :ref:`tut-tuples` "

"）。在可变数量的实参之前，可能有若干个普通参数："

#: ../../tutorial/controlflow.rst:904

msgid ""

"Normally, these *variadic* arguments will be last in the list of formal "

"parameters, because they scoop up all remaining input arguments that are "

"passed to the function. Any formal parameters which occur after the "

"``*args`` parameter are 'keyword-only' arguments, meaning that they can only"

" be used as keywords rather than positional arguments. ::"

msgstr ""

"*variadic* 参数用于采集传递给函数的所有剩余参数，因此，它们通常在形参列表的末尾。``*args`` "

"形参后的任何形式参数只能是仅限关键字参数，即只能用作关键字参数，不能用作位置参数："

#: ../../tutorial/controlflow.rst:921

msgid "Unpacking Argument Lists"

msgstr "解包实参列表"

#: ../../tutorial/controlflow.rst:923

msgid ""

"The reverse situation occurs when the arguments are already in a list or "

"tuple but need to be unpacked for a function call requiring separate "

"positional arguments. For instance, the built-in :func:`range` function "

"expects separate *start* and *stop* arguments. If they are not available "

"separately, write the function call with the ``*``\\ -operator to unpack "

"the arguments out of a list or tuple::"

msgstr ""

"函数调用要求独立的位置参数，但实参在列表或元组里时，要执行相反的操作。例如，内置的 :func:`range` 函数要求独立的 *start* 和 "

"*stop* 实参。如果这些参数不是独立的，则要在调用函数时，用 ``*`` 操作符把实参从列表或元组解包出来："

#: ../../tutorial/controlflow.rst:939

msgid ""

"In the same fashion, dictionaries can deliver keyword arguments with the "

"``**``\\ -operator::"

msgstr "同样，字典可以用 ``**`` 操作符传递关键字参数："

#: ../../tutorial/controlflow.rst:955

msgid "Lambda Expressions"

msgstr "Lambda 表达式"

#: ../../tutorial/controlflow.rst:957

msgid ""

"Small anonymous functions can be created with the :keyword:`lambda` keyword."

" This function returns the sum of its two arguments: ``lambda a, b: a+b``. "

"Lambda functions can be used wherever function objects are required. They "

"are syntactically restricted to a single expression. Semantically, they are"

" just syntactic sugar for a normal function definition. Like nested "

"function definitions, lambda functions can reference variables from the "

"containing scope::"

msgstr ""

":keyword:`lambda` 关键字用于创建小巧的匿名函数。``lambda a, b: a+b`` 函数返回两个参数的和。Lambda "

"函数可用于任何需要函数对象的地方。在语法上，匿名函数只能是单个表达式。在语义上，它只是常规函数定义的语法糖。与嵌套函数定义一样，lambda "

"函数可以引用包含作用域中的变量："

#: ../../tutorial/controlflow.rst:974

msgid ""

"The above example uses a lambda expression to return a function. Another "

"use is to pass a small function as an argument::"

msgstr "上例用 lambda 表达式返回函数。还可以把匿名函数用作传递的实参："

#: ../../tutorial/controlflow.rst:986

msgid "Documentation Strings"

msgstr "文档字符串"

#: ../../tutorial/controlflow.rst:993

msgid ""

"Here are some conventions about the content and formatting of documentation "

"strings."

msgstr "以下是文档字符串内容和格式的约定。"

#: ../../tutorial/controlflow.rst:996

msgid ""

"The first line should always be a short, concise summary of the object's "

"purpose. For brevity, it should not explicitly state the object's name or "

"type, since these are available by other means (except if the name happens "

"to be a verb describing a function's operation). This line should begin "

"with a capital letter and end with a period."

msgstr ""

"第一行应为对象用途的简短摘要。为保持简洁，不要在这里显式说明对象名或类型，因为可通过其他方式获取这些信息（除非该名称碰巧是描述函数操作的动词）。这一行应以大写字母开头，以句点结尾。"

#: ../../tutorial/controlflow.rst:1002

msgid ""

"If there are more lines in the documentation string, the second line should "

"be blank, visually separating the summary from the rest of the description."

" The following lines should be one or more paragraphs describing the "

"object's calling conventions, its side effects, etc."

msgstr "文档字符串为多行时，第二行应为空白行，在视觉上将摘要与其余描述分开。后面的行可包含若干段落，描述对象的调用约定、副作用等。"

#: ../../tutorial/controlflow.rst:1007

msgid ""

"The Python parser does not strip indentation from multi-line string literals"

" in Python, so tools that process documentation have to strip indentation if"

" desired. This is done using the following convention. The first non-blank "

"line *after* the first line of the string determines the amount of "

"indentation for the entire documentation string. (We can't use the first "

"line since it is generally adjacent to the string's opening quotes so its "

"indentation is not apparent in the string literal.) Whitespace "

"\"equivalent\" to this indentation is then stripped from the start of all "

"lines of the string. Lines that are indented less should not occur, but if "

"they occur all their leading whitespace should be stripped. Equivalence of "

"whitespace should be tested after expansion of tabs (to 8 spaces, normally)."

msgstr ""

"Python 解析器不会删除 Python 中多行字符串字面值的缩进，因此，文档处理工具应在必要时删除缩进。这项操作遵循以下约定：文档字符串第一行 "

"*之后* "

"的第一个非空行决定了整个文档字符串的缩进量（第一行通常与字符串开头的引号相邻，其缩进在字符串中并不明显，因此，不能用第一行的缩进），然后，删除字符串中所有行开头处与此缩进“等价”的空白符。不能有比此缩进更少的行，但如果出现了缩进更少的行，应删除这些行的所有前导空白符。转化制表符后（通常为"

" 8 个空格），应测试空白符的等效性。"

#: ../../tutorial/controlflow.rst:1019

msgid "Here is an example of a multi-line docstring::"

msgstr "下面是多行文档字符串的一个例子："

#: ../../tutorial/controlflow.rst:1037

msgid "Function Annotations"

msgstr "函数注解"

#: ../../tutorial/controlflow.rst:1045

msgid ""

":ref:`Function annotations <function>` are completely optional metadata "

"information about the types used by user-defined functions (see :pep:`3107` "

"and :pep:`484` for more information)."

msgstr ""

":ref:`函数注解 <function>` 是可选的用户自定义函数类型的元数据完整信息（详见 :pep:`3107` 和 :pep:`484` ）。"

#: ../../tutorial/controlflow.rst:1049

msgid ""

":term:`Annotations <function annotation>` are stored in the "

":attr:`!__annotations__` attribute of the function as a dictionary and have "

"no effect on any other part of the function. Parameter annotations are "

"defined by a colon after the parameter name, followed by an expression "

"evaluating to the value of the annotation. Return annotations are defined "

"by a literal ``->``, followed by an expression, between the parameter list "

"and the colon denoting the end of the :keyword:`def` statement. The "

"following example has a required argument, an optional argument, and the "

"return value annotated::"

msgstr ""

":term:`标注 <function annotation>` 以字典的形式存放在函数的 :attr:`!__annotations__` "

"属性中而对函数的其他部分没有影响。 形参标注的定义方式是在形参名后加冒号，后面跟一个会被求值为标注的值的表达式。 返回值标注的定义方式是加组合符号 "

"``->``，后面跟一个表达式，这样的校注位于形参列表和表示 :keyword:`def` 语句结束的冒号。 "

"下面的示例有一个必须的参数、一个可选的关键字参数以及返回值都带有相应的标注::"

#: ../../tutorial/controlflow.rst:1071