# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-09-22 21:19+0000\n"
"PO-Revision-Date: 2025-09-22 15:58+0000\n"
"Last-Translator: python-doc bot, 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"
#: ../../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 "
"\"instncias\" desse tipo sejam produzidas. Cada instncia da classe pode "
"ter atributos anexados a ela, para manter seu estado. Instncias da classe "
"tambm podem ter mtodos (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 comparao com outras linguagens de programao, o mecanismo de classes "
"de Python introduz a programao orientada a objetos sem acrescentar muitas "
"novidades de sintaxe ou semntica. uma mistura de mecanismos equivalentes "
"encontrados em C++ e Modula-3. As classes em Python oferecem todas as "
"caractersticas tradicionais da programao orientada a objetos: o mecanismo "
"de herana permite mltiplas classes base (herana mltipla), uma classe "
"derivada pode sobrescrever quaisquer mtodos de uma classe ancestral, e um "
"mtodo pode invocar outro mtodo homnimo de uma classe ancestral. Objetos "
"podem armazenar uma quantidade arbitrria de dados de qualquer tipo. Assim "
"como acontece com os mdulos, as classes fazem parte da natureza dinmica de "
"Python: so criadas em tempo de execuo, e podem ser alteradas aps sua "
"criao."
#: ../../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) so *pblicos* (veja exceo abaixo :ref:`tut-private`), e todos as "
"funes membro so *virtuais*. Como em Modula-3, no existem atalhos para "
"referenciar membros do objeto de dentro dos seus mtodos: o mtodo (funo "
"definida em uma classe) declarado com um primeiro argumento explcito "
"representando o objeto (instncia da classe), que fornecido implicitamente "
"pela chamada ao mtodo. Como em Smalltalk, classes so objetos. Isso fornece "
"uma semntica para importar e renomear. Ao contrrio de C++ ou Modula-3, "
"tipos pr-definidos podem ser utilizados como classes base para extenses "
"por herana pelo usurio. Tambm, como em C++, a maioria dos operadores "
"(aritmticos, indexao, etc) podem ser redefinidos por instncias 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 semntica de orientao a objetos "
"mais prxima 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 tm individualidade, e vrios nomes (em diferentes escopos) podem "
"ser vinculados a um mesmo objeto. Isso chamado de apelidamento em outras "
"linguagens. Geralmente, esta caracterstica no muito apreciada, e pode "
"ser ignorada com segurana ao lidar com tipos imutveis (nmeros, strings, "
"tuplas). Entretanto, apelidamento pode ter um efeito surpreendente na "
"semntica do cdigo Python envolvendo objetos mutveis como listas, "
"dicionrios e a maioria dos outros tipos. Isso pode ser usado em benefcio "
"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 implementao; e se uma funo modifica um objeto passado como "
"argumento, o invocador ver a mudana --- isso elimina a necessidade de ter "
"dois mecanismos de passagem de parmetros como em Pascal."
#: ../../tutorial/classes.rst:61
msgid "Python Scopes and Namespaces"
msgstr "Escopos e espaos 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. "
"Definies de classe fazem alguns truques com espaos de nomes. Portanto, "
"primeiro preciso entender claramente como escopos e espaos de nomes "
"funcionam, para entender o que est acontecendo. Esse conhecimento muito "
"til para qualquer programador Python avanado."
#: ../../tutorial/classes.rst:69
msgid "Let's begin with some definitions."
msgstr "Vamos comear com algumas definies."
#: ../../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 *espao de nomes* um mapeamento que associa nomes a objetos. "
"Atualmente, so implementados como dicionrios em Python, mas isso no "
"perceptvel (a no ser pelo desempenho), e pode mudar no futuro. Exemplos de "
"espaos de nomes so: o conjunto de nomes pr-definidos (funes como :func:"
"`abs` e as excees pr-definidas); nomes globais em um mdulo; e nomes "
"locais na invocao de uma funo. De certa forma, os atributos de um objeto "
"tambm formam um espao de nomes. O mais importante saber que no existe "
"nenhuma relao entre nomes em espaos de nomes distintos. Por exemplo, dois "
"mdulos podem definir uma funo de nome ``maximize`` sem confuso --- "
"usurios dos mdulos devem prefixar a funo com o nome do mdulo, para "
"evitar coliso."
#: ../../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 propsito, utilizo a palavra *atributo* para qualquer nome depois de um "
"ponto. Na expresso ``z.real``, por exemplo, ``real`` um atributo do "
"objeto ``z``. Estritamente falando, referncias para nomes em mdulos so "
"atributos: na expresso ``modname.funcname``, ``modname`` um objeto mdulo "
"e ``funcname`` um de seus atributos. Neste caso, existe um mapeamento "
"direto entre os atributos de um mdulo e os nomes globais definidos no "
"mdulo: eles compartilham o mesmo espao 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, possvel atribuir um novo valor ao atributo. Atributos de mdulos "
"so passveis de atribuio: voc pode escrever ``modname.the_answer = 42``. "
"Atributos que aceitam escrita tambm podem ser apagados atravs da "
"instruo :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 ""
"Espaos de nomes so criados em momentos diferentes e possuem diferentes "
"ciclos de vida. O espao de nomes que contm os nomes embutidos criado "
"quando o interpretador inicializa e nunca removido. O espao de nomes "
"global de um mdulo criado quando a definio do mdulo lida, e "
"normalmente duram at a terminao do interpretador. Os comandos executados "
"pela invocao do interpretador, pela leitura de um script com programa "
"principal, ou interativamente, so parte do mdulo chamado :mod:`__main__`, "
"e portanto possuem seu prprio espao de nomes. (Os nomes embutidos possuem "
"seu prprio espao de nomes no mdulo 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 espao de nomes local de uma funo criado quando a funo invocada, e "
"apagado quando a funo retorna ou levanta uma exceo que no tratada na "
"prpria funo. (Na verdade, uma forma melhor de descrever o que realmente "
"acontece que o espao de nomes local \"esquecido\" quando a funo "
"termina.) Naturalmente, cada invocao recursiva de uma funo tem seu "
"prprio espao 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 regio textual de um programa Python onde um espao de "
"nomes diretamente acessvel. Aqui, \"diretamente acessvel\" significa que "
"uma referncia 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 so usados "
"dinamicamente. A qualquer momento durante a execuo, existem 3 ou 4 escopos "
"aninhados cujos espaos de nomes so diretamente acessveis:"
#: ../../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 funes que envolvem a funo atual, que so acessados a "
"partir do escopo mais prximo, contm nomes no-locais, mas tambm no-"
"globais"
#: ../../tutorial/classes.rst:123
msgid "the next-to-last scope contains the current module's global names"
msgstr "o penltimo escopo contm os nomes globais do mdulo 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) contm os nomes das funes "
"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, ento todas as referncias e "
"atribuies de valores vo diretamente para o penltimo escopo, que contm "
"os nomes globais do mdulo. Para alterar variveis declaradas fora do escopo "
"mais interno, a instruo :keyword:`nonlocal` pode ser usada; caso "
"contrrio, todas essas variveis sero apenas para leitura (a tentativa de "
"atribuir valores a essas variveis simplesmente criar uma *nova* varivel "
"local, no escopo interno, no alterando nada na varivel de nome idntico "
"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 funo corrente no "
"texto do programa. Fora de funes, o escopo local referencia os nomes do "
"escopo global: espao de nomes do mdulo. Definies de classes adicionam um "
"outro espao 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 so determinados estaticamente, pelo texto "
"do cdigo-fonte: o escopo global de uma funo definida em um mdulo o "
"espao de nomes deste mdulo, sem importar de onde ou por qual apelido a "
"funo invocada. Por outro lado, a busca de nomes dinmica, ocorrendo "
"durante a execuo. Porm, a evoluo da linguagem est caminhando para uma "
"resoluo de nomes esttica, em \"tempo de compilao\", portanto no conte "
"com a resoluo dinmica de nomes! (De fato, variveis locais j so "
"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 instruo :keyword:"
"`global` ou :keyword:`nonlocal` estiver em vigor -- as atribuies de nomes "
"sempre entram no escopo mais interno. As atribuies no copiam dados --- "
"elas apenas vinculam nomes aos objetos. O mesmo vale para excluses: a "
"instruo ``del x`` remove a ligao de ``x`` do espao de nomes "
"referenciado pelo escopo local. De fato, todas as operaes que introduzem "
"novos nomes usam o escopo local: em particular, instrues :keyword:`import` "
"e definies de funes ligam o mdulo ou o nome da funo 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 instruo :keyword:`global` pode ser usada para indicar que certas "
"variveis residem no escopo global ao invs do local; a instruo :keyword:"
"`nonlocal` indica que variveis particulares esto em um espoco mais interno "
"e devem ser recuperadas l."
#: ../../tutorial/classes.rst:162
msgid "Scopes and Namespaces Example"
msgstr "Exemplo de escopos e espao 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 "
"espaos de nomes, e como :keyword:`global` e :keyword:`nonlocal` pode afetar "
"ligao entre as variveis::"
#: ../../tutorial/classes.rst:191
msgid "The output of the example code is:"
msgstr "A sada do cdigo de exemplo :"
#: ../../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 atribuio *local* (que o padro) no altera o vnculo de "
"*teste_de_escopo* a *spam*. A instruo :keyword:`nonlocal` mudou o vnculo "
"de *teste_de_escopo* de *spam* e a atribuio :keyword:`global` alterou a "
"ligao para o nvel do mdulo."
#: ../../tutorial/classes.rst:205
msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Voc tambm pode ver que no havia nenhuma ligao anterior para *spam* "
"antes da atribuio :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 sintticas, trs novos tipos de objetos, e "
"tambm alguma semntica nova."
#: ../../tutorial/classes.rst:221
msgid "Class Definition Syntax"
msgstr "Sintaxe da definio 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: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 ""
"Definies de classe, assim como definies de funo (instrues :keyword:"
"`def`), precisam ser executadas antes que tenham qualquer efeito. (Voc pode "
"colocar uma definio de classe dentro do teste condicional de um :keyword:"
"`if` ou dentro de uma funo.)"
#: ../../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 prtica, as instrues dentro da definio de classe geralmente sero "
"definies de funes, mas outras instrues so permitidas, e s vezes so "
"bem teis --- voltaremos a este tema depois. Definies de funes dentro da "
"classe normalmente tm um forma peculiar de lista de argumentos, determinada "
"pela conveno de chamada a mtodos --- isso tambm 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 definio de classe, um novo espao de nomes criado, e "
"usado como escopo local --- assim, todas atribuies a variveis locais "
"ocorrem nesse espao de nomes. Em particular, funes definidas aqui so "
"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 definio de classe finalizada normalmente (at o fim), um "
"*objeto classe* criado. Este objeto encapsula o contedo do espao de "
"nomes criado pela definio da classe; aprenderemos mais sobre objetos "
"classe na prxima seo. O escopo local que estava vigente antes da "
"definio da classe reativado, e o objeto classe vinculado ao "
"identificador da classe nesse escopo (:class:`ClassName` 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 operaes: *referncias a atributos* e "
"*instanciao*."
#: ../../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 ""
"*Referncias a atributos* de classe utilizam a sintaxe padro utilizada para "
"quaisquer referncias a atributos em Python: ``obj.nome``. Nomes de "
"atributos vlidos so todos os nomes presentes dentro do espao de nomes da "
"classe, quando o objeto classe foi criado. Portanto, se a definio de "
"classe tem esta forma::"
#: ../../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:`__doc__` is also a valid attribute, returning the "
"docstring belonging to the class: ``\"A simple example class\"``."
msgstr ""
"ento ``MyClass.i`` e ``MyClass.f`` so referncias a atributo vlidas, "
"retornando, respectivamente, um inteiro e um objeto funo. Atributos de "
"classe podem receber valores, pode-se modificar o valor de ``MyClass.i`` num "
"atribuio. :attr:`__doc__` tambm um atributo vlido da classe, "
"retornando a *documentao* associada: ``\"A simple example class\"``."
#: ../../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 funo. "
"Apenas finja que o objeto classe do exemplo uma funo sem parmetros, que "
"devolve uma nova instncia da classe. Por exemplo (presumindo a classe "
"acima)::"
#: ../../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 *instncia* da classe e atribui o objeto resultante varivel "
"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:`__init__`, like this::"
msgstr ""
"A operao de instanciao (\"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 mtodo especial "
"chamado :meth:`__init__`, assim::"
#: ../../tutorial/classes.rst:299
msgid ""
"When a class defines an :meth:`__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 mtodo :meth:`__init__`, o processo de "
"instanciao automaticamente invoca :meth:`__init__` sobre a instncia recm "
"criada. Em nosso exemplo, uma nova instncia j inicializada pode ser obtida "
"desta maneira::"
#: ../../tutorial/classes.rst:305
msgid ""
"Of course, the :meth:`__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 mtodo :meth:`__init__` pode ter parmetros para maior "
"flexibilidade. Neste caso, os argumentos fornecidos na invocao da classe "
"sero passados para o mtodo :meth:`__init__`. Por exemplo, ::"
#: ../../tutorial/classes.rst:322
msgid "Instance Objects"
msgstr "Objetos instncia"
#: ../../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 instncia? As nicas operaes "
"compreendidas por objetos de instncia so os atributos de referncia. "
"Existem duas maneiras vlidas para nomear atributos: atributos de dados e "
"mtodos."
#: ../../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 ""
#: ../../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. (In Python, the term method is not "
"unique to class instances: other object types can have methods as well. For "
"example, list objects have methods called append, insert, remove, sort, and "
"so on. However, in the following discussion, we'll use the term method "
"exclusively to mean methods of class instance objects, unless explicitly "
"stated otherwise.)"
msgstr ""
"O outro tipo de referncias a atributos de instncia o \"mtodo\". Um "
"mtodo uma funo que \"pertence\" a um objeto instncia. (Em Python, o "
"termo mtodo no aplicado exclusivamente a instncias de classes definidas "
"pelo usurio: outros tipos de objetos tambm podem ter mtodos. Por exemplo, "
"listas possuem os mtodos append, insert, remove, sort, entre outros. Porm, "
"na discusso a seguir, usaremos o termo mtodo apenas para se referir a "
"mtodos de classes definidas pelo usurio. Seremos explcitos ao falar de "
"outros mtodos.)"
#: ../../tutorial/classes.rst:349
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 mtodos vlidos de uma instncia dependem de sua classe. Por "
"definio, cada atributo de uma classe que uma funo corresponde a um "
"mtodo das instncias. Em nosso exemplo, ``x.f`` uma referncia de mtodo "
"vlida j que ``MinhaClasse.f`` uma funo, enquanto ``x.i`` no , j que "
"``MinhaClasse.i`` no uma funo. Entretanto, ``x.f`` no o mesmo que "
"``MinhaClasse.f``. A referncia ``x.f`` acessa um objeto mtodo e a "
"``MinhaClasse.f`` acessa um objeto funo."
#: ../../tutorial/classes.rst:360
msgid "Method Objects"
msgstr "Objetos mtodo"
#: ../../tutorial/classes.rst:362
msgid "Usually, a method is called right after it is bound::"
msgstr "Normalmente, um mtodo chamado imediatamente aps ser referenciado::"
#: ../../tutorial/classes.rst:366
msgid ""
"In the :class:`MyClass` example, 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 ""
"No exemplo :class:`MyClass` o resultado da expresso acima ser a string "
"``'hello world'``. No entanto, no obrigatrio invocar o mtodo "
"imediatamente: como ``x.f`` tambm um objeto ele pode ser atribudo a uma "
"varivel e invocado depois. Por exemplo::"
#: ../../tutorial/classes.rst:374
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:376
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 mtodo invocado? Voc deve ter notado "
"que ``x.f()`` foi chamado sem nenhum argumento, porm a definio da funo :"
"meth:`f` especificava um argumento. O que aconteceu com esse argumento? "
"Certamente Python levanta uma exceo quando uma funo que declara um "
"argumento invocada sem nenhum argumento --- mesmo que o argumento no seja "
"usado no corpo da funo..."
#: ../../tutorial/classes.rst:382
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 mtodos "
"que o objeto da instncia passado como o primeiro argumento da funo. Em "
"nosso exemplo, a chamada ``x.f()`` exatamente equivalente a ``MinhaClasse."
"f(x)``. Em geral, chamar um mtodo com uma lista de *n* argumentos "
"equivalente a chamar a funo correspondente com uma lista de argumentos que "
" criada inserindo o objeto de instncia do mtodo antes do primeiro "
"argumento."
#: ../../tutorial/classes.rst:389
msgid ""
"If you still don't understand how methods work, a look at the implementation "
"can perhaps clarify matters. 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, a method object is created by "
"packing (pointers to) the instance object and the function object just found "
"together in an abstract object: this is the 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 ""
"Se voc ainda no entende como os mtodos funcionam, d uma olhada na "
"implementao para esclarecer as coisas. Quando um atributo de uma "
"instncia, no relacionado a dados, referenciado, a classe da instncia "
"pesquisada. Se o nome um atributo de classe vlido, e o nome de uma "
"funo, um mtodo criado, empacotando a instncia e a funo, que esto "
"juntos num objeto abstrato: este o mtodo. Quando o mtodo invocado com "
"uma lista de argumentos, uma nova lista de argumentos criada inserindo a "
"instncia na posio 0 da lista. Finalmente, o objeto funo empacotado "
"dentro do objeto mtodo invocado com a nova lista de argumentos."
#: ../../tutorial/classes.rst:403
msgid "Class and Instance Variables"
msgstr "Variveis de classe e instncia"
#: ../../tutorial/classes.rst:405
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, variveis de instncia so variveis que indicam dados que "
"so nicos a cada instncia individual, e variveis de classe so variveis "
"de atributos e de mtodos que so comuns a todas as instncias de uma "
"classe::"
#: ../../tutorial/classes.rst:427
msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects with 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 ""
"Como vimos em :ref:`tut-object`, dados compartilhados podem causar efeitos "
"inesperados quando envolvem objetos (:term:`mutveis `), como "
"listas ou dicionrios. Por exemplo, a lista *tricks* do cdigo abaixo no "
"deve ser usada como varivel de classe, pois assim seria compartilhada por "
"todas as instncias de *Cachorro*::"
#: ../../tutorial/classes.rst:450
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Em vez disso, o modelo correto da classe deve usar uma varivel de "
"instncia::"
#: ../../tutorial/classes.rst:474
msgid "Random Remarks"
msgstr "Observaes aleatrias"
#: ../../tutorial/classes.rst:478
msgid ""
"If the same attribute name occurs in both an instance and in a class, then "
"attribute lookup prioritizes the instance::"
msgstr ""
"Se um mesmo nome de atributo ocorre tanto na instncia quanto na classe, a "
"busca pelo atributo prioriza a instncia::"
#: ../../tutorial/classes.rst:493
msgid ""
"Data attributes may be referenced by methods as well as by ordinary users "
"(\"clients\") of an object. In other words, classes are not usable to "
"implement pure abstract data types. In fact, nothing in Python makes it "
"possible to enforce data hiding --- it is all based upon convention. (On "
"the other hand, the Python implementation, written in C, can completely hide "
"implementation details and control access to an object if necessary; this "
"can be used by extensions to Python written in C.)"
msgstr ""
"Atributos de dados podem ser referenciados por mtodos da prpria instncia, "
"bem como por qualquer outro usurio do objeto (tambm chamados \"clientes\" "
"do objeto). Em outras palavras, classes no servem para implementar tipos "
"puramente abstratos de dados. De fato, nada em Python torna possvel "
"assegurar o encapsulamento de dados --- tudo baseado em conveno. (Por "
"outro lado, a implementao de Python, escrita em C, pode esconder "
"completamente detalhes de um objeto e controlar o acesso ao objeto, se "
"necessrio; isto pode ser utilizado por extenses de Python escritas em C.)"
#: ../../tutorial/classes.rst:501
msgid ""
"Clients should use data attributes with care --- clients may mess up "
"invariants maintained by the methods by stamping on their data attributes. "
"Note that clients may add data attributes of their own to an instance object "
"without affecting the validity of the methods, as long as name conflicts are "
"avoided --- again, a naming convention can save a lot of headaches here."
msgstr ""
"Clientes devem utilizar atributos de dados com cuidado, pois podem bagunar "
"invariantes assumidas pelos mtodos ao esbarrar em seus atributos de dados. "
"Note que clientes podem adicionar atributos de dados a suas prprias "
"instncias, sem afetar a validade dos mtodos, desde que seja evitado o "
"conflito de nomes. Novamente, uma conveno de nomenclatura poupa muita dor "
"de cabea."
#: ../../tutorial/classes.rst:507
msgid ""
"There is no shorthand for referencing data attributes (or other methods!) "
"from within methods. I find that this actually increases the readability of "
"methods: there is no chance of confusing local variables and instance "
"variables when glancing through a method."
msgstr ""
"No existe atalho para referenciar atributos de dados (ou outros mtodos!) "
"de dentro de um mtodo. Isso aumenta a legibilidade dos mtodos: no h como "
"confundir variveis locais com variveis da instncia quando lemos "
"rapidamente um mtodo."
#: ../../tutorial/classes.rst:512
msgid ""
"Often, the first argument of a method is called ``self``. This is nothing "
"more than a convention: the name ``self`` has absolutely no special meaning "
"to Python. Note, however, that by not following the convention your code "
"may be less readable to other Python programmers, and it is also conceivable "
"that a *class browser* program might be written that relies upon such a "
"convention."
msgstr ""
"Frequentemente, o primeiro argumento de um mtodo chamado ``self``. Isso "
"no passa de uma conveno: o identificador ``self`` no uma palavra "
"reservada nem possui qualquer significado especial em Python. Mas note que, "
"ao seguir essa conveno, seu cdigo se torna legvel por uma grande "
"comunidade de desenvolvedores Python e possvel que alguma *IDE* dependa "
"dessa conveno para analisar seu cdigo."
#: ../../tutorial/classes.rst:518
msgid ""
"Any function object that is a class attribute defines a method for instances "
"of that class. It is not necessary that the function definition is "
"textually enclosed in the class definition: assigning a function object to a "
"local variable in the class is also ok. For example::"
msgstr ""
"Qualquer objeto funo que atributo de uma classe, define um mtodo para "
"as instncias dessa classe. No necessrio que a definio da funo "
"esteja textualmente embutida na definio da classe. Atribuir um objeto "
"funo a uma varivel local da classe vlido. Por exemplo::"
#: ../../tutorial/classes.rst:535
msgid ""
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer "
"to function objects, and consequently they are all methods of instances of :"
"class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this "
"practice usually only serves to confuse the reader of a program."
msgstr ""
"Agora ``f``, ``g`` e ``h`` so todos atributos da classe :class:`C` que "
"referenciam funes, e consequentemente so todos mtodos de instncias da "
"classe :class:`C`, onde ``h`` exatamente equivalente a ``g``. No entanto, "
"essa prtica serve apenas para confundir o leitor do programa."
#: ../../tutorial/classes.rst:540
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Mtodos podem invocar outros mtodos usando atributos de mtodo do argumento "
"``self``::"
#: ../../tutorial/classes.rst:554
msgid ""
"Methods may reference global names in the same way as ordinary functions. "
"The global scope associated with a method is the module containing its "
"definition. (A class is never used as a global scope.) While one rarely "
"encounters a good reason for using global data in a method, there are many "
"legitimate uses of the global scope: for one thing, functions and modules "
"imported into the global scope can be used by methods, as well as functions "
"and classes defined in it. Usually, the class containing the method is "
"itself defined in this global scope, and in the next section we'll find some "
"good reasons why a method would want to reference its own class."
msgstr ""
"Mtodos podem referenciar nomes globais da mesma forma que funes comuns. O "
"escopo global associado a um mtodo o mdulo contendo sua definio na "
"classe (a classe propriamente dita nunca usada como escopo global!). Ainda "
"que seja raro justificar o uso de dados globais em um mtodo, h diversos "
"usos legtimos do escopo global. Por exemplo, funes e mdulos importados "
"no escopo global podem ser usados por mtodos, bem como as funes e classes "
"definidas no prprio escopo global. Provavelmente, a classe contendo o "
"mtodo em questo tambm foi definida neste escopo global. Na prxima seo "
"veremos razes pelas quais um mtodo pode querer referenciar sua prpria "
"classe."
#: ../../tutorial/classes.rst:564
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Cada valor um objeto e, portanto, tem uma *classe* (tambm chamada de "
"*tipo*). Ela armazenada como ``object.__class__``."
#: ../../tutorial/classes.rst:571
msgid "Inheritance"
msgstr "Herana"
#: ../../tutorial/classes.rst:573
msgid ""
"Of course, a language feature would not be worthy of the name \"class\" "
"without supporting inheritance. The syntax for a derived class definition "
"looks like this::"
msgstr ""
"Obviamente, uma caracterstica da linguagem no seria digna do nome "
"\"classe\" se no suportasse herana. A sintaxe para uma classe derivada "
"assim::"
#: ../../tutorial/classes.rst:584
msgid ""
"The name :class:`BaseClassName` must be defined in a scope containing the "
"derived class definition. In place of a base class name, other arbitrary "
"expressions are also allowed. This can be useful, for example, when the "
"base class is defined in another module::"
msgstr ""
"O identificador :class:`BaseClassName` deve estar definido no escopo que "
"contm a definio da classe derivada. No lugar do nome da classe base, "
"tambm so aceitas outras expresses. Isso muito til, por exemplo, quando "
"a classe base definida em outro mdulo::"
#: ../../tutorial/classes.rst:591
msgid ""
"Execution of a derived class definition proceeds the same as for a base "
"class. When the class object is constructed, the base class is remembered. "
"This is used for resolving attribute references: if a requested attribute is "
"not found in the class, the search proceeds to look in the base class. This "
"rule is applied recursively if the base class itself is derived from some "
"other class."
msgstr ""
"A execuo de uma definio de classe derivada procede da mesma forma que a "
"de uma classe base. Quando o objeto classe construdo, a classe base "
"lembrada. Isso utilizado para resolver referncias a atributos. Se um "
"atributo requisitado no for encontrado na classe, ele procurado na classe "
"base. Essa regra aplicada recursivamente se a classe base por sua vez for "
"derivada de outra."
#: ../../tutorial/classes.rst:597
msgid ""
"There's nothing special about instantiation of derived classes: "
"``DerivedClassName()`` creates a new instance of the class. Method "
"references are resolved as follows: the corresponding class attribute is "
"searched, descending down the chain of base classes if necessary, and the "
"method reference is valid if this yields a function object."
msgstr ""
"No h nada de especial sobre instanciao de classes derivadas: "
"``NomeClasseDerivada()`` cria uma nova instncia da classe. Referncias a "
"mtodos so resolvidas da seguinte forma: o atributo correspondente "
"procurado atravs da cadeia de classes base, e referncias a mtodos so "
"vlidas se essa procura produzir um objeto funo."
#: ../../tutorial/classes.rst:603
msgid ""
"Derived classes may override methods of their base classes. Because methods "
"have no special privileges when calling other methods of the same object, a "
"method of a base class that calls another method defined in the same base "
"class may end up calling a method of a derived class that overrides it. "
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
msgstr ""
"Classes derivadas podem sobrescrever mtodos das suas classes base. Uma vez "
"que mtodos no possuem privilgios especiais quando invocam outros mtodos "
"no mesmo objeto, um mtodo na classe base que invoca um outro mtodo da "
"mesma classe base pode, efetivamente, acabar invocando um mtodo sobreposto "
"por uma classe derivada. (Para programadores C++ isso significa que todos os "
"mtodos em Python so realmente ``virtuais``.)"
#: ../../tutorial/classes.rst:609
msgid ""
"An overriding method in a derived class may in fact want to extend rather "
"than simply replace the base class method of the same name. There is a "
"simple way to call the base class method directly: just call ``BaseClassName."
"methodname(self, arguments)``. This is occasionally useful to clients as "
"well. (Note that this only works if the base class is accessible as "
"``BaseClassName`` in the global scope.)"
msgstr ""
"Um mtodo sobrescrito em uma classe derivada, de fato, pode querer estender, "
"em vez de simplesmente substituir, o mtodo da classe base, de mesmo nome. "
"Existe uma maneira simples de chamar diretamente o mtodo da classe base: "
"apenas chame ``BaseClassName.methodname(self, arguments)``. Isso "
"geralmente til para os clientes tambm. (Note que isto s funciona se a "
"classe base estiver acessvel como ``BaseClassName`` no escopo global)."
#: ../../tutorial/classes.rst:616
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python tem duas funes embutidas que trabalham com herana:"
#: ../../tutorial/classes.rst:618
msgid ""
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
"derived from :class:`int`."
msgstr ""
"Use :func:`isinstance` para verificar o tipo de uma instncia: "
"``isinstance(obj, int)`` ser ``True`` somente se ``obj.__class__`` a "
"classe :class:`int` ou alguma classe derivada de :class:`int`."
#: ../../tutorial/classes.rst:622
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`. However, "
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
"subclass of :class:`int`."
msgstr ""
"Use :func:`issubclass` para verificar herana entre classes: "
"``issubclass(bool, int)`` ``True`` porque :class:`bool` uma subclasse "
"de :class:`int`. Porm, ``issubclass(float, int)`` ``False`` porque :class:"
"`float` no uma subclasse de :class:`int`."
#: ../../tutorial/classes.rst:632
msgid "Multiple Inheritance"
msgstr "Herana mltipla"
#: ../../tutorial/classes.rst:634
msgid ""
"Python supports a form of multiple inheritance as well. A class definition "
"with multiple base classes looks like this::"
msgstr ""
"Python tambm suporta uma forma de herana mltipla. Uma definio de classe "
"com vrias classes bases tem esta forma::"
#: ../../tutorial/classes.rst:644
msgid ""
"For most purposes, in the simplest cases, you can think of the search for "
"attributes inherited from a parent class as depth-first, left-to-right, not "
"searching twice in the same class where there is an overlap in the "
"hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, "
"it is searched for in :class:`Base1`, then (recursively) in the base classes "
"of :class:`Base1`, and if it was not found there, it was searched for in :"
"class:`Base2`, and so on."
msgstr ""
"Para a maioria dos casos mais simples, pense na pesquisa de atributos "
"herdados de uma classe pai como o primeiro nvel de profundidade, da "
"esquerda para a direita, no pesquisando duas vezes na mesma classe em que "
"h uma sobreposio na hierarquia. Assim, se um atributo no encontrado "
"em :class:`DerivedClassName`, procurado em :class:`Base1`, depois, "
"recursivamente, nas classes base de :class:`Base1`, e se no for encontrado "
"l, pesquisado em :class:`Base2` e assim por diante."
#: ../../tutorial/classes.rst:651
msgid ""
"In fact, it is slightly more complex than that; the method resolution order "
"changes dynamically to support cooperative calls to :func:`super`. This "
"approach is known in some other multiple-inheritance languages as call-next-"
"method and is more powerful than the super call found in single-inheritance "
"languages."
msgstr ""
"De fato, um pouco mais complexo que isso; a ordem de resoluo de mtodos "
"muda dinamicamente para suportar chamadas cooperativas para :func:`super`. "
"Essa abordagem conhecida em outras linguagens de herana mltipla como "
"chamar-o-prximo-mtodo, e mais poderosa que a chamada funo super, "
"encontrada em linguagens de herana nica."
#: ../../tutorial/classes.rst:657
msgid ""
"Dynamic ordering is necessary because all cases of multiple inheritance "
"exhibit one or more diamond relationships (where at least one of the parent "
"classes can be accessed through multiple paths from the bottommost class). "
"For example, all classes inherit from :class:`object`, so any case of "
"multiple inheritance provides more than one path to reach :class:`object`. "
"To keep the base classes from being accessed more than once, the dynamic "
"algorithm linearizes the search order in a way that preserves the left-to-"
"right ordering specified in each class, that calls each parent only once, "
"and that is monotonic (meaning that a class can be subclassed without "
"affecting the precedence order of its parents). Taken together, these "
"properties make it possible to design reliable and extensible classes with "
"multiple inheritance. For more detail, see https://www.python.org/download/"
"releases/2.3/mro/."
msgstr ""
"A ordenao dinmica necessria porque todos os casos de herana mltipla "
"exibem um ou mais relacionamentos de diamante (em que pelo menos uma das "
"classes pai pode ser acessada por meio de vrios caminhos da classe mais "
"inferior). Por exemplo, todas as classes herdam de :class:`object`, "
"portanto, qualquer caso de herana mltipla fornece mais de um caminho para "
"alcanar :class:`object`. Para evitar que as classes base sejam acessadas "
"mais de uma vez, o algoritmo dinmico lineariza a ordem de pesquisa, de "
"forma a preservar a ordenao da esquerda para a direita, especificada em "
"cada classe, que chama cada pai apenas uma vez, e que monotnica "
"(significando que uma classe pode ser subclassificada sem afetar a ordem de "
"precedncia de seus pais). Juntas, essas propriedades tornam possvel "
"projetar classes confiveis e extensveis com herana mltipla. Para mais "
"detalhes, veja https://www.python.org/download/releases/2.3/mro/."
#: ../../tutorial/classes.rst:674
msgid "Private Variables"
msgstr "Variveis privadas"
#: ../../tutorial/classes.rst:676
msgid ""
"\"Private\" instance variables that cannot be accessed except from inside an "
"object don't exist in Python. However, there is a convention that is "
"followed by most Python code: a name prefixed with an underscore (e.g. "
"``_spam``) should be treated as a non-public part of the API (whether it is "
"a function, a method or a data member). It should be considered an "
"implementation detail and subject to change without notice."
msgstr ""
"Variveis de instncia \"privadas\", que no podem ser acessadas, exceto em "
"mtodos do prprio objeto, no existem em Python. No entanto, existe uma "
"conveno que seguida pela maioria dos programas em Python: um nome "
"prefixado com um sublinhado (por exemplo: ``_spam`` ) deve ser tratado como "
"uma parte no-pblica da API (seja uma funo, um mtodo ou um atributo de "
"dados). Tais nomes devem ser considerados um detalhe de implementao e "
"sujeito a alterao sem aviso prvio."
#: ../../tutorial/classes.rst:686
msgid ""
"Since there is a valid use-case for class-private members (namely to avoid "
"name clashes of names with names defined by subclasses), there is limited "
"support for such a mechanism, called :dfn:`name mangling`. Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with leading underscore(s) "
"stripped. This mangling is done without regard to the syntactic position of "
"the identifier, as long as it occurs within the definition of a class."
msgstr ""
"Uma vez que existe um caso de uso vlido para a definio de atributos "
"privados em classes (especificamente para evitar conflitos com nomes "
"definidos em subclasses), existe um suporte limitado a identificadores "
"privados em classes, chamado :dfn:`desfigurao de nomes`. Qualquer "
"identificador no formato ``__spam`` (pelo menos dois sublinhados no incio, "
"e no mximo um sublinhado no final) textualmente substitudo por "
"``_classname__spam``, onde ``classname`` o nome da classe atual com "
"sublinhado(s) iniciais omitidos. Essa desfigurao independe da posio "
"sinttica do identificador, desde que ele aparea dentro da definio de uma "
"classe."
#: ../../tutorial/classes.rst:695
msgid ""
"Name mangling is helpful for letting subclasses override methods without "
"breaking intraclass method calls. For example::"
msgstr ""
"A desfigurao de nomes til para que subclasses possam sobrescrever "
"mtodos sem quebrar invocaes de mtodos dentro de outra classe. Por "
"exemplo::"
#: ../../tutorial/classes.rst:717
msgid ""
"The above example would work even if ``MappingSubclass`` were to introduce a "
"``__update`` identifier since it is replaced with ``_Mapping__update`` in "
"the ``Mapping`` class and ``_MappingSubclass__update`` in the "
"``MappingSubclass`` class respectively."
msgstr ""
"O exemplo acima deve funcionar mesmo se ``SubclasseMapeamento`` introduzisse "
"um identificador ``__atualizar`` uma vez que substitudo por "
"``_Mapeamento__atualizar`` na classe ``Mapeamento`` e "
"``_SubclasseMapeamento__atualizar`` na classe ``SubclasseMapeamento``, "
"respectivamente."
#: ../../tutorial/classes.rst:722
msgid ""
"Note that the mangling rules are designed mostly to avoid accidents; it "
"still is possible to access or modify a variable that is considered "
"private. This can even be useful in special circumstances, such as in the "
"debugger."
msgstr ""
"Note que as regras de desfigurao de nomes foram projetadas para evitar "
"acidentes; ainda possvel acessar ou modificar uma varivel que "
"considerada privada. Isso pode ser til em certas circunstncias especiais, "
"como depurao de cdigo."
#: ../../tutorial/classes.rst:726
msgid ""
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
"classname of the invoking class to be the current class; this is similar to "
"the effect of the ``global`` statement, the effect of which is likewise "
"restricted to code that is byte-compiled together. The same restriction "
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
"referencing ``__dict__`` directly."
msgstr ""
"Cdigo passado para ``exec()`` ou ``eval()`` no considera o nome da classe "
"que invocou como sendo a classe corrente; isso semelhante ao funcionamento "
"da instruo ``global``, cujo efeito se aplica somente ao cdigo que "
"compilado junto. A mesma restrio se aplica s funes ``getattr()``, "
"``setattr()`` e ``delattr()``, e quando acessamos diretamente o ``__dict__`` "
"da classe."
#: ../../tutorial/classes.rst:737
msgid "Odds and Ends"
msgstr "Curiosidades e concluses"
#: ../../tutorial/classes.rst:739
msgid ""
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
"or C \"struct\", bundling together a few named data items. The idiomatic "
"approach is to use :mod:`dataclasses` for this purpose::"
msgstr ""
"s vezes, til ter um tipo semelhante ao \"record\" de Pascal ou ao "
"\"struct\" de C, para agrupar alguns itens de dados. A maneira pythnica "
"para este fim usar :mod:`dataclasses`::"
#: ../../tutorial/classes.rst:759
msgid ""
"A piece of Python code that expects a particular abstract data type can "
"often be passed a class that emulates the methods of that data type "
"instead. For instance, if you have a function that formats some data from a "
"file object, you can define a class with methods :meth:`read` and :meth:`!"
"readline` that get the data from a string buffer instead, and pass it as an "
"argument."
msgstr ""
"Um trecho de cdigo Python que espera um tipo de dado abstrato em "
"particular, pode receber, ao invs disso, uma classe que imita os mtodos "
"que aquele tipo suporta. Por exemplo, se voc tem uma funo que formata "
"dados obtidos de um objeto do tipo \"arquivo\", pode definir uma classe com "
"mtodos :meth:`read` e :meth:`!readline` que obtm os dados de um \"buffer "
"de caracteres\" e passar como argumento."
#: ../../tutorial/classes.rst:770
msgid ""
"Instance method objects have attributes, too: ``m.__self__`` is the instance "
"object with the method :meth:`m`, and ``m.__func__`` is the function object "
"corresponding to the method."
msgstr ""
"Mtodos de instncia tem atributos tambm: ``m.__self__`` o objeto "
"instncia com o mtodo :meth:`m`, e ``m.__func__`` o objeto funo "
"correspondente ao mtodo."
#: ../../tutorial/classes.rst:778
msgid "Iterators"
msgstr "Iteradores"
#: ../../tutorial/classes.rst:780
msgid ""
"By now you have probably noticed that most container objects can be looped "
"over using a :keyword:`for` statement::"
msgstr ""
"Voc j deve ter notado que pode usar laos :keyword:`for` com a maioria das "
"colees em Python::"
#: ../../tutorial/classes.rst:794
msgid ""
"This style of access is clear, concise, and convenient. The use of "
"iterators pervades and unifies Python. Behind the scenes, the :keyword:"
"`for` statement calls :func:`iter` on the container object. The function "
"returns an iterator object that defines the method :meth:`~iterator."
"__next__` which accesses elements in the container one at a time. When "
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
"`StopIteration` exception which tells the :keyword:`!for` loop to "
"terminate. You can call the :meth:`~iterator.__next__` method using the :"
"func:`next` built-in function; this example shows how it all works::"
msgstr ""
"Esse estilo de acesso claro, conciso e conveniente. O uso de iteradores "
"permeia e unifica o Python. Nos bastidores, a instruo :keyword:`for` "
"chama :func:`iter` no objeto continer. A funo retorna um objeto iterador "
"que define o mtodo :meth:`~iterator.__next__` que acessa elementos no "
"continer, um de cada vez. Quando no h mais elementos, :meth:`~iterator."
"__next__` levanta uma exceo :exc:`StopIteration` que informa ao :keyword:`!"
"for` para terminar. Voc pode chamar o mtodo :meth:`~iterator.__next__` "
"usando a funo embutida :func:`next`; este exemplo mostra como tudo "
"funciona::"
#: ../../tutorial/classes.rst:819
msgid ""
"Having seen the mechanics behind the iterator protocol, it is easy to add "
"iterator behavior to your classes. Define an :meth:`__iter__` method which "
"returns an object with a :meth:`~iterator.__next__` method. If the class "
"defines :meth:`__next__`, then :meth:`__iter__` can just return ``self``::"
msgstr ""
"Observando o mecanismo por trs do protocolo dos iteradores, fica fcil "
"adicionar esse comportamento s suas classes. Defina um mtodo :meth:"
"`__iter__` que retorna um objeto que tenha um mtodo :meth:`~iterator."
"__next__`. Se uma classe j define :meth:`__next__`, ento :meth:`__iter__` "
"pode simplesmente retornar ``self``::"
#: ../../tutorial/classes.rst:856
msgid "Generators"
msgstr "Geradores"
#: ../../tutorial/classes.rst:858
msgid ""
":term:`Generators ` are a simple and powerful tool for creating "
"iterators. They are written like regular functions but use the :keyword:"
"`yield` statement whenever they want to return data. Each time :func:`next` "
"is called on it, the generator resumes where it left off (it remembers all "
"the data values and which statement was last executed). An example shows "
"that generators can be trivially easy to create::"
msgstr ""
":term:`Geradores ` so uma ferramenta simples e poderosa para "
"criar iteradores. So escritos como funes normais mas usam a instruo :"
"keyword:`yield` quando precisam retornar dados. Cada vez que :func:`next` "
"chamado, o gerador volta ao ponto onde parou (lembrando todos os valores de "
"dados e qual instruo foi executada pela ltima vez). Um exemplo mostra "
"como geradores podem ser trivialmente fceis de criar::"
#: ../../tutorial/classes.rst:879
msgid ""
"Anything that can be done with generators can also be done with class-based "
"iterators as described in the previous section. What makes generators so "
"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods "
"are created automatically."
msgstr ""
"Qualquer coisa que possa ser feita com geradores tambm pode ser feita com "
"iteradores baseados numa classe, como descrito na seo anterior. O que "
"torna geradores to compactos que os mtodos :meth:`__iter__` e :meth:"
"`~generator.__next__` so criados automaticamente."
#: ../../tutorial/classes.rst:884
msgid ""
"Another key feature is that the local variables and execution state are "
"automatically saved between calls. This made the function easier to write "
"and much more clear than an approach using instance variables like ``self."
"index`` and ``self.data``."
msgstr ""
"Outro ponto chave que as variveis locais e o estado da execuo so "
"preservados automaticamente entre as chamadas. Isto torna a funo mais "
"fcil de escrever e muito mais clara do que uma implementao usando "
"variveis de instncia como ``self.index`` e ``self.data``."
#: ../../tutorial/classes.rst:889
msgid ""
"In addition to automatic method creation and saving program state, when "
"generators terminate, they automatically raise :exc:`StopIteration`. In "
"combination, these features make it easy to create iterators with no more "
"effort than writing a regular function."
msgstr ""
"Alm disso, quando geradores terminam, eles levantam :exc:`StopIteration` "
"automaticamente. Combinados, todos estes aspectos tornam a criao de "
"iteradores to fcil quanto escrever uma funo normal."
#: ../../tutorial/classes.rst:898
msgid "Generator Expressions"
msgstr "Expresses geradoras"
#: ../../tutorial/classes.rst:900
msgid ""
"Some simple generators can be coded succinctly as expressions using a syntax "
"similar to list comprehensions but with parentheses instead of square "
"brackets. These expressions are designed for situations where the generator "
"is used right away by an enclosing function. Generator expressions are more "
"compact but less versatile than full generator definitions and tend to be "
"more memory friendly than equivalent list comprehensions."
msgstr ""
"Alguns geradores simples podem ser codificados, de forma sucinta, como "
"expresses, usando uma sintaxe semelhante a compreenses de lista, mas com "
"parnteses em vez de colchetes. Essas expresses so projetadas para "
"situaes em que o gerador usado imediatamente, pela funo que o engloba. "
"As expresses geradoras so mais compactas, mas menos versteis do que as "
"definies completas do gerador, e tendem a usar menos memria do que as "
"compreenses de lista equivalentes."
#: ../../tutorial/classes.rst:907
msgid "Examples::"
msgstr "Exemplos::"
#: ../../tutorial/classes.rst:928
msgid "Footnotes"
msgstr "Notas de rodap"
#: ../../tutorial/classes.rst:929
msgid ""
"Except for one thing. Module objects have a secret read-only attribute "
"called :attr:`~object.__dict__` which returns the dictionary used to "
"implement the module's namespace; the name :attr:`~object.__dict__` is an "
"attribute but not a global name. Obviously, using this violates the "
"abstraction of namespace implementation, and should be restricted to things "
"like post-mortem debuggers."
msgstr ""
"Exceto por uma coisa. Os objetos mdulo tm um atributo secreto e somente "
"para leitura chamado :attr:`~object.__dict__` que retorna o dicionrio usado "
"para implementar o espao de nomes do mdulo; o nome :attr:`~object."
"__dict__` um atributo, mas no um nome global. Obviamente, usar isso viola "
"a abstrao da implementao do espao de nomes, e deve ser restrito a "
"coisas como depuradores post-mortem."