# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2021, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Hildeberto Abreu Magalhães <hildeberto@gmail.com>, 2021

# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2021

# Adorilson Bezerra <adorilson@gmail.com>, 2021

# Alexandre B A Villares, 2021

# Rafael Fontenelle <rffontenelle@gmail.com>, 2021

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.10\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2021-06-29 12:56+0000\n"

"PO-Revision-Date: 2021-06-28 01:50+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2021\n"

"Language-Team: Portuguese (Brazil) (https://www.transifex.com/python-doc/"

"teams/5390/pt_BR/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pt_BR\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

msgid ""

"Besides the :keyword:`while` statement just introduced, Python uses the "

"usual flow control statements known from other languages, with some twists."

msgstr ""

"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 "Comandos :keyword:`!if`"

#: ../../tutorial/controlflow.rst:16

msgid ""

"Perhaps the most well-known statement type is the :keyword:`if` statement. "

"For example::"

msgstr ""

"Provavelmente o mais conhecido comando de controle de fluxo é o :keyword:"

"`if`. Por exemplo::"

#: ../../tutorial/controlflow.rst:33

msgid ""

"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "

"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', "

"and is useful to avoid excessive indentation. An :keyword:`!if` ... :"

"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "

"``switch`` or ``case`` statements found in other languages."

msgstr ""

"Pode haver zero ou mais partes :keyword:`elif`, e a parte :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 os comandos "

"``switch`` ou ``case``, encontrados em outras linguagens."

#: ../../tutorial/controlflow.rst:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"Se você está comparando o mesmo valor com várias constantes, ou verificando "

"por tipos ou atributos específicos, você também pode achar a instrução :"

"keyword:`!match` útil. Para mais detalhes veja :ref:`tut-match`."

#: ../../tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr "Comandos :keyword:`!for`"

#: ../../tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"progression of numbers (like in Pascal), or giving the user the ability to "

"define both the iteration step and halting condition (as C), Python's :"

"keyword:`!for` statement iterates over the items of any sequence (a list or "

"a string), in the order that they appear in the sequence. For example (no "

"pun intended):"

msgstr ""

"O comando :keyword:`for` em Python é um pouco diferente do que costuma ser "

"em C ou Pascal. Ao invés de sempre iterar sobre uma progressão aritmética de "

"números (como no Pascal), ou permitir ao usuário definir o passo de iteração "

"e a condição de parada (como C), o comando :keyword:`!for` do Python itera "

"sobre os itens de qualquer sequência (seja uma lista ou uma string), na "

"ordem que aparecem na sequência. Por exemplo:"

#: ../../tutorial/controlflow.rst:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to "

"loop over a copy of the collection or to create a new collection::"

msgstr ""

"Código que modifica uma coleção sobre a qual está iterando pode ser "

"inseguro. No lugar disso, usualmente você deve iterar sobre uma cópia da "

"coleção ou criar uma nova coleção::"

#: ../../tutorial/controlflow.rst:94

msgid "The :func:`range` Function"

msgstr "A função :func:`range`"

#: ../../tutorial/controlflow.rst:96

msgid ""

"If you do need to iterate over a sequence of numbers, the built-in function :"

"func:`range` comes in handy. It generates arithmetic progressions::"

msgstr ""

"Se você precisa iterar sobre sequências numéricas, a função embutida :func:"

"`range` é a resposta. Ela gera progressões aritméticas::"

#: ../../tutorial/controlflow.rst:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length "

"10. It is possible to let the range start at another number, or to specify "

"a different increment (even negative; sometimes this is called the 'step')::"

msgstr ""

"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 com outro número, ou "

"alterar a razão da progressão (inclusive com passo negativo)::"

#: ../../tutorial/controlflow.rst:122

msgid ""

"To iterate over the indices of a sequence, you can combine :func:`range` "

"and :func:`len` as follows::"

msgstr ""

"Para iterar sobre os índices de uma sequência, combine :func:`range` e :func:"

"`len` da seguinte forma::"

#: ../../tutorial/controlflow.rst:135

msgid ""

"In most such cases, however, it is convenient to use the :func:`enumerate` "

"function, see :ref:`tut-loopidioms`."

msgstr ""

"Na maioria dos casos, porém, é mais conveniente usar a função :func:"

"`enumerate`, veja :ref:`tut-loopidioms`."

#: ../../tutorial/controlflow.rst:138

msgid "A strange thing happens if you just print a range::"

msgstr "Uma coisa estranha acontece se você imprime um intervalo::"

#: ../../tutorial/controlflow.rst:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

msgstr ""

"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:148

msgid ""

"We say such an object is :term:`iterable`, that is, suitable as a target for "

"functions and constructs that expect something from which they can obtain "

"successive items until the supply is exhausted. We have seen that the :"

"keyword:`for` statement is such a construct, while an example of a function "

"that takes an iterable is :func:`sum`::"

msgstr ""

"Dizemos que um objeto é :term:`iterável<iterable>`, isso é, candidato a ser "

"alvo de uma função ou construção que espera alguma coisa capaz de retornar "

"sucessivamente seus elementos um de cada vez. Nós vimos que o comando :"

"keyword:`for` é um exemplo de construção, enquanto que um exemplo de função "

"que recebe um iterável é :func:`sum`::"

#: ../../tutorial/controlflow.rst:157

msgid ""

"Later we will see more functions that return iterables and take iterables as "

"arguments. In chapter :ref:`tut-structures`, we will discuss in more detail "

"about :func:`list`."

msgstr ""

"Mais tarde, veremos mais funções que retornam iteráveis e tomam iteráveis "

"como argumentos. No capítulo :ref:`tut-structures`, iremos discutir em mais "

"detalhes sobre :func:`list`."

#: ../../tutorial/controlflow.rst:164

msgid ""

":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "

"Clauses on Loops"

msgstr ""

"Comandos :keyword:`!break` e :keyword:`!continue`, e cláusula :keyword:`!"

"else`, nos laços de repetição"

#: ../../tutorial/controlflow.rst:166

msgid ""

"The :keyword:`break` statement, like in C, breaks out of the innermost "

"enclosing :keyword:`for` or :keyword:`while` loop."

msgstr ""

"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:169

msgid ""

"Loop statements may have an :keyword:`!else` clause; it is executed when the "

"loop terminates through exhaustion of the iterable (with :keyword:`for`) or "

"when the condition becomes false (with :keyword:`while`), but not when the "

"loop is terminated by a :keyword:`break` statement. This is exemplified by "

"the following loop, which searches for prime numbers::"

msgstr ""

"Laços podem ter uma cláusula :keyword:`!else`, que é executada sempre que o "

"laço se encerra por exaustão do iterável (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:193

msgid ""

"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "

"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"

msgstr ""

"(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:196

msgid ""

"When used with a loop, the ``else`` clause has more in common with the "

"``else`` clause of a :keyword:`try` statement than it does with that of :"

"keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs "

"when no exception occurs, and a loop's ``else`` clause runs when no "

"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, "

"see :ref:`tut-handling`."

msgstr ""

"Quando usado em um laço, a cláusula ``else`` tem mais em comum com a "

"cláusula ``else`` de um comando :keyword:`try` do que com a de um comando :"

"keyword:`if`: a cláusula ``else`` de um comando :keyword:`try` executa "

"quando não ocorre exceção, e o ``else`` de um laço executa quando não ocorre "

"um ``break``. Para mais informações sobre comando :keyword:`!try` e "

"exceções, veja :ref:`tut-handling`."

#: ../../tutorial/controlflow.rst:203

msgid ""

"The :keyword:`continue` statement, also borrowed from C, continues with the "

"next iteration of the loop::"

msgstr ""

"A instrução :keyword:`continue`, também emprestada da linguagem C, continua "

"com a próxima iteração do laço::"

#: ../../tutorial/controlflow.rst:224

msgid ":keyword:`!pass` Statements"

msgstr "Comandos :keyword:`!pass`"

#: ../../tutorial/controlflow.rst:226

msgid ""

"The :keyword:`pass` statement does nothing. It can be used when a statement "

"is required syntactically but the program requires no action. For example::"

msgstr ""

"O comando :keyword:`pass` não faz nada. 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:233

msgid "This is commonly used for creating minimal classes::"

msgstr "Isto é usado muitas vezes para se definir classes mínimas::"

#: ../../tutorial/controlflow.rst:239

msgid ""

"Another place :keyword:`pass` can be used is as a place-holder for a "

"function or conditional body when you are working on new code, allowing you "

"to keep thinking at a more abstract level. The :keyword:`!pass` is silently "

"ignored::"

msgstr ""

"Outra ocasião em que o :keyword:`pass` pode ser usado é como um substituto "

"temporário para uma função ou bloco condicional, quando se está trabalhando "

"com código novo, ainda indefinido, permitindo que mantenha-se o pensamento "

"num nível mais abstrato. O :keyword:`!pass` é silenciosamente ignorado::"

#: ../../tutorial/controlflow.rst:251

msgid ":keyword:`!match` Statements"

msgstr "Instruções :keyword:`!match`"

#: ../../tutorial/controlflow.rst:253

msgid ""

"A match statement takes an expression and compares its value to successive "

"patterns given as one or more case blocks. This is superficially similar to "

"a switch statement in C, Java or JavaScript (and many other languages), but "

"it can also extract components (sequence elements or object attributes) from "

"the value into variables."

msgstr ""

"Uma instrução de correspondência pega uma expressão e compara seu valor com "

"padrões sucessivos fornecidos como um ou mais blocos de case. Isso é "

"superficialmente semelhante a uma instrução switch em C, Java ou JavaScript "

"(e muitas outras linguagens), mas também pode extrair componentes (elementos "

"de sequência ou atributos de objeto) do valor em variáveis."

#: ../../tutorial/controlflow.rst:259

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr ""

"A forma mais simples compara um valor de assunto com um ou mais literais::"

#: ../../tutorial/controlflow.rst:272

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match. If no case matches, none of the branches is executed."

msgstr ""

"Observe o último bloco: o \"nome da variável\" ``_`` atua como um *curinga* "

"e nunca falha em corresponder. Se nenhum caso corresponder, nenhuma das "

"ramificações será executada."

#: ../../tutorial/controlflow.rst:275

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr ""

"Você pode combinar vários literais em um único padrão usando ``|`` (\"ou\")::"

#: ../../tutorial/controlflow.rst:280

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr ""

"Os padrões podem se parecer com atribuições de desempacotamento e podem ser "

"usados para vincular variáveis::"

#: ../../tutorial/controlflow.rst:296

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next "

"two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values, "

"which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"Estude isso com cuidado! O primeiro padrão tem dois literais e pode ser "

"considerado uma extensão do padrão literal mostrado acima. Mas os próximos "

"dois padrões combinam um literal e uma variável, e a variável *vincula* um "

"valor do assunto (``point``). O quarto padrão captura dois valores, o que o "

"torna conceitualmente semelhante à atribuição de desempacotamento ``(x, y) = "

"point``."

#: ../../tutorial/controlflow.rst:303

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr ""

"Se você estiver usando classes para estruturar seus dados, você pode usar o "

"nome da classe seguido por uma lista de argumentos semelhante a um "

"construtor, mas com a capacidade de capturar atributos em variáveis::"

#: ../../tutorial/controlflow.rst:324

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "

"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"Você pode usar parâmetros posicionais com algumas classes embutidas que "

"fornecem uma ordem para seus atributos (por exemplo, classes de dados). Você "

"também pode definir uma posição específica para atributos em padrões "

"configurando o atributo especial ``__match_args__`` em suas classes. Se for "

"definido como (\"x\", \"y\"), os seguintes padrões são todos equivalentes (e "

"todos vinculam o atributo ``y`` à variável ``var``)::"

#: ../../tutorial/controlflow.rst:335

msgid ""

"A recommended way to read patterns is to look at them as an extended form of "

"what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like ``foo."

"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"Uma maneira recomendada de ler padrões é vê-los como uma forma estendida do "

"que você colocaria à esquerda de uma atribuição, para entender quais "

"variáveis seriam definidas para quê. Apenas os nomes autônomos (como ``var`` "

"acima) são atribuídos por uma instrução de correspondência. Nomes "

"pontilhados (como ``foo.bar``), nomes de atributos (o ``x=`` e ``y=`` acima) "

"ou nomes de classes (reconhecidos pelo \"(...)\" próximo a eles, como "

"``Point`` acima) nunca são atribuídos."

#: ../../tutorial/controlflow.rst:342

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of "

"points, we could match it like this::"

msgstr ""

"Os padrões podem ser aninhados arbitrariamente. Por exemplo, se tivermos uma "

"pequena lista de pontos, poderíamos correspondê-la assim::"

#: ../../tutorial/controlflow.rst:357

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"Podemos adicionar uma cláusula ``if`` a um padrão, conhecido como \"guarda"

"\". Se a guarda for falsa, ``match`` continua para tentar o próximo bloco de "

"caso. Observe que a captura de valor ocorre antes que a guarda seja "

"avaliada::"

#: ../../tutorial/controlflow.rst:367

msgid "Several other key features of this statement:"

msgstr "Vários outros recursos importantes desta instrução::"

#: ../../tutorial/controlflow.rst:369

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr ""

"Assim como desempacotar atribuições, os padrões de tupla e lista têm "

"exatamente o mesmo significado e realmente correspondem a sequências "

"arbitrárias. Uma exceção importante é que eles não correspondem a iteradores "

"ou strings."

#: ../../tutorial/controlflow.rst:373

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "

"*rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"Os padrões de sequência têm suporte ao desempacotamento estendido: ``[x, y, "

"*rest]`` e ``(x, y, *rest)`` funcionam de forma semelhante ao "

"desempacotamento de atribuições. O nome depois de ``*`` também pode ser "

"``_``, então ``(x, y, *_)`` corresponde a uma sequência de pelo menos dois "

"itens sem ligar os itens restantes."

#: ../../tutorial/controlflow.rst:378

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the ``"

"\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it not allowed.)"

msgstr ""

"Padrões de mapeamento: ``{\"bandwidth\": b, \"latency\": l}`` captura os "

"valores ``\"bandwidth\"`` e ``\"latency\"`` de um dicionário. Diferente dos "

"padrões de sequência, chaves extra são ignoradas. Um desempacotamento como "

"``**rest`` também é permitido. (Mas ``**_`` seria redundante, então não é "

"permitido.)"

#: ../../tutorial/controlflow.rst:383

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "Subpadrões podem ser capturados usando a palavra reservada ``as``::"

#: ../../tutorial/controlflow.rst:387

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input "

"is a sequence of two points)"

msgstr ""

"Vai capturar o segundo elemento da entrada como ``p2`` (se a entrada for uma "

"sequência de dois pontos)"

#: ../../tutorial/controlflow.rst:390

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr ""

"A maioria dos literais são comparados por igualdade, no entando os "

"singletons ``True``, ``False`` e ``None`` são comparados por identidade."

#: ../../tutorial/controlflow.rst:393

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variable::"

msgstr ""

"Padrões podem usar constantes nomeadas. Estas devem ser nomes pontilhados "

"para prevenir que sejam interpretadas como variáveis de captura::"

#: ../../tutorial/controlflow.rst:410

msgid ""

"For a more detailed explanation and additional examples, you can look into :"

"pep:`636` which is written in a tutorial format."

msgstr ""

"Para uma explicação mais detalhada e exemplos adicionais, você pode olhar :"

"pep:`636` que foi escrita em formato de tutorial."

#: ../../tutorial/controlflow.rst:416

msgid "Defining Functions"

msgstr "Definindo funções"

#: ../../tutorial/controlflow.rst:418

msgid ""

"We can create a function that writes the Fibonacci series to an arbitrary "

"boundary::"

msgstr ""

"Podemos criar uma função que escreve a série de Fibonacci até um limite "

"arbitrário::"

#: ../../tutorial/controlflow.rst:438

msgid ""

"The keyword :keyword:`def` introduces a function *definition*. It must be "

"followed by the function name and the parenthesized list of formal "

"parameters. The statements that form the body of the function start at the "

"next line, and must be indented."

msgstr ""

"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:443

msgid ""

"The first statement of the function body can optionally be a string literal; "

"this string literal is the function's documentation string, or :dfn:"

"`docstring`. (More about docstrings can be found in the section :ref:`tut-"

"docstrings`.) There are tools which use docstrings to automatically produce "

"online or printed documentation, or to let the user interactively browse "

"through code; it's good practice to include docstrings in code that you "

"write, so make a habit of it."

msgstr ""

"Opcionalmente, a primeira linha do corpo da função pode ser uma literal "

"string, 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:450

msgid ""

"The *execution* of a function introduces a new symbol table used for the "

"local variables of the function. More precisely, all variable assignments "

"in a function store the value in the local symbol table; whereas variable "

"references first look in the local symbol table, then in the local symbol "

"tables of enclosing functions, then in the global symbol table, and finally "

"in the table of built-in names. Thus, global variables and variables of "

"enclosing functions cannot be directly assigned a value within a function "

"(unless, for global variables, named in a :keyword:`global` statement, or, "

"for variables of enclosing functions, named in a :keyword:`nonlocal` "

"statement), although they may be referenced."

msgstr ""

"A *execução* de uma função cria uma nova tabela de símbolos para as "

"variáveis locais da função. Mais precisamente, todas as atribuições de "

"variáveis numa função são armazenadas na tabela de símbolos local; "

"referências a variáveis são buscadas primeiro na tabela de símbolos local, "

"em seguida na tabela de símbolos locais de funções delimitadoras ou "

"circundantes, depois na tabela de símbolos global e, finalmente, na tabela "

"de nomes da própria linguagem. Embora possam ser referenciadas, variáveis "

"globais e de funções externas não podem ter atribuições (a menos que seja "

"utilizado o comando :keyword:`global`, para variáveis globais, ou :keyword:"

"`nonlocal`, para variáveis de funções externas)."

#: ../../tutorial/controlflow.rst:461

msgid ""

"The actual parameters (arguments) to a function call are introduced in the "

"local symbol table of the called function when it is called; thus, arguments "

"are passed using *call by value* (where the *value* is always an object "

"*reference*, not the value of the object). [#]_ When a function calls "

"another function, or calls itself recursively, a new local symbol table is "

"created for that call."

msgstr ""

"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, ou chama a si mesma recursivamente, uma nova tabela de "

"símbolos é criada para tal chamada."

#: ../../tutorial/controlflow.rst:468

msgid ""

"A function definition associates the function name with the function object "

"in the current symbol table. The interpreter recognizes the object pointed "

"to by that name as a user-defined function. Other names can also point to "

"that same function object and can also be used to access the function::"

msgstr ""

"Uma definição de função associa o nome da função com o objeto função na "

"tabela de símbolos atual. O interpretador reconhece o objeto apontado pelo "

"nome como uma função definida pelo usuário. Outros nomes também podem "

"apontar para o mesmo objeto função e também pode ser usados pra acessar a "

"função::"

#: ../../tutorial/controlflow.rst:479

msgid ""

"Coming from other languages, you might object that ``fib`` is not a function "

"but a procedure since it doesn't return a value. In fact, even functions "

"without a :keyword:`return` statement do return a value, albeit a rather "

"boring one. This value is called ``None`` (it's a built-in name). Writing "

"the value ``None`` is normally suppressed by the interpreter if it would be "

"the only value written. You can see it if you really want to using :func:"

"`print`::"

msgstr ""

"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 a função :"

"func:`print`::"

#: ../../tutorial/controlflow.rst:490

msgid ""

"It is simple to write a function that returns a list of the numbers of the "

"Fibonacci series, instead of printing it::"

msgstr ""

"É fácil escrever uma função que retorna uma lista de números da série de "

"Fibonacci, ao invés de exibi-los::"

#: ../../tutorial/controlflow.rst:506

msgid "This example, as usual, demonstrates some new Python features:"

msgstr "Este exemplo demonstra novos recursos de Python:"

#: ../../tutorial/controlflow.rst:508

msgid ""

"The :keyword:`return` statement returns with a value from a function. :"

"keyword:`!return` without an expression argument returns ``None``. Falling "

"off the end of a function also returns ``None``."

msgstr ""

"A instrução :keyword:`return` finaliza a execução e retorna um valor da "

"função. :keyword:`!return` sem qualquer expressão como argumento retorna "

"``None``. Atingir o final da função também retorna ``None``."

#: ../../tutorial/controlflow.rst:512

msgid ""

"The statement ``result.append(a)`` calls a *method* of the list object "

"``result``. A method is a function that 'belongs' to an object and is named "

"``obj.methodname``, where ``obj`` is some object (this may be an "

"expression), and ``methodname`` is the name of a method that is defined by "

"the object's type. Different types define different methods. Methods of "

"different types may have the same name without causing ambiguity. (It is "

"possible to define your own object types and methods, using *classes*, see :"

"ref:`tut-classes`) The method :meth:`append` shown in the example is defined "

"for list objects; it adds a new element at the end of the list. In this "

"example it is equivalent to ``result = result + [a]``, but more efficient."

msgstr ""

"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.nomemetodo``, onde ``obj`` é um objeto qualquer (pode ser uma "

"expressão), e ``nomemetodo`` é 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; adiciona um novo elemento ao final da lista. Neste "

"exemplo, ele equivale a ``result = result + [a]``, só que mais eficiente."

#: ../../tutorial/controlflow.rst:527

msgid "More on Defining Functions"

msgstr "Mais sobre definição de funções"

#: ../../tutorial/controlflow.rst:529

msgid ""

"It is also possible to define functions with a variable number of arguments. "

"There are three forms, which can be combined."

msgstr ""

"É possível definir funções com um número variável de argumentos. Existem "

"três formas, que podem ser combinadas."

#: ../../tutorial/controlflow.rst:536

msgid "Default Argument Values"

msgstr "Argumentos com valor padrão"

#: ../../tutorial/controlflow.rst:538

msgid ""

"The most useful form is to specify a default value for one or more "

"arguments. This creates a function that can be called with fewer arguments "

"than it is defined to allow. For example::"

msgstr ""

"A mais útil das três é especificar um valor padrão 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:554

msgid "This function can be called in several ways:"

msgstr "Essa função pode ser chamada de várias formas:"

#: ../../tutorial/controlflow.rst:556

msgid ""

"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"

msgstr ""

"fornecendo apenas o argumento obrigatório: ``ask_ok('Do you really want to "

"quit?')``"

#: ../../tutorial/controlflow.rst:558

msgid ""

"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "

"2)``"

msgstr ""

"fornecendo um dos argumentos opcionais: ``ask_ok('OK to overwrite the "

"file?', 2)``"

#: ../../tutorial/controlflow.rst:560

msgid ""

"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "

"on, only yes or no!')``"

msgstr ""

"ou fornecendo todos os argumentos: ``ask_ok('OK to overwrite the file?', 2, "

"'Come on, only yes or no!')``"

#: ../../tutorial/controlflow.rst:563

msgid ""

"This example also introduces the :keyword:`in` keyword. This tests whether "

"or not a sequence contains a certain value."

msgstr ""

"Este exemplo também introduz a palavra-chave :keyword:`in`, que verifica se "

"uma sequência contém ou não um determinado valor."

#: ../../tutorial/controlflow.rst:566

msgid ""

"The default values are evaluated at the point of function definition in the "

"*defining* scope, so that ::"

msgstr ""

"Os valores padrões 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:577

msgid "will print ``5``."

msgstr "irá exibir ``5``."

#: ../../tutorial/controlflow.rst:579

msgid ""

"**Important warning:** The default value is evaluated only once. This makes "

"a difference when the default is a mutable object such as a list, "

"dictionary, or instances of most classes. For example, the following "

"function accumulates the arguments passed to it on subsequent calls::"

msgstr ""

"**Aviso importante:** Valores padrões 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:592

msgid "This will print ::"

msgstr "Isso exibirá::"

#: ../../tutorial/controlflow.rst:598

msgid ""

"If you don't want the default to be shared between subsequent calls, you can "

"write the function like this instead::"

msgstr ""

"Se não quiser que o valor padrão seja compartilhado entre chamadas "

"subsequentes, pode reescrever a função assim::"

#: ../../tutorial/controlflow.rst:611

msgid "Keyword Arguments"

msgstr "Argumentos nomeados"

#: ../../tutorial/controlflow.rst:613

msgid ""

"Functions can also be called using :term:`keyword arguments <keyword "

"argument>` of the form ``kwarg=value``. For instance, the following "

"function::"

msgstr ""

"Funções também podem ser chamadas usando :term:`argumentos nomeados <keyword "

"argument>` da forma ``chave=valor``. Por exemplo, a função a seguir::"

#: ../../tutorial/controlflow.rst:622

msgid ""

"accepts one required argument (``voltage``) and three optional arguments "

"(``state``, ``action``, and ``type``). This function can be called in any "

"of the following ways::"

msgstr ""

"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:633

msgid "but all the following calls would be invalid::"

msgstr "mas todas as formas a seguir seriam inválidas::"

#: ../../tutorial/controlflow.rst:640

msgid ""

"In a function call, keyword arguments must follow positional arguments. All "

"the keyword arguments passed must match one of the arguments accepted by the "

"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "

"function), and their order is not important. This also includes non-"

"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "

"may receive a value more than once. Here's an example that fails due to this "

"restriction::"

msgstr ""

"Em uma 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 argumento pode receber mais de um "

"valor. Eis um exemplo que não funciona devido a esta restrição::"

#: ../../tutorial/controlflow.rst:656

msgid ""

"When a final formal parameter of the form ``**name`` is present, it receives "

"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "

"except for those corresponding to a formal parameter. This may be combined "

"with a formal parameter of the form ``*name`` (described in the next "

"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "

"positional arguments beyond the formal parameter list. (``*name`` must "

"occur before ``**name``.) For example, if we define a function like this::"

msgstr ""

"Quando um último parâmetro formal no formato ``**nome`` está presente, ele "

"recebe um dicionário (veja :ref:`typesmapping`) contendo todos os argumentos "

"nomeados, exceto aqueles que correspondem a um parâmetro formal. Isto pode "

"ser combinado com um parâmetro formal no formato ``*nome`` (descrito na "

"próxima subseção) que recebe uma :ref:`tupla <tut-tuples>` contendo os "

"argumentos posicionais, além da lista de parâmetros formais. (``*nome`` deve "

"ocorrer antes de ``**nome``.) Por exemplo, se definirmos uma função assim::"

#: ../../tutorial/controlflow.rst:673

msgid "It could be called like this::"

msgstr "Pode ser chamada assim::"

#: ../../tutorial/controlflow.rst:681

msgid "and of course it would print:"

msgstr "e, claro, exibiria:"

#: ../../tutorial/controlflow.rst:694

msgid ""

"Note that the order in which the keyword arguments are printed is guaranteed "

"to match the order in which they were provided in the function call."

msgstr ""

"Observe que a ordem em que os argumentos nomeados são exibidos é garantida "

"para corresponder à ordem em que foram fornecidos na chamada da função."

#: ../../tutorial/controlflow.rst:698

msgid "Special parameters"

msgstr "Parâmetros especiais"

#: ../../tutorial/controlflow.rst:700

msgid ""

"By default, arguments may be passed to a Python function either by position "

"or explicitly by keyword. For readability and performance, it makes sense to "

"restrict the way arguments can be passed so that a developer need only look "

"at the function definition to determine if items are passed by position, by "

"position or keyword, or by keyword."

msgstr ""

"Por padrão, argumentos podem ser passadas para uma função Python tanto por "

"posição quanto explicitamente pelo nome. Para uma melhor legibilidade e "

"desempenho, faz sentido restringir a maneira pelo qual argumentos possam ser "

"passados, assim um desenvolvedor precisa apenas olhar para a definição da "

"função para determinar se os itens são passados por posição, por posição e "

"nome, ou por nome."

#: ../../tutorial/controlflow.rst:706

msgid "A function definition may look like:"

msgstr "A definição de uma função pode parecer com:"

#: ../../tutorial/controlflow.rst:717

msgid ""

"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "

"of parameter by how the arguments may be passed to the function: positional-"

"only, positional-or-keyword, and keyword-only. Keyword parameters are also "

"referred to as named parameters."

msgstr ""

"onde ``/`` e ``*`` são opcionais. Se usados, esses símbolos indicam o tipo "

"de parâmetro pelo qual os argumentos podem ser passados para as funções: "

"somente-posicional, posicional-ou-nomeado, e somente-nomeado. Parâmetros "

"nomeados são também conhecidos como parâmetros palavra-chave."

#: ../../tutorial/controlflow.rst:724

msgid "Positional-or-Keyword Arguments"

msgstr "Argumentos posicional-ou-nomeados"

#: ../../tutorial/controlflow.rst:726

msgid ""

"If ``/`` and ``*`` are not present in the function definition, arguments may "

"be passed to a function by position or by keyword."

msgstr ""

"Se ``/`` e ``*`` não estão presentes na definição da função, argumentos "

"podem ser passados para uma função por posição ou por nome."

#: ../../tutorial/controlflow.rst:731

msgid "Positional-Only Parameters"

msgstr "Parâmetros somente-posicionais"

#: ../../tutorial/controlflow.rst:733

msgid ""

"Looking at this in a bit more detail, it is possible to mark certain "

"parameters as *positional-only*. If *positional-only*, the parameters' order "

"matters, and the parameters cannot be passed by keyword. Positional-only "

"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "

"logically separate the positional-only parameters from the rest of the "

"parameters. If there is no ``/`` in the function definition, there are no "

"positional-only parameters."

msgstr ""

"Olhando com um pouco mais de detalhes, é possível definir certos parâmetros "

"como *somente-posicional*. Se *somente-posicional*, a ordem do parâmetro "

"importa, e os parâmetros não podem ser passados por nome. Parâmetros somente-"

"posicional são colocados antes de ``/`` (barra). A ``/`` é usada para "

"logicamente separar os argumentos somente-posicional dos demais parâmetros. "

"Se não existe uma ``/`` na definição da função, não existe parâmetros "

"somente-posicionais."

#: ../../tutorial/controlflow.rst:741

msgid ""

"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"

"only*."

msgstr ""

"Parâmetros após a ``/`` podem ser *posicional-ou-nomeado* ou *somente-"

"nomeado*."

#: ../../tutorial/controlflow.rst:745

msgid "Keyword-Only Arguments"

msgstr "Argumentos somente-nomeados"

#: ../../tutorial/controlflow.rst:747

msgid ""

"To mark parameters as *keyword-only*, indicating the parameters must be "

"passed by keyword argument, place an ``*`` in the arguments list just before "

"the first *keyword-only* parameter."

msgstr ""

"Para definir parâmetros como *somente-nomeado*, indicando que o parâmetro "

"deve ser passado por argumento nomeado, colocamos um ``*`` na lista de "

"argumentos imediatamente antes do primeiro parâmetro *somente-nomeado*."

#: ../../tutorial/controlflow.rst:753

msgid "Function Examples"

msgstr "Exemplos de funções"

#: ../../tutorial/controlflow.rst:755

msgid ""

"Consider the following example function definitions paying close attention "

"to the markers ``/`` and ``*``::"

msgstr ""

"Considere o seguinte exemplo de definição de função com atenção redobrada "

"para os marcadores ``/`` e ``*``::"

#: ../../tutorial/controlflow.rst:771

msgid ""

"The first function definition, ``standard_arg``, the most familiar form, "

"places no restrictions on the calling convention and arguments may be passed "

"by position or keyword::"

msgstr ""

"A definição da primeira função, ``standard_arg``, a forma mais familiar, não "

"coloca nenhuma restrição para a chamada da função e argumentos podem ser "

"passados por posição ou nome::"

#: ../../tutorial/controlflow.rst:781

msgid ""

"The second function ``pos_only_arg`` is restricted to only use positional "

"parameters as there is a ``/`` in the function definition::"

msgstr ""

"A segunda função ``pos_only_arg`` está restrita ao uso de parâmetros somente "

"posicionais, uma vez que existe uma ``/`` na definição da função::"

#: ../../tutorial/controlflow.rst:792

msgid ""

"The third function ``kwd_only_args`` only allows keyword arguments as "

"indicated by a ``*`` in the function definition::"

msgstr ""

"A terceira função ``kwd_only_args`` permite somente argumentos nomeados como "

"indicado pelo ``*`` na definição da função::"

#: ../../tutorial/controlflow.rst:803

msgid ""

"And the last uses all three calling conventions in the same function "

"definition::"

msgstr ""

"E a última usa as três convenções de chamada na mesma definição de função::"

#: ../../tutorial/controlflow.rst:823

msgid ""

"Finally, consider this function definition which has a potential collision "

"between the positional argument ``name`` and ``**kwds`` which has ``name`` "

"as a key::"

msgstr ""

"Finalmente, considere essa definição de função que possui uma potencial "

"colisão entre o argumento posicional ``name`` e ``**kwds`` que possui "

"``name`` como uma chave::"

#: ../../tutorial/controlflow.rst:828

msgid ""

"There is no possible call that will make it return ``True`` as the keyword "

"``'name'`` will always bind to the first parameter. For example::"

msgstr ""

"Não é possível essa chamada devolver ``True``, uma vez que a chave "

"``'name'`` sempre será aplicada para o primeiro parâmetro. Por exemplo::"

#: ../../tutorial/controlflow.rst:837

msgid ""

"But using ``/`` (positional only arguments), it is possible since it allows "

"``name`` as a positional argument and ``'name'`` as a key in the keyword "

"arguments::"

msgstr ""

"Mas usando ``/`` (somente argumentos posicionais), isso é possível já que "

"permite ``name`` como um argumento posicional e ``'name'`` como uma chave "

"nos argumentos nomeados::"

#: ../../tutorial/controlflow.rst:844

msgid ""

"In other words, the names of positional-only parameters can be used in "

"``**kwds`` without ambiguity."

msgstr ""

"Em outras palavras, o nome de parâmetros somente-posicional podem ser usados "

"em ``**kwds`` sem ambiguidade."

#: ../../tutorial/controlflow.rst:849

msgid "Recap"

msgstr "Recapitulando"

#: ../../tutorial/controlflow.rst:851

msgid ""

"The use case will determine which parameters to use in the function "

"definition::"

msgstr ""

"A situação irá determinar quais parâmetros usar na definição da função::"