Python: An diesen Stellen bitte vorsichtig sein

python ist eine sehr interessante Sprache. Es bietet viele sehr praktische Standardbibliotheken und viele eingebaute Befehle, mit denen wir unsere Aufgaben leicht erledigen können. Aber zu viel Gutes führt zu einer Wahlphobie, so dass wir diese Standardbibliothek und ihre grundlegenden Einrichtungen nicht gut nutzen können. Hier sind einige einfache und effektive Fallstricke für Python-Neulinge.

• Vergessen Sie die Version von Python

Es ist eine Frage, die ständig bei StackOverflow auftaucht. Wie es ist, wenn dein perfekter Code auf dem Computer eines anderen läuft und Fehler auftreten, also ist es an dieser Stelle wichtig, zu überprüfen, ob deine Python-Versionen übereinstimmen.

  $ python --version
  Python 2.7.9

Python-Versionsverwaltung

pyenv ist ein tolles Python-Version-Management-Tool.*pyenv auf Linux-Systemen. Auf Mac OS kann man es einfach mit Brew Install installieren. Auf Linux-Systemen gibt es einen automatischen Installer (automatic installer).

• Es ist ein Problem, wenn man alle Probleme mit einer einzigen Zeile Code lösen muss.

Viele behaupten, dass ich alles mit einer einzigen Zeile Code löse, obwohl ihr Code weniger effizient ist als normal geschrieben, schwerer zu lesen ist und sogar missverständlich ist.

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

Der Code hier oben wurde von mir selbst geschrieben, um die Sache zu erklären. Aber ich habe wirklich viele Leute gesehen, die das getan haben. Wenn Sie sich einfach die Möglichkeit bieten, komplexe Probleme zu lösen, indem Sie Dinge zu einer Liste oder einem Set hinzufügen, dann können Sie nicht bezahlt werden.

Eine Zeile Code ist keine große Errungenschaft, obwohl es manchmal besonders clever erscheint. Guter Code ist einfach, aber mit mehr Aufmerksamkeit auf Effizienz und Lesbarkeit.

• Set wurde falsch initialisiert

Das ist ein viel subtileres Problem, das manchmal überrascht. Die Set-Derivative ist ein bisschen wie die List-Derivative.

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

Das Beispiel oben zeigt das. Set ist ein bisschen wie List in einem Behälter. Sie unterscheiden sich dadurch, dass die Menge keine wiederholten Werte aufweist und nicht ordnungsgemäß ist. Man würde normalerweise annehmen, dass {} eine leere Menge ist, aber das ist es nicht, es ist ein leerer Diktat.

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

Wenn wir also einen leeren Satz initialieren wollen, dann benutzen wir den Satz direkt.

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

Beachten Sie, dass ein leerer Satz als Set () dargestellt werden kann, aber eine Gruppe, die Elemente enthält, als Set () definiert wird.[1, 2]) zu sehen.

• GIL ist falsch verstanden

GIL (Global Interpreter Lock) bedeutet, dass nur ein Thread in einer Python-Anwendung zu jeder Zeit ausgeführt werden kann. Das bedeutet, dass wir keinen Thread erstellen und erwarten können, dass er parallel läuft. Was der Python-Interpreter tatsächlich tut, ist, dass er schnell zwischen verschiedenen laufenden Threads wechselt.

Viele Leute werden versuchen, sich für Python zu rechtfertigen, dass es sich um echte Threads handelt. 3 Das ist zwar wahr, aber es ändert nichts an der Tatsache, dass Python Threads anders verarbeitet, als man erwarten würde.

Die vorgeschlagene Lösung ist die Verwendung eines Multiprocessing-Moduls. Die Prozessklassen, die von einem Multiprocessing-Modul bereitgestellt werden, können die Differenzen im Wesentlichen gut überdecken. Die Differenzen sind jedoch viel teurer als die Kosten für die Threads.

Dieses Problem tritt jedoch nicht bei jedem Python-Programm auf. PyPy-stm ist ein Beispiel für eine Python-Implementierung, die nicht von GIL betroffen ist. Implementierungen, die auf anderen Plattformen wie JVM (Jython) oder CLR (IronPython) basieren, haben keine GIL-Probleme.

Und wenn Sie die Threading-Klasse verwenden, dann sollten Sie darauf achten, dass Sie möglicherweise nicht das bekommen, was Sie wollen.

• Veraltete Stilklassen

In Python 2 gibt es zwei Arten von Klassen, Old-Style-Klassen und Neues-Stil-Klassen. Wenn Sie Python 3 verwenden, verwenden Sie die Standard-Neues-Stil-Klassen. Um sicherzustellen, dass Sie Neues-Stil-Klassen in Python 2 verwenden, müssen Sie Object erben oder jede neue Klasse, die Sie erstellen, die nicht immer die integrierte Anweisung int oder list erbt.

  class MyNewObject(object): # stuff here

Diese neuen Klassenhacks beheben einige sehr grundlegende Probleme, die in den alten Klassen auftraten.

• Falsche Wiederholung

Die folgenden Fehler sind sehr häufig bei Anfängern:

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

Es ist offensichtlich, dass es nicht notwendig ist, len zu verwenden, und es ist tatsächlich möglich, die Liste mit einem sehr einfachen Satz zu durchsuchen:

  for name in names:
     print(name)  

Außerdem gibt es eine Menge anderer Tools, mit denen Sie die Reiteration vereinfachen können. Zum Beispiel kann zip zwei Listen durchlaufen:

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

Wenn wir Index- und Wertlisten-Variablen berücksichtigen wollen, können wir enumerate verwenden.

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

In itertools gibt es viele Funktionen, aus denen Sie auswählen können. Wenn es eine Funktion in itertools gibt, die Sie möchten, ist es sehr bequem, sie zu verwenden. Aber verwenden Sie sie nicht zu sehr, um sie zu verwenden.

Der Missbrauch von itertools hat einen großen Gott auf StackOverflow zu lange gebraucht, um es zu beheben.

Variable Standardparameter verwendet

Ich habe viele davon gesehen:

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

Verwenden Sie keine variablen Standardparameter, sondern:

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

Das folgende Beispiel hilft uns, das Problem intuitiv zu verstehen:

  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]

Dieselbe c wird jedes Mal, wenn die Funktion aufgerufen wird, wieder und wieder zitiert. Das kann zu sehr unnötigen Konsequenzen führen.