Python: Por favor, tenga cuidado en estos lugares

python es un lenguaje muy interesante. Ofrece una gran cantidad de librerías estándar muy convenientes y muchos comandos integrados para que podamos realizar tareas con facilidad. Pero hay demasiadas cosas buenas que tienen una fobia de la elección, de modo que no podemos usar bien esta librería estándar y sus instituciones básicas. A continuación se enumeran algunas trampas que son simples y efectivas para los principiantes en Python.

• Ignorando la versión de python

Este es un problema que se plantea constantemente en StackOverflow. Como es una experiencia cuando tu código perfecto se ejecuta en la computadora de otra persona, es necesario comprobar si tus versiones de Python son compatibles. Asegúrate de que el código se ejecuta en la versión de Python que conoces.

  $ python --version
  Python 2.7.9

Administración de versiones de python

pyenv es una buena herramienta de administración de versiones de Python. Desafortunadamente, sólo funciona en*En los sistemas nix. En Mac OS, puedes instalar pyenv simplemente con brew install. En los sistemas Linux, hay un instalador automático automatic installer

• Atrapado en resolver todos los problemas con una sola línea de código

Muchas personas se jactan de que yo puedo resolver todos los problemas con una sola línea de código, incluso cuando su código es menos eficiente que el normal, y es más difícil de leer e incluso contradictorio.

  l = [m for a, b in zip(this, that) if b.method(a) != b for m in b if not m.method(a, b) and reduce(lambda x, y: a + y.method(), (m, a, b))]

Honestamente, el código de arriba lo escribí yo mismo para explicar esto. Pero he visto a muchas personas hacerlo. Si solo agregas cosas a una lista o a un conjunto para mostrar tus propios medios de resolver problemas complejos, entonces es posible que no te salgan a la vista.

El control de una línea de código no es un gran logro, aunque a veces parece especialmente inteligente. El código excelente es el que es conciso, pero se centra más en la eficiencia y la legibilidad.

• Inicialización incorrecta del set

Este es un problema más delicado, que a veces te sorprenderá. La inferencia de set es un poco como la inferencia de list.

  >>> { n for n in range(10) if n % 2 == 0 }
  {0, 8, 2, 4, 6}
  >>> type({ n for n in range(10) if n % 2 == 0 })

El ejemplo de arriba lo demuestra. set es un poco como poner list en un recipiente. La diferencia es que el conjunto no tiene valores repetidos y es desordenado. La gente suele pensar que {} es un conjunto vacío, pero no lo es, es un dicto vacío.

  >>> {}
  {}
  >>> type({})

Así que si queremos inicializar un conjunto vacío, simplemente usamos set ().

  >>> set()
  set()
  >>> type(set())

Nótese que un conjunto vacío puede ser representado como set (), pero un conjunto que contiene elementos debe ser definido como set ().[1, 2]) de la misma manera.

• El malentendido de GIL

GIL (global interpreter lock) significa que sólo un hilo puede funcionar en un programa de Python en cualquier momento. Esto significa que cuando no podemos crear un hilo y esperar que funcione en paralelo. Lo que el intérprete de Python realmente hace es cambiar rápidamente entre diferentes hilos de ejecución. Pero esta es una versión muy simple.

Muchas personas tratarán de justificar a Python diciendo que estos son los hilos reales. 3 Esto es cierto, pero no cambia el hecho de que Python trata los hilos de una manera diferente a la que se espera.

La solución prevista es el uso de módulos de multiprocesamiento. Las clases de procesos que ofrecen los módulos de multiprocesamiento pueden cubrir básicamente las discrepancias muy bien. Sin embargo, las discrepancias son mucho más costosas que los hilos.

Sin embargo, no todos los programas de Python se enfrentan a este problema. PyPy-stm es un ejemplo de una implementación de Python que no se ve afectada por GIL. Implementaciones basadas en otras plataformas como JVM (Jython) o CLR (IronPython) no tienen problemas con GIL.

En resumen, tenga cuidado con las clases de hilos, ya que lo que obtiene puede no ser lo que quiere.

• Utiliza clases de estilo obsoletas

En Python 2 hay dos tipos de clases, las clases de estilo antiguo y las clases de estilo nuevo. Si usas Python 3, entonces estás usando la clase de estilo nuevo por defecto. Para asegurarte de usar el estilo nuevo en Python 2, necesitas heredar objetos o cualquier clase nueva que creas que no siempre hereda las instrucciones int o list. En otras palabras, tu clase base siempre debe heredar objetos.

  class MyNewObject(object): # stuff here

Estas nuevas claves corrigen algunos problemas muy básicos que aparecían en las clases antiguas, si estás interesado puedes ver la documentación.

• La repetición errónea

Los siguientes errores son muy comunes entre los principiantes:

  for name_index in range(len(names)):
    print(names[name_index])

Es evidente que no es necesario usar el len, de hecho, recorrer la lista se puede hacer con una frase muy simple:

  for name in names:
     print(name)  

Además, hay una gran cantidad de otras herramientas para simplificar la repetición. Por ejemplo, zip se puede usar para recorrer dos listas:

  for cat, dog in zip(cats, dogs):
     print(cat, dog)

Si queremos tener en cuenta las variables de la lista de índices y valores, podemos usar enumerate

  for index, cat in enumerate(cats):
     print(cat, index)

Hay muchas opciones en itertools. Si tiene la función que desea, es fácil de usar. Pero no la use demasiado para usarla.

El abuso de las itertools ha hecho que un gran dios de StackOverflow se tome mucho tiempo para solucionarlo.

Se utiliza un parámetro predeterminado variable

He visto muchas cosas como:

  def foo(a, b, c=[]):
     # append to c
     # do some more stuff

No utilices parámetros predeterminados variables, en lugar de los siguientes:

  def foo(a, b, c=None):
   if c is None:
     c = []
     # append to c
     # do some more stuff 

El siguiente ejemplo puede ayudarnos a entender esto de manera muy intuitiva:

  In[2]: def foo(a, b, c=[]):
  ...     c.append(a)
  ...     c.append(b)
  ...     print(c)
  ...
  In[3]: foo(1, 1)
  [1, 1]
  In[4]: foo(1, 1)
  [1, 1, 1, 1]
  In[5]: foo(1, 1)
  [1, 1, 1, 1, 1, 1]

La misma c es citada una y otra vez cada vez que se llama a la función. Esto puede tener algunas consecuencias muy innecesarias.