Python: Bitte seien Sie vorsichtig in diesen Bereichen.

Schriftsteller:Ich bin nicht derjenige, der das tut., Erstellt: 2016-12-29 13:46:12, aktualisiert:

python是一门非常有趣的语言。它提供了许多非常方便的标准库和许多内置命令是我们轻松完成任务.但是好东西太多了就有选择恐惧症了，以至于我们不能很好第利用这个标准库和它的基本机构。下面列出了一些对python新手来说很简单有效的陷阱。

Die Versionen von Python werden ignoriert.

Dies ist ein Problem, das immer wieder auf StackOverflow auftaucht. Wie ist es, wenn man einen Fehler macht, wenn man seinen perfekten Code auf einem anderen Computer läuft?
```
$ python --version
Python 2.7.9
```
Python-Versionsmanagement

pyenv ist ein gutes python-Versionsmanagement-Tool. Leider läuft es nur auf *nix-Systemen. Auf Mac OS können Sie pyenv einfach mit brew install installieren.
Sie sind verwirrt, indem sie alle Probleme mit einer Zeile Code lösen.

Viele Leute prahlen, dass ich alle Probleme mit einer einzigen Zeile Code gelöst habe, obwohl ihr Code weniger effizient ist als normal geschrieben, und der Code schwerer zu lesen ist und sogar mehr Unklarheiten hervorruft.
```
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))]
```
Ich habe den Code selbst geschrieben, um das zu verdeutlichen. Aber ich habe wirklich viele Leute gesehen, die es getan haben. Wenn Sie sich einfach als Lösung für komplexe Probleme erweisen, indem Sie etwas zu einer Liste oder einem Satz hinzufügen, dann können Sie nicht bezahlt werden.

Eine Zeile Code-Kontrolle ist keine große Leistung, obwohl sie manchmal besonders clever erscheint.
Fehler beim Initiieren des Sets

这是一个更加微妙的问题，有时候会让你措手不及。set推导式起来有点像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 })
```
Das Beispiel oben zeigt das. ⇒set ist ein bisschen wie eine Liste in einem Container. Sie unterscheiden sich darin, dass ein Satz keine doppelten Werte hat und ungeordnet ist. {} wird normalerweise als leerer Satz betrachtet, aber das ist es nicht, es ist ein leerer Dikt.
```
>>> {}
{}
>>> type({})
```
Wenn wir also eine leere Menge einlösen wollen, dann benutzen wir einfach die Set ((()
```
>>> set()
set()
>>> type(set())
```
Beachten Sie, dass ein leerer Satz als Satz bezeichnet werden kann ((), aber als Satz mit Elementen definiert wird (([1, 2])
Das ist ein Missverständnis.

GIL (global Interpreter Lock) bedeutet, dass nur ein Thread in einem Python-Programm zu jeder Zeit ausgeführt werden kann. Das bedeutet, dass wir keinen Thread erstellen können, der parallel ausgeführt werden soll. Die Python-Interpreter tun eigentlich nur, um schnell zwischen verschiedenen Laufsträngen zu wechseln.

Viele Leute werden versuchen, Python zu rechtfertigen, dass dies alle echte Threads sind.3. Das ist wahr, aber es ändert nichts an der Tatsache, dass Python Threads anders behandelt, als Sie es erwarten würden. Ruby hat eine ähnliche Situation (es gibt auch ein Interpreter-Lock).

Die vorgeschlagene Lösung ist die Verwendung von Multiprocessing-Modulen. Die Prozesse, die durch Multiprocessing-Module bereitgestellt werden, können die Differenzen grundsätzlich gut überdecken. Die Differenzen sind jedoch viel höher als die Kosten für den Thread.

Allerdings ist dieses Problem nicht für alle Python-Programme ein Problem. PyPy-stm ist ein Beispiel für eine GIL-unberührte Python-Implementierung.

Also seien Sie vorsichtig, wenn Sie Threads verwenden, denn Sie bekommen möglicherweise nicht das, was Sie wollen.
Veraltete Styles verwendet

In Python 2 gibt es zwei Arten von Klassen, die alten und die neuen Klassen. Wenn Sie Python 3 verwenden, verwenden Sie die Standard-Klassen. Um sicherzustellen, dass Sie die neuen Klassen in Python 2 verwenden, benötigen Sie object oder jede neue Klasse, die Sie erstellen, die nicht immer den integrierten Befehl int oder list erbt.
```
class MyNewObject(object): # stuff here
```
Diese neuen Klassenhebel beheben einige sehr grundlegende Probleme, die in den alten Klassen auftraten.
Die falsche Wiederholung

Die folgenden Fehler sind für Neulinge sehr häufig:
```
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 durchqueren:
```
for name in names:
   print(name)  
```
Außerdem gibt es eine ganze Reihe anderer Tools, mit denen Sie mit der Vereinfachung von Iterationen umgehen können. Zum Beispiel kann zip zwei Listen durchlaufen:
```
for cat, dog in zip(cats, dogs):
   print(cat, dog)
```
Wenn wir Index- und Werte-Liste-Variablen berücksichtigen wollen, können wir es mit enumerate tun.
```
for index, cat in enumerate(cats):
   print(cat, index)
```
Es gibt auch viele Funktionen, die Sie auswählen können. Eine Funktion, die Sie möchten, ist sehr einfach zu finden.

Der Missbrauch von itertools hat es einem großen Gott auf StackOverflow schwer gemacht, es zu beheben.

Verwenden Sie die Variable-Standardparameter

Ich habe viele davon gelesen:
```
def foo(a, b, c=[]):
   # append to c
   # do some more stuff
```
Verwenden Sie keine variablen Default-Parameter, sondern:
```
def foo(a, b, c=None):
 if c is None:
   c = []
   # append to c
   # do some more stuff 
```
Das folgende Beispiel kann uns helfen, das Problem sehr 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]
```
Die gleiche c wird jedes Mal, wenn die Funktion aufgerufen wird, wiederholt zitiert. Dies kann zu einigen sehr unerwünschten Konsequenzen führen.

Mehr