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.
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=
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. | |
| ② | Ur |
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.
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) |
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.
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.
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 (( |
|
| ② | 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
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 (()).
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.
| 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
| 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) |
| 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 |
| Notas | Python 2 | Python 3 |
|---|---|---|
| ① | importar xmlrpclib | Importar xmlrpc.client |
| ② | importar DocXMLRPCServer importar SimpleXMLRPCServer |
Importar xmlrpc.server |
| 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.
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.
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ê.
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.
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, |
lista ((mapa ((uma_função, |
| ② | Mapa ((Nenhum, |
lista (( |
| ③ | 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.
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) |
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.
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) |
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.
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 (( |
exec ((compile ((open (( |
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) |
| ② | ` |
Rep (( |
1, lembre-se, x pode ser qualquer coisa
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.
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, |
levantar MyException (( |
| ③ | levantar MyException, |
levantar MyException (Mensagem de erro).com_traceback (a_traceback) |
| ④ | levantar |
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.
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, |
a_generator.throw ((MyException (( |
| ③ | a_generator.throw (( |
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.
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)).
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 (( |
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 ((().
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.
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:
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.
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_ |
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.
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 |
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.
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, |
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.
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) |
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.
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)) |
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) |
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.
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] |
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)] |
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() |
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.
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.
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} |
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)) |
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. |
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 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
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.
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> 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> <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> 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.
FangBeiO botvs usa Python 2?
Sonhos pequenosO servidor de retrospecção do BotVS usa a versão 2.7 do Python, com suporte para as plataformas BotVS Python 2 e Python 3.