Python Gotchas (C) 2018-2022 T.Birnthaler OSTC GmbH
==============
* Fließkommazahl mit "," statt "." schreiben --> Tupel mit 2 int statt 1 float:
f = 1,5
print(f, type(f)) --> (1, 5) <class 'tuple'>
GRUND: Tupel entsteht sobald ein Komma vorkommt, runde Klammern außenrum sind
nicht notwendig (aber optisch leichter erkennbare Form)
GRUND: Fließkommazahlen sind immer mit "." zu schreiben (jede Sprache).
* "," am Zeilenende --> Tupel statt Wert:
var = 123 --> var hat Wert 123
var = 123, --> var hat Wert (123,) d.h ein Tupel
* ";" am Zeilenende ist überflüssig (Statement-Abschluß):
var = 123
var = 123;
GRUND: In Python gilt das Zeilenende als Ende einer Anweisung.
* Ein vergessenes Komma "," in einer Sequenz von Strings kann dazu führen,
dass versehentlich 2 Elemente zu einem Element zusammengezogen werden:
var = ("aa" "bb") --> var hat Stringwert "aabb" (kein Tupel)
var = ("aa","bb") --> var hat Tupelwert ("aa", bb")
("a", "b", "c" "d", "e" "f") --> ("a", "b", "cd", "ef")
("a",
"b",
"c"
"d",
"e"
"f") --> ("a", "b", "cd", "ef")
GRUND: Direkt hintereinanderstehende Strings (ohne Operator dazwischen)
werden von Python zu einem String zusammengezogen (analog Verkettung per "+")
(auch auf mehreren Zeilen verteilte Strings falls sie in Klammern stehen)
* Verwechslung von "+=" und "=+" (analog C/C++/Java):
v = 5
v += 1 --> 6
v =+ 1 --> v = +1 --> v = 1 --> 1
Verwechslung von "-=" und "=-" (analog C/C++/Java):
v = 5
v -= 1 --> 4
v =- 1 --> v = -1 --> v = -1 --> -1
GRUND: Bei "=+" / "=-" zählt Plus/Minuszeichen als (überflüssiges) Vorzeichen.
* Nutzung von "++" oder "--" zum Inkrementieren/Dekrementieren von Werten:
erg = ++v
erg = --v
erg = ++a * --b
GRUND: Diese beiden Operatoren gibt es in Python nicht, sie werden somit als
doppelte Vorzeichen intepretiert und sind daher ohne Wirkung.
* "assert" ist ein Schlüsselwort, keine Funktion, es erwartet 1 oder 2 durch
Komma getrennte Werte (typischerweise eine Bedingung + einen String)
(Klammern der Parameter führt zu Syntaxfehlern oder merkwürdigen Ergebnissen):
assert TEST --> Korrekte Schreibweise
assert TEST, MSG --> Korrekte Schreibweise
assert(TEST,MSG) --> FEHLER!
assert(TEST) --> FEHLER!
* "del" ist ein Schlüsselwort, keine Funktion
(Klammern sind zwar erlaubt, aber unüblich):
del V1 --> Korrekte Schreibweise
del V1, V2, ... --> Korrekte Schreibweise
del(V1) --> OK, aber ungewöhnlich
del(V1, V2, ...) --> OK, aber ungewöhnlich
* Ein 1-elementiger Tupel sind mit einem "überflüssigen" Komma zu schreiben:
("abc",) --> OK
("abc") --> Falsch da kein Tupel sondern ein Wert (geklammerter Ausdruck)
GRUND: Mehrdeutige Klammer (...) muss eindeutig gemacht werden:
a) Rechenausdruck (Expression): (1+2)*3 (123) (1+2+3)
b) Tupel (Komma notwendig): () (123,) (1, 2, 3)
c) Funktions-Aufruf: f() f(123) f(1, 2, 3)
* Eine LEERE MENGE ist speziell zu schreiben:
set() frozenset() --> OK
set({}) frozenset({}) --> OK
{} --> FALSCH da Dictionary
GRUND: Mehrfachbedeutung von {...} = dict, set, frozenset
* Vergessene schließende Klammer (z.B. bei print(...), [...], {...}) oder
vergessenes schließendes Stringende "..." '...' """...""" '''...'''
--> Fehlermeldung "SyntaxError" evtl. irreführend erst viele Zeilen später,
da Aufteilung auf mehrere Zeilen innerhalb Klammern/String erlaubt ist.
* Methoden müssen in Klasse eingeschachtelt sein (korrekte Einrückung):
class KLASSE:
def METHODE1(self, ...): # Methode Gehört zur Klasse
...
def METHODE(self, ...): # Funktion von Klasse unabhängig
...
Nicht eingerückte Methoden nach Klasse sind Klassen-unabhängige Funktionen.
* Auf KLASSEN-VARIABLE kann per OBJEKT zugegriffen werden,
solange die Klassenvariable NUR GELESEN wird.
Sobald 1x per OBJEKT in die Klassenvariable GESCHRIEBEN wird,
hat Objekt EIGENE gleichnamige Variable mit eigenem Wert.
class C:
var = 111
c1 = C()
c2 = C()
print(C.var, c1.var, c2.var) # --> 111, 111, 111
c1.var = 222
print(C.var, c1.var, c2.var) # --> 111, 222, 111
C.var = 333
print(C.var, c1.var, c2.var) # --> 333, 222, 333
* KLASSEN-VARIABLE nur über den Klassennamen ansprechen, nicht über das Objekt
(wäre nur zum Lesen OK)
GRUND: Solange nur gelesen wird identisches Objekt,
sobald geschrieben wird --> verschiedene Objekte (COW)
class K:
attr = "klasse"
o1 = K()
o2 = K()
print(K.attr, o1.attr, o2.attr) # --> "klasse", "klasse", "klasse"
o1.attr = "objekt"
print(K.attr, o1.attr, o2.attr) # --> "klasse", "objekt", "klasse"
* Klammern nach Bezeichner setzen oder nicht ist ein Riesenunterschied:
var = name() # --> Funktions-Aufruf/Objekt-Konstruktor/...
var = name # --> Referenz auf Funktion/Klasse/...
* Python konvertiert Datentypen NIE automatisch, das ist immer manuell zu tun:
int(STR) <-> str(INT/FLOAT)
int("123.4") --> PENG!
Ausnahmen:
1) Alle Zahlentypen können in Ausdrücken gemischt werden:
bool <-> int <-> float <-> complex <-> Decimal <-> Fraction
2) Bei if/while wird Bedingung automatisch nach bool(...) konvertiert
if BED: ...
while BED: ...
3) print(...) konvertiert alle angegebenen Werte/Objekte per str(...)
--> Kann garantiert jeden Wert/jedes Objekt ausgeben!
* Python verhält sich bei Datei-Input/Output wie ein UNIX/Linux-System:
+ Zeilenenden bleiben erhalten
+ Zeilenende "\r\n" (Windows-OS) <-> "\n" (UNIX/Linux)
+ Verzeichnistrenner "\" (Windows-OS) <-> "/" (UNIX/Linux)
* Die Zeichensatz-Codierung von Source-Code, Eingabe- und Ausgabe-Daten
berücksichtigen (Python 3 geht standardmäßig von Unicode in UTF-8 Codierung
aus).
* Für Bezeichner möglichst nur ASCII-Zeichen verwenden (Code 32-127, Teil von
Unicode und hat UTF-8 Codierung).
KONSTANTE = 3.141529
variable = 123
class KlassenName: ...
def funktions_name
* Der Dateiname eines Moduls muss ein BEZEICHNER sein, damit es per "import"
geladen werden kann (nur die Zeichen "a-zA-Z_0-9" verwenden, insbesondere
kein Leerzeichen und kein Bindestrich "-" im Modulnamen nutzen!)
* Unterverzeichnis mit Modulen und Modul NICHT GLEICH nennen:
Programm-Code
# programm.py
import verz.unter.modul as vum
--> ModuleNotFoundError: No module named 'verz.unter'; 'verz' is not a package
Verzeichnis + Dateistruktur:
+-- programm.py
+-- verz
| +--- unter
| +--- modul.py
+-- verz.py
* Datentypen werden erst zur Laufzeit (Run-Time) überprüft, nicht während der
Übersetzungszeit (Compile-Time), generelle Eigenschaft von Skript-Sprachen.
--> Fehlermeldung TypeError, ValueError, ... erst zur Laufzeit
* Überschreiben von bereits vorhandenen Namen von Variablen, Funktionen, ...
ist jederzeit ohne Warnung möglich (inkl. Typänderung).
Ausnahme: Die 37 Schlüsselworte (if, else, ...) sind nicht umdefinierbar
Typische Kandidaten (versehentlich verwendete eingebaute/interne Namen):
len = 0
sum = 12345
min = 0
max = 999
any = True
all = []
str = "hallo"
int = 123
float = 123
list = [1, 2, 3]
tuple = (1, 2, 3)
dict = {"a": 1, "b": 2, "c": 3}
type = "int"
dir = "C:\\Users\\Administrator\\Documents"
* Eigenes Python-Skript nicht so nennen wie ein Builtin-Modul oder eine
bereits vorhandene interne Variable, Funktion, Klasse oder ...
GRUND: Namen können jederzeit neu definiert werden
(kommentarlos, ohne Fehlermeldungen)
TIP: Unterstrich hinten dranhängen (z.B. "if_")
KANDIDATEN: len sum min max any all str int list ... (Built-in Funktionen)
* Namenskonventionen und Reihenfolgevorgaben einhalten (PEP8):
cls # Klasse in Klassenmethode
self # Objekt in Methode
other # 2. Objekt in Methode
*args # Sammler für Positions-Argument in Funktions-Definition
**kwargs # Sammler für Schlüsselwort-Argument in Funktions-Definition
*_ # Sammler für zu ignorierende Elemente in Tupel-Zuweisungs
_ # Temporäre Variable (z.B. for _)
NAME # Public Attribut/Methode in Klasse
_NAME # Protected Attribut/Methode in Klasse
__NAME # Private Attribut/Methode in Klasse
__NAME__ # Python-interne Variable (nie für eigene Zwecke nutzen!)
KEYWORD_ # Schlüsselworte als Bezeichner (z.B. if_ while_)
funk_tion # Funktions-Bezeichner (Snake Case)
Klasse # Klassen-Bezeichner (Camel Case)
KONSTANTE # Konstanten-Bezeichner (Trump Case)
GRUND: Programm für nächsten (durchschnittlichen) Programmierer schreiben!
* Vollständigen Import aller Elemente aus Modul per * nicht benutzen:
from modul import *
GRUND: Überschreibt alle gleichnamigen bereits vorhandenen Namen!
Welche Namen werden überhaupt importiert und wie viele?
* Fehler NICHT UNTERDRÜCKEN, sondern abfangen und behandeln:
try: # Start
... # "Überwachter" CODE: Fehler --> except angesprungen
except: # Fängt ALLE Fehler ab --> zu viele (z.B. Syntax, Name, Type, Value, Assert, ...)!
pass # Unterdrückt ALLE Fehler --> Programmierer bekommt nichts mit!
GRUND: Alle Fehler-Meldungen werden abgefangen + vollständig unterdrückt!
Keine Fehler-Behandlung sondern Fehler-UNTERDRÜCKUNG!
Erschwert Fehlersuche stark!
* Maximal "Exception" abfangen, nicht "BaseException"!
except: ... # entspricht "except BaseException: ..."
GRUND: Programm mit exit()-Funktion und "Strg-C" (Cancel) nicht abbrechbar!
* Programm übersetzbar, aber Exception löst "NameError" aus
GRUND: Exception-Namen werden erst im Fehlerfall gesucht ob vorhanden
(nicht zur Übersetzungszeit)
Analog bei Funktionen und Klassen: Erst bei Nutzung werden Namen darin geprüft
* Exception-Fall unwirksam
GRUND: Vorher steht in der Kaskade eine allgemeinere Exception --> greift zuerst
Python überprüft nicht, ob Exception-Kasakade disjunkt ist
* Test auf True/False ist "over-engineered" und zu spezifisch
(Datentyp von "var" MUSS "bool" sein, sonst Ergebnis "False"):
if var == True: while var == True:
if var != True: while var != True:
if var == False: while var == False:
if var != False: while var != False:
BESSER: if var: # if --> Boolescher Kontext
if not var: # if --> Boolescher Kontext
GRUND: "Wahr" sind fast alle Werte, identisch mit "True" ist fast keiner.
Ausdruck nach if/while wird automatisch nach bool() konvertiert.
* Test auf leeren/gefüllten Containerist "over-engineered" und zu spezifisch
(Datentyp von "var" MUSS "tuple", "list", "dict" sein, sonst Ergebnis "False"):
if tpl == (): --> if not tpl:
if tpl != (): --> if tpl:
if lst == []: --> if not lst:
if lst != []: --> if lst:
if dct == {}: --> if not dct:
if dct != {}: --> if dct:
if ste == {}: --> if not ste:
if ste != {}: --> if ste:
GRUND: Leere Container ergeben "False" in booleschem Kontext
Gefüllte Container ergeben "True" in booleschem Kontext
{} ist kein set, sondern ein dict --> Datentyp unterschiedlich, nicht Wert!
* Defaultwert eines Funktions-Parameters ist ein mutable Objekt:
def funk(var=[]): ...
BESSER: def funk(var=None):
if var is None:
var = []
GRUND: Objekt [] wird nur 1x erzeugt bei Funktions-Definition
und bei jedem Aufruf ohne Parameter wiederverwendet,
d.h. Änderungen daran bleiben zw. Funktions-Aufrufen erhalten.
* Eigene Funktion liefert "None" als Ergebnis zurück (unabhängig vom Aufruf).
GRUND: "return" ohne Wert oder "return ERGEBNIS" am Funktions-Ende vergessen!
Dann findet automatisch ein "return None" am Funktions-Ende statt!
* Folgende Initialisierungen sind gefährlich:
a = b = {}
a = [[] * 10]
GRUND: Gleiches Dictionary- oder Listen-Objekt wird mehrfach verwendet
BESSER: (a, b) = ({}, {})
(a, b) = ([], [])
a = list(map(lambda x: [], range(10))
* Test auf Datentyp einer Variablen nicht so durchführen:
if type(var) == int:
if type(var) == int or type(var) == float:
if type(var) in (int, float):
sondern BESSER so:
if isinstance(var, int):
if isinstance(var, (int, float)):
GRUND: Vererbung bei "type()" NICHT berücksichtigt, bei "isinstance()" schon!
* Selber zählen und indizieren vermeiden:
arr = ["hallo", "welt", "hier", "bin", "ich"]
for i in range(len(arr)):
print("ELEM", arr[i])
GRUND: "Verzählen" möglich, Performance, Speicherersparnis, Iterator, ...
ZITAT: "In Python zählt man nicht selber, sondern lässt Python zählen."
(mit enumerate, zip, sum, min, max, any, all, ...)
* Mit Iteratoren oder Generatoren arbeiten,
anstatt Listen/Tupel/... zu verwenden
GRUND: Speicherersparnis, Performance
* Quellcode per "Copy-and-Paste" aus Webseiten/PDF/... kopieren ist gefährlich!
"Copy-and-Paste" von Code transferiert oft die EINRÜCKUNG nicht korrekt.
GRUND: Einrückung (Blockstruktur) geht (meist) verloren (teilweise oder
vollständig) und muss manuell korrigiert werden (es gibt keinen
Automatismus dafür, da die Einrückung Teil der Programm-Semantik ist)
GRUND: Leerzeichen/Tabulator falsch übertragen --> Andere Bedeutung möglich
--> Einrückung unbedingt Zeile für Zeile manuell überprüfen!
* "raise" vor FehlerKlasse vergessen:
AssertionError("Problem")
--> Anweisung wird ignoriert
* Raw- und Format-Strings falsch rum geschrieben zählen als normaler String:
"R..." # Korrekt: R"..."
"F..." # Korrekt: F"..."
* Es gibt 3 Funktionen zum Vergleich von REGEX mit String:
re.search() # Kein automatischer Anker
re.match() # Anker ^ automatisch vorne
re.fullmatch() # Anker ^ $ automatisch vorne + hinten
--> IMMER re.search und bei Bedarf die Anker ^ $ verwenden!
* Python verzögert Auswertungen möglichst lange:
print(range(10)) --> "range(10)"
--> Muss daher manchmal dazu gezwungen werden:
print(list(range(10))) --> "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
* Grenzen sind INKONSISTENT (obere Grenze erreicht oder nicht?):
range(10) --> 0..9 (10 Werte!)
range(1, 10) --> 1..9 ( 9 Werte)
var[0:10] --> var[0] .. var[9] (9 Elemente)
random.randint(1, 10) --> 1..10
TIP: Obere Grenze bei Range immer mit Addition/Subtraktion von 1 schreiben:
range(1, 10+1, 1) --> 1..10
range(10, 0-1, -1) --> 10..0
* Auf Wert "None" testen geht auf 2 Arten:
if var == None: # OK (un-pythonic)
if var is None: # OK + empfohlen (pythonic)
GRUND: Bedeutet das Gleiche (None ist SINGLETON, identisch mit Klasse)
* Datentyp "NoneType" gibt es ab Python 3.6 nicht mehr
--> Statt dessen type(None) verwenden falls notwendig
* Vergleich "==" statt Zuweisung "=" verwendet wird ohne Fehlermeldung ignoriert:
var == 123
GRUND: Wertet Vergleich aus und verwirft Ergebnis True/False.
--> Variablenwert bleibt gleich.
* Ausdrücke (Expressions) für sich ohne Zuweisung oder Funktions-Aufruf außenrum
werden ignoriert (sind aber kein Fehler).
"""docstring ...""" # Bewusst für mehrzeilige Kommentare + Docstrings benutzt
var == 123 # Vergleich (statt Zuweisung)
(1 + 2) * 3 ** 4 # Rechenausdruck (ohne Zuweisung)
AssertionError("...") # "raise" davor vergessen
* Walrus-Operator := ist keine Zuweisung, sondern ein Operator.
Verhält sich aber wie eine Zuweisung:
print(erg := 1 + 2 * 3 / 4) # OK: erg == 2.5
erg := 1 + 2 * 3 / 4 # FEHLER
(erg := 1 + 2 * 3 / 4) # OK
GRUND: Nur in geklammertem oder weiterverwendetem Rechenausdruck erlaubt!
* Zirkuläre Struktur ist möglich --> Entscheidung über Freigabe per Reference
Counting funktioniert nicht mehr --> Garbage Collector notwendig:
a = []
b = [a]
a.append(b)
print(a, b) --> [[[...]]] [[[...]]]
* Vergleich "==" und "!=" vergleicht die WERTE von 2 Objekten.
Vergleich "is" und "is not" vergleicht die IDENTITÄT von 2 Objekten.
(OBJ1 is OBJ2 ist ABKÜRZUNG für id(OBJ1) == id(OBJ2)
* Bei "==" muss der Datentyp der Gleiche sein, sonst kommt IMMER "False" heraus.
(außer bei Zahlen bool <-> int <-> float <-> complex <-> Decimal <-> Fraction)
True == 1 # --> True
False == 0 # --> True
123 == 123.0 # --> True
123 == (123.0+0j) # --> True
123.0 == (123.0+0j) # --> True
123 == "123" # --> False
(1, 2, 3) == [1, 2, 3] # --> False
0 == "0" # --> False
"" == () # --> False
[] == () # --> False
* Gleicher Typ + Wert --> Meist nur 1x angelegt und mehrfach referenziert
--> Objekt nicht nur gleich, sondern identisch
a = "abc"
b = "abc"
print(a, b, a == b, a is b) # --> abc abc True True
Aber nicht immer:
c = "ab"
c += "c"
print(a, c, a == c, a is c) # --> abc abc True False
* Gleiche ID heißt auch gleicher WERT!
Gleicher WERT heißt aber nicht unbedingt gleiche ID!
id(OBJ1) is id(OBJ2) # --> OBJ1 == OBJ2
s1 = "hallo welt" # --> s1 = "hallo welt"
s2 = "hallo" # --> s2 = "hallo"
s2 += " welt" # --> s2 = "hallo welt"
s1 == s2 # --> True
s1 is s2 # --> False
* Gleiche Speicherstelle wird evtl. nacheinander für 2 verschiedene Objekte
verwendet (wenn 1. Objekt nicht mehr referenzierbar ist und 2. Objekt den
gleichen Typ hat und genauso viel Speicher benötigt).
t = "hallo" i = 0; print("I", i, id(i))
print(t, id(t)) i += 1; print("I", i, id(i))
del t i += 1; print("I", i, id(i))
z = "zorro" i += 1; print("I", i, id(i))
print(z, id(z)) i += 1; print("I", i, id(i))
* Die Objekte -5 .. 256 sowie 0.0, 1.0, -1.0, True, False, None werden von
Python vorab beim Programmstart erzeugt (da oft benötigt).
--> Haben ungewöhnlich kleine + feste ID.
* Ganze Zahlen haben als ID ihren Wert.
var = 123456
print(var, id(var)) # --> 123 123
* Type Annotation/Hint wird in Python verglichen mit anderen Programmiersprachen
"verkehrt herum" geschrieben und mit einem ":" (Doppelpunkt) zwischen dem
Bezeichner und dem zugehörigem Datentyp getrennt:
var: int = 123
def funk(a: int, b: str, c: float) -> bool:
In C/C++ schreibt man den Typ "anders herum" und ohne ":" (Doppelpunkt)
int var = 123
bool funk(int a, str b, float c)
GRUND: Erst sehr spät hinzugefügt (ab Python 3.5)
* Type Annotation/Hint wird von Python nur akzeptiert, aber komplett ignoriert.
--> Erst von Tools wie "mypy", "pylint", ... werden die Datentypen überprüft.