La diferencia entre python2.7.3 y 3.3.2
Aquí solo se explica el aspecto orientado a objetos. Para obtener más detalles, consulte el enlace de arriba.
Orientado a objetos
(1) Clases clásicas y clases nuevas
Lo más sorprendente de Python OO es que hay dos tipos, clásico y nuevo.
Las principales diferencias entre las clases nuevas y las clases clásicas son las siguientes:
1. Los objetos de clase nueva pueden obtener directamente sus propios tipos a través del atributo __class__: tipo.
2. Se ha cambiado el orden de búsqueda de herencia. El orden de búsqueda de clases clásicas con múltiples atributos de herencia: primero profundice en el lado izquierdo del árbol de herencia y luego regrese y comience a buscar el lado derecho de la nueva clase con múltiples atributos de herencia: primero busque horizontalmente, y luego subir.
3. La nueva clase agrega el atributo incorporado __slots__, que puede bloquear el tipo de atributos de instancia dentro del rango especificado por __slots_.
4. La nueva clase agrega el método __getattribute__.
Python 2.x utiliza por defecto clases clásicas, y sólo aquellas que heredan explícitamente el objeto son clases nuevas.
Python 3.x tiene por defecto una nueva clase, por lo que no es necesario heredar explícitamente el objeto.
python 2.x:
& gt& gt& gtclase clásica. __class__
Rastreo (última llamada):
Archivo "<stdin>, línea 1, en <module>
AttributeError: clase ClassicClass Sin atributo "__class__"
& gt& gt& gt clase NuevaClase(objeto):
...aprobado
...
& gt& gt& gtNuevaClase__
python 3.x:
& gt& gt& gtCategoryNewClass:Pass
...
& gt& gt& gtNueva clase __class__
& ltClass "type"& gt
(2) Método independiente
En Python 2. En x, todos los métodos, excepto los métodos de clase y los métodos estáticos, deben vincularse a una instancia pasando self en el primer parámetro. Sin embargo, en Python 3. Vincularse a la instancia.
Este método no es diferente de una función normal:
Python 2.x:
& gt& gt& gtClass MyClass:
...def function():
...Imprimir "función"
...
& gt& gt& gtMyClass.function()
Rastreo (más reciente call):
Archivo "<stdin>, línea 1, en <module>
TypeError: MyClass debe pasarse al llamar a la instancia de función() del método independiente como primer argumento (pero no se obtuvo cualquier argumento)
& gt& gt& gtm = MyClass()
& gt& gt& gtm .function()
Rastreo (llamada más reciente):
Archivo "<stdin>, línea 1, en <module>
TypeError: function() no toma argumentos (dado 1)
Python 3.x:
& gt& gt& gt categoría MiClase:
...def función():
...print("función")
...
& gt& gt& gtMyClass.function()
Función
& gt& gt& gtm = MiClase()
& gt& gt& gtm . Función()
Rastreo (última llamada):
Archivo" & ltstandard input>, línea 1, en <module>
TypeError: la función () no toma argumentos (1 dado)
(3) Sobrecarga importante
1.next() y __next__(): Esta debería ser la segunda mayor incompatibilidad después de que los programas Python impresos estén llenos de iteradores. pero los nombres de los métodos de la interfaz de implementación de los iteradores son diferentes entre 2 y 3. Está bien, no digas nada.
2. Intercepción de fragmentos: antes de Python 3.x, las clases podían definir los métodos __getslice__ y __setslice__. intercepta específicamente fragmentos, y estos dos métodos tienen prioridad. __getitem__ y __setitem__, pero estos métodos ya no existen en Python 3. La definición predeterminada es Boolean False. También podemos agregar criterios de juicio booleanos personalizados en nuestras propias clases definidas. En 2.x, este método se llama __distinto de cero__, ¡lo cual obviamente es muy intuitivo y poco científico! ¿Deberíamos negar el talento a todos los niños que no aprueban los exámenes? ¡Obviamente no! Por lo tanto, este método pasó a llamarse __bool__ en Python 3.x.
4.3.x canceló el método __cmp__ para comparar tamaños y lo reemplazó con __lt__, __gt__, __le__, __ge__, __eq__, __ne__. Bueno, siento que esta idea es realmente diferente…. .
(4) Modificadores de categoría
En mi último blog, mostré el uso de decoradores de funciones en la validación de formularios. /chihz/blog/122897.
En la era 3.x, las clases también tenían decoradores. Este decorador es muy poderoso y puede hacer que la clase decorada sea irreconocible. En resumen, puedes hacer lo que quieras.
El uso es básicamente el mismo que el decorador de funciones, excepto que los parámetros pasados son tipos:
& gt& gt& gtdefine apagado (cls):
...def apagado_func(self) :
...print("Hacer algo...")
...cls.shutdown = Shutdown_func
...return cls
...
& gt& gt& gt@Shutdown
...Prueba de categoría: Aprobado
...
& gt& gt& gtt = test()
& gt& gt& gtCloseTime()
Haz algo...
Anormal
Primero veamos un fragmento de código.
python 2.x:
& gt& gt& gt personal de clase:
...def __init__(self, msg):
...self.msg = msg
...
& gt& gt& gtIntenta:
...Nurture, "woca"
p>...excepto como p:
...print p.msg
...
woca
python 3.x:
& gt& gt& gt personal de clase:
... def __init__(self, msg):
... self. msg = msg
...
& gt& gt& gttry:
...promocionar persona("woca")
. ..excepto como p:
...Imprimir (primera página)
Rastreo (última llamada):
Archivo" <StandardInput>, línea 2, en <module>
TypeError: la excepción debe derivarse de BaseException
Mientras se manejaba la excepción anterior, se produjo otra excepción:
Rastreo (última llamada):
Archivo "<stdin>, línea 3, en <module>
TypeError: No Permite capturar clases que no heredan de BaseException
& gt& gt& gt
A continuación, hablemos de las diferencias:
En la era 1.2.x, todo tipo de objetos Puedes tirarlo directamente. En la era 3.x, solo se podían lanzar objetos heredados de BaseException.
La declaración de aumento 2.2.x usa comas para separar el tipo de objeto lanzado y los parámetros. 3.x cancela este maravilloso método de escritura y llama directamente al constructor para lanzar el objeto.
En la era 2.x, además de indicar errores de programa, las excepciones a menudo hacían lo que deberían hacer las estructuras de control ordinarias. Como puede ver en 3.x, los diseñadores han hecho que las excepciones sean más específicas. Solo cuando ocurre un error, se puede manejar con declaraciones de captura de excepciones.