O que há de novo no Python 2.7
******************************

Autor:
   A.M. Kuchling (amk at amk.ca)

Este artigo explica os novos recursos do Python 2.7. O Python 2.7 foi
lançado em 3 de julho de 2010.

A manipulação numérica foi aprimorada de várias maneiras, tanto para
números de ponto flutuante quanto para a classe "Decimal". Existem
algumas adições úteis à biblioteca padrão, como um módulo "unittest"
bastante aprimorado, o módulo "argparse" para analisar as opções da
linha de comando, classes convenientes "OrderedDict" e "Counter" no
módulo "collections" e muitas outras melhorias.

O Python 2.7 está planejado para ser o último dos lançamentos 2.x, por
isso trabalhamos para torná-lo um bom lançamento a longo prazo. Para
ajudar na migração para o Python 3, vários novos recursos da série
Python 3.x foram incluídos no 2.7.

Este artigo não tenta fornecer uma especificação completa dos novos
recursos, mas fornece uma visão geral conveniente. Para detalhes
completos, você deve consultar a documentação do Python 2.7 em
https://docs.python.org. Se você deseja entender a lógica do design e
implementação, consulte a PEP para obter um novo recurso específico ou
o problema em https://bugs.python.org no qual uma alteração foi
discutida. Sempre que possível, o "O que há de novo no Python" é
vinculado ao item de bug/patch de cada alteração.


O futuro para o Python 2.x
==========================

Python 2.7 é o último grande lançamento da série 2.x, já que os
mantenedores do Python mudaram o foco de seus esforços de
desenvolvimento de novos recursos para a série Python 3.x. Isso
significa que, embora o Python 2 continue recebendo correções de bugs
e seja atualizado para construir corretamente em novo hardware e
versões de sistemas operados com suporte, não haverá novos lançamentos
de recursos completos para a linguagem ou biblioteca padrão.

No entanto, embora haja um grande subconjunto comum entre Python 2.7 e
Python 3, e muitas das mudanças envolvidas na migração para esse
subconjunto comum, ou diretamente para Python 3, podem ser
automatizadas com segurança, algumas outras mudanças (principalmente
aquelas associadas ao tratamento Unicode) pode exigir uma consideração
cuidadosa e, de preferência, conjuntos de testes de regressão
automatizados robustos, para migrar com eficácia.

Isso significa que o Python 2.7 permanecerá em vigor por um longo
tempo, fornecendo uma plataforma base estável e com suporte para
sistemas de produção que ainda não foram portados para Python 3. O
ciclo de vida completo esperado da série Python 2.7 é detalhado na
**PEP 373**.

Algumas consequências principais da significância de longo prazo de
2.7 são:

* Conforme observado acima, a versão 2.7 tem um período de manutenção
  muito mais longo em comparação com as versões 2.x anteriores.
  Atualmente, espera-se que o Python 2.7 continue com o suporte da
  equipe de desenvolvimento central (recebendo atualizações de
  segurança e outras correções de bugs) até pelo menos 2020 (10 anos
  após seu lançamento inicial, em comparação com o período de suporte
  mais típico de 18-24 meses).

* Conforme a biblioteca padrão do Python 2.7 envelhece, fazer uso
  efetivo do Python Package Index (diretamente ou por meio de um
  redistribuidor) torna-se mais importante para os usuários do Python
  2. Além de uma grande variedade de pacotes de terceiros para várias
  tarefas, os pacotes disponíveis incluem backports de novos módulos e
  recursos da biblioteca padrão do Python 3 que são compatíveis com o
  Python 2, bem como várias ferramentas e bibliotecas que podem tornar
  mais fácil migre para Python 3. O Guia de Usuário para Empacotamento
  de Python fornece orientação sobre como baixar e instalar software
  do Python Package Index.

* Embora a abordagem preferida para aprimorar o Python 2 agora seja a
  publicação de novos pacotes no Python Package Index, essa abordagem
  não funciona necessariamente em todos os casos, especialmente
  aqueles relacionados à segurança de rede. Em casos excepcionais que
  não podem ser tratados adequadamente com a publicação de pacotes
  novos ou atualizados no PyPI, o processo de Proposta de Melhoria do
  Python, ou PEP, pode ser usado para justificar a adição de novos
  recursos diretamente à biblioteca padrão do Python 2. Quaisquer
  adições, e as versões de manutenção onde foram adicionadas, serão
  observadas na seção Novos recursos adicionados às versões de
  manutenção do Python 2.7 abaixo.

Para projetos que desejam migrar de Python 2 para Python 3, ou para
desenvolvedores de bibliotecas e frameworks que desejam oferecer
suporte a usuários em Python 2 e Python 3, há uma variedade de
ferramentas e guias disponíveis para ajudar a decidir sobre uma
abordagem adequada e gerenciar alguns dos os detalhes técnicos
envolvidos. O ponto de partida recomendado é o guia Como portar
códigos do Python 2 para o Python 3.


Mudanças no tratamento de avisos de descontinuação
==================================================

Para Python 2.7, uma decisão política foi feita para silenciar avisos
apenas de interesse para desenvolvedores por padrão.
"DeprecationWarning" e seus descendentes agora são ignorados a menos
que solicitado de outra forma, evitando que os usuários vejam avisos
acionados por uma aplicação. Essa mudança também foi feita no branch
que se tornou o Python 3.2. (Discutido em stdlib-sig e realizado em
bpo-7319.)

Em versões anteriores, as mensagens "DeprecationWarning" eram
habilitadas por padrão, fornecendo aos desenvolvedores de Python uma
indicação clara de onde seu código pode quebrar em uma versão
principal futura do Python.

No entanto, há cada vez mais usuários de aplicações baseadas em Python
que não estão diretamente envolvidos no desenvolvimento dessas
aplicações. Mensagens de "DeprecationWarning" são irrelevantes para
tais usuários, fazendo-os se preocupar com uma aplicação que está
realmente funcionando corretamente e sobrecarregando os
desenvolvedores de aplicações com a resposta a essas preocupações.

Você pode reativar a exibição de mensagens "DeprecationWarning"
executando Python com a opção "-Wdefault" (forma curta: "-Wd") ou
definindo a variável de ambiente "PYTHONWARNINGS" para ""default"" (ou
""d"") antes de executar o Python. O código Python também pode
reativá-los chamando "warnings.simplefilter('default')".

O módulo "unittest" também reativa automaticamente os avisos de
depreciação ao executar testes.


Recursos do Python 3.1
======================

Assim como o Python 2.6 incorporou recursos do Python 3.0, a versão
2.7 incorpora alguns dos novos recursos do Python 3.1. A série 2.x
continua a fornecer ferramentas para migração para a série 3.x.

Uma lista parcial de recursos do 3.1 que foram transferidos para o
2.7:

* A sintaxe para conjuntos de literais ("{1,2,3}" é um conjunto
  mutável).

* Compreensões de dicionário e conjunto ("{i: i*2 for i in
  range(3)}").

* Vários gerenciadores de contexto em uma única instrução "with".

* Uma nova versão da biblioteca "io", reescrita em C para melhor
  desempenho.

* O tipo de dicionário ordenado descrito na PEP 372: Adicionando um
  dicionário ordenado a coleções.

* O novo especificador de formato "","" descrito na PEP 378:
  Especificador de formato para separador de milhares.

* O objeto "memoryview".

* Um pequeno subconjunto do módulo "importlib", descrito sob.

* O "repr()" de um ponto flutuante "x" é mais curto em muitos casos:
  agora é baseado na string decimal mais curta que é garantida para
  arredondar de volta para "x". Como nas versões anteriores do Python,
  é garantido que "float(repr(x))" recupera "x".

* As conversões de ponto flutuante para string e string para ponto
  flutuante são arredondadas corretamente. A função "round()" também
  está agora corretamente arredondada.

* O tipo "PyCapsule", usado para fornecer uma API C para módulos de
  extensão.

* A função de API C "PyLong_AsLongAndOverflow()".

Outros novos avisos do modo Python3 incluem:

* "operator.isCallable()" e "operator.sequenceIncludes()", que não são
  suportados no 3.x, agora disparam avisos.

* A opção "-3" agora habilita automaticamente a opção "-Qwarn" que
  causa avisos sobre o uso de divisão clássica com inteiros e inteiros
  longos.


PEP 372: Adicionando um dicionário ordenado a coleções
======================================================

Dicionários regulares no Python iteram sobre pares de chave/valor em
ordem arbitrária. Ao longo dos anos, vários autores escreveram
implementações alternativas que lembram a ordem em que as chaves foram
inseridas originalmente. Com base nas experiências dessas
implementações, 2.7 introduz uma nova classe "OrderedDict" no módulo
"collections".

A API "OrderedDict" fornece a mesma interface que os dicionários
regulares, mas itera sobre chaves e valores em uma ordem garantida
dependendo de quando uma chave foi inserida pela primeira vez:

   >>> from collections import OrderedDict
   >>> d = OrderedDict([('first', 1),
   ...                  ('second', 2),
   ...                  ('third', 3)])
   >>> d.items()
   [('first', 1), ('second', 2), ('third', 3)]

Se uma nova entrada substituir uma entrada existente, a posição de
inserção original permanece inalterada:

   >>> d['second'] = 4
   >>> d.items()
   [('first', 1), ('second', 4), ('third', 3)]

Excluir uma entrada e reinseri-la irá movê-la para o final:

   >>> del d['second']
   >>> d['second'] = 5
   >>> d.items()
   [('first', 1), ('third', 3), ('second', 5)]

O método "popitem()" tem um argumento opcional *last* cujo valor
padrão é "True". Se *last* for true, a chave adicionada mais
recentemente é retornada e removida; se for falso, a chave mais antiga
é selecionada:

   >>> od = OrderedDict([(x,0) for x in range(20)])
   >>> od.popitem()
   (19, 0)
   >>> od.popitem()
   (18, 0)
   >>> od.popitem(last=False)
   (0, 0)
   >>> od.popitem(last=False)
   (1, 0)

A comparação de dois dicionários ordenados verifica as chaves e os
valores e exige que o pedido de inserção seja o mesmo:

   >>> od1 = OrderedDict([('first', 1),
   ...                    ('second', 2),
   ...                    ('third', 3)])
   >>> od2 = OrderedDict([('third', 3),
   ...                    ('first', 1),
   ...                    ('second', 2)])
   >>> od1 == od2
   False
   >>> # Move 'third' key to the end
   >>> del od2['third']; od2['third'] = 3
   >>> od1 == od2
   True

Comparar um "OrderedDict" com um dicionário regular ignora a ordem de
inserção e apenas compara as chaves e valores.

Como funciona a "OrderedDict"? Ela mantém uma lista duplamente
vinculada de chaves, acrescentando novas chaves à lista à medida que
são inseridas. Um dicionário secundário mapeia as chaves para seu nó
de lista correspondente, portanto, a exclusão não precisa percorrer
toda a lista vinculada e, portanto, permanece *O*(1).

A biblioteca padrão agora oferece suporte ao uso de dicionários
ordenados em vários módulos.

* O módulo "ConfigParser" os usa por padrão, o que significa que os
  arquivos de configuração agora podem ser lidos, modificados e então
  escritos de volta em sua ordem original.

* O método "_asdict()" para "Collections.namedtuple()" agora retorna
  um dicionário ordenado com os valores aparecendo na mesma ordem que
  os índices de tupla subjacentes.

* O construtor de classe "JSONDecoder" do módulo "json" foi estendido
  com um parâmetro *object_pairs_hook* para permitir que instâncias
  "OrderedDict" sejam construídas pelo decodificador. O suporte também
  foi adicionado para ferramentas de terceiros como PyYAML.

Ver também:

  **PEP 372** - Adicionando um dicionário ordenado às coleções
     PEP escrita por Armin Ronacher e Raymond Hettinger; implementada
     por Raymond Hettinger.


PEP 378: Especificador de formato para separador de milhares
============================================================

Para tornar a saída do programa mais legível, pode ser útil adicionar
separadores a números grandes, renderizando-os como
18,446,744.073,709,551,616 em vez de 18446744073709551616.

A solução totalmente geral para fazer isso é o módulo "locale", que
pode usar diferentes separadores ("," na América do Norte, "." na
Europa) e diferentes tamanhos de agrupamento, mas "locale" é
complicado para usar e inadequado para aplicativos multithread onde
diferentes threads estão produzindo saída para diferentes localidades.

Portanto, um mecanismo simples de agrupamento de vírgulas foi
adicionado à minilinguagem usada pelo método "str.format()". Ao
formatar um número de ponto flutuante, basta incluir uma vírgula entre
a largura e a precisão:

   >>> '{:20,.2f}'.format(18446744073709551616.0)
   '18,446,744,073,709,551,616.00'

Ao formatar um número inteiro, inclua a vírgula após a largura:

>>> '{:20,d}'.format(18446744073709551616)
'18,446,744,073,709,551,616'

Este mecanismo não é adaptável de forma alguma; vírgulas são sempre
usadas como separadores e o agrupamento é sempre em grupos de três
dígitos. O mecanismo de formatação de vírgula não é tão geral quanto o
módulo "locale", mas é mais fácil de usar.

Ver também:

  **PEP 378** - Especificador de formato para separador de milhares
     PEP escrita por Raymond Hettinger; implementada por Eric Smith.


PEP 389: O módulo argparse para analisar linhas de comando
==========================================================

O módulo "argparse" para analisar argumentos de linha de comando foi
adicionado como um substituto mais poderoso para o módulo "optparse".

Isso significa que Python agora oferece suporte a três módulos
diferentes para analisar argumentos de linha de comando: "getopt",
"optparse" e "argparse". O módulo "getopt" se assemelha muito à função
"getopt()" da biblioteca C, portanto continua útil se você estiver
escrevendo um protótipo Python que eventualmente será reescrito em C.
"optparse" torna-se redundante, mas não há planos para removê-lo
porque muitos scripts ainda o utilizam e não há uma maneira
automatizada de atualizar esses scripts. (Tornar a API "argparse"
consistente com a interface de "optparse" foi discutido, mas rejeitado
por ser muito confuso e difícil.)

Resumindo, se você está escrevendo um novo script e não precisa se
preocupar com a compatibilidade com versões anteriores do Python, use
"argparse" ao invés de "optparse".

Aqui está um exemplo:

   import argparse

   parser = argparse.ArgumentParser(description='Command-line example.')

   # Add optional switches
   parser.add_argument('-v', action='store_true', dest='is_verbose',
                       help='produce verbose output')
   parser.add_argument('-o', action='store', dest='output',
                       metavar='FILE',
                       help='direct output to FILE instead of stdout')
   parser.add_argument('-C', action='store', type=int, dest='context',
                       metavar='NUM', default=0,
                       help='display NUM lines of added context')

   # Allow any number of additional arguments.
   parser.add_argument(nargs='*', action='store', dest='inputs',
                       help='input filenames (default is stdin)')

   args = parser.parse_args()
   print args.__dict__

A menos que você o substitua, as opções "-h" e "--help" são
adicionadas automaticamente e produzem uma saída formatada de maneira
organizada:

   -> ./python.exe argparse-example.py --help
   usage: argparse-example.py [-h] [-v] [-o FILE] [-C NUM] [inputs [inputs ...]]

   Command-line example.

   positional arguments:
     inputs      input filenames (default is stdin)

   optional arguments:
     -h, --help  show this help message and exit
     -v          produce verbose output
     -o FILE     direct output to FILE instead of stdout
     -C NUM      display NUM lines of added context

Como em "optparse", as opções e argumentos da linha de comando são
retornados como um objeto com atributos nomeados pelos parâmetros
*dest*:

   -> ./python.exe argparse-example.py -v
   {'output': None,
    'is_verbose': True,
    'context': 0,
    'inputs': []}

   -> ./python.exe argparse-example.py -v -o /tmp/output -C 4 file1 file2
   {'output': '/tmp/output',
    'is_verbose': True,
    'context': 4,
    'inputs': ['file1', 'file2']}

"argparse" tem uma validação muito mais sofisticada que "optparse";
você pode especificar um número exato de argumentos como um inteiro, 0
ou mais argumentos passando "'*'", 1 ou mais passando "'+'", ou um
argumento opcional com "'?'". Um analisador de nível superior pode
conter sub-analisadores para definir subcomandos que possuem
diferentes conjuntos de opções, como em "svn commit", "svn checkout",
etc. Você pode especificar o tipo de um argumento como "FileType", que
abrirá arquivos automaticamente para você e entende que "'-'"
significa entrada ou saída padrão.

Ver também:

  Documentação do "argparse"
     A página de documentação do módulo argparse.

  Atualizando código optparse
     Parte da documentação do Python, descrevendo como converter o
     código que usa "optparse".

  **PEP 389** - argparse - Novo módulo de análise sintática de linha
  de comando
     PEP escrita e implementada por Steven Bethard.


PEP 391: Configuração baseada em dicionário para logging
========================================================

O módulo "logging" é muito flexível; os aplicativos podem definir uma
árvore de subsistemas de log e cada logger nessa árvore pode filtrar
determinadas mensagens, formatá-las de maneira diferente e direcionar
mensagens para um número variável de manipuladores.

Toda essa flexibilidade pode exigir muita configuração. Você pode
escrever instruções Python para criar objetos e definir suas
propriedades, mas uma configuração complexa requer um código
detalhado, mas enfadonho. "logging" também suporta uma função
"fileConfig()" que analisa um arquivo, mas o formato do arquivo não
oferece suporte  à configuração de filtros, e é mais confuso gerar
programaticamente.

O Python 2.7 adiciona uma função "dictConfig()" que usa um dicionário
para configurar o log. Existem muitas maneiras de produzir um
dicionário a partir de diferentes fontes: construir um com código;
analisar um arquivo contendo JSON; ou use uma biblioteca de análise de
YAML se houver uma instalada. Para mais informações veja Funções de
configuração.

O exemplo a seguir configura dois loggers, o logger raiz e um logger
denominado "network". As mensagens enviadas para o registrador raiz
serão enviadas para o log do sistema usando o protocolo syslog, e as
mensagens para o logger "network" serão gravadas em um arquivo
"network.log" que será rotacionado assim que o log atingir 1 MB.

   import logging
   import logging.config

   configdict = {
    'version': 1,    # Configuration schema in use; must be 1 for now
    'formatters': {
        'standard': {
            'format': ('%(asctime)s %(name)-15s '
                       '%(levelname)-8s %(message)s')}},

    'handlers': {'netlog': {'backupCount': 10,
                        'class': 'logging.handlers.RotatingFileHandler',
                        'filename': '/logs/network.log',
                        'formatter': 'standard',
                        'level': 'INFO',
                        'maxBytes': 1000000},
                 'syslog': {'class': 'logging.handlers.SysLogHandler',
                            'formatter': 'standard',
                            'level': 'ERROR'}},

    # Specify all the subordinate loggers
    'loggers': {
                'network': {
                            'handlers': ['netlog']
                }
    },
    # Specify properties of the root logger
    'root': {
             'handlers': ['syslog']
    },
   }

   # Set up configuration
   logging.config.dictConfig(configdict)

   # As an example, log two error messages
   logger = logging.getLogger('/')
   logger.error('Database not found')

   netlogger = logging.getLogger('network')
   netlogger.error('Connection failed')

Três melhorias menores no módulo "logging", todas implementadas por
Vinay Sajip, são:

* A classe "SysLogHandler" agora tem suporte a syslogging sobre TCP. O
  construtor tem um parâmetro *socktype* que fornece o tipo de soquete
  a ser usado, "socket.SOCK_DGRAM" para UDP ou "socket.SOCK_STREAM"
  para TCP. O protocolo padrão permanece UDP.

* As instâncias "Logger" ganharam um método "getChild()" que recupera
  um logger descendente usando um caminho relativo. Por exemplo,
  depois de recuperar um logger fazendo "log = getLogger('app')",
  chamar "log.getChild('network.listen')" é equivalente a
  "getLogger('app.network.listen')".

* A classe "LoggerAdapter" ganhou um método "isEnabledFor()" que pega
  um *level* e retorna se o logger subjacente processaria uma mensagem
  desse nível de importância.

Ver também:

  **PEP 391** - Configuração baseada em dicionário para logging
     PEP escrita e implementada por Vinay Sajip.


PEP 3106: Views de dicionário
=============================

Os métodos de dicionário "keys()", "values()" e "items()" são
diferentes no Python 3.x. Eles retornam um objeto chamado *view* em
vez de uma lista totalmente materializada.

Não é possível alterar os valores de retorno de "keys()", "values()" e
"items()" no Python 2.7 porque muito código seria interrompido. Em vez
disso, as versões 3.x foram adicionadas com os novos nomes
"viewkeys()", "viewvalues()" e "viewitems()".

   >>> d = dict((i*10, chr(65+i)) for i in range(26))
   >>> d
   {0: 'A', 130: 'N', 10: 'B', 140: 'O', 20: ..., 250: 'Z'}
   >>> d.viewkeys()
   dict_keys([0, 130, 10, 140, 20, 150, 30, ..., 250])

As views podem ser iteradas, mas as exibições de chave e item também
se comportam como conjuntos. O operador "&" realiza a interseção, e o
"|" realiza uma união:

   >>> d1 = dict((i*10, chr(65+i)) for i in range(26))
   >>> d2 = dict((i**.5, i) for i in range(1000))
   >>> d1.viewkeys() & d2.viewkeys()
   set([0.0, 10.0, 20.0, 30.0])
   >>> d1.viewkeys() | range(0, 30)
   set([0, 1, 130, 3, 4, 5, 6, ..., 120, 250])

A view acompanha o dicionário e seu conteúdo muda à medida que o
dicionário é modificado:

   >>> vk = d.viewkeys()
   >>> vk
   dict_keys([0, 130, 10, ..., 250])
   >>> d[260] = '&'
   >>> vk
   dict_keys([0, 130, 260, 10, ..., 250])

No entanto, observe que você não pode adicionar ou remover chaves
enquanto estiver iterando na view:

   >>> for k in vk:
   ...     d[k*2] = k
   ...
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   RuntimeError: dictionary changed size during iteration

Você pode usar os métodos de exibição no código Python 2.x, e o
conversor 2to3 irá alterá-los para os métodos padrão "keys()",
"values()" e "items()".

Ver também:

  **PEP 3106** - Repaginação de dict.keys(), .values() e .items()
     PEP escrita por Guido van Rossum. Backported para 2.7 por
     Alexandre Vassalotti; bpo-1967.


PEP 3137: O objeto memoryview
=============================

O objeto "memoryview" fornece uma visão do conteúdo da memória de
outro objeto que corresponde à interface do tipo "bytes".

   >>> import string
   >>> m = memoryview(string.letters)
   >>> m
   <memory at 0x37f850>
   >>> len(m)           # Returns length of underlying object
   52
   >>> m[0], m[25], m[26]   # Indexing returns one byte
   ('a', 'z', 'A')
   >>> m2 = m[0:26]         # Slicing returns another memoryview
   >>> m2
   <memory at 0x37f080>

O conteúdo da viewq pode ser convertido em uma string de bytes ou uma
lista de inteiros:

   >>> m2.tobytes()
   'abcdefghijklmnopqrstuvwxyz'
   >>> m2.tolist()
   [97, 98, 99, 100, 101, 102, 103, ... 121, 122]
   >>>

Objetos "memoryview" permitem modificar o objeto subjacente se for um
objeto mutável.

   >>> m2[0] = 75
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: cannot modify read-only memory
   >>> b = bytearray(string.letters)  # Creating a mutable object
   >>> b
   bytearray(b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
   >>> mb = memoryview(b)
   >>> mb[0] = '*'         # Assign to view, changing the bytearray.
   >>> b[0:5]              # The bytearray has been changed.
   bytearray(b'*bcde')
   >>>

Ver também:

  **PEP 3137** - Bytes imutáveis e buffer mutável
     PEP escrita por Guido van Rossum. Implementada por Travis
     Oliphant, Antoine Pitrou e outros. Portado para 2.7 por Antoine
     Pitrou; bpo-2396.


Outras mudanças na linguagem
============================

Algumas das mudanças menores feitas no núcleo da linguagem Python são:

* A sintaxe para set literais foi portada do Python 3.x. Os colchetes
  são usados para cercar o conteúdo do conjunto mutável resultante; os
  literais definidos são diferenciados dos dicionários por não
  conterem caracteres de dois pontos e valores. "{}" continua a
  representar um dicionário vazio; use "set()" para um conjunto vazio.

     >>> {1, 2, 3, 4, 5}
     set([1, 2, 3, 4, 5])
     >>> set() # empty set
     set([])
     >>> {}    # empty dict
     {}

  Portado por Alexandre Vassalotti; bpo-2335.

* As compreensões de dicionário e conjunto são outro recurso importado
  do 3.x, generalizando as compreensões de lista/gerador para usar a
  sintaxe literal para conjuntos e dicionários.

     >>> {x: x*x for x in range(6)}
     {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
     >>> {('a'*x) for x in range(6)}
     set(['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa'])

  Portado por Alexandre Vassalotti; bpo-2333.

* A instrução "with" agora pode usar vários gerenciadores de contexto
  em uma instrução. Os gerenciadores de contexto são processados da
  esquerda para a direita e cada um é tratado como o início de uma
  nova instrução "with". Isso significa que:

     with A() as a, B() as b:
         ... suite of statements ...

  é equivalente a:

     with A() as a:
         with B() as b:
             ... suite of statements ...

  A função "contextlib.nested()" fornece uma função muito similar,
  então não é mais necessária e foi descontinuada.

  (Proposta em https://codereview.appspot.com/53094; implementada por
  Georg Brandl.)

* As conversões entre números de ponto flutuante, ou float. e strings
  agora são arredondadas corretamente na maioria das plataformas.
  Estas conversões ocorrem em muitos lugares diferentes: "str()" em
  floats e números complexos; os construtores "float" e "complex";
  formatação numérica; serializar e desserializar floats e números
  complexos usando os módulos "marshal", "pickle" e "json"; análise de
  float e literais imaginários no código Python; e a conversão
  "Decimal"-para-float.

  Relacionado a isso, o "repr()" de um número de ponto flutuante *x*
  agora retorna um resultado baseado na string decimal mais curta que
  é garantida para arredondar de volta para *x* sob o arredondamento
  correto (com o modo de arredondamento round-half-to-even).
  Anteriormente, fornecia uma string baseada no arredondamento x para
  17 dígitos decimais.

  A biblioteca de arredondamento responsável por essa melhoria
  funciona no Windows e em plataformas Unix usando os compiladores
  gcc, icc ou suncc. Pode haver um pequeno número de plataformas onde
  a operação correta deste código não pode ser garantida, então o
  código não é usado em tais sistemas. Você pode descobrir qual código
  está sendo usado verificando "sys.float_repr_style", que será
  "short" se o novo código estiver em uso e "legacy" se não estiver.

  Implementada por Eric Smith and Mark Dickinson, usando a biblioteca
  "dtoa.c" de David Gay; bpo-7117.

* As conversões de inteiros longos e inteiros regulares para ponto
  flutuante agora arredondam de maneira diferente, retornando o número
  de ponto flutuante mais próximo ao número. Isso não importa para
  pequenos inteiros que podem ser convertidos exatamente, mas para
  grandes números que inevitavelmente perderão a precisão, o Python
  2.7 agora se aproxima mais. Por exemplo, o Python 2.6 computou o
  seguinte:

     >>> n = 295147905179352891391
     >>> float(n)
     2.9514790517935283e+20
     >>> n - long(float(n))
     65535L

  O resultado de ponto flutuante do Python 2.7 é maior, mas muito mais
  próximo do valor verdadeiro:

     >>> n = 295147905179352891391
     >>> float(n)
     2.9514790517935289e+20
     >>> n - long(float(n))
     -1L

  (Implementada por Mark Dickinson; bpo-3166.)

  A divisão inteira também é mais precisa em seus comportamentos de
  arredondamento. (Também implementada por Mark Dickinson; bpo-1811.)

* A coerção implícita para números complexos foi removida; o
  interpretador nunca mais tentará chamar um método "__coerce__()" em
  objetos complexos. (Removido por Meador Inge e Mark Dickinson;
  bpo-5211.)

* O método "str.format()" agora tem suporte à numeração automática dos
  campos de substituição. Isso torna o uso de "str.format()" mais
  parecido com o uso da formatação "%s":

     >>> '{}:{}:{}'.format(2009, 04, 'Sunday')
     '2009:4:Sunday'
     >>> '{}:{}:{day}'.format(2009, 4, day='Sunday')
     '2009:4:Sunday'

  A numeração automática leva os campos da esquerda para a direita,
  então o primeiro especificador "{...}" usará o primeiro argumento
  para "str.format()", o próximo especificador usará o próximo
  argumento e breve. Você não pode misturar a numeração automática e a
  numeração explícita -- numerar todos os seus campos especificadores
  ou nenhum deles -- mas você pode misturar a numeração automática e
  os campos nomeados, como no segundo exemplo acima. (Contribuição de
  Eric Smith; bpo-5237.)

  Números complexos agora suportam corretamente o uso com "format()",
  e o padrão é alinhamento à direita. A especificação de uma precisão
  ou separação por vírgula aplica-se às partes reais e imaginárias do
  número, mas uma largura de campo e alinhamento especificados são
  aplicados a toda a saída "1.5+3j" resultante. (Contribuição de Eric
  Smith; bpo-1588 e bpo-7988.)

  O código de formato 'F' agora sempre formata sua saída usando
  caracteres maiúsculos, então agora produzirá 'INF' e 'NAN'.
  (Contribuição de Eric Smith; bpo-3382.)

  Uma alteração de baixo nível: o método "object.__format__()" agora
  aciona um "PendingDeprecationWarning" se for passado uma string de
  formato, porque o método "__format__()" para "object" converte o
  objeto para uma representação de string e formata isso.
  Anteriormente, o método aplicava silenciosamente a string de formato
  à representação da string, mas isso poderia ocultar erros no código
  Python. Se você estiver fornecendo informações de formatação, como
  alinhamento ou precisão, presumivelmente espera que a formatação
  seja aplicada de alguma maneira específica do objeto. (Correção de
  Eric Smith; bpo-7994.)

* Os tipos "int()" e "long()" ganharam um método "bit_length" que
  retorna o número de bits necessários para representar seu argumento
  em binário:

     >>> n = 37
     >>> bin(n)
     '0b100101'
     >>> n.bit_length()
     6
     >>> n = 2**123-1
     >>> n.bit_length()
     123
     >>> (n+1).bit_length()
     124

  (Contribuição de Fredrik Johansson e Victor Stinner; bpo-3439.)

* A instrução "import" não tentará mais uma importação absoluta se uma
  importação relativa (por exemplo, "from .os import sep") falhar.
  Isso corrige um bug, mas pode possivelmente quebrar certas
  instruções "import" que estavam funcionando apenas por acidente.
  (Correção de Meador Inge; bpo-7902.)

* Agora é possível para uma subclasse do tipo embutido "unicode"
  substituir o método "__unicode__()". (Implementado por Victor
  Stinner; bpo-1583863.)

* O método "translate()" do tipo "bytearray" agora aceita "None" como
  seu primeiro argumento. (Correção de Georg Brandl; bpo-4759.)

* Ao usar "@classmethod" e "@staticmethod" para agrupar métodos como
  classe ou métodos estáticos, o objeto wrapper agora expõe a função
  agrupada como seu atributo "__func__". (Contribuição de Amaury
  Forgeot d'Arc, após sugestão de George Sakkis; bpo-5982.)

* Quando um conjunto restrito de atributos foi definido usando
  "__slots__", excluir um atributo não definido não levantaria
  "AttributeError" como seria de esperar. Correção de Benjamin
  Peterson; bpo-7604.)

* Duas novas codificações agora são suportadas: "cp720", usado
  principalmente para texto em árabe; e "cp858", uma variante do CP
  850 que adiciona o símbolo do euro. (CP720 foi contribuição de
  Alexander Belchenko e Amaury Forgeot d'Arc em bpo-1616979; CP858 foi
  contribuição de Tim Hatch em bpo-8016.)

* O objeto "file" agora definirá o atributo "filename" na exceção
  "IOError" ao tentar abrir um diretório em plataformas POSIX
  (observado por Jan Kaliszewski; bpo-4764) , e agora verifica
  explicitamente e proíbe a gravação em objetos arquivo somente
  leitura em vez de confiar na biblioteca C para detectar e relatar o
  erro (correção de Stefan Krah; bpo-5677).

* O tokenizador do Python agora traduz as próprias terminações de
  linha, então a função embutida "compile()" agora aceita código
  usando qualquer convenção de terminação de linha. Além disso, não
  requer mais que o código termine em uma nova linha.

* Parênteses extras em definições de função são ilegais no Python 3.x,
  o que significa que você obtém um erro de sintaxe de "def f((x)):
  pass". No modo de aviso do Python3, o Python 2.7 agora avisará sobre
  esse uso estranho. (Notado por James Lingard; bpo-7362.)

* Agora é possível criar referências fracas para objetos de classe de
  estilo antigo. As classes de novo estilo sempre tiveram referências
  fracas. (Correção de Antoine Pitrou; bpo-8268.)

* Quando um objeto de módulo é coletado como lixo, o dicionário do
  módulo agora só é limpo se ninguém mais estiver mantendo uma
  referência ao dicionário (bpo-7140).


Alterações no interpretador
---------------------------

Uma nova variável de ambiente, "PYTHONWARNINGS", permite controlar os
avisos. Deve ser definido como uma string contendo configurações de
aviso, equivalentes àquelas usadas com a opção "-W", separadas por
vírgulas. (Contribuição de Brian Curtin; bpo-7301.)

Por exemplo, a configuração a seguir imprimirá avisos toda vez que
ocorrerem, mas transformará os avisos do módulo "Cookie" em um erro.
(A sintaxe exata para definir uma variável de ambiente varia entre
sistemas operacionais e shells.)

   export PYTHONWARNINGS=all,error:::Cookie:0


Otimizações
-----------

Vários aprimoramentos de desempenho foram adicionados:

* Um novo opcode foi adicionado para executar a configuração inicial
  das instruções "with", procurando os métodos "__enter__()" e
  "__exit__()". (Contribuição de Benjamin Peterson.)

* O coletor de lixo agora funciona melhor para um padrão de uso comum:
  quando muitos objetos estão sendo alocados sem desalocar nenhum
  deles. Anteriormente, isso levaria um tempo quadrático para coleta
  de lixo, mas agora o número de coletas de lixo completas é reduzido
  à medida que o número de objetos no heap aumenta. A nova lógica só
  executa uma passagem completa de coleta de lixo quando a geração
  intermediária tiver sido coletada 10 vezes e quando o número de
  objetos sobreviventes da geração intermediária exceder 10% do número
  de objetos da geração mais antiga. (Sugerido por Martin von Löwis e
  implementado por Antoine Pitrou; bpo-4074.)

* O coletor de lixo tenta evitar o rastreamento de contêineres simples
  que não podem fazer parte de um ciclo. No Python 2.7, isso agora é
  verdade para tuplas e dicts contendo tipos atômicos (como ints,
  strings, etc.). Transitivamente, um dict contendo tuplas de tipos
  atômicos também não será rastreado. Isso ajuda a reduzir o custo de
  cada coleta de lixo diminuindo o número de objetos a serem
  considerados e percorridos pelo coletor. (Contribuição de Antoine
  Pitrou; bpo-4688.)

* Inteiros longos agora são armazenados internamente na base "2**15"
  ou na base "2**30", sendo a base determinada no momento da
  compilação. Anteriormente, eles eram sempre armazenados na base
  "2**15". O uso de base "2**30" oferece melhorias significativas de
  desempenho em máquinas de 64 bits, mas os resultados de benchmark em
  máquinas de 32 bits foram mistos. Portanto, o padrão é usar base
  "2**30" em máquinas de 64 bits e base "2**15" em máquinas de 32
  bits; no Unix, há uma nova opção de configuração "--enable-big-
  digits" que pode ser usada para substituir esse padrão.

  Além das melhorias de desempenho, essa alteração deve ser invisível
  para os usuários finais, com uma exceção: para fins de teste e
  depuração, há um novo structseq "sys.long_info" que fornece
  informações sobre o formato interno, fornecendo o número de bits por
  dígito e o tamanho em bytes do tipo C usado para armazenar cada
  dígito:

     >>> import sys
     >>> sys.long_info
     sys.long_info(bits_per_digit=30, sizeof_digit=4)

  (Contributed by Mark Dickinson; bpo-4258.)

  Outro conjunto de alterações tornou os objetos longos alguns bytes
  menores: 2 bytes menores em sistemas de 32 bits e 6 bytes em
  sistemas de 64 bits. (Contribuição de Mark Dickinson; bpo-5260.)

* O algoritmo de divisão para números inteiros longos ficou mais
  rápido apertando o laço interno, fazendo deslocamentos em vez de
  multiplicações e corrigindo uma iteração extra desnecessária. Vários
  benchmarks mostram acelerações entre 50% e 150% para divisões
  inteiras longas e operações de módulo. (Contribuição de Mark
  Dickinson; bpo-5512.) Operações bit a bit também são
  significativamente mais rápidas (patch inicial de Gregory Smith;
  bpo-1087418).

* A implementação de "%" verifica se o operando do lado esquerdo é uma
  string Python e usa casos especiais; isso resulta em um aumento de
  desempenho de 1 a 3% para aplicativos que usam frequentemente "%"
  com strings, como templates em bibliotecas. (Implementação de Collin
  Winter; bpo-5176.)

* Compreensões de lista com uma condição "if" são compiladas em
  bytecode mais rápido. (Patch de Antoine Pitrou, retroportado para
  2.7 por Jeffrey Yasskin; bpo-4715.)

* A conversão de um inteiro ou inteiro longo em uma string decimal
  ficou mais rápida com o uso de maiúsculas e minúsculas especiais na
  base 10, em vez de usar uma função de conversão generalizada que
  oferece suporte a bases arbitrárias. (Patch por Gawain Bolton;
  bpo-6713.)

* Os métodos "split()", "replace()", "rindex()", "rpartition()" e
  "rsplit()" de tipos semelhantes a strings (strings, Strings Unicode
  e objetos "bytearray") agora usam um algoritmo de pesquisa reversa
  rápida em vez de uma varredura caractere por caractere. Às vezes,
  isso é mais rápido por um fator de 10. (Adicionado por Florent
  Xicluna; bpo-7462 e bpo-7622.)

* Os módulos "pickle" e "cPickle" agora internalizam automaticamente
  as strings usadas para nomes de atributos, reduzindo o uso de
  memória dos objetos resultantes da desserialização com pickle.
  (Contribuição de Jake McGuire; bpo-5084.)

* O módulo "cPickle" agora usa dicionários de casos especiais,
  reduzindo quase pela metade o tempo necessário para serializá-los
  com pickle. (Contribuição de Collin Winter; bpo-5670.)


Módulos Novos ou Aprimorados
============================

Como em todas os lançamentos, a biblioteca padrão do Python recebeu
diversas melhorias e correções de bugs. Aqui está uma lista parcial
das mudanças mais notáveis, classificadas em ordem alfabética por nome
do módulo. Consulte o arquivo "Misc/NEWS" na árvore de código-fonte
para uma lista mais completa de alterações, ou procure nos logs do
Subversion para todos os detalhes.

* A classe de depuração base do módulo "bdb" "Bdb" ganhou um recurso
  para pular módulos. O construtor agora usa um iterável contendo
  padrões estilo glob como "django.*"; o depurador não entrará nos
  quadros de pilha de um módulo que corresponda a um desses padrões.
  (Contribuição de Maru Newby após sugestão de Senthil Kumaran;
  bpo-5142.)

* O módulo "binascii" agora oferece suporte à API de buffer, então ele
  pode ser usado com instâncias "memoryview" e outros objetos buffer
  similares. (Backport de 3.x por Florent Xicluna; bpo-7703.)

* Módulo atualizado: o módulo "bsddb" foi atualizado de 4.7.2devel9
  para a versão 4.8.4 do pacote pybsddb. A nova versão apresenta
  melhor compatibilidade com Python 3.x, várias correções de bugs e
  adiciona vários novos sinalizadores e métodos BerkeleyDB.
  (Atualizado por Jesús Cea Avión; bpo-8156. O changelog do pybsddb
  pode ser lido em https://hg.jcea.es/pybsddb/file/tip/ChangeLog.)

* O "BZ2File" do módulo "bz2" agora oferece suporte ao protocolo de
  gerenciamento de contexto, então você pode escrever "with
  bz2.BZ2File(...) as f:". (Contribuição de Hagen Fürstenau;
  bpo-3860.)

* Nova classe: a classe "Counter" no módulo "collections" é útil para
  contabilizar dados. As instâncias "Counter" se comportam
  principalmente como dicionários, mas retornam zero para chaves
  ausentes em vez de levantar uma exceção "KeyError":

     >>> from collections import Counter
     >>> c = Counter()
     >>> for letter in 'here is a sample of english text':
     ...   c[letter] += 1
     ...
     >>> c 
     Counter({' ': 6, 'e': 5, 's': 3, 'a': 2, 'i': 2, 'h': 2,
     'l': 2, 't': 2, 'g': 1, 'f': 1, 'm': 1, 'o': 1, 'n': 1,
     'p': 1, 'r': 1, 'x': 1})
     >>> c['e']
     5
     >>> c['z']
     0

  Existem três métodos "Counter" adicionais. "most_common()" retorna
  os N elementos mais comuns e suas contagens. "elements()" retorna um
  iterador sobre os elementos contidos, repetindo cada elemento tantas
  vezes quanto sua contagem. "subtract()" pega um iterável e subtrai
  um para cada elemento em vez de adicionar; se o argumento for um
  dicionário ou outro "Counter", as contagens são subtraídas.

     >>> c.most_common(5)
     [(' ', 6), ('e', 5), ('s', 3), ('a', 2), ('i', 2)]
     >>> c.elements() ->
        'a', 'a', ' ', ' ', ' ', ' ', ' ', ' ',
        'e', 'e', 'e', 'e', 'e', 'g', 'f', 'i', 'i',
        'h', 'h', 'm', 'l', 'l', 'o', 'n', 'p', 's',
        's', 's', 'r', 't', 't', 'x'
     >>> c['e']
     5
     >>> c.subtract('very heavy on the letter e')
     >>> c['e']    # Count is now lower
     -1

  Contribuição de Raymond Hettinger; bpo-1696199.

  Nova classe: "OrderedDict" é descrita na seção anterior PEP 372:
  Adicionando um dicionário ordenado a coleções.

  Novo método: O tipo de dados "deque" agora tem um método "count()"
  que retorna o número de elementos contidos igual ao argumento
  fornecido *x*, e um "reverse()" método que inverte os elementos do
  deque no local. "deque" também expõe seu comprimento máximo como o
  atributo somente leitura "maxlen". (Ambos os recursos adicionados
  por Raymond Hettinger.)

  A classe "namedtuple" agora possui um parâmetro opcional *rename*.
  Se *rename* for verdadeiro, os nomes de campos inválidos porque
  foram repetidos ou não são identificadores Python legais serão
  renomeados para nomes legais derivados da posição do campo na lista
  de campos:

  >>> from collections import namedtuple
  >>> T = namedtuple('T', ['field1', '$illegal', 'for', 'field2'], rename=True)
  >>> T._fields
  ('field1', '_1', '_2', 'field2')

  (Adição de Raymond Hettinger; bpo-1818.)

  Finalmente, a classe base abstrata "Mapping" agora retorna
  "NotImplemented" se um mapeamento for comparado a outro tipo que não
  seja um "Mapping". (Correção de Daniel Stutzbach; bpo-8729.)

* Construtores para as classes de análise no módulo "ConfigParser"
  agora recebem um parâmetro *allow_no_value*, cujo padrão é false; se
  verdadeiro, opções sem valores serão permitidas. Por exemplo:

     >>> import ConfigParser, StringIO
     >>> sample_config = """
     ... [mysqld]
     ... user = mysql
     ... pid-file = /var/run/mysqld/mysqld.pid
     ... skip-bdb
     ... """
     >>> config = ConfigParser.RawConfigParser(allow_no_value=True)
     >>> config.readfp(StringIO.StringIO(sample_config))
     >>> config.get('mysqld', 'user')
     'mysql'
     >>> print config.get('mysqld', 'skip-bdb')
     None
     >>> print config.get('mysqld', 'unknown')
     Traceback (most recent call last):
       ...
     NoOptionError: No option 'unknown' in section: 'mysqld'

  (Contribuição de Mats Kindahl; bpo-7005.)

* Função descontinuada: "contextlib.nested()", que permite lidar com
  mais de um gerenciador de contexto com uma única instrução "with",
  foi descontinuada porque a instrução "with" agora oferece suporte a
  múltiplos contextos gerentes.

* O módulo "cookielib" agora ignora cookies que possuem um campo de
  versão inválido, que não contém um valor inteiro. (Correção de John
  J. Lee; bpo-3924.)

* A função "deepcopy()" do módulo "copy" agora copiará corretamente os
  métodos de instância vinculados. (Implementado por Robert Collins;
  bpo-1515.)

* O módulo "ctypes" agora sempre converte "None" em um ponteiro C
  "NULL" para argumentos declarados como ponteiros. (Alterado por
  Thomas Heller; bpo-4606.) A biblioteca libffi subjacente foi
  atualizada para a versão 3.0.9, contendo várias correções para
  diferentes plataformas. (Atualizado por Matthias Klose; bpo-8142.)

* Novo método: a classe "timedelta" do módulo "datetime" ganhou um
  método "total_seconds()" que retorna o número de segundos na
  duração. (Contribuição de Brian Quinlan; bpo-5788.)

* Novo método: a classe "Decimal" ganhou um método de classe
  "from_float()" que realiza uma conversão exata de um número de ponto
  flutuante para um "Decimal". Essa conversão exata busca a maior
  aproximação decimal do valor da representação de ponto flutuante; o
  valor decimal resultante ainda incluirá a imprecisão, se houver. Por
  exemplo, "Decimal.from_float(0.1)" retorna "Decimal('0.100000000000
  0000055511151231257827021181583404541015625')". (Implementado por
  Raymond Hettinger; bpo-4796.)

  Comparar instâncias de "Decimal" com números de ponto flutuante
  agora produz resultados sensatos com base nos valores numéricos dos
  operandos. Anteriormente, essas comparações recorreriam às regras
  padrão do Python para comparar objetos, que produziam resultados
  arbitrários com base em seu tipo. Observe que você ainda não pode
  combinar "Decimal" e ponto flutuante em outras operações, como
  adição, já que você deve escolher explicitamente como converter
  entre float e "Decimal". (Corrigido por Mark Dickinson; bpo-2531.)

  O construtor para "Decimal" agora aceita números de ponto flutuante
  (adicionados por Raymond Hettinger; bpo-8257) e caracteres Unicode
  não europeus, como dígitos árabe-índicos (contribuição de Mark
  Dickinson; bpo-6595).

  A maioria dos métodos da classe "Context" agora aceitam números
  inteiros, bem como instâncias "Decimal"; as únicas exceções são os
  métodos "canonical()" e "is_canonical()". (Patch de Juan José Conti;
  bpo-7633.)

  Ao usar instâncias "Decimal" com o método "format()" de uma string,
  o alinhamento padrão era anteriormente o alinhamento à esquerda.
  Isso foi alterado para alinhamento à direita, que é mais sensato
  para tipos numéricos. (Alteração de Mark Dickinson; bpo-6857.)

  Comparações envolvendo um valor NaN de sinalização (ou "sNAN") agora
  sinalizam "InvalidOperation" em vez de retornar silenciosamente um
  valor verdadeiro ou falso dependendo do operador de comparação.
  Valores silenciosos de NaN (ou "NaN") agora são hasheáveis.
  (Corrigido por Mark Dickinson; bpo-7279.)

* O módulo "difflib" agora produz uma saída que é mais compatível com
  as ferramentas **diff**/**patch** modernas através de uma pequena
  mudança, usando um caractere de tabulação em vez de espaços como
  separador no cabeçalho, fornecendo o nome do arquivo. (Correção de
  Anatoly Techtonik; bpo-7585.)

* O comando Distutils "sdist" agora sempre regenera o arquivo
  "MANIFEST", pois mesmo que os arquivos "MANIFEST.in" ou "setup.py"
  não tenham sido modificados, o usuário pode ter criado alguns novos
  arquivos que deveriam ser incluídos. (Correção de Tarek Ziadé;
  bpo-8688.)

* O sinalizador "IGNORE_EXCEPTION_DETAIL" do módulo "doctest" irá
  agora ignorar o nome do módulo que contém a exceção que está sendo
  testada. (Patch de Lennart Regebro; bpo-7490.)

* A classe "Message" do módulo "email" agora aceitará uma carga útil
  com valor Unicode, convertendo automaticamente a carga útil para a
  codificação especificada por "output_charset". (Adição de R. David
  Murray; bpo-1368247.)

* A classe "Fraction" agora aceita uma única instância float ou
  "Decimal", ou dois números racionais, como argumentos para seu
  construtor. (Implementação de Mark Dickinson; racionais adicionados
  em bpo-5812 e float/decimal em bpo-8294.)

  Ordenar comparações ("<", "<=", ">", ">=") entre frações e números
  complexos agora levanta um "TypeError". Isso corrige um descuido,
  fazendo com que "Fraction" corresponda aos outros tipos numéricos.

* Nova classe: "FTP_TLS" no módulo "ftplib" fornece conexões FTP
  seguras usando encapsulamento TLS de autenticação, bem como controle
  subsequente e transferências de dados. (Contribuição de Giampaolo
  Rodola; bpo-2054.)

  O método "storbinary()" para envios de binários agora pode reiniciar
  envios graças a um parâmetro *rest* adicionado (patch de Pablo
  Mouzo; bpo-6845.)

* Novo decorador de classe: "total_ordering()" no módulo "functools"
  pega uma classe que define um método "__eq__()" e um de "__lt__()" ,
  "__le__()", "__gt__()" ou "__ge__()" e gera os métodos de comparação
  ausentes. Como o método "__cmp__()" está sendo descontinuado no
  Python 3.x, esse decorador facilita a definição de classes
  ordenadas. (Adicionado por Raymond Hettinger; bpo-5479.)

  Nova função: "cmp_to_key()" usará uma função de comparação de estilo
  antigo que espera dois argumentos e retornará um novo chamável que
  pode ser usado como parâmetro *key* para funções como "sorted()",
  "min()" e "max()", etc. O principal uso pretendido é ajudar a tornar
  o código compatível com Python 3.x. (Adição de Raymond Hettinger.)

* Nova função: o "is_tracked()" do módulo "gc" retorna verdadeiro se
  uma determinada instância for rastreada pelo coletor de lixo, falso
  caso contrário. (Contribuição de Antoine Pitrou; bpo-4688)

* O "GzipFile" do módulo "gzip" agora oferece suporte ao protocolo de
  gerenciamento de contexto, então você pode escrever "with
  gzip.GzipFile(...) as f:" (contribuição de Hagen Fürstenau;
  bpo-3860), e agora implementa o "io.BufferedIOBase" ABC, então você
  pode envolvê-lo com "io.BufferedReader" para processamento mais
  rápido (contribuição de Nir Aides; bpo-7471). Agora também é
  possível substituir o horário de modificação registrado em um
  arquivo compactado, fornecendo um registro de data e hora opcional
  ao construtor. (Contribuição de Jacques Frechet; bpo-4272.)

  Arquivos no formato gzip podem ser preenchidos com zero bytes à
  direita; o módulo "gzip" agora consumirá esses bytes finais.
  (Correção de Tadek Pietraszek e Brian Curtin; bpo-2846.)

* Novo atributo: o módulo "hashlib" agora possui um atributo
  "algorithms" contendo uma tupla nomeando os algoritmos suportados.
  No Python 2.7, "hashlib.algorithms" contém "('md5', 'sha1',
  'sha224', 'sha256', 'sha384', 'sha512')". (Contribuição de Carl
  Chenet; bpo-7418.)

* A classe padrão "HTTPResponse" usada pelo módulo "httplib" agora
  oferece suporte a buffering, resultando em uma leitura muito mais
  rápida de respostas HTTP. (Contribuição de Kristján Valur Jónsson;
  bpo-4879.)

  As classes "HTTPConnection" e "HTTPSConnection" agora oferecem
  suporte a um parâmetro *source_address*, uma tupla de 2 elementos
  "(host, port)" fornecendo o endereço de origem que será usado para a
  conexão. (Contribuição de Eldon Ziegler; bpo-3972.)

* O módulo "ihooks" agora oferece suporte a importações relativas.
  Observe que "ihooks" é um módulo mais antigo para personalizar
  importações, substituído pelo módulo "imputil" adicionado no Python
  2.0. (Suporte relativo à importação adicionado por Neil
  Schemenauer.)

* O módulo "imaplib" agora oferece suporte a endereços IPv6.
  (Contribuição de Derek Morr; bpo-1655.)

* Nova função: "getcallargs()" do módulo "inspect" pega um chamável e
  seus argumentos nomeados e posicionais, e descobre quais dos
  parâmetros do chamável receberão cada argumento, retornando um
  dicionário mapeando nomes de argumentos para seus valores. Por
  exemplo:

     >>> from inspect import getcallargs
     >>> def f(a, b=1, *pos, **named):
     ...     pass
     >>> getcallargs(f, 1, 2, 3)
     {'a': 1, 'b': 2, 'pos': (3,), 'named': {}}
     >>> getcallargs(f, a=2, x=4)
     {'a': 2, 'b': 1, 'pos': (), 'named': {'x': 4}}
     >>> getcallargs(f)
     Traceback (most recent call last):
     ...
     TypeError: f() takes at least 1 argument (0 given)

  Contribuição de George Sakkis; bpo-3135.

* Módulo atualizado: A biblioteca "io" foi atualizada para a versão
  fornecida com Python 3.1. Para 3.1, a biblioteca de E/S foi
  totalmente reescrita em C e é de 2 a 20 vezes mais rápida dependendo
  da tarefa que está sendo executada. A versão original do Python foi
  renomeada para o módulo "_pyio".

  Uma pequena mudança resultante: a classe "io.TextIOBase" agora tem
  um atributo "errors" fornecendo a configuração de erro usada para
  erros de codificação e decodificação (um dos "'strict'" ,
  "'replace'", "'ignore'").

  A classe "io.FileIO" agora levanta uma exceção "OSError" quando
  passa um descritor de arquivo inválido. (Implementado por Benjamin
  Peterson; bpo-4991.) O método "truncate()" agora preserva a posição
  do arquivo; anteriormente, mudaria a posição do arquivo para o final
  do novo arquivo. (Correção de Pascal Chambon; bpo-6939.)

* Nova função: "itertools.compress(data, selectors)" aceita dois
  iteradores. Elementos de *data* serão retornados se o valor
  correspondente em *selectors* for verdadeiro:

     itertools.compress('ABCDEF', [1,0,1,0,1,1]) =>
       A, C, E, F

  Nova função: "itertools.combinations_with_replacement(iter, r)"
  retorna todas as combinações possíveis de elementos de comprimento
  *r* do *iter* iterável. Ao contrário de "combinations()", elementos
  individuais podem ser repetidos nas combinações geradas:

     itertools.combinations_with_replacement('abc', 2) =>
       ('a', 'a'), ('a', 'b'), ('a', 'c'),
       ('b', 'b'), ('b', 'c'), ('c', 'c')

  Observe que os elementos são tratados como únicos dependendo de sua
  posição na entrada, não de seus valores reais.

  A função "itertools.count()" agora tem um argumento *step* que
  permite incrementar por valores diferentes de 1. "count()" agora
  também permite argumentos nomeados e o uso de valores não inteiros,
  como floats ou "Decimal" instâncias. (Implementação de Raymond
  Hettinger; bpo-5032.)

  "itertools.combinations()" e "itertools.product()" anteriormente
  levantavam "ValueError" para valores de *r* maiores que o iterável
  de entrada. Isto foi considerado um erro de especificação, então
  agora elas retornam um iterador vazio. (Corrigido por Raymond
  Hettinger; bpo-4816.)

* Módulo atualizado: O módulo "json" foi atualizado para a versão
  2.0.9 do pacote simplejson, que inclui uma extensão C que torna a
  codificação e decodificação mais rápidas. (Contribuição de Bob
  Ippolito; bpo-4136.)

  Para oferecer suporte ao novo tipo "collections.OrderedDict",
  "json.load()" agora tem um parâmetro opcional *object_pairs_hook*
  que será chamado com qualquer literal de objeto que decodifica para
  uma lista de pares. (Contribuição de Raymond Hettinger; bpo-5381.)

* A classe "Maildir" do módulo "mailbox" agora registra o registro de
  data e hora nos diretórios que lê, e apenas os relê se o horário de
  modificação for alterado posteriormente. Isso melhora o desempenho,
  evitando varreduras de diretório desnecessárias. (Corrigido por AM
  Kuchling e Antoine Pitrou; bpo-1607951, bpo-6896.)

* Novas funções: o módulo "math" ganhou "erf()" e "erfc()" para a
  função de erro e a função de erro complementar, "expm1()" que
  calcula "e**x - 1" com mais precisão do que usar "exp()" e subtrair
  1, "gamma()" para a função Gamma, e "lgamma()" para o log natural da
  função Gamma. (Contribuição de Mark Dickinson e nirinA raseliarison;
  bpo-3366.)

* As classes "Manager*" do módulo "multiprocessing" agora podem
  receber um chamável que será chamado sempre que um subprocesso for
  iniciado, junto com um conjunto de argumentos que serão passados
  para o chamável. (Contribuição de lekma; bpo-5585.)

  A classe "Pool", que controla um conjunto de processos de trabalho,
  agora possui um parâmetro opcional *maxtasksperchild*. Os processos
  de trabalho executarão o número especificado de tarefas e então
  sairão, fazendo com que "Pool" inicie um novo trabalhador. Isso é
  útil se as tarefas puderem vazar memória ou outros recursos, ou se
  algumas tarefas fizerem com que o trabalho fique muito grande.
  (Contribuição de Charles Cazabon; bpo-6963.)

* O módulo "nntplib" agora oferece suporte para endereços IPv6.
  (Contribuição de Derek Morr; bpo-1664.)

* Novas funções: o módulo "os" envolve as seguintes chamadas de
  sistema POSIX: "getresgid()" e "getresuid()", que retornam os GIDs e
  UIDs reais, efetivos e salvos ; "setresgid()" e "setresuid()", que
  definem GIDs e UIDs reais, efetivos e salvos para novos valores;
  "initgroups()", que inicializa a lista de acesso do grupo para o
  processo atual. (Funções GID/UID foram contribuição de Travis H.;
  bpo-6508. Suporte para initgroups adicionado por Jean-Paul
  Calderone; bpo-7333.)

  A função "os.fork()" agora reinicializa a trava de importação no
  processo filho; isso corrige problemas no Solaris quando "fork()" é
  chamado de um thread. (Correção de Zsolt Cserna; bpo-7242.)

* No módulo "os.path", as funções "normpath()" e "abspath()" agora
  preservam o Unicode; se o caminho de entrada for uma string Unicode,
  o valor de retorno também será uma string Unicode. ("normpath()"
  corrigido por Matt Giuca em bpo-5827; "abspath()" corrigido por Ezio
  Melotti em bpo-3426.)

* O módulo "pydoc" agora tem ajuda para os vários símbolos que o
  Python usa. Agora você pode fazer "help('<<')" ou "help('@')", por
  exemplo. (Contribuição de David Laban; bpo-4739.)

* Os módulos "re" "split()", "sub()" e "subn()" agora aceitam um
  argumento opcional *flags*, para consistência com as outras funções
  do módulo. (Adição de Gregory P. Smith.)

* Nova função: "run_path()" no módulo "runpy" executará o código em um
  argumento *path* fornecido. *path* pode ser o caminho de um arquivo
  fonte Python ("example.py"), um arquivo de bytecode compilado
  ("example.pyc"), um diretório ("./package/") ou um arquivo zip
  ("example.zip"). Se um diretório ou zip path for fornecido, ele será
  adicionado na frente de "sys.path" e o módulo "__main__" será
  importado. É esperado que o diretório ou zip contenha um
  "__main__.py"; caso contrário, algum outro "__main__.py" poderá ser
  importado de um local posteriormente em "sys.path". Isso torna mais
  o maquinário de "runpy" disponível para scripts que desejam imitar a
  maneira como a linha de comando do Python processa um nome de
  caminho explícito. (Adição de Nick Coghlan; bpo-6816.)

* Nova função: no módulo "shutil", "make_archive()" pega um nome de
  arquivo, tipo de arquivo (formato zip ou tar) e um caminho de
  diretório, e cria um arquivo contendo o conteúdo do diretório.
  (Adição de Tarek Ziadé.)

  As funções "copyfile()" e "copytree()" de "shutil" agora levantam
  uma exceção "SpecialFileError" quando solicitado a copiar um
  encadeamento nomeado. Anteriormente, o código trataria pipes
  nomeados como um arquivo normal, abrindo-os para leitura, e isso
  seria bloqueado indefinidamente. (Correção de Antoine Pitrou;
  bpo-3002.)

* O módulo "signal" não reinstala mais o manipulador de sinal a menos
  que isso seja realmente necessário, o que corrige um bug que poderia
  tornar impossível capturar o sinal EINTR de forma robusta. (Correção
  de Charles-François Natali; bpo-8354.)

* Novas funções: no módulo "site", três novas funções retornam vários
  caminhos específicos do site e do usuário. "getsitepackages()"
  retorna uma lista contendo todos os diretórios globais de pacotes de
  sites, "getusersitepackages()" retorna o caminho do diretório de
  pacotes de sites do usuário e "getuserbase()" retorna o valor da
  variável de ambiente "USER_BASE", fornecendo o caminho para um
  diretório que pode ser usado para armazenar dados. (Contribuição de
  Tarek Ziadé; bpo-6693.)

  O módulo "site" agora reporta exceções que ocorrem quando o módulo
  "sitecustomize" é importado, e não irá mais capturar e engolir a
  exceção "KeyboardInterrupt". (Correção de Victor Stinner; bpo-3137.)

* A função "create_connection()" ganhou um parâmetro *source_address*,
  uma tupla de 2 elementos "(host, port)" fornecendo o endereço de
  origem que será usado para a conexão. (Contribuição de Eldon
  Ziegler; bpo-3972.)

  Os métodos "recv_into()" e "recvfrom_into()" agora escreverão em
  objetos que oferecem suporte à API de buffer, mais utilmente objetos
  "bytearray" e "memoryview". (Implementação de Antoine Pitrou;
  bpo-8104.)

* A classe "TCPServer" do módulo "SocketServer" agora oferece suporte
  a limite de tempo de soquete e desativação do algoritmo Nagle. O
  atributo de classe "disable_nagle_algorithm" é padronizado como
  "False"; se substituído como verdadeiro, novas conexões de
  solicitação terão a opção TCP_NODELAY definida para evitar o
  armazenamento em buffer de muitos envios pequenos em um único pacote
  TCP. O atributo de classe "timeout" pode conter um tempo limite em
  segundos que será aplicado ao soquete de solicitação; se nenhuma
  solicitação for recebida dentro desse tempo, "handle_timeout()" será
  chamado e "handle_request()" retornará. (Contribuição de Kristján
  Valur Jónsson; bpo-6192 e bpo-6267.)

* Módulo atualizado: o módulo "sqlite3" foi atualizado para a versão
  2.6.0 do pacote pysqlite. A versão 2.6.0 inclui uma série de
  correções de bugs e adiciona a capacidade de carregar extensões
  SQLite de bibliotecas compartilhadas. Chame o método
  "enable_load_extension(True)" para habilitar extensões, e então
  chame "load_extension()" para carregar uma biblioteca compartilhada
  específica. (Atualização de Gerhard Häring.)

* Os objetos "SSLSocket" do módulo "ssl" agora oferecem suporte à API
  de buffer, que corrigiu uma falha na suíte de testes (correção de
  Antoine Pitrou; bpo-7133) e definiu automaticamente
  "SSL_MODE_AUTO_RETRY" do OpenSSL, que impedirá que um código de erro
  seja retornado de operações "recv()" que acionam uma renegociação
  SSL (correção por Antoine Pitrou; bpo-8222).

  A função construtora "wrap_socket()" agora recebe um argumento
  *ciphers* que é uma string listando os algoritmos de criptografia a
  serem permitidos; o formato da string é descrito na documentação do
  OpenSSL. (Adição de Antoine Pitrou; bpo-8322.)

  Outra mudança faz com que a extensão carregue todas as cifras e
  algoritmos de resumo do OpenSSL para que estejam todos disponíveis.
  Não foi possível verificar alguns certificados SSL, reportando um
  erro de "algoritmo desconhecido". (Relato de Beda Kosata e correção
  de Antoine Pitrou; bpo-8484.)

  A versão do OpenSSL usada agora está disponível como os atributos do
  módulo "ssl.OPENSSL_VERSION" (uma string),
  "ssl.OPENSSL_VERSION_INFO" (uma tupla de 5) e
  "ssl.OPENSSL_VERSION_NUMBER" (um número inteiro). (Adição de Antoine
  Pitrou; bpo-8321.)

* O módulo "struct" não irá mais ignorar silenciosamente erros de
  overflow quando um valor for muito grande para um código de formato
  inteiro específico (um de "bBhHiIlLqQ"); agora sempre levanta uma
  exceção "struct.error". (Alteração de Mark Dickinson; bpo-1523.) A
  função "pack()" também tentará usar "__index__()" para converter e
  empacotar números não inteiros antes de tentar o método "__int__()"
  ou relatar um erro. (Alteração de Mark Dickinson; bpo-8300.)

* Nova função: o "check_output()" do módulo "subprocess" executa um
  comando com um conjunto especificado de argumentos e retorna a saída
  do comando como uma string quando o comando é executado sem erros,
  ou levanta uma exceção "CalledProcessError" caso contrário.

     >>> subprocess.check_output(['df', '-h', '.'])
     'Filesystem     Size   Used  Avail Capacity  Mounted on\n
     /dev/disk0s2    52G    49G   3.0G    94%    /\n'

     >>> subprocess.check_output(['df', '-h', '/bogus'])
       ...
     subprocess.CalledProcessError: Command '['df', '-h', '/bogus']' returned non-zero exit status 1

  (Contribuição de Gregory P. Smith.)

  O módulo "subprocess" agora tentará novamente suas chamadas internas
  do sistema ao receber um sinal "EINTR". (Relato por várias pessoas;
  patch final por Gregory P. Smith em bpo-1068268.)

* Nova função: "is_declared_global()" no módulo "symtable" retorna
  verdadeiro para variáveis que são explicitamente declaradas como
  globais, falso para aquelas que são implicitamente globais.
  (Contribuição de Jeremy Hylton.)

* O módulo "syslog" agora usará o valor de "sys.argv[0]" como
  identificador em vez do valor padrão anterior de "'python'".
  (Alteração de Sean Reifschneider; bpo-8451.)

* O valor "sys.version_info" agora é uma tupla nomeada, com atributos
  chamados "major", "minor", "micro", "releaselevel" e "serial".
  (Contribuição de Ross Light; bpo-4285.)

  "sys.getwindowsversion()" também retorna uma tupla nomeada, com
  atributos chamados "major", "minor", "build", "platform",
  "service_pack", "service_pack_major", "service_pack_minor",
  "suite_mask" e "product_type". (Contribuição de Brian Curtin;
  bpo-7766.)

* O tratamento de erros padrão do módulo "tarfile" foi alterado, para
  não mais suprimir erros fatais. O nível de erro padrão era
  anteriormente 0, o que significava que os erros resultariam apenas
  na gravação de uma mensagem no log de depuração, mas como o log de
  depuração não está ativado por padrão, esses erros passam
  despercebidos. O nível de erro padrão agora é 1, o que levanta uma
  exceção se houver um erro. (Alteração de Lars Gustäbel; bpo-7357.)

  "tarfile" agora oferece suporte à filtragem de objetos "TarInfo"
  sendo adicionados a um arquivo tar. Quando você chama "add()", você
  pode fornecer um argumento *filter* opcional que é chamável. O
  chamável *filter* receberá o "TarInfo" para cada arquivo sendo
  adicionado, e pode modificá-lo e retorná-lo. Se o chamável retornar
  "None", o arquivo será excluído do arquivo resultante. Isto é mais
  poderoso do que o argumento *exclude* existente, que foi, portanto,
  descontinuado. (Adição de Lars Gustäbel; bpo-6856.) A classe
  "TarFile" agora também oferece suporte ao protocolo de gerenciamento
  de contexto. (Adição de Lars Gustäbel; bpo-7232.)

* O método "wait()" da classe "threading.Event" agora retorna o
  sinalizador interno na saída. Isso significa que o método geralmente
  retornará verdadeiro porque "wait()" deve ser bloqueado até que o
  sinalizador interno se torne verdadeiro. O valor de retorno só será
  falso se um tempo limite tiver sido fornecido e a operação tiver
  expirado. (Contribuição de Tim Lesher; bpo-1674032.)

* O banco de dados Unicode fornecido pelo módulo "unicodedata" agora é
  usado internamente para determinar quais caracteres são numéricos,
  espaços em branco ou representam quebras de linha. O banco de dados
  também inclui informações do arquivo de dados "Unihan.txt" (patch de
  Anders Chrigström e Amaury Forgeot d'Arc; bpo-1571184) e foi
  atualizado para a versão 5.2.0 (atualização de Florent Xicluna;
  bpo-8024).

* A função "urlsplit()" do módulo "urlparse" agora lida com esquemas
  de URL desconhecidos de uma forma compatível com **RFC 3986**: se a
  URL estiver no formato ""<alguma_coisa>://..."", o texto antes de
  "://" é tratado como o esquema, mesmo que seja um esquema inventado
  que o módulo não conhece. Essa alteração pode quebrar o código que
  contornava o comportamento antigo. Por exemplo, Python 2.6.4 ou 2.5
  retornará o seguinte:

     >>> import urlparse
     >>> urlparse.urlsplit('invented://host/filename?query')
     ('invented', '', '//host/filename?query', '', '')

  Python 2.7 (e Python 2.6.5) vai retornar:

     >>> import urlparse
     >>> urlparse.urlsplit('invented://host/filename?query')
     ('invented', 'host', '/filename?query', '', '')

  (Na verdade, o Python 2.7 produz uma saída ligeiramente diferente,
  pois retorna uma tupla nomeada em vez de uma tupla padrão.)

  O módulo "urlparse" também oferece suporte a endereços IPv6 literais
  conforme definido pelo **RFC 2732** (contribuição de Senthil
  Kumaran; bpo-2987).

     >>> urlparse.urlparse('http://[1080::8:800:200C:417A]/foo')
     ParseResult(scheme='http', netloc='[1080::8:800:200C:417A]',
                 path='/foo', params='', query='', fragment='')

* Nova classe: a classe "WeakSet" no módulo "weakref" é um conjunto
  que contém apenas referências fracas aos seus elementos; os
  elementos serão removidos quando não houver referências apontando
  para eles. (Originalmente implementado em Python 3.x por Raymond
  Hettinger e portado para 2.7 por Michael Foord.)

* A biblioteca "xml.etree.ElementTree" não escapa mais caracteres de E
  comercial e de sinal de maior e de menor ao gerar uma instrução de
  processamento XML (que se parece com "<?xml-stylesheet
  href="#style1"?>") ou comentário (que se parece com "<!-- comentário
  -->"). (Patch de Neil Muller; bpo-2746.)

* O cliente e servidor de XML-RPC, fornecidos pelos módulos
  "xmlrpclib" e "SimpleXMLRPCServer", melhoraram o desempenho ao
  prover suporte a kep-alive do HTTP/1.1 e, opcionalmente, usando a
  codificação gzip para compactar o XML que está sendo trocado. A
  compactação gzip é controlada pelo atributo "encode_threshold" de
  "SimpleXMLRPCRequestHandler", que contém um tamanho em bytes;
  respostas maiores que isso serão compactadas. (Contribuição de
  Kristján Valur Jónsson; bpo-6267.)

* A classe "ZipFile" do módulo "zipfile" agora oferece suporte ao
  protocolo de gerenciamento de contexto, então você pode escrever
  "with zipfile.ZipFile(...) as f:". (Contribuição de Brian Curtin;
  bpo-5511.)

  "zipfile" agora também oferece suporte ao arquivamento de diretórios
  vazios e os extrai corretamente. (Correção de Kuba Wieczorek;
  bpo-4710.) Ler arquivos de um arquivo é mais rápido e intercalar
  "read()" e "readline()" agora funciona corretamente. (Contribuição
  de Nir Aides; bpo-7610.)

  A função "is_zipfile()" agora aceita um objeto arquivo, além dos
  nomes de caminho aceitos em versões anteriores. (Contribuição de
  Gabriel Genellina; bpo-4756.)

  O método "writestr()" agora tem um parâmetro *compress_type*
  opcional que permite substituir o método de compactação padrão
  especificado no construtor de "ZipFile". (Contribuição de Ronald
  Oussoren; bpo-6003.)


Novo módulo: importlib
----------------------

Python 3.1 inclui o pacote "importlib", uma reimplementação da lógica
subjacente à instrução "import" do Python. "importlib" é útil para
implementadores de interpretadores Python e para usuários que desejam
escrever novos importadores que possam participar do processo de
importação. Python 2.7 não contém o pacote "importlib" completo, mas
em vez disso possui um pequeno subconjunto que contém uma única
função, "import_module()".

"import_module(name, package=None)" importa um módulo. *name* é uma
string contendo o nome do módulo ou pacote. É possível fazer
importações relativas fornecendo uma string que começa com um
caractere ".", como "..utils.errors". Para importações relativas, o
argumento *package* deve ser fornecido e é o nome do pacote que será
usado como âncora para a importação relativa. "import_module()" insere
o módulo importado em "sys.modules" e retorna o objeto do módulo.

Veja alguns exemplos:

   >>> from importlib import import_module
   >>> anydbm = import_module('anydbm')  # Standard absolute import
   >>> anydbm
   <module 'anydbm' from '/p/python/Lib/anydbm.py'>
   >>> # Relative import
   >>> file_util = import_module('..file_util', 'distutils.command')
   >>> file_util
   <module 'distutils.file_util' from '/python/Lib/distutils/file_util.pyc'>

"importlib" foi implementado por Brett Cannon e introduzido no Python
3.1.


Novo módulo: sysconfig
----------------------

O módulo "sysconfig" foi retirado do pacote Distutils, tornando-se um
novo módulo de nível independente. "sysconfig" fornece funções para
obter informações sobre o processo de construção do Python: opções do
compilador, caminhos de instalação, o nome da plataforma e se o Python
está sendo executado a partir de seu diretório de código-fonte.

Algumas das funções do módulo são:

* "get_config_var()" retorna variáveis do Makefile do Python e do
  arquivo "pyconfig.h".

* "get_config_vars()" retorna um dicionário contendo todas as
  variáveis de configuração.

* "get_path()" retorna o caminho configurado para um tipo específico
  de módulo: a biblioteca padrão, módulos específicos do site, módulos
  específicos da plataforma, etc.

* "is_python_build()" retorna verdadeiro se você estiver executando um
  binário de uma árvore de código-fonte em Python, e falso caso
  contrário.

Consulte a documentação do "sysconfig" para mais detalhes e para uma
lista completa de funções.

O pacote Distutils e "sysconfig" agora são mantidos por Tarek Ziadé,
que também iniciou um pacote Distutils2 (repositório fonte em
https://hg.python.org/distutils2/) para desenvolver uma versão de
próxima geração do Distutils.


ttk: Widgets temáticos para Tk
------------------------------

O Tcl/Tk 8.5 inclui um conjunto de widgets temáticos que reimplementam
widgets Tk básicos, mas têm uma aparência mais personalizável e podem,
portanto, se assemelhar mais aos widgets da plataforma nativa. Este
conjunto de widgets foi originalmente chamado de Tile, mas foi
renomeado para Ttk (para "Tk temático") ao ser adicionado ao Tcl/Tck
versão 8.5.

Para saber mais, leia a documentação do módulo "ttk". Você também pode
ler a página de manual do Tcl/Tk que descreve o mecanismo do tema Ttk,
disponível em https://www.tcl.tk/man/tcl8.5/TkCmd/ttk_intro.html.
Algumas capturas de tela do código Python/Ttk em uso estão em
https://code.google.com/archive/p/python-ttk/wikis/Screenshots.wiki.

O módulo "tkinter.ttk" foi escrito por Guilherme Polo e adicionado em
bpo-2983. Uma versão alternativa chamada "Tile.py", escrita por Martin
Franklin e mantida por Kevin Walzer, foi proposta para inclusão em
bpo-2618, mas os autores argumentaram que o trabalho de Guilherme Polo
era mais abrangente.


Módulo atualizado: unittest
---------------------------

The "unittest" module was greatly enhanced; many new features were
added.  Most of these features were implemented by Michael Foord,
unless otherwise noted.  The enhanced version of the module is
downloadable separately for use with Python versions 2.4 to 2.6,
packaged as the "unittest2" package, from
https://pypi.org/project/unittest2.

Quando usado na linha de comando, o módulo pode descobrir testes
automaticamente. Não é tão sofisticado quanto py.test ou nose, mas
fornece uma maneira simples de executar testes mantidos dentro de um
conjunto de diretórios de pacotes. Por exemplo, o comando a seguir irá
pesquisar no subdiretório "test/" por quaisquer arquivos de teste
importáveis chamados "test*.py":

   python -m unittest discover -s test

Consulte a documentação do módulo "unittest" para mais detalhes.
(Desenvolvido em bpo-6001.)

A função "main()" oferece suporte a algumas outras novas opções:

* "-b" ou "--buffer" armazenará em buffer a saída padrão e os fluxos
  de erro padrão durante cada teste. Se o teste for aprovado, qualquer
  saída resultante será descartada; em caso de falha, a saída em
  buffer será exibida.

* "-c" ou "--catch" fará com que a interrupção control-C seja tratada
  com mais elegância. Em vez de interromper imediatamente o processo
  de teste, o teste em execução será concluído e então os resultados
  parciais até a interrupção serão relatados. Se você estiver
  impaciente, um segundo toque no controle C causará uma interrupção
  imediata.

  Este manipulador de control-C tenta evitar causar problemas quando o
  código que está sendo testado ou os testes em execução definiram um
  manipulador de sinal próprio, percebendo que um manipulador de sinal
  já estava definido e chamando-o. Se isso não funcionar para você,
  existe um decorador "removeHandler()" que pode ser usado para marcar
  testes que devem ter o manuseio de control-C desabilitado.

* "-f" ou "--failfast" faz com que a execução do teste pare
  imediatamente quando um teste falha, em vez de continuar a executar
  testes adicionais. (Sugerido por Cliff Dyer e implementado por
  Michael Foord; bpo-8074.)

As mensagens de progresso agora mostram 'x' para falhas esperadas e
'u' para sucessos inesperados quando executadas em modo detalhado.
(Contribuição de Benjamin Peterson.)

Os casos de teste podem levantar a exceção "SkipTest" para pular um
teste (bpo-1034053).

As mensagens de erro para falhas "assertEqual()", "assertTrue()" e
"assertFalse()" agora fornecem mais informações. Se você definir o
atributo "longMessage" de suas classes "TestCase" como true, tanto a
mensagem de erro padrão quanto qualquer mensagem adicional que você
fornecer serão impressas para falhas. (Adição de Michael Foord;
bpo-5663.)

O método "assertRaises()" agora retorna um manipulador de contexto
quando chamado sem fornecer um objeto chamável para ser executado. Por
exemplo, você pode escrever isto:

   with self.assertRaises(KeyError):
       {}['foo']

(implementação de Antoine Pitrou; bpo-4444.)

Correções de desmontagem e configuração em nível de módulo e classe
agora são suportados. Os módulos podem conter funções "setUpModule()"
e "tearDownModule()". As classes podem ter métodos "setUpClass()" e
"tearDownClass()" que devem ser definidos como métodos de classe
(usando "@classmethod" ou equivalente). Essas funções e métodos são
invocados quando o executor de teste alterna para um caso de teste em
um módulo ou classe diferente.

Os métodos "addCleanup()" e "doCleanups()" foram adicionados.
"addCleanup()" permite adicionar funções de limpeza que serão chamadas
incondicionalmente (após "setUp()" se "setUp()" falhar, caso
contrário, após "tearDown()"). Isso permite uma alocação e desalocação
de recursos muito mais simples durante os testes (bpo-5679).

Foram adicionados vários novos métodos que fornecem testes mais
especializados. Muitos desses métodos foram escritos por engenheiros
do Google para uso em seus conjuntos de testes; Gregory P. Smith,
Michael Foord e GvR trabalharam na fusão deles na versão Python de
"unittest".

* "assertIsNone()" e "assertIsNotNone()" pegam uma expressão e
  verificam se o resultado é ou não "None".

* "assertIs()" e "assertIsNot()" pegam dois valores e verificam se os
  dois valores são avaliados como o mesmo objeto ou não. (Adicionado
  por Michael Foord; bpo-2578.)

* "assertIsInstance()" e "assertNotIsInstance()" verificam se o objeto
  resultante é uma instância de uma classe específica ou de uma tupla
  de classes. (Adicionado por Georg Brandl; bpo-7031.)

* "assertGreater()", "assertGreaterEqual()", "assertLess()", e
  "assertLessEqual()" comparam duas quantidades.

* "assertMultiLineEqual()" compara duas strings e, se não forem
  iguais, exibe uma comparação útil que destaca as diferenças nas duas
  strings. Esta comparação agora é usada por padrão quando strings
  Unicode são comparadas com "assertEqual()".

* "assertRegexpMatches()" e "assertNotRegexpMatches()" verificam se o
  primeiro argumento é uma string que corresponde ou não à expressão
  regular fornecida como o segundo argumento (bpo-8038).

* "assertRaisesRegexp()" verifica se uma exceção específica foi
  levantada e também verifica se a representação da string da exceção
  corresponde à expressão regular fornecida.

* "assertIn()" e "assertNotIn()" testa se *primeiro* está ou não em
  *segundo*.

* "assertItemsEqual()" testa se duas sequências fornecidas contêm os
  mesmos elementos.

* "assertSetEqual()" compara se dois conjuntos são iguais e apenas
  relata as diferenças entre os conjuntos em caso de erro.

* Da mesma forma, "assertListEqual()" e "assertTupleEqual()" comparam
  os tipos especificados e explicam quaisquer diferenças sem
  necessariamente imprimir seus valores completos; esses métodos agora
  são usados por padrão ao comparar listas e tuplas usando
  "assertEqual()". De forma mais geral, "assertSequenceEqual()"
  compara duas sequências e pode opcionalmente verificar se ambas as
  sequências são de um tipo específico.

* "assertDictEqual()" compara dois dicionários e relata as diferenças;
  agora é usado por padrão quando você compara dois dicionários usando
  "assertEqual()". "assertDictContainsSubset()" verifica se todos os
  pares chave/valor em *first* são encontrados em *second*.

* "assertAlmostEqual()" e "assertNotAlmostEqual()" testam se *first* e
  *second* são aproximadamente iguais. Este método pode arredondar a
  diferença para um número opcionalmente especificado de *places* (o
  padrão é 7) e compará-lo com zero, ou exigir que a diferença seja
  menor que um valor *delta* fornecido.

* "loadTestsFromName()" respeita corretamente o atributo "suiteClass"
  do "TestLoader". (Correção de Mark Roddy; bpo-6866.)

* Um novo gancho permite estender o método "assertEqual()" para lidar
  com novos tipos de dados. O método "addTypeEqualityFunc()" leva um
  objeto de tipo e uma função. A função será usada quando ambos os
  objetos comparados forem do tipo especificado. Esta função deve
  comparar os dois objetos e gerar uma exceção se eles não
  corresponderem; é uma boa ideia que a função forneça informações
  adicionais sobre por que os dois objetos não correspondem, assim
  como fazem os novos métodos de comparação de sequências.

"unittest.main()" agora recebe um argumento "exit" opcional.  Se for
falso, "main()" não chama "sys.exit()", permitindo que "main()" seja
usado a partir do interpretador interativo.  (Contribuição de J. Pablo
Fernández; bpo-3379.)

"TestResult" tem novos métodos "startTestRun()" e "stopTestRun()" que
são chamados imediatamente antes e depois de uma execução de teste.
(Contribuição de Robert Collins; bpo-5728.)

Com todas essas mudanças, o "unittest.py" estava ficando estranhamente
grande, então o módulo foi transformado em um pacote e o código
dividido em vários arquivos (por Benjamin Peterson). Isso não afeta
como o módulo é importado ou usado.

Ver também:

  https://web.archive.org/web/20210619163128/http://www.voidspace.org
  .uk/python/articles/unittest2.shtml
     Descreve os novos recursos, como usá-los e a justificativa para
     diversas decisões de design. (Por Michael Foord.)


Módulo atualizado: ElementTree 1.3
----------------------------------

A versão da biblioteca ElementTree incluída no Python foi atualizada
para a versão 1.3. Alguns dos novos recursos são:

* As várias funções de análise agora recebem um argumento nomeado
  *parser* fornecendo uma instância "XMLParser" que será usada. Isso
  torna possível substituir a codificação interna do arquivo:

     p = ET.XMLParser(encoding='utf-8')
     t = ET.XML("""<root/>""", parser=p)

  Erros na análise de XML agora levantam uma exceção "ParseError",
  cujas instâncias possuem um atributo "position" contendo uma tupla
  (*linha*, *coluna*) fornecendo a localização do problema.

* O código do ElementTree para converter árvores em strings foi
  significativamente reformulado, tornando-o aproximadamente duas
  vezes mais rápido em muitos casos. Os métodos "ElementTree.write()"
  e "Element.write()" agora possuem um parâmetro *method* que pode ser
  "xml" (o padrão), "html" ou "text". O modo HTML produzirá elementos
  vazios como "<empty></empty>" em vez de "<empty/>", e o modo texto
  irá pular os elementos e exibir apenas os pedaços de texto. Se você
  definir o atributo "tag" de um elemento como "None" mas deixar seus
  filhos no lugar, o elemento será omitido quando a árvore for
  escrita, então você não precisa fazer um rearranjo mais extenso para
  remover um único elemento.

  O tratamento de espaço de nomes também foi melhorado. Todas as
  declarações "xmlns:<alguma_coisa>" agora são geradas no elemento
  raiz, não espalhadas pelo XML resultante.  Você pode definir o
  espaço de nomes padrão para uma árvore definindo o atributo
  "default_namespace" e pode registrar novos prefixos com
  "register_namespace()". No modo XML, você pode usar o parâmetro
  verdadeiro/falso *xml_declaration* para suprimir a declaração XML.

* Novo método "Element": "extend()" anexa os itens de uma sequência
  aos filhos do elemento. Os próprios elementos se comportam como
  sequências, por isso é fácil mover os filhos de um elemento para
  outro:

     from xml.etree import ElementTree as ET

     t = ET.XML("""<list>
       <item>1</item> <item>2</item>  <item>3</item>
     </list>""")
     new = ET.XML('<root/>')
     new.extend(t)

     # Outputs <root><item>1</item>...</root>
     print ET.tostring(new)

* Novo método "Element": "iter()" produz os filhos do elemento como um
  gerador. Também é possível escrever "for child in elem:" para
  percorrer os filhos de um elemento. O método existente
  "getiterator()" agora está descontinuado, assim como "getchildren()"
  que constrói e retorna uma lista de filhos.

* Novo método "Element": "itertext()" produz todos os pedaços de texto
  que são descendentes do elemento. Por exemplo:

     t = ET.XML("""<list>
       <item>1</item> <item>2</item>  <item>3</item>
     </list>""")

     # Outputs ['\n  ', '1', ' ', '2', '  ', '3', '\n']
     print list(t.itertext())

* Descontinuado: usar um elemento como booleano (ou seja, "if elem:")
  retornaria verdadeiro se o elemento tivesse algum filho, ou falso se
  não houvesse nenhum filho. Este comportamento é confuso -- "None" é
  falso, mas um elemento sem filhos também o é? -- então agora irá
  acionar um "FutureWarning". Em seu código, você deve ser explícito:
  escreva "len(elem) != 0" se estiver interessado no número de filhos,
  ou "elem is not None".

Fredrik Lundh desenvolve ElementTree e produziu a versão 1.3; você
pode ler o artigo dele descrevendo 1.3 em https://web.archive.org/web
/20200703234532/http://effbot.org/zone/elementtree-13-intro.htm.
Florent Xicluna atualizou a versão incluída no Python, após discussões
em python-dev e em bpo-6472.)


Mudanças a construções e API C
==============================

As alterações no processo de construção do Python e na API C incluem:

* O uso da versão mais recente do GNU Debugger, GDB 7, pode ser
  programado usando Python. Quando você começa a depurar um programa
  executável P, o GDB irá procurar por um arquivo chamado "P-gdb.py" e
  lê-lo automaticamente. Dave Malcolm contribuiu com um "python-
  gdb.py" que adiciona vários comandos úteis ao depurar o próprio
  Python. Por exemplo, "py-up" e "py-down" sobem ou descem um quadro
  de pilha Python, que geralmente corresponde a vários quadros de
  pilha C. "py-print" imprime o valor de uma variável Python e "py-bt"
  imprime o stack trace do Python. (Adicionado como resultado de
  bpo-8032.)

* Se você usar o arquivo ".gdbinit" fornecido com Python, a macro
  "pyo" na versão 2.7 agora funciona corretamente quando o thread que
  está sendo depurado não contém a GIL; a macro agora a adquire antes
  de imprimir. (Contribuição de Victor Stinner; bpo-3632.)

* "Py_AddPendingCall()" agora é segura para thread, permitindo que
  qualquer thread de trabalho envie notificações para o thread
  principal do Python. Isto é particularmente útil para operações de
  E/S assíncronas. (Contribuição de Kristján Valur Jónsson; bpo-4293.)

* New function: "PyCode_NewEmpty()" creates an empty code object; only
  the filename, function name, and first line number are required.
  This is useful for extension modules that are attempting to
  construct a more useful traceback stack. Previously such extensions
  needed to call "PyCode_New()", which had many more arguments. (Added
  by Jeffrey Yasskin.)

* Nova função: "PyErr_NewExceptionWithDoc()" cria uma nova classe de
  exceção, assim como a "PyErr_NewException()" existente faz, mas
  recebe um argumento "char *" extra contendo a docstring para a nova
  classe de exceção . (Adição de 'lekma' no rastreador de bugs do
  Python; bpo-7033.)

* Nova função: "PyFrame_GetLineNumber()" pega um objeto quadro e
  retorna o número da linha que o frame está executando atualmente.
  Anteriormente, o código precisaria obter o índice da instrução de
  bytecode atualmente em execução e, em seguida, procurar o número da
  linha correspondente a esse endereço. (Adição de Jeffrey Yasskin.)

* Novas funções: "PyLong_AsLongAndOverflow()" e
  "PyLong_AsLongLongAndOverflow()" aproxima um inteiro longo do Python
  como um long ou long long do C. Se o número for muito grande para
  caber no tipo de saída, um sinalizador *overflow* será definido e
  retornado ao chamador. (Contribuição de Case Van Horsen; bpo-7528 e
  bpo-7767.)

* Nova função: decorrente da reescrita da conversão string-para-float,
  uma nova função "PyOS_string_to_double()" foi adicionada. As antigas
  funções "PyOS_ascii_strtod()" e "PyOS_ascii_atof()" agora foram
  descontinuadas.

* Nova função: "PySys_SetArgvEx()" define o valor de "sys.argv" e pode
  opcionalmente atualizar "sys.path" para incluir o diretório que
  contém o script nomeado por "sys.argv[0]" dependendo do valor de um
  parâmetro *updatepath*.

  Esta função foi adicionada para fechar uma falha de segurança em
  aplicativos que incorporam Python. A função antiga,
  "PySys_SetArgv()", sempre atualizava "sys.path", e às vezes
  adicionava o diretório atual. Isso significava que, se você
  executasse uma aplicação incorporando Python em um diretório
  controlado por outra pessoa, os invasores poderiam colocar um módulo
  cavalo de Troia no diretório (digamos, um arquivo chamado "os.py")
  que sua aplicação então usaria. importar e executar.

  Se você mantém uma aplicação C/C++ que incorpora Python, verifique
  se está chamando "PySys_SetArgv()" e considere cuidadosamente se a
  aplicação deve usar "PySys_SetArgvEx()" com *updatepath* definido
  como false.

  Security issue reported as CVE-2008-5983; discussed in bpo-5753, and
  fixed by Antoine Pitrou.

* Novas macros: os arquivos de cabeçalho do Python agora definem as
  seguintes macros: "Py_ISALNUM", "Py_ISALPHA", "Py_ISDIGIT",
  "Py_ISLOWER", "Py_ISSPACE", "Py_ISUPPER", "Py_ISXDIGIT",
  "Py_TOLOWER" e "Py_TOUPPER". Todas essas funções são análogas às
  macros padrão C para classificação de caracteres, mas ignoram a
  configuração de localidade atual, porque em vários lugares o Python
  precisa analisar caracteres de maneira independente de localidade.
  (Adição de Eric Smith; bpo-5793.)

* Função removida: "PyEval_CallObject()" agora está disponível apenas
  como uma macro. Uma versão de função estava sendo mantida para
  preservar a compatibilidade de links ABI, mas isso foi em 1997;
  certamente pode ser excluído agora. (Remoção de Antoine Pitrou;
  bpo-8276.)

* Novos códigos de formato: as funções "PyString_FromFormat()",
  "PyString_FromFormatV()" e "PyErr_Format()" agora aceitam "%lld" e
  "%llu" códigos de formato para exibir os tipos long long de C.
  (Contribuição de Mark Dickinson; bpo-7228.)

* A complicada interação entre threads e forks de processos foi
  alterada. Anteriormente, o processo filho criado por "os.fork()"
  pode falhar porque o filho é criado com apenas um único thread em
  execução, a thread executando "os.fork()". Se outros threads
  estivessem mantendo uma trava, como a trava de importação do Python,
  quando o fork fosse executado, a trava ainda seria marcada como
  "retida" no novo processo. Mas no processo filho nada liberaria a
  trava, pois os outros threads não foram replicados e o processo
  filho não seria mais capaz de realizar importações.

  Python 2.7 adquire a trava de importação antes de executar um
  "os.fork()", e também limpará quaisquer travas criadas usando o
  módulo "threading". Módulos de extensão C que possuem travas
  internas, ou que chamam "fork()" eles próprios, não se beneficiarão
  desta limpeza.

  (Correção de Thomas Wouters; bpo-1590864.)

* A função "Py_Finalize()" agora chama a função interna
  "threading._shutdown()"; isso evita que algumas exceções sejam
  levantadas quando um interpretador é encerrado. (Patch de Adam
  Olsen; bpo-1722344.)

* Ao usar a estrutura "PyMemberDef" para definir atributos de um tipo,
  o Python não permitirá mais que você tente excluir ou definir um
  atributo "T_STRING_INPLACE".

* Símbolos globais definidos pelo módulo "ctypes" agora são prefixados
  com "Py", ou com "_ctypes". (Implementado por Thomas Heller;
  bpo-3102.)

* Nova opção de configuração: a opção "--with-system-expat" permite
  construir o módulo "pyexpat" para usar a biblioteca Expat do
  sistema. (Contribuição de Arfrever Frehtes Taifersar Arahesis;
  bpo-7609.)

* Nova opção de configuração: a opção "--with-valgrind" agora
  desativará o alocador pymalloc, o que é difícil para o detector de
  erros de memória Valgrind analisar corretamente. Valgrind será,
  portanto, melhor na detecção de vazamentos e sobrecargas de memória.
  (Contribuição de James Henstridge; bpo-2422.)

* Nova opção de configuração: agora você pode fornecer uma string
  vazia para "--with-dbmliborder=" para desabilitar todos os vários
  módulos DBM. (Adição de Arfrever Frehtes Taifersar Arahesis;
  bpo-6491.)

* O script **configure** agora verifica erros de arredondamento de
  ponto flutuante em certos chips Intel de 32 bits e define uma
  definição de preprocessador "X87_DOUBLE_ROUNDING". Nenhum código
  atualmente usa esta definição, mas ela está disponível se alguém
  desejar usá-la. (Adicionado por Mark Dickinson; bpo-2937.)

  **configure** agora também define uma variável Makefile
  "LDCXXSHARED" para prover suporte à vinculação C++. (Contribuição de
  Arfrever Frehtes Taifersar Arahesis; bpo-1222585.)

* O processo de construção agora cria os arquivos necessários para
  suporte ao pkg-config. (Contribuição de Clinton Roy; bpo-3585.)

* O processo de construção agora prover suporte ao Subversion 1.7.
  (Contribuição de Arfrever Frehtes Taifersar Arahesis; bpo-6094.)


Capsules
--------

Python 3.1 adiciona um novo tipo de dados C, "PyCapsule", para
fornecer uma API C para um módulo de extensão. Uma cápsula é
essencialmente o detentor de um ponteiro C "void *" e é
disponibilizada como um atributo de módulo; por exemplo, a API do
módulo "socket" é exposta como "socket.CAPI", e "unicodedata" expõe
"ucnhash_CAPI". Outras extensões podem importar o módulo, acessar seu
dicionário para obter o objeto cápsula e então obter o ponteiro "void
*", que normalmente apontará para uma matriz de ponteiros para as
diversas funções da API do módulo.

Já existe um tipo de dados usado para isso, "PyCObject", mas ele não
fornece segurança de tipo. Código maligno escrito em Python puro pode
causar uma falha de segmentação pegando um "PyCObject" do módulo A e
de alguma forma substituindo-o por "PyCObject" no módulo B. As
cápsulas sabem seu próprio nome , e para obter o ponteiro é necessário
fornecer o nome:

   void *vtable;

   if (!PyCapsule_IsValid(capsule, "mymodule.CAPI") {
           PyErr_SetString(PyExc_ValueError, "argument type invalid");
           return NULL;
   }

   vtable = PyCapsule_GetPointer(capsule, "mymodule.CAPI");

Você tem certeza de que "vtable" aponta para o que você espera. Se uma
cápsula diferente fosse passada, "PyCapsule_IsValid()" detectaria o
nome incompatível e retornaria falso. Consulte Providing a C API for
an Extension Module para mais informações sobre como usar esses
objetos.

Python 2.7 agora usa cápsulas internamente para fornecer várias APIs
de módulo de extensão, mas o "PyCObject_AsVoidPtr()" foi modificado
para lidar com cápsulas, preservando a compatibilidade em tempo de
compilação com a interface "PyCObject". O uso de
"PyCObject_AsVoidPtr()" sinalizará uma exceção
"PendingDeprecationWarning", que é silencioso por padrão.

Implementado em Python 3.1 e portado para 2.7 por Larry Hastings;
discutido em bpo-5630.


Alterações específicas da porta: Windows
----------------------------------------

* O módulo "msvcrt" agora contém algumas constantes do arquivo de
  cabeçalho "crtassem.h": "CRT_ASSEMBLY_VERSION",
  "VC_ASSEMBLY_PUBLICKEYTOKEN" e "LIBRARIES_ASSEMBLY_NAME_PREFIX".
  (Contribuição de David Cournapeau; bpo-4365.)

* O módulo "_winreg" para acessar o registro agora implementa as
  funções "CreateKeyEx()" e "DeleteKeyEx()", versões estendidas de
  funções suportadas anteriormente que recebem vários argumentos
  extras. Os "DisableReflectionKey()", "EnableReflectionKey()" e
  "QueryReflectionKey()" também foram testados e documentados.
  (Implementação de Brian Curtin: bpo-7347.)

* A nova API "_beginthreadex()" é usada para iniciar threads, e as
  funções nativas de armazenamento local de thread agora são usadas.
  (Contribuição de Kristján Valur Jónsson; bpo-3582.)

* A função "os.kill()" agora funciona no Windows. O valor do sinal
  pode ser as constantes "CTRL_C_EVENT", "CTRL_BREAK_EVENT" ou
  qualquer número inteiro. As duas primeiras constantes enviarão
  eventos de pressionamento de tecla "Control-C" e "Control-Break"
  para subprocessos; qualquer outro valor usará a API
  "TerminateProcess()". (Contribuição de Miki Tebeka; bpo-1220212.)

* A função "os.listdir()" agora falha corretamente para um caminho
  vazio. (Correção de Hirokazu Yamamoto; bpo-5913.)

* O módulo "mimetypes" agora irá ler o banco de dados MIME do registro
  do Windows ao inicializar. (Patch de Gabriel Genellina; bpo-4969.)


Alterações específicas da porta: Mac OS X
-----------------------------------------

* O caminho "/Library/Python/2.7/site-packages" agora é anexado a
  "sys.path", para compartilhar pacotes adicionados entre a instalação
  do sistema e uma cópia da mesma versão instalada pelo usuário.
  (Alteração de Ronald Oussoren; bpo-4865.)

  Alterado na versão 2.7.13: A partir da versão 2.7.13, esta alteração
  foi removida. "/Library/Python/2.7/site-packages", o diretório site-
  packages usado pelo sistema Python 2.7 fornecido pela Apple não é
  mais anexado a "sys.path" para Pythons instalados pelo usuário, como
  do Instaladores do python.org. A partir do macOS 10.12, a Apple
  mudou a forma como o diretório site-packages do sistema é
  configurado, o que pode causar falha na instalação de componentes
  pip, como setuptools. Os pacotes instalados para o sistema Python
  não serão mais compartilhados com Pythons instalados pelo usuário. (
  bpo-28440)


Alterações específicas da porta: FreeBSD
----------------------------------------

* Constante "SO_SETFIB" do FreeBSD 7.1, usada com os métodos
  "getsockopt()" e "setsockopt()" do "socket()" para selecionar uma
  tabela de roteamento alternativa, agora está disponível no módulo
  "socket". (Adição de Kyle VanderBeek; bpo-8235.)


Outras alterações e correções
=============================

* Dois scripts de benchmark, "iobench" e "ccbench", foram adicionados
  ao diretório "Tools". "iobench" mede a velocidade dos objetos
  embutidos de E/S de arquivo retornados por "open()" durante a
  execução de várias operações, e "ccbench" é um benchmark de
  simultaneidade que tenta medir o rendimento da computação, latência
  de comutação de threads e largura de banda de processamento de E/S
  ao executar diversas tarefas usando um número variável de threads.

* O script "Tools/i18n/msgfmt.py" agora entende formas plurais em
  arquivos ".po". (Correção de Martin von Löwis; bpo-5464.)

* Ao importar um módulo de um arquivo ".pyc" ou ".pyo" com uma
  contraparte ".py" existente, os atributos "co_filename" dos objetos
  código resultantes são substituídos quando o nome do arquivo
  original fica obsoleto. Isso pode acontecer se o arquivo tiver sido
  renomeado, movido ou acessado por caminhos diferentes. (Patch de
  Ziga Seilnacht e Jean-Paul Calderone; bpo-1180193.)

* O script "regrtest.py" agora usa uma opção "--randseed=" que recebe
  um número inteiro que será usado como semente aleatória para a opção
  "-r" que executa testes em ordem aleatória. A opção "-r" também
  informa a semente que foi usada (Adição de Collin Winter.)

* Outra opção "regrtest.py" é "-j", que recebe um número inteiro
  especificando quantos testes são executados em paralelo. Isto
  permite reduzir o tempo total de execução em máquinas com vários
  núcleos. Esta opção é compatível com várias outras opções, incluindo
  a opção "-R" que é conhecida por produzir longos tempos de execução.
  (Adicionado por Antoine Pitrou, bpo-6152.) Isso também pode ser
  usado com uma nova opção "-F" que executa testes selecionados em um
  loop até que eles falhem. (Adição de Antoine Pitrou; bpo-7312.)

* Quando executado como um script, o módulo "py_compile.py" agora
  aceita "'-'" como argumento, que lerá a entrada padrão para a lista
  de nomes de arquivos a serem compilados. (Contribuição de Piotr
  Ożarowski; bpo-8233.)


Portando para Python 2.7
========================

Esta seção lista as alterações descritas anteriormente e outras
correções que podem exigir alterações no seu código.

* A função "range()" processa seus argumentos de forma mais
  consistente; agora ele chamará "__int__()" em argumentos que não são
  ponto flutuantes nem inteiros que são fornecidos a ele. (Correção de
  Alexander Belopolsky; bpo-1533.)

* O método string "format()" alterou a precisão padrão usada para
  números de ponto flutuante e complexos de 6 casas decimais para 12,
  o que corresponde à precisão usada por "str()". (Alteração de Eric
  Smith; bpo-5920.)

* Por causa de uma otimização para a instrução "with", os métodos
  especiais "__enter__()" e "__exit__()" devem pertencer ao tipo do
  objeto e não podem ser diretamente anexados ao instância do objeto.
  Isto afeta classes de novo estilo (derivadas de "object") e tipos de
  extensão C. (bpo-6101.)

* Devido a um bug no Python 2.6, o parâmetro *exc_value* para os
  métodos "__exit__()" era frequentemente a representação de string da
  exceção, não uma instância. Isso foi corrigido na versão 2.7, então
  *exc_value* será uma instância conforme esperado. (Correção de
  Florent Xicluna; bpo-7853.)

* Quando um conjunto restrito de atributos foi definido usando
  "__slots__", excluir um atributo não definido não levantaria
  "AttributeError" como seria de esperar. Correção de Benjamin
  Peterson; bpo-7604.)

Na biblioteca padrão:

* Operações com instâncias "datetime" que resultaram em um ano fora do
  intervalo suportado nem sempre levantam "OverflowError". Esses erros
  agora são verificados com mais cuidado e irão levantar a exceção.
  (Relato de Mark Leander, patch de Anand B. Pillai e Alexander
  Belopolsky; bpo-7150.)

* Ao usar instâncias "Decimal" com o método "format()" de uma string,
  o alinhamento padrão era anteriormente o alinhamento à esquerda.
  Isso foi alterado para alinhamento à direita, o que pode alterar a
  saída dos seus programas. (Alteração de Mark Dickinson; bpo-6857.)

  Comparações envolvendo um valor NaN de sinalização (ou "sNAN") agora
  sinalizam "InvalidOperation" em vez de retornar silenciosamente um
  valor verdadeiro ou falso dependendo do operador de comparação.
  Valores silenciosos de NaN (ou "NaN") agora são hasheáveis.
  (Corrigido por Mark Dickinson; bpo-7279.)

* A biblioteca "xml.etree.ElementTree" não escapa mais os caracteres
  de e-comercial e colchetes angulares ao gerar uma instrução de
  processamento XML (que se parece com "<?xml-stylesheet
  href="#style1"?>") ou comentário ( que se parece com "<!-- comment
  -->"). (Patch de Neil Muller; bpo-2746.)

* O método "readline()" dos objetos "StringIO" agora não faz nada
  quando um comprimento negativo é solicitado, como fazem outros
  objetos arquivo ou similares. (bpo-7348).

* O módulo "syslog" agora usará o valor de "sys.argv[0]" como
  identificador em vez do valor padrão anterior de "'python'".
  (Alteração de Sean Reifschneider; bpo-8451.)

* O tratamento de erros padrão do módulo "tarfile" foi alterado, para
  não mais suprimir erros fatais. O nível de erro padrão era
  anteriormente 0, o que significava que os erros resultariam apenas
  na gravação de uma mensagem no log de depuração, mas como o log de
  depuração não está ativado por padrão, esses erros passam
  despercebidos. O nível de erro padrão agora é 1, o que levanta uma
  exceção se houver um erro. (Alteração de Lars Gustäbel; bpo-7357.)

* A função "urlsplit()" do módulo "urlparse" agora lida com esquemas
  de URL desconhecidos de uma forma compatível com **RFC 3986**: se a
  URL estiver no formato ""<alguma_coisa>://..."", o texto antes de
  "://" é tratado como o esquema, mesmo que seja um esquema inventado
  que o módulo não conhece. Essa alteração pode quebrar o código que
  contornava o comportamento antigo. Por exemplo, Python 2.6.4 ou 2.5
  retornará o seguinte:

     >>> import urlparse
     >>> urlparse.urlsplit('invented://host/filename?query')
     ('invented', '', '//host/filename?query', '', '')

  Python 2.7 (e Python 2.6.5) vai retornar:

     >>> import urlparse
     >>> urlparse.urlsplit('invented://host/filename?query')
     ('invented', 'host', '/filename?query', '', '')

  (Na verdade, o Python 2.7 produz uma saída ligeiramente diferente,
  pois retorna uma tupla nomeada em vez de uma tupla padrão.)

Para extensões C:

* Extensões C que usam códigos de formato inteiro com a família de
  funções "PyArg_Parse*" agora levantarão uma exceção "TypeError" em
  vez de disparar uma "DeprecationWarning" (bpo-5080).

* Use a nova função "PyOS_string_to_double()" em vez das antigas
  funções "PyOS_ascii_strtod()" e "PyOS_ascii_atof()", que agora estão
  descontinuadas.

Para aplicações que incorporam Python:

* A função "PySys_SetArgvEx()" foi adicionada, permitindo que
  aplicativos fechem uma falha de segurança quando a função
  "PySys_SetArgv()" existente for usada. Verifique se você está
  chamando "PySys_SetArgv()" e considere cuidadosamente se a aplicação
  deve usar "PySys_SetArgvEx()" com *updatepath* definido como falso.


Novos recursos adicionados às versões de manutenção do Python 2.7
=================================================================

Novos recursos podem ser adicionados às versões de manutenção do
Python 2.7 quando a situação realmente exigir. Quaisquer adições devem
passar pelo processo de proposta de melhoria do Python, ou em inglês
Python Enhancement Proposal -- PEP, e apresentar um argumento
convincente sobre por que não podem ser abordadas adequadamente
adicionando o novo recurso apenas ao Python 3 ou publicando-o no
Python Package Index.

Além das propostas específicas listadas abaixo, há uma isenção geral
que permite que novos avisos "-3" sejam adicionados em qualquer versão
de manutenção do Python 2.7.


Duas novas variáveis de ambiente para modo de depuração
-------------------------------------------------------

No modo de depuração, a estatística "[xxx refs]" não é escrita por
padrão, a variável de ambiente "PYTHONSHOWREFCOUNT" agora também deve
ser definida. (Contribuição de Victor Stinner; bpo-31733.)

Quando Python é compilado com "COUNT_ALLOC" definido, as contagens de
alocação não são mais despejadas por padrão: a variável de ambiente
"PYTHONSHOWALLOCCOUNT" agora também deve ser definida. Além disso, as
contagens de alocação agora são despejadas no stderr, em vez do
stdout. (Contribuição de Victor Stinner; bpo-31692.)

Novo na versão 2.7.15.


PEP 434: Exceção de aprimoramento do IDLE para todos os branches
----------------------------------------------------------------

**PEP 434** descreve uma isenção geral para alterações feitas no
ambiente de desenvolvimento IDLE enviado junto com o Python. Esta
isenção permite que os desenvolvedores de IDLE forneçam uma
experiência de usuário mais consistente em todas as versões suportadas
do Python 2 e 3.

Para obter detalhes sobre quaisquer alterações do IDLE, consulte o
arquivo NEWS da versão específica.


PEP 466: Aprimoramentos de segurança de rede do Python 2.7
----------------------------------------------------------

**PEP 466** descreve uma série de propostas de melhoria de segurança
de rede que foram aprovadas para inclusão nas versões de manutenção do
Python 2.7, com a primeira dessas mudanças aparecendo na versão Python
2.7.7.

Recursos relacionados a **PEP 466** adicionados no Python 2.7.7:

* "hmac.compare_digest()" foi portado do Python 3 para disponibilizar
  uma operação de comparação resistente a ataques de tempo para
  aplicações em Python 2. (Contribuição de Alex Gaynor; bpo-21306.)

* OpenSSL 1.0.1g foi atualizado nos instaladores oficiais do Windows
  publicados em python.org. (Contribuição de Zachary Ware; bpo-21462.)

Recursos relacionados a **PEP 466** adicionados no Python 2.7.8:

* "hashlib.pbkdf2_hmac()" foi portado do Python 3 para tornar um
  algoritmo de hash adequado para armazenamento seguro de senhas
  amplamente disponível para aplicações Python 2. (Contribuição de
  Alex Gaynor; bpo-21304.)

* OpenSSL 1.0.1h was upgraded for the official Windows installers
  published on python.org. (contributed by Zachary Ware in bpo-21671
  for CVE-2014-0224)

Recursos relacionados a **PEP 466** adicionados no Python 2.7.9:

* A maior parte do módulo "ssl" do Python 3.4 foi portada. Isso
  significa que "ssl" agora provê suporte a indicar de nome de
  servidor, configurações TLS1.x, acesso ao armazenamento de
  certificados da plataforma, a classe "SSLContext" e outros recursos.
  (Contribuição de Alex Gaynor e David Reid; bpo-21308.)

  Consulte as notas "Versão adicionada: 2.7.9" na documentação do
  módulo para obter detalhes específicos.

* "os.urandom()" foi alterado para armazenar em cache um descritor de
  arquivo para "/dev/urandom" em vez de reabrir "/dev/urandom" em cada
  chamada. (Contribuição de Alex Gaynor; bpo-21305.)

* "hashlib.algorithms_guaranteed" e "hashlib.algorithms_available"
  foram portados do Python 3 para tornar mais fácil para os aplicações
  Python 2 selecionarem o algoritmo de hash mais forte disponível.
  (Contribuição de Alex Gaynor em bpo-21307)


PEP 477: Backport do ensurepip (PEP 453) para o Python 2.7
----------------------------------------------------------

A **PEP 477** aprova a inclusão do módulo ensurepip do **PEP 453** e
da documentação aprimorada que foi habilitada por ele nas versões de
manutenção do Python 2.7, aparecendo primeiro na versão Python 2.7.9.


Bootstrapping pip By Default
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

O novo módulo "ensurepip" (definido em **PEP 453**) fornece um
mecanismo padrão de plataforma cruzada para inicializar o instalador
pip em instalações Python. A versão do "pip" incluída no Python 2.7.9
é "pip" 1.5.6, e futuras versões de manutenção 2.7.x atualizarão a
versão empacotada para a versão mais recente do "pip" que está
disponível em o momento da criação do candidato a lançamento.

Por padrão, os comandos "pip", "pipX" e "pipX.Y" serão instalados em
todas as plataformas (onde X.Y representa a versão da instalação do
Python), junto com o pacote Python via "pip" e suas dependências.

Para construções de fontes do CPython em sistemas POSIX, os comandos
"make install" e "make altinstall" não inicializam "pip" por padrão.
Este comportamento pode ser controlado através de opções de
configuração e substituído através de opções do Makefile.

On Windows and Mac OS X, the CPython installers now default to
installing "pip" along with CPython itself (users may opt out of
installing it during the installation process). Window users will need
to opt in to the automatic "PATH" modifications to have "pip"
available from the command line by default, otherwise it can still be
accessed through the Python launcher for Windows as "py -m pip".

As discussed in the PEP, platform packagers may choose not to install
these commands by default, as long as, when invoked, they provide
clear and simple directions on how to install them on that platform
(usually using the system package manager).


Mudanças na documentação
~~~~~~~~~~~~~~~~~~~~~~~~

As part of this change, the Instalando módulos Python and Distribuindo
módulos Python sections of the documentation have been completely
redesigned as short getting started and FAQ documents. Most packaging
documentation has now been moved out to the Python Packaging Authority
maintained Python Packaging User Guide and the documentation of the
individual projects.

However, as this migration is currently still incomplete, the legacy
versions of those guides remaining available as Instalando módulos
Python (versão legada) and Distribuindo Módulos Python (Versão
legada).

Ver também:

  **PEP 453** -- Explicit bootstrapping of pip in Python installations
     PEP written by Donald Stufft and Nick Coghlan, implemented by
     Donald Stufft, Nick Coghlan, Martin von Löwis and Ned Deily.


PEP 476: Habilitando verificação de certificado por padrão para clientes http stdlib
------------------------------------------------------------------------------------

**PEP 476** atualizou "httplib" e módulos que o utilizam, como
"urllib2" e "xmlrpclib", para agora verificar se o servidor apresenta
um certificado que é assinado por uma Autoridade Certificadora no
armazenamento confiável da plataforma e cujo nome de host corresponde
ao nome de host solicitado por padrão, melhorando significativamente a
segurança para muitas aplicações. Essa alteração foi feita na versão
2.7.9 do Python.

Para aplicações que exigem o antigo comportamento anterior, elas podem
passar um contexto alternativo:

   import urllib2
   import ssl

   # This disables all verification
   context = ssl._create_unverified_context()

   # This allows using a specific certificate for the host, which doesn't need
   # to be in the trust store
   context = ssl.create_default_context(cafile="/path/to/file.crt")

   urllib2.urlopen("https://invalid-cert", context=context)


PEP 493: Ferramentas de migração de verificação HTTPS para Python 2.7
---------------------------------------------------------------------

**PEP 493** fornece ferramentas de migração adicionais para provê um
processo de atualização de infraestrutura mais incremental para
ambientes contendo aplicações e serviços que dependem do processamento
historicamente permissivo de certificados de servidor ao estabelecer
conexões HTTPS de clientes. Essas adições foram feitas na versão
2.7.12 do Python.

Estas ferramentas destinam-se a ser utilizadas em casos em que as
aplicações e serviços afetados não podem ser modificados para passar
explicitamente um contexto SSL mais permissivo ao estabelecer a
ligação.

Para aplicações e serviços que não podem ser modificados, a nova
variável de ambiente "PYTHONHTTPSVERIFY" pode ser definida como "0"
para reverter todo um processo Python de volta ao comportamento
permissivo padrão do Python 2.7.8 e anteriores.

Para casos em que o código de estabelecimento da conexão não pode ser
modificado, mas a aplicação geral pode, a nova função
"ssl._https_verify_certificates()" pode ser usada para ajustar o
comportamento padrão em tempo de execução.


Novo alvo de construção "make regen-all"
----------------------------------------

Para simplificar a compilação cruzada e garantir que o CPython possa
ser compilado de forma confiável sem exigir que uma versão existente
do Python já esteja disponível, o sistema de construção baseado em
autotools não tenta mais recompilar implicitamente os arquivos gerados
com base nos tempos de modificação dos arquivos.

Em vez disso, um novo comando "make regen-all" foi adicionado para
forçar a regeneração desses arquivos quando desejado (por exemplo,
após uma versão inicial do Python já ter sido construída com base nas
versões pré-geradas).

Alvos de regeneração mais seletivos também são definidos -- veja
Makefile.pre.in para detalhes.

(Contribuição de Victor Stinner em bpo-23404.)

Novo na versão 2.7.14.


Remoção do alvo de construção "make touch"
------------------------------------------

O alvo de construção "make touch" usado anteriormente para solicitar
regeneração implícita de arquivos gerados atualizando seus tempos de
modificação foi removido.

Ele foi substituído pelo novo alvo "make regen-all".

(Contribuição de Victor Stinner em bpo-23404.)

Alterado na versão 2.7.14.


Reconhecimentos
===============

O autor gostaria de agradecer às seguintes pessoas por oferecerem
sugestões, correções e assistência com vários rascunhos deste artigo:
Nick Coghlan, Philip Jenvey, Ryan Lovett, R. David Murray, Hugh
Secker-Walker.
