executionmodel.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 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
# Vinicius Candeia, 2025
# Pedro Fonini <fonini@protonmail.ch>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-01-03 14:14+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../reference/executionmodel.rst:6
msgid "Execution model"
msgstr "Modelo de execução"

#: ../../reference/executionmodel.rst:15
msgid "Structure of a program"
msgstr "Estrutura de um programa"

#: ../../reference/executionmodel.rst:19
msgid ""
"A Python program is constructed from code blocks. A :dfn:`block` is a piece "
"of Python program text that is executed as a unit. The following are blocks: "
"a module, a function body, and a class definition. Each command typed "
"interactively is a block.  A script file (a file given as standard input to "
"the interpreter or specified as a command line argument to the interpreter) "
"is a code block.  A script command (a command specified on the interpreter "
"command line with the :option:`-c` option) is a code block. A module run as "
"a top level script (as module ``__main__``) from the command line using a :"
"option:`-m` argument is also a code block. The string argument passed to the "
"built-in functions :func:`eval` and :func:`exec` is a code block."
msgstr ""
"Um programa Python é construído a partir de blocos de código. Um :dfn:"
"`bloco` é um pedaço do texto do programa Python que é executado como uma "
"unidade. A seguir estão os blocos: um módulo, um corpo de função e uma "
"definição de classe. Cada comando digitado interativamente é um bloco. Um "
"arquivo de script (um arquivo fornecido como entrada padrão para o "
"interpretador ou especificado como argumento de linha de comando para o "
"interpretador) é um bloco de código. Um comando de script (um comando "
"especificado na linha de comando do interpretador com a opção :option:`-c`) "
"é um bloco de código. Um módulo executado sobre um script de nível superior "
"(como o módulo ``__main__``) a partir da linha de comando usando um "
"argumento :option:`-m` também é um bloco de código. O argumento da string "
"passado para as funções embutidas :func:`eval` e :func:`exec` é um bloco de "
"código."

#: ../../reference/executionmodel.rst:33
msgid ""
"A code block is executed in an :dfn:`execution frame`.  A frame contains "
"some administrative information (used for debugging) and determines where "
"and how execution continues after the code block's execution has completed."
msgstr ""
"Um bloco de código é executado em um :dfn:`quadro de execução`. Um quadro "
"contém algumas informações administrativas (usadas para depuração) e "
"determina onde e como a execução continua após a conclusão do bloco de "
"código."

#: ../../reference/executionmodel.rst:40
msgid "Naming and binding"
msgstr "Nomeação e ligação"

#: ../../reference/executionmodel.rst:49
msgid "Binding of names"
msgstr "Ligação de nomes"

#: ../../reference/executionmodel.rst:55
msgid ""
":dfn:`Names` refer to objects.  Names are introduced by name binding "
"operations."
msgstr ""
":dfn:`Nomes` referem-se a objetos. Os nomes são introduzidos por operações "
"de ligação de nomes."

#: ../../reference/executionmodel.rst:59
msgid "The following constructs bind names:"
msgstr "As seguintes construções ligam nomes:"

#: ../../reference/executionmodel.rst:61
msgid "formal parameters to functions,"
msgstr "parâmetros formais para funções,"

#: ../../reference/executionmodel.rst:62
msgid "class definitions,"
msgstr "definições de classe,"

#: ../../reference/executionmodel.rst:63
msgid "function definitions,"
msgstr "definições de função,"

#: ../../reference/executionmodel.rst:64
msgid "assignment expressions,"
msgstr "expressões de atribuição,"

#: ../../reference/executionmodel.rst:65
msgid ""
":ref:`targets <assignment>` that are identifiers if occurring in an "
"assignment:"
msgstr ""
":ref:`alvos <assignment>` que são identificadores se ocorrerem em uma "
"atribuição:"

#: ../../reference/executionmodel.rst:68
msgid ":keyword:`for` loop header,"
msgstr "cabeçalho de laço :keyword:`for`,"

#: ../../reference/executionmodel.rst:69
msgid ""
"after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` "
"clause, :keyword:`except* <except_star>` clause, or in the as-pattern in "
"structural pattern matching,"
msgstr ""
"depois de :keyword:`!as` em uma instrução :keyword:`with`, cláusula :keyword:"
"`except`, cláusula :keyword:`except* <except_star>` ou no padrão as na "
"correspondência de padrões estruturais,"

#: ../../reference/executionmodel.rst:71
msgid "in a capture pattern in structural pattern matching"
msgstr "em um padrão de captura na correspondência de padrões estruturais"

#: ../../reference/executionmodel.rst:73
msgid ":keyword:`import` statements."
msgstr "instruções :keyword:`import`."

#: ../../reference/executionmodel.rst:74
msgid ":keyword:`type` statements."
msgstr "instruções :keyword:`type`."

#: ../../reference/executionmodel.rst:75
msgid ":ref:`type parameter lists <type-params>`."
msgstr ":ref:`listas de parâmetros de tipo <type-params>`."

#: ../../reference/executionmodel.rst:77
msgid ""
"The :keyword:`!import` statement of the form ``from ... import *`` binds all "
"names defined in the imported module, except those beginning with an "
"underscore. This form may only be used at the module level."
msgstr ""
"A instrução :keyword:`!import` no formato ``from ... import *`` liga todos "
"os nomes definidos no módulo importado, exceto aqueles que começam com um "
"sublinhado. Este formulário só pode ser usado no nível do módulo."

#: ../../reference/executionmodel.rst:81
msgid ""
"A target occurring in a :keyword:`del` statement is also considered bound "
"for this purpose (though the actual semantics are to unbind the name)."
msgstr ""
"Um alvo ocorrendo em uma instrução :keyword:`del` também é considerado "
"ligado a esse propósito (embora a semântica real seja para desligar do nome)."

#: ../../reference/executionmodel.rst:84
msgid ""
"Each assignment or import statement occurs within a block defined by a class "
"or function definition or at the module level (the top-level code block)."
msgstr ""
"Cada atribuição ou instrução de importação ocorre dentro de um bloco "
"definido por uma definição de classe ou função ou no nível do módulo (o "
"bloco de código de nível superior)."

#: ../../reference/executionmodel.rst:89
msgid ""
"If a name is bound in a block, it is a local variable of that block, unless "
"declared as :keyword:`nonlocal` or :keyword:`global`.  If a name is bound at "
"the module level, it is a global variable.  (The variables of the module "
"code block are local and global.)  If a variable is used in a code block but "
"not defined there, it is a :term:`free variable`."
msgstr ""
"Se um nome está ligado a um bloco, é uma variável local desse bloco, a menos "
"que declarado como :keyword:`nonlocal` ou :keyword:`global`. Se um nome está "
"ligado a nível do módulo, é uma variável global. (As variáveis do bloco de "
"código do módulo são locais e globais.) Se uma variável for usada em um "
"bloco de código, mas não definida lá, é uma :term:`variável livre`."

#: ../../reference/executionmodel.rst:95
msgid ""
"Each occurrence of a name in the program text refers to the :dfn:`binding` "
"of that name established by the following name resolution rules."
msgstr ""
"Cada ocorrência de um nome no texto do programa se refere à :dfn:`ligação` "
"daquele nome estabelecido pelas seguintes regras de resolução de nome."

#: ../../reference/executionmodel.rst:101
msgid "Resolution of names"
msgstr "Resolução de nomes"

#: ../../reference/executionmodel.rst:105
msgid ""
"A :dfn:`scope` defines the visibility of a name within a block.  If a local "
"variable is defined in a block, its scope includes that block.  If the "
"definition occurs in a function block, the scope extends to any blocks "
"contained within the defining one, unless a contained block introduces a "
"different binding for the name."
msgstr ""
"O :dfn:`escopo` define a visibilidade de um nome dentro de um bloco. Se uma "
"variável local é definida em um bloco, seu escopo inclui esse bloco. Se a "
"definição ocorrer em um bloco de função, o escopo se estende a quaisquer "
"blocos contidos no bloco de definição, a menos que um bloco contido "
"introduza uma ligação diferente para o nome."

#: ../../reference/executionmodel.rst:113
msgid ""
"When a name is used in a code block, it is resolved using the nearest "
"enclosing scope.  The set of all such scopes visible to a code block is "
"called the block's :dfn:`environment`."
msgstr ""
"Quando um nome é usado em um bloco de código, ele é resolvido usando o "
"escopo envolvente mais próximo. O conjunto de todos esses escopos visíveis a "
"um bloco de código é chamado de :dfn:`ambiente` do bloco."

#: ../../reference/executionmodel.rst:121
msgid ""
"When a name is not found at all, a :exc:`NameError` exception is raised. If "
"the current scope is a function scope, and the name refers to a local "
"variable that has not yet been bound to a value at the point where the name "
"is used, an :exc:`UnboundLocalError` exception is raised. :exc:"
"`UnboundLocalError` is a subclass of :exc:`NameError`."
msgstr ""
"Quando um nome não é encontrado, uma exceção :exc:`NameError` é levantada. "
"Se o escopo atual for um escopo de função e o nome se referir a uma variável "
"local que ainda não foi associada a um valor no ponto onde o nome é usado, "
"uma exceção :exc:`UnboundLocalError` é levantada. :exc:`UnboundLocalError` é "
"uma subclasse de :exc:`NameError`."

#: ../../reference/executionmodel.rst:127
msgid ""
"If a name binding operation occurs anywhere within a code block, all uses of "
"the name within the block are treated as references to the current block.  "
"This can lead to errors when a name is used within a block before it is "
"bound.  This rule is subtle.  Python lacks declarations and allows name "
"binding operations to occur anywhere within a code block.  The local "
"variables of a code block can be determined by scanning the entire text of "
"the block for name binding operations. See :ref:`the FAQ entry on "
"UnboundLocalError <faq-unboundlocalerror>` for examples."
msgstr ""
"Se a operação de ligação de nomes ocorre dentro de um bloco de código, todos "
"os usos do nome dentro do bloco são tratadas como referências para o bloco "
"atual. Isso pode. Isso pode levar a erros quando um nome é usado em um bloco "
"antes de ser vinculado.  Esta regra é sutil.  Python carece de declarações e "
"permite que as operações de ligação de nomes ocorram em qualquer lugar "
"dentro de um bloco de código. As variáveis locais de um bloco de código "
"podem ser determinadas pela varredura de todo o texto do bloco para "
"operações de ligação de nome. Veja :ref:`o FAQ sobre UnboundLocalError <faq-"
"unboundlocalerror>` para exemplos."

#: ../../reference/executionmodel.rst:136
msgid ""
"If the :keyword:`global` statement occurs within a block, all uses of the "
"names specified in the statement refer to the bindings of those names in the "
"top-level namespace.  Names are resolved in the top-level namespace by "
"searching the global namespace, i.e. the namespace of the module containing "
"the code block, and the builtins namespace, the namespace of the module :mod:"
"`builtins`.  The global namespace is searched first.  If the names are not "
"found there, the builtins namespace is searched next. If the names are also "
"not found in the builtins namespace, new variables are created in the global "
"namespace. The global statement must precede all uses of the listed names."
msgstr ""
"Se a instrução :keyword:`global` ocorrer dentro de um bloco, todos os usos "
"dos nomes especificados na instrução referem-se às ligações desses nomes no "
"espaço de nomes de nível superior. Os nomes são resolvidos no espaço de "
"nomes de nível superior pesquisando o espaço de nomes global, ou seja, o "
"espaço de nomes do módulo que contém o bloco de código, e o espaço de nomes "
"embutido, o espaço de nomes do módulo :mod:`builtins`. O espaço de nomes "
"global é pesquisado primeiro. Se os nomes não forem encontrados lá, o espaço "
"de nomes embutidos será pesquisado em seguida. Se os nomes também não forem "
"encontrados no espaço de nomes embutido, novas variáveis são criadas no "
"espaço de nomes global. A instrução global deve preceder todos os usos dos "
"nomes listados."

#: ../../reference/executionmodel.rst:146
msgid ""
"The :keyword:`global` statement has the same scope as a name binding "
"operation in the same block.  If the nearest enclosing scope for a free "
"variable contains a global statement, the free variable is treated as a "
"global."
msgstr ""
"A instrução :keyword:`global` tem o mesmo escopo que uma operação de ligação "
"de nome no mesmo bloco. Se o escopo mais próximo de uma variável livre "
"contiver uma instrução global, a variável livre será tratada como global."

#: ../../reference/executionmodel.rst:152
msgid ""
"The :keyword:`nonlocal` statement causes corresponding names to refer to "
"previously bound variables in the nearest enclosing function scope. :exc:"
"`SyntaxError` is raised at compile time if the given name does not exist in "
"any enclosing function scope. :ref:`Type parameters <type-params>` cannot be "
"rebound with the :keyword:`!nonlocal` statement."
msgstr ""
"A instrução :keyword:`nonlocal` faz com que os nomes correspondentes se "
"refiram a variáveis previamente vinculadas no escopo da função delimitadora "
"mais próxima. A exceção :exc:`SyntaxError` é levantada em tempo de "
"compilação se o nome fornecido não existir em nenhum escopo de função "
"delimitador. :ref:`Parâmetros de tipo <type-params>` não podem ser "
"vinculadas novamente com a instrução :keyword:`!nonlocal`."

#: ../../reference/executionmodel.rst:160
msgid ""
"The namespace for a module is automatically created the first time a module "
"is imported.  The main module for a script is always called :mod:`__main__`."
msgstr ""
"O espaço de nomes de um módulo é criado automaticamente na primeira vez que "
"um módulo é importado. O módulo principal de um script é sempre chamado de :"
"mod:`__main__`."

#: ../../reference/executionmodel.rst:163
msgid ""
"Class definition blocks and arguments to :func:`exec` and :func:`eval` are "
"special in the context of name resolution. A class definition is an "
"executable statement that may use and define names. These references follow "
"the normal rules for name resolution with an exception that unbound local "
"variables are looked up in the global namespace. The namespace of the class "
"definition becomes the attribute dictionary of the class. The scope of names "
"defined in a class block is limited to the class block; it does not extend "
"to the code blocks of methods. This includes comprehensions and generator "
"expressions, but it does not include :ref:`annotation scopes <annotation-"
"scopes>`, which have access to their enclosing class scopes. This means that "
"the following will fail::"
msgstr ""
"Blocos de definição de classe e argumentos para :func:`exec` e :func:`eval` "
"são especiais no contexto de resolução de nome. Uma definição de classe é "
"uma instrução executável que pode usar e definir nomes. Essas referências "
"seguem as regras normais para resolução de nome, com exceção de que "
"variáveis locais não vinculadas são pesquisadas no espaço de nomes global "
"global. O espaço de nomes global da definição de classe se torna o "
"dicionário de atributos da classe. O escopo dos nomes definidos em um bloco "
"de classe é limitado ao bloco de classe; ele não se estende aos blocos de "
"código de métodos. Isso inclui compreensões e expressões geradoras, mas não "
"inclui :ref:`escopos de anotação <annotation-scopes>`, que têm acesso a seus "
"escopos de classe delimitadores. Isso significa que o seguinte falhará::"

#: ../../reference/executionmodel.rst:176
msgid ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"
msgstr ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"

#: ../../reference/executionmodel.rst:180
msgid "However, the following will succeed::"
msgstr "Porém, o seguinte vai funcionar::"

#: ../../reference/executionmodel.rst:182
msgid ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"
msgstr ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"

#: ../../reference/executionmodel.rst:191
msgid "Annotation scopes"
msgstr "Escopos de anotação"

#: ../../reference/executionmodel.rst:193
msgid ""
":term:`Annotations <annotation>`, :ref:`type parameter lists <type-params>` "
"and :keyword:`type` statements introduce *annotation scopes*, which behave "
"mostly like function scopes, but with some exceptions discussed below."
msgstr ""
"As instruções de :term:`anotações <annotation>`, :ref:`listas de parâmetros "
"de tipo <type-params>` e :keyword:`type` introduzem *escopos de anotação*, "
"que se comportam principalmente como escopos de função, mas com algumas "
"exceções discutidas abaixo."

#: ../../reference/executionmodel.rst:198
msgid "Annotation scopes are used in the following contexts:"
msgstr "Os escopos de anotação são usados nos seguintes contextos:"

#: ../../reference/executionmodel.rst:200
msgid ":term:`Function annotations <function annotation>`."
msgstr ":term:`Anotações de funções <function annotation>`."

#: ../../reference/executionmodel.rst:201
msgid ":term:`Variable annotations <variable annotation>`."
msgstr ":term:`Anotações de variável <variable annotation>`."

#: ../../reference/executionmodel.rst:202
msgid ""
"Type parameter lists for :ref:`generic type aliases <generic-type-aliases>`."
msgstr ""
"Listas de parâmetros de tipo para :ref:`apelidos de tipo genérico <generic-"
"type-aliases>`."

#: ../../reference/executionmodel.rst:203
msgid ""
"Type parameter lists for :ref:`generic functions <generic-functions>`. A "
"generic function's annotations are executed within the annotation scope, but "
"its defaults and decorators are not."
msgstr ""
"Listas de parâmetros de tipo para :ref:`funções genéricas <generic-"
"functions>`. As anotações de uma função genérica são executadas dentro do "
"escopo de anotação, mas seus padrões e decoradores não."

#: ../../reference/executionmodel.rst:206
msgid ""
"Type parameter lists for :ref:`generic classes <generic-classes>`. A generic "
"class's base classes and keyword arguments are executed within the "
"annotation scope, but its decorators are not."
msgstr ""
"Listas de parâmetros de tipo para :ref:`classes genéricas <generic-"
"functions>`. As classes base e argumentos nomeados de uma classe genérica "
"são executadas dentro do escopo de anotação, mas seus decoradores não."

#: ../../reference/executionmodel.rst:209
msgid ""
"The bounds, constraints, and default values for type parameters (:ref:"
"`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"Os limites, restrições e valores padrão para parâmetros de tipo (:ref:"
"`avaliados preguiçosamente <lazy-evaluation>`)."

#: ../../reference/executionmodel.rst:211
msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""
"O valor dos apelidos de tipo (:ref:`avaliado preguiçosamente <lazy-"
"evaluation>`)."

#: ../../reference/executionmodel.rst:213
msgid "Annotation scopes differ from function scopes in the following ways:"
msgstr ""
"Escopos de anotação diferenciam-se de escopos de função nas seguintes formas:"

#: ../../reference/executionmodel.rst:215
msgid ""
"Annotation scopes have access to their enclosing class namespace. If an "
"annotation scope is immediately within a class scope, or within another "
"annotation scope that is immediately within a class scope, the code in the "
"annotation scope can use names defined in the class scope as if it were "
"executed directly within the class body. This contrasts with regular "
"functions defined within classes, which cannot access names defined in the "
"class scope."
msgstr ""
"Os escopos de anotação têm acesso ao espaço de nomes da classe delimitadora. "
"Se um escopo de anotação estiver imediatamente dentro de um escopo de classe "
"ou dentro de outro escopo de anotação que esteja imediatamente dentro de um "
"escopo de classe, o código no escopo de anotação poderá usar nomes definidos "
"no escopo de classe como se fosse executado diretamente no corpo da classe. "
"Isto contrasta com funções regulares definidas dentro de classes, que não "
"podem acessar nomes definidos no escopo da classe."

#: ../../reference/executionmodel.rst:221
msgid ""
"Expressions in annotation scopes cannot contain :keyword:`yield`, ``yield "
"from``, :keyword:`await`, or :token:`:= <python-grammar:"
"assignment_expression>` expressions. (These expressions are allowed in other "
"scopes contained within the annotation scope.)"
msgstr ""
"Expressões em escopos de anotação não podem conter expressões :keyword:"
"`yield`, ``yield from``, :keyword:`await` ou :token:`:= 1`. (Essas "
"expressões são permitidas em outros escopos contidos no escopo de anotação.)"

#: ../../reference/executionmodel.rst:225
msgid ""
"Names defined in annotation scopes cannot be rebound with :keyword:"
"`nonlocal` statements in inner scopes. This includes only type parameters, "
"as no other syntactic elements that can appear within annotation scopes can "
"introduce new names."
msgstr ""
"Nomes definidos em escopos de anotação não podem ser vinculados novamente "
"com instruções :keyword:`nonlocal` em escopos internos. Isso inclui apenas "
"parâmetros de tipo, pois nenhum outro elemento sintático que pode aparecer "
"nos escopos de anotação pode introduzir novos nomes."

#: ../../reference/executionmodel.rst:228
msgid ""
"While annotation scopes have an internal name, that name is not reflected in "
"the :term:`qualified name` of objects defined within the scope. Instead, "
"the :attr:`~definition.__qualname__` of such objects is as if the object "
"were defined in the enclosing scope."
msgstr ""
"Embora os escopos de anotação tenham um nome interno, esse nome não é "
"refletido no :term:`nome qualificado` dos objetos definidos dentro do "
"escopo. Em vez disso, o :attr:`~definition.__qualname__` de tais objetos é "
"como se o objeto fosse definido no escopo delimitador."

#: ../../reference/executionmodel.rst:233
msgid "Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."
msgstr ""
"Escopos de anotação foram introduzidos no Python 3.12 como parte da :pep:"
"`695`."

#: ../../reference/executionmodel.rst:236
msgid ""
"Annotation scopes are also used for type parameter defaults, as introduced "
"by :pep:`696`."
msgstr ""
"Os escopos de anotação também são usados para padrões de parâmetros de tipo, "
"conforme introduzido pela :pep:`696`."

#: ../../reference/executionmodel.rst:240
msgid ""
"Annotation scopes are now also used for annotations, as specified in :pep:"
"`649` and :pep:`749`."
msgstr ""
"Os escopos de anotação agora também são usados para anotações, conforme "
"especificado na :pep:`649` e :pep:`749`."

#: ../../reference/executionmodel.rst:247
msgid "Lazy evaluation"
msgstr "Avaliação preguiçosa"

#: ../../reference/executionmodel.rst:249
msgid ""
"Most annotation scopes are *lazily evaluated*. This includes annotations, "
"the values of type aliases created through the :keyword:`type` statement, "
"and the bounds, constraints, and default values of type variables created "
"through the :ref:`type parameter syntax <type-params>`. This means that they "
"are not evaluated when the type alias or type variable is created, or when "
"the object carrying annotations is created. Instead, they are only evaluated "
"when necessary, for example when the ``__value__`` attribute on a type alias "
"is accessed."
msgstr ""
"A maioria dos escopos de anotação são *avaliados preguiçosamente*. Isso "
"inclui anotações, os valores de apelidos de tipo criados por meio da "
"instrução :keyword:`type` e os limites, restrições e valores padrão de tipos "
"variáveis criados por meio da sintaxe de parâmetro de tipo :ref:`sintaxe de "
"parâmetro de tipo <type-params>`. Isso significa que eles não são avaliados "
"quando o apelido de tipo ou a tipo variável é criado, ou quando o objeto que "
"contém as anotações é criado. Em vez disso, eles são avaliados apenas quando "
"necessário, por exemplo, quando o atributo ``__value__`` em um apelido de "
"tipo é acessado."

#: ../../reference/executionmodel.rst:258
msgid "Example:"
msgstr "Exemplo:"

#: ../../reference/executionmodel.rst:260
msgid ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"
msgstr ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"

#: ../../reference/executionmodel.rst:274
msgid ""
"Here the exception is raised only when the ``__value__`` attribute of the "
"type alias or the ``__bound__`` attribute of the type variable is accessed."
msgstr ""
"Aqui a exceção é levantada apenas quando o atributo ``__value__`` do apelido "
"de tipo ou o atributo ``__bound__`` da variável de tipo é acessado."

#: ../../reference/executionmodel.rst:278
msgid ""
"This behavior is primarily useful for references to types that have not yet "
"been defined when the type alias or type variable is created. For example, "
"lazy evaluation enables creation of mutually recursive type aliases::"
msgstr ""
"Esse comportamento é útil principalmente para referências a tipos que ainda "
"não foram definidos quando o alias de tipo ou variável de tipo é criado. Por "
"exemplo, a avaliação preguiçosa permite a criação de apelidos de tipo "
"mutuamente recursivos::"

#: ../../reference/executionmodel.rst:282
msgid ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"
msgstr ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"

#: ../../reference/executionmodel.rst:288
msgid ""
"Lazily evaluated values are evaluated in :ref:`annotation scope <annotation-"
"scopes>`, which means that names that appear inside the lazily evaluated "
"value are looked up as if they were used in the immediately enclosing scope."
msgstr ""
"Valores avaliados preguiçosamente são avaliados em :ref:`escopo de anotação "
"<annotation-scopes>`, o que significa que os nomes que aparecem dentro do "
"valor avaliado preguiçosamente são pesquisados como se fossem usados no "
"escopo imediatamente envolvente."

#: ../../reference/executionmodel.rst:297
msgid "Builtins and restricted execution"
msgstr "Builtins e execução restrita"

#: ../../reference/executionmodel.rst:303
msgid ""
"Users should not touch ``__builtins__``; it is strictly an implementation "
"detail.  Users wanting to override values in the builtins namespace should :"
"keyword:`import` the :mod:`builtins` module and modify its attributes "
"appropriately."
msgstr ""
"Os usuários não devem tocar em ``__builtins__``; é estritamente um detalhe "
"de implementação. Usuários que desejam substituir valores no espaço de nomes "
"interno devem :keyword:`import` o módulo :mod:`builtins` e modificar seus "
"atributos apropriadamente."

#: ../../reference/executionmodel.rst:308
msgid ""
"The builtins namespace associated with the execution of a code block is "
"actually found by looking up the name ``__builtins__`` in its global "
"namespace; this should be a dictionary or a module (in the latter case the "
"module's dictionary is used).  By default, when in the :mod:`__main__` "
"module, ``__builtins__`` is the built-in module :mod:`builtins`; when in any "
"other module, ``__builtins__`` is an alias for the dictionary of the :mod:"
"`builtins` module itself."
msgstr ""
"O espaço de nomes builtins associado com a execução de um bloco de código é "
"encontrado procurando o nome ``__builtins__`` em seu espaço de nomes global; "
"este deve ser um dicionário ou um módulo (no último caso, o dicionário do "
"módulo é usado). Por padrão, quando no módulo :mod:`__main__`, "
"``__builtins__`` é o módulo embutido :mod:`builtins`; quando em qualquer "
"outro módulo, ``__builtins__`` é um apelido para o dicionário do próprio "
"módulo :mod:`builtins`."

#: ../../reference/executionmodel.rst:320
msgid "Interaction with dynamic features"
msgstr "Interação com recursos dinâmicos"

#: ../../reference/executionmodel.rst:322
msgid ""
"Name resolution of free variables occurs at runtime, not at compile time. "
"This means that the following code will print 42::"
msgstr ""
"A resolução de nome de variáveis livres ocorre em tempo de execução, não em "
"tempo de compilação. Isso significa que o código a seguir imprimirá 42::"

#: ../../reference/executionmodel.rst:325
msgid ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"
msgstr ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"

#: ../../reference/executionmodel.rst:333
msgid ""
"The :func:`eval` and :func:`exec` functions do not have access to the full "
"environment for resolving names.  Names may be resolved in the local and "
"global namespaces of the caller.  Free variables are not resolved in the "
"nearest enclosing namespace, but in the global namespace.  [#]_ The :func:"
"`exec` and :func:`eval` functions have optional arguments to override the "
"global and local namespace.  If only one namespace is specified, it is used "
"for both."
msgstr ""
"As funções :func:`eval` e :func:`exec` não têm acesso ao ambiente completo "
"para resolução de nome. Os nomes podem ser resolvidos nos espaços de nomes "
"locais e globais do chamador. Variáveis livres não são resolvidas no espaço "
"de nomes mais próximo, mas no espaço de nomes global. [#]_ As funções :func:"
"`exec` e :func:`eval` possuem argumentos opcionais para substituir o espaço "
"de nomes global e local. Se apenas um espaço de nomes for especificado, ele "
"será usado para ambos."

#: ../../reference/executionmodel.rst:347
msgid "Exceptions"
msgstr "Exceções"

#: ../../reference/executionmodel.rst:358
msgid ""
"Exceptions are a means of breaking out of the normal flow of control of a "
"code block in order to handle errors or other exceptional conditions.  An "
"exception is *raised* at the point where the error is detected; it may be "
"*handled* by the surrounding code block or by any code block that directly "
"or indirectly invoked the code block where the error occurred."
msgstr ""
"As exceções são um meio de romper o fluxo normal de controle de um bloco de "
"código para tratar erros ou outras condições excepcionais. Uma exceção é "
"*levantada* no ponto em que o erro é detectado; ele pode ser *tratado* pelo "
"bloco de código circundante ou por qualquer bloco de código que invocou "
"direta ou indiretamente o bloco de código onde ocorreu o erro."

#: ../../reference/executionmodel.rst:364
msgid ""
"The Python interpreter raises an exception when it detects a run-time error "
"(such as division by zero).  A Python program can also explicitly raise an "
"exception with the :keyword:`raise` statement. Exception handlers are "
"specified with the :keyword:`try` ... :keyword:`except` statement.  The :"
"keyword:`finally` clause of such a statement can be used to specify cleanup "
"code which does not handle the exception, but is executed whether an "
"exception occurred or not in the preceding code."
msgstr ""
"O interpretador Python levanta uma exceção quando detecta um erro em tempo "
"de execução (como divisão por zero). Um programa Python também pode levantar "
"explicitamente uma exceção com a instrução :keyword:`raise`. Os tratadores "
"de exceção são especificados com a instrução :keyword:`try` ... :keyword:"
"`except`. A cláusula :keyword:`finally` de tal declaração pode ser usada "
"para especificar o código de limpeza que não trata a exceção, mas é "
"executado se uma exceção ocorreu ou não no código anterior."

#: ../../reference/executionmodel.rst:374
msgid ""
"Python uses the \"termination\" model of error handling: an exception "
"handler can find out what happened and continue execution at an outer level, "
"but it cannot repair the cause of the error and retry the failing operation "
"(except by re-entering the offending piece of code from the top)."
msgstr ""
"Python usa o modelo de \"terminação\" da manipulação de erros: um "
"manipulador de exceção pode descobrir o que aconteceu e continuar a execução "
"em um nível externo, mas não pode reparar a causa do erro e tentar novamente "
"a operação com falha (exceto reinserindo a parte incorreta de código de "
"cima)."

#: ../../reference/executionmodel.rst:381
msgid ""
"When an exception is not handled at all, the interpreter terminates "
"execution of the program, or returns to its interactive main loop.  In "
"either case, it prints a stack traceback, except when the exception is :exc:"
"`SystemExit`."
msgstr ""
"Quando uma exceção não é manipulada, o interpretador encerra a execução do "
"programa ou retorna ao seu laço principal interativo. Em ambos os casos, ele "
"exeibe um traceback (situação da pilha de execução), exceto quando a exceção "
"é :exc:`SystemExit`."

#: ../../reference/executionmodel.rst:385
msgid ""
"Exceptions are identified by class instances.  The :keyword:`except` clause "
"is selected depending on the class of the instance: it must reference the "
"class of the instance or a :term:`non-virtual base class <abstract base "
"class>` thereof. The instance can be received by the handler and can carry "
"additional information about the exceptional condition."
msgstr ""
"As exceções são identificadas por instâncias de classe. A cláusula :keyword:"
"`except` é selecionada dependendo da classe da instância: ela deve "
"referenciar a classe da instância ou uma :term:`classe base não-virtual "
"<classe base abstrata>` dela. A instância pode ser recebida pelo manipulador "
"e pode conter informações adicionais sobre a condição excepcional."

#: ../../reference/executionmodel.rst:393
msgid ""
"Exception messages are not part of the Python API.  Their contents may "
"change from one version of Python to the next without warning and should not "
"be relied on by code which will run under multiple versions of the "
"interpreter."
msgstr ""
"As mensagens de exceção não fazem parte da API do Python. Seu conteúdo pode "
"mudar de uma versão do Python para outra sem aviso e não deve ser invocado "
"pelo código que será executado em várias versões do interpretador."

#: ../../reference/executionmodel.rst:397
msgid ""
"See also the description of the :keyword:`try` statement in section :ref:"
"`try` and :keyword:`raise` statement in section :ref:`raise`."
msgstr ""
"Veja também a descrição da declaração :keyword:`try` na seção :ref:`try` e a "
"instrução :keyword:`raise` na seção :ref:`raise`."

#: ../../reference/executionmodel.rst:404
msgid "Runtime Components"
msgstr "Componentes do Ambiente de Execução"

#: ../../reference/executionmodel.rst:407
msgid "General Computing Model"
msgstr "Modelo Geral de Computação"

#: ../../reference/executionmodel.rst:409
msgid ""
"Python's execution model does not operate in a vacuum.  It runs on a host "
"machine and through that host's runtime environment, including its operating "
"system (OS), if there is one.  When a program runs, the conceptual layers of "
"how it runs on the host look something like this:"
msgstr ""
"O modelo de execução do Python não opera no vácuo. Ele é executado em uma "
"máquina hospedeira e através do ambiente de execução desse hospedeiro, "
"incluindo seu sistema operacional (SO), se houver um. Quando um programa é "
"executado, as camadas conceituais de como ele é executado no hospedeiro têm "
"esta forma:"

#: ../../reference/executionmodel.rst:0
msgid "**host machine**"
msgstr "**máquina hospedeira**"

#: ../../reference/executionmodel.rst:0
msgid "**process** (global resources)"
msgstr "**processo** (recursos globais)"

#: ../../reference/executionmodel.rst:0
msgid "**thread** (runs machine code)"
msgstr "**thread** (executa código de máquina)"

#: ../../reference/executionmodel.rst:419
msgid ""
"Each process represents a program running on the host.  Think of each "
"process itself as the data part of its program.  Think of the process' "
"threads as the execution part of the program.  This distinction will be "
"important to understand the conceptual Python runtime."
msgstr ""
"Cada processo representa um programa rodando no hospdeiro. Pense em cada "
"processo em si como a parte do programa referente aos dados. Pense nas "
"threads do processo como a parte referente à execução. Essa distinção será "
"importante para entender o ambiente de execução do Python."

#: ../../reference/executionmodel.rst:424
msgid ""
"The process, as the data part, is the execution context in which the program "
"runs.  It mostly consists of the set of resources assigned to the program by "
"the host, including memory, signals, file handles, sockets, and environment "
"variables."
msgstr ""
"O processo, enquanto parte referente a dados, é o contexto de execução sobre "
"o qual o programa roda. Ele consiste majoritariamente no conjunto de "
"recursos alocados paro programa pelo hospedeiro, incluindo memória, sinais, "
"identificadores de arquivos, soquetes, e variáveis de ambiente."

#: ../../reference/executionmodel.rst:429
msgid ""
"Processes are isolated and independent from one another.  (The same is true "
"for hosts.)  The host manages the process' access to its assigned resources, "
"in addition to coordinating between processes."
msgstr ""
"Processos são isolados, e independentes uns dos outros. (O mesmo vale para "
"hospedeiros.) O hospedeiro gerencia o acesso do processo aos recursos a ele "
"alocados, além de orquestrar os vários processos."

#: ../../reference/executionmodel.rst:433
msgid ""
"Each thread represents the actual execution of the program's machine code, "
"running relative to the resources assigned to the program's process.  It's "
"strictly up to the host how and when that execution takes place."
msgstr ""
"Cada thread representa a execução em si do código de máquina do programa, "
"rodando relativamente aos recursos alocados ao processo. Decidir como e "
"quando essa execução acontecerá é prerrogativa exclusiva do hospedeiro."

#: ../../reference/executionmodel.rst:438
msgid ""
"From the point of view of Python, a program always starts with exactly one "
"thread.  However, the program may grow to run in multiple simultaneous "
"threads.  Not all hosts support multiple threads per process, but most do.  "
"Unlike processes, threads in a process are not isolated and independent from "
"one another.  Specifically, all threads in a process share all of the "
"process' resources."
msgstr ""
"Do ponto de vista do Python, um programa sempre começa com exatamente uma "
"thread. Entretanto, o programa pode evoluir para rodar em múltiplas threads "
"simultâneas. Nem todo hospedeiro oferece suporte para múltiplas threads por "
"processo, mas a maioria oferece. Diferentemente de processos, threads em um "
"processo não são isoladas nem independentes umas das outras. "
"Especificamente, cada recurso de um processo é compartilhado por todas as "
"suas threads."

#: ../../reference/executionmodel.rst:445
msgid ""
"The fundamental point of threads is that each one does *run* independently, "
"at the same time as the others.  That may be only conceptually at the same "
"time (\"concurrently\") or physically (\"in parallel\").  Either way, the "
"threads effectively run at a non-synchronized rate."
msgstr ""
"O princípio fundamental das threads é que cada uma delas *roda* "
"independentemente, ao mesmo tempo que as outras. Isso pode significar uma "
"simultaneidade conceitual (\"concorrência\") ou física (\"paralelismo\"). De "
"qualquer modo, as threads rodam efetivamente em passos não sincronizados."

#: ../../reference/executionmodel.rst:453
msgid ""
"That non-synchronized rate means none of the process' memory is guaranteed "
"to stay consistent for the code running in any given thread.  Thus multi-"
"threaded programs must take care to coordinate access to intentionally "
"shared resources.  Likewise, they must take care to be absolutely diligent "
"about not accessing any *other* resources in multiple threads; otherwise two "
"threads running at the same time might accidentally interfere with each "
"other's use of some shared data.  All this is true for both Python programs "
"and the Python runtime."
msgstr ""
"Essa falta de sincronismo significa que não existe nenhuma garantia de "
"consistência em qualquer parte da memória do processo, do ponto de vista do "
"código rodando em qualquer thread. Portanto, programas multi-thread precisam "
"tomar o cuidado de coordenar o acesso a recursos intencionalmente "
"compartilhados. Da mesma forma, eles precisam ter o máximo cuidado para não "
"acessar nenhum *outro* recurso a partir de múltiplas threads; caso "
"contrário, duas threads rodando ao mesmo tempo podem acidentalmente "
"interferir no uso umas das outras desses recursos compartilhados. Tudo isso "
"vale tanto para programas Python quanto para o ambiente de execução do "
"Python."

#: ../../reference/executionmodel.rst:463
msgid ""
"The cost of this broad, unstructured requirement is the tradeoff for the "
"kind of raw concurrency that threads provide.  The alternative to the "
"required discipline generally means dealing with non-deterministic bugs and "
"data corruption."
msgstr ""
"Essa exigência ampla e não estruturada é o custo que precisamos pagar em "
"contrapartida pela concorrência bruta que as threads proporcionam. A "
"alternativa à disciplina necessária geralmente envolve lidar com bugs não "
"determinísticos e corrupção de dados."

#: ../../reference/executionmodel.rst:469
msgid "Python Runtime Model"
msgstr "Modelo do Ambiente de Execução Python"

#: ../../reference/executionmodel.rst:471
msgid ""
"The same conceptual layers apply to each Python program, with some extra "
"data layers specific to Python:"
msgstr ""
"As mesmas camadas conceituais se aplicam a cada programa Python, com algumas "
"camadas de dados específicas para o Python:"

#: ../../reference/executionmodel.rst:0
msgid "Python global runtime (*state*)"
msgstr "Ambiente de execução global do Python (*estado*)"

#: ../../reference/executionmodel.rst:0
msgid "Python interpreter (*state*)"
msgstr "Interpretador Python (*estado*)"

#: ../../reference/executionmodel.rst:0
msgid "**thread** (runs Python bytecode and \"C-API\")"
msgstr "**thread** (roda bytecode Python e a \"API C\")"

#: ../../reference/executionmodel.rst:0
msgid "Python thread *state*"
msgstr "*Estado* da thread Python"

#: ../../reference/executionmodel.rst:481
msgid ""
"At the conceptual level: when a Python program starts, it looks exactly like "
"that diagram, with one of each.  The runtime may grow to include multiple "
"interpreters, and each interpreter may grow to include multiple thread "
"states."
msgstr ""
"No nível conceitual: quando um programa Python começa, ele tem o aspecto "
"exato desse diagrama, com uma instância de cada linha. O ambiente de "
"execução pode evoluir para incluir múltiplos interpretadores, e cada "
"interpretador pode evoluir para incluir múltiplos estados de thread."

#: ../../reference/executionmodel.rst:488
msgid ""
"A Python implementation won't necessarily implement the runtime layers "
"distinctly or even concretely.  The only exception is places where distinct "
"layers are directly specified or exposed to users, like through the :mod:"
"`threading` module."
msgstr ""
"Uma implementação do Python não necessariamente vai implementar essas "
"camadas do ambiente de execução de forma distinta, ou mesmo concreta. A "
"única exceção são os casos em que camadas distintas são diretamente "
"especificadas ou expostas aos usuários, como através do módulo :mod:"
"`threading`."

#: ../../reference/executionmodel.rst:495
msgid ""
"The initial interpreter is typically called the \"main\" interpreter. Some "
"Python implementations, like CPython, assign special roles to the main "
"interpreter."
msgstr ""
"O interpretador inicial é geralmente chamado de interpretador \"principal\". "
"Algumas implementações do Python, como o CPython, dão papéis especiais ao "
"interpretador principal."

#: ../../reference/executionmodel.rst:499
msgid ""
"Likewise, the host thread where the runtime was initialized is known as the "
"\"main\" thread.  It may be different from the process' initial thread, "
"though they are often the same.  In some cases \"main thread\" may be even "