python-docs-pt-br/tutorial/controlflow.po at 3.6 · python/python-docs-pt-br

930 lines (833 loc) · 43.2 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# Translators:
# Adorilson Bezerra <adorilson@gmail.com>, 2019
# Hildeberto Abreu Magalhães <hildeberto@gmail.com>, 2019
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2019
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:19+0000\n"
"Last-Translator: Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2019\n"
"Language-Team: Portuguese (Brazil) (https://www.transifex.com/python-doc/teams/5390/pt_BR/)\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: ../../tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr "Mais ferramentas de controle de fluxo"
#: ../../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."
"Além do comando :keyword:`while` recém apresentado, Python tem as estruturas"
" usuais de controle de fluxo conhecidas em outras linguagens, com algumas "
"particularidades."
#: ../../tutorial/controlflow.rst:14
msgid ":keyword:`if` Statements"
msgstr "Comando :keyword:`if`"
#: ../../tutorial/controlflow.rst:16
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
"Provavelmente o mais conhecido comando de controle de fluxo é o "
":keyword:`if`. Por exemplo::"
#: ../../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."
"Pode haver zero ou mais seções :keyword:`elif`, e a seção :keyword:`else` é "
"opcional. A palavra-chave :keyword:`elif` é uma abreviação para 'else if', e"
" é útil para evitar indentação excessiva. Uma sequência :keyword:`if` ... "
":keyword:`elif` ... :keyword:`elif` ... substitui as construções ``switch`` "
"ou ``case`` existentes em outras linguagens."
#: ../../tutorial/controlflow.rst:43
msgid ":keyword:`for` Statements"
msgstr "Comando :keyword:`for`"
#: ../../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):"
"O comando :keyword:`for` em Python difere um tanto do que talvez estejas\n"
"acostumado em C ou Pascal. Ao invés de se iterar sobre progressões\n"
"aritméticas (como em Pascal), ou dar ao usuário o poder de definir tanto o\n"
"passo da iteração quanto a condição de parada (como em C), o comando\n"
":keyword:`for` de Python itera sobre os itens de qualquer sequência (como uma\n"
"lista ou uma string), na ordem em que eles aparecem na sequência. Por exemplo:"
#: ../../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::"
"Se for necessário modificar a sequência, sobre a qual está iterando, dentro "
"do laço de repetição (por exemplo, para duplicar itens selecionados), é "
"recomendado que primeiro crie-se uma cópia da sequência. Iterar sobre uma "
"sequência não cria implicitamente uma cópia. A notação de fatiamento é "
"bastante conveniente para isso::"
#: ../../tutorial/controlflow.rst:81
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
"Com ``for w in words:``, o exemplo tentaria criar uma lista infinita, "
"inserindo ``defenestrate`` uma e outra vez."
#: ../../tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
msgstr "A função :func:`range`"
#: ../../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::"
"Se você precisar iterar sobre sequências numéricas, a função embutida "
":func:`range` é a resposta. Ela gera progressões aritméticas::"
#: ../../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')::"
"O ponto de parada fornecido nunca é incluído na lista; ``range(10)`` gera "
"uma lista com 10 valores, exatamente os índices válidos para uma sequência "
"de comprimento 10. É possível iniciar o intervalo em outro número, ou "
"alterar a razão da progressão (inclusive com passo negativo)::"
#: ../../tutorial/controlflow.rst:116
"To iterate over the indices of a sequence, you can combine :func:`range` and"
" :func:`len` as follows::"
"Para iterar sobre os índices de uma sequência, combine :func:`range` e "
":func:`len` da seguinte forma:"
#: ../../tutorial/controlflow.rst:129
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
"Na maioria dos casos, porém, é mais conveniente usar a função "
":func:`enumerate`, veja :ref:`tut-loopidioms`."
#: ../../tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
msgstr "Uma coisa estranha acontece se imprime-se um range::"
#: ../../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."
"Em muitos aspectos, o objeto retornado pela função :func:`range` se comporta"
" como se fosse uma lista, mas na verdade não é. É um objeto que retorna os "
"itens sucessivos da sequência desejada quando você itera sobre a mesma, mas "
"na verdade ele não gera a lista, economizando espaço."
#: ../../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::"
"Nós dizemos que tal objeto é *iterável*, isto é, adequado como um alvo para "
"funções e construções que esperam algo do qual possam obter itens sucessivos"
" até que o suprimento se  esgote. Vimos que a instrução :keyword:`for` é um "
"*iterador*. A função :func:`list` é outro; cria listas de iteráveis::"
#: ../../tutorial/controlflow.rst:152
"Later we will see more functions that return iterables and take iterables as"
" argument."
"Mais tarde, veremos mais funções que retornam ``iteráveis`` e recebem "
"``iteráveis`` como argumento."
#: ../../tutorial/controlflow.rst:158
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
"Clauses on Loops"
"Comandos :keyword:`break` e :keyword:`continue`, e cláusulas :keyword:`else`"
" em laços"
#: ../../tutorial/controlflow.rst:160
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
"O comando :keyword:`break`, como no C, sai imediatamente do laço de "
"repetição mais interno, seja :keyword:`for` ou :keyword:`while`."
#: ../../tutorial/controlflow.rst:163
"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::"
"Laços podem ter uma cláusula ``else``, que é executada sempre que o laço se\n"
"encerra por exaustão da lista (no caso do :keyword:`for`) ou quando a condição\n"
"se torna falsa (no caso do :keyword:`while`), mas nunca quando o laço é\n"
"interrompido por um :keyword:`break`. Isto é exemplificado no próximo exemplo\n"
"que procura números primos::"
#: ../../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.)"
"(Sim, o código está correto. Olhe atentamente: a cláusula ``else`` pertence "
"ao laço :keyword:`for`, e **não** ao comando :keyword:`if`.)"
#: ../../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`."
"Quando usado com um loop, a cláusula ``else`` tem mais em comum com a "
"cláusula ``else`` de uma declaração :keyword:`try` o que faz de instruções "
":keyword:`if`: uma declaração ``else`` da instrução :keyword:`try` é "
"executada quando nenhuma exceção ocorre e uma frase do ``else`` do loop é "
"executada quando não ocorre ``break``. Para mais informações sobre a "
"declaração :keyword:`try` e exceções, veja :ref:`tut-handling`."
#: ../../tutorial/controlflow.rst:197
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
"A instrução :keyword:`continue`, também emprestada da linguagem C, continua "
"com a próxima iteração do laço::"
#: ../../tutorial/controlflow.rst:217
msgid ":keyword:`pass` Statements"
msgstr "Comando :keyword:`pass`"
#: ../../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::"
"O comando :keyword:`pass` não faz nada. Ela pode ser usada quando a sintaxe "
"exige um comando mas a semântica do programa não requer nenhuma ação. Por "
"exemplo::"
#: ../../tutorial/controlflow.rst:226
msgid "This is commonly used for creating minimal classes::"
msgstr "Isto é usado muitas vezes para se definir classes mínimas::"
#: ../../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::"
"Outra situação em que :keyword:`pass` pode ser usado é para reservar o lugar"
" de uma função ou de um bloco condicional, quando se está trabalhando em "
"código novo, o que lhe possibilita continuar a raciocinar em um nível mais "
"abstrato. O comando :keyword:`pass` é ignorado silenciosamente::"
#: ../../tutorial/controlflow.rst:243
msgid "Defining Functions"
msgstr "Definindo Funções"
#: ../../tutorial/controlflow.rst:245
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
"Podemos criar uma função que escreve a série de Fibonacci até um limite "
"arbitrário::"
#: ../../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."
"A palavra reservada :keyword:`def` inicia a *definição* de uma função. Ela "
"deve ser seguida do nome da função e da lista de parâmetros formais entre "
"parênteses. Os comandos que formam o corpo da função começam na linha "
"seguinte e devem ser indentados."
#: ../../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."
"Opcionalmente, a primeira linha do corpo da função pode ser uma string "
"literal, cujo propósito é documentar a função. Se presente, essa string "
"chama-se :dfn:`docstring`. (Há mais informação sobre docstrings na seção "
":ref:`tut-docstrings`.) Existem ferramentas que utilizam docstrings para "
"produzir automaticamente documentação online ou para imprimir, ou ainda "
"permitir que o usuário navegue interativamente pelo código. É uma boa "
"prática incluir sempre docstrings em suas funções, portanto, tente fazer "
"disso um hábito."
#: ../../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."
"A *execução* de uma função gera uma nova tabela de símbolos, usada para as\n"
"variáveis locais da função. Mais precisamente, toda atribuição a variável\n"
"dentro da função armazena o valor na tabela de símbolos local. Referências a\n"
"variáveis são buscadas primeiramente na tabela local, então na tabela de\n"
"símbolos global e finalmente na tabela de nomes embutidos (built-in).\n"
"Portanto, não se pode atribuir diretamente um valor a uma variável global\n"
"dentro de uma função (a menos que se utilize a declaração :keyword:`global`\n"
"antes), ainda que variáveis globais possam ser referenciadas livremente."
#: ../../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."
"Os parâmetros reais (argumentos) de uma chamada de função são introduzidos "
"na tabela de símbolos local da função no momento da chamada; portanto, "
"argumentos são passados *por valor* (onde o *valor* é sempre uma "
"*referência* para objeto, não o valor do objeto). [#]_ Quando uma função "
"chama outra função, uma nova tabela de símbolos é criada para tal chamada."
#: ../../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::"
"Uma definição de função introduz o nome da função na tabela de símbolos "
"atual. O valor associado ao nome da função tem um tipo que é reconhecido "
"pelo interpretador como uma função definida pelo usuário. Esse valor pode "
"ser atribuído a outros nomes que também podem ser usados como funções. Esse "
"mecanismo serve para renomear funções::"
#: ../../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`::"
"Conhecendo outras linguagens, pode-se questionar que ``fib`` não é uma "
"função, mas um procedimento, pois ela não devolve um valor. Na verdade, "
"mesmo funções que não usam o comando :keyword:`return` devolvem um valor, "
"ainda que pouco interessante. Esse valor é chamado ``None`` (é um nome "
"embutido). O interpretador interativo evita escrever ``None`` quando ele é o"
" único resultado de uma expressão. Mas se quiser vê-lo pode usar o comando "
":keyword:`print`::"
#: ../../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::"
"É fácil escrever uma função que devolve uma lista de números da série de "
"Fibonacci, ao invés de exibi-los:"
#: ../../tutorial/controlflow.rst:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr "Este exemplo demonstra novos recursos de Python:"
#: ../../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``."
"* O comando :keyword:`return` termina a função devolvendo um valor. Se não\n"
" houver uma expressão após o :keyword:`return`, o valor ``None`` é devolvido.\n"
" Se a função chegar ao fim sem o uso explícito do :keyword:`return`, então\n"
" também será devolvido o valor ``None``."
#: ../../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."
"A instrução ``result.append(a)`` chama um *método* do objeto lista "
"``result``. Um método é uma função que 'pertence' a um objeto, e é chamada "
"``obj.methodname``, onde ``obj`` é um objeto qualquer (pode ser uma "
"expressão), e ``methodname`` é o nome de um método que foi definido pelo "
"tipo do objeto. Tipos diferentes definem métodos diferentes. Métodos de "
"diferentes tipos podem ter o mesmo nome sem ambiguidade. (É possível definir"
" seus próprios tipos de objetos e métodos, utilizando *classes*, veja em "
":ref:`tut-classes`) O método :meth:`append`, mostrado no exemplo é definido "
"para objetos do tipo lista; ele adiciona um novo elemento ao final da lista."
" Neste exemplo, ele equivale a ``result = result + [a]``, só que mais "
"eficiente."
#: ../../tutorial/controlflow.rst:352
msgid "More on Defining Functions"
msgstr "Mais sobre definição de funções"
#: ../../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."
"É possível definir funções com um número variável de argumentos. Existem "
"três formas, que podem ser combinadas."
#: ../../tutorial/controlflow.rst:361
msgid "Default Argument Values"
msgstr "Argumentos com valores padronizados"
#: ../../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::"
"A mais útil das três é especificar um valor padronizado para um ou mais "
"argumentos. Isso cria uma função que pode ser invocada com menos argumentos "
"do que os que foram definidos. Por exemplo::"
#: ../../tutorial/controlflow.rst:379
msgid "This function can be called in several ways:"
msgstr "Essa função pode ser chamada de várias formas:"
#: ../../tutorial/controlflow.rst:381
"giving only the mandatory argument: ``ask_ok('Do you really want to "
"quit?')``"
"fornecendo apenas o argumento obrigatório: ``ask_ok('Do you really want to "
"quit?')``"
#: ../../tutorial/controlflow.rst:383
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"fornecendo um dos argumentos opcionais: ``ask_ok('OK to overwrite the "
"file?', 2)``"
#: ../../tutorial/controlflow.rst:385
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come"
" on, only yes or no!')``"
"ou fornecendo todos os argumentos: ``ask_ok('OK to overwrite the file?', 2, "
"'Come on, only yes or no!')``"
#: ../../tutorial/controlflow.rst:388
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
"Este exemplo também introduz o operador :keyword:`in`, que verifica se uma "
"sequência contém ou não um determinado valor."
#: ../../tutorial/controlflow.rst:391
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
"Os valores padronizados são avaliados no momento da definição da função, e "
"no escopo em que a função foi *definida*, portanto::"
#: ../../tutorial/controlflow.rst:402
msgid "will print ``5``."
msgstr "irá exibir ``5``."
#: ../../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::"
"**Aviso importante:** Valores padronizados são avaliados apenas uma vez. "
"Isso faz diferença quando o valor é um objeto mutável, como uma lista, "
"dicionário, ou instâncias de classes. Por exemplo, a função a seguir acumula"
" os argumentos passados, nas chamadas subsequentes::"
#: ../../tutorial/controlflow.rst:417
msgid "This will print ::"
msgstr "Isso exibirá::"
#: ../../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::"
"Se não quiser que o valor padrão seja compartilhado entre chamadas "
"subsequentes, pode reescrever a função assim::"
#: ../../tutorial/controlflow.rst:436
msgid "Keyword Arguments"
msgstr "Argumentos nomeados"
#: ../../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::"
"Funções também podem ser chamadas usando :term:`keyword arguments <keyword "
"argument>` da forma  ``kwarg=value``.  Por exemplo, a função a seguir::"
#: ../../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::"
"aceita um argumento obrigatório (``voltage``) e três argumentos opcionais "
"(``state``, ``action``, e ``type``). Esta função pode ser chamada de "
"qualquer uma dessas formas::"
#: ../../tutorial/controlflow.rst:458
msgid "but all the following calls would be invalid::"
msgstr "mas todas as formas a seguir seriam inválidas::"
#: ../../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::"
"Numa chamada de função, argumentos nomeados devem vir depois dos argumentos "
"posicionais. Todos os argumentos nomeados passados devem corresponder com "
"argumentos aceitos pela função (ex. ``actor`` não é um argumento nomeado "
"válido para a função ``parrot``), mas sua ordem é irrelevante. Isto também "
"inclui argumentos obrigatórios (ex.: ``parrot(voltage=1000)`` funciona). "
"Nenhum parâmetro pode receber mais de um valor. Eis um exemplo que não "
"funciona devido a esta restrição::"
#: ../../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::"
"Quando o último parâmetro formal usar a sintaxe ``**nome``, ele receberá um\n"
"dicionário (ver :ref:`tut-dictionaries` ou :ref:`typesmapping` [online]) com\n"
"todos os parâmetros nomeados passados para a função, exceto aqueles que\n"
"corresponderam a parâmetros formais definidos antes. Isto pode ser combinado\n"
"com o parâmetro formal ``*nome`` (descrito na próxima subseção) que recebe uma\n"
"tupla (N.d.T. uma sequência de itens, semelhante a uma lista imutável; ver\n"
":ref:`tut-tuples`) contendo todos argumentos posicionais que não correspondem\n"
"à lista da parâmetros formais. (``*nome`` deve ser declarado antes de\n"
"``**nome``.) Por exemplo, se definimos uma função como esta::"
#: ../../tutorial/controlflow.rst:498
msgid "It could be called like this::"
msgstr "Ela pode ser chamada assim::"
#: ../../tutorial/controlflow.rst:506
msgid "and of course it would print:"
msgstr "e, claro, exibiria:"
#: ../../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."
"Observe que a ordem em que os argumentos nomeados são exibidos é garantida "
"corresponder à ordem em que foram fornecidos na chamada da função."
#: ../../tutorial/controlflow.rst:526
msgid "Arbitrary Argument Lists"
msgstr "Listas de argumentos arbitrários"
#: ../../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. ::"
"Finalmente, a opção menos usada é especificar que a função pode ser chamada "
"com um número arbitrário de argumentos. Esses argumentos serão empacotados "
"em uma tupla (ver :ref:`tut-tuples`). Antes dos argumentos em número "
"variável, zero ou mais argumentos normais podem estar presentes. ::"
#: ../../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. ::"
"Normalmente, esses argumentos de ``quantidade indefinida`` estarão no final "
"da lista de parâmetros formais, porque eles englobam todos os argumentos de "
"entrada restantes, que são passados para a função. Quaisquer parâmetros "
"formais que ocorrem após o parâmetro ``*args`` são argumentos 'chave-valor',"
" o que significa que eles só podem ser usados como chave-valor, em vez de "
"argumentos posicionais::"
#: ../../tutorial/controlflow.rst:557
msgid "Unpacking Argument Lists"
msgstr "Desempacotando listas de argumentos"
#: ../../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::"
"A situação inversa ocorre quando os argumentos já estão numa lista ou tupla\n"
"mas ela precisa ser explodida para invocarmos uma função que requer argumentos\n"
"posicionais separados. Por exemplo, a função :func:`range` espera argumentos\n"
"separados, *start* e *stop*. Se os valores já estiverem juntos em uma lista ou\n"
"tupla, escreva a chamada de função com o operador ``*`` para desempacotá-los\n"
"da sequência::"
#: ../../tutorial/controlflow.rst:575
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
"Da mesma forma, dicionários podem produzir argumentos nomeados com o "
"operador ``**``::"
#: ../../tutorial/controlflow.rst:591
msgid "Lambda Expressions"
msgstr "Expressões lambda"
#: ../../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 scope::"
"Pequenas funções anônimas podem ser criadas com a palavra-chave "
":keyword:`lambda`. Esta função retorna a soma de seus dois argumentos: "
"``lambda a, b: a+b``. As funções Lambda podem ser usadas sempre que objetos "
"função forem necessários. Eles são sintaticamente restritos a uma única "
"expressão. Semanticamente, eles são apenas açúcar sintático para uma "
"definição de função normal. Como definições de funções aninhadas, as funções"
" lambda podem referenciar variáveis contidas no escopo::"
#: ../../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::"
"O exemplo acima usa uma expressão lambda para retornar uma função. Outro uso"
" é passar uma pequena função como um argumento::"
#: ../../tutorial/controlflow.rst:622
msgid "Documentation Strings"
msgstr "Strings de documentação"
#: ../../tutorial/controlflow.rst:629
"Here are some conventions about the content and formatting of documentation "
"Aqui estão algumas convenções sobre o conteúdo e formatação de strings de "
"documentação."
#: ../../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."
"A primeira linha deve sempre ser curta, um resumo conciso do propósito do "
"objeto. Por brevidade, não deve explicitamente se referir ao nome ou tipo do"
" objeto, uma vez que estas informações estão disponíveis por outros meios "
"(exceto se o nome da função for o próprio verbo que descreve a finalidade da"
" função). Essa linha deve começar com letra maiúscula e terminar com ponto."
#: ../../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."
"Se existem mais linhas na string de documentação, a segunda linha deve estar"
" em branco, separando visualmente o resumo do resto da descrição. As linhas "
"seguintes devem conter um ou mais parágrafos descrevendo as convenções de "
"chamada ao objeto, seus efeitos colaterais, etc."
#: ../../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)."
"O analisador Python não remove a indentação de literais string multi-linha. "
"Portanto, ferramentas que processem strings de documentação precisam lidar "
"com isso, quando desejável. Existe uma convenção para isso. A primeira linha"
" não vazia após a linha de sumário determina a indentação para o resto da "
"string de documentação. (Não podemos usar a primeira linha para isso porque "
"ela em geral está adjacente às aspas que iniciam a string, portanto sua "
"indentação real não fica aparente.) Espaços em branco \"equivalentes\" a "
"essa indentação são então removidos do início das demais linhas da string. "
"Linhas com indentação menor não devem ocorrer, mas se ocorrerem, todos os "
"espaços à sua esquerda são removidos. A equivalência de espaços em branco "
"deve ser testada após a expansão das tabulações (8 espaços, normalmente)."
#: ../../tutorial/controlflow.rst:655
msgid "Here is an example of a multi-line docstring::"
msgstr "Eis um exemplo de uma docstring multi-linha::"
#: ../../tutorial/controlflow.rst:673
msgid "Function Annotations"
msgstr "Anotações de Função"
#: ../../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)."
":ref:`Function annotations <function>` são informações metadados "
"completamente opcionais sobre os tipos usados pels funções definidas pelo "
"usuário (veja :pep:`3107` e :pep:`484` para mais informações)."
#: ../../tutorial/controlflow.rst:685
"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::"
"As anotações são armazenadas no atributo :attr:`__annotations__` da função "
"como um dicionário e não possuem efeito em nenhuma outra parte da função. As"
" anotações dos parâmetros são definidas por dois pontos após o nome do "
"parâmetro, seguido de uma expressão que avalia o valor da anotação. As "
"anotações de retorno são definidas por um literal ``->``, seguido por uma "
"expressão, entre a lista de parâmetros e o cólon indicando o fim da "
"declaração :keyword:`def`. O exemplo a seguir possui um argumento "
"posicional, um keyword argument e o valor de retorno anotado::"
#: ../../tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
msgstr "Intermezzo: estilo de codificação"
#: ../../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."
"Agora que está prestes a escrever códigos mais longos e complexos em Python,"
" é um bom momento para falar sobre *estilo de codificação*. A maioria das "
"linguagens podem ser escritas (ou *formatadas*) em diferentes estilos; "
"alguns são mais legíveis do que outros. Tornar o seu código mais fácil de "
"ler, para os outros, é sempre uma boa ideia, e adotar um estilo de "
"codificação agradável ajuda bastante."
#: ../../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:"
"Em Python, o :pep:`8` tornou-se o guia de estilo adotado pela maioria dos "
"projetos; promove um estilo de codificação muito legível e visualmente "
"agradável. Todo desenvolvedor Python deve lê-lo em algum momento; eis os "
"pontos mais importantes, selecionados para você:"
#: ../../tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
msgstr "Use indentação com 4 espaços, e não use tabulações."
#: ../../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."
" 4 espaços são um bom meio termo entre indentação estreita (permite maior "
"profundidade de aninhamento) e indentação larga (mais fácil de ler). "
"Tabulações trazem complicações, e o melhor é não usar."
#: ../../tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "Quebre as linhas de modo que não excedam 79 caracteres."
#: ../../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."
"Isso ajuda os usuários com telas pequenas e torna possível abrir vários "
"arquivos de código lado a lado em telas maiores."
#: ../../tutorial/controlflow.rst:734
"Use blank lines to separate functions and classes, and larger blocks of code"
" inside functions."
"Deixe linhas em branco para separar funções e classes, e blocos de código "
"dentro de funções."
#: ../../tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
msgstr "Quando possível, coloque comentários em uma linha própria."
#: ../../tutorial/controlflow.rst:739
msgid "Use docstrings."
msgstr "Escreva strings de documentação."
#: ../../tutorial/controlflow.rst:741
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
"Use espaços ao redor de operadores e após vírgulas, mas não diretamente "
"dentro de parênteses, colchetes e chaves: ``a = f(1, 2) + g(3, 4)``."
#: ../../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)."
"* Nomeie suas classes e funções de modo consistente; a convenção é usar\n"
" ``CamelCase`` (literalmente, *CaixaCamelo*) para classes e\n"
" ``caixa_baixa_com_underscores`` para funções e métodos. Sempre use ``self``\n"
" como nome do primeiro parâmetro formal dos métodos de instância (veja\n"
" :ref:`tut-firstclasses` para saber mais sobre classes e métodos)."
#: ../../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"
"Não use codificações exóticas se o seu código é feito para ser usado em um "
"contexto internacional. O padrão do Python, UTF-8, ou mesmo ASCII puro "
"funciona bem em qualquer caso."
#: ../../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."
"Da mesma forma, não use caracteres não-ASCII em identificadores se houver "
"apenas a menor chance de pessoas falando um idioma diferente ler ou manter o"
#: ../../tutorial/controlflow.rst:759
msgid "Footnotes"
msgstr "Notas de rodapé"
#: ../../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)."
"[#] Na verdade, *passagem por referência para objeto* seria uma descrição "
"melhor, pois, se um objeto mutável for passado, quem chamou verá as "
"alterações feitas por quem foi chamado (por exemplo, a inclusão de itens em "
"uma lista)."
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
