Commits

Juca Cripsim  committed fff8d8c

correções capítulo 11

  • Participants
  • Parent commits 76faaaa

Comments (0)

Files changed (1)

File 2.7/Doc/tutorial/stdlib2.rst

-.. _tut-brieftourtwo:
+.. _tut-brieftourtwo:
 
-*********************************************
-Brief Tour of the Standard Library -- Part II
-*********************************************
+***************************************************
+Um breve passeio pela biblioteca padrão -- Parte II
+***************************************************
 
-This second tour covers more advanced modules that support professional
-programming needs.  These modules rarely occur in small scripts.
+Este segundo passeio apresenta alguns módulos avançados que cobrem algumas
+necessidades de programação profissional. Esses módulos raramente aparecem
+em scripts pequenos.
 
 
 .. _tut-output-formatting:
 
-Output Formatting
-=================
+Formatando a saída
+==================
 
-The :mod:`repr` module provides a version of :func:`repr` customized for
-abbreviated displays of large or deeply nested containers::
+O módulo :mod:`repr` oferece uma versão modificada da função :func:`repr` para
+abreviar a exibição  de contêineres grandes ou profundamente aninhados::
 
    >>> import repr
    >>> repr.repr(set('supercalifragilisticexpialidocious'))
    "set(['a', 'c', 'd', 'e', 'f', 'g', ...])"
 
-The :mod:`pprint` module offers more sophisticated control over printing both
-built-in and user defined objects in a way that is readable by the interpreter.
-When the result is longer than one line, the "pretty printer" adds line breaks
-and indentation to more clearly reveal data structure::
+O módulo :mod: `pprint` oferece um controle mais sofisticado na exibição tanto
+de objetos embutidos quanto aqueles criados pelo usuário de maneira que fique
+mais legível através do interpretador. Quando o resultado é maior que uma
+linha, o "pretty printer" acrescenta quebras de linha e indentação para
+revelar as estruturas de maneira mais clara::
 
    >>> import pprint
-   >>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
-   ...     'yellow'], 'blue']]]
+   >>> t = [[[['preto', 'ciano'], 'branco', ['verde', 'vermelho']],
+   ...     [['magenta', 'amarelo'], 'azul']]]
    ...
    >>> pprint.pprint(t, width=30)
-   [[[['black', 'cyan'],
-      'white',
-      ['green', 'red']],
-     [['magenta', 'yellow'],
-      'blue']]]
+   [[[['preto', 'ciano'],
+      'branco',
+      ['verde', 'vermelho']],
+     [['magenta', 'amarelo'],
+      'azul']]]
 
-The :mod:`textwrap` module formats paragraphs of text to fit a given screen
-width::
+O módulo :mod:`textwrap` formata parágrafos de texto para que caibam em uma
+dada largura de tela::
 
    >>> import textwrap
-   >>> doc = """The wrap() method is just like fill() except that it returns
-   ... a list of strings instead of one big string with newlines to separate
-   ... the wrapped lines."""
+   >>> doc = """O método wrap() funciona como o método fill() exceto pelo fato
+   ... de devolver uma lista de strings ao invés de uma única string com
+   ... quebras de linha para separar as linhas."""
    ...
    >>> print textwrap.fill(doc, width=40)
-   The wrap() method is just like fill()
-   except that it returns a list of strings
-   instead of one big string with newlines
-   to separate the wrapped lines.
+   O método wrap() funciona como o método
+   fill() exceto pelo fato de devolver uma
+   lista de strings ao invés de uma única
+   string com quebras de linha para separar
+   as linhas.
 
-The :mod:`locale` module accesses a database of culture specific data formats.
-The grouping attribute of locale's format function provides a direct way of
-formatting numbers with group separators::
+O módulo :mod:`locale` acessa uma base de dados de formatos específicos a
+determinada cultura. O atributo grouping da função format oferece uma forma
+direta de formatar números com separadores de grupo::
 
    >>> import locale
-   >>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
-   'English_United States.1252'
-   >>> conv = locale.localeconv()          # get a mapping of conventions
+   >>> locale.setlocale(locale.LC_ALL, 'pt_BR.utf8')
+   'pt_BR.utf8'
+   >>> conv = locale.localeconv()          # pega um dicionário das convenções
    >>> x = 1234567.8
    >>> locale.format("%d", x, grouping=True)
-   '1,234,567'
+   '1.234.567'
    >>> locale.format_string("%s%.*f", (conv['currency_symbol'],
    ...                      conv['frac_digits'], x), grouping=True)
-   '$1,234,567.80'
+   'R$1.234.567,80'
 
 
 .. _tut-templating:
 
-Templating
-==========
+Usando modelos
+==============
 
-The :mod:`string` module includes a versatile :class:`Template` class with a
-simplified syntax suitable for editing by end-users.  This allows users to
-customize their applications without having to alter the application.
+O módulo :mod:`string` inclui a versátil classe :class:`Template` com uma 
+sintaxe simplificada, adequada para ser editada por usuários finais. Isso
+permite que usuários personalizem suas aplicações sem a necessidade de alterar
+a aplicação.
 
-The format uses placeholder names formed by ``$`` with valid Python identifiers
-(alphanumeric characters and underscores).  Surrounding the placeholder with
-braces allows it to be followed by more alphanumeric letters with no intervening
-spaces.  Writing ``$$`` creates a single escaped ``$``::
+O formato usa um guarda-lugar (placeholder) formado por ``$`` com um
+identificador Python válido(caracteres alfanuméricos e underscores). Envolvendo
+o guarda-lugar entre chaves, permite que ele seja seguido por mais caracteres
+alfanuméricos sem a necessidade de espaços. Escrevendo ``$$`` cria um único
+``$``::
 
    >>> from string import Template
-   >>> t = Template('${village}folk send $$10 to $cause.')
-   >>> t.substitute(village='Nottingham', cause='the ditch fund')
-   'Nottinghamfolk send $10 to the ditch fund.'
+   >>> t = Template('O pessoal de ${lugar}enviou $$10 para $causa.')
+   >>> t.substitute(lugar='Itaquera', causa='as obras da copa')
+   'O pessoal de Itaqueraenviou $10 para as obras da copa'
 
-The :meth:`substitute` method raises a :exc:`KeyError` when a placeholder is not
-supplied in a dictionary or a keyword argument. For mail-merge style
-applications, user supplied data may be incomplete and the
-:meth:`safe_substitute` method may be more appropriate --- it will leave
-placeholders unchanged if data is missing::
+O método :meth:`substitute` levanta uma exceção :exc:`KeyError` quando um
+guarda-lugar 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 guarda-lugares intactos se os dados estiverem 
+faltando::
 
-   >>> t = Template('Return the $item to $owner.')
-   >>> d = dict(item='unladen swallow')
-   >>> t.substitute(d)
+   >>> t = Template('Encontre o $item e volte para $lugar.')
+   >>> d = dict(item='cálice')
+   >>> print t.substitute(d)
    Traceback (most recent call last):
      . . .
-   KeyError: 'owner'
-   >>> t.safe_substitute(d)
-   'Return the unladen swallow to $owner.'
+   KeyError: 'lugar'
+   >>> print t.safe_substitute(d)
+   Encontre o cálice e volte para $lugar
 
-Template subclasses can specify a custom delimiter.  For example, a batch
-renaming utility for a photo browser may elect to use percent signs for
-placeholders such as the current date, image sequence number, or file format::
+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
+imagem ou formato do aquivo::
 
    >>> import time, os.path
-   >>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
-   >>> class BatchRename(Template):
+   >>> fotos = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
+   >>> class RenomearLote(Template):
    ...     delimiter = '%'
-   >>> fmt = raw_input('Enter rename style (%d-date %n-seqnum %f-format):  ')
-   Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f
+   >>> fmt = raw_input('Estilo para o nome (%d-data %n-numseq %f-formato):  ')
+   Estilo para o nome (%d-data %n-numseq %f-formato):  Ashley_%n%f
 
-   >>> t = BatchRename(fmt)
-   >>> date = time.strftime('%d%b%y')
-   >>> for i, filename in enumerate(photofiles):
-   ...     base, ext = os.path.splitext(filename)
-   ...     newname = t.substitute(d=date, n=i, f=ext)
-   ...     print '{0} --> {1}'.format(filename, newname)
+   >>> t = RenomearLote(fmt)
+   >>> data = time.strftime('%d%b%y')
+   >>> for i, nome_arquivo in enumerate(fotos):
+   ...     base, ext = os.path.splitext(nome_arquivo)
+   ...     novo_nome = t.substitute(d=data, n=i, f=ext)
+   ...     print '{0} --> {1}'.format(nome_arquivo, novo_nome)
 
    img_1074.jpg --> Ashley_0.jpg
    img_1076.jpg --> Ashley_1.jpg
    img_1077.jpg --> Ashley_2.jpg
 
-Another application for templating is separating program logic from the details
-of multiple output formats.  This makes it possible to substitute custom
-templates for XML files, plain text reports, and HTML web reports.
+Uma outra aplicação para o uso de modelos é separar a lógica da aplicação dos
+detalhes de múltiplos formatos de saída. Isso faz possível substituir modelos
+personalizados por arquivos XML, relatórios em texto puro e relatórios web em
+HTML.
 
 
 .. _tut-binary-formats:
 
-Working with Binary Data Record Layouts
-=======================================
+Trabalhando com formatos de dados binários
+==========================================
 
-The :mod:`struct` module provides :func:`pack` and :func:`unpack` functions for
-working with variable length binary record formats.  The following example shows
-how to loop through header information in a ZIP file without using the
-:mod:`zipfile` module.  Pack codes ``"H"`` and ``"I"`` represent two and four
-byte unsigned numbers respectively.  The ``"<"`` indicates that they are
-standard size and in little-endian byte order::
+.. REVISAR ANTES DE COMMITAR!!
+   The :mod:`struct` module provides :func:`pack` and :func:`unpack` functions for
+   working with variable length binary record formats.  The following example shows
+   how to loop through header information in a ZIP file without using the
+   :mod:`zipfile` module.  Pack codes ``"H"`` and ``"I"`` represent two and four
+   byte unsigned numbers respectively.  The ``"<"`` indicates that they are
+   standard size and in little-endian byte order
+
+O módulo :mod:`struct` oferece as funções :func:`pack` e :func:`unpack` para
+trabalhar com formatos binários de tamanho variável. O exemplo a seguir mostra
+como iterar através do cabeçalho de informação num aquivo ZIP sem usar o módulo
+:mod:`zipfile`. Os códigos de empacotamento ``"H"`` e ``"I"`` representam
+números sem sinal de dois e quatro bytes respectivamente. O ``"<"`` indica
+que eles (os bytes) são de tamanho padrão e tem a parte menos significante
+primeiro (little-endian)::
 
    import struct
 
    data = open('myfile.zip', 'rb').read()
    start = 0
-   for i in range(3):                      # show the first 3 file headers
+   for i in range(3):          # mostra o cabeçalho dos 3 primeiros arquivos
        start += 14
        fields = struct.unpack('<IIIHH', data[start:start+16])
        crc32, comp_size, uncomp_size, filenamesize, extra_size = fields
        extra = data[start:start+extra_size]
        print filename, hex(crc32), comp_size, uncomp_size
 
-       start += extra_size + comp_size     # skip to the next header
+       start += extra_size + comp_size      # vai para o próximo cabeçalho
 
 
 .. _tut-multi-threading:
 Multi-threading
 ===============
 
-Threading is a technique for decoupling tasks which are not sequentially
-dependent.  Threads can be used to improve the responsiveness of applications
-that accept user input while other tasks run in the background.  A related use
-case is running I/O in parallel with computations in another thread.
+.. REVISAR ANTES DE COMMITAR!!
+   Threading is a technique for decoupling tasks which are not sequentially
+   dependent.  Threads can be used to improve the responsiveness of applications
+   that accept user input while other tasks run in the background.  A related use
+   case is running I/O in parallel with computations in another thread.
 
-The following code shows how the high level :mod:`threading` module can run
-tasks in background while the main program continues to run::
+O uso de threads é uma técnica para desacoplar tarefas que não são
+sequencialmente dependentes. Threads podem ser usadas para melhorar o
+tempo de resposta de aplicações que aceitam entradas do usuário enquanto outras
+tarefas são executadas em segundo plano. Um caso relacionado é executar ações
+de entrada e saída (I/O) em uma thread paralelamente a cálculos em outra
+thread.
+
+O código a seguir mostra como o módulo de alto nível :mod:`threading` pode
+executar tarefas em segundo plano enquanto o programa principal continua
+a sua execução::
 
    import threading, zipfile
 
            f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
            f.write(self.infile)
            f.close()
-           print 'Finished background zip of: ', self.infile
+           print 'Terminei de zipar em segundo plano o arquivo: ', self.infile
 
    background = AsyncZip('mydata.txt', 'myarchive.zip')
    background.start()
-   print 'The main program continues to run in foreground.'
+   print 'O programa principal continua a sua execução em primeiro plano.'
 
-   background.join()    # Wait for the background task to finish
-   print 'Main program waited until background was done.'
+   background.join()    # Espera até que a tarefa em segundo plano termine.
+   print 'O programa principal esperou até a tarefa em segundo plano terminar.'
 
-The principal challenge of multi-threaded applications is coordinating threads
-that share data or other resources.  To that end, the threading module provides
-a number of synchronization primitives including locks, events, condition
-variables, and semaphores.
+.. The principal challengege of multi-threaded applications is coordinating threads
+   that share data or other resources.  To that end, the threading module provides
+   a number of synchronization primitives including locks, events, condition
+   variables, and semaphores.
 
-While those tools are powerful, minor design errors can result in problems that
-are difficult to reproduce.  So, the preferred approach to task coordination is
-to concentrate all access to a resource in a single thread and then use the
-:mod:`Queue` module to feed that thread with requests from other threads.
-Applications using :class:`Queue.Queue` objects for inter-thread communication
-and coordination are easier to design, more readable, and more reliable.
+.. While those tools are powerful, minor design errors can result in problems that
+   are difficult to reproduce.  So, the preferred approach to task coordination is
+   to concentrate all access to a resource in a single thread and then use the
+   :mod:`Queue` module to feed that thread with requests from other threads.
+   Applications using :class:`Queue.Queue` objects for inter-thread communication
+   and coordination are easier to design, more readable, and more reliable.
+
+O principal desafio de aplicações que usam múltiplas threads é coordenar as
+threads que compartilham dados ou outros recursos. Para esta finalidade, o
+módulo threading oferece alguns mecanismos primitivos de sincronização, como
+travas (locks), eventos, variáveis de condição e semáforos.
+
+Apesar destas ferramentas serem poderosas, pequenos erros podem resultar em
+problemas difíceis de serem reproduzidos. Então, a maneira preferida de
+coordenar tarefas é concentrar todo o acesso a um recurso em uma única thread
+e usar o módulo :mod:`Queue` para alimentar aquela thread com requisições de
+outras threads. Aplicações usando objetos do tipo :class:`Queue.Queue` para
+comunicação e coordenação inter-thread são mais fáceis de implementar, mais
+legíveis e mais confiáveis.
 
 
 .. _tut-logging:
 
-Logging
-=======
+Usando logs
+===========
 
-The :mod:`logging` module offers a full featured and flexible logging system.
-At its simplest, log messages are sent to a file or to ``sys.stderr``::
+O módulo :mod:`logging` oferece um completo e flexível sistema de log. Da
+maneira mais simples, mensagens de log são enviadas para um arquivo ou para
+``sys.stderr``::
 
    import logging
-   logging.debug('Debugging information')
-   logging.info('Informational message')
-   logging.warning('Warning:config file %s not found', 'server.conf')
-   logging.error('Error occurred')
-   logging.critical('Critical error -- shutting down')
+   logging.debug('Informação de debug')
+   logging.info('Mensagem informativa')
+   logging.warning('Aviso:arquivo de configuração %s não encontrado',
+                   'server.conf')
+   logging.error('Um erro ocorreu')
+   logging.critical('Erro crítico -- encerrando o programa.')
 
-This produces the following output::
+Isso produz a seguinte saída::
 
-   WARNING:root:Warning:config file server.conf not found
-   ERROR:root:Error occurred
-   CRITICAL:root:Critical error -- shutting down
+   WARNING:root:Aviso:arquivo de configuração server.conf não encontrado
+   ERROR:root:Um erro ocorreu
+   CRITICAL:root:Erro crítico -- encerrando o programa.
 
-By default, informational and debugging messages are suppressed and the output
-is sent to standard error.  Other output options include routing messages
-through email, datagrams, sockets, or to an HTTP Server.  New filters can select
-different routing based on message priority: :const:`DEBUG`, :const:`INFO`,
-:const:`WARNING`, :const:`ERROR`, and :const:`CRITICAL`.
+Por padrão, mensagens informativas e de depuração são suprimidas e a saída é
+enviada para a saída de erros padrão (stderr). Outras opções de saída incluem
+envio de mensagens através de correio eletrônico, datagramas, sockets ou para
+um servidor HTTP. Novos filtros podem selecionar diferentes formas de envio de
+mensagens, baseadas na prioridade da mensagem: :const:`DEBUG`, :const:`INFO`,
+:const:`WARNING`, :const:`ERROR` e :const:`CRITICAL`.
 
-The logging system can be configured directly from Python or can be loaded from
-a user editable configuration file for customized logging without altering the
-application.
+O sistema de log pode ser configurado diretamente do Python ou pode ser
+carregado a partir de um arquivo de configuração editável pelo usuário
+para logs personalizados sem a necessidade de alterar a aplicação.
 
 
 .. _tut-weak-references:
 
-Weak References
-===============
+Referências fracas
+==================
 
-Python does automatic memory management (reference counting for most objects and
-:term:`garbage collection` to eliminate cycles).  The memory is freed shortly
-after the last reference to it has been eliminated.
+Python faz geranciamento automático de memória (contagem de referências para
+a maioria dos objetos e coleta de lixo para eliminar ciclos). A memória é
+liberada logo depois da última referência ser eliminada.
 
-This approach works fine for most applications but occasionally there is a need
-to track objects only as long as they are being used by something else.
-Unfortunately, just tracking them creates a reference that makes them permanent.
-The :mod:`weakref` module provides tools for tracking objects without creating a
-reference.  When the object is no longer needed, it is automatically removed
-from a weakref table and a callback is triggered for weakref objects.  Typical
-applications include caching objects that are expensive to create::
+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
+algum outro. Infelizmente rastreá-los cria uma referência o que os fazem
+permanentes. O módulo :mod:`weakref` oferece ferramentas para rastrear objetos
+sem criar uma referência. Quando o objeto não é mais necessário, ele é
+automaticamente removido de uma tabela de referências fracas e uma chamada é
+disparada. Aplicações típicas incluem armazenamento de objetos que são muito
+custosos para criar::
 
    >>> import weakref, gc
    >>> class A:
    ...     def __repr__(self):
    ...             return str(self.value)
    ...
-   >>> a = A(10)                   # create a reference
+   >>> a = A(10)                   # cria uma referência
    >>> d = weakref.WeakValueDictionary()
-   >>> d['primary'] = a            # does not create a reference
-   >>> d['primary']                # fetch the object if it is still alive
+   >>> d['primary'] = a            # não cria uma referência
+   >>> d['primary']                # pega o objeto se ele ainda estiver vivo
    10
-   >>> del a                       # remove the one reference
-   >>> gc.collect()                # run garbage collection right away
+   >>> del a                       # remove a única referência
+   >>> gc.collect()                # roda o coletor de lixo logo em seguida
    0
-   >>> d['primary']                # entry was automatically removed
+   >>> d['primary']                # A entrada foi automaticamente removida
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
-       d['primary']                # entry was automatically removed
+       d['primary']                # A entrada foi automaticamente removida
      File "C:/python26/lib/weakref.py", line 46, in __getitem__
        o = self.data[key]()
    KeyError: 'primary'
 
 .. _tut-list-tools:
 
-Tools for Working with Lists
-============================
+Ferramentas para trabalhar com liastas
+======================================
 
-Many data structure needs can be met with the built-in list type. However,
-sometimes there is a need for alternative implementations with different
-performance trade-offs.
+Muitas necessidades envolvendo estrutura de dados podem ser satisfeitas
+com o tipo embutido lista. Entretanto, algumas vezes há uma necessidade
+por implementações alternativas com alguns sacrifícios em nome de melhor
+desempenho.
 
-The :mod:`array` module provides an :class:`array()` object that is like a list
-that stores only homogeneous data and stores it more compactly.  The following
-example shows an array of numbers stored as two byte unsigned binary numbers
-(typecode ``"H"``) rather than the usual 16 bytes per entry for regular lists of
-Python int objects::
+O módulo :mod:`array` oferece um objeto :class:`array()`, semelhante a uma
+lista, mas que armazena apenas dados homogêneos e de maneira mais compacta.
+O exemplo a seguir mostra um vetor de números armazenados como números binários
+de dois bytes sem sinal (typecode ``"H"``) ao invés do usual 16 bytes por item
+nas listas normais de objetos int::
 
    >>> from array import array
    >>> a = array('H', [4000, 10, 700, 22222])
    >>> a[1:3]
    array('H', [10, 700])
 
-The :mod:`collections` module provides a :class:`deque()` object that is like a
-list with faster appends and pops from the left side but slower lookups in the
-middle. These objects are well suited for implementing queues and breadth first
-tree searches::
+O módulo :mod:`collections` oferece um objeto :class:`deque()` que comporta-se
+como uma lista mas com anexações (appends) mais rápidos e remoções (pops)
+feitas pelo lado esquerdo. Esses objetos são adequados para implementação de
+filas e buscas de amplitude em árvores de dados(breadth first tree searches)::
 
    >>> from collections import deque
-   >>> d = deque(["task1", "task2", "task3"])
-   >>> d.append("task4")
-   >>> print "Handling", d.popleft()
-   Handling task1
+   >>> d = deque(["tarefa1", "tarefa2", "tarefa3"])
+   >>> d.append("tarefa4")
+   >>> print "Tratando", d.popleft()
+   Tratando tarefa1
 
-   unsearched = deque([starting_node])
-   def breadth_first_search(unsearched):
-       node = unsearched.popleft()
-       for m in gen_moves(node):
-           if is_goal(m):
-               return m
-           unsearched.append(m)
+   nao_buscados = deque([noh_inicial])
+   def busca_em_amplitude(nao_buscados):
+       noh = nao_buscados.popleft()
+       for m in gen_moves(noh):
+           if eh_objetivo(m):
+	       return m
+           nao_buscados.append(m)
 
-In addition to alternative list implementations, the library also offers other
-tools such as the :mod:`bisect` module with functions for manipulating sorted
-lists::
+Além de implementações alternativas de listas, a biblioteca também oferece
+outras ferramentas como o módulo :mod:`bisect` com funções para manipulação
+de listas ordenadas::
 
    >>> import bisect
-   >>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
-   >>> bisect.insort(scores, (300, 'ruby'))
-   >>> scores
+   >>> pontos = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
+   >>> bisect.insort(pontos, (300, 'ruby'))
+   >>> pontos
    [(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
 
-The :mod:`heapq` module provides functions for implementing heaps based on
-regular lists.  The lowest valued entry is always kept at position zero.  This
-is useful for applications which repeatedly access the smallest element but do
-not want to run a full list sort::
+O módulo :mod:`heapq` oferece funções para implementação de heaps baseadas
+em listas normais. O valor mais baixo é sempre mantido na posição zero. Isso é
+útil para aplicações que acessam repetidamente o menor elemento, mas não querem
+reordenar a lista toda a cada acesso::
 
    >>> from heapq import heapify, heappop, heappush
    >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
-   >>> heapify(data)                      # rearrange the list into heap order
-   >>> heappush(data, -5)                 # add a new entry
-   >>> [heappop(data) for i in range(3)]  # fetch the three smallest entries
+   >>> heapify(data)                      # re-arranja a lista numa ordem heap
+   >>> heappush(data, -5)                 # adiciona um novo item
+   >>> [heappop(data) for i in range(3)]  # recupera os três menores itens
    [-5, 0, 1]
 
 
 .. _tut-decimal-fp:
 
-Decimal Floating Point Arithmetic
-=================================
+Aritmética com ponto flutuante decimal
+======================================
 
-The :mod:`decimal` module offers a :class:`Decimal` datatype for decimal
-floating point arithmetic.  Compared to the built-in :class:`float`
-implementation of binary floating point, the class is especially helpful for
+O módulo :mod:`decimal` oferece o tipo :class:`Decimal` para aritmética
+com ponto flutuante decimal. Comparado a implementação embutida 
+:class:`float` que usa ponto flutuante binário, a classe é especialmente
+útil para
 
-* financial applications and other uses which require exact decimal
-  representation,
-* control over precision,
-* control over rounding to meet legal or regulatory requirements,
-* tracking of significant decimal places, or
-* applications where the user expects the results to match calculations done by
-  hand.
+* aplicações financeiras que requerem representação decimal exata,
+* controle sobre precisão
+* controle sobre arredondamento para satisfazer requerimentos legais,
+* rastreamento de casas decimais significantes, ou
+* aplicações onde o usuário espera que os resultados sejam os mesmos que os
+  dos cálculos feitos à mão.
 
-For example, calculating a 5% tax on a 70 cent phone charge gives different
-results in decimal floating point and binary floating point. The difference
-becomes significant if the results are rounded to the nearest cent::
+Por exemplo, calcular um imposto de 5% numa chamada telefônica de 70 centavos
+devolve diferentes resultados com ponto flutuante decimal e binário. A
+diferença torna-se significante se os resultados são arredondados para o
+centavo mais próximo.
 
    >>> from decimal import *
    >>> x = Decimal('0.70') * Decimal('1.05')
    >>> x
    Decimal('0.7350')
-   >>> x.quantize(Decimal('0.01'))  # round to nearest cent
+   >>> x.quantize(Decimal('0.01'))  # arredonda para o centavo mais próximo
    Decimal('0.74')
-   >>> round(.70 * 1.05, 2)         # same calculation with floats
+   >>> round(.70 * 1.05, 2)         # o mesmo cálculo com float
    0.73
 
-The :class:`Decimal` result keeps a trailing zero, automatically inferring four
-place significance from multiplicands with two place significance.  Decimal
-reproduces mathematics as done by hand and avoids issues that can arise when
-binary floating point cannot exactly represent decimal quantities.
+O resultado de :class:`Decimal` mantém um zero final, automaticamente inferindo
+quatro casas decimais para multiplicandos com duas casas decimais. Decimal
+reproduz a matemática como a feita à mão e evita problemas que podem ocorrer
+quando ponto flutuante binário não pode representar quantidades decimais
+exatamente.
 
-Exact representation enables the :class:`Decimal` class to perform modulo
-calculations and equality tests that are unsuitable for binary floating point::
+Representação exata permite à classe :class:`Decimal` executar cálculos de
+módulo e testes de igualdade que não podem ser feitos com ponto flutuante
+binário::
 
    >>> Decimal('1.00') % Decimal('.10')
    Decimal('0.00')
    >>> sum([0.1]*10) == 1.0
    False
 
-The :mod:`decimal` module provides arithmetic with as much precision as needed::
+O módulo :mod:`decimal` oferece aritmética com tanta precisão quanto
+necessária::
 
    >>> getcontext().prec = 36
    >>> Decimal(1) / Decimal(7)