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

Autor:
   Guido van Rossum

Este artigo explica os novos recursos do Python 3.0, em comparação com
o 2.6. O Python 3.0, também conhecido como "Python 3000" ou "Py3K", é
o primeiro lançamento do Python *intencionalmente incompatível com
versões anteriores*. O Python 3.0 foi lançado em 3 de dezembro de
2008. Há mais mudanças do que em um lançamento típico, e mais que são
importantes para todos os usuários do Python. No entanto, depois de
digerir as mudanças, você verá que o Python realmente não mudou tanto
assim -- em geral, estamos principalmente corrigindo aborrecimentos
bem conhecidos, e removendo muita sujeira antiga.

Este artigo não tenta fornecer uma especificação completa de todos os
novos recursos, mas tenta dar uma visão geral conveniente. Para
detalhes completos, você deve consultar a documentação do Python 3.0
e/ou as muitas PEPs referenciadas no texto. Se você quiser entender a
implementação completa e a lógica de design para um recurso
específico, as PEPs geralmente têm mais detalhes do que a documentação
regular; mas observe que as PEPs geralmente não são mantidas
atualizadas depois que um recurso foi totalmente implementado.

Devido a restrições de tempo, este documento não está tão completo
quanto deveria ser. Como sempre para um novo lançamento, o arquivo
"Misc/NEWS" na distribuição fonte contém uma riqueza de informações
detalhadas sobre cada pequena coisa que foi alterada.


Obstáculos comuns
=================

Esta seção lista as poucas mudanças que provavelmente irão lhe
atrapalhar se você estiver acostumado com o Python 2.5.


print é uma função
------------------

A instrução "print" foi substituída por uma função "print()", com
argumentos nomeados para substituir a maior parte da sintaxe especial
da antiga instrução "print" (**PEP 3105**). Exemplos:

   Old: print "The answer is", 2*2
   New: print("The answer is", 2*2)

   Old: print x,           # Trailing comma suppresses newline
   New: print(x, end=" ")  # Appends a space instead of a newline

   Old: print              # Prints a newline
   New: print()            # You must call the function!

   Old: print >>sys.stderr, "fatal error"
   New: print("fatal error", file=sys.stderr)

   Old: print (x, y)       # prints repr((x, y))
   New: print((x, y))      # Not the same as print(x, y)!

Você também pode personalizar o separador entre itens, por exemplo:

   print("There are <", 2**32, "> possibilities!", sep="")

que produz:

   There are <4294967296> possibilities!

Nota:

* A função "print()" não tem suporte ao recurso "softspace" da antiga
  instrução "print". Por exemplo, no Python 2.x, "print "A\n", "B""
  escreveria ""A\nB\n""; mas no Python 3.0, "print("A\n", "B")"
  escreve ""A\n B\n"".

* Inicialmente, você vai se pegar digitando o antigo "print x"
  bastante no modo interativo. É hora de treinar seus dedos para
  digitar "print(x)" em vez disso!

* Ao usar a ferramenta de conversão de fonte para fonte "2to3", todas
  as instruções "print" são automaticamente convertidas em chamadas de
  função "print()", então isso geralmente não é um problema para
  projetos maiores.


Visualizações e iteradores em vez de listas
-------------------------------------------

Algumas APIs conhecidas não retornam mais listas:

* Os métodos "dict.keys()", "dict.items()" e "dict.values()" de "dict"
  retornam visualizações, ou "views", em vez de listas. Por exemplo,
  isso não funciona mais: "k = d.keys(); k.sort()". Use "k =
  sorted(d)" em vez disso (isso funciona no Python 2.5 também e é
  igualmente eficiente).

* Além disso, os métodos "dict.iterkeys()", "dict.iteritems()" e
  "dict.itervalues()" não são mais suportados.

* "map()" e "filter()" retornam iteradores. Se você realmente precisa
  de uma lista e as sequências de entrada são todas de comprimento
  igual, uma solução rápida é envolver "map()" em "list()", por
  exemplo, "list(map(...))", mas uma solução melhor é frequentemente
  usar uma compreensão de lista (especialmente quando o código
  original usa "lambda"), ou reescrever o código para que ele não
  precise de uma lista. Particularmente complicado é "map()" invocado
  para os efeitos colaterais da função; a transformação correta é usar
  um laço "for" regular (já que criar uma lista seria apenas
  desperdício).

  Se as sequências de entrada não tiverem o mesmo comprimento, "map()"
  irá parar no término da mais curta das sequências. Para
  compatibilidade total com "map()" do Python 2.x, também envolva as
  sequências em "itertools.zip_longest()", por exemplo, "map(func,
  *sequences)" se torna "list(map(func,
  itertools.zip_longest(*sequences)))".

* "range()" agora se comporta como "xrange()" costumava se comportar,
  exceto que funciona com valores de tamanho arbitrário. Este último
  não existe mais.

* "zip()" agora retorna um iterador.


Comparações de ordenação
------------------------

O Python 3.0 simplificou as regras para ordenar comparações:

* Os operadores de comparação de ordenação ("<", "<=", ">=", ">")
  levantam uma exceção TypeError quando os operandos não têm uma
  ordenação natural significativa. Assim, expressões como "1 < ''", "0
  > None" ou "len <= len" não são mais válidas e, por exemplo, "None <
  None" levanta "TypeError" em vez de retornar "False". Um corolário é
  que classificar uma lista heterogênea não faz mais sentido -- todos
  os elementos devem ser comparáveis ​​entre si. Observe que isso não
  se aplica aos operadores "==" e "!=": objetos de diferentes tipos
  incomparáveis ​​sempre são comparados de forma diferente entre si.

* "builtin.sorted()" e "list.sort()" não aceitam mais o argumento
  *cmp* fornecendo uma função de comparação. Use o argumento *key* em
  vez disso. N.B. os argumentos *key* e *reverse* agora são "somente-
  nomeados".

* A função "cmp()" deve ser tratada como extinta, e o método especial
  "__cmp__()" não é mais suportado. Use "__lt__()" para classificação,
  "__eq__()" com "__hash__()" e outras comparações avançadas conforme
  necessário. (Se você realmente precisa da funcionalidade "cmp()",
  pode usar a expressão "(a > b) - (a < b)" como o equivalente para
  "cmp(a, b)".)


Inteiros
--------

* **PEP 237**: Essencialmente, "long" foi renomeado para "int". Ou
  seja, há apenas um tipo integral embutido, chamado "int"; mas ele se
  comporta principalmente como o antigo tipo "long".

* **PEP 238**: Uma expressão como "1/2" retorna um float. Use "1//2"
  para obter o comportamento de truncamento. (A última sintaxe existe
  há anos, pelo menos desde o Python 2.2.)

* A constante "sys.maxint" foi removida, pois não há mais um limite
  para o valor de inteiros. No entanto, "sys.maxsize" pode ser usado
  como um inteiro maior do que qualquer lista prática ou índice de
  string. Ele está em conformidade com o tamanho inteiro "natural" da
  implementação e é tipicamente o mesmo que "sys.maxint" em versões
  anteriores na mesma plataforma (assumindo as mesmas opções de
  construção).

* O "repr()" de um inteiro longo não inclui mais o "L" final, então o
  código que remove esse caractere incondicionalmente cortará o último
  dígito. (Use "str()" em vez disso.)

* Literais octais não estão mais no formato "0720"; em vez disso, use
  "0o720".


Texto vs. Dados em vez de Unicode vs. 8 bits
--------------------------------------------

Tudo o que você achava que sabia sobre dados binários e Unicode mudou.

* O Python 3.0 usa os conceitos de *texto* e *dados* (binários) em vez
  de strings Unicode e strings de 8 bits. Todo texto é Unicode; no
  entanto, o Unicode *codificado* é representado como dados binários.
  O tipo usado para armazenar texto é "str", o tipo usado para
  armazenar dados é "bytes". A maior diferença com a situação 2.x é
  que qualquer tentativa de misturar texto e dados no Python 3.0
  levanta "TypeError", enquanto que se você misturasse strings Unicode
  e de 8 bits no Python 2.x, funcionaria se a string de 8 bits
  contivesse apenas bytes de 7 bits (ASCII), mas você obteria
  "UnicodeDecodeError" se contivesse valores não ASCII. Esse
  comportamento específico de valor causou inúmeras caras tristes ao
  longo dos anos.

* Como consequência dessa mudança na filosofia, praticamente todo
  código que usa Unicode, codificações ou dados binários provavelmente
  terá que mudar. A mudança é para melhor, pois no mundo 2.x havia
  vários bugs relacionados à mistura de texto codificado e não
  codificado. Para estar preparado no Python 2.x, comece a usar
  "unicode" para todo texto não codificado e "str" apenas para dados
  binários ou codificados. Então a ferramenta "2to3" fará a maior
  parte do trabalho para você.

* Você não pode mais usar literais "u"..."" para texto Unicode. No
  entanto, você deve usar literais "b"..."" para dados binários.

* Como os tipos "str" e "bytes" não podem ser misturados, você deve
  sempre converter explicitamente entre eles. Use "str.encode()" para
  ir de "str" para "bytes", e "bytes.decode()" para ir de "bytes" para
  "str". Você também pode usar "bytes(s, encoding=...)" e "str(b,
  encoding=...)", respectivamente.

* Assim como "str", o tipo "bytes" é imutável. Há um tipo *mutável*
  separado para armazenar dados binários em buffer, "bytearray". Quase
  todas as APIs que aceitam "bytes" também aceitam "bytearray". A API
  mutável é baseada em "collections.MutableSequence".

* Todas as contrabarras em literais de strings brutas são
  interpretadas literalmente. Isso significa que os escapes "'\U'" e
  "'\u'" em strings brutas não são tratados de forma especial. Por
  exemplo, "r'\u20ac'" é uma string de 6 caracteres no Python 3.0,
  enquanto no 2.6, "ur'\u20ac'" era o único caractere "euro". (É claro
  que essa mudança afeta apenas literais de strings brutas; o
  caractere euro é "'\u20ac'" no Python 3.0.)

* O tipo abstrato embutido "basestring" foi removido. Use "str" em vez
  disso. Os tipos "str" e "bytes" não têm funcionalidade suficiente em
  comum para garantir uma classe base compartilhada. A ferramenta
  "2to3" (veja abaixo) substitui cada ocorrência de "basestring" por
  "str".

* Arquivos abertos como arquivos texto (ainda o modo padrão para
  "open()") sempre usam uma codificação para mapear entre strings (na
  memória) e bytes (no disco). Arquivos binários (abertos com um "b"
  no argumento mode) sempre usam bytes na memória. Isso significa que
  se um arquivo for aberto usando um modo ou codificação incorretos, a
  E/S provavelmente falhará ruidosamente, em vez de produzir dados
  incorretos silenciosamente. Isso também significa que até mesmo
  usuários Unix terão que especificar o modo correto (texto ou
  binário) ao abrir um arquivo. Há uma codificação padrão dependente
  da plataforma, que em plataformas Unixy pode ser definida com a
  variável de ambiente "LANG" (e às vezes também com algumas outras
  variáveis ​​de ambiente relacionadas à localidade específicas da
  plataforma). Em muitos casos, mas não em todos, o padrão do sistema
  é UTF-8; você nunca deve contar com esse padrão. Qualquer aplicação
  que leia ou escreva mais do que texto ASCII puro provavelmente deve
  ter uma maneira de substituir a codificação. Não há mais necessidade
  de usar os fluxos com reconhecimento de codificação no módulo
  "codecs".

* Os valores iniciais de "sys.stdin", "sys.stdout" e "sys.stderr"
  agora são arquivos texto somente unicode (ou seja, são instâncias de
  "io.TextIOBase"). Para ler e gravar dados de bytes com esses fluxos,
  você precisa usar o atributo "io.TextIOBase.buffer" deles.

* Nomes de arquivo são passados ​​e retornados de APIs como strings
  (Unicode). Isso pode apresentar problemas específicos de plataforma
  porque em algumas plataformas nomes de arquivo são strings de bytes
  arbitrárias. (Por outro lado, no Windows nomes de arquivo são
  armazenados nativamente como Unicode.) Como solução alternativa, a
  maioria das APIs (por exemplo, "open()" e muitas funções no módulo
  "os") que aceitam nomes de arquivo aceitam objetos "bytes" assim
  como strings, e algumas APIs têm uma maneira de pedir um valor de
  retorno "bytes". Assim, "os.listdir()" retorna uma lista de
  instâncias "bytes" se o argumento for uma instância "bytes", e
  "os.getcwdb()" retorna o diretório de trabalho atual como uma
  instância "bytes". Observe que quando "os.listdir()" retorna uma
  lista de strings, os nomes de arquivos que não podem ser
  decodificados corretamente são omitidos em vez de levantar
  "UnicodeError".

* Algumas APIs de sistema como "os.environ" e "sys.argv" também podem
  apresentar problemas quando os bytes disponibilizados pelo sistema
  não são interpretáveis ​​usando a codificação padrão. Definir a
  variável "LANG" e executar o programa novamente é provavelmente a
  melhor abordagem.

* **PEP 3138**: A "repr()" de uma string não escapa mais caracteres
  não-ASCII. No entanto, ele ainda escapa caracteres de controle e
  pontos de código com status não imprimível no padrão Unicode.

* **PEP 3120**: A codificação de fontes padrão agora é UTF-8.

* **PEP 3131**: Letras não ASCII agora são permitidas em
  identificadores. (No entanto, a biblioteca padrão permanece somente
  ASCII, com exceção dos nomes dos colaboradores nos comentários.)

* Os módulos "StringIO" e "cStringIO" se foram. Em vez disso, importe
  o módulo "io" e use "io.StringIO" ou "io.BytesIO" para texto e
  dados, respectivamente.

* Veja também o guia Unicode, que foi atualizado para o Python 3.0.


Visão geral das alterações da sintaxe
=====================================

Esta seção fornece uma breve visão geral de cada mudança *sintática*
no Python 3.0.


Nova sintaxe
------------

* **PEP 3107**: Anotações de argumento de função e valor de retorno.
  Isso fornece uma maneira padronizada de anotar os parâmetros e o
  valor de retorno de uma função. Não há semântica anexada a essas
  anotações, exceto que elas podem ser introspectadas em tempo de
  execução usando o atributo "__annotations__". A intenção é encorajar
  a experimentação por meio de metaclasses, decoradores ou frameworks.

* **PEP 3102**: Argumentos somente-nomeados. Parâmetros nomeados que
  ocorrem após "*args" na lista de parâmetros *devem* ser
  especificados usando a sintaxe dos nomes na chamada. Você também
  pode usar um "*" simples na lista de parâmetros para indicar que não
  aceita uma lista de argumentos de comprimento variável, mas tem
  argumentos somente-nomeados.

* Argumentos nomeados são permitidos após a lista de classes base em
  uma definição de classe. Isso é usado pela nova convenção para
  especificar uma metaclasse (veja a próxima seção), mas pode ser
  usado para outros propósitos também, desde que a metaclasse dê
  suporte.

* **PEP 3104**: instrução "nonlocal". Usando "nonlocal x", agora você
  pode atribuir diretamente a uma variável em um escopo externo (mas
  não global). "nonlocal" é uma nova palavra reservada.

* **PEP 3132**: Desempacotamento iterável estendido. Agora você pode
  escrever coisas como "a, b, *rest = some_sequence". E até mesmo
  "*rest, a = stuff". O objeto "rest" é sempre uma lista
  (possivelmente vazia); o lado direito pode ser qualquer iterável.
  Exemplo:

     (a, *rest, b) = range(5)

  Isso define *a* como "0", *b* como "4" e *rest* como "[1, 2, 3]".

* Compreensões de dicionário: "{k: v for k, v in stuff}" significa a
  mesma coisa que "dict(stuff)", mas é mais flexível. (Isto é **PEP
  274** justificada. :-)

* Definir literais, por exemplo, "{1, 2}". Note que "{}" é um
  dicionário vazio; use "set()" para um conjunto vazio. Compreensões
  de conjuntos também são suportadas; por exemplo, "{x for x in
  stuff}" significa a mesma coisa que "set(stuff)", mas é mais
  flexível.

* Novos literais octais, por exemplo, "0o720" (já em 2.6). Os antigos
  literais octais ("0720") se foram.

* Novos literais binários, por exemplo, "0b1010" (já em 2.6), e há uma
  nova função embutida correspondente, "bin()".

* Literais de bytes são introduzidos com um "b" ou "B" no início, e há
  uma nova função embutida correspondente, "bytes()".


Sintaxe alterada
----------------

* **PEP 3109** e **PEP 3134**: nova sintaxe da instrução "raise":
  "raise [*expr* [from *expr*]]". Veja abaixo.

* "as" e "with" agora são palavras reservadas. (Desde a versão 2.6, na
  verdade.)

* "True", "False" e "None" são palavras reservadas. (A versão 2.6 já
  aplicava parcialmente as restrições em "None".)

* Alteração de "except" *exc*, *var* para "except" *exc* "as" *var*.
  Veja a **PEP 3110**.

* **PEP 3115**: Nova sintaxe de metaclasse. Em vez de:

     class C:
         __metaclass__ = M
         ...

  agora você deve usar:

     class C(metaclass=M):
         ...

  A variável global do módulo "__metaclass__" não é mais suportada.
  (Era uma ajuda para facilitar a mudança do padrão para classes de
  novo estilo sem derivar cada classe de "object".)

* As compreensões de lista não têm mais suporte a mais a forma
  sintática "[... for *var* in *item1*, *item2*, ...]". Use "[... for
  *var* in (*item1*, *item2*, ...)]" em vez disso. Observe também que
  as compreensões de lista têm semântica diferente: elas estão mais
  próximas do açúcar sintático para uma expressão geradora dentro de
  um construtor "list()" e, em particular, as variáveis ​​de controle
  de laço não são mais vazadas para o escopo circundante.

* As *reticências* ("...") podem ser usadas como uma expressão atômica
  em qualquer lugar. (Anteriormente, eram permitidas apenas em
  fatias.) Além disso, agora *devem* ser escritas como "...".
  (Anteriormente, também poderiam ser escritas como ". . .", por um
  mero acidente da gramática.)


Sintaxe removida
----------------

* **PEP 3113**: Desempacotamento de parâmetro de tupla removido. Você
  não pode mais escrever "def foo(a, (b, c)): ...". Em vez disso, use
  "def foo(a, b_c): b, c = b_c".

* Removidos backticks (use "repr()").

* Removido "<>" (use "!=").

* Removida palavra reservada: "exec()" não é mais uma palavra
  reservada; ela permanece como uma função. (Felizmente a sintaxe da
  função também era aceita nas versões 2.x.) Observe também que
  "exec()" não aceita mais um argumento de fluxo; em vez de "exec(f)"
  você pode usar "exec(f.read())".

* Literais de inteiro não mais têm suporte a um "l" ou "L" final.

* Literais de string não mais têm suporte a um "u" ou "U" no início.

* A sintaxe "from" *módulo* "import" "*" é permitida somente no nível
  do módulo, não mais dentro de funções.

* A única sintaxe aceitável para importações relativas é "from
  .[*module*] import *name*". Todos as formas de "import" que não
  começam com "." são interpretadas como importações absolutas. (**PEP
  328**)

* As classes clássicas se foram.


Mudanças já presentes no Python 2.6
===================================

Como muitos usuários provavelmente fazem o salto direto do Python 2.5
para o Python 3.0, esta seção lembra o leitor dos novos recursos que
foram originalmente projetados para o Python 3.0, mas que foram
portados de volta para o Python 2.6. As seções correspondentes em O
que há de novo no Python 2.6 devem ser consultadas para descrições
mais longas.

* PEP 343: The 'with' statement. A instrução "with" agora é um recurso
  padrão e não precisa mais ser importada de "__future__". Confira
  também Writing Context Managers e The contextlib module.

* PEP 366: Explicit Relative Imports From a Main Module. Isso aumenta
  a utilidade da opção "-m" quando o módulo referenciado reside em um
  pacote.

* PEP 370: Per-user site-packages Directory.

* PEP 371: The multiprocessing Package.

* PEP 3101: Advanced String Formatting. Nota: a descrição da versão
  2.6 menciona o método "format()" para strings de 8 bits e Unicode.
  No 3.0, apenas o tipo "str" (strings de texto com suporte a Unicode)
  tem suporte a esse método; o tipo "bytes" não. O plano é
  eventualmente tornar esta a única API para formatação de strings e
  começar a descontinuar o operador "%" no Python 3.1.

* PEP 3105: print As a Function. Este é agora um recurso padrão e não
  precisa mais ser importado de "__future__". Mais detalhes foram
  fornecidos acima.

* PEP 3110: Exception-Handling Changes. A sintaxe "except" *exc* "as"
  *var* agora é padrão e "except" *exc*, *var* não é mais suportado.
  (Claro, a parte "as" *var* ainda é opcional.)

* PEP 3112: Byte Literals. A notação de literal de string "b"..."" (e
  suas variantes como "b'...'", "b"""..."""" e "br"..."") agora produz
  um literal do tipo "bytes".

* PEP 3116: New I/O Library. O módulo "io" agora é a maneira padrão de
  fazer E/S de arquivo. A função embutida "open()" agora é um apelido
  para "io.open()" e tem argumentos nomeados adicionais *encoding*,
  *errors*, *newline* e *closefd*. Observe também que um argumento
  *mode* inválido agora levanta "ValueError", não "IOError". O objeto
  arquivo binário subjacente a um objeto arquivo texto pode ser
  acessado como "f.buffer" (mas tome cuidado, pois o objeto texto
  mantém um buffer de si mesmo para acelerar as operações de
  codificação e decodificação).

* PEP 3118: Revised Buffer Protocol. A antiga função embutida
  "buffer()" agora realmente se foi; a nova função embutida
  "memoryview()" fornece funcionalidade (principalmente) semelhante.

* PEP 3119: Abstract Base Classes. O módulo "abc" e as ABCs definidas
  no módulo "collections" desempenham um papel um pouco mais
  proeminente na linguagem agora, e tipos embutidos de coleção como
  "dict" e "list" estão em conformidade com as ABCs
  "collections.MutableMapping" e "collections.MutableSequence",
  respectivamente.

* PEP 3127: Integer Literal Support and Syntax. Conforme mencionado
  acima, a nova notação de literal octal é a única suportada, e
  literais binários foram adicionados.

* PEP 3129: Class Decorators.

* PEP 3141: A Type Hierarchy for Numbers. O módulo "numbers" é outro
  novo uso de ABCs, definindo a "torre numérica" do Python. Observe
  também o novo módulo "fractions" que implementa "numbers.Rational".


Mudanças na biblioteca
======================

Devido a restrições de tempo, este documento não cobre exaustivamente
as mudanças muito extensas na biblioteca padrão. **PEP 3108** é a
referência para as principais mudanças na biblioteca. Aqui está uma
revisão resumida:

* Muitos módulos antigos foram removidos. Alguns, como "gopherlib"
  (não mais usado) e "md5" (substituído por "hashlib"), já tinham sido
  descontinuados pela **PEP 4**. Outros foram removidos como resultado
  da remoção do suporte para várias plataformas, como Irix, BeOS e Mac
  OS 9 (veja **PEP 11**). Alguns módulos também foram selecionados
  para remoção no Python 3.0 devido à falta de uso ou porque existe
  uma substituição melhor. Veja **PEP 3108** para uma lista exaustiva.

* O pacote "bsddb3" foi removido porque sua presença na biblioteca
  padrão principal provou ao longo do tempo ser um fardo particular
  para os desenvolvedores principais devido à instabilidade dos testes
  e ao cronograma de lançamento do Berkeley DB. No entanto, o pacote
  está vivo e bem, mantido externamente em
  https://www.jcea.es/programacion/pybsddb.htm.

* Alguns módulos foram renomeados porque seu nome antigo desobedecia a
  **PEP 8**, ou por vários outros motivos. Aqui está a lista:

  +-------------------------+-------------------------+
  | Old Name                | Novo nome               |
  |=========================|=========================|
  | _winreg                 | winreg                  |
  +-------------------------+-------------------------+
  | ConfigParser            | configparser            |
  +-------------------------+-------------------------+
  | copy_reg                | copyreg                 |
  +-------------------------+-------------------------+
  | Queue                   | queue                   |
  +-------------------------+-------------------------+
  | SocketServer            | socketserver            |
  +-------------------------+-------------------------+
  | markupbase              | _markupbase             |
  +-------------------------+-------------------------+
  | repr                    | reprlib                 |
  +-------------------------+-------------------------+
  | test.test_support       | test.support            |
  +-------------------------+-------------------------+

* Um padrão comum no Python 2.x é ter uma versão de um módulo
  implementada em Python puro, com uma versão acelerada opcional
  implementada como uma extensão C; por exemplo, "pickle" e "cPickle".
  Isso coloca o fardo de importar a versão acelerada e recorrer à
  versão Python pura em cada usuário desses módulos. No Python 3.0, as
  versões aceleradas são consideradas detalhes de implementação das
  versões Python puras. Os usuários devem sempre importar a versão
  padrão, que tenta importar a versão acelerada e recorrer à versão
  Python pura. O par "pickle" / "cPickle" recebeu esse tratamento. O
  módulo "profile" está na lista para 3.1. O módulo "StringIO" foi
  transformado em uma classe no módulo "io".

* Alguns módulos relacionados foram agrupados em pacotes e,
  geralmente, os nomes dos submódulos foram simplificados. Os novos
  pacotes resultantes são:

  * "dbm" ("anydbm", "dbhash", "dbm", "dumbdbm", "gdbm", "whichdb").

  * "html" ("HTMLParser", "htmlentitydefs").

  * "http" ("httplib", "BaseHTTPServer", "CGIHTTPServer",
    "SimpleHTTPServer", "Cookie", "cookielib").

  * "tkinter" (todos os módulos relacionados a "Tkinter", exceto
    "turtle"). O público-alvo de "turtle" não se importa muito com
    "tkinter". Observe também que, a partir do Python 2.6, a
    funcionalidade de "turtle" foi bastante aprimorada.

  * "urllib" ("urllib", "urllib2", "urlparse", "robotparse").

  * "xmlrpc" ("xmlrpclib", "DocXMLRPCServer", "SimpleXMLRPCServer").

Algumas outras mudanças nos módulos da biblioteca padrão, não cobertas
pela **PEP 3108**:

* "sets" eliminado. Use a classe embutida "set()".

* Limpeza do módulo "sys": removidos "sys.exitfunc()",
  "sys.exc_clear()", "sys.exc_type", "sys.exc_value",
  "sys.exc_traceback". (Observe que "sys.last_type" etc. permanecem.)

* Limpeza do tipo "array.array": os métodos "read()" e "write()" foram
  removidos; use "fromfile()" e "tofile()" em vez disso. Além disso, o
  typecode "'c'" para vetor foi removido -- use "'b'" para bytes ou
  "'u'" para caracteres Unicode.

* Limpeza do módulo "operator": removidos "sequenceIncludes()" e
  "isCallable()".

* Limpeza do módulo "thread": "acquire_lock()" e "release_lock()"
  foram removidos; use "acquire()" e "release()" em vez disso.

* Limpeza do módulo "random": removida a API "jumpahead()".

* O módulo "new" foi removido.

* As funções "os.tmpnam()", "os.tempnam()" e "os.tmpfile()" foram
  removidas em favor do módulo "tempfile".

* O módulo "tokenize" foi alterado para funcionar com bytes. O ponto
  de entrada principal agora é "tokenize.tokenize()", em vez de
  generate_tokens.

* "string.letters" e seus amigos ("string.lowercase" e
  "string.uppercase") se foram.  Use "string.ascii_letters" etc. em
  vez disso.  (O motivo da remoção é que "string.letters" e amigos
  tinham comportamento específico de localidade, o que é uma má ideia
  para "constantes" globais com nomes tão atraentes.)

* Renomeado o módulo "__builtin__" para "builtins" (removendo os
  sublinhados, adicionando um 's'). A variável "__builtins__"
  encontrada na maioria dos espaços de nomes globais não foi alterada.
  Para modificar um builtin, você deve usar "builtins", não
  "__builtins__"!


**PEP 3101**: Uma nova abordagem para formatação de strings
===========================================================

* Um novo sistema para operações de formatação de strings embutidas
  substitui o operador de formatação de strings "%". (No entanto, o
  operador "%" ainda é suportado; ele será descontinuado no Python 3.1
  e removido da linguagem em algum momento posterior.) Leia a **PEP
  3101** para obter informações completas.


Mudanças para exceções
======================

As APIs para levantar e capturar exceções foram limpas e novos
recursos poderosos foram adicionados:

* **PEP 352**: Todas as exceções devem ser derivadas (direta ou
  indiretamente) de "BaseException". Esta é a raiz da hierarquia de
  exceções. Isso não é novo como recomendação, mas o *requisito* para
  herdar de "BaseException" é novo. (O Python 2.6 ainda permitia que
  classes clássicas fossem levantadas e não colocava nenhuma restrição
  sobre o que você pode capturar.) Como consequência, exceções de
  string estão finalmente verdadeira e completamente mortas.

* Quase todas as exceções devem derivar de "Exception";
  "BaseException" deve ser usado apenas como uma classe base para
  exceções que devem ser manipuladas apenas no nível superior, como
  "SystemExit" ou "KeyboardInterrupt". O idioma recomendado para
  manipular todas as exceções, exceto para esta última categoria, é
  usar "except" "Exception".

* "StandardError" foi removida.

* As exceções não se comportam mais como sequências. Use o atributo
  "args" em vez disso.

* **PEP 3109**: levantando exceções. Agora você deve usar "raise
  *Exception*(*args*)" em vez de "raise *Exception*, *args*". Além
  disso, você não pode mais especificar explicitamente um traceback
  (situação da pilha de execução); em vez disso, se você *precisar*
  fazer isso, você pode atribuir diretamente ao atributo
  "__traceback__" (veja abaixo).

* **PEP 3110**: Capturando exceções. Agora você deve usar "except
  *SomeException* as *variable*" em vez de "except *SomeException*,
  *variable*". Além disso, a variável *variable* é explicitamente
  excluída quando o bloco "except" é deixado.

* **PEP 3134**: Encadeamento de exceções. Existem dois casos:
  encadeamento implícito e encadeamento explícito. O encadeamento
  implícito acontece quando uma exceção é levantada em um bloco
  manipulador "except" ou "finally". Isso geralmente acontece devido a
  um bug no bloco do manipulador; chamamos isso de exceção
  *secundária*. Nesse caso, a exceção original (que estava sendo
  manipulada) é salva como o atributo "__context__" da exceção
  secundária. O encadeamento explícito é invocado com esta sintaxe:

     raise SecondaryException() from primary_exception

  (onde *primary_exception* é qualquer expressão que produz um objeto
  de exceção, provavelmente uma exceção que foi capturada
  anteriormente). Neste caso, a exceção primária é armazenada no
  atributo "__cause__" da exceção secundária. O traceback impresso
  quando uma exceção não tratada ocorre percorre a cadeia de atributos
  "__cause__" e "__context__" e imprime um traceback separado para
  cada componente da cadeia, com a exceção primária no topo. (Usuários
  Java podem reconhecer este comportamento.)

* **PEP 3134**: Objetos exceção agora armazenam seu traceback como o
  atributo "__traceback__". Isso significa que um objeto de exceção
  agora contém todas as informações pertencentes a uma exceção, e há
  menos motivos para usar "sys.exc_info()" (embora o último não seja
  removido).

* Algumas mensagens de exceção estão melhores quando o Windows falha
  ao carregar um módulo de extensão. Por exemplo, "error code 193"
  agora é "%1 is not a valid Win32 application". As strings agora
  lidam com localidades que não sejam em inglês.


Outras mudanças diversas
========================


Operadores e métodos especiais
------------------------------

* "!=" agora retorna o oposto de "==", a menos que "==" retorne
  "NotImplemented".

* O conceito de "métodos não vinculados" foi removido da linguagem. Ao
  referenciar um método como um atributo de classe, agora você obtém
  um objeto função simples.

* "__getslice__()", "__setslice__()" e "__delslice__()" foram
  eliminados. A sintaxe "a[i:j]" agora é traduzida para
  "a.__getitem__(slice(i, j))" (ou "__setitem__()" ou "__delitem__()",
  quando usado como um alvo de atribuição ou exclusão,
  respectivamente).

* **PEP 3114**: o método padrão "next()" foi renomeado para
  "__next__()".

* Os métodos especiais "__oct__()" e "__hex__()" foram removidos --
  "oct()" e "hex()" usam "__index__()" agora para converter o
  argumento em um inteiro.

* Removido o suporte para "__members__" e "__methods__".

* Os atributos de função chamados "func_X" foram renomeados para usar
  o formato "__X__", liberando esses nomes no espaço de nomes de
  atributos de função para atributos definidos pelo usuário. A saber,
  "func_closure", "func_code", "func_defaults", "func_dict",
  "func_doc", "func_globals", "func_name" foram renomeados para
  "__closure__", "__code__", "__defaults__", "__dict__", "__doc__",
  "__globals__", "__name__", respectivamente.

* "__nonzero__()" agora é "__bool__()".


Funções embutidas
-----------------

* **PEP 3135**: Nova função "super()". Agora você pode invocar
  "super()" sem argumentos e (presumindo que isso esteja em um método
  de instância regular definido dentro de uma instrução "class") a
  classe e instância corretas serão automaticamente escolhidas. Com
  argumentos, o comportamento de "super()" não é alterado.

* **PEP 3111**: "raw_input()" foi renomeada para "input()". Ou seja, a
  nova função "input()" lê uma linha de "sys.stdin" e a retorna com a
  nova linha final removida. Ela levanta "EOFError" se a entrada for
  encerrada prematuramente. Para obter o comportamento antigo de
  "input()", use "eval(input())".

* Uma nova função embutido "next()" foi adicionada para chamar o
  método "__next__()" em um objeto.

* A estratégia de arredondamento da função "round()" e o tipo de
  retorno foram alterados. Casos exatos de meio caminho agora são
  arredondados para o resultado par mais próximo em vez de para longe
  de zero. (Por exemplo, "round(2.5)" agora retorna "2" em vez de
  "3".) "round(x[, n])" agora delega para "x.__round__([n])" em vez de
  sempre retornar um float. Geralmente retorna um inteiro quando
  chamado com um único argumento e um valor do mesmo tipo que "x"
  quando chamado com dois argumentos.

* Movida "intern()" para "sys.intern()".

* Removida: "apply()". Em vez de "apply(f, args)" use "f(*args)".

* Removida "callable()". Em vez de "callable(f)" você pode usar
  "isinstance(f, collections.Callable)". A função
  "operator.isCallable()" também foi removida.

* Removida "coerce()". Esta função não tem mais propósito agora que as
  classes clássicas desapareceram.

* Removida "execfile()". Em vez de "execfile(fn)" use
  "exec(open(fn).read())".

* Removido o tipo "file". Use "open()". Agora há vários tipos
  diferentes de fluxos que open pode retornar no módulo "io".

* Removida "reduce()". Use "functools.reduce()" se realmente precisar;
  no entanto, 99 por cento das vezes um laço explícito "for" é mais
  legível.

* Removed "reload()".  Use "imp.reload()".

* Removida. "dict.has_key()" -- use o operador "in" em vez disso.


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

Devido a restrições de tempo, aqui está uma lista *muito* incompleta
de alterações na API C.

* O suporte para várias plataformas foi descartado, incluindo, mas não
  se limitando a Mac OS 9, BeOS, RISCOS, Irix e Tru64.

* **PEP 3118**: Nova API de Buffer.

* **PEP 3121**: Inicialização e finalização do módulo de extensão.

* **PEP 3123**: Tornando "PyObject_HEAD" conforme o padrão C.

* Não há mais suporte à API C para execução restrita.

* As APIs C "PyNumber_Coerce()", "PyNumber_CoerceEx()",
  "PyMember_Get()" e "PyMember_Set()" foram removidas.

* Nova API C "PyImport_ImportModuleNoBlock()", funciona como
  "PyImport_ImportModule()", mas não bloqueia na trava de importação
  (retornando um erro).

* Renomeado o slot e o método de nível C de conversão booleana:
  "nb_nonzero" agora é "nb_bool".

* Removidas "METH_OLDARGS" e "WITH_CYCLE_GC" da API C.


Desempenho
==========

O resultado líquido das generalizações do 3.0 é que o Python 3.0
executa o benchmark pystone cerca de 10% mais lento que o Python 2.5.
Provavelmente a maior causa é a remoção do uso de maiúsculas e
minúsculas especiais para números inteiros pequenos. Há espaço para
melhorias, mas isso acontecerá após o lançamento do 3.0!


Portando para o Python 3.0
==========================

Para portar o código-fonte existente do Python 2.5 ou 2.6 para o
Python 3.0, a melhor estratégia é a seguinte:

* (Pré-requisito:) Comece com uma excelente cobertura de teste.

* Portar para o Python 2.6. Isso não deve dar mais trabalho do que o
  port médio do Python 2.x para o Python 2.(x+1). Certifique-se de que
  todos os seus testes passem.

* (Ainda usando 2.6:) Ative a opção de linha de comando "-3". Isso
  habilita avisos sobre recursos que serão removidos (ou alterados) no
  3.0. Execute seu conjunto de testes novamente e corrija o código
  sobre o qual você recebe avisos até que não haja mais avisos e todos
  os seus testes ainda passem.

* Execute o tradutor de fonte para fonte "2to3" sobre sua árvore de
  código-fonte. (Veja 2to3 --- Tradução Automatizada de Código Python
  2 para 3 para mais informações sobre esta ferramenta.) Execute o
  resultado da tradução no Python 3.0. Corrija manualmente quaisquer
  problemas restantes, corrigindo os problemas até que todos os testes
  passem novamente.

Não é recomendado tentar escrever código-fonte que seja executado
inalterado no Python 2.6 e 3.0; você teria que usar um estilo de
codificação muito distorcido, por exemplo, evitando instruções
"print", metaclasses e muito mais. Se você estiver mantendo uma
biblioteca que precisa ter suporte ao Python 2.6 e Python 3.0, a
melhor abordagem é modificar a etapa 3 acima editando a versão 2.6 do
código-fonte e executando o tradutor "2to3" novamente, em vez de
editar a versão 3.0 do código-fonte.

Para portar extensões C para Python 3.0, consulte Portando módulos de
extensão para o Python 3.
