Casi todos los programas de Python 2 requieren algunas modificaciones para funcionar correctamente en el entorno de Python 3. Para simplificar este proceso de conversión, Python 3 viene con un script útil llamado 2to3 (Utility Script), que toma su archivo fuente de programa de Python 2 como entrada y luego lo convierte automáticamente a la forma de Python 3.
En Python 2, print es una frase. Cualquier cosa que quieras exportar, sólo tienes que ponerlas detrás de la palabra clave print. En Python 3, print ((() es una función.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Imprimir | Imprimir |
| ② | Impresión 1 | Imprimir (1) |
| ③ | Impresión 1,2 | Imprimir |
| ④ | Imprimir 1, 2, | Impresión ((1,2,fin= |
| ⑤ | Imprimir >> sys.stderr,1,2,3 | Imprimir ((1,2,3, archivo=sys.stderr) |
1, para exportar una línea en blanco, se requiere una llamada de print sin parámetros ((() ⇒
2, para exportar un valor separado, es necesario que este valor sea un parámetro de print ().
3, para la salida se utilizan dos valores separados por un espacio y se puede llamar print (() con dos parámetros.
4, este ejemplo tiene algunos trucos. En Python 2, si usas un coma (,) como el final de la sentencia de print, esto producirá un resultado separado por espacios, y luego producirá un espacio que sigue (trailing space) sin producir un regreso de carrocería. En Python 3, se puede lograr el mismo efecto al pasar end=
Python 2 tiene dos tipos de strings:Cuadros de UnicodeyLas cuerdas que no son UnicodeEn Python 3 sólo hay un tipo:Las cadenas de código Unicode。
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | ¿Por qué no lo haces? | |
| ② | ¿Por qué no lo haces? | ¿Por qué no lo haces? |
Las cadenas de Unicode en Python 2 son cadenas normales en Python 3, ya que en Python 3 las cadenas son siempre de formato Unicode. Las líneas originales de Unicode ("raw string") ("Python no traducirá automáticamente la línea inversa" con estas líneas) también se sustituyen por líneas normales, ya que en Python 3 todas las líneas originales están codificadas en Unicode.
En Python 2 hay dos funciones globales que pueden convertir objetos forzosamente a una cadena: unicode (() que convierte objetos a una cadena Unicode, y str (() que convierte objetos a una cadena no Unicode. Python 3 sólo tiene un tipo de cadena, la cadena Unicode, por lo que la función str (() puede realizar todas las funciones.La función unicode (()) ya no existe en Python 3.)
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Unicode ((cualquier cosa) | No hay nada. |
Python 2 tiene int y long preparados para números sin punto flotante. El valor máximo del tipo int no puede ser superior a sys.maxint, y este valor máximo es relevante para la plataforma. Se puede definir un tipo de integro longitudinal agregando una L al final del número, que obviamente es mayor que el rango numérico representado por el tipo de int. En Python 3, solo hay un tipo de integer int, que en la mayoría de los casos es muy parecido al tipo de integro longitudinal de Python 2.
Para más información, vea: PEP 237: Unificar el tipo completo y el tipo completo.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | x = 1000000000000L | El importe de las pérdidas se calculará en función de las pérdidas anuales. |
| ② | Se aplicará el método de cálculo de las emisiones de gases de efecto invernadero. | Se aplicará el método siguiente: |
| ③ | largo (x) | Int (x) |
| ④ | el tipo ((x) es largo | el tipo ((x) es int |
| ⑤ | esinstancia ((x,largo) | esinstancia ((x,int) |
En Python 2 el integer decimal se sustituye por el integer ordinario decimal en Python 3. En Python 2, el integer de 16 dígitos se sustituye por el integer ordinario de 16 dígitos en Python 3. En Python 3, ya que el formato completo ya no existe, el formato completo es el mismo.La función natural long ((() tampoco existe. Para forzar la conversión de una variable a un tipo entero, se puede usar la función int ((().¿Qué es esto? Verifica si una variable es de tipo entero, obtiene su tipo de datos y la compara con una de tipo int (no larga). También puede usar la función istance (() para verificar el tipo de datos; una vez más, enfatiza que int, en lugar de long, es el tipo de número entero.
Python 2 soporta <> como sinónimo de!=. Python 3 sólo soporta!=, ya no soporta <>.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | si x <> y: | si x! = y: |
| ② | si x <> y<> z: | Si x es igual a y es igual a z: |
1, simple comparación. 2, comparación entre tres valores de complejidad relativa.
En Python 2, el método has_key para objetos de diccionario se usa para probar si el diccionario contiene una clave específica. Python 3 ya no admite este método.En elEl operador.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | A_dictionary.has_key (( |
|
| ② | a_dicionario.tiene_clave (x) o a_dicionario.tiene_clave (y) | x en el diccionario o y en el diccionario |
| ③ | a_dictionary.has_key ((x o y) | (x o y) en el diccionario |
| ④ | a_dictionary.has_key ((x + y) | (x + y) en el diccionario |
| ⑤ | x + a_dictionary.has_key (y) | x + (y en el diccionario) |
1, la forma más simple.
2, el operador or tiene una prioridad menor que el operador in, por lo que no hay que añadir paréntesis aquí.
Por otra parte, por la misma razón, la prioridad de
En Python 2, muchos métodos de la clase de diccionario devuelven valores de listas. Los métodos más comunes incluyen claves, elementos y valores. En Python 3, todos los métodos devuelven valores en una vista dinámica. En algunos entornos contextuales, este cambio no tiene efecto.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | a_dicionario.claves() | lista ((un_dicionario.claves()) |
| ② | a_dicionario.items (en inglés) | Lista de artículos del diccionario |
| ③ | a_dicionario.iterkeys() | iter ((a_dictionary.keys)) |
| ④ | [i para iin a_dictionary.iterkeys() ] | [i para iin a_dictionary.keys() ] |
| ⑤ | Min (a_dicionario.claves) | No hay cambio |
La función 1, que utiliza la lista (((), convierte el valor de retorno de keys ((() en una lista estática, por razones de seguridad, 2to3 puede retornar errores. Este tipo de código es válido, pero es un poco menos eficiente para usar la vista. 2, que es otro punto de vista de la conversión de la manera (sobre los elementos) a la lista. La conversión de la manera 2to3 a los valores también es lo mismo. 3, en Python 3 ya no se soportan los iterkeys (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 4, 2to3 es capaz de reconocer que el método de iterkeys se utiliza en el análisis de listas y luego lo convierte en keys en Python 3. 5, 2to3 también puede reconocer que el valor de retorno del método keys (() se transmite de inmediato a otra función que recorre toda la secuencia, por lo que no es necesario convertir el valor de retorno de keys (() a una lista. Por el contrario, la función min (()) está dispuesta a recorrer la vista. Este proceso es igualmente válido para min ((), max ((), sum ((), tuple ((), setlist ((), sorted ((), any (()) y all (()).
Desde Python 2 hasta Python 3, algunos módulos de la librería estándar han sido renombrados. Otros módulos interrelacionados también se han combinado o reorganizado para hacer que esta asociación sea más lógica.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Importación httplib | Importar http.client |
| ② | Importación de cookies | Importar http.cookies |
| ③ | Importación de cookies | Importar http.cookiejar |
| ④ | Importar BaseHTTPServer importar SimpleHTTPServer importar CGIHttpServer |
Importar el servidor http. |
El módulo http.client implementa una base de datos que se puede utilizar para solicitar recursos HTTP y analizar las respuestas HTTP. El módulo http.cookies proporciona una interfaz Python para obtener las cookies enviadas a través del encabezado de Set-Cookie Los navegadores más populares almacenan las cookies en forma de archivos en el disco, que pueden ser manipulados por el módulo http.cookiejar. El módulo http.server implementa un servidor HTTP básico
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Importación de URL | importar urllib.request urllib.parse,urllib.error |
| ② | Importación de urllib2 | Importar urllib.request urllib.error |
| ③ | Importación de URL | Importar urllib.parse |
| ④ | Importar robotparser | Importar urllib.robotparser |
| ⑤ | desde urllib import FancyURLopener desde urllib import urlencode |
desde urllib.request importar FancyURLopener desde urllib.parse importar urlencode |
| ⑥ | desde urllib2 import Solicitud desde urllib2 import HTTPError |
desde urllib.request import Request desde urllib.error import HTTPError |
Anteriormente, el módulo urllib en Python 2 tenía una gran variedad de funciones, incluyendo urlopen para obtener datos, y también era útil para dividir una URL en sus componentes: splittype, splithost y splituser. En el nuevo paquete urllib, estas funciones están organizadas de manera más lógica. En Python 3, el módulo urllib2 anterior se incorporó al paquete urllib. Además, en urllib2 todas tus cosas favoritas aparecerán como parte integrante del módulo urllib de Python 3, como el método build_opener, objetos de solicitud, HTTPBasicAuthHandler y amigos. El módulo urllib.parse de Python 3 contiene todas las funciones de análisis del módulo urlparse original de Python 2. El módulo urllib.robotparse analiza el archivo robots.txt. La clase FancyURLopener, que maneja redirecciones HTTP y otros códigos de estado, sigue siendo válida en el módulo urllib.request de Python 3. Los objetos de solicitud siguen siendo válidos en urllib.request, pero las constantes como HTTPError se han trasladado a urllib.error. ¿He mencionado que 2to3 también reescribirá sus llamadas a funciones? Por ejemplo, si usted ha importado un módulo urllib en su código de Python 2 y ha llamado urllib.urlopen))) para obtener datos, 2to3 modificará la declaración de importación y la llamada de la función al mismo tiempo.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | importar urllib imprimir urllib.urlopen ((")http://diveintopython3.org/’) leer)) | Importar urllib.request, urllib.parse, urllib.error Imprimir (en inglés)http://diveintopython3.org/’) leer)) |
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Importar dbm | Importar dbm.ndbm |
| ② | Importar gdbm | importacióndbm.gnu |
| ③ | Importar dbhash | Importar dbm.bsd |
| ④ | Importa el Dumbdbm | Importar dbm.dumb |
| ⑤ | importar cualquier importar cualquier |
Importar dbm |
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Importar xmlrpclib | Importar xmlrpc.client |
| ② | Importar DocXMLRPCServer importar SimpleXMLRPCServer |
Importar xmlrpc.server |
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Intentar: importar cStringIO como StringIO excepto ImportError: importar StringIO |
Importación |
| ② | Intentar: importar encurtido como encurtido excepto ImportarError: importar encurtido |
encurtidos de importación |
| ③ | ImportarConstruido | Construcciones de importación |
| ④ | Importación de copia_reg | Importación de copias |
| ⑤ | Lista de espera de importación | lista de espera de importación |
| ⑥ | Importar SocketServer | Importar servidor de sockets |
| ⑦ | Importar ConfigParser | Importar el parser de configuración |
| ⑧ | Importación | Importar reprlib |
| ⑨ | comandos de importación | subproceso de importación |
1, en Python 2, lo que normalmente harías es intentar importar cStringIO como alternativa a StringIO primero, y si eso falla, importar StringIO de nuevo. No hagas esto en Python 3; el módulo io te ayudará a manejar esto. En Python 2, importar la implementación más rápida de pickle también es una forma útil similar a la anterior. En Python 3, los módulos de pickle se procesan automáticamente para usted, así que no vuelva a hacerlo. El módulo builtins contiene funciones globales, clases y constantes que se usan en todo el lenguaje Python. Una función redefinida en el módulo builtins significa que esta función global se ha redefinido en todas partes. El módulo copyreg agrega soporte para el módulo pickle para tipos personalizados de usuario definidos en C. El módulo de cola 5 realiza una cola de productores a consumidores (multi-producer, multi-consumer queue). 6. El módulo socketserver proporciona una clase básica general para la implementación de una variedad de servidores de sockets. 7. El módulo de parser de configuración se utiliza para analizar los perfiles de estilo INI. El módulo reprlib reimplementa la función repr () y agrega control sobre la longitud de la expresión de la cadena antes de ser cortada. Los módulos de subprocesos permiten crear subprocesos, conectarse a sus canales y obtener sus valores de retorno.
Un paquete es una entidad única compuesta por un conjunto de módulos asociados. En Python 2, para hacer referencia entre sí a los módulos dentro del mismo paquete, se utiliza import foo o from foo import Bar.2解释器会先在当前目录里搜索foo.pyEn Python 3, el proceso es un poco diferente. Python 3 no busca primero en el camino actual, sino que lo hace directamente en el camino de búsqueda de Python. Si quieres importar un módulo del paquete a otro módulo del paquete, necesitas proporcionar explícitamente el camino relativo de los dos módulos.
Supongamos que tienes el siguiente paquete, varios archivos en el mismo directorio:
- ¿Cuál es el problema? ¿Qué es eso? - ¿Qué quieres decir?Iniciar.py ¿Qué es eso?+--constantes.py | +--mbcharsetprober.py | +--detector universal.py
Ahora supongamos que universaldector.py requiere importar todas las constantes.py.，另外还需要导入mbcharsetprober.py的一个类。你会怎样做?
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Constantes de importación | de las constantes.import |
| ② | desde mbcharsetprober importar MultiByteCharSetProber | desde.mbcharsetprober importar MultiByteCharsetProber |
1, cuando necesites importar todo el módulo desde otra parte del paquete, usa la nueva sintaxis de.import de.from.universaldetector.py¿Quieres importar un archivo?constants.pyEn este ejemplo, los dos archivos están en el mismo directorio, por lo que se utiliza un solo final. También puede importar desde el directorio padre ((from... import anothermodule) o desde el subdirectorio. 2. Para importar una clase o función específica directamente desde otros módulos a tu módulo en el espacio de nombres, añade el camino relativo al principio del módulo que se quiere importar y elimina la última barra (slash). En este ejemplo, mbcharsetprober.py y universaldetector.py están en el mismo directorio, por lo que el nombre del camino relativo es una frase. También puedes importar desde el directorio padre (from... import anothermodule) o desde el directorio subdirectorio.
En Python 2, el iterador tiene un método next (), que se utiliza para devolver el siguiente elemento de la secuencia. En Python 3 funciona igual, pero ahora hay una nueva función global next (), que usa un iterador como parámetro.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | AnIterator.next (() | Siguiente (Aniterador) |
| ② | a_function_that_returns_an_iterator().siguiente() | siguiente ((una_función_que_devuelve_un_iterador()) |
| ③ | clase A: def next ((self): aprueba |
clase A: El siguiente.(sólo): pasar por el |
| ④ | clase A: def next ((self, x, y): pasar |
No hay cambio |
| ⑤ | next = 42 para un_iterador en una_secuencia_de_iteradores: an_iterator.next() |
siguiente = 42 para un_iterador en una_secuencia_de_iteradores: un_iterador._El siguiente.() |
El ejemplo más simple es que ya no llamas el método de next ((() de un iterador, y ahora pasas el propio iterador como parámetro a la función global next ((()). 2, si tienes una función de valor de retorno que es una función del iterador, llama esta función y pasa el resultado como parámetro a la función next (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( 3. si usted asume su propia clase y luego la usa como un iterador, en Python 3 usted puede definir un método especialEl siguiente.(¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡ 4, si la clase que defines tiene un next ((), que usa uno o más parámetros, 2to3 no lo moverá cuando se ejecute. Esta clase no puede ser utilizada como un iterador, ya que su método next (() tiene parámetros. 5, este es un poco complicado. Si por casualidad tienes una variable local llamada next, en Python 3 tendrá mayor prioridad que la función global next ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((El siguiente.También puedes reestructurar el código para que esta variable local no tenga el nombre de next, pero 2to3 no lo hará por ti.
En Python 2, el método filtrar regresa una lista, que se detecta a través de una función que devuelve un valor de True o False para cada elemento de la secuencia. En Python 3, la función filtrar regresa un iterador y ya no es una lista.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Filtro (a_función, a_secuencia) | lista ((filtro ((una_función, una_secuencia)) |
| ② | lista ((filtro ((una_función, una_secuencia)) | No hay cambio |
| ③ | Filtro ((Ninguno, a_secuencia) | [i para iin a_secuencia si i] |
| ④ | para i en filtro ((Ninguno, a_secuencia): | No hay cambio |
| ⑤ | [i para el filtro (a_función, a_secuencia) ] | No hay cambio |
En el caso más sencillo, 2to3 envuelve el filtro con una función list (), y la función list () recorre sus parámetros y devuelve una lista. 2, sin embargo, si la llamada filter ((() ya ha sido envuelta por list ((), 2to3 no procesará más, ya que en este caso no importa si el valor devuelto por filter (()) es un iterador. Para procesar una sintaxis especial como filter (None,...) 2to3 convierte esta llamada de forma equivalente en una lista de análisis. 4. No es necesario hacer más modificaciones, ya que el ciclo for recorre toda la secuencia. 5, igual que arriba, no hay necesidad de hacer cambios, ya que la lista se analiza a través de toda la secuencia, incluso si el filtro regresa a un iterador, todavía puede funcionar como si el filtro anterior regresara a la lista.
Al igual que el cambio de filter (), la función map (), ahora devuelve un iterador (..) en Python 2.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | mapa (una_función, |
lista ((mapa ((una_función, |
| ② | Mapa ((Ninguno, |
lista (( |
| ③ | Mapa ((lambda x: x+1,rango ((42)) | [x+1 para x en el rango ((42) ] |
| ④ | para i en el mapa ((a_función, a_secuencia): | No hay cambio |
| ⑤ | [i para una función, una secuencia] | No hay cambio |
1, similar al tratamiento del filtro (), en el caso más simple, 2to3 utiliza una función list (), para envasar la llamada map (). 2、 para la sintaxis de un mapa especial ((None,...) similar a un filtro ((None,...) 2to3 lo convierte en una llamada equivalente a una lista de usos ((( 3, si el primer parámetro de map ((() es una función lambda, 2to3 lo convierte en un parámetro de lista equivalente. 4, no hay necesidad de hacer cambios para los lazos for que recorren toda la secuencia. 5, una vez más, no es necesario hacer modificaciones aquí, ya que la lista se analiza a través de toda la secuencia, aunque el valor de retorno de map ((() sea un iterador y no una lista, funcionará correctamente.
En Python 3, la función reduce (,) ha sido eliminada del espacio de nombres global y ahora se encuentra en el módulo fucntools.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | reducción (a, b, c) | de las herramientas funcionales de importación reducen reducen (a, b, c) |
Python 2 tiene una función global llamada apply (), que usa una función f y una lista [a, b, c] como parámetros, y devuelve el valor f (a, b, c). También puedes hacer lo mismo al llamar directamente a la función y añadir un asterisco (a) antes de la lista.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Aplicar (una función, una lista de argumentos) | a_función(*una_lista_de_argumentos) |
| ② | Aplicar ((una_función, una_lista_de_argumentos, un_dicionario_de_argumentos_nombrados) | a_function ((*una_lista_de_args,**un_dicionario_de_args_nombrados) |
| ③ | Aplicar ((a_función, a_lista_de_argumentos+ z) | a_función(*a_lista_de_args+z) |
| ④ | Aplicar ((aModule.a_function, a_list_of_args) | aModule.a_function ((*una_lista_de_argumentos) |
1, en su forma más simple, puede llamarse a la función añadiendo un asterisco antes de la lista de parámetros (como [a, b, c]) ; esto es equivalente a la función apply (() en Python 2. 2, en Python 2, la función apply puede tener en realidad 3 parámetros: una función, una lista de parámetros, un diccionario de argumentos nombrados. En Python 3, puedes añadir un asterisco antes de la lista de parámetros.), añadiendo dos asteriscos antes del parámetro de nombre del diccionario para lograr el mismo efecto. 3, el operador + se usa aquí como función de la lista de conexiones y tiene mayor prioridad que el operador, por lo que no es necesario añadir paréntesis adicionales alrededor de a_list_of_args + z. Los scripts 4, 2 to 3 son lo suficientemente inteligentes como para convertir llamadas complejas de apply (), incluyendo llamadas a funciones de importación en módulos.
En Python 2, puedes limitar la función interna en una cadena con la función interna para optimizar el rendimiento. En Python 3, la función interna se traslada al módulo sys.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | En el caso de la intermediación, | Sys.intern ((aString) es el nombre de un sistema operativo. |
Al igual que las instrucciones de impresión se convierten en una función en Python 3, las instrucciones de ejec se convierten en una función. La función e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g. e.g.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | código ejecString | - ¿ Qué pasa? |
| ② | Código ejecutivoString en el espacio de nombres global | exec ((codeString, espacio de nombres global) |
| ③ | código ejecString en un espacio de nombres global, un espacio de nombres local | exec ((codeString, espacio de nombres global, espacio de nombres local) |
1, en su forma más simple, porque exec ((() es ahora una función, no una frase, 2to3 rodará este código en forma de cadena con paréntesis. La instrucción exec en Python 2 puede especificar un espacio de nombres, y el código se ejecutará en este espacio privado compuesto por objetos globales. Python 3 también tiene esta función; solo tienes que pasar este espacio de nombres como el segundo parámetro a la función exec (). 3, lo que es más sorprendente, es que la instrucción exec en Python 2 también puede especificar un espacio de nombres local (por ejemplo, una variable declarada en una función).
Al igual que con las instrucciones anteriores de ejec, las instrucciones de ejecfile en Python 2 también pueden usar cuerdas como si ejecutaran código de Python. Diferentemente de ejec, ejec utiliza cuerdas y ejecfile utiliza archivos. En Python 3, la instrucción de ejecfile ya ha sido eliminada. Si realmente quieres ejecutar el código de Python de un archivo (pero no quieres importarlo), puedes hacerlo abriendo el archivo, leyendo su contenido y luego llamando a la función compile (compile) global (Python interpreter forces a compilar el código y luego llama a la nueva función exec).
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | execfile (( |
exec ((compilar ((abrir (( |
En Python 2, para obtener la representación de una cadena de un objeto arbitrario, hay una forma de envolver el objeto en una contracitación (por ejemplo,xEn Python 3, esta capacidad sigue existiendo, pero ya no se puede usar el anti-citado para obtener esta señal.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | ¿ Qué pasa? | Representación |
| ② | ` |
¿Por qué no lo haces? |
1, recuerda que x puede ser cualquier cosa, una clase, una función, un módulo, un tipo de datos básico, etc. ==repr== La función puede usar cualquier tipo de parámetros == 2, en Python 2, las contracitas pueden enmarcarse, lo que da lugar a esta expresión desconcertante (pero efectiva). 2to3 es lo suficientemente inteligente como para convertir esta llamada de enmarcado en la función repr.
La sintaxis de captura de anomalías puede cambiar un poco de Python 2 a Python 3.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Intentar: importar mymodule excepto ImportError, e pasar |
Intentar: importar mymodule excepto ImportError como e: pasar |
| ② | Intentar: importar mymodule excepto (RuntimeError, ImportError), e pasar |
Intentar: importar mymodule excepto (RuntimeError, ImportError) como e: pasar |
| ③ | Intentar: importar mymodule excepto ImportarError: pasar |
No hay cambio |
| ④ | Intentar: importar mymodule excepto: pasar |
No hay cambio |
1, en comparación con Python 2 que añade coma después de un tipo excepcional, Python 3 utiliza una nueva palabra clave, as. 2, la palabra clave as también se puede usar para capturar varios tipos de anomalías a la vez. Si usted captura una excepción, pero no quiere acceder a la excepción en sí, la sintaxis de Python 2 y Python 3 es la misma. Similarmente, si usas un método de seguridad (fallback) para capturar todas las excepciones, la sintaxis de Python 2 y Python 3 es la misma. 5, Cuando se importa un módulo (o en la mayoría de los casos), no se debe utilizar este método (véase el fallback anterior); de lo contrario, el programa puede capturar una excepción como KeyboardInterrupt (si el usuario presiona Ctrl-C para interrumpir el programa), lo que dificulta el descifrado.
En Python 3, hay cambios sutiles en la sintaxis para lanzar las anomalías personalizadas.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Levanta mi excepción | No modificado |
| ② | Aumentar MiExcepción, mensaje de error | elevar MyException (Mensaje de error) |
| ③ | elevar MyException, |
elevar MyException (Mensaje de error).con_traceback (Un_traceback) |
| ④ | elevar |
sin soporte |
1, la sintaxis no cambia en su forma más simple, cuando se lanza una excepción que no trae información errónea personalizada por el usuario. 2, cuando se quiere lanzar una excepción con un error de usuario personalizado, el cambio es obvio. Python 2 utiliza un punto para separar las excepciones y el error; Python 3 transmite el error como un parámetro a las excepciones. 3. Python 2 admite una sintaxis más compleja para lanzar una excepción con una retroceso personalizado del usuario (stack trace). En Python 2, puedes lanzar una excepción sin clase de excepción, con solo un mensaje de excepción. En Python 3, esta forma ya no es compatible. 2to3 te advertirá que no puede reparar esta sintaxis automáticamente.
En Python 2, el generador tiene un método de lanzamiento. Llamar a_generator.throw () lanza una anomalía cuando el generador está suspendido y devuelve el siguiente valor obtenido por la función generadora. En Python 3, esta función sigue disponible, pero con una ligera diferencia en la sintaxis.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | a_generator.throw ((Mi excepción) | No hay cambio |
| ② | a_generator.throw ((MyException, |
a_generator.throw(MyException( |
| ③ | a_generator.throw (( |
sin soporte |
En su forma más simple, el generador lanza una excepción que no contiene un mensaje de error personalizado por el usuario. En este caso, no hay cambios en la sintaxis de Python 2 a Python 3. Si el generador arroja una excepción con un error personalizado por el usuario, se necesita pasar la cadena de error a la clase de excepciones para instanciarla. Python 2 también es compatible con el lanzamiento de excepciones con solo mensajes de excepciones. Python 3 no es compatible con esta sintaxis, y 2to3 muestra un mensaje de advertencia que le dice que necesita reparar el código manualmente.
En Python 2, hay dos maneras de obtener números en un determinado rango: rango (), que devuelve una lista, y rango (), que devuelve un iterador. En Python 3, rango (), que devuelve un iterador, xrange (), que ya no existe.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | xrange ((10) | el rango de las |
| ② | a_list = rango ((10) | a_list = lista (rango) |
| ③ | [i para el rango interno (i) 10) ] | [i para el rango interno (i) 10) ] |
| ④ | para i en el rango ((10)): | No hay cambio |
| ⑤ | cantidad (rango) | No hay cambio |
1, en el caso más simple, 2to3 simplemente convierte xrange (()) a range (()). 2, si su código Python 2 usa el rango ((), 2to3 no sabe si necesita una lista o si un iterador también funciona. Por precaución, 2to3 puede reportar errores y luego usar list (() para forzar la conversión del valor de retorno del rango (() al tipo de lista. 3, Si la función xrange () está presente en el análisis de listas, no es necesario convertir su valor de retorno a una lista, ya que el análisis de listas es igualmente efectivo para los iteradores. 4, de manera similar, el ciclo for también funciona en el iterador, por lo que no cambia nada aquí tampoco. 5, la función sum puede funcionar en el iterador, por lo que 2to3 tampoco se modifica aquí. Al igual que el método de la clase de diccionario que devuelve el valor como vista en lugar de lista, esto también se aplica a min (), max (), sum (), list (), tuple (), set (), sorted (), any (), all (), etc.
Python 2 tiene dos funciones globales que se utilizan en la línea de comandos para solicitar la entrada del usuario. La primera se llama input, que espera que el usuario ingrese una expresión de Python y luego devuelve el resultado. La segunda se llama raw_input, que devuelve lo que el usuario ingresa. Esto es muy confuso para los principiantes y se considera ampliamente como un chicle de la lengua Python.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | En el caso de los datos de datos, | entrada (() |
| ② | ¿Por qué no lo haces? | Entrada (¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡ |
| ③ | entrada (() | Valoración de los datos |
1, en su forma más simple, raw_input (()) se sustituye por input (()). 2, en Python 2, la función raw_input (() puede especificar un puntero como parámetro. En Python 3 se conserva esta función. Si realmente quieres pedirle al usuario que introduzca una expresión de Python, puedes calcular el resultado llamando a la función input() y luego pasar el valor de retorno a eval().
En Python 2, el código dentro de una función tiene acceso a las propiedades especiales de la función misma. En Python 3, estas propiedades especiales se renombraron para ser consistentes.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | a_function.func_name El nombre de la función | - ¿Qué quieres decir?nombre_ |
| ② | a_función.func_doc | - ¿Qué quieres decir?- ¿ Qué pasa? |
| ③ | a_function.func_defaults (en inglés) | - ¿Qué quieres decir?Definiciones |
| ④ | a_function.func_dict | - ¿Qué quieres decir?- ¿ Qué dices? |
| ⑤ | a_función.func_closure | - ¿Qué quieres decir?Cierre |
| ⑥ | A_función.func_globals | - ¿Qué quieres decir?- ¿Qué quieres decir? |
| ⑦ | a_function.func_code y el código de la función | - ¿Qué quieres decir?- ¿ Qué pasa? |
1, el atributo __name__ ((original func_name) contiene el nombre de la función. 2, __doc__ propiedad ((originalfuncdoc) contiene una cadena de documentos (docstring) que usted define en el código fuente de la función 3,__defaults__ propiedad ((originalfunc_defaults) es un conjunto de elementos que guardan el valor predeterminado de los parámetros. 4,__dict__ propiedad (original func_dict) es un espacio de nombres que admite la propiedad de una función arbitraria. La propiedad __closure__ (original func_closure) es un conjunto de objetos de cel que contiene la vinculación de una función a una variable libre. 6. La propiedad __globals__ (original func_globals) es una referencia al espacio de nombres global del módulo, donde la función misma está definida. 7, __code__ propiedad (original func_code) es un objeto de código que representa un cuerpo de funciones después de su compilación.
En Python 2, los objetos de archivo tienen un método xreadlines (), que devuelve un iterador, una línea de lectura de un archivo a la vez. Esto es especialmente útil en el ciclo for. De hecho, las versiones posteriores de Python 2 agregaron esta función a los objetos de archivo mismos.
En Python 3, el método xreadlines (() ya no está disponible. 2 a 3 puede resolver situaciones simples, pero algunos casos de borde requieren intervención manual.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | para la línea en a_file.xreadlines(): | para la línea en a_file: |
| ② | para la línea en a_file.xreadlines(5): | No hay cambio (rotado) |
1, si antes llamabas xreadlines sin parámetros, 2to3 lo convertiría en el objeto del archivo en sí mismo. En Python 3, este código después de la conversión puede hacer el mismo trabajo que antes: leer una línea del archivo una vez y luego ejecutar el ciclo de la bucle for.
2, si antes usaste un parámetro (cuantas líneas leer) para llamar a xreadlines (), 2to3 no puede completar la conversión de Python 2 a Python 3 para ti, tu código fallará de esta manera: AttributeError:
En Python 2, puedes definir una función lambda anónima para que la función pueda recibir varios parámetros, especificando el número de elementos de un conjunto de elementos como parámetros. De hecho, el intérprete de Python 2 desempaca este conjunto de elementos en argumentos nombrados, y luego puedes referirlos en la función lambda. En Python 3, aún puedes pasar un conjunto de elementos como parámetros de la función lambda, pero el intérprete de Python no lo analiza como parámetros de nombres.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | El valor de las emisiones de CO2 de las emisiones de gases de efecto invernadero se calculará en función de las emisiones de CO2 de las emisiones de gases de efecto invernadero. | El valor de las emisiones de CO2 de las emisiones de gases de efecto invernadero se calculará en función de las emisiones de CO2 de las emisiones de gases de efecto invernadero. |
| ② | El valor de las emisiones de dióxido de carbono se calculará en función de las emisiones de dióxido de carbono. | lambda x_y: x_y[0]+f(x_y[1]) |
| ③ | El valor de las emisiones de CO2 de las emisiones de gases de efecto invernadero se calculará en función de las emisiones de CO2 de las emisiones de gases de efecto invernadero. | 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 | No modificado |
1, si ya se ha definido una función lambda, que utiliza como parámetros un conjunto de elementos que contiene un elemento, en Python 3 se convierte en una función lambda que contiene referencias a x1[0]; x1 es un script de 2 a 3 generado automáticamente basado en los parámetros de nombre del conjunto original. La función lambda, que utiliza como parámetro el conjunto de dos elementos (x, y), se convierte en x_y, que tiene dos parámetros de posición, x_y[0] y x_y[1]; Los scripts 3, 2to3 incluso pueden manejar la función lambda que usa los parámetros de nombres de enlace como parámetros. El código resultante es un poco difícil de leer, pero tiene el mismo efecto en Python 3 que el código original en Python 2. 4, puedes definir una función lambda que use varios parámetros. Si no hay paréntesis alrededor de la función, Python 2 la trata como una función lambda que contiene varios parámetros; en este cuerpo de la función lambda, se citan estos parámetros por su nombre, como se hace en otras funciones de tipo. Esta sintaxis sigue siendo válida en Python 3.
En Python 2, los métodos de clase pueden acceder a los objetos de clase que definen su clase, así como a los propios objetos de método. Im_self es el objeto de ejemplo de la clase; im_func es el objeto de función, im_class es la clase misma. En Python 3, estas propiedades se renombran para seguir las convenciones de nombres de otras propiedades.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | aClassInstance.aClassMethod.im_func Las instrucciones de la clase | Una instancia de clase. un método de clase._Función |
| ② | aClassInstance.aClassMethod.im_self (Método de la clase en sí mismo) | Una instancia de clase. un método de clase._Yo mismo. |
| ③ | aClassInstance.aClassMethod.im_class El método de la clase es el siguiente: | Una instancia de clase. un método de clase._Yo mismo.._¿Qué clase? |
En Python 2, puedes crear clases propias y hacerlas usables en un contexto booleano. Por ejemplo, puedes instanciar la clase y usar el objeto de la instancia en una oración si.No es cero() método, que devuelve el valor de True o False, el método se llama cuando el objeto de la instancia está en el contexto de Boole. En Python 3, todavía se puede realizar la misma función, pero el nombre de este método especial se convierte en¿Qué quieres decir?()。
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | clase A: No es cero(sólo): pase |
clase A: ¿Qué quieres decir?(sólo): pase |
| ② | clase A: No es cero(sólo, x, y): pasar |
No hay cambio |
1, cuando Python 3 usa un objeto de clase en el contexto de Bur, Python 3 llama_¿Qué quieres decir?(), y no _No es cero¿Qué es esto? 2 sin embargo, si usted tiene una definición que usa dos parámetrosNo es cero() método, el script 2to3 asume que el método que definiste tiene otro uso y por lo tanto no modifica el código.
Entre Python 2 y Python 3, la sintaxis de la definición de octal cambia ligeramente.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | x = 0755 | x = 0o755 |
La constante sys.maxint ya no es precisa debido a la integración de los tipos longitudinales y integrales. Pero debido a que este valor es útil para la capacidad de detectar plataformas específicas, fue retenido por Python 3 y renombrado como sys.maxsize.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | desde sys importmaxint | desde sys importmaxsize |
| ② | a_función (sys.maxint) | a_function (sys.maxsize) |
1, maxint se convierte en maxsize. 2, todos los sys.maxint se han convertido en sys.maxsize.
En Python 2, puedes usar la función global callable para comprobar si un objeto es callable. En Python 3, esta función global está cancelada.Llama.La existencia de ().
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Se puede llamar a cualquier cosa. | No tiene nada, |
En Python 2, la función global zip ((() puede usar varias secuencias como parámetros, y devuelve una lista compuesta por componentes. El primer componente contiene el primer elemento de cada secuencia; el segundo componente contiene el segundo elemento de cada secuencia; y así sucesivamente. En Python 3, zip ((() devuelve un iterador, no una lista.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | zip ((a, b, c) | lista ((zip ((a, b, c)) |
| ② | d.join ((zip ((a, b, c)) | No hay cambio |
En su forma más simple, puede restablecer la función anterior de la función zip mediante la llamada del valor de retorno de la función list ((() para empaquetar zip (((), y la función list ((() recorre el iterador que devuelve esta función zip ((() y luego devuelve la lista de resultados. En un entorno contextual en el que ya se recorren todos los elementos de la secuencia (por ejemplo, la llamada del método join aquí), el iterador que devuelve zip puede funcionar correctamente. Los scripts 2to3 detectan estas situaciones y no hacen cambios en su código.
En Python 2, el StandardError es el subclase de todas las otras anomalías intrínsecas, excepto StopIteration, GeneratorExit, KeyboardInterrupt, SystemExit. En Python 3, el StandardError ha sido eliminado; se sustituye por Exception.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | x = Error estándar (() | x = Excepción |
| ② | x =Error estándar ((a, b, c) | x = Excepción (a, b, c) |
En Python 2, contiene constantes que representan todos los tipos de datos básicos, como dict e int. En Python 3, estas constantes ya se han eliminado. Solo se necesita reemplazarlas con el nombre del tipo básico.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| types.UnicodeType | el | |
| types.StringType | bytes | |
| types.DictType | dict | |
| types.IntType | Int | |
| types.LongType | Int | |
| types.ListType | lista | |
| types.NoneType | Tipo (Ninguno) | |
| types.BooleanType | Bool también | |
| types.BufferType | Vista de memoria | |
| types.ClassType | Tipo de producto | |
| types.ComplexType | complejo | |
| types.EllipsisType | tipo ((Elíptica) | |
| types.FloatType | flotación | |
| types.ObjectType | objetos | |
| types.NotImplementedType | Tipo (No ejecutado) | |
| types.SliceType | rebanada | |
| types.TupleType | la misma | |
| types.TypeType | Tipo de producto | |
| types.XRangeType | el rango |
Types.StringType está mapeado en bytes, no en str, porque el parámetro de la cadena en Python 2 es en realidad una secuencia de bytes.
La función isinstance (() verifica si un objeto es una instancia de una clase específica o de un tipo específico. En Python 2, puedes pasar un elemento formado por tipos a una instancia, y si el objeto es de cualquier tipo del conjunto, la función devuelve True. En Python 3, puedes hacerlo, pero no es recomendable usar un tipo como parámetro para pasar dos veces.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| es la instancia ((x, ((int,float,int)) | es la instancia ((x, ((int, float)) |
Python 2 tiene dos tipos de strings: una en Unicode y otra en no Unicode. Pero hay otro tipo, basestring. Es un tipo de datos abstracto, una superclase de tipos str y unicode. No se puede llamar directamente o instanciar, pero puedes usarlo como un parámetro de instance para detectar si un objeto es una cadena Unicode o una cadena no Unicode.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| esinstance ((x, cadena de base) | esinstancia ((x, str) |
Python 2.3 introdujo el módulo de itertools, que define las variantes (variantes) de las funciones globales zip, map y filter, cuyo tipo de retorno es un iterador, no una lista. En Python 3, estas variantes en estos itertools se cancelaron debido a que el tipo de retorno de estas funciones globales es un iterador, por lo que todavía hay muchas otras funciones útiles en el módulo de itertools, no solo las mencionadas anteriormente.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | Las herramientas iter.izip (a, b) | zip ((a, b) |
| ② | Itertools.imap (a) y (b) | mapa (a, b) |
| ③ | las herramientas iter.ifilter ((a, b) | filtro (a, b) |
| ④ | desde itertools importar imap, izip, foo | desde itertools importar foo |
1, utiliza la función zip ((() de todo el mundo, en lugar de itertools.izip ((()). 2、 Utiliza el mapa en lugar de itertools.imap. 3,itertools.ifilter ((() se convierte en filtro ((() ▽ El módulo de itertools sigue existiendo en Python 3, pero ya no contiene funciones que ya se han trasladado al espacio de nombres global. Los guiones 2to3 pueden ser lo suficientemente inteligentes como para eliminar las declaraciones de importación que ya no son útiles, manteniendo la integridad de otras declaraciones de importación.
Cuando se trata de excepciones, hay tres variables a las que se puede acceder en el módulo sys: sys.exc_type, sys.exc_value, sys.exc_traceback. En realidad, estas ya existían en la era de Python 1.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| Sys.exc_type: el tipo de la aplicación | Sys.exc_info (()) [0] | |
| Sys.exc_value es el valor de la función de | sys.exc_info (()) [1] | |
| Sys.exc_traceback (en inglés) | sys.exc_info() [2] |
En Python 2, si necesitas escribir una lista de parámetros que atraviese un grupo de elementos, no necesitas poner paréntesis alrededor de los valores de los elementos. En Python 3, estos paréntesis son necesarios.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| [i para los 1,2] | [i para iin(1,2)] |
Python 2 tiene una función llamada os.getcwd (), que devuelve el directorio de trabajo actual como una letra (no codificada en Unicode). Dado que los sistemas de archivos modernos pueden manejar nombres de directorio que pueden ser codificados por varios caracteres, Python 2.3 introduce la función os.getcwdu (), que devuelve la letra codificada en Unicode en el directorio de trabajo actual.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ¿Qué quieres decir? | ¿Qué quieres decir con eso? |
En Python 2, se puede crear una metaclase mediante la definición de los parámetros de metaclase en la declaración de la clase, o bien mediante la definición de una propiedad especial de clase a nivel de clase. En Python 3, la propiedad de _metaclass__ ha sido eliminada.
| Las notas | Python 2 | Python 3 también |
|---|---|---|
| ① | clase C ((metaclase=PapayaMeta): aprobar |
No modificado |
| ② | La clase Whip: _- ¿ Qué pasa?= PapayaMeta |
clase Whip ((metaclass=PapayaMeta): pase |
| ③ | clase C ((Bateador, Bateador):- ¿ Qué pasa?= PapayaMeta | clase C ((Whipper,Beater,metaclass=PapayaMeta): aprueba |
1, cuando se declara una clase, se declara el parámetro de la metaclase, lo cual es válido en Python 2 y Python 3, que son los mismos. 2, en la definición de la clase se declara que el atributo __metaclass__ es válido en Python 2, pero ya no lo es en Python 3. 3, 2to3 puede construir una declaración de clase válida, incluso si la clase hereda de varias clases padres.
Las siguientes correcciones no son verdaderas correcciones; es decir, son sólo cosas sobre el estilo del código y no se relacionan con la esencia del código. Pero los desarrolladores de Python tienen un interés muy grande en hacer que el estilo del código sea lo más uniforme posible. Para ello, hay un manual oficial dedicado a describir el estilo del código de Python.
En Python 2 la única manera de definir un conjunto de valores literal es llamando set a_sequence. En Python 3 esto sigue siendo válido, pero el uso de una nueva notación literal: paréntesis mayúsculas es una forma más clara. Este método es válido además de los conjuntos en blanco, ya que el diccionario también utiliza paréntesis mayúsculas, por lo que {} indica un diccionario en blanco, no un conjunto en blanco.
Los scripts de 2to3 no repararán por defecto el valor de set (()) literal. Para activar esta función, especifique el parámetro -f set_literal cuando llame a 2to3 en la línea de comandos.
| Las notas | Antes de | Después |
|---|---|---|
| conjunto (([1,2,3]) | {1,2,3} | |
| conjunto (((1,2,3)) | {1,2,3} | |
| conjunto (([i para iin a_sequencia]) | {i para dentro de una_ secuencia} |
Los objetos de Python implementados en C pueden exportar una interfaz de búfer que permite a otro código de Python leer y escribir directamente en un bloque de memoria. Esto suena muy poderoso, pero también es terrible. En Python 3, el buffer fue renombrado como memoryview. Las modificaciones reales son más complejas, pero casi se pueden ignorar estas diferencias.
Los scripts de 2to3 no repararán la función buffer (() por defecto. Para activar esta función, especifique el parámetro -f buffer cuando llame a 2to3 en la línea de comandos.
| Las notas | Antes de | Después |
|---|---|---|
| x = amortiguador y | x = vista de memoria (y) |
A pesar de que Python es muy estricto con respecto a los espacios para recortar y resaltar (indenting y outdenting), Python es libre de usar espacios en otros aspectos. En listas, módulos, conjuntos y diccionarios, los espacios pueden aparecer delante o detrás de los comas, lo que no tiene ningún efecto negativo. Sin embargo, el manual de estilo de código de Python indica que no se puede tener un espacio antes de los comas y que debe haber un espacio después de los comas.
Por defecto, el script 2to3 no repara los espacios alrededor de las comillas. Para activar esta función, especifique el parámetro -f wscomma cuando se llama 2to3 en la línea de comandos.
| Las notas | Antes de | Después |
|---|---|---|
| a, b | a, b y c | |
| - ¿Por qué no? | - ¿Qué quieres decir? |
Muchas prácticas se han establecido en la comunidad de Python. Algunas son como while 1: loop, que se remonta a Python 1. (Python no tuvo tipos de bulls en sentido real hasta Python 2.3, por lo que los desarrolladores antes usaban 1 y 0 alternativos.)
Los scripts de 2to3 no hacen reparaciones por defecto para estas convenciones. Para activar esta función, especifique el parámetro -f idioms cuando llame a 2to3 en la línea de comandos.
| Las notas | Antes de | Después |
|---|---|---|
| mientras que 1: do_stuff() |
mientras que True: do_stuff() |
|
| tipo ((x) == T | Es el caso ((x, T) | |
| el tipo ((x) es T | Es el caso ((x, T) | |
| a_lista = lista ((a_secuencia) | a_list = ordenado (a_secuencia) | |
| a_list.sort (() | ¿Qué es esto? | |
| ¿Qué es esto? |
Traducido porEl blog de CSDN
En este artículo, se explica cómo convertir el código de Python 2.x en código de Python 3.x. Cómo convertir el código de Python 2.x en Python 3.x
Esto no tiene que decir mucho si sólo se trata de unas pocas funciones, como print, etc.
Si no lo haces, entonces puedes cambiar tu propio código.
La versión 2.x de Python, como Python 2.7.2, que he instalado, viene con algunas herramientas útiles después de que Windows la descargue y la instale.
其中一个叫做2to3.pyEn el caso de Python 2.x, el código de Python 2.x se convierte en código de Python 3.x.
Está ubicado en: Directorio raíz de instalaciones de Python\Python27\Tools\Scripts\2to3.py
【如何利用2to3.pyImplementar el código de Python 2.x para convertirlo en el código de Python 3.x Por ejemplo, tengo un guión de Python 2.x:
D:\tmp\tmp_dev_root\python\python2_to_python3\34563264_datos_desde_site.py
Ahora, quiero convertirlo en código de Python 3.x.
Se puede abrir el cmd de windows, ubicarlo debajo del script que se quiere convertir y ejecutarlo.
D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_datos_desde_site.py
El resultado de una conversión exitosa es:
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
En este punto, se puede ver el original 34563664_data_from_site.py, que se ha convertido en la versión 3.x de Python.
¿ Qué haces?¿Qué es Python 2 para botvs?
Los inventores cuantifican - sueños pequeñosEl servidor de repetición de BotVS utiliza la versión 2.7 de Python, que es compatible con las plataformas BotVS Python 2 y Python 3.