Selbst wenn Sie die Sprachspezifikationen kennen, gibt es einen Fehler, dass Sie es am Ende tun werden. Ich habe versehentlich die Fehler zusammengefasst, die ich mache.
Wenn Sie in Python nacheinander ein Zeichenfolgenliteral schreiben, wird es automatisch verkettet.
>>> "aaa" "bbb"
'aaabbb'
Wenn Sie beim Definieren eines Arrays von Zeichenfolgenliteralen vergessen, ein Komma hinzuzufügen, wird dies möglicherweise nicht bemerkt, da es keinen Fehler verursacht.
>>> [
... 1 #Wenn Sie vergessen, ein anderes Komma als eine Zeichenfolge hinzuzufügen, tritt ein Fehler auf.
... 2
File "<stdin>", line 3
2
^
SyntaxError: invalid syntax
>>> [
... "a" #Bei Zeichenfolgenliteralen führt das Vergessen des Hinzufügens eines Kommas nicht zu einem Fehler
... "b",
... "c"
... ]
['ab', 'c']
Dies ist ein Fehler, den Anfänger machen. Wenn Sie beispielsweise eine Liste erstellen und einer Variablen zuweisen, geben Sie ihr den Variablennamen "Liste".
>>> list((1, 2, 3))
[1, 2, 3]
>>> list = list((1, 2, 3))
>>> list = list((1, 2, 3))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'list' object is not callable
Wenn Sie den Variablennamen "list" angeben, können Sie "list ()" danach nicht mehr aufrufen.
Es ist üblich, eine Datei mit dem Namen "test" zu erstellen. * "Wenn Sie etwas tun möchten. Mit Python geht das nicht. Da das Standardmodul einen Test enthält, treten Konflikte mit den Namen auf.
Achten Sie darauf, nicht denselben Namen zu verwenden, da viele Standard-Python-Module andere gebräuchliche Namen als "test" haben.
Machen Sie keine test.py in Python! --Qiita [Python] 10 echte Fallstricke von Python, die zu detailliert sind, um | My Koiwa Hotchkiss zu vermitteln
Taples werden definiert, indem sie durch Kommas wie "x, y, z" getrennt werden. Wenn jedoch ein Element vorhanden ist, muss ihnen ein Komma wie "x" folgen.
>>> 1, 2, 3
(1, 2, 3)
>>> 1,
(1,)
Wenn ein Taple tatsächlich verwendet wird, wird es häufig verwendet, indem es aufgrund der Struktur der Anweisung in "()" wie "(x, y, z)" eingeschlossen wird. Aus diesem Grund wird es jedoch in "()" eingeschlossen. Wenn Sie beispielsweise glauben, dass es sich um ein Taple handelt, machen Sie den Fehler, dass Sie vergessen, ein Komma hinzuzufügen, wenn nur ein Element vorhanden ist.
>>> (1, 2, 3) # ()Wenn Sie denken, dass es ein Taple sein wird, wenn Sie es mit umgeben...
(1, 2, 3)
>>> (1) #Vergessen Sie, ein Komma zu setzen, wenn es nur ein Element gibt
1
Um dies zu vermeiden, machen Sie es sich zur Gewohnheit, nach dem letzten Element ein Komma zu setzen, auch wenn mehrere Elemente vorhanden sind.
>>> (1, 2, 3,) #Wenn Sie die Gewohnheit haben, nach dem letzten Element ein Komma zu setzen...
(1, 2, 3)
>>> (1,) #Machen Sie keinen Fehler, wenn es nur ein Element gibt
(1,)
Einige Standardmodule haben Klassen und Funktionen mit demselben Namen wie der Modulname. Zum Beispiel "datetime.datetime" oder "pprint.pprint".
Natürlich unterscheidet sich die Art und Weise, wie Sie den aufzurufenden Code schreiben, beim Importieren eines Moduls und beim Importieren einer internen Klasse. Es ist jedoch leicht, einen Fehler zu machen, wenn das Modul und die Klasse denselben Namen haben.
Insbesondere wenn die Importanweisung durch die Vervollständigungsfunktion der IDE eingefügt wird, kann die interne Klasse importiert werden, obwohl das Modul importiert werden sollte, und umgekehrt.
Beim Importieren von Modulen
import datetime
datetime.datetime.now()
Beim Importieren einer Klasse
from datetime import datetime
datetime.now()
Wenn Sie in Python auf ein Objektattribut verweisen, schreiben Sie "object.name", und wenn Sie auf ein Wörterbuchelement verweisen, schreiben Sie "object [" name "]".
In JavaScript haben sowohl "object.name" als auch "object [" name "]" das gleiche Ergebnis, in Python verhalten sie sich jedoch deutlich unterschiedlich.
Siehe Objektattribute
>>> class A(object):
... def __init__(self):
... self.attr1 = 123
...
>>> a = A()
>>> a.attr1
123
>>> a["attr1"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'A' object is not subscriptable
Beziehen Sie sich auf die Elemente des Wörterbuchs
>>> b = {"key1": 123}
>>> b["key1"]
123
>>> b.key1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'key1'
Die Existenzprüfungsmethode unterscheidet sich ebenfalls: Das Attribut des Objekts lautet "hasattr (Objekt," Name ")", und das Element des Wörterbuchs lautet "Name" in Objekt ". Beachten Sie, dass das Schreiben einer Attribut-Existenzprüfung für ein Wörterbuchobjekt keinen Fehler verursacht.
Überprüfen Sie, ob Objektattribute vorhanden sind
>>> a = A()
>>> "attr1" in a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: argument of type 'A' is not iterable
>>> hasattr(a, "attr1")
True
Überprüfen Sie, ob Wörterbuchelemente vorhanden sind
>>> b = {"key1": 123}
>>> "key1" in b
True
>>> hasattr(b, "key1") #Es treten keine Ausnahmen auf!
False
In Python werden Instanzvariablen und Klassenvariablen wie folgt erstellt.
class A(object):
val1 = [1, 2, 3] #Klassenvariable
def __init__(self):
self.val2 = [4, 5, 6] #Instanzvariable
Das Schreiben von Klassenvariablen in Python ähnelt dem Definieren von Instanzvariablen in einer statisch typisierten Sprache.
Sie können auch auf Klassenvariablen mit self.name auf dieselbe Weise wie Instanzvariablen zugreifen, sodass Sie vielleicht denken, dass Sie Instanzvariablen manipulieren, aber es handelte sich tatsächlich um Klassenvariablen.
>>> class A(object):
... val = [1, 2, 3] #Ich wollte eine Instanzvariable erstellen
...
>>> a = A()
>>> b = A()
>>> a.val #Kann wie eine Instanzvariable aufgerufen werden
[1, 2, 3]
>>> b.val
[1, 2, 3]
>>> a.val.append(10) #Ich glaube, ich manipuliere die Instanzvariable von Objekt a...
>>> a.val
[1, 2, 3, 10]
>>> b.val #Objekt b hat sich ebenfalls geändert...
[1, 2, 3, 10]
>>> A.val #Ich habe tatsächlich Klassenvariablen manipuliert
[1, 2, 3, 10]
In Python können Sie nicht denselben Namen für eine Instanzmethode und eine Instanzvariable gleichzeitig verwenden. Wenn Sie einer Instanzvariablen mit demselben Namen wie die Instanzmethode einen Wert zuweisen, wird die Instanzmethode natürlich mit dem Wert überschrieben, da die Funktion ein erstklassiges Objekt und eine dynamisch typisierte Sprache ist. Ich werde.
>>> class A(object):
... def hoge(self, x):
... self.hoge = x #Ich beabsichtige, es in eine Instanzvariable hoge zu setzen, die sich von der Methode hoge unterscheidet
...
>>> a = A()
>>> a.hoge(123) #Zu diesem Zeitpunkt a.hoge ist eine Methode, die Sie aufrufen können
>>> a.hoge(456) #Zu diesem Zeitpunkt a.hoge ist eine Zahl(123)Ich kann es nicht nennen, weil es ist
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
hoge wird als Klassenvariable hoge beibehalten. (Siehe A.hoge)In Python werden Klassenmethoden und statische Methoden mit Dekoratoren definiert.
class A(object):
@classmethod
def hoge(cls, x):
pass
@staticmethod
def meke(x):
pass
Darüber hinaus können Klassenmethoden und statische Methoden sowohl in Unterklassen als auch in Instanzmethoden überschrieben werden. In diesem Fall muss die überschriebene Methode denselben Dekorator wie die Oberklasse haben. (Es sei denn, Sie wagen es, die Eigenschaften der Methode zu ändern.)
class B(A):
@classmethod #Auch beim Überschreiben erforderlich
def hoge(cls, x):
pass
@staticmethod #Auch beim Überschreiben erforderlich
def meke(x):
pass
Wenn Sie beim Überschreiben vergessen, den Dekorator hinzuzufügen, verursacht dies keinen Fehler an sich. Seien Sie jedoch vorsichtig, da sich der Wert des ersten Arguments in das Instanzobjekt (self) ändert.
Wenn Sie es mit PyCharm-Ergänzung tun, wird es nicht an den Dekorateur übergeben, so dass ich manchmal Fehler mache.
Der Wert des Standardarguments der Funktion wird bei der Definition der Funktion nur einmal ausgewertet. Es wird nicht jedes Mal ausgewertet, wenn Sie eine Funktion aufrufen.
>>> class A(object):
... def __init__(self):
... print("A()Hieß!")
...
>>> def hoge(a=A()):
... print("hoge()Hieß!")
...
A()Hieß!#Standardargumente werden unmittelbar nach der Definition von hoge ausgewertet
>>> hoge()
hoge()Hieß!#Standardargumente werden beim Aufruf von hoge nicht ausgewertet
>>> hoge()
hoge()Hieß!
Aus diesem Grund führt die Verwendung der folgenden Werte als Standardargumente zu enttäuschenden Ergebnissen.
Objekte wie Arrays und Wörterbücher
def append(v, l=[]): ... l.append(v) ... return l ...
append(1) #Fügen Sie 1 zum leeren Array hinzu [1]
append(2) #Fügen Sie 2 zum leeren Array hinzu...Sollte sein... [1, 2]
- Dynamische Werte wie aktuelles Datum und Uhrzeit
```pycon
>>> from datetime import datetime
>>> import time
>>> def printtime(t=datetime.now()):
... print(t)
...
>>> printtime()
2016-02-07 12:30:00.000000
>>> time.sleep(5) #Warten Sie 5 Sekunden
>>> printtime()
2016-02-07 12:30:00.000000 #Die Zeit ist stehen geblieben! ??
Um dies zu vermeiden, setzen Sie den Standardwert auf Keine und den ursprünglichen Wert in der Funktion.
>>> def append(v, l=None):
... if not l:
... l = []
... l.append(v)
... return l
...
>>> append(1)
[1]
>>> append(2)
[2]
Python-Strings fungieren als Zeicheniteratoren. Daher werden Sie es möglicherweise nicht bemerken, selbst wenn Sie vergessen, "[]" hinzuzufügen, wenn das Argument die Funktion des Arrays aufruft.
>>> def print_items(items):
... for i, x in enumerate(items):
... print("[%d]=%s" % (i, x))
...
>>> print_items([1, 2])
[0]=1
[1]=2
>>> print_items(["ab"]) #Um richtig zu sein, schreiben Sie so...
[0]=ab
>>> print_items("ab") # []Wenn Sie vergessen, sich anzuziehen, wird es so sein.
[0]=a
[1]=b
>>> print_items(["a"]) #Aber wenn es ein Buchstabe ist...
[0]=a
>>> print_items("a") # []Selbst wenn Sie das Anziehen vergessen, ist das Ergebnis dasselbe, sodass Sie es nicht bemerken
[0]=a
Recommended Posts