# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-01-25 14:58+0000\n"

"PO-Revision-Date: 2025-09-15 01:05+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\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/expressions.rst:6

msgid "Expressions"

msgstr "Expressões"

#: ../../reference/expressions.rst:10

msgid ""

"This chapter explains the meaning of the elements of expressions in Python."

msgstr ""

"Este capítulo explica o significado dos elementos das expressões em Python."

#: ../../reference/expressions.rst:12

msgid ""

"**Syntax Notes:** In this and the following chapters, extended BNF notation "

"will be used to describe syntax, not lexical analysis. When (one "

"alternative of) a syntax rule has the form"

msgstr ""

"**Notas de sintaxe:** Neste e nos capítulos seguintes, a notação BNF "

"estendida será usada para descrever a sintaxe, não a análise lexical. Quando "

"(uma alternativa de) uma regra de sintaxe tem a forma"

#: ../../reference/expressions.rst:19

msgid ""

"and no semantics are given, the semantics of this form of ``name`` are the "

"same as for ``othername``."

msgstr ""

"e nenhuma semântica é fornecida, a semântica desta forma de ``name`` é a "

"mesma que para ``othername``."

#: ../../reference/expressions.rst:26

msgid "Arithmetic conversions"

msgstr "Conversões aritméticas"

#: ../../reference/expressions.rst:30

msgid ""

"When a description of an arithmetic operator below uses the phrase \"the "

"numeric arguments are converted to a common type\", this means that the "

"operator implementation for built-in types works as follows:"

msgstr ""

"Quando uma descrição de um operador aritmético abaixo usa a frase \"os "

"argumentos numéricos são convertidos em um tipo comum\", isso significa que "

"a implementação do operador para tipos embutidos funciona da seguinte "

"maneira:"

#: ../../reference/expressions.rst:34

msgid ""

"If either argument is a complex number, the other is converted to complex;"

msgstr ""

"Se um dos argumentos for um número complexo, o outro será convertido em "

"complexo;"

#: ../../reference/expressions.rst:36

msgid ""

"otherwise, if either argument is a floating-point number, the other is "

"converted to floating point;"

msgstr ""

"caso contrário, se um dos argumentos for um número de ponto flutuante, o "

"outro será convertido em ponto flutuante;"

#: ../../reference/expressions.rst:39

msgid "otherwise, both must be integers and no conversion is necessary."

msgstr ""

"caso contrário, ambos devem ser inteiros e nenhuma conversão é necessária."

#: ../../reference/expressions.rst:41

msgid ""

"Some additional rules apply for certain operators (e.g., a string as a left "

"argument to the '%' operator). Extensions must define their own conversion "

"behavior."

msgstr ""

"Algumas regras adicionais se aplicam a certos operadores (por exemplo, uma "

"string como um argumento à esquerda para o operador '%'). As extensões devem "

"definir seu próprio comportamento de conversão."

#: ../../reference/expressions.rst:49

msgid "Atoms"

msgstr "Átomos"

#: ../../reference/expressions.rst:53

msgid ""

"Atoms are the most basic elements of expressions. The simplest atoms are "

"identifiers or literals. Forms enclosed in parentheses, brackets or braces "

"are also categorized syntactically as atoms. The syntax for atoms is:"

msgstr ""

"Os átomos são os elementos mais básicos das expressões. Os átomos mais "

"simples são identificadores ou literais. As formas entre parênteses, "

"colchetes ou chaves também são categorizadas sintaticamente como átomos. A "

"sintaxe para átomos é:"

#: ../../reference/expressions.rst:66

msgid "Identifiers (Names)"

msgstr "Identificadores (Nomes)"

#: ../../reference/expressions.rst:70

msgid ""

"An identifier occurring as an atom is a name. See section :ref:"

"`identifiers` for lexical definition and section :ref:`naming` for "

"documentation of naming and binding."

msgstr ""

"Um identificador que ocorre como um átomo é um nome. Veja a seção :ref:"

"`identifiers` para a definição lexical e a seção :ref:`naming` para "

"documentação de nomenclatura e ligação."

#: ../../reference/expressions.rst:76

msgid ""

"When the name is bound to an object, evaluation of the atom yields that "

"object. When a name is not bound, an attempt to evaluate it raises a :exc:"

"`NameError` exception."

msgstr ""

"Quando o nome está vinculado a um objeto, a avaliação do átomo produz esse "

"objeto. Quando um nome não está vinculado, uma tentativa de avaliá-lo "

"levanta uma exceção :exc:`NameError`."

#: ../../reference/expressions.rst:87

msgid "Private name mangling"

msgstr "Desfiguração de nome privado"

#: ../../reference/expressions.rst:89

msgid ""

"When an identifier that textually occurs in a class definition begins with "

"two or more underscore characters and does not end in two or more "

"underscores, it is considered a :dfn:`private name` of that class."

msgstr ""

"Quando um identificador que ocorre textualmente em uma definição de classe "

"começa com dois ou mais caracteres de sublinhado e não termina com dois ou "

"mais sublinhados, ele é considerado um :dfn:`nome privado` daquela classe."

#: ../../reference/expressions.rst:95

msgid "The :ref:`class specifications <class>`."

msgstr "As :ref:`especificações de classe <class>`."

#: ../../reference/expressions.rst:97

msgid ""

"More precisely, private names are transformed to a longer form before code "

"is generated for them. If the transformed name is longer than 255 "

"characters, implementation-defined truncation may happen."

msgstr ""

"Mais precisamente, os nomes privados são transformados em um formato mais "

"longo antes que o código seja gerado para eles. Se o nome transformado tiver "

"mais de 255 caracteres, poderá ocorrer truncamento definido pela "

"implementação."

#: ../../reference/expressions.rst:101

msgid ""

"The transformation is independent of the syntactical context in which the "

"identifier is used but only the following private identifiers are mangled:"

msgstr ""

"A transformação é independente do contexto sintático no qual o identificador "

"é usado, mas apenas os seguintes identificadores privados são desfigurados:"

#: ../../reference/expressions.rst:104

msgid ""

"Any name used as the name of a variable that is assigned or read or any name "

"of an attribute being accessed."

msgstr ""

"Qualquer nome usado como nome de uma variável que é atribuída ou lida ou "

"qualquer nome de um atributo que está sendo acessado."

#: ../../reference/expressions.rst:107

msgid ""

"The :attr:`~definition.__name__` attribute of nested functions, classes, and "

"type aliases is however not mangled."

msgstr ""

"O atributo :attr:`~definition.__name__` de funções aninhadas, classes e "

"apelidos de tipo, entretanto, não é desfigurado."

#: ../../reference/expressions.rst:110

msgid ""

"The name of imported modules, e.g., ``__spam`` in ``import __spam``. If the "

"module is part of a package (i.e., its name contains a dot), the name is "

"*not* mangled, e.g., the ``__foo`` in ``import __foo.bar`` is not mangled."

msgstr ""

"O nome dos módulos importados, por exemplo, ``__spam`` em ``import __spam``. "

"Se o módulo faz parte de um pacote (ou seja, seu nome contém um ponto), o "

"nome *não* é desfigurado, por exemplo, o ``__foo`` em ``import __foo.bar`` "

"não é desfigurado."

#: ../../reference/expressions.rst:115

msgid ""

"The name of an imported member, e.g., ``__f`` in ``from spam import __f``."

msgstr ""

"O nome de um membro importado, por exemplo, ``__f`` em ``from spam import "

"__f``."

#: ../../reference/expressions.rst:117

msgid "The transformation rule is defined as follows:"

msgstr "A regra de transformação está definida da seguinte forma:"

#: ../../reference/expressions.rst:119

msgid ""

"The class name, with leading underscores removed and a single leading "

"underscore inserted, is inserted in front of the identifier, e.g., the "

"identifier ``__spam`` occurring in a class named ``Foo``, ``_Foo`` or "

"``__Foo`` is transformed to ``_Foo__spam``."

msgstr ""

"O nome da classe, com os sublinhados iniciais removidos e um único "

"sublinhado inicial inserido, é inserido na frente do identificador, por "

"exemplo, o identificador ``__spam`` ocorrendo em uma classe chamada ``Foo``, "

"``_Foo`` ou ``__Foo`` é transformado em ``_Foo__spam``."

#: ../../reference/expressions.rst:124

msgid ""

"If the class name consists only of underscores, the transformation is the "

"identity, e.g., the identifier ``__spam`` occurring in a class named ``_`` "

"or ``__`` is left as is."

msgstr ""

"Se o nome da classe consiste apenas em sublinhados, a transformação é a "

"identidade, por exemplo, o identificador ``__spam`` que ocorre em uma classe "

"chamada ``_`` ou ``__`` é deixado como está."

#: ../../reference/expressions.rst:131

msgid "Literals"

msgstr "Literais"

#: ../../reference/expressions.rst:135

msgid "Python supports string and bytes literals and various numeric literals:"

msgstr ""

"Python oferece suporte a strings e bytes literais e vários literais "

"numéricos:"

#: ../../reference/expressions.rst:141

msgid ""

"Evaluation of a literal yields an object of the given type (string, bytes, "

"integer, floating-point number, complex number) with the given value. The "

"value may be approximated in the case of floating-point and imaginary "

"(complex) literals. See section :ref:`literals` for details."

msgstr ""

"A avaliação de um literal produz um objeto do tipo fornecido (string, bytes, "

"inteiro, número de ponto flutuante, número complexo) com o valor fornecido. "

"O valor pode ser aproximado no caso de ponto flutuante e literais "

"imaginários (complexos). Veja a seção :ref:`literals` para detalhes."

#: ../../reference/expressions.rst:150

msgid ""

"All literals correspond to immutable data types, and hence the object's "

"identity is less important than its value. Multiple evaluations of literals "

"with the same value (either the same occurrence in the program text or a "

"different occurrence) may obtain the same object or a different object with "

"the same value."

msgstr ""

"Todos os literais correspondem a tipos de dados imutáveis e, portanto, a "

"identidade do objeto é menos importante que seu valor. Múltiplas avaliações "

"de literais com o mesmo valor (seja a mesma ocorrência no texto do programa "

"ou uma ocorrência diferente) podem obter o mesmo objeto ou um objeto "

"diferente com o mesmo valor."

#: ../../reference/expressions.rst:160

msgid "Parenthesized forms"

msgstr "Formas de parênteses"

#: ../../reference/expressions.rst:166

msgid ""

"A parenthesized form is an optional expression list enclosed in parentheses:"

msgstr ""

"Um forma entre parênteses é uma lista de expressões opcional entre "

"parênteses:"

#: ../../reference/expressions.rst:171

msgid ""

"A parenthesized expression list yields whatever that expression list yields: "

"if the list contains at least one comma, it yields a tuple; otherwise, it "

"yields the single expression that makes up the expression list."

msgstr ""

"Uma lista de expressões entre parênteses produz tudo o que aquela lista de "

"expressões produz: se a lista contiver pelo menos uma vírgula, ela produzirá "

"uma tupla; caso contrário, produz a única expressão que compõe a lista de "

"expressões."

#: ../../reference/expressions.rst:177

msgid ""

"An empty pair of parentheses yields an empty tuple object. Since tuples are "

"immutable, the same rules as for literals apply (i.e., two occurrences of "

"the empty tuple may or may not yield the same object)."

msgstr ""

"Um par de parênteses vazio produz um objeto tupla vazio. Como as tuplas são "

"imutáveis, aplicam-se as mesmas regras dos literais (isto é, duas "

"ocorrências da tupla vazia podem ou não produzir o mesmo objeto)."

#: ../../reference/expressions.rst:185

msgid ""

"Note that tuples are not formed by the parentheses, but rather by use of the "

"comma. The exception is the empty tuple, for which parentheses *are* "

"required --- allowing unparenthesized \"nothing\" in expressions would cause "

"ambiguities and allow common typos to pass uncaught."

msgstr ""

"Observe que as tuplas não são formadas pelos parênteses, mas sim pelo uso da "

"vírgula. A exceção é a tupla vazia, para a qual os parênteses *são* "

"obrigatórios -- permitir \"nada\" sem parênteses em expressões causaria "

"ambiguidades e permitiria que erros de digitação comuns passassem sem serem "

"detectados."

#: ../../reference/expressions.rst:194

msgid "Displays for lists, sets and dictionaries"

msgstr "Sintaxe de criação de listas, conjuntos e dicionários"

#: ../../reference/expressions.rst:198

msgid ""

"For constructing a list, a set or a dictionary Python provides special "

"syntax called \"displays\", each of them in two flavors:"

msgstr ""

"Para construir uma lista, um conjunto ou um dicionário, o Python fornece uma "

"sintaxe especial chamada \"sintaxes de criação\" (em inglês, *displays*), "

"cada uma delas em dois tipos:"

#: ../../reference/expressions.rst:201

msgid "either the container contents are listed explicitly, or"

msgstr "o conteúdo do contêiner é listado explicitamente ou"

#: ../../reference/expressions.rst:203

msgid ""

"they are computed via a set of looping and filtering instructions, called a :"

"dfn:`comprehension`."

msgstr ""

"eles são calculados por meio de um conjunto de instruções de laço e "

"filtragem, chamado de :dfn:`compreensão`."

#: ../../reference/expressions.rst:211

msgid "Common syntax elements for comprehensions are:"

msgstr "Elementos de sintaxe comuns para compreensões são:"

#: ../../reference/expressions.rst:219

msgid ""

"The comprehension consists of a single expression followed by at least one :"

"keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` "

"clauses. In this case, the elements of the new container are those that "

"would be produced by considering each of the :keyword:`!for` or :keyword:`!"

"if` clauses a block, nesting from left to right, and evaluating the "

"expression to produce an element each time the innermost block is reached."

msgstr ""

"A compreensão consiste em uma única expressão seguida por pelo menos uma "

"cláusula :keyword:`!for` e zero ou mais cláusulas :keyword:`!for` ou :"

"keyword:`!if`. Neste caso, os elementos do novo contêiner são aqueles que "

"seriam produzidos considerando cada uma das cláusulas :keyword:`!for` ou :"

"keyword:`!if` de um bloco, aninhando da esquerda para a direita, e avaliando "

"a expressão para produzir um elemento cada vez que o bloco mais interno é "

"alcançado."

#: ../../reference/expressions.rst:226

msgid ""

"However, aside from the iterable expression in the leftmost :keyword:`!for` "

"clause, the comprehension is executed in a separate implicitly nested scope. "

"This ensures that names assigned to in the target list don't \"leak\" into "

"the enclosing scope."

msgstr ""

"No entanto, além da expressão iterável na cláusula :keyword:`!for` mais à "

"esquerda, a compreensão é executada em um escopo aninhado implicitamente "

"separado. Isso garante que os nomes atribuídos na lista de destino não "

"\"vazem\" para o escopo delimitador."

#: ../../reference/expressions.rst:230

msgid ""

"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "

"directly in the enclosing scope and then passed as an argument to the "

"implicitly nested scope. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``[x*y for x in range(10) for y in range(x, x+10)]``."

msgstr ""

"A expressão iterável na cláusula :keyword:`!for` mais à esquerda é avaliada "

"diretamente no escopo envolvente e então passada como um argumento para o "

"escopo aninhado implicitamente. Cláusulas :keyword:`!for` subsequentes e "

"qualquer condição de filtro na cláusula :keyword:`!for` mais à esquerda não "

"podem ser avaliadas no escopo delimitador, pois podem depender dos valores "

"obtidos do iterável mais à esquerda. Por exemplo: ``[x*y for x in range(10) "

"for y in range(x, x+10)]``."

#: ../../reference/expressions.rst:237

msgid ""

"To ensure the comprehension always results in a container of the appropriate "

"type, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly nested scope."

msgstr ""

"Para garantir que a compreensão sempre resulte em um contêiner do tipo "

"apropriado, as expressões ``yield`` e ``yield from`` são proibidas no escopo "

"aninhado implicitamente."

#: ../../reference/expressions.rst:244

msgid ""

"Since Python 3.6, in an :keyword:`async def` function, an :keyword:`!async "

"for` clause may be used to iterate over a :term:`asynchronous iterator`. A "

"comprehension in an :keyword:`!async def` function may consist of either a :"

"keyword:`!for` or :keyword:`!async for` clause following the leading "

"expression, may contain additional :keyword:`!for` or :keyword:`!async for` "

"clauses, and may also use :keyword:`await` expressions."

msgstr ""

"Desde o Python 3.6, em uma função :keyword:`async def`, uma cláusula :"

"keyword:`!async for` pode ser usada para iterar sobre um :term:`iterador "

"assíncrono`. Uma compreensão em uma função :keyword:`!async def` pode "

"consistir em uma cláusula :keyword:`!for` ou :keyword:`!async for` seguindo "

"a expressão inicial, pode conter :keyword:`!for` adicional ou :keyword:`!"

"async for` e também pode usar expressões :keyword:`await`."

#: ../../reference/expressions.rst:251

msgid ""

"If a comprehension contains :keyword:`!async for` clauses, or if it "

"contains :keyword:`!await` expressions or other asynchronous comprehensions "

"anywhere except the iterable expression in the leftmost :keyword:`!for` "

"clause, it is called an :dfn:`asynchronous comprehension`. An asynchronous "

"comprehension may suspend the execution of the coroutine function in which "

"it appears. See also :pep:`530`."

msgstr ""

"Se uma compreensão contém cláusulas :keyword:`!async for`, ou se contém "

"expressões :keyword:`!await` ou outras compreensões assíncronas em qualquer "

"lugar, exceto a expressão iterável na cláusula :keyword:`!for` mais à "

"esquerda, ela é chamada uma :dfn:`compreensão assíncrona`. Uma compreensão "

"assíncrona pode suspender a execução da função de corrotina em que aparece. "

"Veja também a :pep:`530`."

#: ../../reference/expressions.rst:258

msgid "Asynchronous comprehensions were introduced."

msgstr "Compreensões assíncronas foram introduzidas."

#: ../../reference/expressions.rst:261 ../../reference/expressions.rst:440

msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."

msgstr "``yield`` e ``yield from`` proibidos no escopo aninhado implícito."

#: ../../reference/expressions.rst:264

msgid ""

"Asynchronous comprehensions are now allowed inside comprehensions in "

"asynchronous functions. Outer comprehensions implicitly become asynchronous."

msgstr ""

"Compreensões assíncronas agora são permitidas dentro de compreensões em "

"funções assíncronas. As compreensões externas tornam-se implicitamente "

"assíncronas."

#: ../../reference/expressions.rst:273

msgid "List displays"

msgstr "Sintaxes de criação de lista"

#: ../../reference/expressions.rst:283

msgid ""

"A list display is a possibly empty series of expressions enclosed in square "

"brackets:"

msgstr ""

"Uma sintaxe de criação de lista é uma série possivelmente vazia de "

"expressões entre colchetes:"

#: ../../reference/expressions.rst:289

msgid ""

"A list display yields a new list object, the contents being specified by "

"either a list of expressions or a comprehension. When a comma-separated "

"list of expressions is supplied, its elements are evaluated from left to "

"right and placed into the list object in that order. When a comprehension "

"is supplied, the list is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Uma sintaxe de criação de lista produz um novo objeto de lista, sendo o "

"conteúdo especificado por uma lista de expressões ou uma compreensão. Quando "

"uma lista de expressões separadas por vírgulas é fornecida, seus elementos "

"são avaliados da esquerda para a direita e colocados no objeto de lista "

"nessa ordem. Quando uma compreensão é fornecida, a lista é construída a "

"partir dos elementos resultantes da compreensão."

#: ../../reference/expressions.rst:299

msgid "Set displays"

msgstr "Sintaxes de criação de conjunto"

#: ../../reference/expressions.rst:308

msgid ""

"A set display is denoted by curly braces and distinguishable from dictionary "

"displays by the lack of colons separating keys and values:"

msgstr ""

"Uma sintaxe de criação definida é denotada por chaves e distinguível de "

"sintaxes de criação de dicionário pela falta de caractere de dois pontos "

"separando chaves e valores:"

#: ../../reference/expressions.rst:314

msgid ""

"A set display yields a new mutable set object, the contents being specified "

"by either a sequence of expressions or a comprehension. When a comma-"

"separated list of expressions is supplied, its elements are evaluated from "

"left to right and added to the set object. When a comprehension is "

"supplied, the set is constructed from the elements resulting from the "

"comprehension."

msgstr ""

"Uma sintaxe de criação de conjunto produz um novo objeto de conjunto "

"mutável, sendo o conteúdo especificado por uma sequência de expressões ou "

"uma compreensão. Quando uma lista de expressões separadas por vírgula é "

"fornecida, seus elementos são avaliados da esquerda para a direita e "

"adicionados ao objeto definido. Quando uma compreensão é fornecida, o "

"conjunto é construído a partir dos elementos resultantes da compreensão."

#: ../../reference/expressions.rst:320

msgid ""

"An empty set cannot be constructed with ``{}``; this literal constructs an "

"empty dictionary."

msgstr ""

"Um conjunto vazio não pode ser construído com ``{}``; este literal constrói "

"um dicionário vazio."

#: ../../reference/expressions.rst:327

msgid "Dictionary displays"

msgstr "Sintaxes de criação de dicionário"

#: ../../reference/expressions.rst:338

msgid ""

"A dictionary display is a possibly empty series of dict items (key/value "

"pairs) enclosed in curly braces:"

msgstr ""

"Uma sintaxe de criação de dicionário é uma série possivelmente vazia de "

"itens de dicionário (pares chave/valor) envolto entre chaves:"

#: ../../reference/expressions.rst:347

msgid "A dictionary display yields a new dictionary object."

msgstr "Uma sintaxe de criação de dicionário produz um novo objeto dicionário."

#: ../../reference/expressions.rst:349

msgid ""

"If a comma-separated sequence of dict items is given, they are evaluated "

"from left to right to define the entries of the dictionary: each key object "

"is used as a key into the dictionary to store the corresponding value. This "

"means that you can specify the same key multiple times in the dict item "

"list, and the final dictionary's value for that key will be the last one "

"given."

msgstr ""

"Se for fornecida uma sequência separada por vírgulas de itens de dicionário, "

"eles são avaliados da esquerda para a direita para definir as entradas do "

"dicionário: cada objeto chave é usado como uma chave no dicionário para "

"armazenar o valor correspondente. Isso significa que você pode especificar a "

"mesma chave várias vezes na lista de itens de dicionário, e o valor final do "

"dicionário para essa chave será o último dado."

#: ../../reference/expressions.rst:359

msgid ""

"A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand "

"must be a :term:`mapping`. Each mapping item is added to the new "

"dictionary. Later values replace values already set by earlier dict items "

"and earlier dictionary unpackings."

msgstr ""

"Um asterisco duplo ``**`` denota :dfn:`desempacotamento do dicionário`. Seu "

"operando deve ser um :term:`mapeamento`. Cada item de mapeamento é "

"adicionado ao novo dicionário. Os valores posteriores substituem os valores "

"já definidos por itens de dicionário anteriores e desempacotamentos de "

"dicionário anteriores."

#: ../../reference/expressions.rst:364

msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."

msgstr ""

"Desempacotando em sintaxes de criação de dicionário, originalmente proposto "

"pela :pep:`448`."

#: ../../reference/expressions.rst:367

msgid ""

"A dict comprehension, in contrast to list and set comprehensions, needs two "

"expressions separated with a colon followed by the usual \"for\" and \"if\" "

"clauses. When the comprehension is run, the resulting key and value elements "

"are inserted in the new dictionary in the order they are produced."

msgstr ""

"Uma compreensão de dict, em contraste com as compreensões de lista e "

"conjunto, precisa de duas expressões separadas por dois pontos, seguidas "

"pelas cláusulas usuais \"for\" e \"if\". Quando a compreensão é executada, "

"os elementos chave e valor resultantes são inseridos no novo dicionário na "

"ordem em que são produzidos."

#: ../../reference/expressions.rst:375

msgid ""

"Restrictions on the types of the key values are listed earlier in section :"

"ref:`types`. (To summarize, the key type should be :term:`hashable`, which "

"excludes all mutable objects.) Clashes between duplicate keys are not "

"detected; the last value (textually rightmost in the display) stored for a "

"given key value prevails."

msgstr ""

"Restrições nos tipos de valores de chave são listadas anteriormente na "

"seção :ref:`types`. (Para resumir, o tipo de chave deve ser :term:"

"`hasheável`, que exclui todos os objetos mutáveis.) Não são detectadas "

"colisões entre chaves duplicadas; o último valor (textualmente mais à "

"direita na sintaxe de criação) armazenado para um determinado valor de chave "

"prevalece."

#: ../../reference/expressions.rst:381

msgid ""

"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "

"value was not well-defined. In CPython, the value was evaluated before the "

"key. Starting with 3.8, the key is evaluated before the value, as proposed "

"by :pep:`572`."

msgstr ""

"Antes do Python 3.8, em compreensões de dict, a ordem de avaliação de chave "

"e valor não era bem definida. No CPython, o valor foi avaliado antes da "

"chave. A partir de 3.8, a chave é avaliada antes do valor, conforme proposto "

"pela :pep:`572`."

#: ../../reference/expressions.rst:391

msgid "Generator expressions"

msgstr "Expressões geradoras"

#: ../../reference/expressions.rst:398

msgid "A generator expression is a compact generator notation in parentheses:"

msgstr ""

"Uma expressão geradora é uma notação geradora compacta entre parênteses:"

#: ../../reference/expressions.rst:403

msgid ""

"A generator expression yields a new generator object. Its syntax is the "

"same as for comprehensions, except that it is enclosed in parentheses "

"instead of brackets or curly braces."

msgstr ""

"Uma expressão geradora produz um novo objeto gerador. Sua sintaxe é a mesma "

"das compreensões, exceto pelo fato de estar entre parênteses em vez de "

"colchetes ou chaves."

#: ../../reference/expressions.rst:407

msgid ""

"Variables used in the generator expression are evaluated lazily when the :"

"meth:`~generator.__next__` method is called for the generator object (in the "

"same fashion as normal generators). However, the iterable expression in the "

"leftmost :keyword:`!for` clause is immediately evaluated, and the :term:"

"`iterator` is immediately created for that iterable, so that an error "

"produced while creating the iterator will be emitted at the point where the "

"generator expression is defined, rather than at the point where the first "

"value is retrieved. Subsequent :keyword:`!for` clauses and any filter "

"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "

"enclosing scope as they may depend on the values obtained from the leftmost "

"iterable. For example: ``(x*y for x in range(10) for y in range(x, x+10))``."

msgstr ""

"As variáveis usadas na expressão geradora são avaliadas lentamente quando o "

"método :meth:`~generator.__next__` é chamado para o objeto gerador (da mesma "

"forma que os geradores normais). No entanto, a expressão iterável na "

"cláusula :keyword:`!for` mais à esquerda é avaliada imediatamente e o :term:"

"`iterador` é imediatamente criado para aquele iterável, de modo que um erro "

"produzido enquanto cria o iterador será emitido no ponto em que a expressão "

"geradora é definida, em vez de no ponto em que o primeiro valor é "

"recuperado. Cláusulas :keyword:`!for` subsequentes e qualquer condição de "

"filtro na cláusula :keyword:`!for` mais à esquerda não podem ser avaliadas "

"no escopo delimitador, pois podem depender dos valores obtidos do iterável "

"mais à esquerda. Por exemplo: ``(x*y for x in range(10) for y in range(x, "

"x+10))``."

#: ../../reference/expressions.rst:419

msgid ""

"The parentheses can be omitted on calls with only one argument. See "

"section :ref:`calls` for details."

msgstr ""

"Os parênteses podem ser omitidos em chamadas com apenas um argumento. Veja a "

"seção :ref:`calls` para detalhes."

#: ../../reference/expressions.rst:422

msgid ""

"To avoid interfering with the expected operation of the generator expression "

"itself, ``yield`` and ``yield from`` expressions are prohibited in the "

"implicitly defined generator."

msgstr ""

"Para evitar interferir com a operação esperada da própria expressão "

"geradora, as expressões ``yield`` e ``yield from`` são proibidas no gerador "

"definido implicitamente."

#: ../../reference/expressions.rst:426

msgid ""

"If a generator expression contains either :keyword:`!async for` clauses or :"

"keyword:`await` expressions it is called an :dfn:`asynchronous generator "

"expression`. An asynchronous generator expression returns a new "

"asynchronous generator object, which is an asynchronous iterator (see :ref:"

"`async-iterators`)."

msgstr ""

"Se uma expressão geradora contém cláusulas :keyword:`!async for` ou "

"expressões :keyword:`await`, ela é chamada de :dfn:`expressão geradora "

"assíncrona`. Uma expressão geradora assíncrona retorna um novo objeto "

"gerador assíncrono, que é um iterador assíncrono (consulte :ref:`async-"

"iterators`)."

#: ../../reference/expressions.rst:432

msgid "Asynchronous generator expressions were introduced."

msgstr "Expressões geradoras assíncronas foram introduzidas."

#: ../../reference/expressions.rst:435

msgid ""

"Prior to Python 3.7, asynchronous generator expressions could only appear "

"in :keyword:`async def` coroutines. Starting with 3.7, any function can use "

"asynchronous generator expressions."

msgstr ""

"Antes do Python 3.7, as expressões geradoras assíncronas só podiam aparecer "

"em corrotinas :keyword:`async def`. A partir da versão 3.7, qualquer função "

"pode usar expressões geradoras assíncronas."

#: ../../reference/expressions.rst:447

msgid "Yield expressions"

msgstr "Expressões yield"

#: ../../reference/expressions.rst:460

msgid ""

"The yield expression is used when defining a :term:`generator` function or "

"an :term:`asynchronous generator` function and thus can only be used in the "

"body of a function definition. Using a yield expression in a function's "

"body causes that function to be a generator function, and using it in an :"

"keyword:`async def` function's body causes that coroutine function to be an "

"asynchronous generator function. For example::"

msgstr ""

"A expressão yield é usada ao definir uma função :term:`geradora <gerador>` "

"ou uma função :term:`geradora assíncrona <gerador assíncrono>` e, portanto, "

"só pode ser usada no corpo de uma definição de função. Usar uma expressão "

"yield no corpo de uma função faz com que essa função seja uma função "

"geradora, e usá-la no corpo de uma função :keyword:`async def` faz com que "

"essa função de corrotina seja uma função geradora assíncrona. Por exemplo::"

#: ../../reference/expressions.rst:467

msgid ""

"def gen(): # defines a generator function\n"

" yield 123\n"

"\n"

"async def agen(): # defines an asynchronous generator function\n"

" yield 123"

msgstr ""

"def gen(): # define uma função geradora\n"

" yield 123\n"

"\n"

"async def agen(): # define uma função geradora assíncrona\n"

" yield 123"

#: ../../reference/expressions.rst:473

msgid ""

"Due to their side effects on the containing scope, ``yield`` expressions are "

"not permitted as part of the implicitly defined scopes used to implement "

"comprehensions and generator expressions."

msgstr ""

"Devido a seus efeitos colaterais no escopo recipiente, as expressões "

"``yield`` não são permitidas como parte dos escopos definidos implicitamente "

"usados para implementar compreensões e expressões geradoras."

#: ../../reference/expressions.rst:477

msgid ""

"Yield expressions prohibited in the implicitly nested scopes used to "

"implement comprehensions and generator expressions."

msgstr ""

"Expressões yield proibidas nos escopos aninhados implicitamente usados para "

"implementar compreensões e expressões geradoras."

#: ../../reference/expressions.rst:481

msgid ""

"Generator functions are described below, while asynchronous generator "

"functions are described separately in section :ref:`asynchronous-generator-"

"functions`."

msgstr ""

"As funções geradoras são descritas abaixo, enquanto as funções geradoras "

"assíncronas são descritas separadamente na seção :ref:`asynchronous-"

"generator-functions`"

#: ../../reference/expressions.rst:485

msgid ""

"When a generator function is called, it returns an iterator known as a "

"generator. That generator then controls the execution of the generator "

"function. The execution starts when one of the generator's methods is "

"called. At that time, the execution proceeds to the first yield expression, "

"where it is suspended again, returning the value of :token:`~python-grammar:"

"yield_list` to the generator's caller, or ``None`` if :token:`~python-"

"grammar:yield_list` is omitted. By suspended, we mean that all local state "

"is retained, including the current bindings of local variables, the "

"instruction pointer, the internal evaluation stack, and the state of any "

"exception handling. When the execution is resumed by calling one of the "

"generator's methods, the function can proceed exactly as if the yield "

"expression were just another external call. The value of the yield "

"expression after resuming depends on the method which resumed the "

"execution. If :meth:`~generator.__next__` is used (typically via either a :"

"keyword:`for` or the :func:`next` builtin) then the result is :const:"

"`None`. Otherwise, if :meth:`~generator.send` is used, then the result will "

"be the value passed in to that method."

msgstr ""

"Quando uma função geradora é chamada, ela retorna um iterador conhecido como "

"gerador. Esse gerador então controla a execução da função geradora. A "

"execução começa quando um dos métodos do gerador é chamado. Nesse momento, a "

"execução segue para a primeira expressão yield, onde é suspensa novamente, "

"retornando o valor de :token:`~python-grammar:yield_list` ao chamador do "

"gerador, ou ``None`` se :token:`~python-grammar:yield_list` é omitido. Por "

"suspenso, queremos dizer que todo o estado local é retido, incluindo as "

"chamadas atuais de variáveis locais, o ponteiro de instrução, a pilha de "

"avaliação interna e o estado de qualquer tratamento de exceção. Quando a "

"execução é retomada chamando um dos métodos do gerador, a função pode "

"prosseguir exatamente como se a expressão yield fosse apenas outra chamada "

"externa. O valor da expressão yield após a retomada depende do método que "

"retomou a execução. Se :meth:`~generator.__next__` for usado (tipicamente "

"através de uma :keyword:`for` ou do :func:`next` embutido) então o resultado "

"será :const:`None`. Caso contrário, se :meth:`~generator.send` for usado, o "

"resultado será o valor passado para esse método."

#: ../../reference/expressions.rst:505

msgid ""

"All of this makes generator functions quite similar to coroutines; they "

"yield multiple times, they have more than one entry point and their "

"execution can be suspended. The only difference is that a generator "

"function cannot control where the execution should continue after it yields; "

"the control is always transferred to the generator's caller."

msgstr ""

"Tudo isso torna as funções geradoras bastante semelhantes às corrotinas; "

"cedem múltiplas vezes, possuem mais de um ponto de entrada e sua execução "

"pode ser suspensa. A única diferença é que uma função geradora não pode "

"controlar onde a execução deve continuar após o seu rendimento; o controle é "

"sempre transferido para o chamador do gerador."

#: ../../reference/expressions.rst:511

msgid ""

"Yield expressions are allowed anywhere in a :keyword:`try` construct. If "

"the generator is not resumed before it is finalized (by reaching a zero "

"reference count or by being garbage collected), the generator-iterator's :"

"meth:`~generator.close` method will be called, allowing any pending :keyword:"

"`finally` clauses to execute."

msgstr ""

"Expressões yield são permitidas em qualquer lugar em uma construção :keyword:"

"`try`. Se o gerador não for retomado antes de ser finalizado (ao atingir uma "

"contagem de referências zero ou ao ser coletado como lixo), o método :meth:"

"`~generator.close` do iterador de gerador será chamado, permitindo que "

"quaisquer cláusulas :keyword:`finally` pendentes sejam executadas."

#: ../../reference/expressions.rst:520

msgid ""

"When ``yield from <expr>`` is used, the supplied expression must be an "

"iterable. The values produced by iterating that iterable are passed directly "

"to the caller of the current generator's methods. Any values passed in with :"

"meth:`~generator.send` and any exceptions passed in with :meth:`~generator."

"throw` are passed to the underlying iterator if it has the appropriate "

"methods. If this is not the case, then :meth:`~generator.send` will raise :"

"exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` "

"will just raise the passed in exception immediately."

msgstr ""

"Quando ``yield from <expr>`` é usado, a expressão fornecida deve ser "

"iterável. Os valores produzidos pela iteração desse iterável são passados "

"diretamente para o chamador dos métodos do gerador atual. Quaisquer valores "

"passados com :meth:`~generator.send` e quaisquer exceções passadas com :meth:"

"`~generator.throw` são passados para o iterador subjacente se ele tiver os "

"métodos apropriados. Se este não for o caso, então :meth:`~generator.send` "

"irá levantar :exc:`AttributeError` ou :exc:`TypeError`, enquanto :meth:"

"`~generator.throw` irá apenas levantar a exceção passada imediatamente."

#: ../../reference/expressions.rst:529

msgid ""

"When the underlying iterator is complete, the :attr:`~StopIteration.value` "

"attribute of the raised :exc:`StopIteration` instance becomes the value of "

"the yield expression. It can be either set explicitly when raising :exc:"

"`StopIteration`, or automatically when the subiterator is a generator (by "

"returning a value from the subgenerator)."

msgstr ""

"Quando o iterador subjacente estiver completo, o atributo :attr:"

"`~StopIteration.value` da instância :exc:`StopIteration` gerada torna-se o "

"valor da expressão yield. Ele pode ser definido explicitamente ao levantar :"

"exc:`StopIteration` ou automaticamente quando o subiterador é um gerador "

"(retornando um valor do subgerador)."

#: ../../reference/expressions.rst:535

msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."

msgstr ""

"Adicionado ``yield from <expr>`` para delegar o fluxo de controle a um "

"subiterador."

#: ../../reference/expressions.rst:538

msgid ""

"The parentheses may be omitted when the yield expression is the sole "

"expression on the right hand side of an assignment statement."

msgstr ""

"Os parênteses podem ser omitidos quando a expressão yield é a única "

"expressão no lado direito de uma instrução de atribuição."

#: ../../reference/expressions.rst:543

msgid ":pep:`255` - Simple Generators"

msgstr ":pep:`255` - Simple Generators"

#: ../../reference/expressions.rst:544

msgid ""

"The proposal for adding generators and the :keyword:`yield` statement to "

"Python."

msgstr ""

"A proposta para adicionar geradores e a instrução :keyword:`yield` ao Python."

#: ../../reference/expressions.rst:546

msgid ":pep:`342` - Coroutines via Enhanced Generators"

msgstr ":pep:`342` - Corrotinas via Geradores Aprimorados"

#: ../../reference/expressions.rst:547

msgid ""

"The proposal to enhance the API and syntax of generators, making them usable "

"as simple coroutines."

msgstr ""

"A proposta de aprimorar a API e a sintaxe dos geradores, tornando-os "

"utilizáveis como simples corrotinas."

#: ../../reference/expressions.rst:550

msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"

msgstr ":pep:`380` - Sintaxe para Delegar a um Subgerador"

#: ../../reference/expressions.rst:551

msgid ""

"The proposal to introduce the :token:`~python-grammar:yield_from` syntax, "

"making delegation to subgenerators easy."

msgstr ""

"A proposta de introduzir a sintaxe :token:`~python-grammar:yield_from`, "

"facilitando a delegação a subgeradores."

#: ../../reference/expressions.rst:554

msgid ":pep:`525` - Asynchronous Generators"

msgstr ":pep:`525` - Geradores assíncronos"

#: ../../reference/expressions.rst:555

msgid ""

"The proposal that expanded on :pep:`492` by adding generator capabilities to "

"coroutine functions."

msgstr ""

"A proposta que se expandiu em :pep:`492` adicionando recursos de gerador a "

"funções de corrotina."

#: ../../reference/expressions.rst:562

msgid "Generator-iterator methods"

msgstr "Métodos de iterador gerador"

#: ../../reference/expressions.rst:564

msgid ""

"This subsection describes the methods of a generator iterator. They can be "

"used to control the execution of a generator function."

msgstr ""

"Esta subseção descreve os métodos de um iterador gerador. Eles podem ser "

"usados para controlar a execução de uma função geradora."

#: ../../reference/expressions.rst:567

msgid ""

"Note that calling any of the generator methods below when the generator is "

"already executing raises a :exc:`ValueError` exception."

msgstr ""

"Observe que chamar qualquer um dos métodos do gerador abaixo quando o "

"gerador já estiver em execução levanta uma exceção :exc:`ValueError`."

#: ../../reference/expressions.rst:575

msgid ""

"Starts the execution of a generator function or resumes it at the last "

"executed yield expression. When a generator function is resumed with a :"

"meth:`~generator.__next__` method, the current yield expression always "

"evaluates to :const:`None`. The execution then continues to the next yield "

"expression, where the generator is suspended again, and the value of the :"

"token:`~python-grammar:yield_list` is returned to :meth:`__next__`'s "

"caller. If the generator exits without yielding another value, a :exc:"

"`StopIteration` exception is raised."

msgstr ""

"Inicia a execução de uma função geradora ou a retoma na última expressão "

"yield executada. Quando uma função geradora é retomada com um método :meth:"

"`~generator.__next__`, a expressão yield atual sempre é avaliada como :const:"

"`None`. A execução então continua para a próxima expressão yield, onde o "

"gerador é suspenso novamente, e o valor de :token:`~python-grammar:"

"yield_list` é retornado para o chamador de :meth:`__next__`. Se o gerador "

"sair sem produzir outro valor, uma exceção :exc:`StopIteration` será "

"levantada."

#: ../../reference/expressions.rst:584

msgid ""

"This method is normally called implicitly, e.g. by a :keyword:`for` loop, or "

"by the built-in :func:`next` function."

msgstr ""

"Este método é normalmente chamado implicitamente, por exemplo por um laço :"

"keyword:`for`, ou pela função embutida :func:`next`."

#: ../../reference/expressions.rst:590

msgid ""

"Resumes the execution and \"sends\" a value into the generator function. "

"The *value* argument becomes the result of the current yield expression. "

"The :meth:`send` method returns the next value yielded by the generator, or "

"raises :exc:`StopIteration` if the generator exits without yielding another "

"value. When :meth:`send` is called to start the generator, it must be "

"called with :const:`None` as the argument, because there is no yield "

"expression that could receive the value."

msgstr ""

"Retoma a execução e \"envia\" um valor para a função geradora. O argumento "

"*value* torna-se o resultado da expressão yield atual. O método :meth:`send` "

"retorna o próximo valor gerado pelo gerador, ou levanta :exc:`StopIteration` "

"se o gerador sair sem produzir outro valor. Quando :meth:`send` é chamado "

"para iniciar o gerador, ele deve ser chamado com :const:`None` como "

"argumento, porque não há nenhuma expressão yield que possa receber o valor."

#: ../../reference/expressions.rst:602

msgid ""

"Raises an exception at the point where the generator was paused, and returns "

"the next value yielded by the generator function. If the generator exits "

"without yielding another value, a :exc:`StopIteration` exception is raised. "

"If the generator function does not catch the passed-in exception, or raises "

"a different exception, then that exception propagates to the caller."

msgstr ""

"Levanta uma exceção no ponto em que o gerador foi pausado e retorna o "

"próximo valor gerado pela função geradora. Se o gerador sair sem gerar outro "

"valor, uma exceção :exc:`StopIteration` será levantada. Se a função geradora "

"não detectar a exceção passada ou levanta uma exceção diferente, essa "

"exceção se propagará para o chamador."

#: ../../reference/expressions.rst:608