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.)

• The StringIO and cStringIO modules are gone. Instead, import the io module and use io.StringIO or io.BytesIO for text and data respectively.

• 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:

• Many old modules were removed. Some, like gopherlib (no longer used) and md5 (replaced by hashlib), were already deprecated by PEP 4. Others were removed as a result of the removal of support for various platforms such as Irix, BeOS and Mac OS 9 (see PEP 11). Some modules were also selected for removal in Python 3.0 due to lack of use or because a better replacement exists. See PEP 3108 for an exhaustive list.

• The bsddb3 package was removed because its presence in the core standard library has proved over time to be a particular burden for the core developers due to testing instability and Berkeley DB’s release schedule. However, the package is alive and well, externally maintained at 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

• A common pattern in Python 2.x is to have one version of a module implemented in pure Python, with an optional accelerated version implemented as a C extension; for example, pickle and cPickle. This places the burden of importing the accelerated version and falling back on the pure Python version on each user of these modules. In Python 3.0, the accelerated versions are considered implementation details of the pure Python versions. Users should always import the standard version, which attempts to import the accelerated version and falls back to the pure Python version. The pickle / cPickle pair received this treatment. The profile module is on the list for 3.1. The StringIO module has been turned into a class in the io module.

• 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:

• Killed sets. Use the built-in set() class.

• 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().

• Cleanup of the thread module: acquire_lock() and release_lock() are gone; use acquire() and release() instead.

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

• The new module is gone.

• 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: Raising exceptions. You must now use raise Exception(args) instead of raise Exception, args. Additionally, you can no longer explicitly specify a traceback; instead, if you have to do this, you can assign directly to the __traceback__ attribute (see below).

• 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: Exception chaining. There are two cases: implicit chaining and explicit chaining. Implicit chaining happens when an exception is raised in an except or finally handler block. This usually happens due to a bug in the handler block; we call this a secondary exception. In this case, the original exception (that was being handled) is saved as the __context__ attribute of the secondary exception. Explicit chaining is invoked with this syntax:

  raise SecondaryException() from primary_exception
  

  (where primary_exception is any expression that produces an exception object, probably an exception that was previously caught). In this case, the primary exception is stored on the __cause__ attribute of the secondary exception. The traceback printed when an unhandled exception occurs walks the chain of __cause__ and __context__ attributes and prints a separate traceback for each component of the chain, with the primary exception at the top. (Java users may recognize this behavior.)

• PEP 3134: Exception objects now store their traceback as the __traceback__ attribute. This means that an exception object now contains all the information pertaining to an exception, and there are fewer reasons to use sys.exc_info() (though the latter is not removed).

• 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__.

• The function attributes named func_X have been renamed to use the __X__ form, freeing up these names in the function attribute namespace for user-defined attributes. To wit, func_closure, func_code, func_defaults, func_dict, func_doc, func_globals, func_name were renamed to __closure__, __code__, __defaults__, __dict__, __doc__, __globals__, __name__, respectively.

• __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.

• PyNumber_Coerce(), PyNumber_CoerceEx(), PyMember_Get(), and PyMember_Set() C APIs are removed.

• 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.

• Removed METH_OLDARGS and WITH_CYCLE_GC from the C API.

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:

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

1. 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.

2. (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.

3. 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.