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

829 lines (742 loc) · 38.5 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2017
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2017
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:46+0900\n"
"PO-Revision-Date: 2019-09-26 01:29+0000\n"
"Last-Translator: Adorilson Bezerra <adorilson@gmail.com>\n"
"Language-Team: Portuguese (Brazil) (http://www.transifex.com/python-doc/python-27/language/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 uses the "
"usual flow control 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 "
"particulares."
#: ../../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:49
"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 "
"acostumado em C ou Pascal. Ao invés de se iterar sobre progressões "
"aritméticas (como em Pascal), ou dar ao usuário o poder de definir tanto o "
"passo da iteração quanto a condição de parada (como em C), o comando "
":keyword:`for` de Python itera sobre os itens de qualquer sequência (como "
"uma lista ou uma string), na ordem em que eles aparecem na sequência. Por "
#: ../../tutorial/controlflow.rst:70
"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::"
"Não é seguro modificar a sequência sobre a qual se baseia o laço de iteração\n"
"(isto pode acontecer se a sequência for mutável, isto é, uma lista). Se \n"
"precisar modificar a lista sobre a qual está iterando (por exemplo, para\n"
"duplicar itens selecionados), é preciso iterar sobre uma cópia da lista ao\n"
"invés da própria. A notação de fatiamento é bastante conveniente para isso:"
#: ../../tutorial/controlflow.rst:86
msgid "The :func:`range` Function"
msgstr "A função :func:`range`"
#: ../../tutorial/controlflow.rst:88
"If you do need to iterate over a sequence of numbers, the built-in function "
":func:`range` comes in handy.  It generates lists containing arithmetic "
"progressions::"
"Se você precisar iterar sobre sequências numéricas, a função embutida "
":func:`range` é a resposta. Ela gera listas contendo progressões "
"aritméticas, por exemplo::"
#: ../../tutorial/controlflow.rst:95
"The given end point is never part of the generated list; ``range(10)`` "
"generates a list of 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:107
"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:120
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
"Na maioria dos casos como este, porém, é mais conveniente usar a função "
":func:`enumerate`, veja :ref:`tut-loopidioms`."
#: ../../tutorial/controlflow.rst:127
":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:129
"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:132
"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 "
"encerra por exaustão da lista (no caso do :keyword:`for`) ou quando a "
"condição se torna falsa (no caso do :keyword:`while`), mas nunca quando o "
"laço é interrompido por um :keyword:`break`. Isto é exemplificado no próximo"
" exemplo que procura números primos::"
#: ../../tutorial/controlflow.rst:156
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
"(Sim, este é o código correto. Olhe atentamente: a cláusula ``else`` "
"pertence ao laço :keyword:`for`, e **não** ao comando :keyword:`if`.)"
#: ../../tutorial/controlflow.rst:159
"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:166
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
"A declaração :keyword:`continue`, também emprestada da linguagem C, continua"
" com a próxima iteração do loop::"
#: ../../tutorial/controlflow.rst:187
msgid ":keyword:`pass` Statements"
msgstr "Comando :keyword:`pass`"
#: ../../tutorial/controlflow.rst:189
"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:196
msgid "This is commonly used for creating minimal classes::"
msgstr "Isto é usado muitas vezes para se definir classes mínimas::"
#: ../../tutorial/controlflow.rst:202
"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:213
msgid "Defining Functions"
msgstr "Definindo Funções"
#: ../../tutorial/controlflow.rst:215
"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:234
"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:239
"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 lógica do corpo da função pode ser uma string\n"
"literal, cujo propósito é documentar a função. Se presente, essa string\n"
"chama-se :dfn:`docstring`. (Há mais informação sobre docstrings na seção\n"
":ref:`tut-docstrings`.) Existem ferramentas que utilizam docstrings para\n"
"produzir automaticamente documentação online ou para imprimir, ou ainda\n"
"permitir que o usuário navegue interativamente pelo código. É uma boa prática\n"
"incluir sempre docstrings em suas funções, portanto, tente fazer disto um\n"
#: ../../tutorial/controlflow.rst:246
"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:255
"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\n"
"tabela de símbolos local da função no momento da invocação, portanto,\n"
"argumentos são passados por valor (onde o *valor* é sempre uma referência para\n"
"objeto, não o valor do objeto). [#]_ Quando uma função invoca outra, uma nova\n"
"tabela de símbolos é criada para tal chamada."
#: ../../tutorial/controlflow.rst:261
"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.\n"
"O valor associado ao nome da função tem um tipo que é reconhecido pelo\n"
"interpretador como uma função definida pelo usuário. Esse valor pode ser\n"
"atribuído a outros nomes que também podem ser usados como funções. Esse\n"
"mecanismo serve para renomear funções::"
#: ../../tutorial/controlflow.rst:273
"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 "
":keyword:`print`::"
"Conhecendo outras linguagens, pode-se questionar que ``fib`` não é uma\n"
"função, mas um procedimento, pois ela não devolve um valor. Na verdade, mesmo\n"
"funções que não usam o comando :keyword:`return` devolvem um valor, ainda que\n"
"pouco interessante. Esse valor é chamado ``None`` (é um nome embutido). O\n"
"interpretador interativo evita escrever ``None`` quando ele é o único\n"
"resultado de uma expressão. Mas se quiser vê-lo pode usar o comando\n"
":keyword:`print`::"
#: ../../tutorial/controlflow.rst:284
"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 série de\n"
"Fibonacci, ao invés de exibi-los:"
#: ../../tutorial/controlflow.rst:300
msgid "This example, as usual, demonstrates some new Python features:"
"É fácil escrever uma função que devolve uma lista de números série de\n"
"Fibonacci, ao invés de exibi-los:"
#: ../../tutorial/controlflow.rst:302
"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:306
"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."
"* O trecho ``resultado.append(a)`` invoca um *método* do objeto lista\n"
" ``resultado``. Um método é uma função que \"pertence\" a um objeto e é chamada\n"
" através de ``obj.nome_do_metodo`` onde ``obj`` é um objeto qualquer (pode\n"
" ser uma expressão), e ``nome_do_metodo`` é o nome de um método que foi\n"
" definido pelo tipo do objeto. Tipos diferentes definem métodos diferentes.\n"
" Métodos de diferentes tipos podem ter o mesmo nome sem ambiguidade. (É\n"
" possível definir seus próprios tipos de objetos e métodos, utilizando\n"
" *classes*, veja em :ref:`tut-classes`)\n"
" O método :meth:`append` mostrado no exemplo é definido para objetos do\n"
" tipo lista; ele adiciona um novo elemento ao final da lista. Neste exemplo,\n"
" ele equivale a ``resultado = resultado + [a]``, só que mais eficiente."
#: ../../tutorial/controlflow.rst:321
msgid "More on Defining Functions"
msgstr "Mais sobre definição de funções"
#: ../../tutorial/controlflow.rst:323
"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\n"
"formas, que podem ser combinadas."
#: ../../tutorial/controlflow.rst:330
msgid "Default Argument Values"
msgstr "Parâmetros com valores default"
#: ../../tutorial/controlflow.rst:332
"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 default para um ou mais parâmetros\n"
"formais. Isso cria uma função que pode ser invocada com um número menor de\n"
"argumentos do que ela pode receber. Por exemplo::"
#: ../../tutorial/controlflow.rst:348
msgid "This function can be called in several ways:"
msgstr "Essa função pode ser invocada de várias formas:"
#: ../../tutorial/controlflow.rst:350
"giving only the mandatory argument: ``ask_ok('Do you really want to "
"quit?')``"
"* fornecendo apenas o argumento obrigatório:\n"
" ``confirmar('Deseja mesmo encerrar?')``"
#: ../../tutorial/controlflow.rst:352
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"* fornecendo um dos argumentos opcionais:\n"
" ``confirmar('Sobrescrever o arquivo?', 2)``"
#: ../../tutorial/controlflow.rst:354
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come"
" on, only yes or no!')``"
"* ou fornecendo todos os argumentos:\n"
" ``confirmar('Sobrescrever o arquivo?', 2, 'Escolha apenas s ou n')``"
#: ../../tutorial/controlflow.rst:357
"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\n"
"sequência contém ou não um determinado valor."
#: ../../tutorial/controlflow.rst:360
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
"Os valores default são avaliados no momento a definição da função, e no escopo\n"
"em que a função foi *definida*, portanto::"
#: ../../tutorial/controlflow.rst:371
msgid "will print ``5``."
msgstr "irá exibir ``5``."
#: ../../tutorial/controlflow.rst:373
"**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 default são avaliados apenas uma vez. Isso faz\n"
"diferença quando o valor default é um objeto mutável como uma lista ou\n"
"dicionário (N.d.T. dicionários são como arrays associativos ou HashMaps em outras linguagens; ver :ref:`tut-dictionaries`)."
#: ../../tutorial/controlflow.rst:386
msgid "This will print ::"
msgstr "Isso imprimirá ::"
#: ../../tutorial/controlflow.rst:392
"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 default seja compartilhado entre chamadas\n"
"subsequentes, pode reescrever a função assim::"
#: ../../tutorial/controlflow.rst:405
msgid "Keyword Arguments"
msgstr "Argumentos nomeados"
#: ../../tutorial/controlflow.rst:407
"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 passando :term:`keyword arguments <keyword\n"
"argument>` (argumentos nomeados) no formato ``chave=valor``. Por exemplo, a\n"
"seguinte função::"
#: ../../tutorial/controlflow.rst:416
"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\n"
"(``state``, ``action``, e ``type``). Esta função pode ser invocada de todas\n"
"estas formas::"
#: ../../tutorial/controlflow.rst:427
msgid "but all the following calls would be invalid::"
msgstr "mas todas as invocações a seguir seriam inválidas::"
#: ../../tutorial/controlflow.rst:434
"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::"
"Em uma invocação, argumentos nomeados devem vir depois dos argumentos\n"
"posicionais. Todos os argumentos nomeados passados devem casar com os\n"
"parâmetros formais definidos pela função (ex. ``actor`` não é um argumento\n"
"nomeado válido para a função ``parrot``), mas sua ordem é irrelevante. Isto\n"
"também inclui argumentos obrigatórios (ex.: ``parrot(voltage=1000)``\n"
"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:450
"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:468
msgid "It could be called like this::"
msgstr "Ela pode ser invocada assim::"
#: ../../tutorial/controlflow.rst:476
msgid "and of course it would print:"
msgstr "e, claro, imprimiria:"
#: ../../tutorial/controlflow.rst:489
"Note that the list of keyword argument names is created by sorting the "
"result of the keywords dictionary's ``keys()`` method before printing its "
"contents; if this is not done, the order in which the arguments are printed "
"is undefined."
#: ../../tutorial/controlflow.rst:496
msgid "Arbitrary Argument Lists"
msgstr "Listas arbitrárias de argumentos"
#: ../../tutorial/controlflow.rst:501
"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 possibilita que função seja invocada com um\n"
"número arbitrário de argumentos. Esses argumentos serão empacotados em uma\n"
"tupla (ver :ref:`tut-tuples`). Antes dos argumentos em número variável, zero\n"
"ou mais argumentos normais podem estar presentes. ::"
#: ../../tutorial/controlflow.rst:513
msgid "Unpacking Argument Lists"
msgstr "Desempacotando listas de argumentos"
#: ../../tutorial/controlflow.rst:515
"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:531
"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:547
msgid "Lambda Expressions"
msgstr "Construções lambda"
#: ../../tutorial/controlflow.rst:549
"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 Lambdas podem ser usadas sempre que os "
"objetos de função forem necessários. Eles são sintaticamente restritos a uma"
" única expressão. Semanticamente, eles são apenas açúcar sintáticos para uma"
" definição de função normal. Como definições de funções aninhadas, as "
"funções lambda podem referenciar variáveis do contidas no escopo::"
#: ../../tutorial/controlflow.rst:566
"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:578
msgid "Documentation Strings"
msgstr "Strings de documentação"
#: ../../tutorial/controlflow.rst:585
"There are emerging conventions about the content and formatting of "
"documentation strings."
"A comunidade Python está convencionando o conteúdo e o formato de strings de"
" documentação (*docstrings*)."
#: ../../tutorial/controlflow.rst:588
"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 ser um resumo curto e conciso do propósito do objeto.\n"
"Por brevidade, não deve explicitamente se referir ao nome ou tipo do objeto,\n"
"uma vez que estas informações estão disponíveis por outros meios (exceto se o\n"
"nome da função for o próprio verbo que descreve a finalidade da função). Essa\n"
"linha deve começar com letra maiúscula e terminar com ponto."
#: ../../tutorial/controlflow.rst:594
"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\n"
"estar em branco, separando visualmente o resumo do resto da descrição. As\n"
"linhas seguintes devem conter um ou mais parágrafos descrevendo as convenções\n"
"de chamada ao objeto, seus efeitos colaterais, etc."
#: ../../tutorial/controlflow.rst:599
"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 parser do Python não remove a indentação de comentários multi-linha.\n"
"Portanto, ferramentas que processem strings de documentação precisam lidar com\n"
"isso, quando desejável. Existe uma convenção para isso. A primeira linha não\n"
"vazia após a linha de sumário determina a indentação para o resto da string\n"
"de documentação. (Não podemos usar a primeira linha para isso porque ela em\n"
"geral está adjacente às aspas que iniciam a string, portanto sua indentação\n"
"real não fica aparente.) Espaços em branco ou tabs \"equivalentes\" a esta\n"
"indentação são então removidos do início das demais linhas da string. Linhas\n"
"indentação menor não devem ocorrer, mas se ocorrerem, todos os espaços à sua\n"
"esquerda são removidos. Para determinar a indentação, normalmente considera-se\n"
"que um caractere tab equivale a 8 espaços."
#: ../../tutorial/controlflow.rst:611
msgid "Here is an example of a multi-line docstring::"
msgstr "Eis um exemplo de uma docstring multi-linha::"
#: ../../tutorial/controlflow.rst:629
msgid "Intermezzo: Coding Style"
msgstr "Intermezzo: estilo de codificação"
#: ../../tutorial/controlflow.rst:634
"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ás prestes a escrever peças mais longas e complexas em\n"
"Python, é uma bom momento para falar sobre *estilo de codificação*. A maioria\n"
"das linguagens podem ser escritas (ou *formatadas*) em diferentes estilos;\n"
"alguns são mais legíveis do que outros. Tornar o seu código mais fácil de ler,\n"
"para os outros, é sempre uma boa ideia, e adotar um estilo de codificação\n"
"agradável ajuda bastante."
#: ../../tutorial/controlflow.rst:640
"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\n"
"projetos; ele promove um estilo de codificação muito legível e visualmente\n"
"agradável. Todo desenvolvedor Python deve lê-lo em algum momento; aqui estão\n"
"os pontos mais importantes selecionados:"
#: ../../tutorial/controlflow.rst:645
msgid "Use 4-space indentation, and no tabs."
msgstr "* Use 4 espaços de recuo, e nenhum tab."
#: ../../tutorial/controlflow.rst:647
"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\n"
" profundidade de aninhamento) e indentação larga (mais fácil de ler). Tabs\n"
" trazem complicações; é melhor não usar."
#: ../../tutorial/controlflow.rst:651
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:653
"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\n"
" arquivos de código lado a lado em telas maiores."
#: ../../tutorial/controlflow.rst:656
"Use blank lines to separate functions and classes, and larger blocks of code"
" inside functions."
"* Deixe linhas em branco para separar as funções e classes, e grandes blocos\n"
" de código dentro de funções."
#: ../../tutorial/controlflow.rst:659
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:661
msgid "Use docstrings."
msgstr "* Escreva docstrings."
#: ../../tutorial/controlflow.rst:663
"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\n"
" dentro de parênteses, colchetes e chaves: ``a = f(1, 2) + g(3, 4)``."
#: ../../tutorial/controlflow.rst:666
"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:671
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Plain ASCII works best in any case."
"* Não use codificações exóticas se o seu código é feito para ser usado em\n"
" um contexto internacional. ASCII puro funciona bem em qualquer caso.\n"
" (N.d.T. para programadores de língua portuguesa, UTF-8 é atualmente a\n"
" melhor opção, e já se tornou o default em Python 3 conforme o\n"
" :pep:`3120`)."
#: ../../tutorial/controlflow.rst:676
msgid "Footnotes"
msgstr "Notas de Rodapé"
#: ../../tutorial/controlflow.rst:677
"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* (*call by object\n"
" reference*) seria uma descrição melhor do que *passagem por valor*\n"
" (*call-by-value*), pois, se um objeto mutável for passado, o invocador\n"
" (*caller*) verá as alterações feitas pelo invocado (*callee*), como\n"
" por exemplo a inserçã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
