Modificações de Python 2.x.x com Python 3.x.x & Métodos para converter Python 2.x.x para Python 3.x.x

Diferenças, modificações e alterações de sintaxe entre o Python 2 e o Python 3

Quase todos os programas Python 2 precisam de algumas modificações para funcionar normalmente no ambiente Python 3. Para simplificar o processo de conversão, o Python 3 vem com um script utilitário chamado 2to3 (Utility Script), que leva seu arquivo de código do programa Python 2 como entrada e o converte automaticamente para o Python 3.

• expressão de impressão

No Python 2, print é uma expressão. Qualquer coisa que você queira exportar, basta colocá-las atrás da palavra-chave print. No Python 3, print ((() é uma função.

Notas	Python 2	Python 3
①	imprimir	Imprimir
②	Imprimir 1	Imprimir (1)
③	Impressão 1,2	Imprimir ((1,2)
④	Imprimir 1, 2,	imprimir ((1,2,final= ")
⑤	Imprimir >>sys.stderr,1,2,3	print ((1,2,3, arquivo=sys.stderr)

1, para exportar uma linha em branco, é necessário chamar print sem parâmetros ((((((( 2, para exportar um valor separado, é necessário usar este valor como um dos parâmetros do print (). 3, para a saída de dois valores separados por um espaço, pode ser chamado print ((() com dois parâmetros. O exemplo tem algumas dicas. No Python 2, se você usar um ponto de viragem como o final da sentença print, ele irá separar o resultado por espaços, e então não retornará o carro. No Python 3, o mesmo efeito pode ser alcançado passando o end= como um parâmetro de palavra-chave para print. O valor padrão do parâmetro end é \n, então você pode cancelar o símbolo de retorno no final do parâmetro end, reapontando o valor do parâmetro end. 5. No Python 2, você pode redirecionar a saída para um canal usando a sintaxe >pipe_name, como sys.stderr. No Python 3, você pode fazer o mesmo passando o canal como o valor de um arquivo de parâmetros de palavras-chave para o print. O valor padrão do arquivo de parâmetros é std.stdout, então reapontar seu valor fará com que o print () seja exportado para outro canal.

• Estrelas Unicode

O Python 2 tem dois tipos de strings:Estrelas UnicodeeEstruturas não UnicodeO Python 3 tem apenas um tipo:A linha de caracteres é uma linha de caracteres.。

Notas	Python 2	Python 3
①	Papaya Whip.	Papaya Whip
②	UrPapayaWhip\foo	Papaya Whip.

As strings de Unicode no Python 2 são strings normais no Python 3, porque as strings no Python 3 são sempre de formato Unicode. A string original da Unicode ("raw string") ("Python não traduz automaticamente o inverso da linha vertical" usando essa string) também foi substituída por uma string normal, pois em Python 3, todas as strings primitivas são codificadas em Unicode.

• Função universal unicode

O Python 2 tem duas funções globais que podem forçar a conversão de objetos em strings: o unicode ((() converte objetos em strings Unicode e o str ((() converte objetos em strings não Unicode. O Python 3 só tem um tipo de strings, a String Unicode, então a função str ((() pode fazer todas as funções.A função unicode ((() não existe mais no Python 3.)

Notas	Python 2	Python 3
①	Unicode ((qualquer coisa)	Str (((algo)

• long inteiro

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

Leia mais: PEP 237: Unificar o tipo integral e o tipo integral.

Notas	Python 2	Python 3
①	x = 1000000000000L	x = 1000000000000
②	x = 0xFFFFFFFFFFFFL	x = 0xFFFFFFFFFF
③	longos ((x)	int ((x)
④	tipo ((x) é longo	tipo ((x) é int
⑤	isinstance ((x,long)	isinstance ((x,int)

O inteiro decimal em Python 2 é substituído pelo inteiro decimal em Python 3. O inteiro de 16 dígitos em Python 2 é substituído por um inteiro comum de 16 dígitos em Python 3. No Python 3, como o formato integral já não existe, é possível criar um código de instruções que não seja o mesmo.A função natural long ((() também não existe. Para forçar a conversão de uma variável em inteiro, a função int ((( pode ser usada.Não, não. Verifica se uma variável é inteira, obtém seu tipo de dados e compara com um tipo de int (não long). Você também pode usar a função istance (() para verificar o tipo de dados; enfatizando novamente, use int, em vez de long, para verificar o tipo de inteiro.

• Comparação de operadores

O Python 2 suporta <> como sinônimo de!=. O Python 3 só suporta!= e não suporta mais <>.

Notas	Python 2	Python 3
①	se x <> y:	se x! = y:
②	Se x <> y<> z:	se x!= y!= z:

1, simplesmente comparado. 2, comparação entre três valores relativamente complexos.

• Método da classe do dicionário has_key ((()

No Python 2, o método has_key (), usado para testar se o dicionário contém uma chave específica (), não é mais suportado no Python 3.emOperador.

Notas	Python 2	Python 3
①	a_dictionary.has_key ((PapayaWhip)	PapayaWhip no dicionário
②	a_dictionary.has_key ((x) ou a_dictionary.has_key ((y)	x no dicionário ou y no dicionário
③	a_dictionary.has_key ((x ou y)	(x ou y) no dicionário
④	a_dictionary.has_key ((x + y)	(x + y) no dicionário
⑤	x + a_dictionary.has_key ((y))	x + (y no dicionário)

1, a forma mais simples. 2, a prioridade do operador or é menor do que a do operador in, por isso não é necessário adicionar parênteses aqui. Por outro lado, para a mesma razão, a prioridade de or é inferior a in, e aqui é necessário adicionar parênteses. Nota: o código aqui é completamente diferente da linha anterior. Python primeiro interpreta x ou y, obtendo o resultado x (se o valor do contexto de x for verdadeiro) ou y. Então Python verifica se esse resultado é um chave do a_dictionary). O operador in tem uma prioridade menor do que o operador +, então essa forma no código não precisa tecnicamente de parênteses, mas 2to3 ainda é adicionado. 5, essa forma precisa de parênteses, porque a prioridade de in é menor do que +.

• Método de classe de dicionário para retornar a lista

No Python 2, muitos métodos de um dicionário retornam valores de listas; entre os métodos mais usados, há keys, items e values. No Python 3, todos os métodos retornam valores de uma vista dinâmica. Em alguns contextos, essa mudança não tem impacto. Se os valores de retornos desses métodos forem imediatamente transmitidos para outra função e essa função percorrer toda a sequência, os valores de retornos desses métodos são listas ou visualizações que não produzem qualquer diferença.

Notas	Python 2	Python 3
①	a_dictionary.keys (em inglês)	lista ((a_dictionary.keys())
②	a_dictionary.items (em inglês)	lista ((a_dictionary.items())
③	a_dictionary.iterkeys()	iter ((a_dictionary.keys())
④	[i para iin a_dictionary.iterkeys() ]	[i para iin a_dictionary.keys() ]
⑤	Min(a_dictionary.keys())	Nenhuma alteração

1, usando a função list ((() para converter o valor de retorno de keys ((() para uma lista estática. Por razões de segurança, 2to3 pode retornar erros. Esse código é válido, mas é um pouco menos eficiente para usar a visão. Você deve verificar o código após a conversão para ver se é necessário listar, talvez a visão também faça o mesmo trabalho. 2, que é uma outra visão da conversão do método "para itens" para a lista. 3, o Python 3 não suporta mais iterkeys (); se necessário, use o iter (), para converter o valor de retorno de keys (), em um iterador. O método 4, 2to3 é capaz de identificar que o método iterkeys () foi usado na análise de listas e então transformá-lo em keys () no Python 3. O valor de retorno do método 5, 2to3 que também identifica o método keys (() é imediatamente transmitido para outra função que percorre toda a sequência, por isso não é necessário converter o valor de retorno do keys (() para uma lista. Em vez disso, a função min (()) está disposta a percorrer a visão. Este processo é igualmente válido para min ((), max ((), sum ((), tuple ((), setlist ((), sorted ((), any (()) e all (()).

• Módulos renomeados ou reorganizados

De Python 2 para Python 3, alguns módulos da biblioteca padrão foram renomeados. Outros módulos interligados 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, o http.

Notas	Python 2	Python 3
①	importar httplib	importar http.client
②	Importação Cookie	importar http.cookies
③	importar cookielib	importar http.cookiejar
④	importar BaseHTTPServer importar SimpleHTTPServer importar CGIHttpServer	importar http.server

O módulo http.client implementa uma biblioteca subjacente que pode ser usada para solicitar recursos HTTP e paralisar respostas HTTP. O módulo http.cookies fornece uma interface Python para obter os cookies enviados através do cabeçalho do Set-Cookie Os navegadores mais populares armazenam cookies em formato de arquivos no disco, que podem ser manipulados pelo módulo http.cookiejar. O módulo http.server implementa um servidor HTTP básico

• urllib O Python 2 possui alguns módulos para analisar, codificar e obter URLs, mas estes são sobrepostos como um mouse. No Python 3, estes módulos são reestruturados e compostos em um pacote separado, o urllib.

Notas	Python 2	Python 3
①	importar urllib	importar urllib.request urllib.parse,urllib.error
②	importar urllib2	importar urllib.request urllib.error
③	Importação de URL	importar urllib.parse
④	importar robotparser	importar urllib.robotparser
⑤	do urllib import FancyURLopener do urllib import urlencode	de urllib.request importar FancyURLopener de urllib.parse importar urlencode
⑥	de urllib2 import Solicitação de urllib2 import HTTPError	de urllib.request import Request de urllib.error import HTTPError

Anteriormente, o módulo urllib no Python 2 tinha uma grande variedade de funções, incluindo urlopen para obter dados, e também era útil para dividir o URL em suas partes constituintes, as funções splittype (), splithost (), e splituser (). No novo pacote urllib, essas funções são organizadas de forma mais lógica. Em Python 3, o módulo urllib2 anterior foi incorporado ao pacote urllib. Além disso, em urllib2 as coisas que você mais gosta aparecerão como parte integrante do módulo urllib de Python 3, como o método build_opener, objetos de solicitação, HTTPBasicAuthHandler e amigos. O módulo urllib.parse em Python 3 contém todas as funções de análise do módulo urlparse original em Python 2. O módulo urllib.robotparse analisa o arquivo robots.txt. A classe FancyURLopener, que lida com redirecionamento HTTP e outros códigos de estado, ainda é válida no módulo urllib.request do Python 3. Os objetos de solicitação continuam a ser válidos no urllib.request, mas constantes como HTTPError foram transferidos para o urllib.error. Eu já mencionei que o 2to3 também reescreve as suas chamadas de função? Por exemplo, se você impor um módulo urllib no seu código Python 2 e invocar a função urllib.urlopen para obter dados, o 2to3 irá modificar simultaneamente as declarações de importação e as chamadas de função.

Notas	Python 2	Python 3
①	importar urllib imprimir urllib.urlopen"http://diveintopython3.org/’) (leia)	importar urllib.request, urllib.parse, urllib.error print ((urllib.request.urlopen)) "http://diveintopython3.org/’) (leia)

• 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 no pacote do dbm.

Notas	Python 2	Python 3
①	importar dbm	importar dbm.ndbm
②	importar gdbm	Importaçãodbm.gnu
③	importar dbhash	importar dbm.bsd
④	importar dumbdbm	Importar dbm.dumb
⑤	importar qualquer importar qualquer	importar dbm

• xmlrpc XML-RPC é um método leve para executar chamadas RPC remotas através do protocolo HTTP. Algumas implementações de clientes XML-RPC e servidores XML-RPC agora são combinadas em um pacote independente, chamado xmlrpc.

Notas	Python 2	Python 3
①	importar xmlrpclib	Importar xmlrpc.client
②	importar DocXMLRPCServer importar SimpleXMLRPCServer	Importar xmlrpc.server

• Outros módulos

Notas	Python 2	Python 3
①	try: importar cStringIO como StringIO exceto ImportError: importar StringIO	Importação
②	Tente: importar cPickle como pickle exceto ImportError: importar pickle	Peixes de abóbora
③	ImportaçãoConstruído	Importação de construções
④	importar copy_reg	Importação de cópia
⑤	fila de importação	fila de importação
⑥	importar SocketServer	importar servidor de sockets
⑦	importar ConfigParser	importar configparser
⑧	Importação	importar reprlib
⑨	comandos de importação	subprocesso de importação

1, no Python 2, você geralmente faz isso, tentando primeiro importar cStringIO como uma substituição para o StringIO, e, se isso falhar, importar o StringIO novamente. Não faça isso no Python 3; o módulo io irá ajudá-lo a lidar com isso. Ele vai descobrir a implementação mais rápida disponível e usá-la automaticamente. No Python 2, importar a implementação de pickle mais rápida também é um método útil semelhante ao acima. No Python 3, o módulo pickle é processado automaticamente por você, então não faça mais isso. 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 esta função global em todos os lugares. O módulo copyreg adiciona suporte para o módulo pickle para tipos personalizados de usuários definidos em C. O módulo de queue 5 implementa uma fila de produtores-consumidores (multi-producer, multi-consumer queue). O módulo socketserver fornece uma classe básica geral para implementar vários servidores de sockets. O módulo configparser é usado para analisar perfis de estilo INI. O módulo 8 reprlib reimplementa a função repr () e adiciona controle sobre o comprimento da expressão de uma string antes de ser cortada. O módulo de subprocessos permite que você crie subprocessos, conecte-os a seus canais e obtenha seus valores de retorno.

• Importação relativa dentro do pacote

O pacote é uma entidade única composta por um conjunto de módulos associados. No Python 2, para fazer uma referência mútua de módulos dentro do mesmo pacote, você usa o import foo ou from foo import Bar.2解释器会先在当前目录里搜索foo.pyNo Python 3, o processo é um pouco diferente. O Python 3 não pesquisa primeiro no caminho atual, ele pesquisa diretamente no caminho de pesquisa do Python. Se você quiser importar um módulo do pacote para outro módulo do pacote, você precisa fornecer explicitamente o caminho relativo dos dois módulos.

Suponha que você tenha o seguinte pacote, vários arquivos no mesmo diretório:

Chardet/ - Sim, sim. ±-Iniciar.py - Sim, sim.+--constantes.py | +--mbcharsetprober.py | +--universaldetector.py

Agora, suponha que o universal detector.py precisa de importar todas as constantes.py.，另外还需要导入mbcharsetprober.py的一个类。你会怎样做?

Notas	Python 2	Python 3
①	Constantes de importação	das constantes.import
②	do mbcharsetprober importar MultiByteCharSetProber	do.mbcharsetprober importar MultiByteCharsetProber

1, quando você precisa importar o módulo inteiro de outro lugar do pacote, use o novo from. import sintaxe.universaldetector.py) e você quer importar o arquivo (((constants.pyNo exemplo acima, os dois documentos estão no mesmo diretório, portanto, um único ponto é usado. Você também pode importar do diretório pai ((from... import anothermodule) ou do diretório subdirectório. 2, para importar uma classe ou função específica de outros módulos diretamente para o espaço de nomes do seu módulo, adicione o caminho relativo no início do módulo a importar e remova o último 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 (de... import anothermodule) ou do diretório filho.

• Método do iterador next (((

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

Notas	Python 2	Python 3
①	AnIterator.next ((()	Próximo (Aniterador)
②	a_function_that_returns_an_iterator().next()	next ((a_function_that_returns_an_iterator())
③	classe A: def next ((self): passar	classe A: def _A seguir.(self): passagem para o outro lado
④	classe A: def next ((self, x, y): passar	Nenhuma alteração
⑤	next = 42 para um_iterador em uma_sequência_de_iteradores: an_iterator.next()	next = 42 para um_iterador em uma_sequência_de_iteradores: um_iterador._A seguir.()

O exemplo mais simples é que você deixou de chamar o método next (() de um iterador e agora passa o próprio iterador como um parâmetro para a função global next ((). 2, se você tem um valor de retorno que é uma função do iterador, invoque 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ê tiver uma classe própria e a usar como um iterador, no Python 3 você pode definir um método especial.A seguir.(), para realizar. 4, se a classe definida tiver um next (), que usa um ou mais parâmetros, 2to3 não o move quando executado. 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ê tiver uma variável local chamada next, em Python 3 ela terá uma prioridade maior do que a função global next (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((A seguir.() para obter o próximo elemento na sequência. Ou, você também pode refazer o código para que o nome da variável local não seja next, mas 2to3 não vai fazer isso por você.

• Filter funções globais

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

Notas	Python 2	Python 3
①	filtro (a_função, a_sequência)	lista ((filtro ((uma_função, uma_sequência))
②	lista ((filtro ((uma_função, uma_sequência))	Nenhuma alteração
③	filtro ((Nenhum, a_sequência)	[i para iin a_sequência se i]
④	para i no filtro ((Nenhum, a_sequência):	Nenhuma alteração
⑤	[i para o filtro iin ((a_função, a_sequência) ]	Nenhuma alteração

1, no caso mais simples, 2to3 usa uma função list ((() para envelopar o filtro ((), e a função list (()) percorre seus parâmetros e retorna uma lista. 2, no entanto, se a chamada filter ((() já foi envolvida pela lista (((), 2to3 não processa mais, pois, nesse caso, não importa se o valor de retorno do filter ((() é um iterador. 3, para lidar com a sintaxe especial de filtro (None,...) 2to3 converte essa chamada de forma equivalente da sintaxe para análise de lista. 4, como o loop for percorre toda a sequência, não é necessário fazer mais modificações. 5, como acima, não é necessário fazer alterações, porque a lista é analisada em toda a sequência, e mesmo que o filtro retorne a um iterador, ele ainda pode funcionar como o filtro anterior retornar a lista.

• Função global map ((()

Assim como as mudanças feitas no filter ((), a função map (() agora retorna um iterador.

Notas	Python 2	Python 3
①	mapa ((a_função,PapayaWhip)	lista ((mapa ((uma_função,PapayaWhip))
②	Mapa ((Nenhum,PapayaWhip)	lista ((PapayaWhip)
③	mapa ((lambda x: x+1,intervalo ((42))	[x+1 para x no intervalo ((42) ]
④	para i em mapa ((a_função, a_sequência):	Nenhuma alteração
⑤	[i para um mapa ((a_função,a_sequência) ]	Nenhuma alteração

1, semelhante ao tratamento do filtro (), no caso mais simples, 2to3 usa uma função list (), para envelopar o recurso map (). 2、 para o mapa especial ((None,...) semântica, semelhante ao filtro ((None,...) 2to3 irá transformá-lo em uma chamada equivalente a list ((). 3, se o primeiro parâmetro de map () é uma função lambda, 2to3 converte-o em uma solução de lista equivalente. Não é necessário fazer alterações para o loop for que percorre toda a sequência. 5, novamente, não é necessário fazer modificações aqui, porque a lista de análise vai percorrer toda a sequência, mesmo que o valor de retorno do map ((() seja um iterador e não uma lista, ele funcionará corretamente.

• A função global reduce (((

No Python 3, a função reduce () foi removida do espaço de nomes global e agora é colocada no módulo fucntools.

Notas	Python 2	Python 3
①	reduzir ((a, b, c)	de funtools importar reduzir reduzir ((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 parâmetros, e retorna o valor f (a, b, c). Você também pode fazer o mesmo, chamando diretamente a função e adicionando um asterisco (a) antes da lista.

Notas	Python 2	Python 3
①	Aplicar (a_função, a_lista_de_argumentos)	a_função ((*a_list_of_args)
②	aplicar ((a_function, a_list_of_args, a_dictionary_of_named_args)	a_função ((*a_list_of_args,**a_dictionary_of_named_args)
③	aplicar ((a_função, a_lista_de_args+z)	a_função(*a_lista_de_args+z)
④	Aplicar ((aModule.a_function, a_list_of_args)	aModule.a_function ((*a_list_of_args)

A forma mais simples é chamar uma função adicionando um asterisco antes da lista de parâmetros (como [a, b, c]). 2, no Python 2, a função apply ((() pode realmente ter três parâmetros: uma função, uma lista de parâmetros, um dicionário de argumentos nomeados. No Python 3, você pode adicionar um asterisco antes da lista de parâmetros.), adicionando dois asteriscos ((**) antes dos parâmetros de nome do dicionário para obter o mesmo efeito. 3, o operador + é usado aqui como função de lista de ligação, e tem maior prioridade do que o operador, por isso não é necessário adicionar parênteses adicionais em torno de a_list_of_args + z. Os scripts 4 e 2 a 3 são inteligentes o suficiente para converter chamadas aplicativas complexas, incluindo chamadas de funções importadas no módulo.

• Função interna global

No Python 2, você pode limitar a função interna em uma string usando a função interna para obter otimização de desempenho. No Python 3, a função interna foi transferida para o módulo sys.

Notas	Python 2	Python 3
①	interna ((aString)	sys.intern ((aString)

• exec expressão

Assim como a instrução print se torna uma função no Python 3, a instrução exec também é assim. A função exec usa uma string que contém qualquer código Python como um parâmetro e executa-a como se fosse uma instrução de execução ou uma expressão. A função exec é semelhante àeval, mas é mais robusta e mais sofisticada. A função exec executa apenas uma expressão individual, mas a função exec executa várias instruções, importa, importa e declara funções.

Notas	Python 2	Python 3
①	exec codeString	exec ((codeString)
②	exec codeString em a_global_namespace	exec ((codeString, a_global_namespace)
③	exec codeString no espaço de nomes global, espaço de nomes local	exec ((codeString, a_global_namespace,a_local_namespace)

1, na sua forma mais simples, porque exec ((() é agora uma função, e não uma frase, 2to3 encerra este código de forma de string com parênteses. 2, A instrução exec no Python 2 pode especificar o espaço de nomes, o código será executado no espaço privado, que é composto por objetos globais. O Python 3 também possui essa função; você só precisa passar esse espaço de nomes como o segundo parâmetro para a função exec (). 3, ainda mais surpreendentemente, a instrução exec no Python 2 também pode especificar um namespace local (por exemplo, uma variável declarada em uma função). No Python 3, a função exec também tem essa função.

• execfile declarações

Assim como o exec anterior, o execfile em Python 2 pode ser executado usando strings da mesma forma que o código Python. Diferentemente do exec, o exec usa strings e o execfile usa arquivos. No Python 3, o execfile já foi removido. Se você realmente quiser executar o código Python de um arquivo (mas não quiser importá-lo), você pode fazer isso abrindo o arquivo, lendo o conteúdo dele e depois chamando a função compile (compile) global.

Notas	Python 2	Python 3
①	execfile ((a_filename)	exec ((compile ((open ((a_filename).read(),a_filename,exec))

• repr (em contra-cotas)

Em Python 2, para obter a representação de uma cadeia de caracteres de um objeto arbitrário, há uma forma de envelopar o objeto em uma contracitação (por exemplo,xNo Python 3, essa capacidade ainda existe, mas você não pode mais usar o contra-citação para obter essa expressão. Você precisa usar a função global repr ().

Notas	Python 2	Python 3
①	Não, não.	repr ((x)
②	` Papaya Whip + `2 `	Rep ((PapayaWhip+rep ((2))

1, lembre-se, x pode ser qualquer coisa uma classe, função, módulo, tipo de dados básicos, etc..repr ()) função pode usar qualquer tipo de parâmetros. 2, no Python 2, as contra-citas podem ser aninhadas, resultando em uma expressão desconcertante mas eficaz. 2to3 é inteligente o suficiente para converter essa chamada de anel em função repr.

• Try...except expressão

A sintaxe de captura de anomalias pode variar um pouco de Python 2 para Python 3.

Notas	Python 2	Python 3
①	try: importar mymodule exceto ImportError, e pass	tentativa: importar mymodule exceto ImportError como e: passar
②	try: importar mymodule exceto (RuntimeError, ImportError), e pass	try: importar mymodule exceto (RuntimeError, ImportError) como e: passar
③	tentativa: importar mymodule exceto ImportError: pass	Nenhuma alteração
④	Tente: importar mymodule exceto: passar	Nenhuma alteração

1, em comparação com a adição de vírgulas após o tipo de exceção no Python 2, o Python 3 usa uma nova palavra-chave, as. A palavra-chave as pode também ser usada para capturar vários tipos de anomalias ao mesmo tempo. Se você capturar uma anomalia, mas não quer acessar o objeto da anomalia, a sintaxe do Python 2 e do Python 3 é a mesma. 4, da mesma forma, se você usar um método de segurança (fallback) para capturar todas as exceções, a sintaxe do Python 2 e do Python 3 é a mesma. 5. Ao importar um módulo (ou na maioria das outras situações), você absolutamente não deve usar esse método (refira-se o fallback acima); caso contrário, o programa pode capturar uma exceção como KeyboardInterrupt (se o usuário interromper o programa com Ctrl-C), tornando o depurador mais difícil.

• Raise expressão

Em Python 3, há pequenas mudanças na sintaxe para lançar anomalias personalizadas.

Notas	Python 2	Python 3
①	Levante a MinhaExcepção	Inalterado
②	levantar MyException, mensagem de erro	levantar MyException (( mensagem de erro)
③	levantar MyException, mensagem de erro, a_traceback	levantar MyException (Mensagem de erro).com_traceback (a_traceback)
④	levantar mensagem de erro	não suportado

1, lançando uma anomalia que não traz uma mensagem errada personalizada pelo usuário, sem que a sintaxe seja alterada na sua forma mais simples. A mudança é óbvia quando você deseja lançar uma anomalia com um erro personalizado pelo usuário. O Python 2 separa o tipo de anomalia e o erro com um ponto; o Python 3 passa o erro como um parâmetro para o tipo de anomalia. O Python 2 suporta uma sintaxe mais complexa para lançar uma excepção com um rastreamento de pilha personalizado pelo usuário. Você pode fazer isso no Python 3, mas a sintaxe é 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. O 2to3 irá alertá-lo de que não pode corrigir essa sintaxe automaticamente.

• Método de lançamento do gerador

No Python 2, o gerador tem um método throw (); a chamada a_generator.throw (); lança uma anomalia 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 gramaticalmente.

Notas	Python 2	Python 3
①	a_generator.throw ((MyException))	Nenhuma alteração
②	a_generator.throw ((MyException, mensagem de erro)	a_generator.throw ((MyException (( mensagem de erro))
③	a_generator.throw (( mensagem de erro)	não suportado

1, na sua forma mais simples, o gerador lança uma anomalia que não traz uma mensagem de erro personalizada pelo usuário. Neste caso, não há mudança de sintaxe de Python 2 para Python 3. Se o gerador lança uma anomalia com um erro personalizado pelo usuário, você precisa passar essa string de erro para a classe de anomalias para instantiá-la. O Python 2 também suporta o lançamento de anomalias com apenas informações de exceção. O Python 3 não suporta essa sintaxe e o 2to3 exibe um aviso informando que você precisa reparar manualmente o código.

• Função global xrange ((()

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

Notas	Python 2	Python 3
①	xrange ((10)	Distância ((10)
②	a_list = intervalo ((10)	a_list = lista (range)
③	[i para a faixa de variação ((10) ]	[i para a faixa de variação ((10) ]
④	para i no intervalo ((10)):	Nenhuma alteração
⑤	Somma (range)	Nenhuma alteração

1, no caso mais simples, 2to3 simplesmente converte xrange (()) para range (()). 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 retornar um erro e então usar list (), para forçar a conversão do valor de retorno de range (), para o tipo de lista. 3, se a função xrange () estiver presente na análise de listas, não é necessário converter o valor de retorno dela para uma lista, pois a análise de listas é igualmente válida para o iterador. 4, semelhante, o ciclo for também funciona no iterador, por isso não muda nada aqui também. 5, a função sum () pode funcionar no iterador, então 2to3 não é modificado aqui. Assim como o método de dicionário que retorna o valor como vista (view) e não mais como lista, isso também é válido para min (min), max (max), sum (sum), list (list), tuple (tuple), set (set), sorted (sorted), any (any), and all (all)).

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

O Python 2 tem duas funções globais que são usadas na linha de comando para solicitar informações ao usuário. A primeira é chamada de input, que espera que o usuário insira uma expressão Python e retorna resultados. A segunda é chamada de raw_input, que retorna o que o usuário insere. Isso é muito confuso para os iniciantes e é amplamente visto como um chiclete da linguagem Python.

Notas	Python 2	Python 3
①	raw_input()	Input ((()
②	raw_input ((prompt)	Introdução
③	Input ((()	Avaliação (input)

A forma mais simples, raw_input ((() é substituída por input ((()). 2, em Python 2, a função raw_input () pode especificar um prompt como um parâmetro. Se você realmente quiser solicitar que o usuário insira uma expressão Python, o resultado pode ser calculado chamando a função input ((() e passando o valor de retorno para eval ((().

• Função func_*

No Python 2, o código dentro da função pode acessar as propriedades especiais da função em si. No Python 3, essas propriedades especiais foram renomeadas para maior consistência.

Notas	Python 2	Python 3
①	a_function.func_name	Função.Nome
②	a_função.func_doc	Função.Doc.
③	a_function.func_defaults	Função.padrões_
④	a_function.func_dict	Função.Dict_
⑤	a_function.func_closure	Função.fechamento
⑥	a_function.func_globals	Função.Globalmente
⑦	a_function.func_code	Função.Código_

1,__name__ propriedade ((original func_name) contém o nome da função. 2,__doc__ propriedade ((originalfuncdoc) contém a string do documento que você definiu no código fonte da função ((docstring)) 3,__defaults__ propriedade ((originalfunc_defaults) é um conjunto de elementos que guarda o valor padrão do parâmetro. O atributo __dict__ (original func_dict) é um espaço de nomes que suporta atributos de funções arbitrárias. O atributo func_closure é um conjunto de objetos cell que contém a ligação de funções a variáveis livres. A propriedade __globals__ é uma referência ao espaço de nomes global do módulo, onde a função é definida. O atributo __code__ é um objeto de código que representa um corpo de funções compilado.

• Método de I/O xreadlines

No Python 2, os objetos de arquivo têm um método xreadlines (), que retorna um iterador, uma linha de leitura de arquivo por vez. Isso é especialmente útil no ciclo for. Na verdade, versões posteriores do Python 2 adicionaram esse recurso ao próprio objeto de arquivo.

No Python 3, o método xreadlines ((() não está mais disponível. 2to3 pode resolver situações simples, mas alguns casos de borda exigem intervenção manual.

Notas	Python 2	Python 3
①	para linha em a_file.xreadlines():	para linha em a_file:
②	para linha em a_file.xreadlines(5):	Nenhuma alteração (quebrada)

1, se você tiver chamado xreadlines sem parâmetros anteriormente, 2to3 o transformará no objeto do arquivo em si. No Python 3, esse código depois da conversão pode fazer o mesmo trabalho antes: ler uma linha do arquivo uma vez e executar o loop do loop for. 2, Se você já usou um parâmetro (xreadlines) para chamar xreadlines (), 2to3 não pode fazer a conversão de Python 2 para Python 3 para você, seu código vai falhar da seguinte forma: AttributeError: _io.TextIOWrapper object has no attribute xreadlines. Você pode manualmente transformar xreadlines (xreadlines) em readlines (xreadlines) para que o código funcione no Python 3.

• Funções lambda que usam elementos em vez de vários parâmetros

No Python 2, você pode definir uma função lambda anônima, permitindo que a função receba vários parâmetros, especificando o número de elementos de um conjunto de elementos como um parâmetro. Na verdade, o interpretador do Python 2 desembaina este conjunto de elementos em parâmetros nomeados, e você pode então referenciá-los no lambda. No Python 3, você ainda pode passar um conjunto de elementos como parâmetros da função lambda, mas o interpretador do Python não o resolve como parâmetros nomeados.

Notas	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	Inalterado

1, se você já definiu uma função lambda, que usa um elemento que contém um elemento como parâmetro, no Python 3, ela é convertida para um lambda que contém uma referência para x1[0]; x1 é um script 2to3 gerado automaticamente com base nos parâmetros de nome do elemento original. 2, A função lambda usada como parâmetro para um conjunto de elementos com dois elementos ((x, y) é convertida para x_y, que tem dois parâmetros de posição, x_y[0] e x_y[1]; Os scripts 3 e 2to3 podem até processar componentes que usam os parâmetros de nomeação do ninho como funções lambda. O código resultante é um pouco mais difícil de ler, mas tem o mesmo efeito no Python 3 que o código original no Python 2. 4, você pode definir uma função lambda usando vários parâmetros. Se não houver parênteses em torno da função, Python 2 a tratará como uma função lambda com vários parâmetros; neste corpo de funções lambda, você cita esses parâmetros por nome, como acontece com outras funções de tipo.

• Atribuições de métodos especiais

No Python 2, os métodos de classe podem acessar objetos de classe que definem os mesmos, mas também podem acessar os próprios objetos de método. Im_self é o objeto exemplo da classe; im_func é o objeto funcional e im_class é a própria classe. No Python 3, essas propriedades são renomeadas para seguir as convenções de nomeação de outras propriedades.

Notas	Python 2	Python 3
①	aClassInstance.aClassMethod.im_func	aClassInstance.aClassMethod._Função
②	aClassInstance.aClassMethod.im_self	aClassInstance.aClassMethod._Eu mesmo.
③	aClassInstance.aClassMethod.im_class	aClassInstance.aClassMethod._Eu mesmo.._classe_

• __nonzero__ método especial

No Python 2, você pode criar suas próprias classes e usá-las em um contexto booleano. Por exemplo, você pode instanciar essa classe e usar esse objeto de exemplo em uma seção. Para isso, você define um objeto especial.Não zero() método, cujo valor de retorno é True ou False, e que é chamado quando o objeto do exemplo está no contexto de Boole. No Python 3, você ainda pode executar a mesma função, mas o nome deste método especial se tornaBool_()。

Notas	Python 2	Python 3
①	classe A: def _Não zero(self): passar	classe A: def _Bool_(self): passar
②	classe A: def _Não zero(self, x, y): passar	Nenhuma alteração

1, quando um objeto de classe é usado no contexto de Boole, Python 3 chamaBool_(), e nãoNão zero(Aplausos) Mas se você tiver uma definição que usa dois parâmetrosNão zeroO script 2to3 assume que o método definido por você tem outro uso e, portanto, não modifica o código.

• Tipos de octavos

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

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

• sys.maxint

A constante sys.maxint não é mais precisa porque os inteiros e os inteiros foram integrados. Mas, como esse valor é útil para a capacidade de detecção de uma plataforma específica, ele foi mantido pelo Python 3 e renomeado como sys.maxsize.

Notas	Python 2	Python 3
①	do sys importmaxint	do 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ção global callable ((()

No Python 2, você pode usar a função global callable para verificar se um objeto é chamável. No Python 3, essa função global foi cancelada. Para verificar se um objeto é chamável, você pode verificar métodos especiais.Chama-me.A existência de ().

Notas	Python 2	Python 3
①	Callable (qualquer coisa)	Não tem nada, _Chama-me.’)

• Função global ((zip)

No Python 2, a função global zip ((() pode usar várias séries como parâmetros, e retorna uma lista composta por componentes. O primeiro componente contém o primeiro elemento de cada série; o segundo componente contém o segundo elemento de cada série; e, em seguida, se move para baixo. No Python 3, zip ((() retorna um iterador, não uma lista.

Notas	Python 2	Python 3
①	zip ((a, b, c)	lista ((zip ((a, b, c))
②	d.join ((zip ((a, b, c))	Nenhuma alteração

Na forma mais simples, você pode restaurar o valor de retorno da função zip antes da função list (), que percorre o iterador onde a função zip () é devolvida e retorna a lista de resultados. Em um ambiente contextual que já percorre todos os elementos da seqüência (por exemplo, aqui a chamada para o método join), o iterador que retorna o zip funciona normalmente. O script 2to3 detecta essas situações e não altera o seu código.

• Erro padrão

No Python 2, o StandardError é um sub-clube de todas as outras anomalias embutidas, exceto StopIteration, GeneratorExit, KeyboardInterrupt e SystemExit. No Python 3, o StandardError foi eliminado; substituído por Exception.

Notas	Python 2	Python 3
①	x =Erro Padrão()	x = Exceção ((()
②	x = StandardError ((a, b, c)	x = Exceção ((a, b, c)

• Constantes no módulo types

O módulo types tem uma variedade de constantes que ajudam a determinar o tipo de um objeto. No Python 2, ele contém as constantes que representam todos os tipos de dados básicos, como dict e int. No Python 3, essas constantes foram eliminadas.

Notas	Python 2	Python 3
	types.UnicodeType	str
	types.StringType	bytes
	types.DictType	Dicionário
	types.IntType	int
	types.LongType	int
	types.ListType	lista
	types.NoneType	Tipo ((Nenhum)
	types.BooleanType	Bool
	types.BufferType	memóriaview
	types.ClassType	Tipo
	types.ComplexType	complexo
	types.EllipsisType	Tipo ((Elípsis)
	types.FloatType	flutuante
	types.ObjectType	Objeto
	types.NotImplementedType	Tipo ((Não implementado)
	types.SliceType	Parcela
	types.TupleType	dupla
	types.TypeType	Tipo
	types.XRangeType	Distância

Types.StringType é mapeado como bytes, não como str, porque a barra de string em Python 2 é na verdade apenas uma sequência de bytes codificada com algum tipo de caractere.

• Funções globais in instance

A função isinstance verifica se um objeto é uma instância de uma determinada classe ou tipo. No Python 2, você pode passar um elemento constituído por tipos para o istance, e a função retorna True se o objeto for qualquer tipo do conjunto. No Python 3, você ainda pode fazer isso, mas não é recomendável passar duas vezes usando um tipo como parâmetro.

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

• Tipo de dados basestring

O Python 2 possui dois tipos de strings: strings codificados em Unicode e strings não codificados em Unicode. Mas há um outro tipo, basestring. É um tipo de dados abstrato, uma superclasse de tipos str e unicode. Não pode ser invocado ou instantiado diretamente, mas você pode usá-lo como um parâmetro de instância para detectar se um objeto é uma strings Unicode ou não Unicode.

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

• módulo itertools

O Python 2.3 introduziu um módulo de itertools, que define variantes (variantes) para as funções globais zip, map e filter, cujo tipo de retorno é um iterador, e não uma lista. No Python 3, essas variantes foram canceladas porque o tipo de retorno dessas funções globais é um iterador.

Notas	Python 2	Python 3
①	itertools.izip (a, b)	zip ((a, b)
②	itertools.imap (a, b)	mapa ((a, b)
③	itertools.ifilter ((a, b)	filtro ((a, b)
④	Importação de imap, izip, foo	Importação de dados

1, usando a função global zip ((() em vez de itertools.izip ((()). 2、 Use map (em vez de itertools.imap (em) ‖ 3,itertools.ifilter ((() tornou-se filtro ((() ▽ O módulo itertools ainda existe no Python 3, apenas não contém funções que já 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

Quando se trata de 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, elas já existiam na era do Python 1). A partir do Python 1.5, não é mais recomendado o uso dessas três variáveis devido ao novo sys.exc_info, que é um subconjunto que contém todos os três elementos acima. No Python 3, elas finalmente não existem mais; isso significa que você deve usar sys.exc_info.

Notas	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]

• Parse a lista de elementos

No Python 2, se você precisa escrever uma análise de lista que percorre um conjunto de elementos, você não precisa colocar parênteses em torno do valor do elemento. No Python 3, esses parênteses são necessários.

Notas	Python 2	Python 3
	[i para in 1,2]	[i para 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 lidar com nomes de diretórios que podem ser codificados por vários caracteres, o Python 2.3 introduziu a função os.getcwdu (), que retorna o diretório de trabalho atual como uma string codificada em Unicode.

Notas	Python 2	Python 3
	Os.getcwdu ((()	Os.getcwd()

• Metaclasses

No Python 2, você pode criar uma meta-classe definindo os parâmetros da meta-classe na declaração da classe, ou definindo uma propriedade especial de nível de classe. No Python 3, a propriedade _metaclass__ foi cancelada.

Notas	Python 2	Python 3
①	classe C ((metaclass=PapayaMeta): passar	Inalterado
②	classe Whip: _Metaclasse_= PapayaMeta	classe Whip ((metaclass=PapayaMeta): passe
③	Classe C (Fraqueador, Batedor):Metaclasse_= PapayaMeta	Classe C ((Whipper,Beater,metaclass=PapayaMeta):

1, quando a classe é declarada, declara os parâmetros da metaclass, o que é válido em Python 2 e Python 3, eles são os mesmos. 2, na definição da classe, declara que a propriedade __metaclass__ é válida no Python 2, mas não é 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-padres.

• Sobre o estilo de código

As seguintes correções não são realmente correções; isto é, são apenas coisas sobre o estilo do código e não envolvem a essência do código. No entanto, os desenvolvedores do Python têm um grande interesse 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 Python.

• set (literal) (explicativo)

No Python 2, a única maneira de definir um conjunto de valores literais é chamando um conjunto de seqüências. No Python 3, isso ainda é válido, mas a nova notação literal: parênteses maiores é uma maneira mais clara. Este método é válido além dos conjuntos vazios, pois o dicionário também é marcado por parênteses maiores, então {} significa um dicionário vazio, não um conjunto vazio.

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

Notas	Antes	Após
	conjunto (([1,2,3])	{1,2,3}
	conjunto (((1,2,3))	{1,2,3}
	conjunto (([i para iin a_sequência])	{i para dentro de uma_ sequência}

• Função global buffer (a) (obviamente)

Objetos Python implementados em C podem exportar uma interface de buffer que permite que outro código Python leia e escreva diretamente em um bloco de memória. Isso soa poderoso, mas é igualmente terrível.

Os scripts 2to3 não reparam a função buffer ((() por padrão. Para ativar essa função, especifique o parâmetro -f buffer quando a linha de comando for chamada para 2to3.

Notas	Antes	Após
	x = amortecedor (y)	x = visualização de memória ((y))

• Espaços em torno de vírgulas (obviamente)

Embora o Python seja muito rígido em relação aos espaços de indentamento e de salientação, o Python é livre para usar espaços em outros aspectos. Em listas, componentes, conjuntos e dicionários, os espaços podem aparecer antes ou depois dos commas, o que não tem nenhum efeito negativo. No entanto, o manual de estilo de código do Python indica que não pode haver um espaço antes dos commas e um espaço após os commas.

Os scripts 2to3 não reparam os espaços ao redor dos vírgulos por padrão. Para ativar este recurso, especifique o parâmetro -f wscomma quando a linha de comando for chamada para 2to3.

Notas	Antes	Após
	a, b	a, b
	- Não, não.	- Não, não.

• Idiomas comuns (obviamente)

Muitos protocolos foram estabelecidos na comunidade Python. Existem alguns como o while 1: loop, que remonta ao Python 1. (Python não teve um tipo de buraco de verdadeiro significado até o Python 2.3, então os desenvolvedores usaram 1 e 0 alternativos anteriormente.)

Os scripts 2to3 não corrigem essas convenções por padrão. Para ativar essa função, especifique o parâmetro -f idioms quando a linha de comando for chamada para 2to3.

Notas	Antes	Após
	enquanto 1: do_stuff()	enquanto True: do_stuff()
	Tipo ((x) == T	é instância ((x, T)
	Tipo ((x) é T	é instância ((x, T)
	a_lista = lista ((a_sequência)	a_list = sorted (a_sequência)
	a_list.sort (()	do_stuff ((a_list)
	do_stuff ((a_list)

Traduzido porBlog do CSDN

Como converter código do Python 2 para código do Python 3

Como converter o código do Python 2.x para o código do Python 3.x. Como converter código Python 2.x para Python 3.x

• 1.自己手动转换

Isso não é preciso dizer muito, se apenas envolve poucas funções, como print, etc.

A partir daí, você pode alterar seu próprio código.

• 2.利用Python内置（Python脚本）工具，帮你自动转换

A versão 2.x do Python, como o Python 2.7.2 que eu instalei, vem com algumas ferramentas úteis após o download e instalação do Windows.

其中一个叫做2to3.pyO Python 2.x é o código que você pode usar para transformar o código do Python 2.x para o Python 3.x.

Ele está localizado no diretório raiz instalado no Python \Python27\Tools\Scripts\2to3.py

【如何利用2to3.py, implementar o código do Python 2.x, transformando-o em um bloco de código do Python 3.x Por exemplo, eu tenho um script Python 2.x:

D:\tmp\tmp_dev_root\python\python2_to_python3\34563264_data_from_site.py

Agora, quero transformá-lo em código Python 3.x.

Pode-se abrir o cmd do windows, localizá-lo sob o script a ser convertido e executá-lo.

D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py

Se a conversão for bem-sucedida, o resultado da execução correspondente será:

D:\tmp\tmp_dev_root\python\python2_to_python3>D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py
RefactoringTool: Skipping implicit fixer: buffer
RefactoringTool: Skipping implicit fixer: idioms
RefactoringTool: Skipping implicit fixer: set_literal
RefactoringTool: Skipping implicit fixer: ws_comma
RefactoringTool: Refactored 34563264_data_from_site.py
--- 34563264_data_from_site.py  (original)
+++ 34563264_data_from_site.py  (refactored)
@@ -18,7 +18,7 @@
 import time;
 import codecs;
 import logging;
-import urllib;
+import urllib.request, urllib.parse, urllib.error;
 from datetime import datetime,timedelta;
 from optparse import OptionParser;
 from string import Template,replace;
@@ -90,7 +90,7 @@
         foundPhone = eachItemSoup.find(attrs={"class":"phone"});
         logging.debug("foundPhone=%s", foundPhone);
         if(foundPhone):
-            foundPhoneUni = unicode(foundPhone);
+            foundPhoneUni = str(foundPhone);
             logging.debug("foundPhoneUni=%s", foundPhoneUni);
             # case 1:
             #<p class="phone"><strong>phone:</strong>&nbsp;800.206.7886<br />
@@ -122,7 +122,7 @@
         foundWeb = eachItemSoup.find(attrs={"class":"web"});
         logging.debug("foundWeb=%s", foundWeb);
         if(foundWeb):
-            foundWebUni = unicode(foundWeb);
+            foundWebUni = str(foundWeb);
             logging.debug("foundWebUni=%s", foundWebUni);
 
             # <p class="web"><strong>e-mail:</strong>&nbsp;<a href="#">sales@cinesysinc.com</a><br />
@@ -151,7 +151,7 @@
         foundAddr = eachItemSoup.find(attrs={"class":"addr"});
         logging.debug("foundAddr=%s", foundAddr);
         if(foundAddr):
-            foundAddrUni = unicode(foundAddr);
+            foundAddrUni = str(foundAddr);
 
             # <p class="addr">
                 # <strong>address:</strong>&nbsp;740 SW 21st Ave, Suite #310<br />
RefactoringTool: Files that were modified:
RefactoringTool: 34563264_data_from_site.py

Neste ponto, você pode ver o original 34563664_data_from_site.py, que se tornou a versão 3.x do Python.

Mais.