# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-04-08 08:18+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.7.0\n"
#: ../Doc/tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr " "
#: ../Doc/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 ""
" :keyword:`while` , , "
" ."
#: ../Doc/tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
msgstr ":keyword:`!if` "
#: ../Doc/tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` "
"statement. For example::"
msgstr " :keyword:`if` . ::"
#: ../Doc/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`` ."
#: ../Doc/tutorial/controlflow.rst:43
msgid ":keyword:`!for` Statements"
msgstr ":keyword:`!for` "
#: ../Doc/tutorial/controlflow.rst:48
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 ""
" :keyword:`for` C . () "
" , (C) , "
":keyword:`!for` ( ) . "
" ( ):"
#: ../Doc/tutorial/controlflow.rst:69
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 ""
" . , "
" ::"
#: ../Doc/tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
msgstr ":func:`range` "
#: ../Doc/tutorial/controlflow.rst:90
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`\\ . ::"
#: ../Doc/tutorial/controlflow.rst:102
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 "
" . , ( ; "
"'(step)' ) ::"
#: ../Doc/tutorial/controlflow.rst:116
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr " , :func:`range`\\ :func:`len` ::"
#: ../Doc/tutorial/controlflow.rst:129
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` "
" ."
#: ../Doc/tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:137
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`\\ , . "
" , ."
#: ../Doc/tutorial/controlflow.rst:142
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:` ` . "
" . :keyword:`for` . "
" :func:`sum`\\::"
#: ../Doc/tutorial/controlflow.rst:151
msgid ""
"Later we will see more functions that return iterables and take iterables"
" as arguments. Lastly, maybe you are curious about how to get a list "
"from a range. Here is the solution::"
msgstr ""
" . , range "
" . ::"
#: ../Doc/tutorial/controlflow.rst:158
msgid ""
"In chapter :ref:`tut-structures`, we will discuss in more detail about "
":func:`list`."
msgstr ":ref:`tut-structures` :func:`list`\\ ."
#: ../Doc/tutorial/controlflow.rst:164
msgid ""
":keyword:`!break` and :keyword:`!continue` Statements, and "
":keyword:`!else` Clauses on Loops"
msgstr " :keyword:`!break` :keyword:`!continue` , :keyword:`!else` "
#: ../Doc/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` , C, :keyword:`for` :keyword:`while` "
" ."
#: ../Doc/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 ""
" :keyword:`!else` ; (:keyword:`for`\\ "
") (:keyword:`while`\\ ) . "
":keyword:`break` . ::"
#: ../Doc/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 ""
"( . : ``else`` :keyword:`if` **** "
":keyword:`for` .)"
#: ../Doc/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`` :keyword:`if` :keyword:`try` ``else`` "
" : :keyword:`try` ``else`` , "
"``else`` ``break``\\ . :keyword:`!try` "
" :ref:`tut-handling` ."
#: ../Doc/tutorial/controlflow.rst:203
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with "
"the next iteration of the loop::"
msgstr ":keyword:`continue` , C , ::"
#: ../Doc/tutorial/controlflow.rst:223
msgid ":keyword:`!pass` Statements"
msgstr ":keyword:`!pass` "
#: ../Doc/tutorial/controlflow.rst:225
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` . , "
" . ::"
#: ../Doc/tutorial/controlflow.rst:232
msgid "This is commonly used for creating minimal classes::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:238
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` ::"
#: ../Doc/tutorial/controlflow.rst:249
msgid "Defining Functions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:251
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary"
" boundary::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:271
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`\\ **\\ . "
". , ."
#: ../Doc/tutorial/controlflow.rst:276
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` "
".) , "
" ; , ."
#: ../Doc/tutorial/controlflow.rst:283
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` )."
#: ../Doc/tutorial/controlflow.rst:294
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 ""
" () ; "
"* (call by value)*\\ (**\\ **\\). "
"[#]_ , , ."
#: ../Doc/tutorial/controlflow.rst:301
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 ""
" . "
". ::"
#: ../Doc/tutorial/controlflow.rst:312
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`` , ``None`` "
". :func:`print`\\ ::"
#: ../Doc/tutorial/controlflow.rst:323
msgid ""
"It is simple to write a function that returns a list of the numbers of "
"the Fibonacci series, instead of printing it::"
msgstr " , ::"
#: ../Doc/tutorial/controlflow.rst:339
msgid "This example, as usual, demonstrates some new Python features:"
msgstr " , :"
#: ../Doc/tutorial/controlflow.rst:341
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``\\ ."
#: ../Doc/tutorial/controlflow.rst:345
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]`` "
" , ."
#: ../Doc/tutorial/controlflow.rst:360
msgid "More on Defining Functions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:362
msgid ""
"It is also possible to define functions with a variable number of "
"arguments. There are three forms, which can be combined."
msgstr " . , ."
#: ../Doc/tutorial/controlflow.rst:369
msgid "Default Argument Values"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:371
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 ""
" . "
" . ::"
#: ../Doc/tutorial/controlflow.rst:387
msgid "This function can be called in several ways:"
msgstr " :"
#: ../Doc/tutorial/controlflow.rst:389
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to "
"quit?')``"
msgstr " : ``ask_ok(' ?')``"
#: ../Doc/tutorial/controlflow.rst:391
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the "
"file?', 2)``"
msgstr " : ``ask_ok(' ?', 2)``"
#: ../Doc/tutorial/controlflow.rst:393
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, "
"'Come on, only yes or no!')``"
msgstr " : ``ask_ok(' ?', 2, ', !')``"
#: ../Doc/tutorial/controlflow.rst:396
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests "
"whether or not a sequence contains a certain value."
msgstr " :keyword:`in` . ."
#: ../Doc/tutorial/controlflow.rst:399
msgid ""
"The default values are evaluated at the point of function definition in "
"the *defining* scope, so that ::"
msgstr " * * , ::"
#: ../Doc/tutorial/controlflow.rst:410
msgid "will print ``5``."
msgstr " ``5``\\ ."
#: ../Doc/tutorial/controlflow.rst:412
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 ""
"** :** . "
" . , ::"
#: ../Doc/tutorial/controlflow.rst:425
msgid "This will print ::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:431
msgid ""
"If you don't want the default to be shared between subsequent calls, you "
"can write the function like this instead::"
msgstr " , ::"
#: ../Doc/tutorial/controlflow.rst:444
msgid "Keyword Arguments"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:446
msgid ""
"Functions can also be called using :term:`keyword arguments ` of the form ``kwarg=value``. For instance, the following "
"function::"
msgstr ""
" ``kwarg=value`` :term:` ` "
". , ::"
#: ../Doc/tutorial/controlflow.rst:455
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``) "
". ."
#: ../Doc/tutorial/controlflow.rst:466
msgid "but all the following calls would be invalid::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:473
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)`` ). "
" . , ::"
#: ../Doc/tutorial/controlflow.rst:489
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 ` "
"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`` ( ) "
" , :ref:` `\\ "
". (``*name``\\ ``**name`` .) , ::"
#: ../Doc/tutorial/controlflow.rst:506
msgid "It could be called like this::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:514
msgid "and of course it would print:"
msgstr " :"
#: ../Doc/tutorial/controlflow.rst:527
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 " ."
#: ../Doc/tutorial/controlflow.rst:531
msgid "Special parameters"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:533
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 ""
", . , , "
" , ."
#: ../Doc/tutorial/controlflow.rst:539
msgid "A function definition may look like:"
msgstr " :"
#: ../Doc/tutorial/controlflow.rst:550
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 ""
" ``/``\\ ``*``\\ . , "
": , - . (named) ."
#: ../Doc/tutorial/controlflow.rst:557
msgid "Positional-or-Keyword Arguments"
msgstr "-(Positional-or-Keyword) "
#: ../Doc/tutorial/controlflow.rst:559
msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments "
"may be passed to a function by position or by keyword."
msgstr " ``/``\\ ``*``\\ , ."
#: ../Doc/tutorial/controlflow.rst:564
msgid "Positional-Only Parameters"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:566
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 ""
" , * *\\ . * *\\, "
", . ``/`` () . ``/``\\ "
" . ``/``\\ , "
" ."
#: ../Doc/tutorial/controlflow.rst:574
msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or "
"*keyword-only*."
msgstr "``/`` *-*\\ * *\\ ."
#: ../Doc/tutorial/controlflow.rst:578
msgid "Keyword-Only Arguments"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:580
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 ""
" , * *\\ , * * "
" ``*``\\ ."
#: ../Doc/tutorial/controlflow.rst:586
msgid "Function Examples"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:588
msgid ""
"Consider the following example function definitions paying close "
"attention to the markers ``/`` and ``*``::"
msgstr "``/``\\ ``*`` ::"
#: ../Doc/tutorial/controlflow.rst:604
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``\\ , "
" ::"
#: ../Doc/tutorial/controlflow.rst:614
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``\\ ``/``\\ ::"
#: ../Doc/tutorial/controlflow.rst:625
msgid ""
"The third function ``kwd_only_args`` only allows keyword arguments as "
"indicated by a ``*`` in the function definition::"
msgstr " ``kwd_only_args``\\ ``*``\\ ::"
#: ../Doc/tutorial/controlflow.rst:636
msgid ""
"And the last uses all three calling conventions in the same function "
"definition::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:656
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 ""
", ``name``\\ ``name``\\ ``**kwds`` "
" ::"
#: ../Doc/tutorial/controlflow.rst:661
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 ""
"``'name'`` ``True``\\ . "
"::"
#: ../Doc/tutorial/controlflow.rst:670
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'``\\ "
" ::"
#: ../Doc/tutorial/controlflow.rst:677
msgid ""
"In other words, the names of positional-only parameters can be used in "
"``**kwds`` without ambiguity."
msgstr ", ``**kwds``\\ ."
#: ../Doc/tutorial/controlflow.rst:682
msgid "Recap"
msgstr ""
#: ../Doc/tutorial/controlflow.rst:684
msgid ""
"The use case will determine which parameters to use in the function "
"definition::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:688
msgid "As guidance:"
msgstr ":"
#: ../Doc/tutorial/controlflow.rst:690
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 ""
" . , "
" , ."
#: ../Doc/tutorial/controlflow.rst:695
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 ""
" , "
" ."
#: ../Doc/tutorial/controlflow.rst:698
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 ."
#: ../Doc/tutorial/controlflow.rst:704
msgid "Arbitrary Argument Lists"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:709
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` ). , ."
#: ../Doc/tutorial/controlflow.rst:718
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 ""
", `` `` , "
". ``*args`` '-' , "
" . ::"
#: ../Doc/tutorial/controlflow.rst:735
msgid "Unpacking Argument Lists"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:737
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* . "
" , ``*``\\ - ::"
#: ../Doc/tutorial/controlflow.rst:753
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr " ``**``\\ - ::"
#: ../Doc/tutorial/controlflow.rst:769
msgid "Lambda Expressions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:771
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``. . "
" . , . , "
" ::"
#: ../Doc/tutorial/controlflow.rst:788
msgid ""
"The above example uses a lambda expression to return a function. Another"
" use is to pass a small function as an argument::"
msgstr " . ::"
#: ../Doc/tutorial/controlflow.rst:800
msgid "Documentation Strings"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:807
msgid ""
"Here are some conventions about the content and formatting of "
"documentation strings."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:810
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 ""
" , . , "
", ( ). "
" ."
#: ../Doc/tutorial/controlflow.rst:816
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 ""
" , , . "
" , , ."
#: ../Doc/tutorial/controlflow.rst:821
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 ""
" , "
". . * * "
" . ( , "
" .) \"\" "
". , . "
"( 8 ) ."
#: ../Doc/tutorial/controlflow.rst:833
msgid "Here is an example of a multi-line docstring::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:851
msgid "Function Annotations"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:859
msgid ""
":ref:`Function annotations ` are completely optional metadata "
"information about the types used by user-defined functions (see "
":pep:`3107` and :pep:`484` for more information)."
msgstr ""
":ref:` ` "
"( :pep:`3107` :pep:`484` )."
#: ../Doc/tutorial/controlflow.rst:863
msgid ""
":term:`Annotations ` 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:` `\\ :attr:`__annotations__` "
" . "
", . ``->`` "
" , :keyword:`def` . "
", , ::"
#: ../Doc/tutorial/controlflow.rst:885
msgid "Intermezzo: Coding Style"
msgstr ": "
#: ../Doc/tutorial/controlflow.rst:890
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 ""
" , , * *\\ . "
" ( , **) ; . "
" , "
" ."
#: ../Doc/tutorial/controlflow.rst:896
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 ""
" , :pep:`8`\\ ; "
" . ; "
"::"
#: ../Doc/tutorial/controlflow.rst:901
msgid "Use 4-space indentation, and no tabs."
msgstr " 4- , ."
#: ../Doc/tutorial/controlflow.rst:903
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 ( ) ( ) . "
" , ."
#: ../Doc/tutorial/controlflow.rst:907
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "79 ."
#: ../Doc/tutorial/controlflow.rst:909
msgid ""
"This helps users with small displays and makes it possible to have "
"several code files side-by-side on larger displays."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:912
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of "
"code inside functions."
msgstr ", , ."
#: ../Doc/tutorial/controlflow.rst:915
msgid "When possible, put comments on a line of their own."
msgstr ", ."
#: ../Doc/tutorial/controlflow.rst:917
msgid "Use docstrings."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:919
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
" , : ``a = f(1, 2) + g(3, "
"4)``."
#: ../Doc/tutorial/controlflow.rst:922
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 ""
" ; ``UpperCamelCase``, "
"``lowercase_with_underscores``\\. ``self``\\ "
" ( :ref:`tut-firstclasses` )."
#: ../Doc/tutorial/controlflow.rst:927
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 ""
" . , UTF-8, "
" ASCII, ."
#: ../Doc/tutorial/controlflow.rst:931
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 ""
", , ASCII "
" ."
#: ../Doc/tutorial/controlflow.rst:937
msgid "Footnotes"
msgstr ""
#: ../Doc/tutorial/controlflow.rst:938
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 ""
", * (call by object reference)* , , "
" ( )."