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

5
License Creative Commons Attribution 4 Python 3 Cheat Sheet Latest English version on :
[Link]
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 [Link]
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. [Link])
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=[Link] 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 [Link](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
[Link](val)→ Position [Link](val)→ Vorkommen zählen Name der Funktion (identifier) Definition von Funktionen
import copy benannte Parameter
[Link](c)→ flache Kopie des Containers def fct(x,y,z):
[Link](c)→ tiefe Kopie des Containers fct
"""Dokumentation"""
☝ verändert die Original-Liste ! Operationen auf Listen # Befehlsblock, Berechnung von res, etc.
[Link](val) füge Wert am Ende an return res Ergebnis des Funktionsaufrufs, wenn die
Funktion nichts zurückgibt: return None
[Link](seq) füge Folge von Elementen am Ende an ☝ Parameter und alle
[Link](idx,val) füge Element beim Index ein Variablen dieses Blocks existieren nur in diesem Block und während des
[Link](val) entferne erstes Element mit Wert val Funktionsaufrufs. (Denke an eine “black box”.)
[Link]([idx])→Wert entferne & liefere Element bei idx (Standard: Letztes) Fortgeschritten: def fct(x,y,z,*args,a=3,b=5,**kwargs):
[Link]() [Link]() 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
[Link]() 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
[Link](d2) - ^ → Mengen-Differenz ☝ Das ist die Benutzung Fortgeschritten: fct() fct
[Link]() Verknüpfungen
< <= > >= → Einschließungsrelationen einer Funktion mit *sequence
[Link]() →aufzählbare Ansichten Operatoren existieren auch als Methoden. Klammern (Aufruf). **dict
[Link]() keys/Werte/Assoziationen
[Link](key[,default])→ Wert [Link](s2) [Link]()
[Link]()→ (key,Wert) [Link](key) [Link](key) [Link](prefix[,start[,ende]])Zeichenketten-Operationen
[Link](key[,default])→ Wert [Link](key) [Link]() [Link](suffix[,start[,ende]]) [Link]([Zeichen])
[Link](key[,default])→Wert [Link]() [Link](sub[,start[,ende]])[Link](sep)→ (vorher,sep,nachher)
[Link](sub[,start[,ende]]) [Link](sub[,start[,ende]])
Daten permanent auf Platte speichern und auslesen Dateien [Link]…() prüft auf Zeichenkategorien (z.B. [Link]())
f = open("[Link]","w",encoding="utf8") [Link]() [Link]() [Link]() [Link]()
[Link]() [Link]() [Link]([Breite,Füllzeichen])
Datei-Variable Name der Datei Öffnungsmodus Kodierung der [Link]([Breite,Füllz.] [Link]([Breite,Füllz.]) [Link]([Breite])
für Operationen auf der Platte ◽ 'r' nur lesen (read) Zeichen für [Link](Kodierung) [Link]([sep]) [Link](Folge)
(+Pfad…) ◽ 'w' lesen&schreiben Textdateien:
◽ 'a' anfügen utf8 ascii Formatierungsanweisungen zu formatierende Werte Formatierung
[Link] os, [Link] und pathlib ◽ …'+' 'x' 'b' 't' latin1 …
"Muster{} {} {}".format(x,y,r) str
schreiben ☝ Lese leere Zeichenkette am Ende der Datei lesen "{Auswahl:Formatierung!Umwandlung}"
[Link]("coucou") [Link]([n]) → nächste Zeichen
[Link](Liste von Zeilen) wenn n nicht festgelegt, lese bis zum Ende! ◽ Auswahl : "{:+2.3f}".format(45.72793)
[Link]([n]) → list der nächste Zeilen 2 →'+45.728'
Beispiele

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

☝ Standardmäßig Textmodus t (liest/schreibt str), möglich binärer [Link] →' toto'
4[key] "{x!r}".format(x="I'm")
Modus b (liest/schreibt bytes). Konvertiere in den nötigen Typ! 0[2]
[Link]() ☝ Vergiss nie, die Datei nach Nutzung zu schließen! →'"I\'m"'
◽ Formatierung :
[Link]() Schreibe den Cache [Link]([Größe]) Größe ändern Füllzeichen Ausrichtung Vorzeichen [Link]äzision~[Link] Typ
Lesen/Schreiben erfolgt sequentiell in die Datei, änderbar mit:
<>^= + - space 0 am Anfang zum Auffüllen mit 0
[Link]()→aktuelle Position [Link](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)