©2012-2015 - Laurent Pointal Mémento v2.0.

5
License Creative Commons Attribution 4 Python 3 Cheat Sheet Latest English version on :
https://perso.limsi.fr/pointal/python:memento
integer, float, boolean, string, bytes Grund-Typen ◾ geordnete Folgen, schneller indizierter Zugriff, Werte wiederholbar Container Typen
int 783 0 -192 0b010 0o642 0xF3 list [1,5,9] ["x",11,8.9] ["mot"] []
null binär oktal hexadezimal tuple (1,5,9) 11,"y",7.4 ("mot",) ()
float 9.23 0.0 -1.7e-6
-6 Nicht veränderbare Werte (immutables) ☝ Ausdruck nur mit Kommas →tuple
bool True False ×10
""
str bytes (geordnete Folge von chars / bytes)
str "One\nTwo" Multiline string: b""
escaped new line """X\tY\tZ ◾ key Container, a priori ohne Ordnung, schneller key Zugriff, jeder key ist einmalig
'I\'m' 1\t2\t3""" dictionary dict {"key":"value"} dict(a=3,b=4,k="v") {}
escaped ' escaped tab (key/value Verknüpfungen){1:"one",3:"three",2:"two",3.14:"π"}
bytes b"toto\xfe\775" collection set {"key1","key2"} {1,9,3,0} set()
hexadezimal oktal ☝ unveränderbare ☝ keys=hashbare Werte (Grundtypen, unveränderbare…) frozenset unveränderbares set empty

Für Variablen, Funktionen, Identifizierer type(Ausdruck) Konvertierungen

Module, Klassen… Namen
int("15") → 15
int("3f",16) → 63 ganzzahlige Zahlenbasis kann im zweiten Parameter stehen
a…zA…Z_ gefolgt von a…zA…Z_0…9
◽ Sonderzeichen sind zu vermeiden int(15.56) → 15 schneide Nachkommastellen ab
◽ python-Schlüsselwörter sind verboten float("-11.24e8") → -1124000000.0
◽ GROß-/kleinschreibung spielt eine Rolle round(15.56,1)→ 15.6 runde auf eine Dezimale (0 Dezimalen → Ganzzahl)
☺ a toto x7 y_max BigOne bool(x)False für kein x, leeren Container x , None oder False x ; True für andere x
☹ 8y and for str(x)→ "…" Zeichenkette von x für die Anzeige (Formatierung im Hintergrund)
chr(64)→'@' ord('@')→64 code ↔ char
= Variablenzuweisung
repr(x)→ "…" Literal-Darstellung von x
☝ Zuweisung ⇔ Binden eines Namens an einen Wert
1) Auswertung des Wertes auf der rechten Seite bytes([72,9,64]) → b'H\t@'
2) Zuweisung zum linken Namen list("abc") → ['a','b','c']
x=1.2+8+sin(y) dict([(3,"three"),(1,"one")]) → {1:'one',3:'three'}
a=b=c=0 Zuweisung zum selben Wert set(["one","two"]) → {'one','two'}
y,z,r=9.2,-7.6,0 Mehrfache Zuweisung Trenner str und Folge von str → zusammengesetzter str
a,b=b,a Wertetausch ':'.join(['toto','12','pswd']) → 'toto:12:pswd'
a,*b=seq Entpacken einer Folge in str getrennt durch whitespaces → list von str
*a,b=seq Element und Liste "words with spaces".split() → ['words','with','spaces']
and str getrennt durch Separator str → list von str
x+=3 Inkrement ⇔ x=x+3 *=
x-=2 Dekrement ⇔ x=x-2 /= "1,4,8,2".split(",") → ['1','4','8','2']
x=None « undefniert » konstanter Wert %= Folge eines Typs → list eines anderen Typs (via comprehension list)
del x Entferne Name x aus dem Speicher … [int(x) for x in ('1','29','-3')] → [1,29,-3]
Für Listen, Tupel, Zeichenketten, bytes… Indizierung von Folgen und Containern
negativer Index -5 -4 -3 -2 -1 Anzahl der Elemente Individueller Zugriff auf Elemente via lst[index]
positiver Index 0 1 2 3 4 len(lst)→5 lst[0]→10 ⇒ erstes Element lst[1]→20
lst=[10, 20, 30, 40, 50] lst[-1]→50 ⇒ letztes Element lst[-2]→40
positiver slice 0 1 2 3 4 5 ☝ Index beginnt bei 0
Bei veränderbaren Folgen (list):
negativer slice -5 -4 -3 -2 -1 (hier von 0 bis 4)
Entfernen mit del lst[3] und
Zugriff auf Sub-Folgen via lst[start slice:end slice:Schrittweite] Verändern durch Zuweisung lst[4]=25
lst[:-1]→[10,20,30,40] lst[::-1]→[50,40,30,20,10] lst[1:3]→[20,30] lst[:3]→[10,20,30]
lst[1:-1]→[20,30,40] lst[::-2]→[50,30,10] lst[-3:-1]→[30,40] lst[3:]→[40,50]
lst[::2]→[10,30,50] lst[:]→[10,20,30,40,50] flache Kopie der Folge
Ohne angegebenen slice → von Anfang / bis zum Ende.
Bei veränderbaren Folgen (list): Entfernen mit del lst[3:5] und Verändern durch Zuweisung lst[1:4]=[15,25]

Boolesche Logik Ausdrucksblöcke Import von Modulen/Namen

module truc⇔file truc.py
Komparatoren: < > <= >= == != from monmod import nom1,nom2 as fct
(boolesche Resultate) ≤ ≥ = ≠ Eltern-Ausdruck: →direkter Zugriff auf Namen, umbenennen mit as
a and b Logisches Und Beide Befehlsblock 1… import monmod → Zugriff über monmod.nom1 …
gleichzeitig ⁝ ☝ Module und Pakete werden im python-Pfad gesucht (vgl. sys.path)
a or b Logisches Oder Eines oder Eltern-Ausdruck:
Einzug !

beide Befehlsblock wird nur ausgeführt Bedingte Ausführung

Befehlsblock 2… wenn eine Bedingung wahr ist.
☝ Falle : and und or geben einen Wert von ⁝ ja nein ja
a oder von b zurück (shortcut evaluation). if logische Bedingung: ? ?
⇒ stelle sicher, dass a und b boolesch sind. nein
not a Logisches Nicht
Nächster Befehl nach Block 1 Befehlsblock
Kann in Verbindung mit mehreren elif,
translated into German by M. Putzlocher 2016

True ☝ stelle den Editor so ein, dass er 4 elif... und nur einem finalen else benutzt
Wahr- und Falsch-Konstanten if age<=18:
False Leerzeichen anstelle eines Tabs macht. werden. Nur der Block mit der ersten state="Kid"
wahren Bedingung wird ausgeführt. elif age>65:
☝ Fließkommazahlen… ungefähre Werte Mathe
Winkel in Bogenmaß! ☝ mit einer Variablen x: state="Retired"
if bool(x)==True: ⇔ if x: else:
Operatoren: + - * / // % ** from math import sin,pi… state="Active"
× ÷ ab if bool(x)==False: ⇔ if not x:
Priorität (…) sin(pi/4)→0.707…
ganzzahlige ÷ ÷ Rest cos(2*pi/3)→-0.4999… Ausnahmen bei Fehlern
Einen Fehler signalisieren:
@ → Matrizen-× python3.5+numpy sqrt(81)→9.0 √ raise AusnKlasse(…) fehlerhafte
(1+5.3)*2→12.6 log(e**2)→2.0 Fehlerbehandlung : normale Ausführung
raise X() fehlerhafte
abs(-3.2)→3.2 ceil(12.5)→13 try: raise
round(3.57,1)→3.6 Ausführung Ausführung
floor(12.5)→12 Normaler Ausführungsblock
pow(4,3)→64.0 Module math, statistics, random, except AusnKlasse as e: ☝ finally startet den Block für die
☝ gewöhnliche Prioritäten decimal, fractions, numpy etc. (vgl. doc) Fehlerbehandlungsblock Endverarbeitung in allen Fällen.
☝ vermeide Endlosschleifen! Befehlsblock wird ausgeführt, Bedingte Schleifenanweisung Befehlsblock wird für jedes Iterative Schleifenanweisung
solange wie Bedingung wahr ist. Element eines Containers oder Iterators ausgeführt.
ja nächstes
while logische Bedingung: ? Schleifenkontrolle for var in Folge: …
nein Ende
Befehlsblock break direktes Verlassen Befehlsblock

☝ gute Angewohnheit : Ändere nicht die Schleifenvariable !

continue nächste Iteration
s = 0 Initialisierungen vor der Schleife ☝ else Block für Geht über die Werte einer Folge :
i = 1 Bedingung mit mindestens einem Variablenwert normales Beenden. s = "Ein Text" Initialisierungen vor der Schleife
(hier i) Algorithmus: cnt = 0
while i <= 100: i=100 Schleifenzähler, Zuweisung erfolgt durch for-Befehl
s = s + i**2 2 for c in s:
i = i + 1
print("sum:",s)
☝ verändere die Variable der Bedingung! s= i∑ if c == "e": Algorithmus:
Zähle die Anzahl
i=1 cnt = cnt + 1
print("gefunden",cnt,"'e'") der e in der
print("v=",3,"cm :",x,",",y+4) Anzeige Schleife über dict/set ⇔ Schleife über Folge der keys Zeichenkette s.
Nutze slices um über eine Sub-Folge zu iterieren.

Anzuzeigende Elemenge : Literalwerte, Variablen, Ausdrücke Schleife über die Indizes einer Folge :
print Optionen: ◽ Verändere Element beim Index.
◽ sep=" " Trennzeichen, Standard: Leerzeichen ◽ Greife auf benachbarte Elemente zu. (vor oder zurück)
lst = [11,18,9,12,23,4,17]
◽ end="\n" Ende der Anzeige, Standard: neue Zeile lost = []
◽ file=sys.stdout Ausgabe in Datei, Standard: standard out for idx in range(len(lst)): Algorithmus:
val = lst[idx] Begrenze Werte
s = input("Anweisungen:") Eingabe
if val > 15: größer als 15 auf 15,
☝ input liefert immer eine Zeichenkette zurück, konvertiere in den lost.append(val) rette verlorene Werte
nötigen Datentyp! (vgl. Konvertierungen auf der anderen Seite). lst[idx] = 15
print("modif:",lst,"-lost:",lost)
len(c)→ Anzahl Elemente Generische Operationen auf Containern Schleife gleichzeitig über Indizes und Werte einer Folge:
min(c) max(c) sum(c) Note: For dictionaries and sets, these for idx,val in enumerate(lst):
sorted(c)→ list sortierte Kopie operations use keys.
val in c → boolesch, Zugehörigkeitsoperator in (Fehlen: not in) range([Start,] Ende [,Schrittweite]) Ganzzahlige Folgen
enumerate(c)→ Iterator über (Index, Wert) ☝ Start normal 0, Ende nicht in Folge enthalten, Schrittweite normal 1
zip(c1,c2…)→ Iterator über Tupel, die ci Elemente beim gleichen Index haben
range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11
all(c)→ True wenn alle c Elemente zu wahr ausgewertet werden, sonst False range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10
any(c)→ True wenn mindestens ein Element von c als wahr ausgewertet wird, sonst False range(len(seq))→ Folge der Indizes der Werte in seq
Speziell für Container geordneter Folgen (Listen, Tupel, Zeichenketten, bytes…) ☝ range liefert eine unveränderbare Folge ganzer Zahlen, wie man sie braucht.
reversed(c)→ umgekehrter Iter. c*5→ vervielfachen c+c2→ zusammensetzen
c.index(val)→ Position c.count(val)→ Vorkommen zählen Name der Funktion (identifier) Definition von Funktionen
import copy benannte Parameter
copy.copy(c)→ flache Kopie des Containers def fct(x,y,z):
copy.deepcopy(c)→ tiefe Kopie des Containers fct
"""Dokumentation"""
☝ verändert die Original-Liste ! Operationen auf Listen # Befehlsblock, Berechnung von res, etc.
lst.append(val) füge Wert am Ende an return res Ergebnis des Funktionsaufrufs, wenn die
Funktion nichts zurückgibt: return None
lst.extend(seq) füge Folge von Elementen am Ende an ☝ Parameter und alle
lst.insert(idx,val) füge Element beim Index ein Variablen dieses Blocks existieren nur in diesem Block und während des
lst.remove(val) entferne erstes Element mit Wert val Funktionsaufrufs. (Denke an eine “black box”.)
lst.pop([idx])→Wert entferne & liefere Element bei idx (Standard: Letztes) Fortgeschritten: def fct(x,y,z,*args,a=3,b=5,**kwargs):
lst.sort() lst.reverse() sortiere / kehre Liste um vor Ort *args variable Anzahl von Argumenten (→tuple), Standardwerte,
**kwargs variable Anzahl benannter Argumente (→dict)
Operationen auf Dictionaries Operationen auf Mengen
d.clear() Operatoren: r = fct(3,i+2,2*i) Funktionsaufruf
d[key]=Wert Speicher des ein Argument pro
d[key]→ Wert del d[key] | → Vereinigung (vertikaler Balken) Rückgabewerts Parameter
ändere/ergänze & → Schnittmenge
d.update(d2) - ^ → Mengen-Differenz ☝ Das ist die Benutzung Fortgeschritten: fct() fct
d.keys() Verknüpfungen
< <= > >= → Einschließungsrelationen einer Funktion mit *sequence
d.values() →aufzählbare Ansichten Operatoren existieren auch als Methoden. Klammern (Aufruf). **dict
d.items() keys/Werte/Assoziationen
d.pop(key[,default])→ Wert s.update(s2) s.copy()
d.popitem()→ (key,Wert) s.add(key) s.remove(key) s.startswith(prefix[,start[,ende]])Zeichenketten-Operationen
d.get(key[,default])→ Wert s.discard(key) s.clear() s.endswith(suffix[,start[,ende]]) s.strip([Zeichen])
d.setdefault(key[,default])→Wert s.pop() s.count(sub[,start[,ende]])s.partition(sep)→ (vorher,sep,nachher)
s.index(sub[,start[,ende]]) s.find(sub[,start[,ende]])
Daten permanent auf Platte speichern und auslesen Dateien s.is…() prüft auf Zeichenkategorien (z.B. s.isalpha())
f = open("file.txt","w",encoding="utf8") s.upper() s.lower() s.title() s.swapcase()
s.casefold() s.capitalize() s.center([Breite,Füllzeichen])
Datei-Variable Name der Datei Öffnungsmodus Kodierung der s.ljust([Breite,Füllz.] s.rjust([Breite,Füllz.]) s.zfill([Breite])
für Operationen auf der Platte ◽ 'r' nur lesen (read) Zeichen für s.encode(Kodierung) s.split([sep]) s.join(Folge)
(+Pfad…) ◽ 'w' lesen&schreiben Textdateien:
◽ 'a' anfügen utf8 ascii Formatierungsanweisungen zu formatierende Werte Formatierung
vgl.Module os, os.path und pathlib ◽ …'+' 'x' 'b' 't' latin1 …
"Muster{} {} {}".format(x,y,r) str
schreiben ☝ Lese leere Zeichenkette am Ende der Datei lesen "{Auswahl:Formatierung!Umwandlung}"
f.write("coucou") f.read([n]) → nächste Zeichen
f.writelines(Liste von Zeilen) wenn n nicht festgelegt, lese bis zum Ende! ◽ Auswahl : "{:+2.3f}".format(45.72793)
f.readlines([n]) → list der nächste Zeilen 2 →'+45.728'
Beispiele

f.readline() → nächste Zeile nom "{1:>10s}".format(8,"toto")

☝ Standardmäßig Textmodus t (liest/schreibt str), möglich binärer 0.nom →' toto'
4[key] "{x!r}".format(x="I'm")
Modus b (liest/schreibt bytes). Konvertiere in den nötigen Typ! 0[2]
f.close() ☝ Vergiss nie, die Datei nach Nutzung zu schließen! →'"I\'m"'
◽ Formatierung :
f.flush() Schreibe den Cache f.truncate([Größe]) Größe ändern Füllzeichen Ausrichtung Vorzeichen min.Breite.Präzision~max.Breite Typ
Lesen/Schreiben erfolgt sequentiell in die Datei, änderbar mit:
<>^= + - space 0 am Anfang zum Auffüllen mit 0
f.tell()→aktuelle Position f.seek(Position[,Ursprung]) Ganze Zahl: b binär, c Zeichen, d Dezimale (std.), o oktal, x or X hexa…
Weit verbreitet: Öffnen mit einem geschützten with open(…) as f: Fließkomma: e or E Exponentiell, f or F Fixpunkt, g or G passend,
Block (automatisches Schließen) und for line in f : Zeichenkette: s … % Prozent
Leseschleife über die Zeilen einer Textdatei: # Bearbeitung der line ◽ Umwandlung : s (lesbarer Text) oder r (Literal-Repräsentation)