classes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2017
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:46+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: Hildeberto Abreu Magalhães <hildeberto@gmail.com>\n"
"Language-Team: Portuguese (Brazil) (http://www.transifex.com/python-doc/python-27/language/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=2; plural=(n > 1);\n"

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

#: ../../tutorial/classes.rst:7
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, 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 a 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:17
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, 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. Um 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 invocação. 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 de usuário por herança. Como em C++, mas "
"diferentemente de Modula-3, a maioria dos operadores (aritméticos, "
"indexação,etc) podem ser redefinidos para instâncias de classe."

#: ../../tutorial/classes.rst:28
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 é mais próxima a de Python, "
"mas creio que poucos leitores já ouviram falar dessa linguagem.)"

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

#: ../../tutorial/classes.rst:39
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 (inclusive em diferentes escopos) podem estar vinculados a um mesmo objeto. Isso é chamado de *aliasing* em outras linguagens. (N.d.T. *aliasing* é, literalmente, \"apelidamento\": um mesmo objeto pode ter vários apelidos.) À primeira vista, esta característica não é muito apreciada, e pode ser seguramente ignorada ao lidar com tipos imutáveis (números, strings, tuplas). Entretanto, aliasing pode ter um efeito inesperado sobre a semântica de 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 *aliases* (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.  \n"
"\n"
"N.d.T. Na terminologia de C++ e Java, o que o parágrafo acima denomina\n"
"\"apelidos\" são identificadores de referências (variáveis de referência), e os\n"
"ponteiros são as próprias referências. Se uma variável ``a`` está associada a\n"
"um objeto qualquer, informalmente dizemos que a variável \"contém\" o objeto,\n"
"mas na realidade o objeto existe independente da variável, e o conteúdo da\n"
"variável é apenas uma referência (um ponteiro) para o objeto. O *aliasing*\n"
"ocorre quando existem diversas variáveis, digamos ``a``, ``b`` e ``c``,\n"
"apontando para o mesmo objeto."

#: ../../tutorial/classes.rst:55
msgid "Python Scopes and Namespaces"
msgstr "Escopos e Namespaces"

#: ../../tutorial/classes.rst:57
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 *namespaces* (espaços de "
"nomes). Portanto, primeiro é preciso entender claramente como escopos e "
"*namespaces* funcionam. Esse conhecimento é muito útil para o programador "
"avançado em Python."

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

#: ../../tutorial/classes.rst:65
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 *namespace* (ou 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 embutidas); nomes globais em um módulo; e nomes\n"
"locais na invocação de uma função. De uma 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 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:76
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 ``nomemod.nomefunc``, ``nomemod`` é um objeto módulo"
" e ``nomefunc`` é 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:84
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 para leitura ou para leitura e escrita. No "
"segundo caso, é possível atribuir um novo valor ao atributo. (N.d.T. Também "
"é possível criar novos atributos.) Atributos de módulos são passíveis de "
"atribuição: você pode escrever ``nomemod.a_reposta = 42``. Atributos que "
"aceitam escrita também podem ser apagados através do comando :keyword:`del`."
" Por exemplo, ``del nomemod.a_reposta`` remove o atributo :attr:`a_resposta`"
" do objeto referenciado por ``nomemod``."

#: ../../tutorial/classes.rst:90
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:`__builtin__`.)"
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\n"
"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:`__builtin__`.)."

#: ../../tutorial/classes.rst:100
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:106
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* (*scope*) é 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:110
msgid ""
"Although scopes are determined statically, they are used dynamically. At any"
" time during execution, there are at least three 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 no mínimo três"
" escopos diretamente acessíveis:"

#: ../../tutorial/classes.rst:114
msgid "the innermost scope, which is searched first, contains the local names"
msgstr ""
"* o escopo mais interno (que é acessado primeiro) contendo nomes locais;"

#: ../../tutorial/classes.rst:115
msgid ""
"the scopes of any enclosing functions, which are searched starting with the "
"nearest enclosing scope, contains 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 mias próximo, contém nomes não-locais mas também não-"
"globais;"

#: ../../tutorial/classes.rst:117
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:118
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:120
msgid ""
"If a name is declared global, then all references and assignments go "
"directly to the middle scope containing the module's global names. "
"Otherwise, all variables found outside of the innermost scope 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 valores vão diretamente para o escopo intermediário que contém "
"os nomes globais do módulo. Caso contrário, todas as variáveis encontradas "
"fora do escopo mais interno são apenas para leitura (a tentativa de atribuir"
" valores a essas variáveis irá 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:126
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:131
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\" (N.d.T. quando um "
"módulo é carregado ele é compilado em memória), 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:139
msgid ""
"A special quirk of Python is that -- if no :keyword:`global` 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.  (The :keyword:`global` statement can be "
"used to indicate that particular variables live in the global scope.)"
msgstr ""
"Uma peculiaridade de Python é que atribuições ocorrem sempre no escopo mais "
"interno, exceto quando o comando :keyword:`global` é usado. Atribuições não "
"copiam dados, apenas associam nomes a objetos. O mesmo vale para remoções: o"
" comando ``del x`` remove o vínculo de ``x`` do espaço de nomes do 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 "
"associam o nome módulo ou da função ao escopo local. (A palavra reservada "
":keyword:`global` pode ser usada para indicar que certas variáveis residem "
"no escopo global ao invés do local.)"

#: ../../tutorial/classes.rst:153
msgid "A First Look at Classes"
msgstr "Primeiro contato com classes"

#: ../../tutorial/classes.rst:155
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:162
msgid "Class Definition Syntax"
msgstr "Sintaxe de definição de classe"

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

#: ../../tutorial/classes.rst:173
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 classes, assim como definições de funções (instruções "
":keyword:`def`), precisam ser executados antes que tenham qualquer efeito. "
"(Por exemplo, você pode colocar uma definição de classe dentro de teste "
"condicional :keyword:`if` ou dentro de uma função.)"

#: ../../tutorial/classes.rst:177
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 declarações dentro da definição de classe geralmente serão "
"definições de função, mas outras declarações são permitidas e, por vezes, "
"úteis --- falaremos sobre isso mais tarde. As definições de função dentro de"
" uma classe normalmente têm uma forma peculiar de lista de argumentos, "
"ditada pelas convenções de chamada para métodos --- novamente, isso abordado"
" mais tarde."

#: ../../tutorial/classes.rst:183
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 namespace é criado, e usado "
"como escopo local --- assim, todas atribuições a variáveis locais ocorrem "
"nesse namespace. Em particular, funções definidas aqui são vinculadas a "
"nomes nesse escopo."

#: ../../tutorial/classes.rst:188
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 o processamento de uma definição de classe é completado (normalmente,"
" sem erros), 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 (no exemplo acima, "
":class:`NomeDaClasse` é o identificador da classe)."

#: ../../tutorial/classes.rst:200
msgid "Class Objects"
msgstr "Objetos de Classe"

#: ../../tutorial/classes.rst:202
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:205
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``. Atributos "
"válidos são todos os nomes presentes dentro do namespace da classe quando o "
"objeto classe foi criado. Portanto, se a definição da classe foi assim::"

#: ../../tutorial/classes.rst:217
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 ""
"então ``MinhaClasse.i`` e ``MinhaClasse.f`` são referências válidas, que "
"acessam, respectivamente, um inteiro e um objeto função. É possível mudar os"
" valores dos atributos da classe, ou mesmo criar novos atributos, fazendo "
"uma atribuição simples assim: ``MinhaClasse.i = 10``. O nome ``__doc__`` "
"identifica outro atributo válido da classe, referenciando a *docstring* "
"associada à ela: ``\"Um exemplo simples de classe\"``."

#: ../../tutorial/classes.rst:223
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 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 (continuando o exemplo "
"acima)::"

#: ../../tutorial/classes.rst:229
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:232
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 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:`__init__`, assim::"

#: ../../tutorial/classes.rst:240
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 método :meth:`__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:246
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 método :meth:`__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:263
msgid "Instance Objects"
msgstr "Objetos de Instância"

#: ../../tutorial/classes.rst:265
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 instâncias? As únicas operações reconhecidas "
"por instâncias são referências a atributos. Existem dois tipos de nomes de "
"atributos válidos: atributos de dados (*data attributes*) e métodos."

#: ../../tutorial/classes.rst:269
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 \"data members\" 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 na instância (por causa do uso de "
":keyword:`del`)::"

#: ../../tutorial/classes.rst:281
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 referências a atributos são métodos. Um método é uma função "
"que \"pertence\" a uma instância. (Em Python, o termo método não é aplicado "
"exclusivamente a instâncias de classes definidas pelo usuário: outros tipos "
"de objetos também podem ter métodos. Por exemplo, listas possuem os métodos "
"append, insert, remove, sort, etc. Porém, na discussão a seguir usaremos o "
"termo método apenas para se referir a métodos de classes definidas pelo "
"usuário. Seremos explícitos ao falar de outros métodos.)"

#: ../../tutorial/classes.rst:290
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 (*method "
"object*), e a ``MinhaClasse.f`` acessa um objeto função."

#: ../../tutorial/classes.rst:301
msgid "Method Objects"
msgstr "Objetos Métodos"

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

#: ../../tutorial/classes.rst:307
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:`MinhaClasse` 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 (um objeto método), ele pode "
"atribuído a uma variável invocado depois. Por exemplo:"

#: ../../tutorial/classes.rst:315
msgid "will continue to print ``hello world`` until the end of time."
msgstr "esse código exibirá o texto ``'olá, mundo'`` até o mundo acabar."

#: ../../tutorial/classes.rst:317
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 parâmetro, porém a definição da função "
":meth:`f` especificava um parâmetro. O que aconteceu com esse parâmetro? "
"Certamente Python levanta uma exceção quando uma função que declara um "
"parâmetro é invocada sem nenhum argumento --- mesmo que o argumento não seja"
" usado no corpo da função..."

#: ../../tutorial/classes.rst:323
msgid ""
"Actually, you may have guessed the answer: the special thing about methods "
"is that the 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 object before the first argument."
msgstr ""
"Talvez você já tenha adivinhado a resposta: o que os métodos têm de especial"
" é que eles passam o objeto (ao qual o método está vinculado) como primeiro "
"argumento da função definida na classe. No nosso exemplo, a chamada "
"``x.f()`` equivale exatamente ``MinhaClasse.f(x)``. Em geral, chamar um "
"método com uma lista de *n* argumentos é equivalente a chamar a função na "
"classe correspondente passando a instância como o primeiro argumento antes "
"dos demais *n* argumentos."

#: ../../tutorial/classes.rst:330
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 não entende como os métodos funcionam, dê uma olhada na "
"implementação para  esclarecer as coisas. 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,  e é o nome de uma "
"função, um método é criado, empacotando a instância e a função, que estão "
"juntos num objeto abstrato: este é o método. Quando o método é chamado com "
"uma lista de argumentos, uma nova lista de argumentos é construída a partir "
"da instância e da lista de argumentos, e a função é chamada com essa nova "
"lista de argumentos."

#: ../../tutorial/classes.rst:344
msgid "Class and Instance Variables"
msgstr "Variáveis de Classe e Instância"

#: ../../tutorial/classes.rst:346
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 as variáveis que indicam dados "
"que são únicos a cada instância, em nível individual, e variáveis de classe "
"são as variáveis de atributos e de métodos que são comuns a todas as "
"instâncias de uma determinada classe::"

#: ../../tutorial/classes.rst:368
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 ""
"Conforme discutido em :ref:`tut-object`, o compartilhamento de dados pode "
"implicar em efeitos inesperados quando envolve objetos mutáveis (em inglês: "
":term:`mutable` objects), tais como as listas ou dicionários. Por exemplo, a"
" lista *tricks* no código a seguir não deveria ser usada como uma variável "
"de classe, pois assim apenas uma única lista seria comum a toda e qualquer "
"instância de *Dog*::"

#: ../../tutorial/classes.rst:391
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"O design correto da classe deve usar uma variável de instância em ao invés "
"disso aqui::"

#: ../../tutorial/classes.rst:415
msgid "Random Remarks"
msgstr "Observações Aleatórias"

#: ../../tutorial/classes.rst:419
msgid ""
"Data attributes override method attributes with the same name; to avoid "
"accidental name conflicts, which may cause hard-to-find bugs in large "
"programs, it is wise to use some kind of convention that minimizes the "
"chance of conflicts.  Possible conventions include capitalizing method "
"names, prefixing data attribute names with a small unique string (perhaps "
"just an underscore), or using verbs for methods and nouns for data "
"attributes."
msgstr ""
"Atributos de dados sobrescrevem atributos métodos homônimos. Para evitar "
"conflitos de nome acidentais, que podem gerar bugs de difícil rastreio em "
"programas extensos, é sábio adotar algum tipo de convenção que minimize a "
"chance de conflitos. Convenções comuns incluem: definir nomes de métodos com"
" inicial maiúscula, prefixar atributos de dados com uma string única (quem "
"sabe \"_\" [*underscore* ou sublinhado]), ou usar sempre verbos para nomear "
"métodos e substantivos para atributos de dados. "

#: ../../tutorial/classes.rst:426
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 métodos da própria instância,"
" bem como por qualquer outro usuário do objeto (também chamados \"clientes\""
" do objeto). Em outras palavras, classes não servem para implementar tipos "
"puramente abstratos de dados. De fato, nada em Python torna possível "
"assegurar o encapsulamento de dados --- tudo é convenção. (Por outro lado, a"
" implementação de Python, escrita em C, pode esconder completamente detalhes"
" de um objeto ou controlar seu acesso, se necessário; isto pode ser "
"utilizado por extensões de Python escritas em C.)"

#: ../../tutorial/classes.rst:434
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 bagunçar "
"invariantes assumidas pelos métodos ao esbarrar em seus atributos de dados. "
"Note que clientes podem adicionar à vontade atributos de dados a uma "
"instância sem afetar a validade dos métodos, desde que seja evitado o "
"conflito de nomes. Novamente, uma convenção de nomenclatura poupa muita dor "
"de cabeça."

#: ../../tutorial/classes.rst:440
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 ""
"Não existe atalho para referenciar atributos de dados (ou outros métodos!) "
"de dentro de um método: sempre é preciso fazer referência explícita ao "
"``self.`` para acessar qualquer atributo da instância. Em minha opinião isso"
" aumenta a legibilidade dos métodos: não há como confundir uma variável "
"local com um atributo da instância quando lemos rapidamente um método "
"desconhecido."

#: ../../tutorial/classes.rst:445
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 método é chamado ``self``. Isso não\n"
"passa de uma convenção: o identificador ``self`` não é uma palavra reservada\n"
"nem possui qualquer significado especial em Python. Mas note que, ao seguir\n"
"essa convenção, seu código se torna legível por uma grande comunidade de\n"
"desenvolvedores Python e é possível que alguma *IDE* dependa dessa convenção\n"
"para analisar seu código."

#: ../../tutorial/classes.rst:451
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 função que é atributo de uma classe, define um método para "
"as instâncias desta classe. Não é necessário que a definição da função "
"esteja textualmente embutida na definição da classe. Atribuir um objeto "
"função a uma variável local da classe é válido. Por exemplo::"

#: ../../tutorial/classes.rst:468
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`` são todos atributos da classe :class:`C` que "
"referenciam funções, e consequentemente são todos métodos de instâncias da "
"classe :class:`C`, onde ``h`` é equivalente a ``g``. No entanto, essa "
"prática serve apenas para confundir o leitor do programa."

#: ../../tutorial/classes.rst:473
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Métodos podem chamar outros métodos como atributos do argumento ``self``::"

#: ../../tutorial/classes.rst:487
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 ""
"Métodos podem referenciar nomes globais da mesma forma que funções comuns. O"
" escopo global associado a um método é o módulo contendo sua a definição de "
"sua classe (a classe propriamente dita nunca é usada como escopo global!). "
"Ainda que seja raro justificar o uso de dados globais em um método, há "
"diversos usos legítimos do escopo global. Por exemplo, funções e módulos "
"importados no escopo global podem ser usados por métodos, bem como as "
"funções e classes definidas no próprio escopo global. Provavelmente, a "
"classe contendo o método em questão também foi definida neste escopo global."
" Na próxima seção veremos razões pelas quais um método pode querer "
"referenciar sua própria classe."

#: ../../tutorial/classes.rst:497
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Todo valor em Python é um objeto, e portanto tem uma *classe* (também "
"conhecida como seu tipo, ou *type*). A classe de um objeto pode ser "
"referenciada como ``objeto.__class__``."

#: ../../tutorial/classes.rst:504
msgid "Inheritance"
msgstr "Herança"

#: ../../tutorial/classes.rst:506
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 característica não seria digna do nome \"classe\" se não "
"suportasse herança. A sintaxe para uma classe derivada é assim::"

#: ../../tutorial/classes.rst:517
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:`NomeClasseBase` deve estar definido no escopo que "
"contém a definição da classe derivada. No lugar do nome da classe base, "
"também são aceitas outras expressões. Isso é muito útil, por exemplo, quando"
" a classe base é definida em outro módulo::"

#: ../../tutorial/classes.rst:524
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 execução de uma definição de classe derivada procede da mesma forma que a "
"de uma classe base. Quando o objeto classe é construído, a classe base é "
"lembrada. Isso é utilizado para resolver referências a atributos. Se um "
"atributo requisitado não 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:530
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 ""
"Não há nada de especial sobre instanciação de classes derivadas. "
"``NomeClasseDerivada()`` cria uma nova instância da classe. Referências a "
"métodos são resolvidas da seguinte forma: o atributo correspondente é "
"procurado através da cadeia de classes base, e referências a métodos são "
"válidas desde se essa procura produza um objeto função."

#: ../../tutorial/classes.rst:536
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 métodos das suas classes base. Uma vez "
"que métodos não possuem privilégios especiais quando invocam outros métodos "
"no mesmo objeto, um método na classe base que invocava um outro método da "
"mesma classe base, pode efetivamente acabar invocando um método sobreposto "
"por uma classe derivada. (Para programadores C++ isso significa que todos os"
" métodos em Python são realmente virtuais.)"

#: ../../tutorial/classes.rst:542
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 método sobrescrito em uma classe derivada, de fato, pode querer estender "
"em vez de simplesmente substituir o método da classe base, de mesmo nome. "
"Existe uma maneira simples de chamar diretamente o método da classe base: "
"apenas chame `` BaseClassName.methodname (self, arguments) ``. Isso é "
"geralmente útil para os clientes também. (Note que isto só funciona se a "
"classe base estiver acessível como `` BaseClassName`` no escopo global)."

#: ../../tutorial/classes.rst:549
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python tem duas funções embutidas que trabalham com herança:"

#: ../../tutorial/classes.rst:551
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 instância:\n"
" ``isinstance(obj, int)`` será ``True`` somente se ``obj.__class__`` é\n"
" a classe :class:`int` ou alguma classe derivada de :class:`int`."

#: ../../tutorial/classes.rst:555
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)``"
" is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(unicode, str)`` is ``False`` since :class:`unicode` is not a "
"subclass of :class:`str` (they only share a common ancestor, "
":class:`basestring`)."
msgstr ""

#: ../../tutorial/classes.rst:566
msgid "Multiple Inheritance"
msgstr "Herança Múltipla"

#: ../../tutorial/classes.rst:568
msgid ""
"Python supports a limited form of multiple inheritance as well.  A class "
"definition with multiple base classes looks like this::"
msgstr ""
"Python também suporta uma forma limitada de herança múltipla. Uma definição "
"de classe com várias classes base tem esta forma::"

#: ../../tutorial/classes.rst:578
msgid ""
"For old-style classes, the only rule is depth-first, left-to-right.  Thus, "
"if an attribute is not found in :class:`DerivedClassName`, it is searched in"
" :class:`Base1`, then (recursively) in the base classes of :class:`Base1`, "
"and only if it is not found there, it is searched in :class:`Base2`, and so "
"on."
msgstr ""

#: ../../tutorial/classes.rst:583
msgid ""
"(To some people breadth first --- searching :class:`Base2` and "
":class:`Base3` before the base classes of :class:`Base1` --- looks more "
"natural.  However, this would require you to know whether a particular "
"attribute of :class:`Base1` is actually defined in :class:`Base1` or in one "
"of its base classes before you can figure out the consequences of a name "
"conflict with an attribute of :class:`Base2`.  The depth-first rule makes no"
" differences between direct and inherited attributes of :class:`Base1`.)"
msgstr ""

#: ../../tutorial/classes.rst:591
msgid ""
"For :term:`new-style class`\\es, 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 ""

#: ../../tutorial/classes.rst:596
msgid ""
"With new-style classes, 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 new-style 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).  "