Commits

Luciano Ramalho committed 7354b92

correcoes nos caps. 9 e 11

  • Participants
  • Parent commits ce389bb

Comments (0)

Files changed (2)

File 2.7/Doc/tutorial/classes.rst

 redefinidos para instâncias de classe.
 
 (Na falta de uma terminologia universalmente aceita para falar sobre classes,
-ocasionalmente farei uso de termos comuns em Smalltalk ou C++ (eu usaria
+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.)
 
 Sintaxe de definição de classe
 ------------------------------
 
-A forma mais simples de definir uma classe é:::
+A forma mais simples de definir uma classe é::
 
    class NomeDaClasse:
        <instrução-1>
 ele apareça dentro da definição de uma classe.
 
 A desfiguração de nomes é útil para que subclasses possam sobrescrever métodos
-sem quebrar a invocações de métodos dentro de outra classe. Por exemplo::
+sem quebrar invocações de métodos dentro de outra classe. Por exemplo::
 
 
    class Mapping:
 normal, mas usa o comando :keyword:`yield` para produzir resultados. (N.d.T.
 Quando invocada, a função geradora produz um objeto gerador.) Cada vez que
 :meth:`next` é invocado, o gerador continua a partir de onde parou (ele mantem
-na memória seus dados internos e o último comando executado). Um exemplo
-mostra como geradores podem ser muito fáceis de criar::
+na memória seus dados internos e a próxima instrução a ser executada). Um
+exemplo mostra como geradores podem ser muito fáceis de criar::
 
 
    def inversor(data):
    implementação de namespaces, e é algo que só deve ser feito por ferramentas
    especiais, como depuradores "post-mortem".
 
-.. [#] N.d.T. Os termos :term:`new-style class <new-style class>` e "old-style
-   class" referem-se a duas implementações de classes que convivem desde o
-   Python 2.2. A implementação mais antiga, "old-style classes" foi preservada
-   até o Python 2.7 para manter a compatibilidade com bibliotecas e scripts
-   antigos, mas deixou de existir a partir do Python 3.0. As "new-style
-   classes" suportam o mecanismo de descritores, usado para implementar
-   propriedades (*properties*). Recomenda-se que todo código Python novo use
-   apenas "new-style classes".
+.. [#] N.d.T. Os termos :term:`new-style class <new-style class>` e
+   "old-style class" referem-se a duas implementações de classes que
+   convivem desde o Python 2.2. A implementação mais antiga, "old-style
+   classes" foi preservada até o Python 2.7 para manter a compatibilidade com
+   bibliotecas e scripts antigos, mas deixou de existir a partir do Python
+   3.0. As "new-style classes" suportam o mecanismo de descritores, usado para
+   implementar propriedades (*properties*). Recomenda-se que todo código
+   Python novo use apenas "new-style classes".
 
-  Desde o Python 2.2, a forma de declarar uma classe determina se ela usa a
-  implementação nova ou antiga. Qualquer classe derivada direta ou
-  indiretamente de :class:`object` é uma classe "new-style". Objetos classe
-  novos são do tipo ``type`` e objetos classe antigos são do tipo
-  ``classobj``. Veja este exemplo::
+   Desde o Python 2.2, a forma de declarar uma classe determina se ela usa a
+   implementação nova ou antiga. Qualquer classe derivada direta ou
+   indiretamente de :class:`object` é uma classe "new-style". Objetos classe
+   novos são do tipo ``type`` e objetos classe antigos são do tipo
+   ``classobj``. Veja este exemplo::
 
       >>> class Nova(object):
       ...     pass
       >>> type(Velha)
       <type 'classobj'>
 
-  Note que a definição acima é recursiva. Em particular, uma classe
-  que herda de uma classe antiga e de uma nova é uma classe "new-style",
-  pois através da classe nova ela é uma subclasse indireta de :class:`object`.
-  Não é uma boa prática misturar os dois estilos de classes, mas eis um
-  exemplo para ilustrar esse ponto::
+   Note que a definição acima é recursiva. Em particular, uma classe
+   que herda de uma classe antiga e de uma nova é uma classe "new-style",
+   pois através da classe nova ela é uma subclasse indireta de :class:`object`.
+   Não é uma boa prática misturar os dois estilos de classes, mas eis um
+   exemplo para ilustrar esse ponto::
 
       >>> class Mista(Velha, Nova):
       ...     pass
       >>> type(Mista)
       <type 'type'>
 
-  Para saber mais sobre as diferenças, veja `New Class vs Classic Class`_ no wiki
-  do python.org. ou artigo original de Guido van Rossum, `Unifying types and
-  classes in Python 2.2`_.
+   Para saber mais sobre as diferenças, veja `New Class vs Classic Class`_ no wiki
+   do python.org ou artigo original de Guido van Rossum, `Unifying types and
+   classes in Python 2.2`_.
 
 .. _New Class vs Classic Class: http://wiki.python.org/moin/NewClassVsClassicClass
 .. _Unifying types and classes in Python 2.2: http://www.python.org/download/releases/2.2.3/descrintro/

File 2.7/Doc/tutorial/stdlib2.rst

 .. _tut-brieftourtwo:
 
-***************************************************
-Um breve passeio pela biblioteca padrão -- Parte II
-***************************************************
+****************************************************
+Um breve passeio pela biblioteca padrão --- parte II
+****************************************************
 
-Este segundo passeio apresenta alguns módulos avançados que cobrem algumas
-necessidades de programação profissional. Esses módulos raramente aparecem
+Este segundo passeio apresenta alguns módulos avançados que atendem
+necessidades de programação profissional. Estes módulos raramente aparecem
 em scripts pequenos.
 
 
 permite que usuários personalizem suas aplicações sem a necessidade de alterar
 a aplicação.
 
-O formato usa um guarda-lugar (placeholder) formado por ``$`` seguido por um
+Em um template são colocadas marcações indicando o local onde o texto variável
+deve ser inserido. Uma marcação é formada por ``$`` seguido de um
 identificador Python válido (caracteres alfanuméricos e underscores).
-Envolvendo-se o guarda-lugar entre chaves, permite que ele seja seguido por
-mais caracteres alfanuméricos sem a necessidade de espaços. Escrevendo-se
-``$$`` cria-se um único ``$``::
+Envolvendo-se o identificador da marcação entre chaves, permite que ele seja
+seguido por mais caracteres alfanuméricos sem a necessidade de espaços.
+Escrevendo-se ``$$`` cria-se um único ``$``::
 
    >>> from string import Template
    >>> t = Template('Os ${lugar}nos enviaram $$10 para $causa.')
 
 O método :meth:`substitute` levanta uma exceção :exc:`KeyError` quando o
 identificador de uma marcação não é fornecido em um dicionário ou em um
-argumento nomeado (keyword argument). Para aplicações que podem receber dados
-incompletos fornecidos pelo usuário, o método :meth:`safe_substitute` pode ser
-mais apropriado --- deixará os marcadores intactos se os dados estiverem
-faltando::
+argumento nomeado (*keyword argument*). Para aplicações que podem receber
+dados incompletos fornecidos pelo usuário, o método :meth:`safe_substitute`
+pode ser mais apropriado --- deixará os marcadores intactos se os dados
+estiverem faltando::
 
    >>> t = Template('Encontre o $item e volte para $lugar.')
    >>> d = dict(item='cálice')
    Encontre o cálice e volte para $lugar
 
 Subclasses de Template podem especificar um delimitador personalizado. Por
-exemplo, um utilitário para renomeação em lote de fotos, pode usar o sinal
-de porcentagem para guarda-lugares como a data atual, número sequencial da
+exemplo, um utilitário para renomeação em lote de fotos pode usar o sinal
+de porcentagem para marcações como a data atual, número sequencial da
 imagem ou formato do aquivo::
 
    >>> import time, os.path
    img_1077.jpg --> Ashley_2.jpg
 
 Outra aplicação para templates é separar a lógica da aplicação dos detalhes de
-múltiplos formatos de saída. Isso faz possível substituir templates
-personalizados por arquivos XML, relatórios em texto puro e relatórios web em
-HTML.
+múltiplos formatos de saída. Assim é possível usar templates personalizados
+para gerar arquivos XML, relatórios em texto puro e relatórios web em HTML.
 
 
 .. _tut-binary-formats:
 Referências fracas
 ==================
 
-Python faz geranciamento automático de memória (contagem de referências para a
-maioria dos objetos e :term:`garbage collection` [coleta de lixo] para
-eliminar ciclos). A memória ocupada por um objeto é liberada logo depois da
-última referência a ele ser eliminada.
+Python faz gerenciamento automático de memória (contagem de referências para a
+maioria dos objetos e :term:`garbage collection <garbage collection>` [coleta
+de lixo] para eliminar ciclos). A memória ocupada por um objeto é liberada
+logo depois da última referência a ele ser eliminada.
 
 Essa abordagem funciona bem para a maioria das aplicações, mas ocasionalmente
 surge a necessidade de rastrear objetos apenas enquanto estão sendo usados por
 
 * aplicações financeiras que requerem representação decimal exata,
 * controle sobre a precisão,
-* controle sobre arredondamento para satisfazer requesitos legais,
+* controle sobre arredondamento para satisfazer requisitos legais,
 * rastreamento de casas decimais significativas, ou
 * aplicações onde o usuário espera que os resultados sejam os mesmos que os
   dos cálculos feitos à mão.