controlflow.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2023
# Freesand Leo <yuqinju@163.com>, 2024
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-05-24 15:56+0000\n"
"PO-Revision-Date: 2022-11-05 17:23+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2024\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 "&#26356;&#22810;&#25511;&#21046;&#27969;&#24037;&#20855;"

#: ../../tutorial/controlflow.rst:7
msgid ""
"Besides the :keyword:`while` statement just introduced, Python uses the "
"usual flow control statements known from other languages, with some twists."
msgstr "&#38500;&#20102;&#19978;&#19968;&#31456;&#20171;&#32461;&#30340; :keyword:`while` &#35821;&#21477;&#65292;Python &#36824;&#25903;&#25345;&#20854;&#20182;&#35821;&#35328;&#20013;&#24120;&#35265;&#30340;&#27969;&#31243;&#25511;&#21046;&#35821;&#21477;&#65292;&#21482;&#26159;&#31245;&#26377;&#19981;&#21516;&#12290;"

#: ../../tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
msgstr ":keyword:`!if` &#35821;&#21477;"

#: ../../tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr "&#26368;&#35753;&#20154;&#32819;&#29087;&#33021;&#35814;&#30340;&#35821;&#21477;&#24212;&#24403;&#26159; :keyword:`if` &#35821;&#21477;&#65306;"

#: ../../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 ""
"&#21487;&#26377;&#38646;&#20010;&#25110;&#22810;&#20010; :keyword:`elif` &#37096;&#20998;&#65292;:keyword:`else` &#37096;&#20998;&#20063;&#26159;&#21487;&#36873;&#30340;&#12290;&#20851;&#38190;&#23383; ':keyword:`!elif`' &#26159; "
"'else if' &#30340;&#32553;&#20889;&#65292;&#29992;&#20110;&#36991;&#20813;&#36807;&#22810;&#30340;&#32553;&#36827;&#12290;:keyword:`!if` ... :keyword:`!elif` ... "
":keyword:`!elif` ... &#24207;&#21015;&#21487;&#20197;&#24403;&#20316;&#20854;&#23427;&#35821;&#35328;&#20013; ``switch`` &#25110; ``case`` &#35821;&#21477;&#30340;&#26367;&#20195;&#21697;&#12290;"

#: ../../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 ""
"&#22914;&#26524;&#26159;&#25226;&#19968;&#20010;&#20540;&#19982;&#22810;&#20010;&#24120;&#37327;&#36827;&#34892;&#27604;&#36739;&#65292;&#25110;&#32773;&#26816;&#26597;&#29305;&#23450;&#31867;&#22411;&#25110;&#23646;&#24615;&#65292;:keyword:`!match` &#35821;&#21477;&#26356;&#26377;&#29992;&#12290;&#35814;&#35265; :ref:`tut-match`&#12290;"

#: ../../tutorial/controlflow.rst:46
msgid ":keyword:`!for` Statements"
msgstr ":keyword:`!for` &#35821;&#21477;"

#: ../../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 &#30340; :keyword:`for` &#35821;&#21477;&#19982; C &#25110; Pascal &#20013;&#30340;&#19981;&#21516;&#12290;Python &#30340; :keyword:`!for` "
"&#35821;&#21477;&#19981;&#36845;&#20195;&#31639;&#26415;&#36882;&#22686;&#25968;&#20540;&#65288;&#22914; Pascal&#65289;&#65292;&#25110;&#26159;&#32473;&#20104;&#29992;&#25143;&#23450;&#20041;&#36845;&#20195;&#27493;&#39588;&#21644;&#32467;&#26463;&#26465;&#20214;&#30340;&#33021;&#21147;&#65288;&#22914; "
"C&#65289;&#65292;&#32780;&#26159;&#22312;&#21015;&#34920;&#25110;&#23383;&#31526;&#20018;&#31561;&#20219;&#24847;&#24207;&#21015;&#30340;&#20803;&#32032;&#19978;&#36845;&#20195;&#65292;&#25353;&#23427;&#20204;&#22312;&#24207;&#21015;&#20013;&#20986;&#29616;&#30340;&#39034;&#24207;&#12290; &#20363;&#22914;&#65288;&#36825;&#19981;&#26159;&#26377;&#24847;&#35201;&#26263;&#25351;&#20160;&#20040;&#65289;&#65306;"

#: ../../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 "&#24456;&#38590;&#27491;&#30830;&#22320;&#22312;&#36845;&#20195;&#22810;&#39033;&#38598;&#30340;&#21516;&#26102;&#20462;&#25913;&#22810;&#39033;&#38598;&#30340;&#20869;&#23481;&#12290;&#26356;&#31616;&#21333;&#30340;&#26041;&#27861;&#26159;&#36845;&#20195;&#22810;&#39033;&#38598;&#30340;&#21103;&#26412;&#25110;&#32773;&#21019;&#24314;&#26032;&#30340;&#22810;&#39033;&#38598;&#65306;"

#: ../../tutorial/controlflow.rst:94
msgid "The :func:`range` Function"
msgstr ":func:`range` &#20989;&#25968;"

#: ../../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 "&#20869;&#32622;&#20989;&#25968; :func:`range` &#29992;&#20110;&#29983;&#25104;&#31561;&#24046;&#25968;&#21015;&#65306;"

#: ../../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 ""
"&#29983;&#25104;&#30340;&#24207;&#21015;&#32477;&#19981;&#20250;&#21253;&#25324;&#32473;&#23450;&#30340;&#32456;&#27490;&#20540;&#65307;``range(10)`` &#29983;&#25104; 10 &#20010;&#20540;&mdash;&mdash;&#38271;&#24230;&#20026; 10 &#30340;&#24207;&#21015;&#30340;&#25152;&#26377;&#21512;&#27861;&#32034;&#24341;&#12290;range &#21487;&#20197;&#19981;&#20174; 0 "
"&#24320;&#22987;&#65292;&#19988;&#21487;&#20197;&#25353;&#32473;&#23450;&#30340;&#27493;&#38271;&#36882;&#22686;&#65288;&#21363;&#20351;&#26159;&#36127;&#25968;&#27493;&#38271;&#65289;&#65306;"

#: ../../tutorial/controlflow.rst:122
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` and"
" :func:`len` as follows::"
msgstr "&#35201;&#25353;&#32034;&#24341;&#36845;&#20195;&#24207;&#21015;&#65292;&#21487;&#20197;&#32452;&#21512;&#20351;&#29992; :func:`range` &#21644; :func:`len`&#65306;"

#: ../../tutorial/controlflow.rst:135
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr "&#19981;&#36807;&#22823;&#22810;&#25968;&#24773;&#20917;&#19979; :func:`enumerate` &#20989;&#25968;&#24456;&#26041;&#20415;&#65292;&#35814;&#35265; :ref:`tut-loopidioms`&#12290;"

#: ../../tutorial/controlflow.rst:138
msgid "A strange thing happens if you just print a range::"
msgstr "&#22914;&#26524;&#30452;&#25509;&#25171;&#21360;&#19968;&#20010; range &#20250;&#21457;&#29983;&#24847;&#24819;&#19981;&#21040;&#30340;&#20107;&#24773;&#65306;"

#: ../../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` "
"&#36820;&#22238;&#30340;&#23545;&#35937;&#22312;&#24456;&#22810;&#26041;&#38754;&#21644;&#21015;&#34920;&#30340;&#34892;&#20026;&#19968;&#26679;&#65292;&#20294;&#20854;&#23454;&#23427;&#21644;&#21015;&#34920;&#19981;&#19968;&#26679;&#12290;&#35813;&#23545;&#35937;&#21482;&#26377;&#22312;&#34987;&#36845;&#20195;&#26102;&#25165;&#19968;&#20010;&#19968;&#20010;&#22320;&#36820;&#22238;&#25152;&#26399;&#26395;&#30340;&#21015;&#34920;&#39033;&#65292;&#24182;&#27809;&#26377;&#30495;&#27491;&#29983;&#25104;&#36807;&#19968;&#20010;&#21547;&#26377;&#20840;&#37096;&#39033;&#30340;&#21015;&#34920;&#65292;&#20174;&#32780;&#33410;&#30465;&#20102;&#31354;&#38388;&#12290;"

#: ../../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 ""
"&#36825;&#31181;&#23545;&#35937;&#31216;&#20026;&#21487;&#36845;&#20195;&#23545;&#35937; :term:`iterable`&#65292;&#36866;&#21512;&#20316;&#20026;&#38656;&#35201;&#33719;&#21462;&#19968;&#31995;&#21015;&#20540;&#30340;&#20989;&#25968;&#25110;&#31243;&#24207;&#26500;&#20214;&#30340;&#21442;&#25968;&#12290;:keyword:`for` "
"&#35821;&#21477;&#23601;&#26159;&#36825;&#26679;&#30340;&#31243;&#24207;&#26500;&#20214;&#65307;&#20197;&#21487;&#36845;&#20195;&#23545;&#35937;&#20316;&#20026;&#21442;&#25968;&#30340;&#20989;&#25968;&#20363;&#22914; :func:`sum`&#65306;"

#: ../../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 ""
"&#20043;&#21518;&#25105;&#20204;&#20250;&#30475;&#21040;&#26356;&#22810;&#36820;&#22238;&#21487;&#36845;&#20195;&#23545;&#35937;&#65292;&#25110;&#20197;&#21487;&#36845;&#20195;&#23545;&#35937;&#20316;&#20026;&#21442;&#25968;&#30340;&#20989;&#25968;&#12290;&#22312; :ref:`tut-structures` &#36825;&#19968;&#31456;&#20013;&#65292;&#25105;&#20204;&#23558;&#35752;&#35770; "
":func:`list` &#30340;&#26356;&#22810;&#32454;&#33410;&#12290;"

#: ../../tutorial/controlflow.rst:164
msgid ""
":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "
"Clauses on Loops"
msgstr "&#24490;&#29615;&#20013;&#30340; :keyword:`!break`&#12289;:keyword:`!continue` &#35821;&#21477;&#21450; :keyword:`!else` &#23376;&#21477;"

#: ../../tutorial/controlflow.rst:166
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
":keyword:`break` &#35821;&#21477;&#21644; C &#20013;&#30340;&#31867;&#20284;&#65292;&#29992;&#20110;&#36339;&#20986;&#26368;&#36817;&#30340; :keyword:`for` &#25110; :keyword:`while` &#24490;&#29615;&#12290;"

#: ../../tutorial/controlflow.rst:169
msgid ""
"Loop statements may have an :keyword:`!else` clause; it is executed when the"
" loop terminates through exhaustion of the iterable (with :keyword:`for`) or"
" when the condition becomes false (with :keyword:`while`), but not when the "
"loop is terminated by a :keyword:`break` statement.  This is exemplified by "
"the following loop, which searches for prime numbers::"
msgstr ""
"&#24490;&#29615;&#35821;&#21477;&#25903;&#25345; :keyword:`!else` &#23376;&#21477;&#65307;:keyword:`for` &#24490;&#29615;&#20013;&#65292;&#21487;&#36845;&#20195;&#23545;&#35937;&#20013;&#30340;&#20803;&#32032;&#20840;&#37096;&#24490;&#29615;&#23436;&#27605;&#65292;&#25110; "
":keyword:`while` &#24490;&#29615;&#30340;&#26465;&#20214;&#20026;&#20551;&#26102;&#65292;&#25191;&#34892;&#35813;&#23376;&#21477;&#65307;:keyword:`break` &#35821;&#21477;&#32456;&#27490;&#24490;&#29615;&#26102;&#65292;&#19981;&#25191;&#34892;&#35813;&#23376;&#21477;&#12290; "
"&#35831;&#30475;&#19979;&#38754;&#36825;&#20010;&#26597;&#25214;&#32032;&#25968;&#30340;&#24490;&#29615;&#31034;&#20363;&#65306;"

#: ../../tutorial/controlflow.rst:193
msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
msgstr ""
"&#65288;&#27809;&#38169;&#65292;&#36825;&#27573;&#20195;&#30721;&#23601;&#26159;&#36825;&#20040;&#20889;&#12290;&#20180;&#32454;&#30475;&#65306;``else`` &#23376;&#21477;&#23646;&#20110; :keyword:`for` &#24490;&#29615;&#65292;**&#19981;&#23646;&#20110;** :keyword:`if` &#35821;&#21477;&#12290;&#65289;"

#: ../../tutorial/controlflow.rst:196
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`` &#23376;&#21477;&#29992;&#20110;&#24490;&#29615;&#26102;&#27604;&#36215; :keyword:`if`  &#35821;&#21477;&#30340; ``else`` &#23376;&#21477;&#65292;&#26356;&#20687; :keyword:`try` "
"&#35821;&#21477;&#30340;&#12290;:keyword:`try` &#35821;&#21477;&#30340; ``else`` &#23376;&#21477;&#22312;&#26410;&#21457;&#29983;&#24322;&#24120;&#26102;&#25191;&#34892;&#65292;&#24490;&#29615;&#30340; ``else`` &#23376;&#21477;&#21017;&#22312;&#26410;&#21457;&#29983; ``break`` "
"&#26102;&#25191;&#34892;&#12290; :keyword:`!try` &#35821;&#21477;&#21644;&#24322;&#24120;&#35814;&#35265; :ref:`tut-handling`&#12290;"

#: ../../tutorial/controlflow.rst:203
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
msgstr ":keyword:`continue` &#35821;&#21477;&#65292;&#21516;&#26679;&#20511;&#37492;&#33258; C &#35821;&#35328;&#65292;&#20197;&#25191;&#34892;&#24490;&#29615;&#30340;&#19979;&#19968;&#27425;&#36845;&#20195;&#26469;&#32487;&#32493;&#65306;"

#: ../../tutorial/controlflow.rst:224
msgid ":keyword:`!pass` Statements"
msgstr ":keyword:`!pass` &#35821;&#21477;"

#: ../../tutorial/controlflow.rst:226
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` &#35821;&#21477;&#19981;&#25191;&#34892;&#20219;&#20309;&#21160;&#20316;&#12290;&#35821;&#27861;&#19978;&#38656;&#35201;&#19968;&#20010;&#35821;&#21477;&#65292;&#20294;&#31243;&#24207;&#27595;&#38656;&#25191;&#34892;&#20219;&#20309;&#21160;&#20316;&#26102;&#65292;&#21487;&#20197;&#20351;&#29992;&#35813;&#35821;&#21477;&#12290;&#20363;&#22914;&#65306;"

#: ../../tutorial/controlflow.rst:233
msgid "This is commonly used for creating minimal classes::"
msgstr "&#36825;&#24120;&#29992;&#20110;&#21019;&#24314;&#19968;&#20010;&#26368;&#23567;&#30340;&#31867;&#65306;"

#: ../../tutorial/controlflow.rst:239
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` &#36824;&#21487;&#29992;&#20316;&#20989;&#25968;&#25110;&#26465;&#20214;&#35821;&#21477;&#20307;&#30340;&#21344;&#20301;&#31526;&#65292;&#35753;&#20320;&#20445;&#25345;&#22312;&#26356;&#25277;&#35937;&#30340;&#23618;&#27425;&#36827;&#34892;&#24605;&#32771;&#12290;:keyword:`!pass` &#20250;&#34987;&#40664;&#40664;&#22320;&#24573;&#30053;&#65306;"

#: ../../tutorial/controlflow.rst:251
msgid ":keyword:`!match` Statements"
msgstr ":keyword:`!match` &#35821;&#21477;"

#: ../../tutorial/controlflow.rst:253
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` &#35821;&#21477;&#25509;&#21463;&#19968;&#20010;&#34920;&#36798;&#24335;&#24182;&#25226;&#23427;&#30340;&#20540;&#19982;&#19968;&#20010;&#25110;&#22810;&#20010; case &#22359;&#32473;&#20986;&#30340;&#19968;&#31995;&#21015;&#27169;&#24335;&#36827;&#34892;&#27604;&#36739;&#12290;&#36825;&#34920;&#38754;&#19978;&#20687; C&#12289;Java &#25110; "
"JavaScript&#65288;&#20197;&#21450;&#35768;&#22810;&#20854;&#20182;&#31243;&#24207;&#35774;&#35745;&#35821;&#35328;&#65289;&#20013;&#30340; switch &#35821;&#21477;&#65292;&#20294;&#20854;&#23454;&#23427;&#26356;&#20687; Rust &#25110; Haskell "
"&#20013;&#30340;&#27169;&#24335;&#21305;&#37197;&#12290;&#21482;&#26377;&#31532;&#19968;&#20010;&#21305;&#37197;&#30340;&#27169;&#24335;&#20250;&#34987;&#25191;&#34892;&#65292;&#24182;&#19988;&#23427;&#36824;&#21487;&#20197;&#25552;&#21462;&#20540;&#30340;&#32452;&#25104;&#37096;&#20998;&#65288;&#24207;&#21015;&#30340;&#20803;&#32032;&#25110;&#23545;&#35937;&#30340;&#23646;&#24615;&#65289;&#36171;&#32473;&#21464;&#37327;&#12290;"

#: ../../tutorial/controlflow.rst:261
msgid ""
"The simplest form compares a subject value against one or more literals::"
msgstr "&#26368;&#31616;&#21333;&#30340;&#24418;&#24335;&#26159;&#23558;&#19968;&#20010;&#20027;&#35821;&#20540;&#19982;&#19968;&#20010;&#25110;&#22810;&#20010;&#23383;&#38754;&#20540;&#36827;&#34892;&#27604;&#36739;&#65306;"

#: ../../tutorial/controlflow.rst:274
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 "&#27880;&#24847;&#26368;&#21518;&#19968;&#20010;&#20195;&#30721;&#22359;&#65306;&ldquo;&#21464;&#37327;&#21517;&rdquo; ``_`` &#34987;&#20316;&#20026; *&#36890;&#37197;&#31526;* &#24182;&#24517;&#23450;&#20250;&#21305;&#37197;&#25104;&#21151;&#12290;&#22914;&#26524;&#27809;&#26377; case &#21305;&#37197;&#25104;&#21151;&#65292;&#21017;&#19981;&#20250;&#25191;&#34892;&#20219;&#20309;&#20998;&#25903;&#12290;"

#: ../../tutorial/controlflow.rst:277
msgid ""
"You can combine several literals in a single pattern using ``|`` (\"or\")::"
msgstr "&#20320;&#21487;&#20197;&#20351;&#29992; ``|`` &#65288;&ldquo; or &rdquo;&#65289;&#22312;&#19968;&#20010;&#27169;&#24335;&#20013;&#32452;&#21512;&#20960;&#20010;&#23383;&#38754;&#20540;::"

#: ../../tutorial/controlflow.rst:282
msgid ""
"Patterns can look like unpacking assignments, and can be used to bind "
"variables::"
msgstr "&#24418;&#22914;&#35299;&#21253;&#36171;&#20540;&#30340;&#27169;&#24335;&#21487;&#34987;&#29992;&#20110;&#32465;&#23450;&#21464;&#37327;&#65306;"

#: ../../tutorial/controlflow.rst:298
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 ""
"&#35831;&#20180;&#32454;&#23398;&#20064;&#27492;&#20195;&#30721;&#65281;&#31532;&#19968;&#20010;&#27169;&#24335;&#26377;&#20004;&#20010;&#23383;&#38754;&#20540;&#65292;&#21487;&#35270;&#20026;&#21069;&#36848;&#23383;&#38754;&#20540;&#27169;&#24335;&#30340;&#25193;&#23637;&#12290;&#25509;&#19979;&#26469;&#30340;&#20004;&#20010;&#27169;&#24335;&#32467;&#21512;&#20102;&#19968;&#20010;&#23383;&#38754;&#20540;&#21644;&#19968;&#20010;&#21464;&#37327;&#65292;&#21464;&#37327; *&#32465;&#23450;* "
"&#20102;&#26469;&#33258;&#20027;&#35821;&#65288;``point``&#65289;&#30340;&#19968;&#20010;&#20540;&#12290;&#31532;&#22235;&#20010;&#27169;&#24335;&#25429;&#33719;&#20102;&#20004;&#20010;&#20540;&#65292;&#20351;&#20854;&#22312;&#27010;&#24565;&#19978;&#19982;&#35299;&#21253;&#36171;&#20540; ``(x, y) = point`` &#31867;&#20284;&#12290;"

#: ../../tutorial/controlflow.rst:305
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 "&#22914;&#26524;&#29992;&#31867;&#32452;&#32455;&#25968;&#25454;&#65292;&#21487;&#20197;&#29992;&ldquo;&#31867;&#21517;&#21518;&#25509;&#19968;&#20010;&#21442;&#25968;&#21015;&#34920;&rdquo;&#36825;&#31181;&#24456;&#20687;&#26500;&#36896;&#22120;&#30340;&#24418;&#24335;&#65292;&#25226;&#23646;&#24615;&#25429;&#33719;&#21040;&#21464;&#37327;&#37324;&#65306;"

#: ../../tutorial/controlflow.rst:326
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 ""
"&#20320;&#21487;&#20197;&#22312;&#26576;&#20123;&#20026;&#20854;&#23646;&#24615;&#25552;&#20379;&#20102;&#25490;&#24207;&#30340;&#20869;&#32622;&#31867;&#65288;&#20363;&#22914; dataclass&#65289;&#20013;&#20351;&#29992;&#20301;&#32622;&#21442;&#25968;&#12290; &#20320;&#20063;&#21487;&#20197;&#36890;&#36807;&#22312;&#20320;&#30340;&#31867;&#20013;&#35774;&#32622; ``__match_args__`` "
"&#29305;&#27530;&#23646;&#24615;&#26469;&#20026;&#27169;&#24335;&#20013;&#30340;&#23646;&#24615;&#23450;&#20041;&#19968;&#20010;&#19987;&#38376;&#30340;&#20301;&#32622;&#12290; &#22914;&#26524;&#23427;&#34987;&#35774;&#20026; (\"x\", \"y\")&#65292;&#21017;&#20197;&#19979;&#27169;&#24335;&#22343;&#20026;&#31561;&#20215;&#30340;&#65288;&#24182;&#19988;&#37117;&#26159;&#23558; ``y`` &#23646;&#24615;&#32465;&#23450;&#21040; "
"``var`` &#21464;&#37327;&#65289;::"

#: ../../tutorial/controlflow.rst:337
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 ""
"&#24314;&#35758;&#36825;&#26679;&#26469;&#38405;&#35835;&#19968;&#20010;&#27169;&#24335;&mdash;&mdash;&#36890;&#36807;&#23558;&#20854;&#35270;&#20026;&#36171;&#20540;&#35821;&#21477;&#31561;&#21495;&#24038;&#36793;&#30340;&#19968;&#31181;&#25193;&#23637;&#24418;&#24335;&#65292;&#26469;&#29702;&#35299;&#21508;&#20010;&#21464;&#37327;&#34987;&#35774;&#20026;&#20309;&#20540;&#12290;match &#35821;&#21477;&#21482;&#20250;&#20026;&#21333;&#19968;&#30340;&#21517;&#31216;&#65288;&#22914;&#19978;&#38754;&#30340; "
"``var``&#65289;&#36171;&#20540;&#65292;&#32780;&#19981;&#20250;&#36171;&#20540;&#32473;&#24102;&#28857;&#21495;&#30340;&#21517;&#31216;&#65288;&#22914; ``foo.bar``&#65289;&#12289;&#23646;&#24615;&#21517;&#65288;&#22914;&#19978;&#38754;&#30340; ``x=`` &#21644; ``y=``&#65289;&#21644;&#31867;&#21517;&#65288;&#26159;&#36890;&#36807;&#20854;&#21518;&#30340; "
"\"(...)\" &#26469;&#35782;&#21035;&#30340;&#65292;&#22914;&#19978;&#38754;&#30340; ``Point``&#65289;&#12290;"

#: ../../tutorial/controlflow.rst:344
msgid ""
"Patterns can be arbitrarily nested.  For example, if we have a short list of"
" points, we could match it like this::"
msgstr "&#27169;&#24335;&#21487;&#20197;&#20219;&#24847;&#22320;&#23884;&#22871;&#12290;&#20363;&#22914;&#65292;&#22914;&#26524;&#26377;&#19968;&#20010;&#30001;&#28857;&#32452;&#25104;&#30340;&#30701;&#21015;&#34920;&#65292;&#21017;&#21487;&#20351;&#29992;&#22914;&#19979;&#26041;&#24335;&#36827;&#34892;&#21305;&#37197;&#65306;"

#: ../../tutorial/controlflow.rst:359
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 ""
"&#25105;&#20204;&#21487;&#20197;&#21521;&#19968;&#20010;&#27169;&#24335;&#28155;&#21152; ``if`` &#23376;&#21477;&#65292;&#31216;&#20026;&ldquo;&#32422;&#26463;&#39033;&rdquo;&#12290; &#22914;&#26524;&#32422;&#26463;&#39033;&#20026;&#20551;&#20540;&#65292;&#21017; ``match`` &#23558;&#32487;&#32493;&#23581;&#35797;&#19979;&#19968;&#20010; case &#35821;&#21477;&#22359;&#12290; "
"&#35831;&#27880;&#24847;&#20540;&#30340;&#25429;&#33719;&#21457;&#29983;&#22312;&#32422;&#26463;&#39033;&#34987;&#27714;&#20540;&#20043;&#21069;&#12290;::"

#: ../../tutorial/controlflow.rst:369
msgid "Several other key features of this statement:"
msgstr "&#35813;&#35821;&#21477;&#30340;&#19968;&#20123;&#20854;&#23427;&#20851;&#38190;&#29305;&#24615;&#65306;"

#: ../../tutorial/controlflow.rst:371
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 "&#19982;&#35299;&#21253;&#36171;&#20540;&#31867;&#20284;&#65292;&#20803;&#32452;&#21644;&#21015;&#34920;&#27169;&#24335;&#20855;&#26377;&#23436;&#20840;&#30456;&#21516;&#30340;&#21547;&#20041;&#24182;&#19988;&#23454;&#38469;&#19978;&#37117;&#33021;&#21305;&#37197;&#20219;&#24847;&#24207;&#21015;&#65292;&#21306;&#21035;&#26159;&#23427;&#20204;&#19981;&#33021;&#21305;&#37197;&#36845;&#20195;&#22120;&#25110;&#23383;&#31526;&#20018;&#12290;"

#: ../../tutorial/controlflow.rst:375
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 ""
"&#24207;&#21015;&#27169;&#24335;&#25903;&#25345;&#25193;&#23637;&#35299;&#21253;&#65306;``[x, y, *rest]`` &#21644; ``(x, y, *rest)`` &#21644;&#30456;&#24212;&#30340;&#35299;&#21253;&#36171;&#20540;&#20570;&#30340;&#20107;&#26159;&#19968;&#26679;&#30340;&#12290;&#25509;&#22312; ``*`` "
"&#21518;&#30340;&#21517;&#31216;&#20063;&#21487;&#20197;&#20026; ``_``&#65292;&#25152;&#20197; ``(x, y, *_)`` &#21305;&#37197;&#21547;&#33267;&#23569;&#20004;&#39033;&#30340;&#24207;&#21015;&#65292;&#32780;&#19981;&#24517;&#32465;&#23450;&#21097;&#20313;&#30340;&#39033;&#12290;"

#: ../../tutorial/controlflow.rst:380
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 ""
"&#26144;&#23556;&#27169;&#24335;&#65306;``{\"bandwidth\": b, \"latency\": l}`` &#20174;&#23383;&#20856;&#20013;&#25429;&#33719; ``\"bandwidth\"`` &#21644; "
"``\"latency\"`` &#30340;&#20540;&#12290;&#39069;&#22806;&#30340;&#38190;&#20250;&#34987;&#24573;&#30053;&#65292;&#36825;&#19968;&#28857;&#19982;&#24207;&#21015;&#27169;&#24335;&#19981;&#21516;&#12290;``**rest`` &#36825;&#26679;&#30340;&#35299;&#21253;&#20063;&#25903;&#25345;&#12290;&#65288;&#20294; ``**_`` "
"&#23558;&#20250;&#26159;&#20887;&#20313;&#30340;&#65292;&#25925;&#19981;&#20801;&#35768;&#20351;&#29992;&#12290;&#65289;"

#: ../../tutorial/controlflow.rst:385
msgid "Subpatterns may be captured using the ``as`` keyword::"
msgstr "&#23376;&#27169;&#24335;&#21487;&#20351;&#29992; ``as`` &#20851;&#38190;&#23383;&#26469;&#25429;&#33719;::"

#: ../../tutorial/controlflow.rst:389
msgid ""
"will capture the second element of the input as ``p2`` (as long as the input"
" is a sequence of two points)"
msgstr "&#23558;&#25226;&#36755;&#20837;&#20013;&#30340;&#31532;&#20108;&#20010;&#20803;&#32032;&#25429;&#33719;&#20026; ``p2`` &#65288;&#21482;&#35201;&#36755;&#20837;&#26159;&#21253;&#21547;&#20004;&#20010;&#28857;&#30340;&#24207;&#21015;&#65289;"

#: ../../tutorial/controlflow.rst:392
msgid ""
"Most literals are compared by equality, however the singletons ``True``, "
"``False`` and ``None`` are compared by identity."
msgstr "&#22823;&#22810;&#25968;&#23383;&#38754;&#20540;&#26159;&#25353;&#30456;&#31561;&#24615;&#27604;&#36739;&#30340;&#65292;&#20294;&#26159;&#21333;&#20363;&#23545;&#35937; ``True``&#12289;``False`` &#21644; ``None`` &#21017;&#26159;&#25353; id &#27604;&#36739;&#30340;&#12290;"

#: ../../tutorial/controlflow.rst:395
msgid ""
"Patterns may use named constants.  These must be dotted names to prevent "
"them from being interpreted as capture variable::"
msgstr "&#27169;&#24335;&#21487;&#20197;&#20351;&#29992;&#20855;&#21517;&#24120;&#37327;&#12290;&#23427;&#20204;&#24517;&#39035;&#20316;&#20026;&#24102;&#28857;&#21495;&#30340;&#21517;&#31216;&#20986;&#29616;&#65292;&#20197;&#38450;&#27490;&#23427;&#20204;&#34987;&#35299;&#37322;&#20026;&#29992;&#20110;&#25429;&#33719;&#30340;&#21464;&#37327;&#65306;"

#: ../../tutorial/controlflow.rst:414
msgid ""
"For a more detailed explanation and additional examples, you can look into "
":pep:`636` which is written in a tutorial format."
msgstr "&#26356;&#35814;&#32454;&#30340;&#35828;&#26126;&#21644;&#26356;&#22810;&#31034;&#20363;&#65292;&#21487;&#21442;&#38405;&#20197;&#25945;&#31243;&#26684;&#24335;&#25776;&#20889;&#30340; :pep:`636`&#12290;"

#: ../../tutorial/controlflow.rst:420
msgid "Defining Functions"
msgstr "&#23450;&#20041;&#20989;&#25968;"

#: ../../tutorial/controlflow.rst:422
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr "&#19979;&#21015;&#20195;&#30721;&#21019;&#24314;&#19968;&#20010;&#21487;&#20197;&#36755;&#20986;&#38480;&#23450;&#25968;&#20540;&#20869;&#30340;&#26000;&#27874;&#37027;&#22865;&#25968;&#21015;&#20989;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:442
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 "*&#23450;&#20041;* &#20989;&#25968;&#20351;&#29992;&#20851;&#38190;&#23383; :keyword:`def`&#65292;&#21518;&#36319;&#20989;&#25968;&#21517;&#19982;&#25324;&#21495;&#20869;&#30340;&#24418;&#21442;&#21015;&#34920;&#12290;&#20989;&#25968;&#35821;&#21477;&#20174;&#19979;&#19968;&#34892;&#24320;&#22987;&#65292;&#24182;&#19988;&#24517;&#39035;&#32553;&#36827;&#12290;"

#: ../../tutorial/controlflow.rst:447
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 ""
"&#20989;&#25968;&#20869;&#30340;&#31532;&#19968;&#26465;&#35821;&#21477;&#26159;&#23383;&#31526;&#20018;&#26102;&#65292;&#35813;&#23383;&#31526;&#20018;&#23601;&#26159;&#25991;&#26723;&#23383;&#31526;&#20018;&#65292;&#20063;&#31216;&#20026; :dfn:`docstring`&#65292;&#35814;&#35265; :ref:`tut-"
"docstrings`&#12290;&#21033;&#29992;&#25991;&#26723;&#23383;&#31526;&#20018;&#21487;&#20197;&#33258;&#21160;&#29983;&#25104;&#22312;&#32447;&#25991;&#26723;&#25110;&#25171;&#21360;&#29256;&#25991;&#26723;&#65292;&#36824;&#21487;&#20197;&#35753;&#24320;&#21457;&#32773;&#22312;&#27983;&#35272;&#20195;&#30721;&#26102;&#30452;&#25509;&#26597;&#38405;&#25991;&#26723;&#65307;Python "
"&#24320;&#21457;&#32773;&#26368;&#22909;&#20859;&#25104;&#22312;&#20195;&#30721;&#20013;&#21152;&#20837;&#25991;&#26723;&#23383;&#31526;&#20018;&#30340;&#22909;&#20064;&#24815;&#12290;"

#: ../../tutorial/controlflow.rst:454
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 ""
"&#20989;&#25968;&#22312; *&#25191;&#34892;* "
"&#26102;&#20351;&#29992;&#20989;&#25968;&#23616;&#37096;&#21464;&#37327;&#31526;&#21495;&#34920;&#65292;&#25152;&#26377;&#20989;&#25968;&#21464;&#37327;&#36171;&#20540;&#37117;&#23384;&#22312;&#23616;&#37096;&#31526;&#21495;&#34920;&#20013;&#65307;&#24341;&#29992;&#21464;&#37327;&#26102;&#65292;&#39318;&#20808;&#65292;&#22312;&#23616;&#37096;&#31526;&#21495;&#34920;&#37324;&#26597;&#25214;&#21464;&#37327;&#65292;&#28982;&#21518;&#65292;&#26159;&#22806;&#23618;&#20989;&#25968;&#23616;&#37096;&#31526;&#21495;&#34920;&#65292;&#20877;&#26159;&#20840;&#23616;&#31526;&#21495;&#34920;&#65292;&#26368;&#21518;&#26159;&#20869;&#32622;&#21517;&#31216;&#31526;&#21495;&#34920;&#12290;&#22240;&#27492;&#65292;&#23613;&#31649;&#21487;&#20197;&#24341;&#29992;&#20840;&#23616;&#21464;&#37327;&#21644;&#22806;&#23618;&#20989;&#25968;&#30340;&#21464;&#37327;&#65292;&#20294;&#26368;&#22909;&#19981;&#35201;&#22312;&#20989;&#25968;&#20869;&#30452;&#25509;&#36171;&#20540;&#65288;&#38500;&#38750;&#26159;"
" :keyword:`global` &#35821;&#21477;&#23450;&#20041;&#30340;&#20840;&#23616;&#21464;&#37327;&#65292;&#25110; :keyword:`nonlocal` &#35821;&#21477;&#23450;&#20041;&#30340;&#22806;&#23618;&#20989;&#25968;&#21464;&#37327;&#65289;&#12290;"

#: ../../tutorial/controlflow.rst:465
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 ""
"&#22312;&#35843;&#29992;&#20989;&#25968;&#26102;&#20250;&#23558;&#23454;&#38469;&#21442;&#25968;&#65288;&#23454;&#21442;&#65289;&#24341;&#20837;&#21040;&#34987;&#35843;&#29992;&#20989;&#25968;&#30340;&#23616;&#37096;&#31526;&#21495;&#34920;&#20013;&#65307;&#22240;&#27492;&#65292;&#23454;&#21442;&#26159;&#20351;&#29992; *&#25353;&#20540;&#35843;&#29992;* &#26469;&#20256;&#36882;&#30340;&#65288;&#20854;&#20013;&#30340; *&#20540;* &#22987;&#32456;&#26159;&#23545;&#35937;&#30340; *&#24341;&#29992;* "
"&#32780;&#19981;&#26159;&#23545;&#35937;&#30340;&#20540;&#65289;&#12290; [#]_ &#24403;&#19968;&#20010;&#20989;&#25968;&#35843;&#29992;&#21478;&#22806;&#19968;&#20010;&#20989;&#25968;&#26102;&#65292;&#20250;&#20026;&#35813;&#35843;&#29992;&#21019;&#24314;&#19968;&#20010;&#26032;&#30340;&#23616;&#37096;&#31526;&#21495;&#34920;&#12290;"

#: ../../tutorial/controlflow.rst:472
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 ""
"&#20989;&#25968;&#23450;&#20041;&#22312;&#24403;&#21069;&#31526;&#21495;&#34920;&#20013;&#25226;&#20989;&#25968;&#21517;&#19982;&#20989;&#25968;&#23545;&#35937;&#20851;&#32852;&#22312;&#19968;&#36215;&#12290;&#35299;&#37322;&#22120;&#25226;&#20989;&#25968;&#21517;&#25351;&#21521;&#30340;&#23545;&#35937;&#20316;&#20026;&#29992;&#25143;&#33258;&#23450;&#20041;&#20989;&#25968;&#12290;&#36824;&#21487;&#20197;&#20351;&#29992;&#20854;&#20182;&#21517;&#31216;&#25351;&#21521;&#21516;&#19968;&#20010;&#20989;&#25968;&#23545;&#35937;&#65292;&#24182;&#35775;&#38382;&#35775;&#35813;&#20989;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:483
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 ""
"&#22914;&#26524;&#20320;&#29992;&#36807;&#20854;&#20182;&#35821;&#35328;&#65292;&#20320;&#21487;&#33021;&#20250;&#35748;&#20026; ``fib`` &#19981;&#26159;&#20989;&#25968;&#32780;&#26159;&#19968;&#20010;&#36807;&#31243;&#65292;&#22240;&#20026;&#23427;&#27809;&#26377;&#36820;&#22238;&#20540;&#12290; &#20107;&#23454;&#19978;&#65292;&#21363;&#20351;&#27809;&#26377; :keyword:`return` "
"&#35821;&#21477;&#30340;&#20989;&#25968;&#20063;&#26377;&#36820;&#22238;&#20540;&#65292;&#23613;&#31649;&#36825;&#20010;&#20540;&#21487;&#33021;&#30456;&#24403;&#26080;&#32842;&#12290; &#36825;&#20010;&#20540;&#34987;&#31216;&#20026; ``None`` (&#26159;&#19968;&#20010;&#20869;&#32622;&#21517;&#31216;)&#12290; &#36890;&#24120;&#35299;&#37322;&#22120;&#20250;&#23631;&#34109;&#21333;&#29420;&#30340;&#36820;&#22238;&#20540; ``None``&#12290; "
"&#22914;&#26524;&#20320;&#30830;&#26377;&#38656;&#35201;&#21487;&#20197;&#20351;&#29992; :func:`print` &#26597;&#30475;&#23427;::"

#: ../../tutorial/controlflow.rst:494
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr "&#32534;&#20889;&#19981;&#30452;&#25509;&#36755;&#20986;&#26000;&#27874;&#37027;&#22865;&#25968;&#21015;&#36816;&#31639;&#32467;&#26524;&#65292;&#32780;&#26159;&#36820;&#22238;&#36816;&#31639;&#32467;&#26524;&#21015;&#34920;&#30340;&#20989;&#25968;&#20063;&#38750;&#24120;&#31616;&#21333;&#65306;"

#: ../../tutorial/controlflow.rst:510
msgid "This example, as usual, demonstrates some new Python features:"
msgstr "&#26412;&#20363;&#20063;&#26032;&#24341;&#20837;&#20102;&#19968;&#20123; Python &#21151;&#33021;&#65306;"

#: ../../tutorial/controlflow.rst:512
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` &#35821;&#21477;&#36820;&#22238;&#20989;&#25968;&#30340;&#20540;&#12290;:keyword:`!return` &#35821;&#21477;&#19981;&#24102;&#34920;&#36798;&#24335;&#21442;&#25968;&#26102;&#65292;&#36820;&#22238; "
"``None``&#12290;&#20989;&#25968;&#25191;&#34892;&#23436;&#27605;&#36864;&#20986;&#20063;&#36820;&#22238; ``None``&#12290;"

#: ../../tutorial/controlflow.rst:516
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)`` &#35821;&#21477;&#35843;&#29992;&#20102;&#21015;&#34920;&#23545;&#35937; ``result`` &#30340; *&#26041;&#27861;* &#12290;&#26041;&#27861;&#26159;&ldquo;&#20174;&#23646;&#20110;&rdquo;&#23545;&#35937;&#30340;&#20989;&#25968;&#65292;&#21629;&#21517;&#20026; "
"``obj.methodname``&#65292;``obj`` &#26159;&#23545;&#35937;&#65288;&#20063;&#21487;&#20197;&#26159;&#34920;&#36798;&#24335;&#65289;&#65292;``methodname`` "
"&#26159;&#23545;&#35937;&#31867;&#22411;&#23450;&#20041;&#30340;&#26041;&#27861;&#21517;&#12290;&#19981;&#21516;&#31867;&#22411;&#23450;&#20041;&#19981;&#21516;&#30340;&#26041;&#27861;&#65292;&#19981;&#21516;&#31867;&#22411;&#30340;&#26041;&#27861;&#21517;&#21487;&#20197;&#30456;&#21516;&#65292;&#19988;&#19981;&#20250;&#24341;&#36215;&#27495;&#20041;&#12290;&#65288;&#29992; *&#31867;* &#21487;&#20197;&#33258;&#23450;&#20041;&#23545;&#35937;&#31867;&#22411;&#21644;&#26041;&#27861;&#65292;&#35814;&#35265; "
":ref:`tut-classes` &#65289;&#31034;&#20363;&#20013;&#30340;&#26041;&#27861; :meth:`append` &#26159;&#20026;&#21015;&#34920;&#23545;&#35937;&#23450;&#20041;&#30340;&#65292;&#29992;&#20110;&#22312;&#21015;&#34920;&#26411;&#23614;&#28155;&#21152;&#26032;&#20803;&#32032;&#12290;&#26412;&#20363;&#20013;&#65292;&#35813;&#26041;&#27861;&#30456;&#24403;&#20110; "
"``result = result + [a]`` &#65292;&#20294;&#26356;&#26377;&#25928;&#12290;"

#: ../../tutorial/controlflow.rst:531
msgid "More on Defining Functions"
msgstr "&#20989;&#25968;&#23450;&#20041;&#35814;&#35299;"

#: ../../tutorial/controlflow.rst:533
msgid ""
"It is also possible to define functions with a variable number of arguments."
" There are three forms, which can be combined."
msgstr "&#20989;&#25968;&#23450;&#20041;&#25903;&#25345;&#21487;&#21464;&#25968;&#37327;&#30340;&#21442;&#25968;&#12290;&#36825;&#37324;&#21015;&#20986;&#19977;&#31181;&#21487;&#20197;&#32452;&#21512;&#20351;&#29992;&#30340;&#24418;&#24335;&#12290;"

#: ../../tutorial/controlflow.rst:540
msgid "Default Argument Values"
msgstr "&#40664;&#35748;&#20540;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:542
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 "&#20026;&#21442;&#25968;&#25351;&#23450;&#40664;&#35748;&#20540;&#26159;&#38750;&#24120;&#26377;&#29992;&#30340;&#26041;&#24335;&#12290;&#35843;&#29992;&#20989;&#25968;&#26102;&#65292;&#21487;&#20197;&#20351;&#29992;&#27604;&#23450;&#20041;&#26102;&#26356;&#23569;&#30340;&#21442;&#25968;&#65292;&#20363;&#22914;&#65306;"

#: ../../tutorial/controlflow.rst:558
msgid "This function can be called in several ways:"
msgstr "&#35813;&#20989;&#25968;&#21487;&#20197;&#29992;&#20197;&#19979;&#26041;&#24335;&#35843;&#29992;&#65306;"

#: ../../tutorial/controlflow.rst:560
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to "
"quit?')``"
msgstr "&#21482;&#32473;&#20986;&#24517;&#36873;&#23454;&#21442;&#65306;``ask_ok('Do you really want to quit?')``"

#: ../../tutorial/controlflow.rst:562
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr "&#32473;&#20986;&#19968;&#20010;&#21487;&#36873;&#23454;&#21442;&#65306;``ask_ok('OK to overwrite the file?', 2)``"

#: ../../tutorial/controlflow.rst:564
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come"
" on, only yes or no!')``"
msgstr ""
"&#32473;&#20986;&#25152;&#26377;&#23454;&#21442;&#65306;``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or "
"no!')``"

#: ../../tutorial/controlflow.rst:567
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr "&#26412;&#20363;&#36824;&#20351;&#29992;&#20102;&#20851;&#38190;&#23383; :keyword:`in` &#65292;&#29992;&#20110;&#30830;&#35748;&#24207;&#21015;&#20013;&#26159;&#21542;&#21253;&#21547;&#26576;&#20010;&#20540;&#12290;"

#: ../../tutorial/controlflow.rst:570
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr "&#40664;&#35748;&#20540;&#22312; *&#23450;&#20041;* &#20316;&#29992;&#22495;&#37324;&#30340;&#20989;&#25968;&#23450;&#20041;&#20013;&#27714;&#20540;&#65292;&#25152;&#20197;&#65306;"

#: ../../tutorial/controlflow.rst:581
msgid "will print ``5``."
msgstr "&#19978;&#20363;&#36755;&#20986;&#30340;&#26159; ``5``&#12290;"

#: ../../tutorial/controlflow.rst:583
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 ""
"**&#37325;&#35201;&#35686;&#21578;&#65306;** &#40664;&#35748;&#20540;&#21482;&#35745;&#31639;&#19968;&#27425;&#12290;&#40664;&#35748;&#20540;&#20026;&#21015;&#34920;&#12289;&#23383;&#20856;&#25110;&#31867;&#23454;&#20363;&#31561;&#21487;&#21464;&#23545;&#35937;&#26102;&#65292;&#20250;&#20135;&#29983;&#19982;&#35813;&#35268;&#21017;&#19981;&#21516;&#30340;&#32467;&#26524;&#12290;&#20363;&#22914;&#65292;&#19979;&#38754;&#30340;&#20989;&#25968;&#20250;&#32047;&#31215;&#21518;&#32493;&#35843;&#29992;&#26102;&#20256;&#36882;&#30340;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:596
msgid "This will print ::"
msgstr "&#36755;&#20986;&#32467;&#26524;&#22914;&#19979;&#65306;"

#: ../../tutorial/controlflow.rst:602
msgid ""
"If you don't want the default to be shared between subsequent calls, you can"
" write the function like this instead::"
msgstr "&#19981;&#24819;&#22312;&#21518;&#32493;&#35843;&#29992;&#20043;&#38388;&#20849;&#20139;&#40664;&#35748;&#20540;&#26102;&#65292;&#24212;&#20197;&#22914;&#19979;&#26041;&#24335;&#32534;&#20889;&#20989;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:615
msgid "Keyword Arguments"
msgstr "&#20851;&#38190;&#23383;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:617
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`` &#24418;&#24335;&#30340; :term:`&#20851;&#38190;&#23383;&#21442;&#25968; <keyword argument>` &#20063;&#21487;&#20197;&#29992;&#20110;&#35843;&#29992;&#20989;&#25968;&#12290;&#20989;&#25968;&#31034;&#20363;&#22914;&#19979;&#65306;"

#: ../../tutorial/controlflow.rst:626
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 ""
"&#35813;&#20989;&#25968;&#25509;&#21463;&#19968;&#20010;&#24517;&#36873;&#21442;&#25968;&#65288;``voltage``&#65289;&#21644;&#19977;&#20010;&#21487;&#36873;&#21442;&#25968;&#65288;``state``, ``action`` &#21644; "
"``type``&#65289;&#12290;&#35813;&#20989;&#25968;&#21487;&#29992;&#19979;&#21015;&#26041;&#24335;&#35843;&#29992;&#65306;"

#: ../../tutorial/controlflow.rst:637
msgid "but all the following calls would be invalid::"
msgstr "&#20197;&#19979;&#35843;&#29992;&#20989;&#25968;&#30340;&#26041;&#24335;&#37117;&#26080;&#25928;&#65306;"

#: ../../tutorial/controlflow.rst:644
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 ""
"&#20989;&#25968;&#35843;&#29992;&#26102;&#65292;&#20851;&#38190;&#23383;&#21442;&#25968;&#24517;&#39035;&#36319;&#22312;&#20301;&#32622;&#21442;&#25968;&#21518;&#38754;&#12290;&#25152;&#26377;&#20256;&#36882;&#30340;&#20851;&#38190;&#23383;&#21442;&#25968;&#37117;&#24517;&#39035;&#21305;&#37197;&#19968;&#20010;&#20989;&#25968;&#25509;&#21463;&#30340;&#21442;&#25968;&#65288;&#27604;&#22914;&#65292;``actor`` &#19981;&#26159;&#20989;&#25968; ``parrot`` "
"&#30340;&#26377;&#25928;&#21442;&#25968;&#65289;&#65292;&#20851;&#38190;&#23383;&#21442;&#25968;&#30340;&#39034;&#24207;&#24182;&#19981;&#37325;&#35201;&#12290;&#36825;&#20063;&#21253;&#25324;&#24517;&#36873;&#21442;&#25968;&#65292;&#65288;&#27604;&#22914;&#65292;``parrot(voltage=1000)`` "
"&#20063;&#26377;&#25928;&#65289;&#12290;&#19981;&#33021;&#23545;&#21516;&#19968;&#20010;&#21442;&#25968;&#22810;&#27425;&#36171;&#20540;&#65292;&#19979;&#38754;&#23601;&#26159;&#19968;&#20010;&#22240;&#27492;&#38480;&#21046;&#32780;&#22833;&#36133;&#30340;&#20363;&#23376;&#65306;"

#: ../../tutorial/controlflow.rst:660
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 ""
"&#26368;&#21518;&#19968;&#20010;&#24418;&#21442;&#20026; ``**name``  &#24418;&#24335;&#26102;&#65292;&#25509;&#25910;&#19968;&#20010;&#23383;&#20856;&#65288;&#35814;&#35265; "
":ref:`typesmapping`&#65289;&#65292;&#35813;&#23383;&#20856;&#21253;&#21547;&#19982;&#20989;&#25968;&#20013;&#24050;&#23450;&#20041;&#24418;&#21442;&#23545;&#24212;&#20043;&#22806;&#30340;&#25152;&#26377;&#20851;&#38190;&#23383;&#21442;&#25968;&#12290;``**name`` &#24418;&#21442;&#21487;&#20197;&#19982; ``*name`` "
"&#24418;&#21442;&#65288;&#19979;&#19968;&#23567;&#33410;&#20171;&#32461;&#65289;&#32452;&#21512;&#20351;&#29992;&#65288;``*name`` &#24517;&#39035;&#22312; ``**name`` &#21069;&#38754;&#65289;&#65292; ``*name`` &#24418;&#21442;&#25509;&#25910;&#19968;&#20010; :ref:`&#20803;&#32452; <tut-"
"tuples>`&#65292;&#35813;&#20803;&#32452;&#21253;&#21547;&#24418;&#21442;&#21015;&#34920;&#20043;&#22806;&#30340;&#20301;&#32622;&#21442;&#25968;&#12290;&#20363;&#22914;&#65292;&#21487;&#20197;&#23450;&#20041;&#19979;&#38754;&#36825;&#26679;&#30340;&#20989;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:677
msgid "It could be called like this::"
msgstr "&#35813;&#20989;&#25968;&#21487;&#20197;&#29992;&#22914;&#19979;&#26041;&#24335;&#35843;&#29992;&#65306;"

#: ../../tutorial/controlflow.rst:685
msgid "and of course it would print:"
msgstr "&#36755;&#20986;&#32467;&#26524;&#22914;&#19979;&#65306;"

#: ../../tutorial/controlflow.rst:698
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 "&#27880;&#24847;&#65292;&#20851;&#38190;&#23383;&#21442;&#25968;&#22312;&#36755;&#20986;&#32467;&#26524;&#20013;&#30340;&#39034;&#24207;&#19982;&#35843;&#29992;&#20989;&#25968;&#26102;&#30340;&#39034;&#24207;&#19968;&#33268;&#12290;"

#: ../../tutorial/controlflow.rst:702
msgid "Special parameters"
msgstr "&#29305;&#27530;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:704
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 ""
"&#40664;&#35748;&#24773;&#20917;&#19979;&#65292;&#21442;&#25968;&#21487;&#20197;&#25353;&#20301;&#32622;&#25110;&#26174;&#24335;&#20851;&#38190;&#23383;&#20256;&#36882;&#32473; Python "
"&#20989;&#25968;&#12290;&#20026;&#20102;&#35753;&#20195;&#30721;&#26131;&#35835;&#12289;&#39640;&#25928;&#65292;&#26368;&#22909;&#38480;&#21046;&#21442;&#25968;&#30340;&#20256;&#36882;&#26041;&#24335;&#65292;&#36825;&#26679;&#65292;&#24320;&#21457;&#32773;&#21482;&#38656;&#26597;&#30475;&#20989;&#25968;&#23450;&#20041;&#65292;&#21363;&#21487;&#30830;&#23450;&#21442;&#25968;&#39033;&#26159;&#20165;&#25353;&#20301;&#32622;&#12289;&#25353;&#20301;&#32622;&#25110;&#20851;&#38190;&#23383;&#65292;&#36824;&#26159;&#20165;&#25353;&#20851;&#38190;&#23383;&#20256;&#36882;&#12290;"

#: ../../tutorial/controlflow.rst:710
msgid "A function definition may look like:"
msgstr "&#20989;&#25968;&#23450;&#20041;&#22914;&#19979;&#65306;"

#: ../../tutorial/controlflow.rst:721
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 "``/`` &#21644; ``*`` &#26159;&#21487;&#36873;&#30340;&#12290;&#36825;&#20123;&#31526;&#21495;&#34920;&#26126;&#24418;&#21442;&#22914;&#20309;&#25226;&#21442;&#25968;&#20540;&#20256;&#36882;&#32473;&#20989;&#25968;&#65306;&#20301;&#32622;&#12289;&#20301;&#32622;&#25110;&#20851;&#38190;&#23383;&#12289;&#20851;&#38190;&#23383;&#12290;&#20851;&#38190;&#23383;&#24418;&#21442;&#20063;&#21483;&#20316;&#21629;&#21517;&#24418;&#21442;&#12290;"

#: ../../tutorial/controlflow.rst:728
msgid "Positional-or-Keyword Arguments"
msgstr "&#20301;&#32622;&#25110;&#20851;&#38190;&#23383;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:730
msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments may"
" be passed to a function by position or by keyword."
msgstr "&#20989;&#25968;&#23450;&#20041;&#20013;&#26410;&#20351;&#29992; ``/`` &#21644; ``*`` &#26102;&#65292;&#21442;&#25968;&#21487;&#20197;&#25353;&#20301;&#32622;&#25110;&#20851;&#38190;&#23383;&#20256;&#36882;&#32473;&#20989;&#25968;&#12290;"

#: ../../tutorial/controlflow.rst:735
msgid "Positional-Only Parameters"
msgstr "&#20165;&#20301;&#32622;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:737
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 ""
"&#27492;&#22788;&#20877;&#20171;&#32461;&#19968;&#20123;&#32454;&#33410;&#65292;&#29305;&#23450;&#24418;&#21442;&#21487;&#20197;&#26631;&#35760;&#20026; *&#20165;&#38480;&#20301;&#32622;*&#12290;*&#20165;&#38480;&#20301;&#32622;* &#26102;&#65292;&#24418;&#21442;&#30340;&#39034;&#24207;&#24456;&#37325;&#35201;&#65292;&#19988;&#36825;&#20123;&#24418;&#21442;&#19981;&#33021;&#29992;&#20851;&#38190;&#23383;&#20256;&#36882;&#12290;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#24212;&#25918;&#22312; ``/``  "
"&#65288;&#27491;&#26012;&#26464;&#65289;&#21069;&#12290;``/`` &#29992;&#20110;&#22312;&#36923;&#36753;&#19978;&#20998;&#21106;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#19982;&#20854;&#23427;&#24418;&#21442;&#12290;&#22914;&#26524;&#20989;&#25968;&#23450;&#20041;&#20013;&#27809;&#26377; ``/``&#65292;&#21017;&#34920;&#31034;&#27809;&#26377;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#12290;"

#: ../../tutorial/controlflow.rst:745
msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"
"only*."
msgstr "``/`` &#21518;&#21487;&#20197;&#26159; *&#20301;&#32622;&#25110;&#20851;&#38190;&#23383;* &#25110; *&#20165;&#38480;&#20851;&#38190;&#23383;* &#24418;&#21442;&#12290;"

#: ../../tutorial/controlflow.rst:749
msgid "Keyword-Only Arguments"
msgstr "&#20165;&#38480;&#20851;&#38190;&#23383;&#21442;&#25968;"

#: ../../tutorial/controlflow.rst:751
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 "&#25226;&#24418;&#21442;&#26631;&#35760;&#20026; *&#20165;&#38480;&#20851;&#38190;&#23383;*&#65292;&#34920;&#26126;&#24517;&#39035;&#20197;&#20851;&#38190;&#23383;&#21442;&#25968;&#24418;&#24335;&#20256;&#36882;&#35813;&#24418;&#21442;&#65292;&#24212;&#22312;&#21442;&#25968;&#21015;&#34920;&#20013;&#31532;&#19968;&#20010; *&#20165;&#38480;&#20851;&#38190;&#23383;* &#24418;&#21442;&#21069;&#28155;&#21152; ``*``&#12290;"

#: ../../tutorial/controlflow.rst:757
msgid "Function Examples"
msgstr "&#20989;&#25968;&#31034;&#20363;"

#: ../../tutorial/controlflow.rst:759
msgid ""
"Consider the following example function definitions paying close attention "
"to the markers ``/`` and ``*``::"
msgstr "&#35831;&#30475;&#19979;&#38754;&#30340;&#20989;&#25968;&#23450;&#20041;&#31034;&#20363;&#65292;&#27880;&#24847; ``/`` &#21644; ``*`` &#26631;&#35760;&#65306;"

#: ../../tutorial/controlflow.rst:775
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 "&#31532;&#19968;&#20010;&#20989;&#25968;&#23450;&#20041; ``standard_arg`` &#26159;&#26368;&#24120;&#35265;&#30340;&#24418;&#24335;&#65292;&#23545;&#35843;&#29992;&#26041;&#24335;&#27809;&#26377;&#20219;&#20309;&#38480;&#21046;&#65292;&#21487;&#20197;&#25353;&#20301;&#32622;&#20063;&#21487;&#20197;&#25353;&#20851;&#38190;&#23383;&#20256;&#36882;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:785
msgid ""
"The second function ``pos_only_arg`` is restricted to only use positional "
"parameters as there is a ``/`` in the function definition::"
msgstr "&#31532;&#20108;&#20010;&#20989;&#25968; ``pos_only_arg`` &#30340;&#20989;&#25968;&#23450;&#20041;&#20013;&#26377; ``/``&#65292;&#20165;&#38480;&#20351;&#29992;&#20301;&#32622;&#24418;&#21442;&#65306;"

#: ../../tutorial/controlflow.rst:796
msgid ""
"The third function ``kwd_only_args`` only allows keyword arguments as "
"indicated by a ``*`` in the function definition::"
msgstr "&#31532;&#19977;&#20010;&#20989;&#25968; ``kwd_only_args`` &#30340;&#20989;&#25968;&#23450;&#20041;&#36890;&#36807; ``*`` &#34920;&#26126;&#20165;&#38480;&#20851;&#38190;&#23383;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:807
msgid ""
"And the last uses all three calling conventions in the same function "
"definition::"
msgstr "&#26368;&#21518;&#19968;&#20010;&#20989;&#25968;&#22312;&#21516;&#19968;&#20010;&#20989;&#25968;&#23450;&#20041;&#20013;&#65292;&#20351;&#29992;&#20102;&#20840;&#37096;&#19977;&#31181;&#35843;&#29992;&#24815;&#20363;&#65306;"

#: ../../tutorial/controlflow.rst:827
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 "&#19979;&#38754;&#30340;&#20989;&#25968;&#23450;&#20041;&#20013;&#65292;``kwds`` &#25226; ``name`` &#24403;&#20316;&#38190;&#65292;&#22240;&#27492;&#65292;&#21487;&#33021;&#19982;&#20301;&#32622;&#21442;&#25968; ``name`` &#20135;&#29983;&#28508;&#22312;&#20914;&#31361;&#65306;"

#: ../../tutorial/controlflow.rst:832
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 "&#35843;&#29992;&#35813;&#20989;&#25968;&#19981;&#21487;&#33021;&#36820;&#22238; ``True``&#65292;&#22240;&#20026;&#20851;&#38190;&#23383; ``'name'`` &#24635;&#19982;&#31532;&#19968;&#20010;&#24418;&#21442;&#32465;&#23450;&#12290;&#20363;&#22914;&#65306;"

#: ../../tutorial/controlflow.rst:841
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 ""
"&#21152;&#19978; ``/`` &#65288;&#20165;&#38480;&#20301;&#32622;&#21442;&#25968;&#65289;&#21518;&#65292;&#23601;&#21487;&#20197;&#20102;&#12290;&#27492;&#26102;&#65292;&#20989;&#25968;&#23450;&#20041;&#25226; ``name`` &#24403;&#20316;&#20301;&#32622;&#21442;&#25968;&#65292;``'name'`` &#20063;&#21487;&#20197;&#20316;&#20026;&#20851;&#38190;&#23383;&#21442;&#25968;&#30340;&#38190;&#65306;"

#: ../../tutorial/controlflow.rst:848
msgid ""
"In other words, the names of positional-only parameters can be used in "
"``**kwds`` without ambiguity."
msgstr "&#25442;&#21477;&#35805;&#35828;&#65292;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#30340;&#21517;&#31216;&#21487;&#20197;&#22312; ``**kwds`` &#20013;&#20351;&#29992;&#65292;&#32780;&#19981;&#20135;&#29983;&#27495;&#20041;&#12290;"

#: ../../tutorial/controlflow.rst:853
msgid "Recap"
msgstr "&#23567;&#32467;"

#: ../../tutorial/controlflow.rst:855
msgid ""
"The use case will determine which parameters to use in the function "
"definition::"
msgstr "&#20197;&#19979;&#29992;&#20363;&#20915;&#23450;&#21738;&#20123;&#24418;&#21442;&#21487;&#20197;&#29992;&#20110;&#20989;&#25968;&#23450;&#20041;&#65306;"

#: ../../tutorial/controlflow.rst:859
msgid "As guidance:"
msgstr "&#35828;&#26126;&#65306;"

#: ../../tutorial/controlflow.rst:861
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 "&#20351;&#29992;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#65292;&#21487;&#20197;&#35753;&#29992;&#25143;&#26080;&#27861;&#20351;&#29992;&#24418;&#21442;&#21517;&#12290;&#24418;&#21442;&#21517;&#27809;&#26377;&#23454;&#38469;&#24847;&#20041;&#26102;&#65292;&#24378;&#21046;&#35843;&#29992;&#20989;&#25968;&#30340;&#23454;&#21442;&#39034;&#24207;&#26102;&#65292;&#25110;&#21516;&#26102;&#25509;&#25910;&#20301;&#32622;&#24418;&#21442;&#21644;&#20851;&#38190;&#23383;&#26102;&#65292;&#36825;&#31181;&#26041;&#24335;&#24456;&#26377;&#29992;&#12290;"

#: ../../tutorial/controlflow.rst:866
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 "&#24403;&#24418;&#21442;&#21517;&#26377;&#23454;&#38469;&#24847;&#20041;&#65292;&#19988;&#26174;&#24335;&#21517;&#31216;&#21487;&#20197;&#35753;&#20989;&#25968;&#23450;&#20041;&#26356;&#26131;&#29702;&#35299;&#26102;&#65292;&#38459;&#27490;&#29992;&#25143;&#20381;&#36182;&#20256;&#36882;&#23454;&#21442;&#30340;&#20301;&#32622;&#26102;&#65292;&#25165;&#20351;&#29992;&#20851;&#38190;&#23383;&#12290;"

#: ../../tutorial/controlflow.rst:869
msgid ""
"For an API, use positional-only to prevent breaking API changes if the "
"parameter's name is modified in the future."
msgstr "&#23545;&#20110; API&#65292;&#20351;&#29992;&#20165;&#38480;&#20301;&#32622;&#24418;&#21442;&#65292;&#21487;&#20197;&#38450;&#27490;&#26410;&#26469;&#20462;&#25913;&#24418;&#21442;&#21517;&#26102;&#36896;&#25104;&#30772;&#22351;&#24615;&#30340; API &#21464;&#21160;&#12290;"

#: ../../tutorial/controlflow.rst:875
msgid "Arbitrary Argument Lists"
msgstr "&#20219;&#24847;&#23454;&#21442;&#21015;&#34920;"

#: ../../tutorial/controlflow.rst:880
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 ""
"&#35843;&#29992;&#20989;&#25968;&#26102;&#65292;&#20351;&#29992;&#20219;&#24847;&#25968;&#37327;&#30340;&#23454;&#21442;&#26159;&#26368;&#23569;&#35265;&#30340;&#36873;&#39033;&#12290;&#36825;&#20123;&#23454;&#21442;&#21253;&#21547;&#22312;&#20803;&#32452;&#20013;&#65288;&#35814;&#35265; :ref:`tut-tuples` "
"&#65289;&#12290;&#22312;&#21487;&#21464;&#25968;&#37327;&#30340;&#23454;&#21442;&#20043;&#21069;&#65292;&#21487;&#33021;&#26377;&#33509;&#24178;&#20010;&#26222;&#36890;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:889
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* &#21442;&#25968;&#29992;&#20110;&#37319;&#38598;&#20256;&#36882;&#32473;&#20989;&#25968;&#30340;&#25152;&#26377;&#21097;&#20313;&#21442;&#25968;&#65292;&#22240;&#27492;&#65292;&#23427;&#20204;&#36890;&#24120;&#22312;&#24418;&#21442;&#21015;&#34920;&#30340;&#26411;&#23614;&#12290;``*args`` "
"&#24418;&#21442;&#21518;&#30340;&#20219;&#20309;&#24418;&#24335;&#21442;&#25968;&#21482;&#33021;&#26159;&#20165;&#38480;&#20851;&#38190;&#23383;&#21442;&#25968;&#65292;&#21363;&#21482;&#33021;&#29992;&#20316;&#20851;&#38190;&#23383;&#21442;&#25968;&#65292;&#19981;&#33021;&#29992;&#20316;&#20301;&#32622;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:906
msgid "Unpacking Argument Lists"
msgstr "&#35299;&#21253;&#23454;&#21442;&#21015;&#34920;"

#: ../../tutorial/controlflow.rst:908
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 ""
"&#20989;&#25968;&#35843;&#29992;&#35201;&#27714;&#29420;&#31435;&#30340;&#20301;&#32622;&#21442;&#25968;&#65292;&#20294;&#23454;&#21442;&#22312;&#21015;&#34920;&#25110;&#20803;&#32452;&#37324;&#26102;&#65292;&#35201;&#25191;&#34892;&#30456;&#21453;&#30340;&#25805;&#20316;&#12290;&#20363;&#22914;&#65292;&#20869;&#32622;&#30340; :func:`range` &#20989;&#25968;&#35201;&#27714;&#29420;&#31435;&#30340; *start* &#21644; "
"*stop* &#23454;&#21442;&#12290;&#22914;&#26524;&#36825;&#20123;&#21442;&#25968;&#19981;&#26159;&#29420;&#31435;&#30340;&#65292;&#21017;&#35201;&#22312;&#35843;&#29992;&#20989;&#25968;&#26102;&#65292;&#29992; ``*`` &#25805;&#20316;&#31526;&#25226;&#23454;&#21442;&#20174;&#21015;&#34920;&#25110;&#20803;&#32452;&#35299;&#21253;&#20986;&#26469;&#65306;"

#: ../../tutorial/controlflow.rst:924
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr "&#21516;&#26679;&#65292;&#23383;&#20856;&#21487;&#20197;&#29992; ``**`` &#25805;&#20316;&#31526;&#20256;&#36882;&#20851;&#38190;&#23383;&#21442;&#25968;&#65306;"

#: ../../tutorial/controlflow.rst:940
msgid "Lambda Expressions"
msgstr "Lambda &#34920;&#36798;&#24335;"

#: ../../tutorial/controlflow.rst:942
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` &#20851;&#38190;&#23383;&#29992;&#20110;&#21019;&#24314;&#23567;&#24039;&#30340;&#21311;&#21517;&#20989;&#25968;&#12290;``lambda a, b: a+b`` &#20989;&#25968;&#36820;&#22238;&#20004;&#20010;&#21442;&#25968;&#30340;&#21644;&#12290;Lambda "
"&#20989;&#25968;&#21487;&#29992;&#20110;&#20219;&#20309;&#38656;&#35201;&#20989;&#25968;&#23545;&#35937;&#30340;&#22320;&#26041;&#12290;&#22312;&#35821;&#27861;&#19978;&#65292;&#21311;&#21517;&#20989;&#25968;&#21482;&#33021;&#26159;&#21333;&#20010;&#34920;&#36798;&#24335;&#12290;&#22312;&#35821;&#20041;&#19978;&#65292;&#23427;&#21482;&#26159;&#24120;&#35268;&#20989;&#25968;&#23450;&#20041;&#30340;&#35821;&#27861;&#31958;&#12290;&#19982;&#23884;&#22871;&#20989;&#25968;&#23450;&#20041;&#19968;&#26679;&#65292;lambda "
"&#20989;&#25968;&#21487;&#20197;&#24341;&#29992;&#21253;&#21547;&#20316;&#29992;&#22495;&#20013;&#30340;&#21464;&#37327;&#65306;"

#: ../../tutorial/controlflow.rst:959
msgid ""
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
msgstr "&#19978;&#20363;&#29992; lambda &#34920;&#36798;&#24335;&#36820;&#22238;&#20989;&#25968;&#12290;&#36824;&#21487;&#20197;&#25226;&#21311;&#21517;&#20989;&#25968;&#29992;&#20316;&#20256;&#36882;&#30340;&#23454;&#21442;&#65306;"

#: ../../tutorial/controlflow.rst:971
msgid "Documentation Strings"
msgstr "&#25991;&#26723;&#23383;&#31526;&#20018;"

#: ../../tutorial/controlflow.rst:978
msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr "&#20197;&#19979;&#26159;&#25991;&#26723;&#23383;&#31526;&#20018;&#20869;&#23481;&#21644;&#26684;&#24335;&#30340;&#32422;&#23450;&#12290;"

#: ../../tutorial/controlflow.rst:981
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 ""
"&#31532;&#19968;&#34892;&#24212;&#20026;&#23545;&#35937;&#29992;&#36884;&#30340;&#31616;&#30701;&#25688;&#35201;&#12290;&#20026;&#20445;&#25345;&#31616;&#27905;&#65292;&#19981;&#35201;&#22312;&#36825;&#37324;&#26174;&#24335;&#35828;&#26126;&#23545;&#35937;&#21517;&#25110;&#31867;&#22411;&#65292;&#22240;&#20026;&#21487;&#36890;&#36807;&#20854;&#20182;&#26041;&#24335;&#33719;&#21462;&#36825;&#20123;&#20449;&#24687;&#65288;&#38500;&#38750;&#35813;&#21517;&#31216;&#30896;&#24039;&#26159;&#25551;&#36848;&#20989;&#25968;&#25805;&#20316;&#30340;&#21160;&#35789;&#65289;&#12290;&#36825;&#19968;&#34892;&#24212;&#20197;&#22823;&#20889;&#23383;&#27597;&#24320;&#22836;&#65292;&#20197;&#21477;&#28857;&#32467;&#23614;&#12290;"

#: ../../tutorial/controlflow.rst:987
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 "&#25991;&#26723;&#23383;&#31526;&#20018;&#20026;&#22810;&#34892;&#26102;&#65292;&#31532;&#20108;&#34892;&#24212;&#20026;&#31354;&#30333;&#34892;&#65292;&#22312;&#35270;&#35273;&#19978;&#23558;&#25688;&#35201;&#19982;&#20854;&#20313;&#25551;&#36848;&#20998;&#24320;&#12290;&#21518;&#38754;&#30340;&#34892;&#21487;&#21253;&#21547;&#33509;&#24178;&#27573;&#33853;&#65292;&#25551;&#36848;&#23545;&#35937;&#30340;&#35843;&#29992;&#32422;&#23450;&#12289;&#21103;&#20316;&#29992;&#31561;&#12290;"

#: ../../tutorial/controlflow.rst:992
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 &#35299;&#26512;&#22120;&#19981;&#20250;&#21024;&#38500; Python &#20013;&#22810;&#34892;&#23383;&#31526;&#20018;&#23383;&#38754;&#20540;&#30340;&#32553;&#36827;&#65292;&#22240;&#27492;&#65292;&#25991;&#26723;&#22788;&#29702;&#24037;&#20855;&#24212;&#22312;&#24517;&#35201;&#26102;&#21024;&#38500;&#32553;&#36827;&#12290;&#36825;&#39033;&#25805;&#20316;&#36981;&#24490;&#20197;&#19979;&#32422;&#23450;&#65306;&#25991;&#26723;&#23383;&#31526;&#20018;&#31532;&#19968;&#34892; "
"*&#20043;&#21518;* "
"&#30340;&#31532;&#19968;&#20010;&#38750;&#31354;&#34892;&#20915;&#23450;&#20102;&#25972;&#20010;&#25991;&#26723;&#23383;&#31526;&#20018;&#30340;&#32553;&#36827;&#37327;&#65288;&#31532;&#19968;&#34892;&#36890;&#24120;&#19982;&#23383;&#31526;&#20018;&#24320;&#22836;&#30340;&#24341;&#21495;&#30456;&#37051;&#65292;&#20854;&#32553;&#36827;&#22312;&#23383;&#31526;&#20018;&#20013;&#24182;&#19981;&#26126;&#26174;&#65292;&#22240;&#27492;&#65292;&#19981;&#33021;&#29992;&#31532;&#19968;&#34892;&#30340;&#32553;&#36827;&#65289;&#65292;&#28982;&#21518;&#65292;&#21024;&#38500;&#23383;&#31526;&#20018;&#20013;&#25152;&#26377;&#34892;&#24320;&#22836;&#22788;&#19982;&#27492;&#32553;&#36827;&ldquo;&#31561;&#20215;&rdquo;&#30340;&#31354;&#30333;&#31526;&#12290;&#19981;&#33021;&#26377;&#27604;&#27492;&#32553;&#36827;&#26356;&#23569;&#30340;&#34892;&#65292;&#20294;&#22914;&#26524;&#20986;&#29616;&#20102;&#32553;&#36827;&#26356;&#23569;&#30340;&#34892;&#65292;&#24212;&#21024;&#38500;&#36825;&#20123;&#34892;&#30340;&#25152;&#26377;&#21069;&#23548;&#31354;&#30333;&#31526;&#12290;&#36716;&#21270;&#21046;&#34920;&#31526;&#21518;&#65288;&#36890;&#24120;&#20026;"
" 8 &#20010;&#31354;&#26684;&#65289;&#65292;&#24212;&#27979;&#35797;&#31354;&#30333;&#31526;&#30340;&#31561;&#25928;&#24615;&#12290;"

#: ../../tutorial/controlflow.rst:1004
msgid "Here is an example of a multi-line docstring::"
msgstr "&#19979;&#38754;&#26159;&#22810;&#34892;&#25991;&#26723;&#23383;&#31526;&#20018;&#30340;&#19968;&#20010;&#20363;&#23376;&#65306;"

#: ../../tutorial/controlflow.rst:1022
msgid "Function Annotations"
msgstr "&#20989;&#25968;&#27880;&#35299;"

#: ../../tutorial/controlflow.rst:1030
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:`&#20989;&#25968;&#27880;&#35299; <function>` &#26159;&#21487;&#36873;&#30340;&#29992;&#25143;&#33258;&#23450;&#20041;&#20989;&#25968;&#31867;&#22411;&#30340;&#20803;&#25968;&#25454;&#23436;&#25972;&#20449;&#24687;&#65288;&#35814;&#35265; :pep:`3107` &#21644; :pep:`484` &#65289;&#12290;"

#: ../../tutorial/controlflow.rst:1034
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:`&#26631;&#27880; <function annotation>` &#20197;&#23383;&#20856;&#30340;&#24418;&#24335;&#23384;&#25918;&#22312;&#20989;&#25968;&#30340; :attr:`__annotations__` "
"&#23646;&#24615;&#20013;&#65292;&#24182;&#19988;&#19981;&#20250;&#24433;&#21709;&#20989;&#25968;&#30340;&#20219;&#20309;&#20854;&#20182;&#37096;&#20998;&#12290; &#24418;&#21442;&#26631;&#27880;&#30340;&#23450;&#20041;&#26041;&#24335;&#26159;&#22312;&#24418;&#21442;&#21517;&#21518;&#21152;&#20882;&#21495;&#65292;&#21518;&#38754;&#36319;&#19968;&#20010;&#34920;&#36798;&#24335;&#65292;&#35813;&#34920;&#36798;&#24335;&#20250;&#34987;&#27714;&#20540;&#20026;&#26631;&#27880;&#30340;&#20540;&#12290; "
"&#36820;&#22238;&#20540;&#26631;&#27880;&#30340;&#23450;&#20041;&#26041;&#24335;&#26159;&#21152;&#32452;&#21512;&#31526;&#21495; ``->``&#65292;&#21518;&#38754;&#36319;&#19968;&#20010;&#34920;&#36798;&#24335;&#65292;&#35813;&#26631;&#27880;&#20301;&#20110;&#24418;&#21442;&#21015;&#34920;&#21644;&#34920;&#31034; :keyword:`def` &#35821;&#21477;&#32467;&#26463;&#30340;&#20882;&#21495;&#20043;&#38388;&#12290;  "
"&#19979;&#38754;&#30340;&#31034;&#20363;&#26377;&#19968;&#20010;&#24517;&#39035;&#30340;&#21442;&#25968;&#65292;&#19968;&#20010;&#21487;&#36873;&#30340;&#20851;&#38190;&#23383;&#21442;&#25968;&#20197;&#21450;&#36820;&#22238;&#20540;&#37117;&#24102;&#26377;&#30456;&#24212;&#30340;&#26631;&#27880;::"

#: ../../tutorial/controlflow.rst:1056
msgid "Intermezzo: Coding Style"
msgstr "&#23567;&#25554;&#26354;&#65306;&#32534;&#30721;&#39118;&#26684;"

#: ../../tutorial/controlflow.rst:1061
msgid ""
"Now that you are about to write longer, more complex pieces of Python, it is"
" a good time to talk about *coding style*.  Most languages can be written "
"(or more concise, *formatted*) in different styles; some are more readable "
"than others. Making it easy for others to read your code is always a good "
"idea, and adopting a nice coding style helps tremendously for that."
msgstr ""
"&#29616;&#22312;&#20320;&#23558;&#35201;&#20889;&#26356;&#38271;&#65292;&#26356;&#22797;&#26434;&#30340; Python &#20195;&#30721;&#65292;&#26159;&#26102;&#20505;&#35752;&#35770;&#19968;&#19979; *&#20195;&#30721;&#39118;&#26684;* &#20102;&#12290; "
"&#22823;&#22810;&#25968;&#35821;&#35328;&#37117;&#33021;&#20197;&#19981;&#21516;&#30340;&#39118;&#26684;&#34987;&#32534;&#20889;&#65288;&#25110;&#26356;&#20934;&#30830;&#22320;&#35828;&#65292;&#34987;&#26684;&#24335;&#21270;&#65289;&#65307;&#26377;&#20123;&#27604;&#20854;&#20182;&#30340;&#26356;&#20855;&#26377;&#21487;&#35835;&#24615;&#12290; "
"&#33021;&#35753;&#20854;&#20182;&#20154;&#36731;&#26494;&#38405;&#35835;&#20320;&#30340;&#20195;&#30721;&#24635;&#26159;&#19968;&#20010;&#22909;&#20027;&#24847;&#65292;&#37319;&#29992;&#19968;&#31181;&#22909;&#30340;&#32534;&#30721;&#39118;&#26684;&#23545;&#27492;&#26377;&#24456;&#22823;&#24110;&#21161;&#12290;"

#: ../../tutorial/controlflow.rst:1067
msgid ""
"For Python, :pep:`8` has emerged as the style guide that most projects "
"adhere to; it promotes a very readable and eye-pleasing coding style.  Every"
" Python developer should read it at some point; here are the most important "
"points extracted for you:"
msgstr ""
"Python &#39033;&#30446;&#22823;&#22810;&#37117;&#36981;&#24490; :pep:`8` &#30340;&#39118;&#26684;&#25351;&#21335;&#65307;&#23427;&#25512;&#34892;&#30340;&#32534;&#30721;&#39118;&#26684;&#26131;&#20110;&#38405;&#35835;&#12289;&#36175;&#24515;&#24742;&#30446;&#12290;Python "
"&#24320;&#21457;&#32773;&#22343;&#24212;&#25277;&#26102;&#38388;&#24713;&#24515;&#30740;&#35835;&#65307;&#20197;&#19979;&#26159;&#35813;&#25552;&#26696;&#20013;&#30340;&#26680;&#24515;&#35201;&#28857;&#65306;"

#: ../../tutorial/controlflow.rst:1072
msgid "Use 4-space indentation, and no tabs."
msgstr "&#32553;&#36827;&#65292;&#29992; 4 &#20010;&#31354;&#26684;&#65292;&#19981;&#35201;&#29992;&#21046;&#34920;&#31526;&#12290;"

#: ../../tutorial/controlflow.rst:1074
msgid ""
"4 spaces are a good compromise between small indentation (allows greater "
"nesting depth) and large indentation (easier to read).  Tabs introduce "
"confusion, and are best left out."
msgstr "4 &#20010;&#31354;&#26684;&#26159;&#23567;&#32553;&#36827;&#65288;&#26356;&#28145;&#23884;&#22871;&#65289;&#21644;&#22823;&#32553;&#36827;&#65288;&#26356;&#26131;&#38405;&#35835;&#65289;&#20043;&#38388;&#30340;&#25240;&#20013;&#26041;&#26696;&#12290;&#21046;&#34920;&#31526;&#20250;&#24341;&#36215;&#28151;&#20081;&#65292;&#26368;&#22909;&#21035;&#29992;&#12290;"

#: ../../tutorial/controlflow.rst:1078
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "&#25442;&#34892;&#65292;&#19968;&#34892;&#19981;&#36229;&#36807; 79 &#20010;&#23383;&#31526;&#12290;"

#: ../../tutorial/controlflow.rst:1080
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr "&#36825;&#26679;&#25442;&#34892;&#30340;&#23567;&#23631;&#38405;&#35835;&#20307;&#39564;&#26356;&#22909;&#65292;&#36824;&#20415;&#20110;&#22312;&#22823;&#23631;&#26174;&#31034;&#22120;&#19978;&#24182;&#25490;&#38405;&#35835;&#22810;&#20010;&#20195;&#30721;&#25991;&#20214;&#12290;"

#: ../../tutorial/controlflow.rst:1083
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code"
" inside functions."
msgstr "&#29992;&#31354;&#34892;&#20998;&#38548;&#20989;&#25968;&#21644;&#31867;&#65292;&#21450;&#20989;&#25968;&#20869;&#36739;&#22823;&#30340;&#20195;&#30721;&#22359;&#12290;"

#: ../../tutorial/controlflow.rst:1086
msgid "When possible, put comments on a line of their own."
msgstr "&#26368;&#22909;&#25226;&#27880;&#37322;&#25918;&#21040;&#21333;&#29420;&#19968;&#34892;&#12290;"

#: ../../tutorial/controlflow.rst:1088
msgid "Use docstrings."
msgstr "&#20351;&#29992;&#25991;&#26723;&#23383;&#31526;&#20018;&#12290;"

#: ../../tutorial/controlflow.rst:1090
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr "&#36816;&#31639;&#31526;&#21069;&#21518;&#12289;&#36887;&#21495;&#21518;&#35201;&#29992;&#31354;&#26684;&#65292;&#20294;&#19981;&#35201;&#30452;&#25509;&#22312;&#25324;&#21495;&#20869;&#20351;&#29992;&#65306; ``a = f(1, 2) + g(3, 4)``&#12290;"

#: ../../tutorial/controlflow.rst:1093
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``UpperCamelCase`` for classes and ``lowercase_with_underscores`` for "
"functions and methods.  Always use ``self`` as the name for the first method"
" argument (see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
"&#31867;&#21644;&#20989;&#25968;&#30340;&#21629;&#21517;&#35201;&#19968;&#33268;&#65307;&#25353;&#24815;&#20363;&#65292;&#21629;&#21517;&#31867;&#29992; ``UpperCamelCase``&#65292;&#21629;&#21517;&#20989;&#25968;&#19982;&#26041;&#27861;&#29992; "
"``lowercase_with_underscores``&#12290;&#21629;&#21517;&#26041;&#27861;&#20013;&#31532;&#19968;&#20010;&#21442;&#25968;&#24635;&#26159;&#29992; ``self`` (&#31867;&#21644;&#26041;&#27861;&#35814;&#35265; :ref:`tut-"
"firstclasses`)&#12290;"

#: ../../tutorial/controlflow.rst:1098
msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Python's default, UTF-8, or even plain ASCII work best in any"
" case."
msgstr "&#32534;&#20889;&#29992;&#20110;&#22269;&#38469;&#22810;&#35821;&#29615;&#22659;&#30340;&#20195;&#30721;&#26102;&#65292;&#19981;&#35201;&#29992;&#29983;&#20731;&#30340;&#32534;&#30721;&#12290;Python &#40664;&#35748;&#30340; UTF-8 &#25110;&#32431; ASCII &#21487;&#20197;&#32988;&#20219;&#21508;&#31181;&#24773;&#20917;&#12290;"

#: ../../tutorial/controlflow.rst:1102
msgid ""
"Likewise, don't use non-ASCII characters in identifiers if there is only the"
" slightest chance people speaking a different language will read or maintain"
" the code."
msgstr "&#21516;&#29702;&#65292;&#23601;&#31639;&#22810;&#35821;&#38405;&#35835;&#12289;&#32500;&#25252;&#20195;&#30721;&#30340;&#21487;&#33021;&#20877;&#23567;&#65292;&#20063;&#19981;&#35201;&#22312;&#26631;&#35782;&#31526;&#20013;&#20351;&#29992;&#38750; ASCII &#23383;&#31526;&#12290;"

#: ../../tutorial/controlflow.rst:1108
msgid "Footnotes"
msgstr "&#22791;&#27880;"

#: ../../tutorial/controlflow.rst:1109
msgid ""
"Actually, *call by object reference* would be a better description, since if"
" a mutable object is passed, the caller will see any changes the callee "
"makes to it (items inserted into a list)."
msgstr "&#23454;&#38469;&#19978;&#65292;*&#23545;&#35937;&#24341;&#29992;&#35843;&#29992;* &#36825;&#31181;&#35828;&#27861;&#26356;&#22909;&#65292;&#22240;&#20026;&#65292;&#20256;&#36882;&#30340;&#26159;&#21487;&#21464;&#23545;&#35937;&#26102;&#65292;&#35843;&#29992;&#32773;&#33021;&#21457;&#29616;&#34987;&#35843;&#32773;&#20570;&#20986;&#30340;&#20219;&#20309;&#26356;&#25913;&#65288;&#25554;&#20837;&#21015;&#34920;&#30340;&#20803;&#32032;&#65289;&#12290;"