Python : Soyez prudent dans ces endroits

python est un langage très intéressant. Il fournit de nombreuses bibliothèques de normes très pratiques et de nombreuses commandes intégrées qui nous facilitent la tâche. Mais trop de bonnes choses entraînent une phobie du choix au point que nous ne pouvons pas très bien utiliser cette bibliothèque de normes et ses institutions de base. Voici quelques pièges simples et efficaces pour les débutants en python.

• La version de python ignorée

C’est une question qui revient régulièrement sur StackOverflow. Comme il est difficile de faire une erreur lorsque votre code parfait est exécuté sur un ordinateur d’un autre, il est important de vérifier que votre version de Python est cohérente. Assurez-vous que le code est exécuté avec la version de Python que vous connaissez.

  $ python --version
  Python 2.7.9

Gestion de la version python

pyenv est un bon outil de gestion de version en python. Malheureusement, il ne fonctionne qu’en*Sur les systèmes nix. Sur Mac OS, vous pouvez installer pyenv simplement en utilisant brew install. Sur les systèmes linux, il existe un programme d’installation automatique

• Engager dans une seule ligne de code pour résoudre tous les problèmes

Beaucoup de gens se vantent d’avoir résolu tous les problèmes avec une seule ligne de code, même si leur code est moins efficace qu’il ne l’est normalement, et qu’il est plus difficile à lire, voire ambigu.

  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))]

Honnêtement, le code ci-dessus a été écrit par moi-même pour expliquer ce problème. Mais j’ai vraiment vu beaucoup de gens le faire. Si vous avez simplement ajouté quelque chose à une liste ou à un ensemble pour montrer comment résoudre des problèmes complexes, vous risquez de ne pas être remboursé.

La maîtrise d’une seule ligne de code n’est pas une grande réussite, même si elle semble parfois particulièrement intelligente. Un bon code est un code qui est simple, mais qui est plus axé sur l’efficacité et la lisibilité.

• Initialement incorrect

C’est un problème plus délicat, qui peut parfois vous surprendre. Les déductions de groupes ressemblent un peu à celles de listes.

  >>> { 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 })

L’exemple ci-dessus l’illustre bien. Set est un peu comme une liste dans un conteneur. La différence entre les deux est que set n’a pas de valeur répétée et n’est pas ordonné. On pense généralement que {} est un set vide, mais ce n’est pas le cas, c’est un dict vide.

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

Donc si nous voulons initialier un ensemble vide, nous allons utiliser directement set ().

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

Notez qu’un ensemble vide peut être représenté comme un ensemble (), mais qu’un ensemble contenant des éléments doit être défini comme un ensemble ().[1, 2]) est la même.

• Je ne comprends pas GIL.

GIL (global interpreter lock) signifie qu’un seul thread peut être exécuté dans une application Python à tout moment. Cela signifie que nous ne pouvons pas créer un thread et s’attendre à ce qu’il fonctionne en parallèle. Ce que l’interpréteur Python fait en fait est de passer rapidement entre différents threads en cours d’exécution. Mais c’est une version très simple.

Beaucoup de gens essaieront de justifier Python en disant que ce sont de vrais threads. 3 C’est vrai, mais cela ne change rien au fait que Python traite les threads différemment de ce que vous attendez.

La solution proposée est l’utilisation d’un module de multiprocessage. Les classes de processus fournies par le module de multiprocessage peuvent essentiellement bien couvrir les divergences. Cependant, les divergences coûtent beaucoup plus cher que les threads.

Cependant, ce problème n’est pas rencontré par tous les programmes Python. PyPy-stm est un exemple d’implémentation de Python qui n’est pas affectée par GIL. Les implémentations construites sur d’autres plates-formes comme JVM (Jython) ou CLR (IronPython) n’ont pas de problèmes GIL.

En résumé, faites attention à ce que vous utilisez, car vous n’obtiendrez peut-être pas ce que vous voulez.

• Utilisation de classes de style obsolètes

Il y a deux types de classes en Python 2, les classes de style ancien et les classes de style nouveau. Si vous utilisez Python 3, vous utilisez les classes de style nouveau par défaut. Pour vous assurer que vous utilisez les classes de style nouveau dans Python 2, vous devez hériter d’objets ou de toute nouvelle classe que vous créez qui n’hérite pas toujours de la commande int ou de la liste.

  class MyNewObject(object): # stuff here

Ces nouveaux plugins corrigent des problèmes très basiques qui se produisaient dans les classes plus anciennes, si vous êtes intéressé, vous pouvez consulter la documentation.

• Une mauvaise répétition

Les erreurs suivantes sont très fréquentes chez les débutants:

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

Il est évident qu’il n’est pas nécessaire d’utiliser le langage len, et en fait, parcourir la liste peut être réalisé avec une phrase très simple:

  for name in names:
     print(name)  

En outre, il y a une foule d’autres outils qui vous aideront à simplifier l’itération. Par exemple, zip peut être utilisé pour parcourir deux listes:

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

Si nous voulons considérer les variables de l’index et de la liste de valeurs, nous pouvons utiliser enumerate.

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

Il y a beaucoup de fonctionnalités à choisir dans itertools. Si vous voulez quelque chose dans itertools, il est facile de l’obtenir. Mais n’utilisez pas trop pour l’utiliser.

L’abus des itertools a pris beaucoup de temps à un des géants de StackOverflow pour le résoudre.

Paramètres par défaut variables utilisés

J’en ai vu beaucoup comme ceci:

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

N’utilisez pas de paramètres par défaut variables, mais plutôt:

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

L’exemple suivant peut nous aider à comprendre cela de manière intuitive:

  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]

Le même c est cité encore et encore chaque fois que la fonction est appelée. Cela peut avoir des conséquences très inutiles.