Python 3 Cheat Sheet

(1)

Indizierung von Folgen und Containern Grund-Typen

Python 3 Cheat Sheet

License Creative Commons Attribution 4 Latest English version on :

https://perso.limsi.fr/pointal/python:memento

0

783 -192

int

9.23 0.0 -1.7e-6

float

True False

bool

"One\nTwo"

'I\'m'

str

"""X\tY\tZ 1\t2\t3"""

×10^-6

escaped tab escaped new line

Multiline string:

list

^[1,5,9] ["x",11,8.9] ["mot"] []

tuple

^(1,5,9) 11,"y",7.4 ("mot",) ()

dict

{1:"one",3:"three",2:"two",3.14:"π"}

{"key":"value"}

set

{}

{1,9,3,0}

◾ geordnete Folgen, schneller indizierter Zugriff, Werte wiederholbar

set()

◾ key Container, a priori ohne Ordnung, schneller key Zugriff, jeder key ist einmalig

{"key1","key2"}

Nicht veränderbare Werte (immutables)

Variablenzuweisung

x=1.2+8+sin(y) y,z,r=9.2,-7.6,0

a…zA…Z_ gefolgt von a…zA…Z_0…9

◽ Sonderzeichen sind zu vermeiden

◽ python-Schlüsselwörter sind verboten

◽ GROß-/kleinschreibung spielt eine Rolle

☝ Ausdruck nur mit Kommas →tuple

dictionary collection

integer, float, boolean, string, bytes

Identifizierer

☺

a toto x7 y_max BigOne

☹

8y and for

x+=3

x-=2

Inkrement ⇔ x=x+3 Dekrement ⇔ x=x-2

Konvertierungen

Für Listen, Tupel, Zeichenketten, bytes…

int("15") → 15

int("3f",16) → 63

ganzzahlige Zahlenbasis kann im zweiten Parameter stehen

int(15.56) → 15 schneide Nachkommastellen ab

float("-11.24e8") → -1124000000.0

round(15.56,1)→ 15.6 runde auf eine Dezimale (0 Dezimalen → Ganzzahl) bool(x)

False

für kein x , leeren Container x ,

None

oder

False

x ;

True für andere x

str(x)→ "…" Zeichenkette von x für die Anzeige (Formatierung im Hintergrund) chr(64) → '@' ord('@') → 64 code ↔ char

repr(x) → "…" Literal-Darstellung von x bytes([72,9,64]) → b'H\t@' list("abc") → ['a','b','c']

dict([(3,"three"),(1,"one")]) → {1:'one',3:'three'}

set(["one","two"]) → {'one','two'}

Trenner str und Folge von str → zusammengesetzter str

':'.join(['toto','12','pswd']) → 'toto:12:pswd' str getrennt durch whitespaces → list von str

"words with spaces".split() → ['words','with','spaces']

str getrennt durch Separator str → list von str

"1,4,8,2".split(",") → ['1','4','8','2']

Folge eines Typs → list eines anderen Typs (via comprehension list) [int(x) for x in ('1','29','-3')] → [1,29,-3]

type(Ausdruck)

lst=[10, 20, 30, 40, 50] ^lst[1]→20 _lst[-2] _→ ₄₀

0 1 2 3 4

-5 -4 -3 -2 -1 Individueller Zugriff auf Elemente via lst[index]

positiver Index negativer Index

0 1 2 3 4 5

-5 -4 -3 -2 -1

negativer slice positiver slice

Zugriff auf Sub-Folgen via lst[start slice:end slice:Schrittweite]

len(lst) → 5

lst[1:3]→[20,30]

lst[::2]→[10,30,50]

lst[-3:-1]→[30,40]

lst[:3]→[10,20,30]

lst[:-1]→[10,20,30,40]

lst[3:]→[40,50]

lst[1:-1]→[20,30,40]

lst[:]→[10,20,30,40,50]

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]

Bedingte Ausführung

if age<=18:

state="Kid"

elif age>65:

state="Retired"

else:

state="Active"

Boolesche Logik Ausdrucksblöcke

Eltern-Ausdruck :

Befehlsblock 1…

⁝

Eltern-Ausdruck:

Befehlsblock 2…

⁝

Nächster Befehl nach Block 1

Beide gleichzeitig

Einzug !

Komparatoren: < > <= >= == !=

≠

=

≥

≤

a and b a or b

not a

Logisches Und Logisches Oder

Logisches Nicht

Eines oder beide

if logische Bedingung : Befehlsblock

Befehlsblock wird nur ausgeführt wenn eine Bedingung wahr ist.

Kann in Verbindung mit mehreren elif, elif... und nur einem finalen else benutzt werden. Nur der Block mit der ersten wahren Bedingung wird ausgeführt.

lst[-1]→50 lst[0] → 10

⇒ letztes Element

⇒ erstes Element

x=None

« undefniert » konstanter Wert

Mathe Operatoren: + - * / // % **

× ÷

ganzzahlige ÷ ÷ Resta^b from math import sin,pi…

sin(pi/4)→0.707…

**cos(2*pi/3)→-0.4999…**

sqrt(81)→9.0 √ log(e2)→2.0 ceil(12.5)→13 floor(12.5)→12**

escaped '

☝ Fließkommazahlen… ungefähre Werte Winkel in Bogenmaß!

(1+5.3)*2→12.6 abs(-3.2)→3.2 round(3.57,1)→3.6 pow(4,3)→64.0 Für Variablen, Funktionen, Module, Klassen… Namen

Mémento v2.0.5

str

(geordnete Folge von chars / bytes)

(key/value Verknüpfungen)

☝ Falle : and und or geben einen Wert von a oder von b zurück (shortcut evaluation).

⇒ stelle sicher, dass a und b boolesch sind.

(boolesche Resultate)

a=b=c=0

Zuweisung zum selben Wert Mehrfache Zuweisung

a,b=b,a

Wertetausch

**a,*b=seq**

*a,b=seq

Entpacken einer Folge in Element und Liste

bytes

b"toto\xfe\775"

hexadezimal oktal

0b010 0o642 0xF3

binär oktal hexadezimal

""

empty dict(a=3,b=4,k="v")

Anzahl der Elemente

☝ keys=hashbare Werte (Grundtypen, unveränderbare…)

True

False Wahr- und Falsch-Konstanten ☝ stelle den Editor so ein, dass er 4 Leerzeichen anstelle eines Tabs macht.

lst[::-1]→[50,40,30,20,10]

lst[::-2]→[50,30,10]

1) Auswertung des Wertes auf der rechten Seite 2) Zuweisung zum linken Namen

=

☝ Zuweisung ⇔ Binden eines Namens an einen Wert

☝ unveränderbare

Bei veränderbaren Folgen (list):

Entfernen mit del lst[3] und Verändern durch Zuweisung lst[4]=25 del x Entferne Name x aus dem Speicher

b""

@ → Matrizen-× python3.5+numpy

☝ Index beginnt bei 0 (hier von 0 bis 4)

frozenset unveränderbares set

Priorität (…)

☝ gewöhnliche Prioritäten Module math, statistics, random, decimal, fractions, numpy etc. (vgl. doc)

Import von Modulen/Namen from monmod import nom1,nom2 as fct

module truc⇔file truc.py

→direkter Zugriff auf Namen, umbenennen mit as import monmod→ Zugriff über monmod.nom1 …

☝ Module und Pakete werden im python-Pfad gesucht (vgl. sys.path)

ja ? nein flache Kopie der Folge

ja ? nein and*=

/=

%=

…

☝ mit einer Variablen x:

if bool(x)==True: ⇔ if x:

if bool(x)==False:⇔ if not x:

raise AusnKlasse(…) Einen Fehler signalisieren:

Fehlerbehandlung : try:

Normaler Ausführungsblock except AusnKlasse as e:

Fehlerbehandlungsblock

normale Ausführung

fehlerhafte Ausführung fehlerhafte Ausführung^raise raise X()

null

☝ finally startet den Block für die Endverarbeitung in allen Fällen. translated into German by M. Putzlocher 2016

Container Typen

Ausnahmen bei Fehlern

(2)

"Muster{} {} {}".format(x,y,r)

"{Auswahl:Formatierung!Umwandlung}"

◽ Auswahl : 2 nom 0.nom 4[key]

0[2]

str Anzeige

print("v=",3,"cm :",x,",",y+4)

print Optionen:

◽ sep=" " Trennzeichen, Standard: Leerzeichen

◽ end="\n" Ende der Anzeige, Standard: neue Zeile

◽ file=sys.stdout Ausgabe in Datei, Standard: standard out Anzuzeigende Elemenge : Literalwerte, Variablen, Ausdrücke

Schleife über dict/set ⇔ Schleife über Folge der keys Nutze slices um über eine Sub-Folge zu iterieren.

Bedingte Schleifenanweisung Befehlsblock wird ausgeführt,

solange wie Bedingung wahr ist.

while logische Bedingung : Befehlsblock

s = 0 i = 1

while i <= 100:

s = s + i**2 i = i + 1 print("sum:",s)

Initialisierungen vor der Schleife

Bedingung mit mindestens einem Variablenwert (hier i)

☝ verändere die Variable der Bedingung!

Befehlsblock wird für jedes

Element eines Containers oder Iterators ausgeführt.

for var in Folge : Befehlsblock

s = "Ein Text"

cnt = 0 for c in s:

if c == "e":

cnt = cnt + 1 print("gefunden",cnt,"'e'") Geht über die Werte einer Folge :

Algorithmus:

Zähle die Anzahl der e in der Zeichenkette s.

Schleife über die Indizes einer Folge :

◽ Verändere Element beim Index.

◽ Greife auf benachbarte Elemente zu. (vor oder zurück) lst = [11,18,9,12,23,4,17]

lost = []

for idx in range(len(lst)):

val = lst[idx]

if val > 15:

lost.append(val) lst[idx] = 15

print("modif:",lst,"-lost:",lost) Algorithmus:

Begrenze Werte größer als 15 auf 15, rette verlorene Werte

☝ vermeide Endlosschleifen!

Initialisierungen vor der Schleife Schleifenzähler, Zuweisung erfolgt durch for-Befehl

Zeichenketten-Operationen

zu formatierende Werte Formatierungsanweisungen

Ganzzahlige Folgen

Dateien

s = input("Anweisungen:")

☝ input liefert immer eine Zeichenkette zurück, konvertiere in den nötigen Datentyp! (vgl. Konvertierungen auf der anderen Seite).

range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11 range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10 range(len(seq))→ Folge der Indizes der Werte in seq

☝range liefert eine unveränderbare Folge ganzer Zahlen, wie man sie braucht.

range([Start,] Ende [,Schrittweite])

f = open("file.txt","w",encoding="utf8")

Daten permanent auf Platte speichern und auslesen

Öffnungsmodus

◽ 'r' nur lesen (read)

◽ 'w' lesen&schreiben

◽ 'a' anfügen

◽ …'+' 'x' 'b' 't'

Kodierung der Zeichen für Textdateien:

utf8 ascii latin1 … Name der Datei

auf der Platte (+Pfad…) Datei-Variable

für Operationen

f.write("coucou")

f.writelines(Liste von Zeilen)

schreiben lesen

f.read([n]) → nächste Zeichen wenn n nicht festgelegt, lese bis zum Ende!

f.readlines([n]) → list der nächste Zeilen f.readline() → nächste Zeile

with open(…) as f:

for line in f : # Bearbeitung der line

vgl.Module os, os.path und pathlib

f.close()

☝ Vergiss nie, die Datei nach Nutzung zu schließen!

Weit verbreitet: Öffnen mit einem geschützten Block (automatisches Schließen) und Leseschleife über die Zeilen einer Textdatei:

Definition von Funktionen

def fct(x,y,z):

"""Dokumentation"""

# Befehlsblock, Berechnung von res, etc.

return res

Name der Funktion (identifier)

Ergebnis des Funktionsaufrufs, wenn die Funktion nichts zurückgibt: return None

☝ Parameter und alle

Variablen dieses Blocks existieren nur in diesem Block und während des Funktionsaufrufs. (Denke an eine “black box”.)

benannte Parameter

Funktionsaufruf

**r = fct(3,i+2,2*i)**

Generische Operationen auf Containern

☝ Lese leere Zeichenkette am Ende der Datei

len(c)→ Anzahl Elemente min(c) max(c) sum(c) sorted(c)→ list sortierte Kopie

val in c → boolesch, Zugehörigkeitsoperator in (Fehlen: not in) enumerate(c)→ Iterator über (Index, Wert)

zip(c1,c2…)→ Iterator über Tupel, die c_iElemente beim gleichen Index haben all(c)→ True wenn alle c Elemente zu wahr ausgewertet werden, sonst False any(c)→ True wenn mindestens ein Element von c als wahr ausgewertet wird, sonst False

☝ verändert die Original-Liste !

lst.append(val) füge Wert am Ende an

lst.extend(seq) füge Folge von Elementen am Ende an lst.insert(idx,val) füge Element beim Index ein

lst.remove(val) entferne erstes Element mit Wert val

lst.pop([idx])→Wert entferne & liefere Element bei idx (Standard: Letztes) lst.sort() lst.reverse() sortiere / kehre Liste um vor Ort

"{:+2.3f}".format(45.72793)

→'+45.728'

"{1:>10s}".format(8,"toto")

→' toto'

"{x!r}".format(x="I'm")

→'"I\'m"'

☝ Start normal 0, Ende nicht in Folge enthalten, Schrittweite normal 1

◽ Umwandlung : s (lesbarer Text) oder r (Literal-Repräsentation)

< > ^ = 0 am Anfang zum Auffüllen mit 0

Ganze Zahl: b binär, c Zeichen, d Dezimale (std.), o oktal, x or X hexa…

Fließkomma: e or E Exponentiell, f or F Fixpunkt, g or G passend,

Zeichenkette: s … % Prozent

◽ Formatierung :

Füllzeichen Ausrichtung Vorzeichen min.Breite.Präzision~max.Breite Typ + - space

Operationen auf Dictionaries

Operatoren:

| → Vereinigung (vertikaler Balken) & → Schnittmenge

- ^ → Mengen-Differenz

< <= > >= → Einschließungsrelationen Operatoren existieren auch als Methoden.

d.update(d2) ändere/ergänze Verknüpfungen

Note: For dictionaries and sets, these operations use keys.

Speziell für Container geordneter Folgen (Listen, Tupel, Zeichenketten, bytes…) reversed(c)→ umgekehrter Iter.c*5→ vervielfachenc+c2→ zusammensetzen c.index(val)→ Position c.count(val)→ Vorkommen zählen

Operationen auf Listen

d[key]=Wert d[key]→ Wert d.keys() d.values() d.items()

d.clear() del d[key]

→aufzählbare Ansichten keys/Werte/Assoziationen

Beispiele

d.pop(key[,default])→ Wert d.popitem()→ (key,Wert) d.get(key[,default])→ Wert d.setdefault(key[,default])→Wert

s.update(s2) s.copy() s.add(key) s.remove(key) s.discard(key) s.clear() s.pop()

Schleifenkontrolle

Schleife gleichzeitig über Indizes und Werte einer Folge:

for idx,val in enumerate(lst):

☝ gute Angewohnheit : Ändere nicht die Schleifenvariable !

Fortgeschritten: def fct(x,y,z,*args,a=3,b=5,**kwargs):

*args variable Anzahl von Argumenten (→tuple), Standardwerte,

**kwargs variable Anzahl benannter Argumente (→dict) ein Argument pro

Parameter Speicher des

Rückgabewerts Algorithmus:

f.flush() Schreibe den Cache

f.tell()→aktuelle PositionLesen/Schreiben erfolgt sequentiell in die Datei, änderbar mit:

f.seek(Position[,Ursprung]) f.truncate([Größe])Größe ändern

Formatierung Fortgeschritten:

*sequence

**dict

s.startswith(prefix[,start[,ende]])

s.endswith(suffix[,start[,ende]]) s.strip([Zeichen])

s.count(sub[,start[,ende]])s.partition(sep)→ (vorher,sep,nachher) s.index(sub[,start[,ende]]) s.find(sub[,start[,ende]])

s.is…() prüft auf Zeichenkategorien (z.B. s.isalpha()) s.upper() s.lower() s.title() s.swapcase() s.casefold() s.capitalize() s.center([Breite,Füllzeichen]) s.ljust([Breite,Füllz.] s.rjust([Breite,Füllz.]) s.zfill([Breite]) s.encode(Kodierung) s.split([sep]) s.join(Folge) ja ?

nein

nächstes Ende

…

Eingabe

import copy

copy.copy(c)→ flache Kopie des Containers copy.deepcopy(c)→ tiefe Kopie des Containers

☝ Das ist die Benutzung einer Funktion mit Klammern (Aufruf).

fct()

fct

☝ Standardmäßig Textmodus t (liest/schreibt str), möglich binärer Modus b (liest/schreibt bytes). Konvertiere in den nötigen Typ!

break direktes Verlassen continue nächste Iteration

☝ else Block für normales Beenden.

s = ∑

i=1 i=100

i

²

Iterative Schleifenanweisung

Operationen auf Mengen

Python 3 Cheat Sheet