python-docs-it/tutorial/controlflow.po at 3.11 · python/python-docs-it

658 lines (561 loc) · 23.8 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-04-21 18:09+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: ../Doc/tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
#: ../Doc/tutorial/controlflow.rst:7
"Besides the :keyword:`while` statement just introduced, Python knows the "
"usual control flow statements known from other languages, with some twists."
#: ../Doc/tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
#: ../Doc/tutorial/controlflow.rst:16
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
#: ../Doc/tutorial/controlflow.rst:33
"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."
#: ../Doc/tutorial/controlflow.rst:43
msgid ":keyword:`!for` Statements"
#: ../Doc/tutorial/controlflow.rst:48
"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):"
#: ../Doc/tutorial/controlflow.rst:69
"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::"
#: ../Doc/tutorial/controlflow.rst:81
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
#: ../Doc/tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
#: ../Doc/tutorial/controlflow.rst:90
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates arithmetic progressions::"
#: ../Doc/tutorial/controlflow.rst:102
"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')::"
#: ../Doc/tutorial/controlflow.rst:116
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
#: ../Doc/tutorial/controlflow.rst:129
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
#: ../Doc/tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
#: ../Doc/tutorial/controlflow.rst:137
"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."
#: ../Doc/tutorial/controlflow.rst:142
"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::"
#: ../Doc/tutorial/controlflow.rst:152
"Later we will see more functions that return iterables and take iterables as "
"argument."
#: ../Doc/tutorial/controlflow.rst:158
":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "
"Clauses on Loops"
#: ../Doc/tutorial/controlflow.rst:160
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
#: ../Doc/tutorial/controlflow.rst:163
"Loop statements may have an :keyword:`!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::"
#: ../Doc/tutorial/controlflow.rst:187
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
#: ../Doc/tutorial/controlflow.rst:190
"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`."
#: ../Doc/tutorial/controlflow.rst:197
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
#: ../Doc/tutorial/controlflow.rst:217
msgid ":keyword:`!pass` Statements"
#: ../Doc/tutorial/controlflow.rst:219
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
#: ../Doc/tutorial/controlflow.rst:226
msgid "This is commonly used for creating minimal classes::"
#: ../Doc/tutorial/controlflow.rst:232
"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::"
#: ../Doc/tutorial/controlflow.rst:243
msgid "Defining Functions"
#: ../Doc/tutorial/controlflow.rst:245
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
#: ../Doc/tutorial/controlflow.rst:265
"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."
#: ../Doc/tutorial/controlflow.rst:270
"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."
#: ../Doc/tutorial/controlflow.rst:277
"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."
#: ../Doc/tutorial/controlflow.rst:286
"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."
#: ../Doc/tutorial/controlflow.rst:292
"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::"
#: ../Doc/tutorial/controlflow.rst:304
"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`::"
#: ../Doc/tutorial/controlflow.rst:315
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
#: ../Doc/tutorial/controlflow.rst:331
msgid "This example, as usual, demonstrates some new Python features:"
#: ../Doc/tutorial/controlflow.rst:333
"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``."
#: ../Doc/tutorial/controlflow.rst:337
"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."
#: ../Doc/tutorial/controlflow.rst:352
msgid "More on Defining Functions"
#: ../Doc/tutorial/controlflow.rst:354
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
#: ../Doc/tutorial/controlflow.rst:361
msgid "Default Argument Values"
#: ../Doc/tutorial/controlflow.rst:363
"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::"
#: ../Doc/tutorial/controlflow.rst:379
msgid "This function can be called in several ways:"
#: ../Doc/tutorial/controlflow.rst:381
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
#: ../Doc/tutorial/controlflow.rst:383
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
#: ../Doc/tutorial/controlflow.rst:385
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
#: ../Doc/tutorial/controlflow.rst:388
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
#: ../Doc/tutorial/controlflow.rst:391
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
#: ../Doc/tutorial/controlflow.rst:402
msgid "will print ``5``."
#: ../Doc/tutorial/controlflow.rst:404
"**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::"
#: ../Doc/tutorial/controlflow.rst:417
msgid "This will print ::"
#: ../Doc/tutorial/controlflow.rst:423
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
#: ../Doc/tutorial/controlflow.rst:436
msgid "Keyword Arguments"
#: ../Doc/tutorial/controlflow.rst:438
"Functions can also be called using :term:`keyword arguments <keyword "
"argument>` of the form ``kwarg=value``.  For instance, the following "
"function::"
#: ../Doc/tutorial/controlflow.rst:447
"accepts one required argument (``voltage``) and three optional arguments "
"(``state``, ``action``, and ``type``).  This function can be called in any "
"of the following ways::"
#: ../Doc/tutorial/controlflow.rst:458
msgid "but all the following calls would be invalid::"
#: ../Doc/tutorial/controlflow.rst:465
"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::"
#: ../Doc/tutorial/controlflow.rst:481
"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::"
#: ../Doc/tutorial/controlflow.rst:498
msgid "It could be called like this::"
#: ../Doc/tutorial/controlflow.rst:506
msgid "and of course it would print:"
#: ../Doc/tutorial/controlflow.rst:519
"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."
#: ../Doc/tutorial/controlflow.rst:526
msgid "Arbitrary Argument Lists"
#: ../Doc/tutorial/controlflow.rst:531
"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. ::"
#: ../Doc/tutorial/controlflow.rst:540
"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. ::"
#: ../Doc/tutorial/controlflow.rst:557
msgid "Unpacking Argument Lists"
#: ../Doc/tutorial/controlflow.rst:559
"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::"
#: ../Doc/tutorial/controlflow.rst:575
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**`` operator::"
#: ../Doc/tutorial/controlflow.rst:591
msgid "Lambda Expressions"
#: ../Doc/tutorial/controlflow.rst:593
"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 "
#: ../Doc/tutorial/controlflow.rst:610
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
#: ../Doc/tutorial/controlflow.rst:622
msgid "Documentation Strings"
#: ../Doc/tutorial/controlflow.rst:629
"Here are some conventions about the content and formatting of documentation "
#: ../Doc/tutorial/controlflow.rst:632
"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."
#: ../Doc/tutorial/controlflow.rst:638
"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."
#: ../Doc/tutorial/controlflow.rst:643
"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)."
#: ../Doc/tutorial/controlflow.rst:655
msgid "Here is an example of a multi-line docstring::"
#: ../Doc/tutorial/controlflow.rst:673
msgid "Function Annotations"
#: ../Doc/tutorial/controlflow.rst:681
":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)."
#: ../Doc/tutorial/controlflow.rst:685
":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 positional argument, a keyword argument, and the return value annotated::"
#: ../Doc/tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
#: ../Doc/tutorial/controlflow.rst:712
"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."
#: ../Doc/tutorial/controlflow.rst:718
"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:"
#: ../Doc/tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
#: ../Doc/tutorial/controlflow.rst:725
"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."
#: ../Doc/tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
#: ../Doc/tutorial/controlflow.rst:731
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
#: ../Doc/tutorial/controlflow.rst:734
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
#: ../Doc/tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
#: ../Doc/tutorial/controlflow.rst:739
msgid "Use docstrings."
#: ../Doc/tutorial/controlflow.rst:741
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
#: ../Doc/tutorial/controlflow.rst:744
"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)."
#: ../Doc/tutorial/controlflow.rst:749
"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 "
#: ../Doc/tutorial/controlflow.rst:753
"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."
#: ../Doc/tutorial/controlflow.rst:759
msgid "Footnotes"
#: ../Doc/tutorial/controlflow.rst:760
"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)."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

controlflow.po

Latest commit

History

controlflow.po

File metadata and controls
