# 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.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-05-26 11:10+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (http://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.5.1\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 knows the "
"usual control flow 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 ""
"If you need to modify the sequence you are iterating over while inside "
"the loop (for example to duplicate selected items), it is recommended "
"that you first make a copy. Iterating over a sequence does not "
"implicitly make a copy. The slice notation makes this especially "
"convenient::"
msgstr ""
" ( , ), "
". . ::"
#: ../Doc/tutorial/controlflow.rst:81
msgid ""
"With ``for w in words:``, the example would attempt to create an infinite"
" list, inserting ``defenestrate`` over and over again."
msgstr ""
"``for w in words:`` , ``defenestrate`` , "
" ."
#: ../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 *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 an *iterator*. The function :func:`list`"
" is another; it creates lists from iterables::"
msgstr ""
" ** . "
" . :keyword:`for` . :func:`list` "
"; ::"
#: ../Doc/tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables"
" as argument."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:158
msgid ""
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
"Clauses on Loops"
msgstr " :keyword:`break` :keyword:`continue` , :keyword:`else` "
#: ../Doc/tutorial/controlflow.rst:160
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:163
msgid ""
"Loop statements may have an ``else`` clause; it is executed when the loop"
" terminates through exhaustion of the list (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 ""
" ``else`` ; (:keyword:`for` ) "
" (:keyword:`while` ) . :keyword:`break` "
" . ::"
#: ../Doc/tutorial/controlflow.rst:187
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:190
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 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:197
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:217
msgid ":keyword:`pass` Statements"
msgstr ":keyword:`pass` "
#: ../Doc/tutorial/controlflow.rst:219
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:226
msgid "This is commonly used for creating minimal classes::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:232
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:243
msgid "Defining Functions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:245
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary"
" boundary::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:265
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:270
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:277
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 cannot be directly assigned a value within a function (unless "
"named in a :keyword:`global` statement), although they may be referenced."
msgstr ""
" ** . , "
" ; , , "
" . , , (:keyword:`global` "
" ) ."
#: ../Doc/tutorial/controlflow.rst:286
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, a new local symbol table is created for that "
"call."
msgstr ""
" () ; "
"* (call by value)* (** ** ). "
"[#]_ , ."
#: ../Doc/tutorial/controlflow.rst:292
msgid ""
"A function definition introduces the function name in the current symbol "
"table. The value of the function name has a type that is recognized by "
"the interpreter as a user-defined function. This value can be assigned "
"to another name which can then also be used as a function. This serves "
"as a general renaming mechanism::"
msgstr ""
" . . "
" , . ::"
#: ../Doc/tutorial/controlflow.rst:304
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:315
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:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr " , :"
#: ../Doc/tutorial/controlflow.rst:333
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:337
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:352
msgid "More on Defining Functions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:354
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:361
msgid "Default Argument Values"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:363
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:379
msgid "This function can be called in several ways:"
msgstr " :"
#: ../Doc/tutorial/controlflow.rst:381
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to "
"quit?')``"
msgstr " : ``ask_ok(' ?')``"
#: ../Doc/tutorial/controlflow.rst:383
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the "
"file?', 2)``"
msgstr " : ``ask_ok(' ?', 2)``"
#: ../Doc/tutorial/controlflow.rst:385
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:388
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:391
msgid ""
"The default values are evaluated at the point of function definition in "
"the *defining* scope, so that ::"
msgstr " * * , ::"
#: ../Doc/tutorial/controlflow.rst:402
msgid "will print ``5``."
msgstr " ``5`` ."
#: ../Doc/tutorial/controlflow.rst:404
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:417
msgid "This will print ::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:423
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:436
msgid "Keyword Arguments"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:438
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:447
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:458
msgid "but all the following calls would be invalid::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:465
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:481
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 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`` ( ) "
" , . (``*name`` "
"``**name`` .) , ::"
#: ../Doc/tutorial/controlflow.rst:498
msgid "It could be called like this::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:506
msgid "and of course it would print:"
msgstr " :"
#: ../Doc/tutorial/controlflow.rst:519
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:526
msgid "Arbitrary Argument Lists"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:531
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:540
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:557
msgid "Unpacking Argument Lists"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:559
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:575
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr " ``**``\\ - ::"
#: ../Doc/tutorial/controlflow.rst:591
msgid "Lambda Expressions"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:593
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:610
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:622
msgid "Documentation Strings"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:629
msgid ""
"Here are some conventions about the content and formatting of "
"documentation strings."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:632
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:638
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:643
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:655
msgid "Here is an example of a multi-line docstring::"
msgstr " ::"
#: ../Doc/tutorial/controlflow.rst:673
msgid "Function Annotations"
msgstr " "
#: ../Doc/tutorial/controlflow.rst:680
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:684
msgid ""
"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 "
"positional argument, a keyword argument, and the return value annotated::"
msgstr ""
" :attr:`__annotations__` "
" . , "
" . ``->`` , "
":keyword:`def` . , , "
"::"
#: ../Doc/tutorial/controlflow.rst:706
msgid "Intermezzo: Coding Style"
msgstr ": "
#: ../Doc/tutorial/controlflow.rst:711
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:717
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:722
msgid "Use 4-space indentation, and no tabs."
msgstr " 4- , ."
#: ../Doc/tutorial/controlflow.rst:724
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:728
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "79 ."
#: ../Doc/tutorial/controlflow.rst:730
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:733
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of "
"code inside functions."
msgstr ", , ."
#: ../Doc/tutorial/controlflow.rst:736
msgid "When possible, put comments on a line of their own."
msgstr ", ."
#: ../Doc/tutorial/controlflow.rst:738
msgid "Use docstrings."
msgstr " ."
#: ../Doc/tutorial/controlflow.rst:740
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:743
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``CamelCase`` for classes and ``lower_case_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 ""
" ; ``CamelCase``, "
"``lower_case_with_underscores`` . ``self`` "
" ( :ref:`tut-firstclasses` )."
#: ../Doc/tutorial/controlflow.rst:748
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:752
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:758
msgid "Footnotes"
msgstr ""
#: ../Doc/tutorial/controlflow.rst:759
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)* , , "
" ( )."