Diferenças e mudanças de gramática entre python2 e python3

Quase todos os programas Python 2 precisam de algumas modificações para funcionar corretamente no ambiente Python 3. Para simplificar a conversão, o Python 3 traz um script utilitário chamado 2to3 (Utility Script), que toma o arquivo de origem do seu programa Python 2 como entrada e o converte automaticamente no formato Python 3. O estudo de caso: Porting chardet to Python 3 descreve como executar o script e depois mostra algumas situações em que ele não pode ser corrigido automaticamente.

• #### A frase print

No Python 2, print é uma frase. Qualquer coisa que você queira expor, basta colocá-la atrás da palavra-chave print. No Python 3, print () é uma função. Como outras funções, print () requer que você passe o que deseja expor como um parâmetro.

Notes	Python 2	Python 3
①	print	print()
②	print 1	print(1)
③	print 1,2	print(1,2)
④	print 1,2,	print(1,2,end=’ ‘)
⑤	print >>sys.stderr,1,2,3	print(1,2,3, file=sys.stderr)

1 , para a saída de uma linha em branco, é necessário chamar print sem parâmetros ((() ◦ 2 , para a saída de um valor isolado, é necessário que este valor seja um dos parâmetros print (). 3 , para a saída, use dois valores separados por um espaço, usando dois argumentos para chamar print (). No Python 2, se você usar uma vírgula ((() como o final da frase print, ela separará o resultado da saída com um espaço, e depois irá traçar um espaço de seguimento (((trailing space), em vez de trazer o retorno (((carriage return)). No Python 3, o mesmo efeito pode ser obtido passando end=’ ‘ como um parâmetro de palavra-chave para print ((). O valor padrão do parâmetro end é ‘\n’, então o valor do parâmetro end pode ser removido ao final do retorno de saída. No Python 2, você pode redirecionar a saída para um pipeline usando a sintaxe>>pipe_name, como sys.stderr. No Python 3, você pode fazer o mesmo passando o valor do pipeline como um parâmetro de arquivo de palavras-chave para o print (). O valor padrão do arquivo de parâmetros é std.stdout, então redirecionar o valor dele fará com que o print () exporte para outro pipeline.

• #### Estribo de Unicode

Python 2 tem dois tipos de string:Estribo de UnicodeeString não UnicodeO Python 3 tem apenas um tipo:Strings em Unicode。

Notes	Python 2	Python 3
①	u’PapayaWhip’	‘PapayaWhip’
②	ur’PapayaWhip\foo’	r’PapayaWhip\foo’

As strings do Unicode no Python 2 são as strings comuns no Python 3, porque no Python 3 as strings são sempre em Unicode. A string original do Unicode ((raw string) (() é uma string que o Python não traduz automaticamente para a linha invertida.“) também foi substituído por uma simples string, pois em Python 3, todas as strings originais são codificadas em Unicode .

• #### Funções globais (unicode)

O Python 2 tem duas funções globais que podem forçar a conversão de objetos em strings: unicode ((() que converte os objetos em strings Unicode, e str ((() que converte os objetos em strings não-Unicode. O Python 3 tem apenas um tipo de string, o string Unicode, então a função str ((() pode fazer tudo isso.A função unicode() não existe mais no Python 3.)

Notes	Python 2	Python 3
①	unicode(anything)	str(anything)

• #### longos e inteiros

O Python 2 tem os tipos int e long disponíveis para números não floatados. O valor máximo do tipo int não pode exceder sys.maxint, e esse valor máximo é relevante para a plataforma. O tipo inteiro longo pode ser definido adicionando um L ao final do número, o que é, obviamente, maior que o alcance do número representado pelo tipo int. No Python 3, há apenas um tipo inteiro int, que na maioria dos casos é muito parecido com o tipo inteiro longo no Python 2. Como os dois tipos de inteiros não existem, não é necessário usar uma gramática especial para diferenciá-los.

Leia mais: PEP 237: Unificação de longas e inteiras formas.

Notes	Python 2	Python 3
①	x = 1000000000000L	x = 1000000000000
②	x = 0xFFFFFFFFFFFFL	x = 0xFFFFFFFFFFFF
③	long(x)	int(x)
④	type(x) is long	type(x) is int
⑤	isinstance(x,long)	isinstance(x,int)

O inteiro decimal longo no Python 2 foi substituído pelo inteiro decimal comum no Python 3. O inteiro de dezesseis dígitos no Python 2 foi substituído pelo inteiro normal de dezesseis dígitos no Python 3. No Python 3, os longos inteiros já não existem.A função natural long () também não existe. Para forçar a conversão de uma variável para um inteiro, pode-se usar a função int ()。 Verificar se uma variável é inteira, obter seu tipo de dados e compará-la com um int do tipo ((não long)). Você também pode usar a função insinstance (()) para verificar o tipo de dados; enfatizando mais uma vez, use int, em vez de long, para verificar o tipo inteiro。

• #### <> Comparar o operador

O Python 2 suporta <> como sinônimo de !=. O Python 3 só suporta!=, já não é suportado <>.

Notes	Python 2	Python 3
①	if x <> y:	if x != y:
②	if x <> y<> z:	if x != y!= z:

1. Simplesmente comparar
2. Comparação entre três valores relativamente complexos.

• #### Método de classe de dicionário has_key()

Em Python 2, o has de um objeto de dicionário_key() método usado para testar se o dicionário contém uma determinada chave (((key) ❚ O Python 3 não suporta mais este método ❚ Você precisa usarinOperador

Notes	Python 2	Python 3
①	a_dictionary.has_key(‘PapayaWhip’)	‘PapayaWhip’ in a_dictionary
②	a_dictionary.has_key(x) or a_dictionary.has_key(y)	x in a_dictionary or y in a_dictionary
③	a_dictionary.has_key(x or y)	(x or y) in a_dictionary
④	a_dictionary.has_key(x + y)	(x + y) in a_dictionary
⑤	x + a_dictionary.has_key(y)	x + (y in a_dictionary)

1, a forma mais simples. 2. O operador or tem menor prioridade do que o operador in, portanto não é necessário adicionar parênteses . 3, por outro lado, para o mesmo motivo, o or tem menor prioridade do que o in, e aqui é necessário adicionar parênteses. Nota: o código aqui é completamente diferente do da linha anterior. O Python interpreta primeiro x ou y, obtendo o resultado x (se o valor do contexto de x no booleano é verdadeiro) ou y. Então o Python verifica se o resultado é a_Uma das chaves do dicionário. 4, o operador in tem menor prioridade do que o operador +, então essa forma no código não precisa de parênteses, mas 2to3 é adicionado. 5. Essa forma precisa de parênteses, pois a prioridade de in é menor do que a prioridade de +。

• #### Métodos de classe de dicionário que retornam a lista

Em Python 2, muitos métodos de classe de dicionário retornam lists. Os métodos mais usados são os que têm chaves, items e valores. Em Python 3, todos os métodos acima retornam valores para uma visão dinâmica. Em alguns contextos, essa mudança não tem efeito. Se os valores de retorno desses métodos forem imediatamente transmitidos a outra função, e essa função percorrer toda a sequência, o retorno dos métodos acima é uma lista ou uma visão e não produzirá nenhuma diferença.

Notes	Python 2	Python 3
①	a_dictionary.keys()	list(a_dictionary.keys())
②	a_dictionary.items()	list(a_dictionary.items())
③	a_dictionary.iterkeys()	iter(a_dictionary.keys())
④	[i for iin a_dictionary.iterkeys()]	[i for iin a_dictionary.keys()]
⑤	min(a_dictionary.keys())	no change

A função list () converte o valor de retorno de keys () em uma lista estática. Por razões de segurança, 2to3 pode falhar. Esse tipo de código é eficaz, mas é menos eficiente para o uso de visualizações. 2 , esta é uma outra visão sobre a conversão de () para a lista de () para o método de () para o método de () para a lista de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para o método de () para 3 , O Python 3 não suporta mais as chaves iter ((). Se necessário, use iter (() para transformar o valor de retorno de chaves () em um iterador . 4, 2to3 é capaz de identificar que o método iterkeys () é usado na análise de listas, e depois transformá-lo para o método keys () do Python 3 (sem a necessidade de usar um iter adicional para empacotar o valor de retorno). Isso é possível porque a visão é iterável. 5 2to3 também pode identificar que o valor de retorno do método keys ((() é imediatamente transmitido a outra função que percorrerá toda a sequência, portanto não há necessidade de converter o valor de retorno do keys ((() em uma lista. Pelo contrário, a função min ((() será feliz em percorrer a vista. Este processo é igualmente eficaz para min (((), max (((), sum (((), list (((), tuple (((), set (((), sorted (((), any ((() e all (().

• #### Módulos rebatizados ou reorganizados

Desde o Python 2 até o Python 3, alguns módulos da biblioteca padrão foram renomeados. Outros módulos inter-relacionados também foram combinados ou reorganizados para tornar essa associação mais lógica.

• http No Python 3, vários módulos HTTP relacionados são combinados em um pacote separado, chamado http.

Notes	Python 2	Python 3
①	import httplib	import http.client
②	import Cookie	import http.cookies
③	import cookielib	import http.cookiejar
④	import BaseHTTPServer import SimpleHTTPServer import CGIHttpServer	import http.server

O módulo http.client implementa uma biblioteca subjacente que pode ser usada para solicitar recursos HTTP e analisar a resposta HTTP. O módulo http.cookies fornece uma interface Python para obter cookies enviados pelo Set-Cookie através do cabeçalho HTTP Na maioria dos navegadores, os cookies são armazenados em disco como arquivos, que podem ser manipulados pelo módulo http.cookiejar. O módulo http.server implementa um servidor HTTP básico

• urllib O Python 2 tem alguns módulos para analisar, codificar e obter URLs, mas eles se sobrepõem uns aos outros como se fosse uma caixa de ratos. No Python 3, esses módulos são reestruturados e integrados em um pacote separado, o urllib.

Notes	Python 2	Python 3
①	import urllib	import urllib.request urllib.parse,urllib.error
②	import urllib2	import urllib.request urllib.error
③	import urlparse	import urllib.parse
④	import robotparser	import urllib.robotparser
⑤	from urllib import FancyURLopener from urllib import urlencode	from urllib.request import FancyURLopener from urllib.parse import urlencode
⑥	from urllib2 import Request from urllib2 import HTTPError	from urllib.request import Request from urllib.error import HTTPError

Anteriormente, o módulo urllib no Python 2 tinha uma variedade de funções, incluindo a função urlopen () usada para obter dados, e também era útil para dividir o URL em seus componentes como as funções splitype () e splitost () e splituser (). No novo pacote urllib, essas funções são organizadas de forma mais lógica. 2to3 irá modificar a chamada dessas funções para se adaptar ao novo esquema de nomeação. No Python 3, os módulos anteriores do urllib2 foram incorporados ao pacote urllib. Ao mesmo tempo, todas as coisas que você mais gosta no urllib2 aparecerão no módulo urllib do Python 3, como build_O opener () método, o objeto de solicitação, o HTTPBasicAuthHandler e os amigos. O módulo urllib.parse do Python 3 contém todas as funções de partilha do módulo urlparse do Python 2. O módulo urllib.robotparse analisa o arquivo robots.txt. A classe FancyURLopener, que lida com redirecionamentos HTTP e outros códigos de status, permanece ativa no módulo urllib.request do Python 3. A função ❚urlencode() foi transferida para o urllib.parse. O objeto Request permanece válido em urllib.request, mas constantes como HTTPError foram transferidas para urllib.error. Eu mencionei que o 2to3 também reescreveria suas chamadas de função? Por exemplo, se você importar o módulo urllib em seu código Python 2 e chamar a função urllib.urlopen (() para obter dados, o 2to3 irá modificar a import statement e a chamada de função ao mesmo tempo.

Notes	Python 2	Python 3
①	import urllib print urllib.urlopen(’http://diveintopython3.org/‘).read()	import urllib.request, urllib.parse, urllib.error print(urllib.request.urlopen(’http://diveintopython3.org/‘).read())

• dbm Todos os clones do DBM estão agora em um pacote separado, o dbm. Se você precisar de uma variante específica, como o GNUDBM, você pode importar o módulo apropriado do pacote dbm.

Notes	Python 2	Python 3
①	import dbm	import dbm.ndbm
②	import gdbm	import dbm.gnu
③	import dbhash	import dbm.bsd
④	import dumbdbm	import dbm.dumb
⑤	import anydbm import whichdb	import dbm

• xmlrpc O XML-RPC é um método de nível leve para executar chamadas de RPC remotas através do protocolo HTTP. Algumas das bibliotecas de implementações do cliente XML-RPC e do servidor XML-RPC agora são combinadas em pacotes separados, ou seja, xmlrpc.

Notes	Python 2	Python 3
①	import xmlrpclib	import xmlrpc.client
②	import DocXMLRPCServer import SimpleXMLRPCServer	import xmlrpc.server

• #### Outros módulos

Notes	Python 2	Python 3
①	try: 　　import cStringIO as StringIO except ImportError: 　　import StringIO	import io
②	try: 　　import cPickle as pickle except ImportError:　 　　import pickle	import pickle
③	import _builtin_	import builtins
④	import copy_reg	import copyreg
⑤	import Queue	import queue
⑥	import SocketServer	import socketserver
⑦	import ConfigParser	import configparser
⑧	import repr	import reprlib
⑨	import commands	import subprocess

1, no Python 2, você normalmente faz isso, primeiro tenta importar o cStringIO como um substituto para o StringIO, e se isso falhar, importa o StringIO. Não faça isso no Python 3; o módulo io irá ajudá-lo a lidar com isso. Ele encontrará o método de implementação mais rápido disponível e usará automaticamente. No Python 2, importar a implementação mais rápida do pickle também é uma maneira útil de fazer o mesmo. No Python 3, o módulo do pickle é feito automaticamente para você, então não faça mais isso. 3. O módulo builtins contém funções globais, classes e constantes usadas em toda a linguagem Python. Redefinir uma função no módulo builtins significa redefinir essa função global em todos os lugares. Isso soa poderoso, mas também é assustador. 4. O módulo copyreg adiciona suporte ao módulo pickle para tipos de usuário personalizados definidos na linguagem C. O módulo de queue implementa uma fila multi-produtor, multi-consumidor. O módulo socketserver fornece classes básicas gerais para a implementação de vários servidores de sockets. 7 . O módulo configparser é usado para analisar o arquivo de configuração de estilo INI. 8, o módulo reprlib reimplementa a função embutida repr (), e adiciona o controle sobre o comprimento da representação da string antes de ser cortada. O módulo subprocess permite criar subprocessos, conectá-los ao seu pipeline e obter seus valores de retorno.

• Importação relativa dentro do pacote

Um pacote é uma entidade individual composta por um conjunto de módulos relacionados. No Python 2, para fazer referência mútua de módulos dentro do mesmo pacote, você usa import foo ou from foo import Bar. O interpretador do Python 2 pesquisa primeiro no diretório atual em foo.py e depois no caminho de pesquisa do Python ((sys.path). No Python 3, o processo é um pouco diferente.

Suponha que você tenha um pacote com vários arquivos no mesmo diretório:

chardet/ | +–init.py | +–constants.py | +–mbcharsetprober.py | +–universaldetector.py

Agora, suponha que o universaldetector.py precisa de importar toda a constants.py, além de uma classe do mbcharsetprober.py. O que você faria?

Notes	Python 2	Python 3
①	import constants	from .import constants
②	from mbcharsetprober import MultiByteCharSetProber	from .mbcharsetprober import MultiByteCharsetProber

Quando você precisa importar um módulo inteiro de outro lugar do pacote, use a nova sintaxe de importar. O ponto (..) aqui representa o caminho relativo entre o arquivo atual (universaldetector.py) e o arquivo que você deseja importar (constants.py). Neste exemplo, os dois arquivos estão no mesmo diretório, então um ponto único é usado. Você também pode importar do diretório pai (import anothermodule) ou do subdiretório. Para importar uma classe ou função específica de outro módulo diretamente para o seu espaço de nomes, adicione o caminho relativo ao nome do módulo que precisa ser importado e remova a última barra (slash). Neste exemplo, mbcharsetprober.py e universaldetector.py estão no mesmo diretório, então o nome do caminho relativo é um ponto. Você também pode importar do diretório pai (from .. import anothermodule) ou no subdiretório.

• #### Método do iterador (next)

No Python 2, o iterador tem um método next (), que retorna o próximo item da sequência. No Python 3, isso também funciona, mas agora há uma nova função global next (), que usa um iterador como um parâmetro.

Notes	Python 2	Python 3
①	anIterator.next()	next(anIterator)
②	a_function_that_returns_an_iterator().next()	next(a_function_that_returns_an_iterator())

|③|class A:
　　def next(self):
　　pass|class A:
　　def next(self):
　　pass｜ |④|class A:
　　def next(self, x, y):
　　pass|no change | |⑤|next = 42
for an_iterator in a_sequence_of_iterators:
　　an_iterator.next()|next = 42
for an_iterator in a_sequence_of_iterators:
　　an_iterator.next() | 1, o exemplo mais simples, você não está mais chamando o next () método de um iterador, agora você está passando o iterador em si como um parâmetro para a função global next (((). 2. Se você tem uma função que retorna o valor do iterador, chame essa função e passe o resultado como um parâmetro para a função next ((((o script 2to3 é inteligente o suficiente para executar essa conversão corretamente))) 3 - Se você definir sua própria classe e usá-la como um iterador, em Python 3 você pode definir um método especial para isso.next() para a realização. Se uma classe que você definiu tiver um next () que use um ou mais parâmetros, ela não será movida durante a execução de 2 a 3. Esta classe não pode ser usada como um iterador, pois seu método next () tem parâmetros. 5, este é um pouco complicado. Se você tem uma variável local chamada next, em Python 3 ela tem prioridade maior do que a função global next (((). Nesse caso, você precisa invocar um método especial do iterador.next() para obter o próximo elemento da sequência。(Ou, você pode reorganizar o código para que a variável local não seja chamada next, mas 2to3 não fará isso por você。)

• #### Filter de função global

No Python 2, o método filter() retorna uma lista obtida por meio de uma função que retorna o valor True ou False para cada item da sequência. No Python 3, a função filter() retorna um iterador e não mais uma lista.

Notes	Python 2	Python 3
①	filter(a_function, a_sequence)	list(filter(a_function, a_sequence))
②	list(filter(a_function, a_sequence))	no change
③	filter(None, a_sequence)	[i for iin a_sequence if i]
④	for i in filter(None, a_sequence):	no change
⑤	[i for iin filter(a_function, a_sequence)]	no change

1, no caso mais simples, 2to3 usa uma função list () para empacotar o filter () e a função list () percorre seus parâmetros e retorna uma lista. 2 , no entanto, se a chamada filter() já foi pacotada com list(), 2to3 não processará mais, pois, nesse caso, é irrelevante se o valor de retorno do filter() é um iterador. Para lidar com a gramática específica do filter ((None, …) 2to3 transforma essa chamada de uma gramatical equivalência para a análise de lista. 4. Uma vez que o ciclo for percorre toda a sequência, não é necessário fazer mais modificações. 5. Como acima, não é necessário fazer alterações, pois a análise de lista percorre toda a sequência, e mesmo que o filter () retorne um iterador, ele ainda pode funcionar como o filter () anterior que retorna a lista.

• #### Mapa de funções globais

Assim como a alteração feita pelo filter, a função map agora retorna um iterador. Em Python 2, ela retorna uma lista.

Notes	Python 2	Python 3
①	map(a_function,‘PapayaWhip’)	list(map(a_function,‘PapayaWhip’))
②	map(None,‘PapayaWhip’)	list(‘PapayaWhip’)
③	map(lambda x: x+1,range(42))	[x+1for x in range(42)]
④	for i in map(a_function, a_sequence):	no change
⑤	[i for iin map(a_function,a_sequence)]	no change

1 , semelhante ao tratamento de filter ((), no caso mais simples, 2to3 usa uma função list (() para empacotar a chamada map ((). 2, para a gramática especial map ((None, …) semelhante ao filter ((None, …) 2to3 irá transformá-lo em uma chamada de equivalência usando list (() 3 , Se o primeiro parâmetro do mapa () for uma função lambda, 2to3 irá convertê-lo equivalentemente para a resolução de lista. 4. Não é necessário fazer alterações no loop for que percorre toda a sequência. 5, mais uma vez, não há necessidade de fazer alterações aqui, porque a análise de lista percorrerá toda a sequência, mesmo que o valor de retorno de map () seja um iterador e não uma lista, ele funcionará bem.

• #### Função global redução

No Python 3, a função reduce ((() foi removida do namespace global e agora está localizada no módulo fucntools。

Notes	Python 2	Python 3
①	reduce(a, b, c)	from functools import reduce reduce(a, b, c)

• #### A função global apply

O Python 2 tem uma função global chamada apply (), que usa uma função f e uma lista.[a, b, c] como um parâmetro, retorna o valor f ((a, b, c) . Você também pode chamar a função diretamente, adicionando um asterisco (((*) como um parâmetro para fazer a mesma coisa. No Python 3, a função apply ((() não existe mais; deve-se usar a marcação de asteriscos.

Notes	Python 2	Python 3
①	apply(a_function, a_list_of_args)	a_function(*a_list_of_args)
②	apply(a_function, a_list_of_args, a_dictionary_of_named_args)	a_function(*a_list_of_args,**a_dictionary_of_named_args)
③	apply(a_function, a_list_of_args+ z)	a_function(*a_list_of_args+ z)
④	apply(aModule.a_function, a_list_of_args)	aModule.a_function(*a_list_of_args)

1, a forma mais simples, pode ser feita através de uma lista de parâmetros como[Como a, b, c]), adicione um asterisco antes de chamar a função. Isso é equivalente à função apply ((() do Python 2. No Python 2, a função apply ((() pode, na verdade, ter 3 argumentos: uma função, uma lista de argumentos, um dicionário de argumentos nomeados. No Python 3, você pode adicionar um asterisco antes da lista de argumentos), adicionar dois asteriscos antes do parâmetro de nomeação do dicionário ((**O blogueiro também escreveu sobre o assunto: 3 - O operador + é usado aqui como função de lista de ligações e tem prioridade sobre o operador, então não há necessidade de adicionar parênteses adicionais em torno de a_list_of_args + z. 4, 2 a 3 scripts são inteligentes o suficiente para transformar complexas aplicações de () e () incluindo a invocação de funções no módulo de importação.

• #### Função global interna

No Python 2, você pode usar a função intern () para definir a função intern () em uma string para obter otimização de desempenho. No Python 3, a função intern () foi transferida para o módulo sys.

Notes	Python 2	Python 3
①	intern(aString)	sys.intern(aString)

• #### Declaração do exec

Assim como a frase print se torna uma função no Python 3, a frase exec também. A função .exec () usa uma string que contém código Python arbitrário como um parâmetro e depois executa-a como se fosse uma frase ou uma expressão.

Notes	Python 2	Python 3

|①|exec codeString|exec(codeString) |②|exec codeString in a_global_namespace|exec(codeString, a_global_namespace)| |③|exec codeString in a_global_namespace, a_local_namespace|exec(codeString, a_global_namespace,a_local_namespace)| 1, na sua forma mais simples, como exec (() é agora uma função e não uma declaração, 2to3 coloca este código em forma de string entre parênteses。 2 A instrução exec no Python 2 pode especificar um espaço de nomes, e o código será executado neste espaço privado de objetos globais. O Python 3 também possui essa função; você só precisa passar esse espaço de nomes como um segundo parâmetro para a função exec (). O que é ainda mais incrível é que a instrução exec no Python 2 também pode especificar um espaço de nomes local (como uma variável declarada em uma função). No Python 3, a função exec () também possui essa função.

• #### Declaração do execfile

Assim como as anteriores instruções de exec, as instruções de execfile no Python 2 usam strings como se executassem código em Python. Ao contrário do exec que usa strings, o execfile usa arquivos. No Python 3, a instrução de execfile foi removida. Se você realmente quer executar o código em um arquivo, mas não quer importá-lo, você pode fazer isso abrindo o arquivo, lendo o conteúdo e chamando a função compile (global) para forçar o compilador do Python e chamando a nova função exec (global).

Notes	Python 2	Python 3
①	execfile(‘a_filename’)	exec(compile(open(‘a_filename’).read(),‘a_filename’,‘exec’))

• #### Reprima (em vírgula)

No Python 2, para obter uma representação de uma string de um objeto arbitrário, há uma forma de envolver o objeto em contra-indicações, como por exemplo:xNa Python 3, essa capacidade ainda existe, mas você não pode mais usar a contracorrente para obter essa string. Você precisa usar a função global repr ().

Notes	Python 2	Python 3
①	`x`	repr(x)
②	`‘PapayaWhip’ + `2``	repr(‘PapayaWhip’+ repr(2))

1. Lembre-se que x pode ser qualquer coisa: uma classe, uma função, um módulo, um tipo de dados básico, etc. 2, no Python 2, os retrocédidos podem ser embutidos, resultando em uma expressão desconcertante (mas eficaz). 2to3 é inteligente o suficiente para converter essa invocação embutida em uma função repr ().

• #### “Try…except” (exceto)

A linguagem para capturar anomalias mudou um pouco de Python 2 para Python 3.

Notes	Python 2	Python 3
①	try: 　　import mymodule except　ImportError, e 　　pass	try: 　　import mymodule except ImportError as e: 　　pass
②	try: 　　import mymodule except (RuntimeError, ImportError), e 　　pass	try: 　　import　mymodule except (RuntimeError, ImportError) as e: 　　pass
③	try: 　　import mymodule except ImportError: 　　pass	no change
④	try: 　　import mymodule except: 　　pass	no change

1 , Comparado com o Python 2 para adicionar uma vírgula após o tipo de exceção, o Python 3 usa uma nova palavra-chave, as。 2. A palavra-chave as também pode ser usada para capturar vários tipos de anomalias ao mesmo tempo. 3. Se você capturar uma exceção, mas não se importa de acessar o objeto de exceção em si, a sintaxe do Python 2 e Python 3 é a mesma. 4 Similarmente, se você usar um método de segurança para capturar todas as exceções, a sintaxe do Python 2 e do Python 3 é a mesma. 5. Quando você importa um módulo (ou a maioria dos outros casos), você definitivamente não deve usar esse método (veja o fallback acima). Caso contrário, o programa pode capturar uma exceção como o KeyboardInterrupt (interrompa o programa se o usuário pressionar o Ctrl-C), tornando a debug mais difícil.

• #### A frase “raise”

Em Python 3, há uma pequena mudança na sintaxe para lançar exceções personalizadas.

Notes	Python 2	Python 3
①	raise MyException	unchanged
②	raise MyException,‘error message’	raise MyException(‘error message’)
③	raise MyException,‘error message’, a_traceback	raise MyException(‘errormessage’).with_traceback(a_traceback)
④	raise ‘error message’	unsupported

1o. Lançar excepções sem mensagens de erro personalizadas pelo usuário, sem mudança de gramática na sua forma mais simples. 2. Quando você deseja lançar uma exceção com uma mensagem de erro personalizada pelo usuário, a mudança é visível. Python 2 usa uma vírgula para separar a classe de exceção da mensagem de erro; Python 3 passa a mensagem de erro para a classe de exceção como um parâmetro. O Python 2 suporta uma gramática mais complexa para lançar uma excepção com um regressão personalizado pelo usuário. No Python 3 você também pode fazer isso, mas a gramática é completamente diferente. No Python 2, você pode lançar uma exceção sem classe de exceção, com apenas uma mensagem de exceção. No Python 3, essa forma não é mais suportada. 2to3 avisará que não pode corrigir essa sintaxe automaticamente.

• #### Método de lançamento do gerador

No Python 2, o gerador tem uma técnica de throw (). A chamada a_generator.throw () lança uma exceção quando o gerador é suspenso e retorna o próximo valor obtido pela função do gerador. No Python 3, essa função ainda está disponível, mas é um pouco diferente na sintaxe.

Notes	Python 2	Python 3
①	a_generator.throw(MyException)	no change
②	a_generator.throw(MyException,‘error message’)	a_generator.throw(MyException(‘error message’))
③	a_generator.throw(‘error message’)	unsupported

1, em sua forma mais simples, o gerador lança excepções sem mensagens de erro personalizadas pelo usuário. Nesse caso, não há mudanças na gramática do Python 2 para o Python 3. 2. Se o gerador lançar uma exceção com um erro personalizado pelo usuário, você precisará passar esse erro para a classe de exceção para que ela seja instantiada. O Python 3 não suporta essa gramática, e o 2to3 exibirá uma mensagem de alerta dizendo que você precisa corrigir o código manualmente.

• #### Função global xrange

No Python 2, há duas maneiras de obter números dentro de um determinado intervalo: range (), que retorna uma lista, e range (), que retorna um iterador. No Python 3, range (), que retorna um iterador, e xrange (), que não existe mais.

Notes	Python 2	Python 3
①	xrange(10)	range(10)
②	a_list = range(10)	a_list = list(range(10))
③	[i for iin xrange(10)]	[i for iin range(10)]
④	for i in range(10):	no change
⑤	sum(range(10))	no change

1, no caso mais simples, 2to3 simplesmente converteria xrange () para range () [2]. 2 Se o seu código Python 2 usa range (), 2to3 não sabe se você precisa de uma lista, ou se um iterador também funciona. Por precaução, 2to3 pode cometer erros e usar list () para forçar a conversão do valor de retorno de range () para o tipo de lista. 3. Se a lista tiver uma função xrange (), não há necessidade de converter o seu valor de retorno para uma lista, pois a lista é igualmente válida para o iterador. 4 Similarmente, o ciclo for também funciona com o iterador, então aqui também não muda nada. A função sum ((() funciona como um iterador, então 2to3 também não faz nenhuma modificação aqui. Assim como o método de classe de dicionário que retorna o valor como vista ((view) e não mais como uma lista, isso também se aplica a min (((), max (((), sum (((), list (((), tuple (((), set (((), sorted (((), any (((), all (()) [2].

• #### Funções globais (raw_input) e (input)

O Python 2 tem duas funções globais para solicitar a entrada do usuário na linha de comando. A primeira é chamada de input (((), que espera que o usuário digite uma expressão Python ((( e retorne o resultado). A segunda é chamada de raw_input (((), e o que o usuário insere é o que ele retorna.

Notes	Python 2	Python 3
①	raw_input()	input()
②	raw_input(‘prompt’)	input(‘prompt’)
③	input()	eval(input())

1, na forma mais simples, raw_input (() é substituído por input (()) [2]. 2, no Python 2, a função raw_input ((() pode especificar um indicador como um parâmetro. No Python 3, esta função é mantida. 3. Se você realmente quer pedir ao usuário que digite uma expressão em Python e calcular o resultado, você pode chamar a função input (), e passar o valor de retorno para eval ().

• #### Propriedade da função func_*

No Python 2, o código de uma função pode acessar as propriedades especiais da função. No Python 3, essas propriedades especiais foram renomeadas para manter a consistência.

Notes	Python 2	Python 3
①	a_function.func_name	a_function._name_
②	a_function.func_doc	a_function._doc_
③	a_function.func_defaults	a_function._defaults_
④	a_function.func_dict	a_function._dict_
⑤	a_function.func_closure	a_function._closure_
⑥	a_function.func_globals	a_function._globals_
⑦	a_function.func_code	a_function._code_

1、name_O atributo _(originalfunc_name) contém o nome da função。 2、doc__ atributo ((originalfuncdoc) contém a string do documento que você definiu no código fonte da função ((docstring) 3、defaultsattribute ((originalfunc_defaults) é um subconjunto que preserva os valores padrão dos parâmetros. 4、dictattribute ((originalfunc_dict) é um espaço de nomes que suporta atributos de funções arbitrárias。 5、closureattribute ((originalfunc_closure) é um subconjunto composto por objetos de células que contém a vinculação de uma função a uma variável livre ((free variable)). 6、globalsattribute ((originalfunc_globals) é uma referência ao namespace global do módulo, onde a função é definida. 7、codeattribute ((originalfunc_code) é um objeto de código que representa um corpo funcional compilado.

• #### Métodos de I/O xreadlines

No Python 2, um objeto de arquivo tem um método xreadlines () que retorna um iterador que lê uma linha do arquivo de cada vez. Isso é especialmente útil no loop for. Na verdade, versões posteriores do Python 2 adicionaram esse recurso ao objeto de arquivo em si.

No Python 3, o método xreadlines ((() não é mais usado. 2to3 pode resolver situações simples, mas alguns casos de borda requerem intervenção manual.

Notes	Python 2	Python 3
①	for line in a_file.xreadlines():	for line in a_file:
②	for line in a_file.xreadlines(5):	no change (broken)

1, se você chamou xreadlines que não possuem parâmetros anteriormente, 2to3 irá transformá-los em objetos de arquivo. Em Python 3, o código após essa conversão pode fazer o mesmo trabalho que antes: ler uma linha de arquivo uma vez e executar o corpo de arquivos do ciclo for. 2 Se você usou um argumento anterior (número de linhas por leitura) para chamar xreadlines (), 2to3 não pode fazer a conversão do Python 2 para o Python 3 para você, e seu código falhará desta maneira: AttributeError: ‘_io.TextIOWrapper’ object has no attribute ‘xreadlines’. Você pode manualmente transformar xreadlines em readlines para que o código funcione no Python 3. A metodologia readline retorna o iterador no Python 3, então ela não é tão eficiente quanto as xreadlines no Python 2.

• #### Funções lambda que usam elementos em vez de múltiplos argumentos

No Python 2, você pode definir uma função lambda anônima, que é capaz de receber vários parâmetros, especificando o número de elementos de um módulo como um argumento. Na verdade, o interpretador do Python 2 decompõe esse módulo em argumentos nomeados, que você pode então citar na função lambda. No Python 3, você ainda pode transmitir um módulo como um parâmetro da função lambda, mas o interpretador do Python não o decompõe como um parâmetro nomeado.

Notes	Python 2	Python 3
①	lambda (x,): x+ f(x)	lambda x1: x1[0]+f(x1[0])
②	lambda (x, y): x+f(y)	lambda x_y: x_y[0]+f(x_y[1])
③	lambda (x,(y,z)): x+ y+ z	lambda x_y_z: x_y_z[0]+x_y_z[1][0]+ x_y_z[1][1]
④	lambda x, y, z: x+y + z	unchanged

1, se você já definiu uma função lambda que usa um grupo de elementos como um parâmetro, no Python 3, ela será convertida em um grupo de elementos que contém x1[A função lambda que é citada em [0]。x1 é gerada automaticamente pelo script 2to3 com base nos parâmetros de nomeação no subgrupo original。 A função lambda que usa um grupo de dois elementos (x, y) como parâmetro é convertida em x_y, que tem dois parâmetros de posição, x_y[0] e x_y[1]。 Um script de 2 a 3 pode até mesmo lidar com a função lambda de um módulo que usa um parâmetro de nomeação embutida como parâmetro. O código resultante é um pouco difícil de ler, mas é o mesmo no Python 3 que o código original no Python 2. 4. Você pode definir uma função lambda que usa vários parâmetros. Se não houver parênteses em torno de um parâmetro, o Python 2 irá tratá-lo como uma função lambda que contém vários parâmetros; nesse corpo de funções lambda, você irá referenciar esses parâmetros pelo nome, como acontece em outros tipos de funções. Essa gramática ainda é válida no Python 3.

• #### Atributos de métodos especiais

Em Python 2, os métodos de classe podem acessar o objeto de classe que define a classe, bem como o objeto de método. Im_self é o objeto de instância da classe; im_func é o objeto de função e im_class é a própria classe. Em Python 3, essas propriedades foram renomeadas para seguir as convenções de nomeação de outras propriedades.

Notes	Python 2	Python 3
①	aClassInstance.aClassMethod.im_func	aClassInstance.aClassMethod._func_
②	aClassInstance.aClassMethod.im_self	aClassInstance.aClassMethod._self_
③	aClassInstance.aClassMethod.im_class	aClassInstance.aClassMethod._self_._class_

• #### nonzero Método especial

Em Python 2, você pode criar suas próprias classes e torná-las utilizáveis em um contexto booleano. Por exemplo, você pode instanciar a classe e usar o objeto de instância em uma sentença if.nonzero() método, que retorna o valor True ou False, quando o objeto da instância está no contexto de um Boolean. No Python 3, você ainda pode fazer o mesmo, mas o nome desse método especial ébool()。

Notes	Python 2	Python 3

|①|class A:
　　def nonzero(self):
　　pass|class A:
　　def bool(self):
　　pass |②|class A:
　　def nonzero(self, x, y):
　　pass|no change| 1. Quando um objeto de classe é usado em um contexto em BULL, o Python 3 chamabool_Não, não.nonzero()。 No entanto, se você tiver definido um que usa dois parâmetrosnonzero__() método, o script 2 a 3 assume que o método que você definiu tem outras utilidades e, portanto, não faz modificações no código.

• #### Tipos de sistema octogonal

Entre o Python 2 e o Python 3, há uma pequena mudança na gramática para definir o número octal.

Notes	Python 2	Python 3
①	x = 0755	x = 0o755

• #### sys.maxint

Como o inteiro longo e o inteiro longo foram integrados, a constante sys.maxint não é mais precisa. Mas como esse valor ainda é útil para detectar a capacidade de uma plataforma específica, ele foi mantido pelo Python 3 e renomeado para sys.maxsize.

Notes	Python 2	Python 3
①	from sys importmaxint	from sys importmaxsize
②	a_function(sys.maxint)	a_function(sys.maxsize)

1, maxint é transformado em maxsize. 2. Todos os sys.maxint são transformados em sys.maxsize。

• #### Funções globais callable (())

Em Python 2, você pode usar a função global callable ((() para verificar se um objeto é chamado ((callable, como função)). Em Python 3, esta função global foi cancelada. Para verificar se um objeto é chamado, você pode verificar métodos especiais.__call_A existência de…

Notes	Python 2	Python 3
①	callable(anything)	hasattr(anything,’_call_’)

• #### Função global (zip)

Em Python 2, a função global zip() pode usar qualquer sequência como um parâmetro, e retorna uma lista composta por subgrupos. O primeiro subgrupo contém o primeiro elemento de cada sequência; o segundo subgrupo contém o segundo elemento de cada sequência; e segue em frente. Em Python 3, zip() retorna um iterador, e não uma lista.

Notes	Python 2	Python 3
①	zip(a, b, c)	list(zip(a, b, c))
②	d.join(zip(a, b, c))	no change

Na forma mais simples, você pode recuperar o valor de retorno do função list () usando a função de encapsulamento zip () para reverter a função anterior, list () percorre o iterador que a função zip () retorna, e retorna a lista de resultados. Em contextos em que todos os elementos da seqüência já foram executados (exemplo: a chamada do método join), o iterador que retorna (zip) funciona normalmente. O script 2to3 detecta essas situações e não altera o seu código.

• #### Excepção StandardError

No Python 2, o StandardError é a classe base de todas as outras exceções embutidas, exceto StopIteration, GeneratorExit, KeyboardInterrupt e SystemExit. No Python 3, o StandardError foi cancelado e substituído pelo Exception.

Notes	Python 2	Python 3
①	x =StandardError()	x =Exception()
②	x =StandardError(a, b, c)	x =Exception(a, b, c)

• #### Constantes no módulo types

A variedade de constantes no módulo types ajuda você a decidir o tipo de um objeto. No Python 2, ele contém as constantes que representam todos os tipos básicos de dados, como dict e int. No Python 3, essas constantes foram eliminadas.

Notes	Python 2	Python 3
	types.UnicodeType	str
	types.StringType	bytes
	types.DictType	dict
	types.IntType	int
	types.LongType	int
	types.ListType	list
	types.NoneType	type(None)
	types.BooleanType	bool
	types.BufferType	memoryview
	types.ClassType	type
	types.ComplexType	complex
	types.EllipsisType	type(Ellipsis)
	types.FloatType	float
	types.ObjectType	object
	types.NotImplementedType	type(NotImplemented)
	types.SliceType	slice
	types.TupleType	tuple
	types.TypeType	type
	types.XRangeType	range

types.StringType é mapeado em bytes, e não em str, porque o string em Python 2 é, na verdade, uma sequência de bytes codificados com um determinado tipo de caracteres.

• #### Instança da função global

isinstance() é uma função que verifica se um objeto é uma instância de uma determinada classe ou tipo. No Python 2, você pode passar um subconjunto de tipos para a instância. Se o objeto for de qualquer tipo do subconjunto, a função retorna True. No Python 3, você ainda pode fazer isso, mas não é recomendado usar um tipo como argumento para passar duas vezes.

Notes	Python 2	Python 3
	isinstance(x,(int,float,int))	isinstance(x,(int,float))

• #### Tipo de dados de base-string

O Python 2 tem dois tipos de string: strings codificados em Unicode e strings não codificados em Unicode. No entanto, há um outro tipo, o basestring. É um tipo de dados abstrato, uma superclasse dos tipos str e unicode.

Notes	Python 2	Python 3
	isinstance(x, basestring)	isinstance(x, str)

• #### Módulo itertools

O Python 2.3 introduziu o módulo itertools, que define variantes das funções globais zip (), map (), filter (), cujas variantes retornam tipos de iteradores, e não de listas. No Python 3, essas funções variantes foram eliminadas, pois o tipo de retorno dessas funções globais é o iterador.

Notes	Python 2	Python 3
①	itertools.izip(a, b)	zip(a, b)
②	itertools.imap(a, b)	map(a, b)
③	itertools.ifilter(a, b)	filter(a, b)
④	from itertools import imap, izip, foo	from itertools import foo

1 , usar a função global zip () em vez de itertools.izip () 2o Usar map (em vez de itertools.imap) 3 ,itertools.ifilter() tornou-se um filter() O módulo itertools permanece no Python 3, mas não contém funções que foram transferidas para o espaço de nomes global. O script 2to3 é inteligente o suficiente para remover as instruções de importação que não são mais úteis, mantendo a integridade de outras instruções de importação.

• #### sys.exc_type, sys.exc_value, sys.exc_traceback

Para lidar com as exceções, há três variáveis que você pode acessar no módulo sys: sys.exc_type, sys.exc_value, sys.exc_traceback. (Na verdade, essas variáveis já existiam na era do Python 1.) A partir do Python 1.5, o uso dessas três variáveis não é mais recomendado devido ao novo sys.exc_info, um subconjunto que contém todos os três elementos acima. No Python 3, essas três variáveis finalmente não existem mais; isso significa que você deve usar sys.exc_info.

Notes	Python 2	Python 3
	sys.exc_type	sys.exc_info()[0]
	sys.exc_value	sys.exc_info()[1]
	sys.exc_traceback	sys.exc_info()[2]

• #### Resolução de lista para módulos

No Python 2, se você precisa escrever uma parcela de lista de parâmetros que percorre um algarismo, você não precisa colocar parênteses em torno do valor do algarismo. No Python 3, esses parênteses são necessários.

Notes	Python 2	Python 3
	[i for iin 1,2]	[i for iin(1,2)]

• #### Função os.getcwdu

O Python 2 tem uma função chamada os.getcwd() que retorna o diretório de trabalho atual como uma string (((não codificada em Unicode)). Como os sistemas de arquivos modernos são capazes de processar nomes de diretórios que codificam caracteres geométricos, o Python 2.3 introduziu a função os.getcwdu ((() que retorna os caracteres codificados em Unicode do diretório de trabalho atual. No Python 3, você só precisa de os.getcwdu (((), pois há apenas um tipo de string do tipo (((Unicode)).

Notes	Python 2	Python 3
	os.getcwdu()	os.getcwd()

• #### Metaclasse

No Python 2, você pode definir um parâmetro metaclass em uma declaração de classe, ou definir um nível de classe especial.metaclassproperty, para criar subclasses.__metaclass_O atributo _ foi cancelado.

Notes	Python 2	Python 3
①	class C(metaclass=PapayaMeta): 　　pass	unchanged
②	class Whip: 　　_metaclass_ = PapayaMeta	class Whip(metaclass=PapayaMeta): 　　pass
③	class C(Whipper, Beater): 　　_metaclass_ = PapayaMeta	class C(Whipper,Beater,metaclass=PapayaMeta): 　　pass

1. Declarar um parâmetro metaclass quando uma classe é declarada. Isso é válido tanto no Python 2 quanto no Python 3. Eles são os mesmos. 2o, declarar a propriedade metaclass na definição da classe, que é válida no Python 2, mas não mais válida no Python 3. 3, 2to3 é capaz de construir uma declaração de classe válida, mesmo que a classe herde de várias classes-pai.

• #### Sobre o estilo do código

Os bug fixes listados abaixo não são, em essência, verdadeiros bugs. Ou seja, eles são apenas coisas sobre o estilo do código, e não envolvem a essência do código. Mas os desenvolvedores do Python têm um interesse muito grande em tornar o estilo do código o mais consistente possível. Para isso, há um manual oficial dedicado a descrever o estilo do código do Python.

• #### set (literal) expressão

No Python 2, a única maneira de definir um conjunto de valores literais é invocar set (a_sequence). No Python 3, isso ainda funciona, mas a nova notação literal: parênteses maiúsculos ({}) é uma maneira mais clara. Esta abordagem funciona além dos conjuntos vazios, pois o dicionário também é marcado com parênteses maiúsculos, então {} representa um dicionário vazio, e não um conjunto vazio.

Os scripts 2to3 não corrigem o valor literal set (). Para ativar este recurso, especifique o parâmetro -f set_literal quando a linha de comando é chamada 2to3.

Notes	Before	After
	set([1,2,3])	{1,2,3}
	set((1,2,3))	{1,2,3}
	set([i for iin a_sequence])	{i for iin a_sequence}

• #### Global Function Buffer (em inglês)

Os objetos Python implementados em C exportam um interface de buffer que permite que o código Python leia e escreva diretamente um pedaço de memória. Isso soa muito forte, mas também é assustador.

O script 2to3 não corrige a função buffer ((() por padrão. Para ativar essa função, especifique o parâmetro -f buffer quando a linha de comando é chamada 2to3.

Notes	Before	After
	x =buffer(y)	x =memoryview(y)

• #### Espaço em torno da vírgula (expresso)

Embora o Python seja rigoroso quanto aos espaços para indentando e salientando, o Python é muito livre quanto aos espaços em outros