# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

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

# Alexandre B A Villares, 2020

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

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2024-09-06 22:14+0000\n"

"PO-Revision-Date: 2020-05-30 12:15+0000\n"

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

"Language-Team: Portuguese (Brazil) (https://app.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=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

"1000000 == 0 ? 1 : 2;\n"

#: ../../reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr "Instruções compostas"

#: ../../reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

"Instruções compostas contém (grupos de) outras instruções; Elas afetam ou "

"controlam a execução dessas outras instruções de alguma maneira. Em geral, "

"instruções compostas abrangem múltiplas linhas, no entanto em algumas "

"manifestações simples uma instrução composta inteira pode estar contida em "

"uma linha."

#: ../../reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while "

"the :keyword:`with` statement allows the execution of initialization and "

"finalization code around a block of code. Function and class definitions "

"are also syntactically compound statements."

msgstr ""

"As instruções :keyword:`if`, :keyword:`while` e :keyword:`for` implementam "

"construções tradicionais de controle do fluxo de execução. :keyword:`try` "

"especifica tratadores de exceção e/ou código de limpeza para uma instrução "

"ou grupo de instruções, enquanto a palavra reservada :keyword:`with` permite "

"a execução de código de inicialização e finalização em volta de um bloco de "

"código. Definições de função e classe também são sintaticamente instruções "

"compostas."

#: ../../reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

"Uma instrução composta consiste em uma ou mais \"cláusulas\". Uma cláusula "

"consiste em um cabeçalho e um \"conjunto\". Os cabeçalhos das cláusulas de "

"uma instrução composta específica estão todos no mesmo nível de indentação. "

"Cada cabeçalho de cláusula começa com uma palavra reservada de identificação "

"exclusiva e termina com dois pontos. Um conjunto é um grupo de instruções "

"controladas por uma cláusula. Um conjunto pode ser uma ou mais instruções "

"simples separadas por ponto e vírgula na mesma linha do cabeçalho, após os "

"dois pontos do cabeçalho, ou pode ser uma ou mais instruções indentadas nas "

"linhas subsequentes. Somente a última forma de conjunto pode conter "

"instruções compostas aninhadas; o seguinte é ilegal, principalmente porque "

"não ficaria claro a qual cláusula :keyword:`if` a seguinte "

"cláusula :keyword:`else` pertenceria::"

#: ../../reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

"Observe também que o ponto e vírgula é mais vinculado que os dois pontos "

"neste contexto, de modo que no exemplo a seguir, todas ou nenhuma das "

"chamadas :func:`print` são executadas::"

#: ../../reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "Resumindo:"

#: ../../reference/compound_stmts.rst:68

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring "

"nested :keyword:`if` statements to be indented)."

msgstr ""

"Note que instruções sempre terminam em uma ``NEWLINE`` possivelmente seguida "

"por uma ``DEDENT``. Note também que cláusulas opcionais de continuação "

"sempre começam com uma palavra reservada que não pode iniciar uma instrução, "

"desta forma não há ambiguidades (o problema do \":keyword:`else` pendurado\" "

"é resolvido em Python obrigando que instruções :keyword:`if` aninhadas "

"tenham indentação)"

#: ../../reference/compound_stmts.rst:74

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

"A formatação das regras de gramática nas próximas seções põe cada cláusula "

"em uma linha separada para as tornar mais claras."

#: ../../reference/compound_stmts.rst:83

msgid "The :keyword:`!if` statement"

msgstr "A instrução :keyword:`!if`"

#: ../../reference/compound_stmts.rst:91

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr "A instrução :keyword:`if` é usada para execução condicional:"

#: ../../reference/compound_stmts.rst:98

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

"Ele seleciona exatamente um dos conjuntos avaliando as expressões uma por "

"uma até que uma seja considerada verdadeira (veja a seção :ref:`booleans` "

"para a definição de verdadeiro e falso); então esse conjunto é executado (e "

"nenhuma outra parte da instrução :keyword:`if` é executada ou avaliada). Se "

"todas as expressões forem falsas, o conjunto da cláusula :keyword:`else`, se "

"presente, é executado."

#: ../../reference/compound_stmts.rst:108

msgid "The :keyword:`!while` statement"

msgstr "A instrução :keyword:`!while`"

#: ../../reference/compound_stmts.rst:116

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

"A instrução :keyword:`while` é usada para execução repetida desde que uma "

"expressão seja verdadeira:"

#: ../../reference/compound_stmts.rst:123

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

"Isto testa repetidamente a expressão e, se for verdadeira, executa o "

"primeiro conjunto; se a expressão for falsa (o que pode ser a primeira vez "

"que ela é testada) o conjunto da cláusula :keyword:`!else`, se presente, é "

"executado e o laço termina."

#: ../../reference/compound_stmts.rst:132

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. "

"A :keyword:`continue` statement executed in the first suite skips the rest "

"of the suite and goes back to testing the expression."

msgstr ""

"Uma instrução :keyword:`break` executada no primeiro conjunto termina o loop "

"sem executar o conjunto da cláusula :keyword:`!else`. Uma "

"instrução :keyword:`continue` executada no primeiro conjunto ignora o resto "

"do conjunto e volta a testar a expressão."

#: ../../reference/compound_stmts.rst:141

msgid "The :keyword:`!for` statement"

msgstr "A instrução :keyword:`!for`"

#: ../../reference/compound_stmts.rst:152

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

"A instrução :keyword:`for` é usada para iterar sobre os elementos de uma "

"sequência (como uma string, tupla ou lista) ou outro objeto iterável:"

#: ../../reference/compound_stmts.rst:159

msgid ""

"The expression list is evaluated once; it should yield an iterable object. "

"An iterator is created for the result of the ``expression_list``. The suite "

"is then executed once for each item provided by the iterator, in the order "

"returned by the iterator. Each item in turn is assigned to the target list "

"using the standard rules for assignments (see :ref:`assignment`), and then "

"the suite is executed. When the items are exhausted (which is immediately "

"when the sequence is empty or an iterator raises a :exc:`StopIteration` "

"exception), the suite in the :keyword:`!else` clause, if present, is "

"executed, and the loop terminates."

msgstr ""

#: ../../reference/compound_stmts.rst:172

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. "

"A :keyword:`continue` statement executed in the first suite skips the rest "

"of the suite and continues with the next item, or with the :keyword:`!else` "

"clause if there is no next item."

msgstr ""

"Uma instrução :keyword:`break` executada no primeiro conjunto termina o loop "

"sem executar o conjunto da cláusula :keyword:`!else`. Uma "

"instrução :keyword:`continue` executada no primeiro conjunto pula o resto do "

"conjunto e continua com o próximo item, ou com a cláusula :keyword:`!else` "

"se não houver próximo item."

#: ../../reference/compound_stmts.rst:178

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

"O laço for faz atribuições às variáveis na lista de destino. Isso substitui "

"todas as atribuições anteriores a essas variáveis, incluindo aquelas feitas "

"no conjunto do laço for::"

#: ../../reference/compound_stmts.rst:192

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in function :func:`range` returns an iterator of "

"integers suitable to emulate the effect of Pascal's ``for i := a to b do``; "

"e.g., ``list(range(3))`` returns the list ``[0, 1, 2]``."

msgstr ""

#: ../../reference/compound_stmts.rst:204

msgid ""

"There is a subtlety when the sequence is being modified by the loop (this "

"can only occur for mutable sequences, e.g. lists). An internal counter is "

"used to keep track of which item is used next, and this is incremented on "

"each iteration. When this counter has reached the length of the sequence "

"the loop terminates. This means that if the suite deletes the current (or a "

"previous) item from the sequence, the next item will be skipped (since it "

"gets the index of the current item which has already been treated). "

"Likewise, if the suite inserts an item in the sequence before the current "

"item, the current item will be treated again the next time through the loop. "

"This can lead to nasty bugs that can be avoided by making a temporary copy "

"using a slice of the whole sequence, e.g., ::"

msgstr ""

#: ../../reference/compound_stmts.rst:225

msgid "The :keyword:`!try` statement"

msgstr "A instrução :keyword:`!try`"

#: ../../reference/compound_stmts.rst:235

msgid ""

"The :keyword:`try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

#: ../../reference/compound_stmts.rst:248

msgid ""

"The :keyword:`except` clause(s) specify one or more exception handlers. When "

"no exception occurs in the :keyword:`try` clause, no exception handler is "

"executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the except "

"clauses in turn until one is found that matches the exception. An "

"expression-less except clause, if present, must be last; it matches any "

"exception. For an except clause with an expression, that expression is "

"evaluated, and the clause matches the exception if the resulting object is "

"\"compatible\" with the exception. An object is compatible with an "

"exception if it is the class or a base class of the exception object, or a "

"tuple containing an item that is the class or a base class of the exception "

"object."

msgstr ""

#: ../../reference/compound_stmts.rst:260

msgid ""

"If no except clause matches the exception, the search for an exception "

"handler continues in the surrounding code and on the invocation stack. [#]_"

msgstr ""

#: ../../reference/compound_stmts.rst:263

msgid ""

"If the evaluation of an expression in the header of an except clause raises "

"an exception, the original search for a handler is canceled and a search "

"starts for the new exception in the surrounding code and on the call stack "

"(it is treated as if the entire :keyword:`try` statement raised the "

"exception)."

msgstr ""

#: ../../reference/compound_stmts.rst:270

msgid ""

"When a matching except clause is found, the exception is assigned to the "

"target specified after the :keyword:`!as` keyword in that except clause, if "

"present, and the except clause's suite is executed. All except clauses must "

"have an executable block. When the end of this block is reached, execution "

"continues normally after the entire try statement. (This means that if two "

"nested handlers exist for the same exception, and the exception occurs in "

"the try clause of the inner handler, the outer handler will not handle the "

"exception.)"

msgstr ""

#: ../../reference/compound_stmts.rst:278

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the except clause. This is as if ::"

msgstr ""

#: ../../reference/compound_stmts.rst:284

msgid "was translated to ::"

msgstr "fosse traduzido para ::"

#: ../../reference/compound_stmts.rst:292

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the except clause. Exceptions are cleared because with "

"the traceback attached to them, they form a reference cycle with the stack "

"frame, keeping all locals in that frame alive until the next garbage "

"collection occurs."

msgstr ""

#: ../../reference/compound_stmts.rst:301

msgid ""

"Before an except clause's suite is executed, details about the exception are "

"stored in the :mod:`sys` module and can be accessed "

"via :func:`sys.exc_info`. :func:`sys.exc_info` returns a 3-tuple consisting "

"of the exception class, the exception instance and a traceback object (see "

"section :ref:`types`) identifying the point in the program where the "

"exception occurred. :func:`sys.exc_info` values are restored to their "

"previous values (before the call) when returning from a function that "

"handled an exception."

msgstr ""

#: ../../reference/compound_stmts.rst:315

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and "

"no :keyword:`return`, :keyword:`continue`, or :keyword:`break` statement was "

"executed. Exceptions in the :keyword:`!else` clause are not handled by the "

"preceding :keyword:`except` clauses."

msgstr ""

"A cláusula opcional :keyword:`!else` é executada se o fluxo de controle "

"deixar o conjunto :keyword:`try`, nenhuma exceção foi levantada e nenhuma "

"instrução :keyword:`return`, :keyword:`continue` ou :keyword:`break` foi "

"executada. Exceções na cláusula :keyword:`!else` não são manipuladas pelas "

"cláusulas :keyword:`except` precedentes."

#: ../../reference/compound_stmts.rst:323

msgid ""

"If :keyword:`finally` is present, it specifies a 'cleanup' handler. "

"The :keyword:`try` clause is executed, including any :keyword:`except` "

"and :keyword:`!else` clauses. If an exception occurs in any of the clauses "

"and is not handled, the exception is temporarily saved. The :keyword:`!"

"finally` clause is executed. If there is a saved exception it is re-raised "

"at the end of the :keyword:`!finally` clause. If the :keyword:`!finally` "

"clause raises another exception, the saved exception is set as the context "

"of the new exception. If the :keyword:`!finally` clause executes "

"a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement, the "

"saved exception is discarded::"

msgstr ""

#: ../../reference/compound_stmts.rst:342

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`finally` clause."

msgstr ""

#: ../../reference/compound_stmts.rst:350

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`finally` clause is also executed 'on the "

"way out.'"

msgstr ""

#: ../../reference/compound_stmts.rst:354

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`finally` clause always executes, "

"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "

"will always be the last one executed::"

msgstr ""

#: ../../reference/compound_stmts.rst:368

msgid ""

"Additional information on exceptions can be found in "

"section :ref:`exceptions`, and information on using the :keyword:`raise` "

"statement to generate exceptions may be found in section :ref:`raise`."

msgstr ""

"Informações adicionais sobre exceções podem ser encontradas na "

"seção :ref:`exceptions`, e informações sobre como usar a "

"instrução :keyword:`raise` para gerar exceções podem ser encontradas na "

"seção :ref:`raise`."

#: ../../reference/compound_stmts.rst:372

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in "

"the :keyword:`finally` clause due to a problem with the implementation."

msgstr ""

#: ../../reference/compound_stmts.rst:381

msgid "The :keyword:`!with` statement"

msgstr "A instrução :keyword:`!with`"

#: ../../reference/compound_stmts.rst:390

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`..."

"\\ :keyword:`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

"A instrução :keyword:`with` é usada para envolver em um invólucro a execução "

"de um bloco com métodos definidos por um gerenciador de contexto (veja a "

"seção :ref:`context-managers`). Isso permite que padrões comuns de uso "

"de :keyword:`try`...\\ :keyword:`except`...\\ :keyword:`finally` sejam "

"encapsulados para reutilização conveniente."

#: ../../reference/compound_stmts.rst:399

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

"A execução da instrução :keyword:`with` com um \"item\" ocorre da seguinte "

"maneira:"

#: ../../reference/compound_stmts.rst:401

msgid ""

"The context expression (the expression given in the :token:`with_item`) is "

"evaluated to obtain a context manager."

msgstr ""

#: ../../reference/compound_stmts.rst:404

msgid "The context manager's :meth:`__enter__` is loaded for later use."

msgstr ""

#: ../../reference/compound_stmts.rst:406

msgid "The context manager's :meth:`__exit__` is loaded for later use."

msgstr ""

#: ../../reference/compound_stmts.rst:408

msgid "The context manager's :meth:`__enter__` method is invoked."

msgstr ""

#: ../../reference/compound_stmts.rst:410

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`__enter__` is assigned to it."

msgstr ""

#: ../../reference/compound_stmts.rst:415

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`__enter__` "

"method returns without an error, then :meth:`__exit__` will always be "

"called. Thus, if an error occurs during the assignment to the target list, "

"it will be treated the same as an error occurring within the suite would be. "

"See step 6 below."

msgstr ""

#: ../../reference/compound_stmts.rst:421

msgid "The suite is executed."

msgstr "O conjunto é executado."

#: ../../reference/compound_stmts.rst:423

msgid ""

"The context manager's :meth:`__exit__` method is invoked. If an exception "

"caused the suite to be exited, its type, value, and traceback are passed as "

"arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are "

"supplied."

msgstr ""

#: ../../reference/compound_stmts.rst:428

msgid ""

"If the suite was exited due to an exception, and the return value from "

"the :meth:`__exit__` method was false, the exception is reraised. If the "

"return value was true, the exception is suppressed, and execution continues "

"with the statement following the :keyword:`with` statement."

msgstr ""

#: ../../reference/compound_stmts.rst:433

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`__exit__` is ignored, and execution proceeds at the normal "

"location for the kind of exit that was taken."

msgstr ""

#: ../../reference/compound_stmts.rst:437

#: ../../reference/compound_stmts.rst:806

#: ../../reference/compound_stmts.rst:847

msgid "The following code::"

msgstr "O seguinte código::"

#: ../../reference/compound_stmts.rst:442

#: ../../reference/compound_stmts.rst:467

#: ../../reference/compound_stmts.rst:852

msgid "is semantically equivalent to::"

msgstr "é semanticamente equivalente a::"

#: ../../reference/compound_stmts.rst:461

msgid ""

"With more than one item, the context managers are processed as if "

"multiple :keyword:`with` statements were nested::"

msgstr ""

"Com mais de um item, os gerenciadores de contexto são processados ​como se "

"várias instruções :keyword:`with` estivessem aninhadas::"

#: ../../reference/compound_stmts.rst:473

msgid "Support for multiple context expressions."

msgstr "Suporte para múltiplas expressões de contexto."

#: ../../reference/compound_stmts.rst:479

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` - A instrução \"with\""

#: ../../reference/compound_stmts.rst:479

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr ""

"A especificação, o histórico e os exemplos para a instrução "

"Python :keyword:`with`."

#: ../../reference/compound_stmts.rst:490

msgid "Function definitions"

msgstr "Definições de função"

#: ../../reference/compound_stmts.rst:505

msgid ""

"A function definition defines a user-defined function object (see "

"section :ref:`types`):"

msgstr ""

"Uma definição de função define um objeto de função definido pelo usuário "

"(veja a seção :ref:`types`):"

#: ../../reference/compound_stmts.rst:525

msgid ""

"A function definition is an executable statement. Its execution binds the "

"function name in the current local namespace to a function object (a wrapper "

"around the executable code for the function). This function object contains "

"a reference to the current global namespace as the global namespace to be "

"used when the function is called."

msgstr ""

"Uma definição de função é uma instrução executável. Sua execução vincula o "

"nome da função no espaço de nomes local atual a um objeto função (um "

"invólucro em torno do código executável para a função). Este objeto função "

"contém uma referência ao espaço de nomes global atual como o espaço de nomes "

"global a ser usado quando a função é chamada."

#: ../../reference/compound_stmts.rst:531

msgid ""

"The function definition does not execute the function body; this gets "

"executed only when the function is called. [#]_"

msgstr ""

"A definição da função não executa o corpo da função; ela é executada somente "

"quando a função é chamada. [#]_"

#: ../../reference/compound_stmts.rst:537

msgid ""

"A function definition may be wrapped by one or more :term:`decorator` "

"expressions. Decorator expressions are evaluated when the function is "

"defined, in the scope that contains the function definition. The result "

"must be a callable, which is invoked with the function object as the only "

"argument. The returned value is bound to the function name instead of the "

"function object. Multiple decorators are applied in nested fashion. For "

"example, the following code ::"

msgstr ""

"Uma definição de função pode ser encapsulada por uma ou mais "

"expressões :term:`decoradoras <decorador>`. Expressões decoradoras são "

"avaliadas quando a função é definida, no escopo que contém a definição da "

"função. O resultado deve ser um chamável, que é invocado com o objeto de "

"função como o único argumento. O valor retornado é vinculado ao nome da "

"função em vez do objeto de função. Vários decoradores são aplicados de forma "

"aninhada. Por exemplo, o código a seguir ::"

#: ../../reference/compound_stmts.rst:548

#: ../../reference/compound_stmts.rst:720

msgid "is roughly equivalent to ::"

msgstr "é aproximadamente equivalente a ::"

#: ../../reference/compound_stmts.rst:553

msgid ""

"except that the original function is not temporarily bound to the name "

"``func``."

msgstr ""

"exceto que a função original não está temporariamente vinculada ao nome "

"``func``."

#: ../../reference/compound_stmts.rst:560

msgid ""

"When one or more :term:`parameters <parameter>` have the form *parameter* "

"``=`` *expression*, the function is said to have \"default parameter values."

"\" For a parameter with a default value, the corresponding :term:`argument` "

"may be omitted from a call, in which case the parameter's default value is "

"substituted. If a parameter has a default value, all following parameters "

"up until the \"``*``\" must also have a default value --- this is a "

"syntactic restriction that is not expressed by the grammar."

msgstr ""

"Quando um ou mais :term:`parâmetros <parameter>` têm a forma *parameter* "

"``=`` *expression*, diz-se que a função tem \"valores de parâmetro padrão\". "

"Para um parâmetro com um valor padrão, o :term:`argumento` correspondente "

"pode ser omitido de uma chamada, em cujo caso o valor padrão do parâmetro é "

"substituído. Se um parâmetro tiver um valor padrão, todos os parâmetros "

"seguintes até \"``*``\" também devem ter um valor padrão --- esta é uma "

"restrição sintática que não é expressa pela gramática."

#: ../../reference/compound_stmts.rst:568

msgid ""

"**Default parameter values are evaluated from left to right when the "

"function definition is executed.** This means that the expression is "

"evaluated once, when the function is defined, and that the same \"pre-"

"computed\" value is used for each call. This is especially important to "

"understand when a default parameter is a mutable object, such as a list or a "

"dictionary: if the function modifies the object (e.g. by appending an item "

"to a list), the default value is in effect modified. This is generally not "

"what was intended. A way around this is to use ``None`` as the default, and "

"explicitly test for it in the body of the function, e.g.::"

msgstr ""

#: ../../reference/compound_stmts.rst:589

msgid ""

"Function call semantics are described in more detail in "

"section :ref:`calls`. A function call always assigns values to all "

"parameters mentioned in the parameter list, either from positional "

"arguments, from keyword arguments, or from default values. If the form "

"\"``*identifier``\" is present, it is initialized to a tuple receiving any "

"excess positional parameters, defaulting to the empty tuple. If the form "

"\"``**identifier``\" is present, it is initialized to a new ordered mapping "

"receiving any excess keyword arguments, defaulting to a new empty mapping of "

"the same type. Parameters after \"``*``\" or \"``*identifier``\" are "

"keyword-only parameters and may only be passed by keyword arguments. "

"Parameters before \"``/``\" are positional-only parameters and may only be "

"passed by positional arguments."

msgstr ""

"A semântica de chamada de função é descrita em mais detalhes na "

"seção :ref:`calls`. Uma chamada de função sempre atribui valores a todos os "

"parâmetros mencionados na lista de parâmetros, seja de argumentos "

"posicionais, de argumentos nomeados ou de valores padrão. Se o formato "

"\"``*identifier``\" estiver presente, ele será inicializado para uma tupla "

"que recebe quaisquer parâmetros posicionais excedentes, padronizando para a "

"tupla vazia. Se o formato \"``**identifier``\" estiver presente, ele será "

"inicializado para um novo mapeamento ordenado que recebe quaisquer "

"argumentos nomeados excedentes, padronizando para um novo mapeamento vazio "

"do mesmo tipo. Parâmetros após \"``*``\" ou \"``*identifier``\" são "

"parâmetros somente-nomeados e podem ser passados ​​somente por argumentos "

"nomeados. Parâmetros antes de \"``/``\" são parâmetros somente-posicionais e "

"podem ser passados ​​somente por argumentos posicionais."

#: ../../reference/compound_stmts.rst:601

msgid ""

"The ``/`` function parameter syntax may be used to indicate positional-only "

"parameters. See :pep:`570` for details."

msgstr ""

"A sintaxe do parâmetro de função ``/`` pode ser usada para indicar "

"parâmetros somente-posicionais. Veja a :pep:`570` para detalhes."

#: ../../reference/compound_stmts.rst:610

msgid ""

"Parameters may have an :term:`annotation <function annotation>` of the form "

"\"``: expression``\" following the parameter name. Any parameter may have "

"an annotation, even those of the form ``*identifier`` or ``**identifier``. "

"Functions may have \"return\" annotation of the form \"``-> expression``\" "

"after the parameter list. These annotations can be any valid Python "

"expression. The presence of annotations does not change the semantics of a "

"function. The annotation values are available as values of a dictionary "

"keyed by the parameters' names in the :attr:`__annotations__` attribute of "

"the function object. If the ``annotations`` import from :mod:`__future__` "

"is used, annotations are preserved as strings at runtime which enables "

"postponed evaluation. Otherwise, they are evaluated when the function "

"definition is executed. In this case annotations may be evaluated in a "

"different order than they appear in the source code."

msgstr ""

#: ../../reference/compound_stmts.rst:625

msgid ""

"It is also possible to create anonymous functions (functions not bound to a "

"name), for immediate use in expressions. This uses lambda expressions, "

"described in section :ref:`lambda`. Note that the lambda expression is "

"merely a shorthand for a simplified function definition; a function defined "

"in a \":keyword:`def`\" statement can be passed around or assigned to "

"another name just like a function defined by a lambda expression. The "

"\":keyword:`!def`\" form is actually more powerful since it allows the "

"execution of multiple statements and annotations."

msgstr ""

"Também é possível criar funções anônimas (funções não vinculadas a um nome), "

"para uso imediato em expressões. Isso usa expressões lambda, descritas na "

"seção :ref:`lambda`. Observe que a expressão lambda é meramente uma "

"abreviação para uma definição de função simplificada; uma função definida em "

"uma instrução \":keyword:`def`\" pode ser passada adiante ou atribuída a "

"outro nome, assim como uma função definida por uma expressão lambda. O "

"formato \":keyword:`!def`\" é, na verdade, mais poderoso, pois permite a "

"execução de várias instruções e anotações."

#: ../../reference/compound_stmts.rst:633

msgid ""

"**Programmer's note:** Functions are first-class objects. A \"``def``\" "

"statement executed inside a function definition defines a local function "

"that can be returned or passed around. Free variables used in the nested "

"function can access the local variables of the function containing the def. "

"See section :ref:`naming` for details."

msgstr ""

"**Nota do programador:** Funções são objetos de primeira classe. Uma "

"instrução \"``def``\" executada dentro de uma definição de função define uma "

"função local que pode ser retornada ou passada adiante. Variáveis livres "

"usadas na função aninhada podem acessar as variáveis locais da função que "

"contém o \"def\". Veja a seção :ref:`naming` para detalhes."

#: ../../reference/compound_stmts.rst:642

msgid ":pep:`3107` - Function Annotations"

msgstr ":pep:`3107` - Anotações de função"

#: ../../reference/compound_stmts.rst:642

msgid "The original specification for function annotations."

msgstr "A especificação original para anotações de funções."

#: ../../reference/compound_stmts.rst:645

msgid ":pep:`484` - Type Hints"

msgstr ":pep:`484` - Dicas de tipo"

#: ../../reference/compound_stmts.rst:645

msgid "Definition of a standard meaning for annotations: type hints."

msgstr "Definição de um significado padrão para anotações: dicas de tipo."

#: ../../reference/compound_stmts.rst:649

msgid ":pep:`526` - Syntax for Variable Annotations"

msgstr ":pep:`526` - Sintaxe para Anotações de Variáveis"

#: ../../reference/compound_stmts.rst:648

msgid ""

"Ability to type hint variable declarations, including class variables and "

"instance variables"

msgstr ""

#: ../../reference/compound_stmts.rst:652

msgid ":pep:`563` - Postponed Evaluation of Annotations"

msgstr ":pep:`563` - Avaliação postergada de anotações"

#: ../../reference/compound_stmts.rst:652

msgid ""

"Support for forward references within annotations by preserving annotations "

"in a string form at runtime instead of eager evaluation."

msgstr ""

"Suporte para referências futuras dentro de anotações, preservando anotações "

"em um formato de string em tempo de execução em vez de avaliação antecipada."

#: ../../reference/compound_stmts.rst:659

msgid "Class definitions"

msgstr "Definições de classe"

#: ../../reference/compound_stmts.rst:674

msgid "A class definition defines a class object (see section :ref:`types`):"

msgstr ""

"Uma definição de classe define um objeto classe (veja a seção :ref:`types`):"

#: ../../reference/compound_stmts.rst:681

msgid ""

"A class definition is an executable statement. The inheritance list usually "

"gives a list of base classes (see :ref:`metaclasses` for more advanced "

"uses), so each item in the list should evaluate to a class object which "

"allows subclassing. Classes without an inheritance list inherit, by "

"default, from the base class :class:`object`; hence, ::"

msgstr ""

"Uma definição de classe é uma instrução executável. A lista de herança "

"geralmente fornece uma lista de classes base (veja :ref:`metaclasses` para "

"usos mais avançados), então cada item na lista deve ser executada como um "

"objeto classe que permite extensão via subclasse. Classes sem uma lista de "

"herança herdam, por padrão, da classe base :class:`object`; portanto, ::"

#: ../../reference/compound_stmts.rst:690

msgid "is equivalent to ::"

msgstr "equivale a ::"

#: ../../reference/compound_stmts.rst:695

msgid ""

"The class's suite is then executed in a new execution frame "

"(see :ref:`naming`), using a newly created local namespace and the original "

"global namespace. (Usually, the suite contains mostly function "

"definitions.) When the class's suite finishes execution, its execution "

"frame is discarded but its local namespace is saved. [#]_ A class object is "

"then created using the inheritance list for the base classes and the saved "

"local namespace for the attribute dictionary. The class name is bound to "

"this class object in the original local namespace."

msgstr ""

"O conjunto da classe é então executado em um novo quadro de execução "

"(veja :ref:`naming`), usando um espaço de nomes local recém-criado e o "

"espaço de nomes global original. (Normalmente, o conjunto contém "

"principalmente definições de função.) Quando o conjunto da classe termina a "

"execução, seu quadro de execução é descartado, mas seu espaço de nomes local "

"é salvo. [#]_ Um objeto classe é então criado usando a lista de herança para "

"as classes base e o espaço de nomes local salvo para o dicionário de "

"atributos. O nome da classe é vinculado a este objeto classe no espaço de "

"nomes local original."

#: ../../reference/compound_stmts.rst:704

msgid ""

"The order in which attributes are defined in the class body is preserved in "

"the new class's ``__dict__``. Note that this is reliable only right after "

"the class is created and only for classes that were defined using the "

"definition syntax."

msgstr ""

#: ../../reference/compound_stmts.rst:709

msgid ""

"Class creation can be customized heavily using :ref:`metaclasses "

"<metaclasses>`."

msgstr ""

"A criação de classes pode ser bastante personalizada "

"usando :ref:`metaclasses <metaclasses>`."

#: ../../reference/compound_stmts.rst:714

msgid "Classes can also be decorated: just like when decorating functions, ::"

msgstr ""

"As classes também podem ser decoradas: assim como na decoração de funções, ::"

#: ../../reference/compound_stmts.rst:725

msgid ""

"The evaluation rules for the decorator expressions are the same as for "

"function decorators. The result is then bound to the class name."

msgstr ""

"As regras de execução para as expressões de decorador são as mesmas que para "

"decoradores de função. O resultado é então vinculado ao nome da classe."

#: ../../reference/compound_stmts.rst:728

msgid ""

"**Programmer's note:** Variables defined in the class definition are class "

"attributes; they are shared by instances. Instance attributes can be set in "

"a method with ``self.name = value``. Both class and instance attributes are "

"accessible through the notation \"``self.name``\", and an instance attribute "

"hides a class attribute with the same name when accessed in this way. Class "

"attributes can be used as defaults for instance attributes, but using "

"mutable values there can lead to unexpected results. :ref:`Descriptors "

"<descriptors>` can be used to create instance variables with different "

"implementation details."

msgstr ""

"**Nota do programador:** Variáveis ​​definidas na definição de classe são "

"atributos de classe; elas são compartilhadas por instâncias. Atributos de "

"instância podem ser definidos em um método com ``self.nome = valor``. "

"Atributos de classe e instância são acessíveis por meio da notação "

"\"``self.nome``\", e um atributo de instância oculta um atributo de classe "

"com o mesmo nome quando acessado dessa forma. Atributos de classe podem ser "

"usados ​​como padrões para atributos de instância, mas usar valores mutáveis ​​"

"pode levar a resultados inesperados. :ref:`Descritores <descriptors>` podem "

"ser usados para criar variáveis ​​de instância com diferentes detalhes de "

"implementação."

#: ../../reference/compound_stmts.rst:743

msgid ":pep:`3115` - Metaclasses in Python 3000"

msgstr ":pep:`3115` - Metaclasses no Python 3000"

#: ../../reference/compound_stmts.rst:741

msgid ""

"The proposal that changed the declaration of metaclasses to the current "

"syntax, and the semantics for how classes with metaclasses are constructed."

msgstr ""

"A proposta que alterou a declaração de metaclasses para a sintaxe atual e a "

"semântica de como as classes com metaclasses são construídas."

#: ../../reference/compound_stmts.rst:746

msgid ":pep:`3129` - Class Decorators"

msgstr ":pep:`3129` - Class Decorators"

#: ../../reference/compound_stmts.rst:746

msgid ""

"The proposal that added class decorators. Function and method decorators "

"were introduced in :pep:`318`."

msgstr ""

"A proposta que adicionou decoradores de classe. Decoradores de função e "

"método foram introduzidos na :pep:`318`."

#: ../../reference/compound_stmts.rst:753

msgid "Coroutines"

msgstr "Corrotinas"

#: ../../reference/compound_stmts.rst:761

msgid "Coroutine function definition"

msgstr "Definição de função de corrotina"

#: ../../reference/compound_stmts.rst:771

msgid ""

"Execution of Python coroutines can be suspended and resumed at many points "

"(see :term:`coroutine`). Inside the body of a coroutine function, ``await`` "

"and ``async`` identifiers become reserved keywords; :keyword:`await` "

"expressions, :keyword:`async for` and :keyword:`async with` can only be used "

"in coroutine function bodies."

msgstr ""

#: ../../reference/compound_stmts.rst:777

msgid ""

"Functions defined with ``async def`` syntax are always coroutine functions, "

"even if they do not contain ``await`` or ``async`` keywords."

msgstr ""

"Funções definidas com a sintaxe ``async def`` são sempre funções de "

"corrotina, mesmo que não contenham palavras reservadas ``await`` ou "

"``async``."

#: ../../reference/compound_stmts.rst:780

msgid ""

"It is a :exc:`SyntaxError` to use a ``yield from`` expression inside the "

"body of a coroutine function."

msgstr ""

"Ocorre uma :exc:`SyntaxError` se usada uma expressão ``yield from`` dentro "

"do corpo de uma função de corrotina."

#: ../../reference/compound_stmts.rst:783

msgid "An example of a coroutine function::"

msgstr "Um exemplo de uma função de corrotina::"

#: ../../reference/compound_stmts.rst:794

msgid "The :keyword:`!async for` statement"

msgstr "A instrução :keyword:`!async for`"

#: ../../reference/compound_stmts.rst:799

msgid ""

"An :term:`asynchronous iterable` is able to call asynchronous code in its "

"*iter* implementation, and :term:`asynchronous iterator` can call "

"asynchronous code in its *next* method."

msgstr ""

#: ../../reference/compound_stmts.rst:803

msgid ""

"The ``async for`` statement allows convenient iteration over asynchronous "

"iterators."

msgstr ""

#: ../../reference/compound_stmts.rst:813

msgid "Is semantically equivalent to::"

msgstr "É semanticamente equivalente a::"

#: ../../reference/compound_stmts.rst:829

msgid "See also :meth:`__aiter__` and :meth:`__anext__` for details."

msgstr ""

#: ../../reference/compound_stmts.rst:831

msgid ""

"It is a :exc:`SyntaxError` to use an ``async for`` statement outside the "

"body of a coroutine function."

msgstr ""

"Ocorre uma :exc:`SyntaxError` se usada uma instrução ``async for`` fora do "

"corpo de uma função de corrotina."

#: ../../reference/compound_stmts.rst:839

msgid "The :keyword:`!async with` statement"

msgstr "A instrução :keyword:`!async with`"

#: ../../reference/compound_stmts.rst:844

msgid ""

"An :term:`asynchronous context manager` is a :term:`context manager` that is "

"able to suspend execution in its *enter* and *exit* methods."

msgstr ""

"Um :term:`gerenciador de contexto assíncrono` é um :term:`gerenciador de "

"contexto` que é capaz de suspender a execução em seus métodos *enter* e "

"*exit*."

#: ../../reference/compound_stmts.rst:871

msgid "See also :meth:`__aenter__` and :meth:`__aexit__` for details."

msgstr ""

#: ../../reference/compound_stmts.rst:873

msgid ""

"It is a :exc:`SyntaxError` to use an ``async with`` statement outside the "

"body of a coroutine function."

msgstr ""

"Ocorre uma :exc:`SyntaxError` se usada uma instrução ``async with`` fora do "

"corpo de uma função de corrotina."

#: ../../reference/compound_stmts.rst:879

msgid ":pep:`492` - Coroutines with async and await syntax"

msgstr ":pep:`492` - Corrotina com sintaxe de async e wait"

#: ../../reference/compound_stmts.rst:879

msgid ""

"The proposal that made coroutines a proper standalone concept in Python, and "

"added supporting syntax."

msgstr ""

"A proposta que tornou as corrotinas um conceito autônomo em Python e "

"adicionou sintaxe de suporte."

#: ../../reference/compound_stmts.rst:884

msgid "Footnotes"

msgstr "Notas de rodapé"

#: ../../reference/compound_stmts.rst:885

msgid ""

"The exception is propagated to the invocation stack unless there is "

"a :keyword:`finally` clause which happens to raise another exception. That "

"new exception causes the old one to be lost."

msgstr ""

#: ../../reference/compound_stmts.rst:889

msgid ""

"A string literal appearing as the first statement in the function body is "

"transformed into the function's ``__doc__`` attribute and therefore the "