classes.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
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-02-17 14:41+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: python-doc bot, 2025\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"

#: ../../tutorial/classes.rst:5
msgid "Classes"
msgstr "Classes"

#: ../../tutorial/classes.rst:7
msgid ""
"Classes provide a means of bundling data and functionality together.  "
"Creating a new class creates a new *type* of object, allowing new "
"*instances* of that type to be made.  Each class instance can have "
"attributes attached to it for maintaining its state.  Class instances can "
"also have methods (defined by its class) for modifying its state."
msgstr ""
"Classes proporcionam uma forma de organizar dados e funcionalidades juntos. "
"Criar uma nova classe cria um novo \"tipo\" de objeto, permitindo que novas "
"\"instâncias\" desse tipo sejam produzidas. Cada instância da classe pode "
"ter atributos anexados a ela, para manter seu estado. Instâncias da classe "
"também podem ter métodos (definidos pela classe) para modificar seu estado."

#: ../../tutorial/classes.rst:13
msgid ""
"Compared with other programming languages, Python's class mechanism adds "
"classes with a minimum of new syntax and semantics.  It is a mixture of the "
"class mechanisms found in C++ and Modula-3.  Python classes provide all the "
"standard features of Object Oriented Programming: the class inheritance "
"mechanism allows multiple base classes, a derived class can override any "
"methods of its base class or classes, and a method can call the method of a "
"base class with the same name.  Objects can contain arbitrary amounts and "
"kinds of data.  As is true for modules, classes partake of the dynamic "
"nature of Python: they are created at runtime, and can be modified further "
"after creation."
msgstr ""
"Em comparação com outras linguagens de programação, o mecanismo de classes "
"de Python introduz a programação orientada a objetos sem acrescentar muitas "
"novidades de sintaxe ou semântica. É uma mistura de mecanismos equivalentes "
"encontrados em C++ e Modula-3. As classes em Python oferecem todas as "
"características tradicionais da programação orientada a objetos: o mecanismo "
"de herança permite múltiplas classes base (herança múltipla), uma classe "
"derivada pode sobrescrever quaisquer métodos de uma classe ancestral, e um "
"método pode invocar outro método homônimo de uma classe ancestral. Objetos "
"podem armazenar uma quantidade arbitrária de dados de qualquer tipo. Assim "
"como acontece com os módulos, as classes fazem parte da natureza dinâmica de "
"Python: são criadas em tempo de execução, e podem ser alteradas após sua "
"criação."

#: ../../tutorial/classes.rst:23
msgid ""
"In C++ terminology, normally class members (including the data members) are "
"*public* (except see below :ref:`tut-private`), and all member functions are "
"*virtual*.  As in Modula-3, there are no shorthands for referencing the "
"object's members from its methods: the method function is declared with an "
"explicit first argument representing the object, which is provided "
"implicitly by the call.  As in Smalltalk, classes themselves are objects.  "
"This provides semantics for importing and renaming.  Unlike C++ and "
"Modula-3, built-in types can be used as base classes for extension by the "
"user.  Also, like in C++, most built-in operators with special syntax "
"(arithmetic operators, subscripting etc.) can be redefined for class "
"instances."
msgstr ""
"Usando a terminologia de C++, todos os membros de uma classe (incluindo "
"dados) são *públicos* (veja exceção abaixo :ref:`tut-private`), e todos as "
"funções membro são *virtuais*. Como em Modula-3, não existem atalhos para "
"referenciar membros do objeto de dentro dos seus métodos: o método (função "
"definida em uma classe) é declarado com um primeiro argumento explícito "
"representando o objeto (instância da classe), que é fornecido implicitamente "
"pela chamada ao método. Como em Smalltalk, classes são objetos. Isso fornece "
"uma semântica para importar e renomear. Ao contrário de C++ ou Modula-3, "
"tipos pré-definidos podem ser utilizados como classes base para extensões "
"por herança pelo usuário. Também, como em C++, a maioria dos operadores "
"(aritméticos, indexação, etc) podem ser redefinidos por instâncias de classe."

#: ../../tutorial/classes.rst:34
msgid ""
"(Lacking universally accepted terminology to talk about classes, I will make "
"occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
"since its object-oriented semantics are closer to those of Python than C++, "
"but I expect that few readers have heard of it.)"
msgstr ""
"(Na falta de uma terminologia universalmente aceita para falar sobre "
"classes, ocasionalmente farei uso de termos comuns em Smalltalk ou C++. Eu "
"usaria termos de Modula-3, já que sua semântica de orientação a objetos é "
"mais próxima da de Python, mas creio que poucos leitores já ouviram falar "
"dessa linguagem.)"

#: ../../tutorial/classes.rst:43
msgid "A Word About Names and Objects"
msgstr "Uma palavra sobre nomes e objetos"

#: ../../tutorial/classes.rst:45
msgid ""
"Objects have individuality, and multiple names (in multiple scopes) can be "
"bound to the same object.  This is known as aliasing in other languages.  "
"This is usually not appreciated on a first glance at Python, and can be "
"safely ignored when dealing with immutable basic types (numbers, strings, "
"tuples).  However, aliasing has a possibly surprising effect on the "
"semantics of Python code involving mutable objects such as lists, "
"dictionaries, and most other types. This is usually used to the benefit of "
"the program, since aliases behave like pointers in some respects.  For "
"example, passing an object is cheap since only a pointer is passed by the "
"implementation; and if a function modifies an object passed as an argument, "
"the caller will see the change --- this eliminates the need for two "
"different argument passing mechanisms as in Pascal."
msgstr ""
"Objetos têm individualidade, e vários nomes (em diferentes escopos) podem "
"ser vinculados a um mesmo objeto. Isso é chamado de apelidamento em outras "
"linguagens. Geralmente, esta característica não é muito apreciada, e pode "
"ser ignorada com segurança ao lidar com tipos imutáveis (números, strings, "
"tuplas). Entretanto, apelidamento pode ter um efeito surpreendente na "
"semântica do código Python envolvendo objetos mutáveis como listas, "
"dicionários e a maioria dos outros tipos. Isso pode ser usado em benefício "
"do programa, porque os apelidos funcionam de certa forma como ponteiros. Por "
"exemplo, passar um objeto como argumento é barato, pois só um ponteiro é "
"passado na implementação; e se uma função modifica um objeto passado como "
"argumento, o invocador verá a mudança --- isso elimina a necessidade de ter "
"dois mecanismos de passagem de parâmetros como em Pascal."

#: ../../tutorial/classes.rst:61
msgid "Python Scopes and Namespaces"
msgstr "Escopos e espaços de nomes do Python"

#: ../../tutorial/classes.rst:63
msgid ""
"Before introducing classes, I first have to tell you something about "
"Python's scope rules.  Class definitions play some neat tricks with "
"namespaces, and you need to know how scopes and namespaces work to fully "
"understand what's going on. Incidentally, knowledge about this subject is "
"useful for any advanced Python programmer."
msgstr ""
"Antes de introduzir classes, é preciso falar das regras de escopo em Python. "
"Definições de classe fazem alguns truques com espaços de nomes. Portanto, "
"primeiro é preciso entender claramente como escopos e espaços de nomes "
"funcionam, para entender o que está acontecendo. Esse conhecimento é muito "
"útil para qualquer programador Python avançado."

#: ../../tutorial/classes.rst:69
msgid "Let's begin with some definitions."
msgstr "Vamos começar com algumas definições."

#: ../../tutorial/classes.rst:71
msgid ""
"A *namespace* is a mapping from names to objects.  Most namespaces are "
"currently implemented as Python dictionaries, but that's normally not "
"noticeable in any way (except for performance), and it may change in the "
"future.  Examples of namespaces are: the set of built-in names (containing "
"functions such as :func:`abs`, and built-in exception names); the global "
"names in a module; and the local names in a function invocation.  In a sense "
"the set of attributes of an object also form a namespace.  The important "
"thing to know about namespaces is that there is absolutely no relation "
"between names in different namespaces; for instance, two different modules "
"may both define a function ``maximize`` without confusion --- users of the "
"modules must prefix it with the module name."
msgstr ""
"Um *espaço de nomes* é um mapeamento que associa nomes a objetos. "
"Atualmente, são implementados como dicionários em Python, mas isso não é "
"perceptível (a não ser pelo desempenho), e pode mudar no futuro. Exemplos de "
"espaços de nomes são: o conjunto de nomes pré-definidos (funções como :func:"
"`abs` e as exceções pré-definidas); nomes globais em um módulo; e nomes "
"locais na invocação de uma função. De certa forma, os atributos de um objeto "
"também formam um espaço de nomes. O mais importante é saber que não existe "
"nenhuma relação entre nomes em espaços de nomes distintos. Por exemplo, dois "
"módulos podem definir uma função de nome ``maximize`` sem confusão --- "
"usuários dos módulos devem prefixar a função com o nome do módulo, para "
"evitar colisão."

#: ../../tutorial/classes.rst:82
msgid ""
"By the way, I use the word *attribute* for any name following a dot --- for "
"example, in the expression ``z.real``, ``real`` is an attribute of the "
"object ``z``.  Strictly speaking, references to names in modules are "
"attribute references: in the expression ``modname.funcname``, ``modname`` is "
"a module object and ``funcname`` is an attribute of it.  In this case there "
"happens to be a straightforward mapping between the module's attributes and "
"the global names defined in the module: they share the same namespace!  [#]_"
msgstr ""
"A propósito, utilizo a palavra *atributo* para qualquer nome depois de um "
"ponto. Na expressão ``z.real``, por exemplo, ``real`` é um atributo do "
"objeto ``z``. Estritamente falando, referências para nomes em módulos são "
"atributos: na expressão ``modname.funcname``, ``modname`` é um objeto módulo "
"e ``funcname`` é um de seus atributos. Neste caso, existe um mapeamento "
"direto entre os atributos de um módulo e os nomes globais definidos no "
"módulo: eles compartilham o mesmo espaço de nomes! [#]_"

#: ../../tutorial/classes.rst:90
msgid ""
"Attributes may be read-only or writable.  In the latter case, assignment to "
"attributes is possible.  Module attributes are writable: you can write "
"``modname.the_answer = 42``.  Writable attributes may also be deleted with "
"the :keyword:`del` statement.  For example, ``del modname.the_answer`` will "
"remove the attribute :attr:`!the_answer` from the object named by "
"``modname``."
msgstr ""
"Atributos podem ser somente leitura ou para leitura e escrita. No segundo "
"caso, é possível atribuir um novo valor ao atributo. Atributos de módulos "
"são passíveis de atribuição: você pode escrever ``modname.the_answer = 42``. "
"Atributos que aceitam escrita também podem ser apagados através da "
"instrução :keyword:`del`. Por exemplo, ``del modname.the_answer`` removerá o "
"atributo :attr:`!the_answer` do objeto referenciado por ``modname``."

#: ../../tutorial/classes.rst:96
msgid ""
"Namespaces are created at different moments and have different lifetimes.  "
"The namespace containing the built-in names is created when the Python "
"interpreter starts up, and is never deleted.  The global namespace for a "
"module is created when the module definition is read in; normally, module "
"namespaces also last until the interpreter quits.  The statements executed "
"by the top-level invocation of the interpreter, either read from a script "
"file or interactively, are considered part of a module called :mod:"
"`__main__`, so they have their own global namespace.  (The built-in names "
"actually also live in a module; this is called :mod:`builtins`.)"
msgstr ""
"Espaços de nomes são criados em momentos diferentes e possuem diferentes "
"ciclos de vida. O espaço de nomes que contém os nomes embutidos é criado "
"quando o interpretador inicializa e nunca é removido. O espaço de nomes "
"global de um módulo é criado quando a definição do módulo é lida, e "
"normalmente duram até a terminação do interpretador. Os comandos executados "
"pela invocação do interpretador, pela leitura de um script com programa "
"principal, ou interativamente, são parte do módulo chamado :mod:`__main__`, "
"e portanto possuem seu próprio espaço de nomes. (Os nomes embutidos possuem "
"seu próprio espaço de nomes no módulo chamado :mod:`builtins`.)."

#: ../../tutorial/classes.rst:106
msgid ""
"The local namespace for a function is created when the function is called, "
"and deleted when the function returns or raises an exception that is not "
"handled within the function.  (Actually, forgetting would be a better way to "
"describe what actually happens.)  Of course, recursive invocations each have "
"their own local namespace."
msgstr ""
"O espaço de nomes local de uma função é criado quando a função é invocada, e "
"apagado quando a função retorna ou levanta uma exceção que não é tratada na "
"própria função. (Na verdade, uma forma melhor de descrever o que realmente "
"acontece é que o espaço de nomes local é \"esquecido\" quando a função "
"termina.) Naturalmente, cada invocação recursiva de uma função tem seu "
"próprio espaço de nomes."

#: ../../tutorial/classes.rst:112
msgid ""
"A *scope* is a textual region of a Python program where a namespace is "
"directly accessible.  \"Directly accessible\" here means that an unqualified "
"reference to a name attempts to find the name in the namespace."
msgstr ""
"Um *escopo* é uma região textual de um programa Python onde um espaço de "
"nomes é diretamente acessível. Aqui, \"diretamente acessível\" significa que "
"uma referência sem um prefixo qualificador permite o acesso ao nome."

#: ../../tutorial/classes.rst:116
msgid ""
"Although scopes are determined statically, they are used dynamically. At any "
"time during execution, there are 3 or 4 nested scopes whose namespaces are "
"directly accessible:"
msgstr ""
"Ainda que escopos sejam determinados estaticamente, eles são usados "
"dinamicamente. A qualquer momento durante a execução, existem 3 ou 4 escopos "
"aninhados cujos espaços de nomes são diretamente acessíveis:"

#: ../../tutorial/classes.rst:120
msgid "the innermost scope, which is searched first, contains the local names"
msgstr "o escopo mais interno, que é acessado primeiro, contem os nomes locais"

#: ../../tutorial/classes.rst:121
msgid ""
"the scopes of any enclosing functions, which are searched starting with the "
"nearest enclosing scope, contain non-local, but also non-global names"
msgstr ""
"os escopos das funções que envolvem a função atual, que são acessados a "
"partir do escopo mais próximo, contêm nomes não-locais, mas também não-"
"globais"

#: ../../tutorial/classes.rst:123
msgid "the next-to-last scope contains the current module's global names"
msgstr "o penúltimo escopo contém os nomes globais do módulo atual"

#: ../../tutorial/classes.rst:124
msgid ""
"the outermost scope (searched last) is the namespace containing built-in "
"names"
msgstr ""
"e o escopo mais externo (acessado por último) contém os nomes das funções "
"embutidas e demais objetos pré-definidos do interpretador"

#: ../../tutorial/classes.rst:126
msgid ""
"If a name is declared global, then all references and assignments go "
"directly to the next-to-last scope containing the module's global names.  To "
"rebind variables found outside of the innermost scope, the :keyword:"
"`nonlocal` statement can be used; if not declared nonlocal, those variables "
"are read-only (an attempt to write to such a variable will simply create a "
"*new* local variable in the innermost scope, leaving the identically named "
"outer variable unchanged)."
msgstr ""
"Se um nome é declarado no escopo global, então todas as referências e "
"atribuições de valores vão diretamente para o penúltimo escopo, que contém "
"os nomes globais do módulo. Para alterar variáveis declaradas fora do escopo "
"mais interno, a instrução :keyword:`nonlocal` pode ser usada; caso "
"contrário, todas essas variáveis serão apenas para leitura (a tentativa de "
"atribuir valores a essas variáveis simplesmente criará uma *nova* variável "
"local, no escopo interno, não alterando nada na variável de nome idêntico "
"fora dele)."

#: ../../tutorial/classes.rst:133
msgid ""
"Usually, the local scope references the local names of the (textually) "
"current function.  Outside functions, the local scope references the same "
"namespace as the global scope: the module's namespace. Class definitions "
"place yet another namespace in the local scope."
msgstr ""
"Normalmente, o escopo local referencia os nomes locais da função corrente no "
"texto do programa. Fora de funções, o escopo local referencia os nomes do "
"escopo global: espaço de nomes do módulo. Definições de classes adicionam um "
"outro espaço de nomes ao escopo local."

#: ../../tutorial/classes.rst:138
msgid ""
"It is important to realize that scopes are determined textually: the global "
"scope of a function defined in a module is that module's namespace, no "
"matter from where or by what alias the function is called.  On the other "
"hand, the actual search for names is done dynamically, at run time --- "
"however, the language definition is evolving towards static name resolution, "
"at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
"local variables are already determined statically.)"
msgstr ""
"É importante perceber que escopos são determinados estaticamente, pelo texto "
"do código-fonte: o escopo global de uma função definida em um módulo é o "
"espaço de nomes deste módulo, sem importar de onde ou por qual apelido a "
"função é invocada. Por outro lado, a busca de nomes é dinâmica, ocorrendo "
"durante a execução. Porém, a evolução da linguagem está caminhando para uma "
"resolução de nomes estática, em \"tempo de compilação\", portanto não conte "
"com a resolução dinâmica de nomes! (De fato, variáveis locais já são "
"resolvidas estaticamente.)"

#: ../../tutorial/classes.rst:146
msgid ""
"A special quirk of Python is that -- if no :keyword:`global` or :keyword:"
"`nonlocal` statement is in effect -- assignments to names always go into the "
"innermost scope. Assignments do not copy data --- they just bind names to "
"objects.  The same is true for deletions: the statement ``del x`` removes "
"the binding of ``x`` from the namespace referenced by the local scope.  In "
"fact, all operations that introduce new names use the local scope: in "
"particular, :keyword:`import` statements and function definitions bind the "
"module or function name in the local scope."
msgstr ""
"Uma peculiaridade especial do Python é que -- se nenhuma instrução :keyword:"
"`global` ou :keyword:`nonlocal` estiver em vigor -- as atribuições de nomes "
"sempre entram no escopo mais interno. As atribuições não copiam dados --- "
"elas apenas vinculam nomes aos objetos. O mesmo vale para exclusões: a "
"instrução ``del x`` remove a ligação de ``x`` do espaço de nomes "
"referenciado pelo escopo local. De fato, todas as operações que introduzem "
"novos nomes usam o escopo local: em particular, instruções :keyword:`import` "
"e definições de funções ligam o módulo ou o nome da função no escopo local."

#: ../../tutorial/classes.rst:154
msgid ""
"The :keyword:`global` statement can be used to indicate that particular "
"variables live in the global scope and should be rebound there; the :keyword:"
"`nonlocal` statement indicates that particular variables live in an "
"enclosing scope and should be rebound there."
msgstr ""
"A instrução :keyword:`global` pode ser usada para indicar que certas "
"variáveis residem no escopo global ao invés do local; a instrução :keyword:"
"`nonlocal` indica que variáveis particulares estão em um espoco mais interno "
"e devem ser recuperadas lá."

#: ../../tutorial/classes.rst:162
msgid "Scopes and Namespaces Example"
msgstr "Exemplo de escopos e espaço de nomes"

#: ../../tutorial/classes.rst:164
msgid ""
"This is an example demonstrating how to reference the different scopes and "
"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
"variable binding::"
msgstr ""
"Este é um exemplo que demonstra como se referir aos diferentes escopos e aos "
"espaços de nomes, e como :keyword:`global` e :keyword:`nonlocal` pode afetar "
"ligação entre as variáveis::"

#: ../../tutorial/classes.rst:168
msgid ""
"def scope_test():\n"
"    def do_local():\n"
"        spam = \"local spam\"\n"
"\n"
"    def do_nonlocal():\n"
"        nonlocal spam\n"
"        spam = \"nonlocal spam\"\n"
"\n"
"    def do_global():\n"
"        global spam\n"
"        spam = \"global spam\"\n"
"\n"
"    spam = \"test spam\"\n"
"    do_local()\n"
"    print(\"After local assignment:\", spam)\n"
"    do_nonlocal()\n"
"    print(\"After nonlocal assignment:\", spam)\n"
"    do_global()\n"
"    print(\"After global assignment:\", spam)\n"
"\n"
"scope_test()\n"
"print(\"In global scope:\", spam)"
msgstr ""
"def teste_de_escopo():\n"
"    def faz_local():\n"
"        spam = \"spam local\"\n"
"\n"
"    def faz_nonlocal():\n"
"        nonlocal spam\n"
"        spam = \"spam não-local\"\n"
"\n"
"    def faz_global():\n"
"        global spam\n"
"        spam = \"spam global\"\n"
"\n"
"    spam = \"spam teste\"\n"
"    faz_local()\n"
"    print(\"Após atribuição local:\", spam)\n"
"    faz_nonlocal()\n"
"    print(\"Após atribuição não-local:\", spam)\n"
"    faz_global()\n"
"    print(\"Após atribuição global:\", spam)\n"
"\n"
"teste_de_escopo()\n"
"print(\"No escopo global:\", spam)"

#: ../../tutorial/classes.rst:191
msgid "The output of the example code is:"
msgstr "A saída do código de exemplo é:"

#: ../../tutorial/classes.rst:193
msgid ""
"After local assignment: test spam\n"
"After nonlocal assignment: nonlocal spam\n"
"After global assignment: nonlocal spam\n"
"In global scope: global spam"
msgstr ""
"Após atribuição local: spam teste\n"
"Após atribuição não-local: spam não-local\n"
"Após atribuição global: spam não-local\n"
"No escopo global: spam global"

#: ../../tutorial/classes.rst:200
msgid ""
"Note how the *local* assignment (which is default) didn't change "
"*scope_test*\\'s binding of *spam*.  The :keyword:`nonlocal` assignment "
"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "
"assignment changed the module-level binding."
msgstr ""
"Observe como uma atribuição *local* (que é o padrão) não altera o vínculo de "
"*teste_de_escopo* a *spam*. A instrução :keyword:`nonlocal` mudou o vínculo "
"de *teste_de_escopo* de *spam* e a atribuição :keyword:`global` alterou a "
"ligação para o nível do módulo."

#: ../../tutorial/classes.rst:205
msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Você também pode ver que não havia nenhuma ligação anterior para *spam* "
"antes da atribuição :keyword:`global`."

#: ../../tutorial/classes.rst:212
msgid "A First Look at Classes"
msgstr "Uma primeira olhada nas classes"

#: ../../tutorial/classes.rst:214
msgid ""
"Classes introduce a little bit of new syntax, three new object types, and "
"some new semantics."
msgstr ""
"Classes introduzem novidades sintáticas, três novos tipos de objetos, e "
"também alguma semântica nova."

#: ../../tutorial/classes.rst:221
msgid "Class Definition Syntax"
msgstr "Sintaxe da definição de classe"

#: ../../tutorial/classes.rst:223
msgid "The simplest form of class definition looks like this::"
msgstr "A forma mais simples de definir uma classe é::"

#: ../../tutorial/classes.rst:225
msgid ""
"class ClassName:\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class NomeClasse:\n"
"    <instrução-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <instrução-N>"

#: ../../tutorial/classes.rst:232
msgid ""
"Class definitions, like function definitions (:keyword:`def` statements) "
"must be executed before they have any effect.  (You could conceivably place "
"a class definition in a branch of an :keyword:`if` statement, or inside a "
"function.)"
msgstr ""
"Definições de classe, assim como definições de função (instruções :keyword:"
"`def`), precisam ser executadas antes que tenham qualquer efeito. (Você pode "
"colocar uma definição de classe dentro do teste condicional de um :keyword:"
"`if` ou dentro de uma função.)"

#: ../../tutorial/classes.rst:236
msgid ""
"In practice, the statements inside a class definition will usually be "
"function definitions, but other statements are allowed, and sometimes useful "
"--- we'll come back to this later.  The function definitions inside a class "
"normally have a peculiar form of argument list, dictated by the calling "
"conventions for methods --- again, this is explained later."
msgstr ""
"Na prática, as instruções dentro da definição de classe geralmente serão "
"definições de funções, mas outras instruções são permitidas, e às vezes são "
"bem úteis --- voltaremos a este tema depois. Definições de funções dentro da "
"classe normalmente têm um forma peculiar de lista de argumentos, determinada "
"pela convenção de chamada a métodos --- isso também será explicado mais "
"tarde."

#: ../../tutorial/classes.rst:242
msgid ""
"When a class definition is entered, a new namespace is created, and used as "
"the local scope --- thus, all assignments to local variables go into this "
"new namespace.  In particular, function definitions bind the name of the new "
"function here."
msgstr ""
"Quando se inicia a definição de classe, um novo espaço de nomes é criado, e "
"usado como escopo local --- assim, todas atribuições a variáveis locais "
"ocorrem nesse espaço de nomes. Em particular, funções definidas aqui são "
"vinculadas a nomes nesse escopo."

#: ../../tutorial/classes.rst:247
msgid ""
"When a class definition is left normally (via the end), a *class object* is "
"created.  This is basically a wrapper around the contents of the namespace "
"created by the class definition; we'll learn more about class objects in the "
"next section.  The original local scope (the one in effect just before the "
"class definition was entered) is reinstated, and the class object is bound "
"here to the class name given in the class definition header (:class:`!"
"ClassName` in the example)."
msgstr ""
"Quando uma definição de classe é finalizada normalmente (até o fim), um "
"*objeto classe* é criado. Este objeto encapsula o conteúdo do espaço de "
"nomes criado pela definição da classe; aprenderemos mais sobre objetos "
"classe na próxima seção. O escopo local (que estava vigente antes da "
"definição da classe) é reativado, e o objeto classe é vinculado ao "
"identificador da classe nesse escopo (:class:`!NomeClasse` no exemplo)."

#: ../../tutorial/classes.rst:259
msgid "Class Objects"
msgstr "Objetos classe"

#: ../../tutorial/classes.rst:261
msgid ""
"Class objects support two kinds of operations: attribute references and "
"instantiation."
msgstr ""
"Objetos classe suportam dois tipos de operações: *referências a atributos* e "
"*instanciação*."

#: ../../tutorial/classes.rst:264
msgid ""
"*Attribute references* use the standard syntax used for all attribute "
"references in Python: ``obj.name``.  Valid attribute names are all the names "
"that were in the class's namespace when the class object was created.  So, "
"if the class definition looked like this::"
msgstr ""
"*Referências a atributos* de classe utilizam a sintaxe padrão utilizada para "
"quaisquer referências a atributos em Python: ``obj.nome``. Nomes de "
"atributos válidos são todos os nomes presentes dentro do espaço de nomes da "
"classe, quando o objeto classe foi criado. Portanto, se a definição de "
"classe tem esta forma::"

#: ../../tutorial/classes.rst:269
msgid ""
"class MyClass:\n"
"    \"\"\"A simple example class\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'hello world'"
msgstr ""
"class MinhaClasse:\n"
"    \"\"\"Um exemplo de classe simples\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'olá mundo'"

#: ../../tutorial/classes.rst:276
msgid ""
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
"returning an integer and a function object, respectively. Class attributes "
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
"assignment. :attr:`~type.__doc__` is also a valid attribute, returning the "
"docstring belonging to the class: ``\"A simple example class\"``."
msgstr ""
"então ``MinhaClasse.i`` e ``MinhaClasse.f`` são referências a atributo "
"válidas, retornando, respectivamente, um inteiro e um objeto função. "
"Atributos de classe podem receber valores, pode-se modificar o valor de "
"``MinhaClasse.i`` num atribuição. :attr:`~type.__doc__` também é um atributo "
"válido da classe, retornando a docstring associada à classe: ``\"Um exemplo "
"de classe simples\"``."

#: ../../tutorial/classes.rst:282
msgid ""
"Class *instantiation* uses function notation.  Just pretend that the class "
"object is a parameterless function that returns a new instance of the class. "
"For example (assuming the above class)::"
msgstr ""
"Para *instanciar* uma classe, usa-se a mesma sintaxe de invocar uma função. "
"Apenas finja que o objeto classe do exemplo é uma função sem parâmetros, que "
"devolve uma nova instância da classe. Por exemplo (presumindo a classe "
"acima)::"

#: ../../tutorial/classes.rst:286 ../../tutorial/classes.rst:303
msgid "x = MyClass()"
msgstr "x = MinhaClasse()"

#: ../../tutorial/classes.rst:288
msgid ""
"creates a new *instance* of the class and assigns this object to the local "
"variable ``x``."
msgstr ""
"cria uma nova *instância* da classe e atribui o objeto resultante à variável "
"local ``x``."

#: ../../tutorial/classes.rst:291
msgid ""
"The instantiation operation (\"calling\" a class object) creates an empty "
"object. Many classes like to create objects with instances customized to a "
"specific initial state. Therefore a class may define a special method named :"
"meth:`~object.__init__`, like this::"
msgstr ""
"A operação de instanciação (\"invocar\" um objeto classe) cria um objeto "
"vazio. Muitas classes preferem criar novos objetos com um estado inicial "
"predeterminado. Para tanto, a classe pode definir um método especial "
"chamado :meth:`~object.__init__`, assim::"

#: ../../tutorial/classes.rst:296
msgid ""
"def __init__(self):\n"
"    self.data = []"
msgstr ""
"def __init__(self):\n"
"    self.data = []"

#: ../../tutorial/classes.rst:299
msgid ""
"When a class defines an :meth:`~object.__init__` method, class instantiation "
"automatically invokes :meth:`!__init__` for the newly created class "
"instance.  So in this example, a new, initialized instance can be obtained "
"by::"
msgstr ""
"Quando uma classe define um método :meth:`~object.__init__`, o processo de "
"instanciação automaticamente invoca :meth:`!__init__` sobre a instância "
"recém criada. Em nosso exemplo, uma nova instância já inicializada pode ser "
"obtida desta maneira::"

#: ../../tutorial/classes.rst:305
msgid ""
"Of course, the :meth:`~object.__init__` method may have arguments for "
"greater flexibility.  In that case, arguments given to the class "
"instantiation operator are passed on to :meth:`!__init__`.  For example, ::"
msgstr ""
"Naturalmente, o método :meth:`~object.__init__` pode ter parâmetros para "
"maior flexibilidade. Neste caso, os argumentos fornecidos na invocação da "
"classe serão passados para o método :meth:`!__init__`. Por exemplo, ::"

#: ../../tutorial/classes.rst:309
msgid ""
">>> class Complex:\n"
"...     def __init__(self, realpart, imagpart):\n"
"...         self.r = realpart\n"
"...         self.i = imagpart\n"
"...\n"
">>> x = Complex(3.0, -4.5)\n"
">>> x.r, x.i\n"
"(3.0, -4.5)"
msgstr ""
">>> class Complex:\n"
"...     def __init__(self, realpart, imagpart):\n"
"...         self.r = realpart\n"
"...         self.i = imagpart\n"
"...\n"
">>> x = Complex(3.0, -4.5)\n"
">>> x.r, x.i\n"
"(3.0, -4.5)"

#: ../../tutorial/classes.rst:322
msgid "Instance Objects"
msgstr "Objetos instância"

#: ../../tutorial/classes.rst:324
msgid ""
"Now what can we do with instance objects?  The only operations understood by "
"instance objects are attribute references.  There are two kinds of valid "
"attribute names: data attributes and methods."
msgstr ""
"Agora o que podemos fazer com objetos de instância? As únicas operações "
"compreendidas por objetos de instância são os atributos de referência. "
"Existem duas maneiras válidas para nomear atributos: atributos de dados e "
"métodos."

#: ../../tutorial/classes.rst:328
msgid ""
"*Data attributes* correspond to \"instance variables\" in Smalltalk, and to "
"\"data members\" in C++.  Data attributes need not be declared; like local "
"variables, they spring into existence when they are first assigned to.  For "
"example, if ``x`` is the instance of :class:`!MyClass` created above, the "
"following piece of code will print the value ``16``, without leaving a "
"trace::"
msgstr ""
"*Atributos de dados* correspondem a \"variáveis de instância\" em Smalltalk, "
"e a \"membros de dados\" em C++. Atributos de dados não precisam ser "
"declarados. Assim como variáveis locais, eles passam a existir na primeira "
"vez em que é feita uma atribuição. Por exemplo, se ``x`` é uma instância da :"
"class:`!MinhaClasse` criada acima, o próximo trecho de código irá exibir o "
"valor ``16``, sem deixar nenhum rastro::"

#: ../../tutorial/classes.rst:334
msgid ""
"x.counter = 1\n"
"while x.counter < 10:\n"
"    x.counter = x.counter * 2\n"
"print(x.counter)\n"
"del x.counter"
msgstr ""
"x.contador = 1\n"
"while x.contador < 10:\n"
"    x.contador = x.contador * 2\n"
"print(x.contador)\n"
"del x.contador"

#: ../../tutorial/classes.rst:340
msgid ""
"The other kind of instance attribute reference is a *method*. A method is a "
"function that \"belongs to\" an object."
msgstr ""
"O outro tipo de referência a um atributo de instância é um *método*. Um "
"método é uma função que \"pertence a\" um objeto."

#: ../../tutorial/classes.rst:345
msgid ""
"Valid method names of an instance object depend on its class.  By "
"definition, all attributes of a class that are function  objects define "
"corresponding methods of its instances.  So in our example, ``x.f`` is a "
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
"not, since ``MyClass.i`` is not.  But ``x.f`` is not the same thing as "
"``MyClass.f`` --- it is a *method object*, not a function object."
msgstr ""
"Nomes de métodos válidos de uma instância dependem de sua classe. Por "
"definição, cada atributo de uma classe que é uma função corresponde a um "
"método das instâncias. Em nosso exemplo, ``x.f`` é uma referência de método "
"válida já que ``MinhaClasse.f`` é uma função, enquanto ``x.i`` não é, já que "
"``MinhaClasse.i`` não é uma função. Entretanto, ``x.f`` não é o mesmo que "
"``MinhaClasse.f``. A referência ``x.f`` acessa um objeto método e a "
"``MinhaClasse.f`` acessa um objeto função."

#: ../../tutorial/classes.rst:356
msgid "Method Objects"
msgstr "Objetos método"

#: ../../tutorial/classes.rst:358
msgid "Usually, a method is called right after it is bound::"
msgstr "Normalmente, um método é chamado imediatamente após ser referenciado::"

#: ../../tutorial/classes.rst:360
msgid "x.f()"
msgstr "x.f()"

#: ../../tutorial/classes.rst:362
msgid ""
"If ``x = MyClass()``, as above, this will return the string ``'hello "
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
"is a method object, and can be stored away and called at a later time.  For "
"example::"
msgstr ""
"Se ``x = MinhaClasse()``, como acima, o resultado da expressão acima será a "
"string ``\"olá mundo\"``. No entanto, não é obrigatório invocar o método "
"imediatamente: como ``x.f`` é também um objeto ele pode ser atribuído a uma "
"variável e invocado depois. Por exemplo::"

#: ../../tutorial/classes.rst:366
msgid ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"
msgstr ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"

#: ../../tutorial/classes.rst:370
msgid "will continue to print ``hello world`` until the end of time."
msgstr "exibirá o texto ``olá mundo`` até o mundo acabar."

#: ../../tutorial/classes.rst:372
msgid ""
"What exactly happens when a method is called?  You may have noticed that ``x."
"f()`` was called without an argument above, even though the function "
"definition for :meth:`!f` specified an argument.  What happened to the "
"argument? Surely Python raises an exception when a function that requires an "
"argument is called without any --- even if the argument isn't actually "
"used..."
msgstr ""
"O que ocorre precisamente quando um método é invocado? Você deve ter notado "
"que ``x.f()`` foi chamado sem nenhum argumento, porém a definição da função :"
"meth:`!f` especificava um argumento. O que aconteceu com esse argumento? "
"Certamente Python levanta uma exceção quando uma função que declara um "
"argumento é invocada sem nenhum argumento --- mesmo que o argumento não seja "
"usado no corpo da função..."

#: ../../tutorial/classes.rst:378
msgid ""
"Actually, you may have guessed the answer: the special thing about methods "
"is that the instance object is passed as the first argument of the "
"function.  In our example, the call ``x.f()`` is exactly equivalent to "
"``MyClass.f(x)``.  In general, calling a method with a list of *n* arguments "
"is equivalent to calling the corresponding function with an argument list "
"that is created by inserting the method's instance object before the first "
"argument."
msgstr ""
"Na verdade, pode-se supor a resposta: a particularidade sobre os métodos é "
"que o objeto da instância é passado como o primeiro argumento da função. Em "
"nosso exemplo, a chamada ``x.f()`` é exatamente equivalente a ``MinhaClasse."
"f(x)``. Em geral, chamar um método com uma lista de *n* argumentos é "
"equivalente a chamar a função correspondente com uma lista de argumentos que "
"é criada inserindo o objeto de instância do método antes do primeiro "
"argumento."

#: ../../tutorial/classes.rst:385
msgid ""
"In general, methods work as follows.  When a non-data attribute of an "
"instance is referenced, the instance's class is searched. If the name "
"denotes a valid class attribute that is a function object, references to "
"both the instance object and the function object are packed into a method "
"object.  When the method object is called with an argument list, a new "
"argument list is constructed from the instance object and the argument list, "
"and the function object is called with this new argument list."
msgstr ""
"Em geral, os métodos funcionam da seguinte forma. Quando um atributo de uma "
"instância, não relacionado a dados, é referenciado, a classe da instância é "
"pesquisada. Se o nome é um atributo de classe válido que é um objeto função, "
"referências ao objeto de instância e ao objeto função serão empacotadas em "
"um objeto método. Quando o objeto método é chamado com uma lista de "
"argumentos, uma nova lista de argumentos é construída a partir do objeto de "
"instância e da lista de argumentos, e o objeto função é chamado com essa "
"nova lista de argumentos."

#: ../../tutorial/classes.rst:398
msgid "Class and Instance Variables"
msgstr "Variáveis de classe e instância"

#: ../../tutorial/classes.rst:400
msgid ""
"Generally speaking, instance variables are for data unique to each instance "
"and class variables are for attributes and methods shared by all instances "
"of the class::"
msgstr ""
"De forma geral, variáveis de instância são variáveis que indicam dados que "
"são únicos a cada instância individual, e variáveis de classe são variáveis "
"de atributos e de métodos que são comuns a todas as instâncias de uma "
"classe::"

#: ../../tutorial/classes.rst:404
msgid ""
"class Dog:\n"
"\n"
"    kind = 'canine'         # class variable shared by all instances\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name    # instance variable unique to each instance\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.kind                  # shared by all dogs\n"
"'canine'\n"
">>> e.kind                  # shared by all dogs\n"
"'canine'\n"
">>> d.name                  # unique to d\n"
"'Fido'\n"
">>> e.name                  # unique to e\n"
"'Buddy'"
msgstr ""
"class Cachorro:\n"
"\n"
"    tipo = 'canino'         # variável de classe compartilhada por todas as "
"instâncias\n"
"\n"
"    def __init__(self, nome):\n"
"        self.nome = nome    # variável de instância única para cada "
"instância\n"
"\n"
">>> d = Cachorro('Fido')\n"
">>> e = Cachorro('Buddy')\n"
">>> d.tipo                  # compartilhada por todos os cachorros\n"
"'canino'\n"
">>> e.tipo                  # compartilhada por todos os cachorros\n"
"'canino'\n"
">>> d.nome                  # exclusiva do d\n"
"'Fido'\n"
">>> e.nome                  # exclusiva do e\n"
"'Buddy'"

#: ../../tutorial/classes.rst:422
msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects involving :term:`mutable` objects such as lists and dictionaries. "
"For example, the *tricks* list in the following code should not be used as a "
"class variable because just a single list would be shared by all *Dog* "
"instances::"
msgstr ""

#: ../../tutorial/classes.rst:428
msgid ""
"class Dog:\n"
"\n"
"    tricks = []             # mistaken use of a class variable\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks                # unexpectedly shared by all dogs\n"
"['roll over', 'play dead']"
msgstr ""
"class Cachorro:\n"
"\n"
"    truques = []             # uso incorreto de uma variável de classe\n"
"\n"
"    def __init__(self, nome):\n"
"        self.nome = nome\n"
"\n"
"    def adicionar_truque(self, truque):\n"
"        self.truques.append(truque)\n"
"\n"
">>> d = Cachorro('Fido')\n"
">>> e = Cachorro('Buddy')\n"
">>> d.adicionar_truque('rolar')\n"
">>> e.adicionar_truque('fingir de morto')\n"
">>> d.truques                # inesperadamente compartilhado por todos os "
"cães\n"
"['rolar', 'fingir de morto']"

#: ../../tutorial/classes.rst:445
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Em vez disso, o modelo correto da classe deve usar uma variável de "
"instância::"

#: ../../tutorial/classes.rst:447
msgid ""
"class Dog:\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"        self.tricks = []    # creates a new empty list for each dog\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"