Código de error de Python: 10 errores más comunes que cometen los desarrolladores

Sobre Python

Python es un lenguaje de programación interpretado, orientado a objetos y de alto nivel con semántica dinámica. Las estructuras de datos integradas de alto nivel combinadas con la tipificación dinámica y el enlace dinámico lo hacen muy atractivo para BRPS (desarrollo rápido de herramientas de aplicación), así como para usarlo como un lenguaje de scripting y conexión para conectar componentes o servicios existentes. Python admite módulos y paquetes, fomentando así la modularidad del programa y la reutilización de código.

Sobre este articulo

La simplicidad y la facilidad de aprender este lenguaje pueden ser confusas para los desarrolladores (especialmente aquellos que recién comienzan a aprender Python), por lo que puede perder de vista algunas sutilezas importantes y subestimar el poder de la variedad de soluciones posibles que usan Python.

Con esto en mente, este artículo presenta los "10 principales" errores sutiles y difíciles de encontrar que incluso los desarrolladores avanzados de Python pueden cometer.

Error # 1: mal uso de expresiones como valores predeterminados para argumentos de función

Python le permite indicar que una función puede tener argumentos opcionales estableciendo un valor predeterminado para ellos. Esto, por supuesto, es una característica muy conveniente del lenguaje, pero puede tener consecuencias desagradables si el tipo de este valor es mutable. Por ejemplo, considere la siguiente definición de función:

>>> def foo(bar=[]): # bar -    #      . ... bar.append("baz") #     ... ... return bar 

Un error común en este caso es pensar que el valor de un argumento opcional se establecerá en el valor predeterminado cada vez que se llame a una función sin un valor para este argumento. En el código anterior, por ejemplo, podemos suponer que al llamar repetidamente a la función foo () (es decir, sin especificar un valor para el argumento de la barra), siempre devolverá "baz", ya que se supone que cada vez que se llama a foo () especificando la barra de argumentos), la barra se establece en [] (es decir, una nueva lista vacía).

Pero veamos qué sucederá realmente:

 >>> foo() ["baz"] >>> foo() ["baz", "baz"] >>> foo() ["baz", "baz", "baz"] 

¿Eh? ¿Por qué la función continúa agregando el valor predeterminado "baz" a la lista existente cada vez que se llama a foo (), en lugar de crear una nueva lista cada vez?

La respuesta a esta pregunta será una comprensión más profunda de lo que está sucediendo con Python "bajo el capó". A saber: el valor predeterminado para la función se inicializa solo una vez, durante la definición de la función. Por lo tanto, el argumento de la barra se inicializa de manera predeterminada (es decir, una lista vacía) solo cuando se define foo () por primera vez, pero las llamadas posteriores a foo () (es decir, sin especificar el argumento de la barra) continuarán utilizando la misma lista que estaba creado para la barra de argumentos en el momento de la primera definición de función.

Como referencia, una "solución" común para este error es la siguiente definición:

 >>> def foo(bar=None): ... if bar is None: # or if not bar: ... bar = [] ... bar.append("baz") ... return bar ... >>> foo() ["baz"] >>> foo() ["baz"] >>> foo() ["baz"] 

Error # 2: mal uso de las variables de clase

Considere el siguiente ejemplo:

 >>> class A(object): ... x = 1 ... >>> class B(A): ... pass ... >>> class C(A): ... pass ... >>> print Ax, Bx, Cx 1 1 1 

Todo parece estar en orden.

 >>> Bx = 2 >>> print Ax, Bx, Cx 1 2 1 

Sí, todo fue como se esperaba.

 >>> Ax = 3 >>> print Ax, Bx, Cx 3 2 3 

¿Qué demonios? Acabamos de cambiar Ax. ¿Por qué también cambió Cx?

En Python, las variables de clase se tratan como diccionarios y siguen lo que a menudo se llama Orden de resolución de método (MRO). Por lo tanto, en el código anterior, dado que el atributo x no se encuentra en la clase C, se encontrará en sus clases base (solo A en el ejemplo anterior, aunque Python admite herencia múltiple). En otras palabras, C no tiene su propia propiedad x independiente de A. Por lo tanto, las referencias a Cx son en realidad referencias a Ax. Esto causará problemas si estos casos no se manejan adecuadamente. Entonces, cuando aprenda Python, preste especial atención a los atributos de la clase y trabaje con ellos.

Error No. 3: parámetros incorrectos para el bloque de excepción

Supongamos que tiene el siguiente código:

 >>> try: ... l = ["a", "b"] ... int(l[2]) ... except ValueError, IndexError: # To catch both exceptions, right? ... pass ... Traceback (most recent call last): File "<stdin>", line 3, in <module> IndexError: list index out of range 

El problema aquí es que la expresión de excepción no acepta la lista de excepciones especificada de esta manera. Más bien, en Python 2.x, la expresión "excepto Excepción, e" se usa para vincular la excepción a un segundo parámetro opcional dado en segundo lugar (en este caso, e) para que esté disponible para una inspección adicional. Como resultado, en el código anterior, la instrucción except no captura una excepción IndexError; más bien, la excepción termina con el enlace a un parámetro llamado IndexError en su lugar.

La forma correcta de capturar varias excepciones con la expresión de excepción es especificar el primer parámetro como una tupla que contiene todas las excepciones que desea capturar. Además, para obtener la máxima compatibilidad, use la palabra clave as, ya que esta sintaxis es compatible con Python 2 y Python 3:

 >>> try: ... l = ["a", "b"] ... int(l[2]) ... except (ValueError, IndexError) as e: ... pass ... >>> 

Error # 4: entender mal las reglas de alcance de Python

El alcance en Python se basa en la llamada regla LEGB, que es una abreviatura de Local (nombres asignados de cualquier manera dentro de una función (def o lambda), y no declarada global en esta función), Encerrando (nombre en el alcance local de cualquier función que incluya estáticamente ( def o lambda), de interno a externo), Global (nombres asignados en el nivel superior del archivo del módulo, o ejecutando las instrucciones globales en def dentro del archivo), Integrado (nombres previamente asignados en el módulo de nombre incorporado: abierto, rango, SyntaxError, ...). Parece bastante simple, ¿verdad? Bueno, en realidad, hay algunas sutilezas sobre cómo funciona esto en Python, lo que nos lleva al problema general de programación de Python más complejo a continuación. Considere el siguiente ejemplo:

 >>> x = 10 >>> def foo(): ... x += 1 ... print x ... >>> foo() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in foo UnboundLocalError: local variable 'x' referenced before assignment 

Cual es el problema

El error anterior se produce porque cuando asigna una variable en el alcance, Python automáticamente lo considera local a ese alcance y oculta cualquier variable con el mismo nombre en cualquier alcance principal.

Por lo tanto, muchos se sorprenden cuando reciben UnboundLocalError en el código que se estaba ejecutando anteriormente, cuando se modifica agregando un operador de asignación en algún lugar del cuerpo de la función.

Esta característica es especialmente confusa para los desarrolladores cuando usan listas. Considere el siguiente ejemplo:

 >>> lst = [1, 2, 3] >>> def foo1(): ... lst.append(5) #   ... ... >>> foo1() >>> lst [1, 2, 3, 5] >>> lst = [1, 2, 3] >>> def foo2(): ... lst += [5] # ...    ! ... >>> foo2() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in foo UnboundLocalError: local variable 'lst' referenced before assignment 

¿Eh? ¿Por qué se bloquea foo2 mientras foo1 funciona bien?

La respuesta es la misma que en el ejemplo anterior, pero, según la creencia popular, la situación aquí es más sutil. foo1 no aplica el operador de asignación a lst, mientras que foo2 no. Teniendo en cuenta que lst + = [5] en realidad es solo una abreviatura de lst = lst + [5], vemos que estamos tratando de asignar el valor lst (por lo que Python supone que está en el ámbito local). Sin embargo, el valor que queremos asignar a lst se basa en lst en sí mismo (de nuevo, ahora se supone que está en el ámbito local), que aún no se ha determinado. Y tenemos un error.

Error # 5: cambiar una lista durante la iteración sobre ella

El problema en el siguiente fragmento de código debería ser bastante obvio:

 >>> odd = lambda x : bool(x % 2) >>> numbers = [n for n in range(10)] >>> for i in range(len(numbers)): ... if odd(numbers[i]): ... del numbers[i] # BAD: Deleting item from a list while iterating over it ... Traceback (most recent call last): File "<stdin>", line 2, in <module> IndexError: list index out of range 

Eliminar un elemento de una lista o matriz durante la iteración es un problema de Python que es bien conocido por cualquier desarrollador de software experimentado. Pero, aunque el ejemplo anterior puede ser bastante obvio, incluso los desarrolladores experimentados pueden embarcarse en este rastrillo en un código mucho más complejo.

Afortunadamente, Python incluye una serie de paradigmas de programación elegantes que, cuando se usan correctamente, pueden conducir a una simplificación y optimización de código significativas. Una consecuencia agradable adicional de esto es que en un código más simple, la probabilidad de caer en el error de eliminar accidentalmente un elemento de la lista durante la iteración es mucho menor. Uno de esos paradigmas son los generadores de listas. Además, comprender el funcionamiento de los generadores de listas es especialmente útil para evitar este problema en particular, como se muestra en esta implementación alternativa del código anterior, que funciona bien:

 >>> odd = lambda x : bool(x % 2) >>> numbers = [n for n in range(10)] >>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all >>> numbers [0, 2, 4, 6, 8] 

Error # 6: malentendido cómo Python une las variables en los cierres

Considere el siguiente ejemplo:

 >>> def create_multipliers(): ... return [lambda x : i * x for i in range(5)] >>> for multiplier in create_multipliers(): ... print multiplier(2) ... 

Puede esperar el siguiente resultado:

 0 2 4 6 8 

Pero en realidad entiendes esto:

 8 8 8 8 8 

Sorpresa!

Esto se debe al enlace tardío en Python, lo que significa que los valores de las variables utilizadas en los cierres se buscan durante la llamada a la función interna. Por lo tanto, en el código anterior, cada vez que se llama a cualquiera de las funciones devueltas, se busca el valor i en el alcance circundante durante su llamada (y para ese momento el ciclo ya se había completado, por lo que ya se me había asignado el resultado final - valor 4) .

La solución a este problema común de Python sería:

 >>> def create_multipliers(): ... return [lambda x, i=i : i * x for i in range(5)] ... >>> for multiplier in create_multipliers(): ... print multiplier(2) ... 0 2 4 6 8 

Voila! Usamos los argumentos predeterminados aquí para generar funciones anónimas para lograr el comportamiento deseado. Algunos llamarían a esta solución elegante. Algunos son
delgado Algunas personas odian estas cosas. Pero si eres un desarrollador de Python, de todos modos, es importante entenderlo.

Error # 7: crear dependencias de módulos cíclicos

Supongamos que tiene dos archivos, a.py y b.py, cada uno de los cuales importa el otro, de la siguiente manera:

En a.py:

 import b def f(): return bx print f() 

En b.py:

 import a x = 1 def g(): print af() 

Primero, intente importar a.py:

 >>> import a 1 

Funcionó bien. Esto puede sorprenderte. Después de todo, los módulos se importan entre sí cíclicamente y esto probablemente debería ser un problema, ¿verdad?

La respuesta es que simplemente tener una importación cíclica de módulos no es en sí un problema en Python. Si el módulo ya se ha importado, Python es lo suficientemente inteligente como para no intentar volver a importarlo. Sin embargo, dependiendo del punto en el que cada módulo intente acceder a las funciones o variables definidas en otro, es posible que tenga problemas.

Entonces, volviendo a nuestro ejemplo, cuando importamos a.py, no tuvo problemas para importar b.py, ya que b.py no requiere que se defina nada de a.py durante su importación. La única referencia en b.py a a es una llamada a af (). Pero esta llamada en g () y nada en a.py o b.py no llama a g (). Entonces todo funciona bien.

Pero, ¿qué sucede si intentamos importar b.py (sin importar primero a.py, es decir):

 >>> import b Traceback (most recent call last): File "<stdin>", line 1, in <module> File "b.py", line 1, in <module> import a File "a.py", line 6, in <module> print f() File "a.py", line 4, in f return bx AttributeError: 'module' object has no attribute 'x' 

Oh oh ¡Esto no es bueno! El problema aquí es que durante el proceso de importación de b.py intenta importar a.py, que a su vez llama a f (), que intenta acceder a bx, pero bx aún no se ha definido. De ahí la excepción AttributeError.

Al menos una solución a este problema es bastante trivial. Simplemente modifique b.py para importar a.py en g ():

 x = 1 def g(): import a # This will be evaluated only when g() is called print af() 

Ahora cuando lo importamos, todo está bien:

 >>> import b >>> bg() 1 # Printed a first time since module 'a' calls 'print f()' at the end 1 # Printed a second time, this one is our call to 'g' 

Error # 8: intersección de nombres con nombres de módulos en la biblioteca estándar de Python

Uno de los encantos de Python son sus muchos módulos que salen de la caja. Pero como resultado, si no sigue esto conscientemente, puede encontrar que el nombre de su módulo puede tener el mismo nombre que el módulo en la biblioteca estándar que viene con Python (por ejemplo, en su código puede haber un módulo con el nombre email.py, que entrará en conflicto con el módulo de biblioteca estándar con el mismo nombre).

Esto puede conducir a problemas serios. Por ejemplo, si alguno de los módulos intenta importar la versión del módulo de la biblioteca estándar de Python, y tiene un módulo en el proyecto con el mismo nombre, que se importará por error en lugar del módulo de la biblioteca estándar.

Por lo tanto, se debe tener cuidado de no usar los mismos nombres que en los módulos de la biblioteca estándar de Python. Es mucho más fácil cambiar el nombre del módulo en su proyecto que enviar una solicitud para cambiar el nombre del módulo en la biblioteca estándar y obtener su aprobación.

Error # 9: no tener en cuenta las diferencias entre Python 2 y Python 3

Considere el siguiente archivo foo.py:

 import sys def bar(i): if i == 1: raise KeyError(1) if i == 2: raise ValueError(2) def bad(): e = None try: bar(int(sys.argv[1])) except KeyError as e: print('key error') except ValueError as e: print('value error') print(e) bad() 

En Python 2, funcionará bien:

 $ python foo.py 1 key error 1 $ python foo.py 2 value error 2 

Pero ahora veamos cómo funcionará en Python 3:

 $ python3 foo.py 1 key error Traceback (most recent call last): File "foo.py", line 19, in <module> bad() File "foo.py", line 17, in bad print(e) UnboundLocalError: local variable 'e' referenced before assignment 

¿Qué acaba de pasar aquí? El "problema" es que en Python 3, un objeto en un bloque de excepción no está disponible fuera de él. (La razón de esto es que, de lo contrario, los objetos en este bloque se almacenarán en la memoria hasta que el recolector de basura se inicie y elimine las referencias a ellos desde allí).

Una forma de evitar este problema es mantener la referencia al objeto del bloque de excepción fuera de este bloque para que permanezca disponible. Aquí está la versión del ejemplo anterior que utiliza esta técnica, obteniendo así el código adecuado tanto para Python 2 como para Python 3:

 import sys def bar(i): if i == 1: raise KeyError(1) if i == 2: raise ValueError(2) def good(): exception = None try: bar(int(sys.argv[1])) except KeyError as e: exception = e print('key error') except ValueError as e: exception = e print('value error') print(exception) good() 

Ejecútalo en Python 3:

 $ python3 foo.py 1 key error 1 $ python3 foo.py 2 value error 2 

¡Hurra!

Error # 10: uso incorrecto del método __del__

Digamos que tiene un archivo mod.py como este:

 import foo class Bar(object): ... def __del__(self): foo.cleanup(self.myhandle) 

Y está intentando hacer esto desde otro another_mod.py:

 import mod mybar = mod.Bar() 

Y obtén un terrible AttributeError.

Por qué Porque, como se informa aquí , cuando el intérprete se apaga, todas las variables globales del módulo tienen el valor Ninguno. Como resultado, en el ejemplo anterior, cuando se llamó a __del__, el nombre foo ya estaba establecido en Ninguno.

La solución a esta "tarea con un asterisco" es usar atexit.register (). Por lo tanto, cuando su programa completa la ejecución (es decir, cuando sale normalmente), sus identificadores se eliminan antes de que el intérprete complete su trabajo.

Con esto en mente, la solución para el código mod.py anterior podría verse así:

 import foo import atexit def cleanup(handle): foo.cleanup(handle) class Bar(object): def __init__(self): ... atexit.register(cleanup, self.myhandle) 

Dicha implementación proporciona una manera simple y confiable de llamar a cualquier limpieza necesaria después de la finalización normal del programa. Obviamente, la decisión sobre cómo tratar con el objeto que está asociado con el nombre self.myhandle se deja a foo.cleanup, pero creo que entiendes la idea.

Conclusión

Python es un lenguaje potente y flexible con muchos mecanismos y paradigmas que pueden mejorar significativamente el rendimiento. Sin embargo, como con cualquier herramienta de software o lenguaje, con una comprensión o evaluación limitada de sus capacidades, pueden surgir problemas imprevistos durante el desarrollo.

Una introducción a los matices de Python cubiertos en este artículo ayudará a optimizar su uso del lenguaje, evitando algunos errores comunes.