Programmieren 3 Skript - Medieninformatik - Hochschule RheinMain

Programmieren 3 

Programmieren in C und Python 

Prof. Dr. Peter Barth 

Hochschule RheinMain 

Fachbereich Design Informatik Medien 

Medieninformatik 

29. Januar 2013 

Prof. Dr. Peter Barth (HS-RheinMain) Programmieren 3 29. Januar 2013 1 / 326

Organisatorisches 


Vorlesung 

• Dienstags, 10:00 – 11:30 Uhr, Raum 11 

Praktikum 

• Duchmann: Di R13: C ab 8:15 Uhr, B ab 11:45 Uhr 

• Barth: Mo R13: E ab 16:00 Uhr, Di R15: A ab 11:45 Uhr, 

Mi R15: D ab 16:00 Uhr 

Vorlesungsfolien, Übungsblätter, weitere Informationen 

• Read.MI 

• http://www.mi.hs-rm.de/˜barth/hsrm/prog3 

Bewertung 

• Prüfungsleistung, Klausur 70 % 

• Studienleistung, Praktikum 30 % 

• Online-Test C 

• Online-Test Python 



Bewertung Praktikum 

Erreichbar 

• Online-Test C 

• Online-Test Python 

• Bonus beide Tests > 3 Punkte 

Bestanden 

• Mindestens 6 Punkte 

• Bis 9 Punkte ausreichend 

Keine Wiederholung der Online-Tests 

21 Punkte 

9 Punkte 

9 Punkte 

3 Punkte 



Ziele der Veranstaltung 

Weitere Sprachparadigmen und Sprachebenen verwenden 

• Umgang mit anderen Arten von Programmiersprachen 

• Auswahl Sprache und Paradigmen entsprechend der Aufgabe 

• Sprachparadigmen imperativ, funktional und logisch 

• Programmierparadigmen wie nebenläufiges Programmieren/Threading 

• Sprachebenen höhere Abstraktion und maschinennah 

• Einsatz und Nutzen passender Bibliotheken 

Umgang mit praxisrelevanten Sprachen in typischer Umgebung 

• Maschinennahes Programmieren 

mit C 

• Höheres Programmieren/Skripten 

mit Python 



Maschinennahe Sprachen – C 

C, Ansi C 

• Maschinennahe Sprache 

• Systemnahe Programmierung 

• Erstellung von Bibliotheken 

• Eigene Speicherverwaltung 

• Spartanische, 

aber mächtige Entwicklungsumgebung 

Inhalt 

• Editor 

• Kommandozeilentools 

• Entwicklungsumgebung Kommandozeile 

• Datentypen, Kontrollstrukturen und Funktionen 

• Pointer und Speicherverwaltung 

• Zeichenkettenverarbeitung 



Ausdrucksstarke höhere Sprachen – Python 

Python 

• Skriptsprache 

• Anwendungsentwicklung 

• Einfach Quellcode zu erstellen, 

zu lesen, zu warten 

• Interaktiv, viele IDEs 

• Integration verschiedener Sprachparadigmen, 

Einsatz nach Bedarf/Eleganz 

• Imperativ 

• Objekt-orientiert 

• Funktional 

• Einsatz von Bibliotheken: GUI, reguläre Ausdrücke, . . . 

Inhalt 

• Eingebaute mächtige Datentypen und Kontrollstrukturen 

• Funktionales Programmieren und Generatoren 

• Module und Klassen 



Thread-Programmierung 

Nebenläufiges Programmieren / Thread-Programmierung 

• Mehrere Ausführungsstränge gleichzeitig 

innerhalb eines Prozesses eines Anwendungsprogramms 

• Zeit sinnvoll nutzen während IO-Operationen 

• Nutzen von Mehrkernumgebungen 

Inhalt 

• Thread-API 

• Phänomene und Vermeidung 

• Typische Patterns 

Wissen 1:1 für Java-Umgebung nutzbar 

• In Python/Jython 

• Python Thread API wie Java Thread API 

Thread 

Objekt 

Sperre 

Objekt 

Thread 



Literatur 

C 

• C als erste Programmiersprache, Dausmann, 

Bröckl, Goll[Online verfügbar] 

• Programmieren in C, (ANSI C), 

Brian W. Kernighan, Dennis M. Ritchie 

• http://openbook.galileocomputing.de 

Python 

/c_von_a_bis_z/ 

• http://www.python.org/doc 

• Einführung in Python, Mark Lutz und 

David Ascher, O’Reilly, 2. Auflage 

• Python Scripting for Computational Science, 

Langtangen, Springer 

Threading 

• Concurrent Programming in Java, Doug Lea 


Programmieren in C 

Einführung in C 

Die Programmiersprache C 

Seit 1971 für Systemprogrammierung 

Ziel 

• Entwicklung/Portierung von Betriebssystem (Unix, PDP-7, DEC) 

• Statt Assembler, aber Performance vergleichbar mit Assembler 

• Hardware-nah, aber doch plattformunabhängig 

• Maschinennah, aber strukturierte Programmierung unterstützen 

Historie 

71: Ritchie, C (Weiterentwicklung von B, BCPL), 

Portierung von Unix (nur 10 % Assembler, Rest C) 

78: Kernighan & Ritchie, “The C Programming Language” 

89: Standardisierung, ANSI-C (Sprache, Bibliotheken), 

Überarbeitung C90, heute weit verbreitet 

99: C99, Einflüsse C++, noch nicht weit verbreitet 

Verwendung 

• Systementwicklung, „portabler Assembler“ 

• Betriebssysteme (z.B. Unix, Linux), Tools (z.B. Shell, gtk) 

• Programmiersprachen (z.B. Java, Python, ...) 




Verbreitung von C 

Weltweit ist C die meist verwendete Programmiersprache 

The C Programming Language 

• Klassisches Buch 

• Übersetzt in sehr viele Sprachen 

• http://cm.bell-labs.com/ 

cm/cs/cbook/index.html 

Programming Language Index 

• Juli 2012 wieder die meist 

verwendete Sprache 

• http://www.tiobe.com/ 

index.php/content/ 

paperinfo/ 

tpci/index.html 




Eigenschaften von C 

Imperativ, hardwarenah und plattformunabhängig 

C is declining somewhat in usage compared to C++, and maybe 

Java, but perhaps even more compared to higher-level scripting 

languages. It’s still fairly strong for the basic system-type things. 

Dennis Ritchie 

Imperative/Prozedurale Sprache 

• Typen, Variablen, Kontrollstrukturen, Funktionen 

• Zeiger und Bitoperationen in Sprache integriert, maschinennah 

• Kleiner Sprachkern, aber viele Operatoren 

• Keine Objektorientierung 

(C++ als C-Erweiterung mit OO-Konzepten) 

Getrennte Übersetzung 

• Übersetzung von Quelldateien in Objektdateien 

• Linken der Objektdateien zu ausführbarem Programm 

• Kein Modulkonzept, textueller Präprozessor 

Plattformunabhängig 

• Auf fast jeder Hardware verfügbar 

• Programme laufen auf jeder Hardware auf der C läuft, 

zumindest wenn man entsprechend programmiert 




Erstes Beispiel 

“Hello World” in C 

• Syntax ähnlich zu Java 

• Eigentlich umgekehrt 

1 Kommentare 

• Von /* und */ umschlossen 

• Nicht verschachtelt 

• Mehrere Zeilen möglich 

2 Makros 

• Kein Modulkonzept 

• Andere Dateien werden inkludiert, 

(Inhalt an die Stelle “kopieren”) 

• Makroanweisungen mit #... 

3 Whitespaces nicht relevant 

4 Funktionsdefinitionen 

• Eine Hauptfunktion je Programm 

• Name ist immer main 

1 /* the one and only */ 

2 #include 

3 

4 int main(void) { 

5 printf("Hello C World\n"); 

6 return 0; 

7 } 

5 Funktionsaufrufe 

• printf, in stdio.h deklariert 

• Mit einem Parameter 

6 Rückgabewert 

• Hauptfunktion gibt immer einen 

Integer-Wert zurück 

7 Ende der Funktion 

• Einrückregeln wie in Java erlaubt, 

andere möglich 




Übersetzen und Starten 

Separate Übersetzung in eine ausführbare Datei 

Datei hello.c mit Editor erstellen 

• Emacs oder vi empfohlen 

• Geany oder auch IDE möglich 

Übersetzen mit C-Compiler 

• (g)cc, (GNU) C Compiler 

• Erzeugt ausführbares Programm, 

Datei a.out 

Compiler-Optionen -g -ansi -Wall -o 

• Debug, ANSI-Standard, Warnung 

• Ausgabedatei ist hello 

Ausführen 

• Aufruf Name erzeugter Datei 

• Auf Kommandozeile 

• ./ davor wenn . nicht im Pfad 

$ ls -l hello.c 

-rwx------ 1 pb pb 80 

30. Aug 13:33 hello.c 

$ gcc hello.c 

$ ls -al a.out 

-rwx------ 1 pb pb 4699 

30. Aug 13:46 a.out 

$ ./a.out 

Hello C World 

$ gcc -g -ansi -Wall hello.c -o hello 

$ ls -l ./hello 

-rwx------ 1 pb pb 5871 

30. Aug 13:47 ./hello 

$ ./hello 

Hello C World 




Übersetzungsprozess 

Was passiert bei der Übersetzung im Detail 

Präprozessor 

• Fügt Quelltexte/Include-Dateien ein, Konvention 

Endung .h (Header), sucht Dateien in bestimmten 

Verzeichnissen /usr/include/..., 

• Textuelle Ersetzungen 

C-Compiler 

• Übersetzt C-Quellcode in hardwarespezifische 

Assemblersprache 

• Optimierungen 

Assembler 

• Übersetzt Assembler in Maschinensprache 

Linker 

• Bindet externen Objektcode ein (z.B. printf), sucht 

Bibliotheken in bestimmten Verzeichnissen 

/usr/lib/..., 

hello.c 

gcc hello.c -o hello 

Präprozessor 

C-Compiler 

Assembler 

Linker 

hello 




Makefiles 

Automatisierung des Übersetzungsprozesses ... 

Variablen 

1 Definition: CC=gcc 

• Verwendung mit $(CC) 

• Variablennamen per Konvention 

GROßBUCHSTABEN 

Regeln 

4 Ziel hello und Abhängigkeit hello.c 

• Um Ziel zu machen, schaue ob 

Abhängigkeit neuer ist als hello, wenn 

ja dann mache 

5 Führe Befehl (mit Ersetzungen) aus 

Verwenden auf Kommandozeile 

• Auf Kommandozeile make 

• Ziel als Parameter möglich 

Makefile 

1 CC=gcc 

2 CFLAGS=-ansi -g -Wall 

3 

4 hello: hello.c 

5 $(CC) $(CFLAGS) hello.c -o hello 

$ make 

gcc -ansi -Wall hello.c -o hello 

$ ./hello 

Hello C World 




Makefiles 

... etwas ausführlicheres Beispiel, Details im Informationsblatt 

Ziel all 

• Erstes Ziel ist Default-Ziel 

• Konvention all 

Trennen Compile/Link 

• Erst Objekt-Datei mit -c 

• Dann Binden/Linken 

Beispiel 

• Mache rot13 falls rot13.o neuer 

• Mache rot13.o falls rot13.c ... 

Ziel clean 

• Konvention, zum Löschen aller 

erzeugten Dateien 

• Ohne Abhängigkeit (Datei clean nicht 

vorhanden), immer ausführen 

Makefile 

1 CC=gcc 

2 CFLAGS=-ansi -g -Wall 

3 

4 all: hello rot13 

5 

6 hello: hello.c 

7 $(CC) $(CFLAGS) hello.c -o hello 

8 

9 rot13.o: rot13.c 

10 $(CC) -c $(CFLAGS) rot13.c -o rot13.o 

11 

12 rot13: rot13.o 

13 $(CC) $(CFLAGS) rot13.o -o rot13 

14 

15 clean: 

16 # - vor Befehl, ignoriere Fehlschlag 

17 -/bin/rm -f hello rot13 rot13.o 




Java versus C 

Objektorientiert 

Java 

Automatische Speicherverwaltung 

Ausnahmen 

Aussagekräftige Fehlermeldungen zu 

Laufzeit: Zum Beispiel IndexOutOf- 

Bounds, NullPointer 

Plattformunabhängige auf JVM ausführbare 

Dateien 

Getrennte Übersetzungseinheiten, 

klassenbasiert 

Namensräume 

String-Typ eingebaut 

C 

Prozedural, imperativ 

Manuelle Speicherverwaltung 

keine Ausnahmen, Konvention Fehler- 

Codes 

Keine Laufzeitfehlermeldungen: Abbruch 

durch Betriebssystem oder undefiniertes 

Verhalten 

Plattformabhängige 

Dateien 

Getrennte 

dateibasiert 

Keine Namensräume 

ausführbare 

Übersetzungseinheiten, 

Kein eingebauter String-Typ, Konvention 

char-Felder 



Variablen und Datentypen 

Variablen und Grundtypen 

Variablen und Grundtypen fast wie in Java 

Lokale Variablen 

• Deklaration (oder Vereinbarung) am 

Anfang der Funktion 

• Viele Compiler erlauben die 

Deklaration an beliebiger Stelle, wie in 

Java. Erst ab C99 erlaubt, vermeiden. 

• Erst Typname dann Variablenname 

4 Initialisierung möglich 

5 Mehrfachvereinbarung möglich 

Ausgabe mit printf 

• Konvention wie System.out.format 

1 #include 

2 


4 int i = 3; 

5 int j, k; 

6 double x = 3; 

7 j = 4; 

8 printf("%d\n", i+j); 

9 printf("%f\n", x*3.3); 

10 return 0; 

11 } 

• Dokumentation mit man 3 printf 

7 

9.900000 




Nicht initialisierte lokale Variablen 

Nicht initialisierte lokale Variablen haben undefinierten Wert 

Nicht initialisierte lokale Variablen 

• Deklarierbar und verwendbar 

• “Undefinierter” (beliebiger) Wert 

in der Variablen k 

Compiler/Laufzeit 

• Warnung nur bei höchster 

Warnstufe 

• Ausführung möglich 

• Undefiniertes Verhalten 

Variablen immer mit Wert initialisieren! 

1 #include 


3 int j, k; 

4 j = 4; 

5 printf("%d\n%d\n", j, j+k); 

6 return 0; 

7 } 

$ gcc -Wall ./nichtinit.c -o nichtinit 

./nichtinit.c: In Funktion "main": 

./nichtinit.c:9:9: Warnung: "k" wird in 

Funktion uninitialisiert verwendet 

$ ./nichtinit 

4 

134513308 




Globale und lokale Variablen 

Globale Variablen leben immer und werden initialisiert 

Globale/Externe Variablen 

• Außerhalb von Funktionen definiert 

• Können initialisiert werden 

• Wenn nicht explizit initialisiert, werden 

sie implizit mit 0 initialisiert 

• In allen Funktionen global verfügbar 

• In Java nicht vorhanden 

Lokale Variablen 

• Lebensdauer der Funktion nur 

innerhalb eines Blocks 

• Innere Variable gleichen Namens 

überdeckt äußere 

• Wie in Java 

• Ohne Initialisierung beliebiger Wert 

1 #include 

2 int i=3; 

3 int j,k; 


5 j = 4; 

6 printf("%d\n%d\n", j, j+k); 

7 { int lokal=3; 

8 printf("%d\n", lokal); } 

9 /* lokal nicht mehr vereinbart */ 

10 return 0; 

11 } 

4 

4 

3 




Grundtypen – Ganze Zahlen 

Typen 

• char, short, int, long 

• Alternativen: short int statt short, 

long int statt long 

Vorzeichen 

• Vorsatz unsigned oder signed, 

Vorgabe ist signed 

• char kann auch unsigned sein, 

implementierungsabhängig 

Angabe von Werten 

• Zusatz mit U für unsigned und 

L für long 

• Automatisch konvertiert 

1 #include 


3 char c = 17; 

4 short s = 300; 

5 int i = 66666; 

6 long l = 66666L; 

7 return 0; 

8 } 




Grundtypen – Ganze Zahlen, Größen 

Größen-Hierarchie 

• char genau 1 Byte groß 

• char



Rechnen mit Zahlen 

Ausdrücke 

• Operatoren, Präzedenzen, . . . , 

wie von Java gewöhnt 

• Modulo-Arithmetik, Zweierkomplement 

Typkonversion 

• Automatische Konversion aller Werte zu 

mindestens int 

• Konvertiere danach erst zu Zieltyp 

Besonderheit Zuweisung 

• Zuweisung ist Ausdruck, Wert ist Wert der rechten 

Seite 

• = ist rechtsassoziativ 

c1 = c2 = 222 entspricht c1 = (c2 = 222) 

1 #include 


3 unsigned char c1, c2; 

4 short s; 

5 c1 = c2 = 222; 

6 s = c1 + c2; 

7 printf("%d\n", s); 

8 /* Ausgabe 444 */ 

9 } 




Gleitkommazahlen 

Gleitkommanzahlen, Fließpunktzahlen 

• float und double als Datentypen wie 

in Java 

• zusätzlich long double 

• float



Zeichen 

Datentyp char 

• Ganzzahliger Datentyp 

• Steht meist für ein Zeichen 

• Meist (trotzdem) signed, 


• Genau ein Byte groß 

• Kleinster Datentyp in C 

Verwendung 

• Ganze Zahlen oder Zeichen 

• Zeichen sind ganze Zahlen 

• Entsprechung ’A’== 65 abhängig 

von Umgebung/Compiler 

1 #include 


3 char c0 = ’A’; 

4 char c1 = 65; 

5 

6 printf("%c, %c\n", c0, c1); 

7 printf("%d, %d\n", c0, c1); 

8 printf("%d\n", ’A’*’B’); 

9 

10 return 0; 

11 } 

A, A 

65, 65 

4290 




Kein Boolean, sondern ganze Zahlen 

Kein Boolean in C 

• ab C99 _Bool 

Ganze Zahlen als Boolescher Ausdruck 

• Jede ganze Zahl kann als Boolean 

interpretiert werden 

• Auch Ausdrücke möglich 

• 0 ist falsch, 

ungleich 0 ist wahr 

Boolesche Ausdrücke evaluieren zu 

Zahlen 

• Boolesche Ausdrücke (Operatoren) 

• Evaluieren zu 

0 (falsch) oder 1 (wahr) 

1 #include 


3 int zahl = 2; 

4 if (1) 

5 printf("ja1\n"); 

6 if (zahl) 


8 if (zahl-2) 


10 printf("%d\n", zahl == 2); 

11 return 0; 

12 } 

ja1 

ja2 

1 




Aufzählungstypen 

Aufzählung mit enum 

• Definition von Konstanten 

• Kompatibel zu Typ int 

• Durch Komma getrennt 

• Optional mit Initialisierung 

• Dürfen überall auftauchen wo 

Konstanten erwartet werden 

(z.B. case in switch-Konstrukt) 

Initialisierung 

• Erste Konstante 0, wenn nicht 

initialisiert 

• Nächste Konstante immer um 1 höher, 

wenn nicht initialisiert 

Achtung: Nicht typsicher, kein 

Wertebereichs-Check 

1 #include 

2 enum skat { karo=9, herz, pik, kreuz }; 

3 enum farbe { rot, gruen=17, blau }; 

4 


6 enum skat blatt = karo; 

7 printf("karo=%d, herz=%d, " 

8 "pik=%d, kreuz=%d\n", 

9 karo, herz, pik, kreuz); 

10 printf("rot=%d, gruen=%d, blau=%d\n", 

11 rot, gruen, blau); 

12 blatt = 42; /* kein Check*/ 

13 return 0; 

14 } 

karo=9, herz=10, pik=11, kreuz=12 

rot=0, gruen=17, blau=18 



Bitoperationen 

Mengen mit Bitoperationen – Definition 

Beispiel für Aufzählungstypen 

Idee – Interpretiere Zahlen als Bitfeld 

• Shift-Operationen um mit 1



Mengen mit Bitoperationen – Verwendung 

Beispiel für Aufzählungstypen 

Beispiel 

• Scheine von Rudi und Susi ausgeben 

• Susi und Rudi haben von den 

möglichen fünf Scheine 

• Von denen ist nur einer der Gleiche 

• Susi fehlen noch zwei Scheine 

Kein Wertebereichs-Check 

• Susi |= 0xFFFFFF 

• Wäre ok 

• Keine Überprüfung ob Wert einer der 

Werte des Aufzählungstyps ist 


2 enum Scheine Susi = 

3 Prog1 | Prog2 | Theo; 

4 int Rudi = Prog1 | Prog3 | ADS; 

5 

6 printschein(Susi); 

7 printschein(Rudi); 

8 printschein(Susi|Rudi); 

9 printschein(Susi&Rudi); 

10 printschein(~Susi); 

11 return 0; 

12 } 

Prog1 Prog2 Theo 

Prog1 Prog3 ADS 

Prog1 Prog2 Prog3 ADS Theo 

Prog1 

Prog3 ADS 




Variablen Definition und Deklaration 

Variablen Definition 

• Legt Typ fest 

• Reserviert Speicherplatz 

• Darf nur einmal vorkommen 

• Syntax wie gewohnt, 

global und lokal 

Variablen Deklaration 

• Legt Typ fest 

• Darf mehrmals vorkommen 

• Schlüsselwort extern davor, 

muss global sein 

Definition = Deklaration + Speicherplatz 

1 extern int exta; /* Deklaration */ 


3 return exta; 

4 } 

5 /* Fehler, exta nicht definiert */ 



3 

4 int exta = 3; /* Definition */ 

5 

6 /* int exta = 3; Fehler Redefinition */ 

7 




11 /* int exta; lokal nicht erlaubt */ 

12 } 




Typ-Attribute – konstant 

Konstantenvereinbarung 

• Schlüsselwert const 

• Wert darf nicht verändert werden 

• Definition ohne Wert möglich (leider), 

Vorgabewert ist 0 

• extern möglich, muss dann später als 

const definiert werden 

Verwendung von const im Parametertyp 

• Wert darf dann in Funktion nicht 

verändert werden 

• Da Werte kopiert werden, sind 

Änderungen an z.B. einem int 

sowieso nur lokal 

#define nicht verwenden 

• Nicht typsicher, nicht Teil von C 

1 #define PI 3.14 /* boese */ 

2 

3 const double pi = 3.14; 

4 

5 const int len=7+3; 

6 

7 extern const int c; 

8 const int c=3; 

9 

10 int f(void) { 

11 /* c = 4; Fehler */ 

12 return c; 

13 } 

14 

15 int f2(const int i) { 

16 /* i = 4; Fehler */ 

17 return i; 

18 } 




Typ-Attribute – const statt #define 

Präprozessor #define 

• Textersetzung, Text nach ersten 

Whitespaces durch Text nach zweiten 

Whitespaces 

• Keine Ersetzung in Zeichenketten und 

innerhalb von Bezeichnern 

• Alter Stil, als es const noch nicht gab 

• Nicht typsicher, tückisch, vermeiden 

Konstanten mit const 

• Definition einer Variablen mit 

konstantem Inhalt 

• Typsicher, Klar, verwenden 

enum für int-Konstanten 

• Wenn const nicht geht (z.B. 

Feldgrenzen), dann enum verwenden 

1 #include 

2 

3 #define PI 3.14 

4 const double pi = 3.14; 

5 

6 double umfangc(double radius) { 

7 return 2*pi*radius; 

8 } 

9 double umfangd(double radius) { 

10 return 2*PI*radius; 

11 } 

12 

13 #define LEN 7+3 

14 const int len=7+3; 

15 


17 printf("%3d\n", LEN*3); /* 16 */ 

18 printf("%3d\n", len*3); /* 30 */ 

19 return 0; 

20 } 




Typ-Attribute – volatil 

Variable ändert sich “von außen” 

• Variable kann sich ohne Einwirkung 

des laufenden Programms ändern 

• Beispiel: Treiber für eine Hardware, 

die Ihren Zustand nicht auf Grund von 

Programmabläufen ändert 

• Gewünschtes Verhalten: 

• Compiler soll keine Optimierungen 

(Eliminiation aus Ausdrücken, 

Umordnung von Code) vornehmen 

• Wert muss jedesmal aus 

Speicherbereich gelesen werden 

volatil-Vereinbarung 

• Schlüsselwort volatile 

1 #include 

2 


4 volatile int x=3; 

5 int i, s=0; 

6 for (i=0; i < 1000; i+=1) { 

7 /* x wird immer hier neu gelesen */ 

8 s += x*i; 

9 } 

10 return 0; 

11 } 



Eingabe und Ausgabe 

Ausgabe 

printf 

• Gibt 1. Parameter auf Standardausgabe aus 

Aufeinanderfolgende Strings werden zu einem 

zusammengefasst – vermeiden 

• Ersetzt alle %-Konstrukte in 1. Parameter durch 

jeweils nächsten Wert in den weiteren Parametern 

• Wie System.out.format, beliebig viele Parameter 

sprintf 

• Zusätzlicher 1. Parameter 

• In diesen String (1. Parameter) wird geschrieben statt 

Ausgabe nach stdout 

• Achtung: String muss lang genug sein 

putchar 

• Gibt Paramter (int nicht char) auf stdout aus 

• Erlaubt Ausgabe von Steuerzeichen (EOF, . . . ) 

1 #include 


3 int d=42; 

4 char c=’a’; 

5 double g=3.14; 

6 printf( 

7 "int: %d\n" 

8 "char: %c\n" 

9 "double: %e\n", 

10 d, c, g); 

11 return 0; 

12 } 

int: 42 

char: a 

double: 3.140000e+00 




Eingabe 

scanf 

• Liest Zeichen von der Standardeingabe 

• Wie in 1. Parameter verlangt 

• Im Beispiel ist das Leerzeichen in der Eingabe wichtig 

• Bei %-Konstrukten wird entsprechender Wert erzeugt 

• Wert wird an die Adresse der Variablen (Notation mit 

&-Zeichen) gespeichert 

• Rückgabewert ist die Anzahl der erfolgreich 

eingelesenen Werte 

• Bei Fehlern geht es undefiniert weiter 

sscanf 

• Neuer erster Parameter, der Eingabestring 

• Eingabestring statt Lesen von stdin 

1 #include 

2 


4 int d; 

5 char c; 

6 double g; 

7 scanf("%d %c %lg", 

8 &d, &c, &g); 

9 printf("int: %d\n" 

10 "char: %c\n" 

11 "double:%e\n", 

12 d, c, g); 

13 return 0; 

14 } 

>> 42 a 3.14 



Eingabe zeichenweise 

getchar 

• Ein Zeichen von stdin lesen 

• Wert ist Zeichen als int 

• Steuerzeichen möglich, zum Beispiel 

EOF am Ende einer Datei oder der 

Eingabe 

Beispiel: Eingabe auf Ausgabe kopieren 

• Zeichenweises einlesen von der 

Standardeingabe bis 

Dateiendezeichen (CTRL-D) 

• Zuweisung in Test, typisches Idiom 

1 #include 

2 

3 int main() { 

4 int c; 

5 while ((c = getchar()) != EOF) { 

6 putchar(c); 

7 } 

8 return 0; 

9 } 

• putchar als Gegenstück zu getchar 

• getc zur Angabe eines 

Eingabe-Stroms 




%-Konstrukte 

%-Konstrukte für ganze Zahlen 

• char: %c, int: %d, %i 

• unsigned int: %u dezimal, %o oktal, 

%x hexadezimal 

• long int: %ld, %li, 

short int: %hd, %hi 

%-Konstrukte Gleitkommenzahlen 

• float: %f(x.xx), %e(x.xxEyy), %g 

double: %lf(x.xx), %le(x.xxEyy), %lg 

• Modifier l nur bei Eingabe relevant, 

Ausgabe wird immer erst mindestens 

double 

Dokumentation 

• Mit man printf, man scanf 

• Gewöhnen Sie sich an man 

1 #include 

2 int main() { 

3 unsigned int d = 17; 

4 double f = 3.14; 

5 

6 printf("%%u: %u, %%o: %o, %%x: %x\n", 

7 d, d, d); 

8 printf("%%f: %f, %%e: %e, %%g: %g\n", 

9 f, f, f); 

10 f = 1.000000000000001; 

11 printf("%20.20f\n%20.20f\n", 

12 f, (float) f); 

13 return 0; 

14 } 

%u: 17, %o: 21, %x: 11 

%f: 3.140000, %e: 3.140000e+00, %g: 3.14 

1.00000000000000111022 

1.00000000000000000000 



Kontrollstrukturen 

Kontrollstrukturen wie in Java 

Bedingungen 

• Beliebige arithmetische Ausdrücke 

• Logische Operatoren geben 0 oder 1 

zurück 

Verzweigung 

• wie gewohnt 

• if, else, switch, break 

Schleifen 

• while, do while, break, continue 

• for 

anfang 0 

anfang 1 

anfang 0 

• Keine Variablenbelegung in for 

• Erlaubt ab C99 

1 #include 


3 int i; 

4 for (i=0; i < 3; i++) { 

5 int j=2, k=0; 

6 while (j) 

7 j--; 

8 j = 1


Funktionen 

Funktionen 

Funktionsdefinition ähnlich zu Java 

• Auf oberster Ebene 

• Nicht geschachtelt 

Parameter 

• Parameter werden als Werte 

übergeben (call by value) 

• Keine Parameter mit (void) 

• Nur () veraltet, vermeiden 

• Beliebig viele Parameter mit (...) 

• prinf ist so definiert 

• Wird nicht weiter behandelt 

• Überladen ist nicht möglich 

Rückgabewert 

• Typ angeben (Vorgabe int, veraltet) 

• void für kein Rückgabewert 

1 #include 

2 

3 int f(void) { 

4 return 0; 

5 } 

6 

7 int inc(int i) { 

8 return i+1; 

9 } 

10 

11 int summiere(int i0, int i1) { 

12 return i0 + i1; 

13 } 

14 


16 int i = inc(3); 

17 return summiere(i, -i); 

18 } 



Funktionen 

Funktionsprototypen 

Problem – Benutzung vor Definition 

• Funktion wird verwendet, bevor sie definiert wurde 

• Andere Reihenfolge ist keine Lösung bei 

verschränkter Rekursion (odd, even) 

Lösung – Funktionsprototypen 

• Kopf der Funktion, Zeile 3 

• Ohne definierenden Block, mit Semikolon, 

Parameternamen dürfen fehlen 

• Funktion wird deklariert, noch nicht definiert 

• Angabe von extern davor erlaubt 

• extern int even(short int i); 

• Bekanntgabe des Rückgabewerts und des Typs des 

Parameters 

• Ohne Prototypen im Beispiel Übersetzungsfehler 

• Schlimmer wäre implizite Deklaration 

int even(); 

1 #include 

2 

3 int even(short int i); 

4 int odd(short int i) { 

5 if (i == 0) 

6 return 0; 

7 return even(i-1); 

8 } 

9 int even(short int i) { 

10 if (i == 0) 

11 return 1; 

12 return odd(i-1); 

13 } 

14 


16 short int i = 17; 

17 printf("%d ist %s\n", i, 

18 odd(i) ? "odd" : "even"); 

19 return 0; 

20 } 



Felder 

Felder 

Feld 

• Speicherbereich mit mehreren gleich 

großen Elementen eines Typs 

• Zusammenhängender 

Speicherbereich 

Felder anlegen 

• Definition mit 

[] 

• Die Länge des Felds ist ein konstanter 

Ganzzahlausdruck, Angabe mit 

enum-Wert erlaubt 

• Ab C99 darf Länge eine Variable sein 

• In GCC erlaubt, nicht verwenden 

• Index von 0 bis -1 

Beispiel: 10 int Werte 

int a[10]; 

0 1 2 3 4 5 6 7 8 9 

enum { G=10 }; 

... 

int a[G]; 



Felder 

Feldgröße 

Größe des Felds 

• Anzahl der Elemente mal Größe je 

Element 

• Gesamtgröße außerhalb des Blocks 

der Definition nicht verfügbar 

Beispiel 

• im Gegensatz zu Java 

• 10 Mal ein int der Größe 4, 

also 40 Byte 

• Bei Funktion f mit Feld als Parameter 

ist die verfügbar Größe nur die Größe 

des Zeigers (später) 

1 #include 

2 void f(int a[10]) { 

3 printf("in f : %ld\n", sizeof a); 

4 } 


6 int a[10]; 

7 printf("in main: %ld\n", sizeof a); 

8 f(a); 

9 return 0; 

10 } 

in main: 40 

in f : 4 



Felder 

Auf Feldelemente zugreifen 

Zugriff mit [] 

• Erlaubt von Index 0 bis Länge-1 

• Verwendung auf linker und rechter 

Seite der Zuweisung (=) 

• Wie in Java 

Beispiel 

• Initialisierung des Felds mit 

Quadratzahlen 

• Berechnung der Summe der ersten 

G-1 Quadratzahlen in Funktion 

sum=285 

1 #include 

2 enum { G=10 }; 

3 int dosum(int a[], int length) { 

4 int sum=0, i; 

5 for(i=0; i < length; i++) { 

6 sum += a[i]; 

7 } 

8 return sum; 

9 } 


11 int a[G], i; 

12 for(i=0; i < G; i++) { 

13 a[i] = i*i; 

14 } 

15 printf("sum=%d\n", dosum(a, G)); 

16 return 0; 

17 } 



Felder 

Zugriff außerhalb der Feldgrenzen 

Feldgrenzen 

• Keine Überprüfung der Feldgrenzen 

• Zugriff zunächst erlaubt 

• Verhalten außerhalb der Feldgrenzen 

undefiniert 

• Nicht wie in Java, 

keine Laufzeitumgebung wie in Java 

Fehlerverhalten 

• Es geht meistens schief 

• Meistens, aber nicht immer 

• (viel schlimmer) Nicht immer sofort 

• Bei Ausführung Programmabbruch 

durch Betriebssystem möglich 

(Speicherzugriffsfehler) 

• Tools wie valgrind helfen 

1 int main(void) { /* felderbumm.c */ 

2 int a[30]; 

3 a[30000] = 0; 

4 } 

Speicherzugriffsfehler 

1 int main(void) { /* feldernbumm.c */ 

2 int a[30]; 

3 a[1000] = 0; 

4 } 

% valgrind ./feldernbumm 

== Memcheck, a memory error detector 

== Invalid write of size 4 

== at 0x4004BC: main (feldernbumm.c:3) 

== Address 0x7ff0012f0 is not stack’d, 

malloc’d or (recently) free’d 



Felder 

Felder kopieren 

Feldname 

• Kann verwendet werden als Konstante 

mit Adresse des ersten Feldelements 

• Insbesondere als Funktionsparameter 

nicht Feld sondern Adresse des Felds 

• Ändern der Feldinhalte möglich 

Kopieren? 

• Durch Zuweisung nicht möglich 

• In Java Zuweisung der Referenz 

• Bei Feld als Parameter werden dann 

Adressen kopiert 

• Nicht unbedingt was man will 

Richtig kopieren 

• Feldweise, wie in Java 

• Genauso bei Vergleich, Ausgabe, etc. 

1 #include 

2 


4 int a[30], b[30], i; 

5 /* a = b; nicht erlaubt */ 

6 if (a == b) 

7 printf("NIE\n"); 

8 for (i=0; i < 30; i++) /* init */ 

9 a[i] = 0; 

10 for (i=0; i < 30; i++) /* copy */ 

11 b[i] = a[i]; 

12 return 0; 

13 } 

14 

15 void f(int x[30], int y[30]) { 

16 x = y; /* erlaubt aber sinnlos */ 

17 } 



Felder 

Mehrdimensionale Felder 

Definieren mehrdimensionaler Felder 

• Definition durch Angabe weiterer 

Dimensionen 

• [3][5] nicht [3,5] 

• Größe entspricht Grundgröße mal 

Produkt der Dimensionen 

• Immer noch ein zusammenhängender 

Speicherbereich 

Struktur 

• Zeilenweise (row major) 

• Letzter Index läuft am schnellsten 

Beispiel 

• Feld a von 3 Zeilen mit je 5 Zahlen 

• Insgesamt (3 · 5) · 4 = 60 Byte 

1 int a[3][5], i, j; 

2 printf("%lu\n", sizeof a); 

3 for (i=0; i < 3; i++) { 

4 for (j=0; j < 5; j++) 

5 a[i][j] = i*5+j; 

6 } 

7 for (i=0; i < 3; i++) { 

8 for (j=0; j < 5; j++) 

9 printf("%2d ", a[i][j]); 

10 printf("\n"); 

11 } 

0 1 2 3 4 

5 6 7 8 9 

10 11 12 13 14 

60 

0 1 2 3 4 

5 6 7 8 9 

10 11 12 13 14 



Felder 

Mehrdimensionale Felder als Parameter 

Problem – Dimensionen notwendig 

• Dimensionen notwendig um Position in 

Speicherbereich zu bestimmen 

• Alle Dimensionen außer der Ersten 

Zwang Angabe Dimensionen 


müssen angegeben werden 

• Wenn nicht, dann Fehler 


müssen stimmen 

Beispiel 

• Wenn nicht, dann Warnung 

• g1 ist ok 

• g2 ist nicht ok 

• Bei a fehlt die zweite Dimension 

• Bei b fehlt die zweite Dimension 

10 

1 void g1(int a[][5], int b[3][5], 

2 int c[10][5]) { 

3 printf("%2d %2d %2d\n", 

4 a[1][0], b[1][0], c[1][0]); 

5 printf("%2ld %2ld %2ld\n", 

6 &a[2][0] - &a[0][0], 

7 &b[2][0] - &b[0][0], 

8 &c[2][0] - &c[0][0]); 

9 } 

11 /* Fehler 

12 void g2(int a[3][], int b[][]) {} */ 

0 1 2 3 4 

5 6 7 8 9 

10 11 12 13 14 5 5 5 

10 10 10 



Felder 

Initialisierung von Feldern 

Initialisierungswerte mit {} 

• Funktioniert für eindimensionale und 

mehrdimensionale Felder 

• Es wird zeilenweise weiter aufgefüllt 

• Warnung bei modernen Compilern 

• Falls Elemente fehlen, dann werden 

diese mit 0 initialisiert 

Größe 

• Falls Dimension fehlt, dann so viele 

wie benötigt 

• Nur erste Dimension darf fehlen, die 

wird dann berechnet anhand der 

Initialisierungswerte 

• Keine dynamischen Feldgrößen! 

1 int a1[3][5] = { {0,1,2,3,4}, 

2 {5,6,7,8,9}, 

3 {10,11,12,13,14} }; 

4 int a2[][5] = { 0,1,2,3,4, 

5 5,6,7,8,9, 

6 10,11,12,13,14 }; 

7 char a3[5] = {1,2,3}; 

8 int a4[] = {1,2,3}; 

9 gibaus(a1); /* Ausgabe als Block */ 

10 gibaus(a2); /* Wie schon angegeben */ 

11 printf("%2d %2d %2d %2d %2d \n", 

12 a3[0], a3[1], a3[2], a3[3], a3[4]); 

13 printf("%lu \n", sizeof a4); 

0 1 2 3 4 

5 6 7 8 9 

10 11 12 13 14 

... 

1 2 3 0 0 

12 



Felder 

Zeichenketten 

Kein Zeichenketten-Typ in C! 

• Kein dedizierter Typ 

• Es wird ein char-Feld verwendet 

• Konvention 

• Zeichenkette wird mit Zeichen ’\0’ 

(der Wert 0) abgeschlossen 

Keine Operatoren auf Zeichenketten 

• Kein kopieren, vergleichen, 

konkatenieren, . . . 

Bibiliotheken 

• Operationen sind Teil der 

Standardbibliothek 

• string.h, man 3 string 

• Verwendung mit Funktionsaufrufen 

Beispiel Zeile 8, kein Platz, trotzdem 

1 char s1[6] = "Hallo"; 

2 char s2[11] = "Hallo"; 

3 char s3[] = "Hallo"; 

4 char s4[] = {’H’, ’a’, ’l’, 

5 ’l’, ’o’, ’\0’ }; 

6 printf("%s %s %s %s\n", s1, s2, s3, s4); 

7 strcat(s2,s1); 

8 strcat(s3,s1); 

9 printf("%s", s2); 

s1 H a l l o \0 

s2 H a l l o \0 \0 \0 \0 \0 \0 

H a l l o \0 

s3 H a l l o \0 

H a l l o \0 

s4 H a l l o \0 





Größere Softwareprojekte 

• Alles in einer Datei nicht mehr sinnvoll 

• Keine Modularisierung, keine Pakete 

• Was tun? 

a.h 

#include 

b.h 


• Getrennte Quell-Dateien, .c 

• Header-Dateien, 

• .h, mit #include verwenden 

• Typinformation, Prototypen, extern 

• Separat übersetzen 

• -c, nur übersetzen, nicht binden 

• Erstellt Objekt-Dateien, .o 

• Binden (linken) 

• Alle notwendigen Objekt-Dateien, 

Abhängigkeiten auflösen 

• Ausführbares Programm erzeugen 

a.c m.c b.c 

$ gcc -c a.c -o a.o 

a.o m.o b.o 

$ gcc a.o b.o c.o -o m 

m 




Getrennte Übersetzung – Beispiel Fibonacci/1 

Separate Fibonacci-Berechnung 

• Zwei Methoden, einmal rekursiv 

(fibr), einmal iterativ (fibi) 

• Gleiche Signatur, von/nach 

unsigned int 

Separate Datei, fibs.c 

• Übersetzung mit -c erzeugt fibs.o 

gcc -c fibs.c -o fibs.o 

• Die Symbole fibr und fibi werden 

bereit gestellt 

fibs.o 

< 

> fibr, fibi 

fibs.c 

1 unsigned int fibr(unsigned int n) { 

2 if ((n == 0) || (n == 1)) 

3 return n; 

4 return fibr(n-1) + fibr(n-2); 

5 } 

6 

7 unsigned int fibi(unsigned int n) { 

8 unsigned int f0, f1 = 1, f2 = 0; 

9 if ((n == 0) || (n == 1)) 

10 return n; 

11 while (--n) { 

12 f0 = f1+f2; 

13 f2 = f1; 

14 f1 = f0; 

15 } 

16 return f0; 

17 } 




Getrennte Übersetzung – Beispiel Fibonacci/2 

Verwenden 

• Prototypen, damit Typ stimmt 

• Aufruf der Funktion 

Übersetzen, wie fibs.c 

• Die Symbole fibr, fibi und printf 

werden benötigt 

• Das Symbol main wird bereit gestellt 

Binden (linken) 

• Alle Objekt-Dateien werden 

zusammengeklebt 

• gcc fibs.o fib.o -o fib 

• main als Start benötigt 

• printf in Standardbibliothek 

Ausführen: fib(10) = 55 = 55 

fib.c 

1 #include 

2 unsigned int fibr(unsigned int); 

3 unsigned int fibi(unsigned int); 

4 


6 const unsigned int n = 10; 

7 printf("fib(%d) = %d = %d\n", 

8 n, fibr(n), fibi(n)); 

9 return 0; 

10 } 

fib.o 

< fibr, fibi, 

printf 

> main 

fibs.o 

< 

> fibr, fibi 

fib 

< main 

> printf 




Header-Dateien 

Problem – Mehrfachangabe Prototypen 

an jedem Vorkommen in der Anwendung 

Lösung – Header-Dateien 

• Endung per Konvention mit .h 

• Auslagern der Prototypen und extern 

Deklaration der Variablen 

Verwendung 

• Einbinden mit #include 

• Bei “ im aktuellen Verzeichnis, bei < 

nur im Systemverzeichnis 

Vorteile 

• Mit -I Suchpfad anpassbar 

• Wiederverwendbare Module 

• Schneller, nur Teile neu übersetzen 

• Paralleles Arbeiten einfacher möglich 

fibs.h 



fib.c 

1 #include 

2 #include "fibs.h" 


4 const unsigned int n = 10; 

5 printf("fib(%d) = %d = %d\n", 

6 n, fibr(n), fibi(n)); 

7 return 0; 

8 } 

fibs.c 

1 #include "fibs.h" 

2 unsigned int fibr(unsigned int n) { 

3 ... 




Mehrfachinklusion 

Mehrfachinklusion bei großen Projekten 

• Header-Dateien inkludieren andere, 

die wieder andere Header-Dateien 

inkludieren 

• Dabei kann es passieren, dass eine 

Header-Datei mehrfach inkludiert wird 

Probleme 

• Schlimmstenfalls führt dies zu Fehlern 

bei der Übersetzung 

• Problematische 

Mehrfachvereinbarung zum Beispiel 

bei enum 

• Endlos-Inklusion falls ursprüngliche 

Datei wieder inkludiert wird 

• Auf alle Fälle unnötig lange 

Übersetzungszeit 




Präprozessor 

Präprozessor 

• Inkludieren mit #include 

• Textersetzungen mit #define 

• Tests mit #ifdef, #ifndef, #else 

Umsetzung 

• Ausführen der Ersetzungen vor dem 

eigentlichen Übersetzen 

• Zwischenergebnis nach Ersetzung 

mit Option -E 

gcc -E prepro.c > prepro.txt 

Einsatzgebiet 

• Für Konstanten vermeiden 

• Für Include-Guards verwenden 

1 #include 

2 #define TOLLE "SUPER" 

3 #define OK 0 


5 printf("Hallo %s TOLLE Welt\n", TOLLE); 

6 #ifdef TOLLE 

7 printf("Es ist was definiert\n"); 

8 #else 

9 printf("Nix is"); 

10 #endif 

11 return OK; 

12 } 

# 1 "prepro.c" 

# [ ... > 800 Zeilen ...] 

int main(void) { 

printf("Hallo %s TOLLE Welt\n", "SUPER") 

printf("Es ist was definiert\n"); 

return 0; 

} 




Include-Guards 

Ziel: Vermeide Mehrfach-Inklusion 

• Wenn eine Header-Datei schon 

einmal inkludiert wurde, 

• Dann inkludiere sie nicht mehr 

• Es kann nicht sinnvoll sein 

• Deklarationen reichen einmal 

Lösung: Include-Guard 

• Definiere eine Konstante 

• Konvention Dateiname groß, Sonderzeichen 

durch Unterstrich ersetzt 

• Prüfe ob Konstante nicht definert ist 

• Berücksichtige Inhalte nur, wenn diese 

Konstate nicht definiert ist 

• Effekt: Nur bei ersten Mal wird Inhalt 

berücksichtigt 

fibs.h 

1 #ifndef FIBS_H 

2 #define FIBS_H 

3 



6 

7 #endif 




Beispiel Mehrfachinklusion mit Include-Guards – Schalter/1 

zustaende.h 

1 #ifndef ZUSTAENDE_H 

2 #define ZUSTAENDE_H 

3 enum zustand {aus, an}; 

4 extern enum zustand initial; 

5 #endif 

zustaende.c 

1 #include "zustaende.h" 

2 enum zustand initial = aus; 

reset.h 


2 enum zustand reset(void); 

wechsel.h 


2 enum zustand wechsel( 

3 enum zustand aktuell); 

reset.c 

1 #include "reset.h" 

2 static int zaehler=0; 

3 static int f(void); 

4 enum zustand reset(void) { 

5 zaehler += 1+f(); 

6 return initial; 

7 } 

8 static int f(void) { return 0; } 

wechsel.c 

1 #include "wechsel.h" 



4 enum zustand wechsel( 

5 enum zustand aktuell) { 

6 zaehler += 1+f(); 

7 return (aktuell == an) ? aus : an; 

8 } 





Beispiel Mehrfachinklusion mit Include-Guards – Schalter/2 

Aufbau 

• Wir modellieren einen Schalter 

• zustand.h wird von allen gebraucht 

• zustand.h wird von reset.h und 

wechsel.h inkludiert 

• Das Hauptprogramm schalter 

resetted und schaltet und inkludiert 

entsprechend 

Problem 

• Mehrfachinklusion in einer 

Übersetzungsheit von zustand.h 

• Übersetzungsfehler 

Mehrfachvereinbarung enum zustand 

Lösung: Inlcude-Guard verhindert 

Mehrfachinklusion 

schalter.c 

1 #include 



4 


6 enum zustand schalter; 

7 schalter = reset(); 

8 printf("%u\n", schalter); 

9 schalter = wechsel(schalter); 

10 printf("%u\n", schalter); 

11 return 0; 

12 } 

Include-Guards 

In jeder Header-Datei immer verwenden. 




Beispiel Mehrfachdefinition 

Problem, Zeile 4 

• Definition in einer Header-Datei 

• Extrem böse! 

• Nie, nie, nie machen 

• Da hilft auch kein Include-Guard 

Fehlerauftreten 

• Sobald Header-Datei in zwei 

verschiedenen Übersetzungseinheiten 

verwendet wird 

• Zweimal Speicherplatz reserviert für 

das gleiche Symbol 

Doppelt definiertes Symbol 

Vermeiden 

• In Header-Datei nur deklarieren 

• nie definieren 

zustaende.h 

1 #ifndef ZUSTAENDE_H 

2 #define ZUSTAENDE_H 

3 enum zustand {aus, an}; 

4 enum zustand initial=an; 

5 #endif 

reset.o 

< .. 

> initial 

schalter.o 

< .. 

> initial 

wechsel.o 

< .. 

> initial 

Mehrfach definiertes Symbol initial 




Namenskollision und static 

Namenskollision 

• Situation: In zwei Quelldateien (.c 

Übersetzungseinheiten) wird zufällig 

der gleiche globale Name verwendet 

• Effekt: Das Binden geht schief (doppelt 

definiertes Symbol), die Variable kann 

von überall manipuliert werden 

Lösung – static 

• static definierte Variable auf globaler 

Ebene ist nur lokal für die 

Übersetzungseinheit definiert 

• Variable ist nicht sichtbar in anderen 

Übersetzungseinheiten 

• Gleicher Name darf mehrfach 

vorkommen 

• Dito für static definierte Funktionen 

wechsel.c 




4 enum zustand wechsel... 


reset.c 




4 enum zustand reset... 


Im Beispiel ist Zaehlvariable zaehler und 

Funktion f jeweils nur für 

Übersetzungseinheit wechsel.c bzw. 

reset.c gültig. 




Komplettes Makefile für schalter /1 

1,2 Definition Compiler und Optionen 

3,4 Definition Programme und Quellen 

7 all per Konvention erstes Ziel, soll 

“alles” machen 

9 Es wird die Datei make.depend 

eingelesen und als Teil des Makefiles 

interpretiert 

1-15 : Wie wird schalter erstellt 

17 Die Datei make.depend wird nicht 

selbst erstellt, der Gnu-C Compiler 

kann das auf Basis der Quellen 

machen. Das erste Mal eine leere 

Datei erstellen ($ touch 

make.depend), damit es los geht. 

Ansonsten bei Strukturänderungen 

#include im Quellcode. 

1 CC=gcc 

2 CFLAGS= -Wall -g -ansi 

3 PROGS=schalter 

4 SRC=schalter.c reset.c wechsel.c \ 

5 zustaende.c 

6 

7 all: $(PROGS) 

8 

10 

9 include make.depend 

11 schalter: schalter.o wechsel.o \ 

12 reset.o zustaende.o 

13 $(CC) $(CFLAGS) schalter.o \ 

14 wechsel.o reset.o zustaende.o \ 

15 -o schalter 

16 

17 depend: 

18 $(CC) -MM $(SRC) > make.depend 




Komplettes Makefile für schalter /2 

Fortsetzung Makefile 

1,2 Ein beliebtes Ziel ist test zur 

Test-Automatisierung, ein anderes 

übliches Ziel wäre run 

4 clean ist keine Datei und muss daher 

immer “erstellt” werden 

6 clean räumt Projekt auf. Alle 

generierten Dateien werden gelöscht. 

9 Endungen von zu verarbeitenden 

Dateien sind .o, .c und .h 

11 Generische Regel: Um eine .o Datei 

aus einer .c Datei mit gleichem 

Namen zu machen . . . 

12 $< für erste Abhängigkeit (.c-Datei), 

$@ für Ziel (die .o-Datei) 

1 test: $(PROGS) 

2 ./schalter 

3 

4 .PHONY: clean 

5 

6 clean: 

7 -/bin/rm *.o $(PROGS) 

8 

10 

9 .SUFFIXES: .o .c .h 

11 %.o : %.c 

12 $(CC) -c $(CFLAGS) $< -o $@ 

13 %.o : %.c %.h 

14 $(CC) -c $(CFLAGS) $< -o $@ 

13 Wenn auch von .h Datei abhängig 

Weitere Abhängigkeiten nicht generisch, 

make.depend 




Nutzen des Makefiles 

$ make -f clean 

/bin/rm *.o schalter 

$ make depend 

gcc -MM schalter.c reset.c wechsel.c zustaende.c > make.depend 

$ cat make.depend 

schalter.o: schalter.c reset.h zustaende.h wechsel.h 

reset.o: reset.c reset.h zustaende.h 

wechsel.o: wechsel.c wechsel.h zustaende.h 

zustaende.o: zustaende.c zustaende.h 

$ make 

gcc -c schalter.c -o schalter.o 

gcc -c wechsel.c -o wechsel.o 

gcc -c reset.c -o reset.o 

gcc -c zustaende.c -o zustaende.o 

gcc schalter.o wechsel.o \ 

reset.o zustaende.o -o schalter 

$ make test 

./schalter 

0 

1 Prof. Dr. Peter Barth (HS-RheinMain) Programmieren 3 29. Januar 2013 63 / 326


Zeiger 

Zeiger 

Arbeitsspeicher 

• . . . ist in Speicherzellen eingeteilt 

• . . . ist Byte-weise adressierbar 

• . . . ist Wort-weise strukturiert 

0x0A0 

0x0A4 

42 

*ptr 

• Adressraum meist 2 32 oder 2 64 Bytes 

Zeiger 

0x100 

0x0A0 

&val 

• Speicherzelle, die Adresse einer 

anderen Speicherzelle beinhaltet 

• Typisiert, Anfangsadresse eines Werts 

Notation Zugriff 

• * ptr: Wert auf den der Zeiger ptr 

verweist, Inhaltsoperator * 

• &val: Adresse von Wert val, 

Adressoperator & 



Zeiger 

Zeiger – Definition und Verwendung 

Notation Typ-Definition 

• *: Definiert einen Zeiger 

name auf 

• Beispiel: int *ptr; 

ptr ist Zeiger auf int 

Beispiel: 

• Variable val ist an Speicher mit 

Adresse (Hex) 0x0A0 abgelegt 

• Variable ptr ist an Speicher mit 

Adresse (Hex) 0x100 abgelegt 

• 32-Bit Wörter 

Ausgabe 

42 42 0x0A0 0x0A0 

0x100 

0x0A0 

0x0A4 

0x100 

1 int val = 42; 

2 int *ptr = &val; 

3 

42 

0x0A0 

4 printf("%d %d %p %p\n", 

5 val, *ptr, 

6 (void *) &val, 

7 (void *) ptr); 

*ptr 

8 printf("%p\n", (void *) &ptr); 

&val 



Zeiger 

Zeigergröße 

Zeigergröße 

• Zeigergröße selbst durch Maschine 

festgelegt 

• Zeigergröße meist 4-Byte (32-Bit) oder 

8 Byte (64 Bit) 

• Zeigergröße unabhängig von 

Werte-Typ 

Beispiel 

0x0A0 

0x0A4 

0x100 

0x104 

0x108 

42 

'A' 'B' 

0x0A0 

0x0A4 

0x0A5 

• Ein int und zwei char 

• Auf 32-Bit Maschinen ist ein int 4 Byte 

groß und ein char 1 Byte 

• Zeiger sind auf 32-Bit Maschinen 4 

Byte groß, unabhängig vom Basis-Typ 

42 A B 

0x0A0 0x0A4 0x0A5 

0x100 0x104 0x108 

1 int a = 42; char b = ’A’, c = ’B’; 

2 int *ap = &a; char *bp = &b, *cp = &c; 

3 

4 printf("%d %c %c\n", a, b, c); 

5 printf("%p %p %p\n", 

6 (void *) &a, (void *) &b, (void *) &c); 

7 printf("%p %p %p\n", 

8 (void *) &ap,(void *) &bp, (void *) &cp); 



Zeiger 

Zeiger auf Zeichen, Zeichenketten 

Zeiger auf Zeichen 

• Zeichen (Byte) ist kleinste 

adressierbare Einheit (Speicherzelle) 

Zeichenketten 

• Name des Felds kann als konstanter 

Zeiger auf das erste Element 

verwendet werden 

• Dereferenzierung entspricht 

Feldzugriff an Stelle 0 

• Achtung: Ein Zeichen ist ein 

Ganzzahltyp 

Beispielausgabe 

A 65 0x0A3 

B B 0x0A4 0x0A4 

0x0A0 

0x0A4 

0x100 

1 char ch = ’A’; 

'A' 

'B' 'C' 'D' '\0' 

0x0A3 

0x0A4 

2 char *chptr = &ch; 

3 char str[4] = "BCD"; 

4 printf("%c %d %p\n", 

5 ch, ch, (void *) chptr); 

6 chptr = str; 

7 printf("%c %c %p %p\n", 

8 str[0], *chptr, 

9 (void *) chptr, (void *) &str[0]); 



Zeiger 

Zeigerdefinition – Besonderheiten 

Syntax: * 

• Erst Typname 

• Dann Stern * 

• Schließlich Variablenname 

Beispiel: int *var 

Achtung 

• Der * bezieht sich auf den 

Variablennamen 

• Potentielles Problem bei mehreren 

Variablen in einer Definition 

• Der Typ eines Zeigers ist * 

Notationskonvention 

• * immer nahe am Variablennamen 

• Nie nahe am Typnamen 

1 int* ptr, qtr; 

1 /* entspricht */ 

2 int *ptr; 

3 int qtr; 

1 int *ptr, *qtr; 

1 /* entspricht */ 

2 int *ptr; 

3 int *qtr; 

int* ptr; 



Zeiger 

Vorrangregeln von Operatoren 

Von hoch nach niedrig: 

10 () [] -> . 

Vorrang 

9 ! ˜ ++ -- + - * & (typ) sizeof 

8 * / % 

+ - 

7 > 

6 < >= 

== != 

5 & 

ˆ 

| 

4 && 

|| 

3 ?: 

2 = += -= *= %= ˆ= &= = 

1 , 



Zeiger 

Zeiger – Beispiele/1 

1 unsigned long l0 = 0; 



4 unsigned long *pl[3] = { 

5 &l0, &l1, &l2 /* not ANSI-C, but C99 */ 

6 }; 

7 *pl[0] = 0; 

1 double d[3] = {1.0, 2.0, 3.0}; 

2 double (*pd)[3] = &d; 

3 (*pd)[0] = 3.0; 

0 1 2 

pl 0x.. 0x.. 0x.. 

l0 0 l1 1 l2 2 

0 1 2 

pd 0x.. d 1.0 2.0 3.0 

u 42 

1 unsigned int u=42; 

2 unsigned int *pu = &u; 

3 unsigned int **ppu = &pu; 

4 unsigned int ***pppu = &ppu; 

pppu 

ppu 

0x.. 

pu 

0x.. 

0x.. 



Zeiger 

Zeiger – Beispiele/2 

1 char ch; 

2 char *pc= &ch; 

3 char **ppc=&pc; 

4 char **xf[3][2]; 

5 char **(*px)[3][2] = &xf; 

6 

7 ch = ’a’; 

8 *pc = ’a’; 

9 **ppc = ’a’; 

0 printf("%p %p\n", 

1 (void *) pc, (void *) ppc); 

2 xf[0][1] = ppc; 

3 **(*px)[0][1] = ’b’; 

4 printf("%c\n", ch); 

ppc 

px 

0x.. 

0x.. 

pc 0x.. ch 

xf 0 

1 

2 

0 1 

0x.. 0x.. 

0x.. 0x.. 

0x.. 0x.. 

'a' 

'b' 



Zeiger 

Zeigeroperationen, Zeiger auf void 

Operationen gleich(==), ungleich (!=) 

• Immer erlaubt 

• Test ob gleiche/ungleiche Adresse 

Zuweisung 

• Immer erlaubt 

• Gleicher Typ, sonst Warnung, 

vermeiden mit explizitem Cast 

• Von zu void * ohne Warnung 

void *, Zeiger auf beliebige Werte 

• Automatische Umwandlung bei 

Zuweisung 

• Dereferenzierung mit Inhaltsoperator 

verboten (was sollte rauskommen?) 

• Achtung: Böse, möglichst vermeiden 

1 char s[] = "hallo"; 

2 char *cp = s; 

3 void *vp = cp; 

4 int *ip; 

5 

6 printf((s == cp) ? "==\n" : "!=\n"); 

7 printf((s != cp) ? "!=\n" : "==\n"); 

8 

9 ip = vp; /* keine Warnung */ 

10 ip = cp; /* Warnung */ 

11 ip = (int *) cp; /* keine Warnung */ 

12 

13 printf("%i\n", 

14 *ip); /* was auch immer... */ 

== 

== 

1819042152 



Zeiger 

Zeigerarithmetik 

Zeiger und Zahlen 

• Addition und Subtraktion erlaubt 

• Ergebnis ist ein Zeiger 

• Effekt: Zeiger um Vielfaches des 

Platzbedarfs des Grundtyps ändern 

• typ *ptr; int i; 

int N = sizeof(typ); 

• ptr=ptr+i, ptr um i*N Byte erhöhen 

• ptr=ptr-i, um i*N Byte vermindern 

• ptr++, ptr--, ptr+=i . . . erlaubt 

Zeiger und Zeiger 

• Nur Subtraktion erlaubt 

• Ergebnis ist ganze Zahl 

Keine Zeigerarithmentik mit void * 

p p+1 

N Byte 

1 int ai[10]; 

2 int *pi = &ai[0]; 

3 double ad[10]; 

4 double *pd = &ad[0]; 

5 printf("%p %p %ld\n", 

6 (void *) pi, (void *) (pi+1), 

7 ((char *) (pi+1)) - ((char *) pi)); 

8 printf("%p %p %ld\n", 

9 (void *) pd, (void *) (pd+1), 

10 ((char *) (pd+1)) - ((char *) pd)); 

0x585e6210 0x585e6214 4 

0x585e61c0 0x585e61c8 8 



Zeiger 

Beipiel – Zeichenketten 

Zeichenkette s mit Platz am Ende 

• Feld kann Zeiger zugewiesen werden 

Erste while-Schleife, Zeile 7 

• * ptr testet ob das Zeichen 0 ist 

• Läuft bis String-Ende 

Zweite while-Schleife, Zeile 9 

• Typische C-Idiom 

• Zuweisung, Zeigererhöhung und Test 

in einer Zeile 

• Doppelte Klammer vermeidet 

Warnung 

Gesamt 

• while-Schleifen – strcat(str, ttr) 

• for-Schleife – strlen(str) 

H a l l o u n d s o . \0 

1 char s[100] = "Hallo"; 

2 char *p = s; 

3 char t[] = " und so."; 

4 char *q = t; 

5 int i; 

6 

7 while (*p) 

8 p++; 

9 while ((*p++ = *q++)) 

10 ; /* leere Anweisung */ 

11 p = s; 

12 for (i=0; *p++; i++) 

13 ; /* leere Anweisung */ 

14 printf("%s (%d)\n", s, i); 

Hallo und so. (13) 



Zeiger 

Rechnen mit Zeigern 

Zeigerarithmetik, gleicher Zeigertyp 

• Nur bei gleichen Zeigertypen sinnvoll 

• Beispiele 

cq - cp == 5 

cq == cp + 5 

cp == cq - 5 

Zeigerarithmetik bei verschiedenen 

Zeigertypen ist Unsinn 

• cq - ip ??? 

• Keine Vermischung von Typen, was 

bedeutet +1? 

1 char cp[] = "abcdefghij"; 

2 char *cq = cp+5; 

3 short int sp[] = {0,1,2,3,4}; 

4 short int *sq = sp+2; 

5 int ip[] = {0, 1, 2}; 

6 int *iq = ip + 1; 

7 double dp[] = { 3.1415, 2.7182 }; 

8 double *dq = dp+1; 

cp 

cq 

a b c d e f g h i j 

sp 

sq 

0 1 2 3 4 

ip 

iq 

0 

1 

2 

dp 

dq 

3,1415 

2, 



Zeiger und Felder 


1 int af[] = {2,3,5,7,11,13,17,19,23,29}; 

Feldnamen als Zeiger 

2 int i=6; 

• Der Name eines Feldes kann als 

3 

konstanter Zeiger auf das erste 

4 printf("%d == %d\n", af[i], *(af+i)); 

Element des Feldes verwendet werden 5 printf("%d == %d\n", af[i], i[af]); 

Feldzugriff und Inhaltsoperation Zeiger 

• Es gilt ptr[i] == *((ptr) + (i)) 

• Feldzugriff wird als Inhaltsoperation 

interpretiert 

• Äquivalenz gilt immer 

• Zeile 6: i[af] – so nicht 

programmieren 

Beispiel 

• Was macht nebenstehendes 

Programm? 

• 345 A 5 

17 == 17 

17 == 17 

1 char vstr[] = "12345"; 

2 char *ptr = vstr; 

3 

4 printf ("%s %c %c", ptr+2, 

5 ’A’+ptr[5], 

6 3[ptr+1]); 




Zeiger und Felder sind nicht dasselbe/1 

Einem Feldnamen kann kein Zeiger 

zugewiesen werden 

• Der Feldname selbst ist kein Zeiger 

• Es wird kein Platz angelegt für den 

Feldnamen 

Ein Zeiger selbst braucht Speicherplatz 

• Der Zeiger beinhaltet die Adresse an 

der das erste Element des Feldes 

beginnt 

• Ein Zeiger zeigt bei Wertänderung auf 

andere Speicherbereiche 

1 char str[] = "abcde"; 

2 char *ptr = "abcde"; 

3 

4 ptr = str; /* geht */ 

5 /* str = ptr; geht nicht */ 

str a b c d e \0 

ptr 0x.. a b c d e \0 




Zeiger und Felder sind nicht dasselbe/2 

Feld von Felder 

• Ein Feld von Feldern ist eigentlich ein 

grosses Feld 

• Row Major, zeilenweise 

• Die Größe ist fix 

1 char *pp[] = 

2 {"ein", "kleiner", "text"}; 

3 char vv[][10] = 

4 {"ein", "kleiner", "text"}; 

5 printf("%ld %ld\n", sizeof pp, sizeof vv) 

Feld von Zeiger 

12 30 

• Ein Feld von Zeigern ist ein normales 

eindimensionales Feld 

• Die Werte sind Zeiger auf Werte, bzw. 

Zeiger auf den Anfang von Feldern 

0 

1 

2 

pp 

0x.. 

0x.. 

0x.. 

e i n \0 

k l e i 

t e s t 

n e r \0 

\0 

0 

1 

2 

vv 

e i n \0 

k l e i n e r \0 

t e s t \0 




Zeigersalat 

1 char *c[] = { "ENTER", "NEW", "POINT", 

2 "FIRST" }; 

3 char **cp[] = { c+3, c+2, c+1, c }; 

4 char ***cpp = cp; 

5 printf("%s", **++cpp); 

6 printf("%s", *--*++cpp+3); 

7 printf("%s", *cpp[-2]+3); 

8 printf("%s\n", cpp[-1][-1]+1); 

0x.. 

cpp 

3 

2 

0x.. 

0x.. 

0x.. 

1 

0x.. 

0 

cp 

0x.. 

0x.. 

0x.. 

0x.. 

c 

F I R S 

P O I N 

N E W \0 

E N T E 

T \0 

T \0 

R \0 




Zeigersalat – Zeile 5 


2 "FIRST" }; 

3 char **cp[] = { c+3, c+2, c+1, c }; 



6 printf("%s", *--*++cpp+3); 

7 printf("%s", *cpp[-2]+3); 

8 printf("%s\n", cpp[-1][-1]+1); 

0x.. 

cpp 

3 

2 

0x.. 

0x.. 

0x.. 

1 

0x.. 

0 

cp 

0x.. 

0x.. 

0x.. 

0x.. 

c 

F I R S 

P O I N 

N E W \0 

E N T E 

T \0 

T \0 

R \0 

POINT 






2 "FIRST" }; 

3 char **cp[] = { c+3, c+2, c+1, c }; 



6 printf("%s", *--*++cpp+3); 

7 printf("%s", *cpp[-2]+3); 

8 printf("%s\n", cpp[-1][-1]+1); 

0x.. 

cpp 

3 

2 

0x.. 

0x.. 

0x.. 

1 

0x.. 

0 

cp 

0x.. 

0x.. 

0x.. 

0x.. 

c 

F I R S 

P O I N 

N E W \0 

E N T E 

T \0 

T \0 

R \0 

POINTER 






2 "FIRST" }; 

3 char **cp[] = { c+3, c+2, c+1, c }; 



6 printf("%s", *--*++cpp+3); 

7 printf("%s", *cpp[-2]+3); 

8 printf("%s\n", cpp[-1][-1]+1); 

0x.. 

cpp 

3 

2 

0x.. 

0x.. 

0x.. 

1 

0x.. 

0 

cp 

0x.. 

0x.. 

0x.. 

0x.. 

c 

F I R S 

P O I N 

N E W \0 

E N T E 

T \0 

T \0 

R \0 

POINTERST 






2 "FIRST" }; 

3 char **cp[] = { c+3, c+2, c+1, c }; 



6 printf("%s", *--*++cpp+3); 

7 printf("%s", *cpp[-2]+3); 

8 printf("%s\n", cpp[-1][-1]+1); 

0x.. 

cpp 

3 

2 

0x.. 

0x.. 

0x.. 

1 

0x.. 

0 

cp 

0x.. 

0x.. 

0x.. 

0x.. 

c 

F I R S 

P O I N 

N E W \0 

E N T E 

T \0 

T \0 

R \0 

POINTERSTEW 




Kommandozeilenparameter 

Parameter von main 

• Anzahl der Argumente (inklusive 

Name des Programms) 

int argc 

• Argumente als Feld von char-Zeigern 

char *argv[] 

Ähnlich wie in Java 

• Eigentlich umgekehrt 

args.c 

1 #include 

2 

3 int main(int argc, char *argv[]) { 

4 int i; 

5 for (i=0; i < argc; i++) { 

6 printf("%2d: %s\n", i, argv[i]); 

7 } 

8 return 0; 

9 } 

$ gcc args.c -o args 

$ args hallo tolle C Welt 

0: args 

1: hallo 

2: tolle 

3: C 

4: Welt 

0 

1 

2 

3 

4 

argv 

0x.. 

0x.. 

0x.. 

0x.. 

0x.. 

a r g s \0 

h a l l 

t o I l 

C \0 

W e l t \0 

o \0 

e \0 



Funktionsparameter 

Funktionsparameter 

Grundtypen 

• In Java Werte 

Änderbare Parameter durch 

Verpacken in Objekte 

• In C Werte 

Änderbare Parameter durch 

Adressoperator (“call by reference”) 

• Idiom für z.B. scanf 

Felder 

• In Java als Referenz übergeben 

Werte in Feld ändern möglich 

Zuweisung heißt Referenz kopieren 

• In C Parameter als Zeiger übergeben 

Werte in Feld können geändert 

werden 

Zuweisung an Feld nicht möglich 

1 void f1(int *pi) { *pi = 17; } 

2 void g1(int a[]) { 

3 int c[3] = {1,2,3}; 

4 a = c; /* erlaubt */ } 

5 void g2(int *a) { 

6 int c[3] = {1,2,3}; a = c; } 

7 void g3(int *a) { a[0] = 17; } 

1 int i=2; 

2 int a[3] = {2,3,5}; 

3 int b[3] = {2,3,5}; 

4 /* b = a; nicht erlaubt */ 

5 f1(&i); 

6 /* i == 17 */ 

7 g3(a); 

8 /* a[0] == 17 */ 

9 scanf("%d", &i); 

10 /* i == */ 



Strukturen 

Strukturen – struct 

Wie Java-Klasse ohne Methoden 

• Alle Komponenten public 

Definition mit struct 

• Variablendefinition bei 

struct-Deklaration möglich 

• Spätere Variablendefinition möglich, 

immer mit Schlüsselwort struct 

• Initialisierung in Reihenfolge der 

Deklaration möglich 

• Größe implementierungsabhängig 

Zugriff auf Komponenten mit .-Operator 

Zuweisung ist Kopie 

44 

• NICHT wie in Java 

1234 Susi Sinnlos 

4711 Willi Wahnsinn 

1 struct person { 

2 char name[40]; 

3 unsigned int id; 

4 } susi; 

5 

6 struct person rudi; 

7 struct person willi = { 

8 "Willi Wahnsinn", 

9 4711 

10 }; 

1 strcpy (susi.name, "Susi Sinnlos"); 

2 susi.id = 1234; 

3 rudi = willi; 

4 willi.id = 123456; 

5 willi.name[0] = ’X’; 

6 printf("%6d %s\n", susi.id, susi.name); 

7 printf("%6d %s\n", rudi.id, rudi.name); 

8 printf("%ld\n", sizeof (struct person)); 



Strukturen 

Strukturen – Speicherlayout 

Speicherlayout 

• Compiler entscheidet 

• Keine Annahmen treffen 

Beispiel 

• Findet heraus wo was liegt 

• Code nicht gut/portabel 

0 

4 

8 

12 

16 

a 0x44ac2d20 

b 

c d 

d 

e 

Füll-Bytes 

1 struct p1 { 

2 short a; 

3 int b; 

4 char c[3]; 

5 char d[4]; 

6 int e; 

7 }; 

1 struct p1 p; 

2 char *base = (char *) &p; 

3 printf("== p:%p ==\n", base); 

4 printf("a:%2ld b:%2ld c:%2ld d:%2ld e:%2l 

5 ((char *) &p.a)-base, ((char *) &p.b)-ba 

6 ((char *) &p.c)-base, ((char *) &p.d)-ba 

7 ((char *) &p.e)-base); 

== p:0x44ac2d20 == 

a: 0 b: 4 c: 8 d:11 e:16 



Strukturen 

Strukturen und Zeiger 

Zugriff mit -> 

• pp->id ist Kurzform für (*pp).id 

• Erlaubt einfachen Zugriff auf 

Komponenten einer Struktur 

• Beispiel: 987654 Rudi Ratlos 

Bequem bei Zeigerketten 

• Beispiel: 0 

lp a b c 

0x.. 2 0x.. 1 0x.. 0 0x.. 

1 void change(struct person *pp) { 

2 strcpy(pp->name, "Rudi Ratlos"); 

3 pp->id = 987654; 

4 } 

1 struct person *pp = &rudi; 

2 change(pp); 

3 printf("%6d %s\n", pp->id, pp->name); 

1 struct node { 

2 int data; 

3 struct node *next; 

4 }; 

1 struct node c = {0, NULL}; 

2 struct node b = {1, &c}; 

3 struct node a = {2, &b}; 

4 struct node *lp = &a; 

5 printf("%d\n", lp->next->next->data); 



Typdefinition 

Typdefinitionen – typedef 

Typdefinition 

• Syntax: typedef 

• Danach Verwendung von 

statt möglich 

• Kein neuer Typ, nur ein weiterer 

Name für denselben Typ 

Vorteil 

• (Meist) Kürzer 

• Portabler, da Typdefinition nur an 

einer Stelle steht 

Beispiel 

• Keine neuen Typen nur neue Namen 

• struct knoten wäre auch ok 

• knoten und struct knoten ergeben 

kein Namensproblem 

1 typedef int ganzzahl; 

2 typedef enum {ROT, GELB, GRUEN} ampel; 

3 typedef struct _knoten *knotenzeiger; 

4 typedef struct _knoten { 

5 knotenzeiger next; 

6 int data; 

7 } knoten; 

8 typedef struct _node { 

9 struct _node *next; 

10 int data; 

11 } node; 

12 typedef node *nodeptr; 

1 knoten k1, k2; 

2 knotenzeiger kp = &k2; 

3 k1.next = kp; 

4 node n1, n2; 

5 nodeptr np = &n1; 

6 node *nq = &n2; 

7 np->next = nq; 



Freispeicherverwaltung 


Speicher anfordern 

• Es gibt kein new 

• Speicher mit malloc anfordern 

• Anzahl Bytes angeben 

• Adresse wird zurückgegeben 

• Freispeicher wird von Betriebsystem 

verwaltet 

Speicher freigeben 

• Es gibt keinen Garbage Collector 

• Speicher mit free freigeben 

• Adresse als Parameter angeben 

• Größe dem Betriebssystem bekannt 

• Danach Zugriff auf Speicher illegal 

• Achtung: Keine Compiler-Warnung 

• Achtung: (Nicht unbedingt gleich) 

Fehler zur Laufzeit 

1 int len=10, i; 

2 char *a = malloc(len*sizeof(char)); 

3 for (i=0; i < len; i++) { 

4 a[i] = i; 

5 } 

6 free(a); 

7 a[0] = 17; /* illegal, Laufzeit */ 

0x200 

a,0x100 

0 1 2 3 

4 5 6 7 

8 9 

0x200 

Freispeicher, 

Heap 

Stack 




Dynamische Speicherverwaltung 

Funktionen zur dynamischen Speicherverwaltung 

• void *malloc(size_t size) 

Reserviert einen size Byte großen Speicherblock 

• void *calloc(size_t nEle, size_t eleSize) 

Reserviert einen nEle * eleSize Byte großen Speicherblock und füllt ihn mit Nullen 

• void free(void *ptr) 

Gibt den vormals mit [mc]alloc allokierten Speicherbereich an der Adresse ptr an 

das System zurück 

Alles definiert in stdlib.h 

• size_t ist ein vorzeichenloser Ganzzahltyp 

Fehlerfall 

• Falls beim Allokieren kein Speicherblock mehr zur Verfügung steht wird NULL 

zurückgegeben 

• NULL ist ein Makro, Zeiger auf nicht definierten Wert, verwenden wie null in Java 

• NULL ist meist (nicht immer) so definiert: #define NULL ((void *) 0) 




Keine Garbage-Collection 

Achtung Speicherlecks (leak) 

• Speicher wird nicht automatisch 

freigegeben 

• Jeder allokierte Block muss 

freigegeben werden 

$ leak 

Kein Speicher nach 80330 mallocs 

$ leak -f 

ok nach 100000 mallocs 





... 


... 

1 #include 

2 #include 

3 #include 


5 int len = 10000, *a, run=1, mallocs=0; 

6 while(run) { 

7 a = malloc(len*sizeof(int)); 

8 if (a == NULL) { 

9 printf("Kein Speicher nach %d mallocs\n", 

10 mallocs); 

11 run = 0; 

12 } 

13 mallocs += 1; 

14 if (mallocs % 100000 == 0) 

15 printf ("ok nach %d mallocs\n", mallocs); 

16 if (argc > 1 && 

17 strcmp(argv[1], "-f") == 0) 

18 free(a); 

19 } return 0; } 




Speicherlecks erkennen 

Speicherlecks Beispiel 

• Beispiel ähnlich 

• Lecks ohne Option -f 

Speicherlecks erkennen mit valgrind 

• valgrind, memory checker 

• Instrumentieren von vorhandenem 

Code 

• Einfach vor Programmaufruf 

valgrind 

1 #include 

2 #include 

3 #include 

4 


6 int len = 10000, run=1, mallocs=0, i; 

7 int *aptr; 

8 while(run && (mallocs < 1000)) { 

9 aptr = malloc(len*sizeof(int)); 

10 for (i=0; i 1 && 

14 strcmp(argv[1], "-f") == 0) 

15 free(aptr); 

16 } 

17 return 0; 

18 } 




valgrind Beispiellauf 

$ valgrind ./leakval.exe 

==12615== Memcheck, a memory error detector 

==12615== HEAP SUMMARY: 

==12615== in use at exit: 40,000,000 bytes in 1,000 blocks 

==12615== total heap usage: 1,000 allocs, 0 frees, 40,000,000 bytes allocated 

==12615== LEAK SUMMARY: 

==12615== definitely lost: 40,000,000 bytes in 1,000 blocks 

==12615== indirectly lost: 0 bytes in 0 blocks 

==12615== possibly lost: 0 bytes in 0 blocks 

==12615== still reachable: 0 bytes in 0 blocks 

==12615== suppressed: 0 bytes in 0 blocks 

$ valgrind ./leakval.exe -f 

==12618== Memcheck, a memory error detector 

==12618== HEAP SUMMARY: 

==12618== in use at exit: 0 bytes in 0 blocks 

==12618== total heap usage: 1,000 allocs, 1,000 frees, 40,000,000 bytes allocated 

==12618== All heap blocks were freed -- no leaks are possible 




Verkettete Liste – Header 

Einfach verkettete Liste 

• Zeiger auf Nachfolger 

• Wert ist Feld mit 80 Zeichen 

• Merken des Zeigers auf das erste Feld 

zur Repräsentation der Liste 

Hilfsroutinen 

• Liste anzeigen, show_list: 

Durchlaufen und Zeichenkette 

9 

10 

} slist; 

typedef slist *slptr; 

11 

ausgeben 

12 void show_list(slptr l); 

• Listenelement am Anfang einfügen, 13 slptr insert(slptr list, const char *s); 

insert: String mit max 80 Zeichen wird14 void delete_list(slptr list); 

kopiert 

15 slptr copy_list_reverse(slptr first); 

• Liste löschen, delete_list: Erstes 

Element schrittweise löschen 

• Kopieren, copy_list_reverse: Kopie 

hat umgekehrte Reihenfolge 

1 #ifndef SLIST_H 

2 #define SLIST_H 

3 

4 #define SMAXLEN 80 

5 

16 

6 typedef struct _slist { 

7 struct _slist *next; 

8 char s[SMAXLEN]; 

17 #endif 




Verkettete Liste – Implementierung/1 

1 void show_list(slptr lis) { 

2 for (; lis; lis = lis->next) 

3 printf("%s ", lis->s); 


5 } 

6 

7 static void scopy(char *dest, const char *src) { 

8 strncpy(dest, src, SMAXLEN); 

9 dest[SMAXLEN-1] = 0; 

0 } 

1 

2 slptr insert(slptr lis, const char *s) { 

3 slptr neu = malloc(sizeof(slist)); 

4 if (neu == NULL) 

5 return NULL; 

6 scopy(neu->s, s); 

7 neu->next = lis; 

8 return neu; 

9 } 




Verkettete Liste – Implementierung/2 

1 void delete_list(slptr lis) { 

2 slptr next; 

3 while (lis) { 

4 next = lis->next; 

5 free(lis); 

6 lis = next; 

7 } 

8 } 

9 

0 slptr copy_list_reverse(slptr lis) { 

1 slptr nlis = NULL; 

2 while (lis) { 

3 nlis = insert(nlis, lis->s); 

4 lis = lis->next; 

5 } 

6 return nlis; 

7 } 

lis 

a 

c 

0x.. 

0x.. 

b 

b 

0x.. 

0x.. 

c 

nlis 

a 

0x.. 

0x.. 




Verkettete Liste – SelectionSort 

SelectionSort 

• Gibt neue sortierte Liste zurück 

• Sortieren durch Auswahl des größten Elements 

• Aufsteigend sortiert 

Anmerkungen 

• Auswahl des größten Elements, neue Liste von hinten aufgebaut, dass man das 

nächste (kleinere) immer vorne anfügen kann 

• Arbeiten auf Kopie, also zunächste Kopie erstellen, Reihenfolge egal (Zeile 4) 

• Kopfelement um Sonderfälle zu vermeiden, wird nie verschoben 

• Bestimme größtes Element (Zeile 10-14) 

• Hänge größtes Element aus und in neue Liste ein (Zeile 15-18) 




Verkettete Liste – SelectionSort, Implementierung 

1 slptr selection_sort(slptr lis) { 

2 if (lis == NULL) { return lis; } 

3 slptr cp_lis=copy_list_reverse(lis), start=NULL; 

4 slist _first; /* Kopfelement, es wird niemals damit verglichen */ 

5 slptr first = &_first; first->next = cp_lis; 

6 while (first->next) { 

7 slptr befmax=first, lis=first, hlis; 

8 while (lis->next) { /* Finde Maximales */ 

9 if (strcmp(lis->next->s, befmax->next->s) > 0) { 

0 befmax = lis; 

1 } 

2 lis = lis->next; 

3 } 

4 hlis = befmax->next->next; /* Max. an Anfang der neuen Liste */ 

5 befmax->next->next = start; 

6 start = befmax->next; 

7 befmax->next = hlis; 

8 } 

9 return start; 

0 } 



Varianten/Unions 


Ziel – Wenig Speicherplatz 

• Nur eine von mehreren Varianten 

• Bei struct müsste für alle Platz 

vorgehalten werden 

Variante – union 

• Syntax wie struct, aber union 

• Alle Komponenten erhalten dieselbe 

Anfangsadresse im Speicher 

• Bei struct hintereinander 

• Nur eine Variante ist gültig 

• Nur diese sollte verwendet werden 

• Leider sind alle verwendbar mit dann 

meist sinnlosen Werten 

• Größe ist die Größe der größten 

Variante 

1 union zahl { 

2 int i; 

3 char c[12]; 

4 double d; 

5 }; 

1 union zahl z1; 

2 z1.i = 42; 

3 printf("%12d ", z1.i); 

4 strcpy(z1.c, "42"); 

5 printf("%12s ", z1.c); 

6 printf("%12d ", z1.i); 

7 printf("%12g\n", z1.d); 

42 42 12852 4.85435e-270 

4 2 \0 

12852 

4.85435e-270 




Beispiel – Varianten von Personen/1 

Zwei Personentypen 

• Studierende, STUD 

• Professoren, PROF 

Abbildung mit struct und union 

• Ein struct mit Klassifikator was das 

für eine Variante ist 

• union aus structs mit den Varianten 

1 enum typ { STUD, PROF }; 

2 

3 struct person { 

4 enum typ was; 

5 union { 

6 struct { 

7 int matnr; 

8 double notenschnitt; 

9 int semester; 

10 } studi; 

11 struct { 

12 int persnr; 

13 int seitjahr; 

14 } prof; 

15 } details; 

16 }; 





Erstellung von zwei Personen 

• Eine Studierende Susi 

• Ein Professor Roland 

Ausgabe, nächste Seite 

1 struct person susi; 

2 struct person roland; 

3 

4 susi.was = STUD; 

5 susi.details.studi.matnr = 123456; 

6 susi.details.studi.notenschnitt = 1.6; 

7 susi.details.studi.semester = 3; 

8 

9 roland.was = PROF; 

10 roland.details.prof.persnr = 654321; 

11 roland.details.prof.seitjahr = 1418; 

12 

13 

14 show(&susi); 

15 show(&roland); 

123456 1.6 3 

654321 1418 





Ausgabe von Personen 

• Je nach Variante unterschiedlich 

1 void show(struct person *p) { 

2 switch (p->was) { 

3 case STUD: 

4 printf("%6d %4.2g %1d\n", 

5 p->details.studi.matnr, 

6 p->details.studi.notenschnitt, 

7 p->details.studi.semester); 

8 break; 

9 case PROF: 

10 printf("%6d %4d\n", 

11 p->details.prof.persnr, 

12 p->details.prof.seitjahr); 

13 break; 

14 } 

15 } 

123456 1.6 3 

654321 1418 



Bitfelder 

Bitfelder 

1 struct punkt { 

Ziel – Wenig Speicherplatz 

2 /* XY-Position: 0-1024 */ 

• Mehrere Zahlen mit kleinem 

3 unsigned x:10; 

Zahlenbereich kompakt repräsentieren 4 unsigned y:10; 

Umsetzung – Bitfelder 

• Syntax wie struct 

• Komponenten 

unsigned : 

• Es werden Anzahl für Zahl 

reserviert 

• statt unsigned auch signed möglich 

Zugriff 

• Punkt-Notation 

• Compiler übernimmt Bit-Shifterei 

• Achtung: Aktuelles Speicherlayout 


5 /* RGB-Anteile: 0-255 */ 

6 unsigned r:8; 

7 unsigned g:8; 

8 unsigned b:8; 

9 }; 

x y r g b 

6-8 Byte je Punkt 

statt 20 (int) oder 10-12, 16 (short) 



Bitfelder 

Bitfelder – Verwendung 

x y r g b 

1 struct punkt weissediagonale[1024]; 

2 int i; 

3 for (i=0; i < 1024; i++) { 

4 weissediagonale[i].x = i; 

5 weissediagonale[i].y = i; 

6 weissediagonale[i].r = 

7 weissediagonale[i].g = 

8 weissediagonale[i].b = 255; 

9 } 

0 printf("%ld\n", sizeof weissediagonale); 

8192, entspricht 8 Byte, Trennung an Wortgrenze 



Funktionszeiger 


Ziel – Parametrisiertes Verhalten 

• Keine Objektorientierung 

• Funktionalität zuordnen/kapseln 

können 

Umsetzung – Zeiger auf Funktion 

• Parametervereinbarung wie gewohnt 

• Statt Funktionsname den 

Namen des Funktionszeigers in 

Klammern mit einem Stern davor 

• (*) 

Aufruf 

• Inhaltsoperator 

• Geht auch direkt mit Namen, 

was sonst sollte gemeint sein 

1 char g1[] = "Hallo"; 

2 char g2[] = "Hey Depp"; 

3 

4 char *nett(void) { return g1; } 

5 char *boese(void) { return g2; } 

6 

7 typedef char *(*grusstyp)(void); 

1 char *(*gruss1)(void); 

2 grusstyp gruss2; 

3 

4 gruss1 = nett; 

5 printf("%s, wie geht es?\n", (*gruss1)()) 

6 printf("%s, wie geht es?\n", gruss1()); 

7 gruss2 = boese; 

8 printf("%s, wie geht es?\n", gruss2()); 

Hallo, wie geht es? 

Hallo, wie geht es? 

Hey Depp, wie geht es? 




Funktionszeiger – Beispiel qsort 

Quicksort 

• Bibliotheksfunktion qsort 

• Funktioniert für Felder von 

beliebigem Datentyp 

• Vergleichsfunktion muss 

übergeben werden 

Vergleichsfunktion 

• Gibt int zurück 

< 0 wenn kleiner, > 0 wenn 

größer, = 0 wenn gleich 

• Parameter sind Zeiger auf zu 

vergleichende Werte 

2 5 3 

2 3 5 

5 3 2 

• void *, jeder Typ 

• const Wert wird nicht geändert 

1 void show(int a[], int len) { 

2 int i; 

3 for (i=0; i < 3; i++) 

4 printf("%d ", a[i]); 


6 } 

7 int kleiner(const void *e1, const void *e2) { 

8 return *((int *) e1) - *((int *) e2); 

9 } 

10 int groesser(const void *e1, const void *e2) { 

11 return *((int *) e2) - *((int *) e1); 

12 } 

1 int a[3] = { 2, 5, 3 }; 

2 show(a,3); 

3 qsort(a, 3, sizeof (int), kleiner); 

4 show(a,3); 

5 qsort(a, 3, sizeof (int), groesser); 

6 show(a,3); 



Makros 

Makros – Präprozessor 

• #include: Dateien einfügen 

• #define: Ersetzen von Text 

• #ifdef, #ifndef, #if defined, #if !defined, #if, #else, #elif, #endif, . . . 

Bedingte Übersetzung 

• Beispiel: Include-Guards 

• Beispiel: /usr/include/stdio.h 

1 #ifdef __USE_GNU 

2 

3 #endif 

1 #if defined __GNUC__ || defined __USE_GNU 

2 

3 #endif 



Makros 

Makros – Ersetzen von Text 

Ersetzen von Text 

• #define 


• wird durch ersetzt 

4 int iPI=0; 

• Ersetzungen finden weder innerhalb 5 char *s = " PI ist cool"; 

von Zeichenketten statt noch innerhalb 6 printf("%g\n", PI); 

von Bezeichnern 

7 return 0; 

Verwendung 

• Wird auch für Konstanten verwendet, 

vermeiden wegen fehlender 

Typprüfung 

• Sinnvoll zum Beispiel für 

Parametrisieren von Typen 

makros.c 

1 #include 

2 #define PI 3.1415 

8 } 

1 $ ./makros 

2 3.1415 

3 $ gcc -E makros.c | tail 

4 # 940 "/usr/include/stdio.h" 3 4 

5 # 2 "makrosa.c" 2 


7 int iPI=0; 

8 char *s = " PI ist cool"; 

9 printf("%g\n", 3.1415); 

10 return 0; 

11 } 



Makros 

Makros – Parameter 

Makros mit Parametern 

• Syntax: 

#define (, ..., ) \ 

 

• Kein Leerzeichen zwischen Namen 

und Klammer auf( 

• Verwenden der Parameternamen im 

 

Rein textuelle Ersetzung 

• Keine Typen, also keine 

Typüberprüfung 

• Achtung bei Ausdrücken, nur textuelle 

Ersetzung! 

• Im Beispiel geht etwas mit der 

Operatorpräzedenz schief 

1 #include 

2 

3 #define add1(i,j) i+j 

4 #define mul1(i,j) i*j 

1 int i=3, j=4; 

2 printf("%d\n", mul1(i, j)); /* 12 */ 

3 printf("%d\n", add1(i, j)); /* 7 */ 

4 printf("%d\n", mul1(i+1, j)); /* 7 */ 

5 printf("%d\n", add1(i, j)*2); /* 11 */ 

Zeile 4: Ergebnis 7 statt 16 

i+1*j 

Zeile 5: Ergebnis 11 statt 14 

i+j*2 



Makros 

Makros – Parameter, Klammern 

Klammerung der Parameter vermeidet 

manche Probleme 

Leider nicht alle 

1 #define add2(i,j) ((i) + (j)) 

2 #define mul2(i,j) ((i) * (j)) 

1 int i=3, j=4; 

2 printf("%d\n", mul2(i, j)); /* 12 */ 

3 printf("%d\n", add2(i, j)); /* 7 */ 

4 printf("%d\n", mul2(i+1, j)); /* 16 */ 

5 printf("%d\n", add2(i, j)*2); /* 14 */ 

6 

7 printf("%d\n", add2(++i, ++i)*2); /* 20 * 

Zeile 7: Ergebnis 20 statt 18 ??? 

((++i) + (++i))*2 

Seiteneffekte, was soll rauskommen? 



Makros 

Makros – Parameter, Klammern, Seiteneffekte 

Makros können Mehrfachverwendung mit 

1 #define quad(i) ((i)*(i)) 

unerwünschten Seiteneffekten kaschieren 

Nicht machen 

1 int i=3; 

inline-Funktionen im Header verwenden 2 printf("%d\n", quad(++i)); /* 25 */ 

ab C99 

3 printf("%d\n", i); /* 5 */ 

Zeile 2: Ergebnis 25 statt 16 ??? 

((++i) * (++i)) 

Niemand sieht und erwartet im Quellcode 

die doppelte Erhöhung von i. 



Konstanten 

Konstanten 

Konstanten 

• Syntax: const ... 

• Modifizierer des Typs 

• Compiler stellt sicher, dass der Wert 

nicht geändert werden kann 

Statt #define besser const verwenden 

• Typüberprüfung findet statt 

• Achtung: In Headern als extern 

deklarieren ohne Wert und Wert in 

einer Übersetzungseinheit definieren 

• Alternative: enum für Feldgrößen da 

const dort nicht erlaubt 

1 #include "constlib.h" 

2 

3 #define ANTWORT 42 

4 const int ANSWER=42; 

5 

6 #define AGROESSE 100; 

7 enum { ASIZE=100 }; 

8 char s[ASIZE]; 

constlib.h 

1 #ifndef CONSTLIB_H 

2 #define CONSTLIB_H 

3 extern const int THEANSWER; 

4 #endif 

constlib.c 

1 #include "constlib.h" 

2 const int THEANSWER=42; 



Konstanten 

Konstanten und Zeiger 

Konstanten und Zeiger 

• const char * 

(veränderbarer) Zeiger auf konstantes 

Zeichen 

• char *const 

Konstanter Zeiger auf (veränderbares) 

Zeichen 

• const char *const 

Konstanter Zeiger auf konstantes 

Zeichen 

1 char s[100]; 

2 

3 const char *a = s; 

4 /* a[0] = ’x’; verboten */ 

5 a = s+1; /* ok */ 

6 

10 

7 char *const b = s; 

8 b[0] = ’x’; /* ok */ 

9 /* b = s+1; verboten */ 

11 const char *const c="Fixer String"; 

12 /* c[0] = ’x’; verboten */ 

13 /* c = s+1; verboten */ 



Standard-Bibliothek 

Standard-Bibliothek – Übersicht 

Standard-Bibliothek – Auszug 

• assert.h: Zusicherungen 

• ctype.h: Klassifizierung und Konversion von Zeichen 

• math.h: Mathematische Funktionen 

• stdarg.h: Variable Parameterlisten 

• stdio.h: Ein-/Ausgabe 

• stdlib.h: Speicherverwaltung, Stringkonvertierung, Zufallszahlen, . . . 

• string.h: String-/Speicherbearbeitung 

• time.h: Datum und Uhrzeit 

• .... 

Teil von ANSI-C / ISO-C 

• Syntax und Verhalten definiert 

• Meist plattformunabhängig, Unterstützung für Plattformabhängigkeiten (wenn man 

will/muss kann man plattformunabhängigen Code schreiben) 

• Viele weitere Bibliotheken (außerhalb des Standards) verfügbar 

Dokumentation: man 




Standard-Bibliothek – assert 

Zusicherungen 

• assert() 

• Makro in assert.h 

• Falls Bedingung nicht erfüllt ist, dann 

wird Programm mit entsprechender 

Meldung abgebrochen. 

Übersetzung 

• Kein Code für assert, wenn die 

Konstante NDEBUG definiert ist. 

• Programm läuft schneller 

• Makros können mit Compiler-Option 

gesetzt werden 

• -DNDEBUG 

• In Makefile verwendbar, CFLAGS 

1 #include 

2 #include 

3 int mydiv(int zaehler, int nenner) { 

4 assert (nenner != 0); 

5 return zaehler/nenner; 

6 } 


8 printf("%d\n", mydiv(17,2)); 

9 printf("%d\n", mydiv(17,0)); 

10 return 0; } 

$ gcc assert.c -o assert 

$ ./assert 

8 

assert.exe: assert.c:5: div: 

Assertion ‘nenner != 0’ failed. 

Aborted 

$ gcc -DNDEBUG assert.c -o assert 

8 

Floating point exception 




Standard-Bibliothek – Standard I/O 

Zeiger auf Ströme 

• stdin (Eingabe), stdout (Ausgabe), stderr (Fehler) 

High-Level – gepuffert 

• FILE * (Zeiger auf Strom) 

• printf, scanf; fprintf, fscanf (Dateien); 

sprintf, sscanf (Strings) 

• puts, putc, gets, getchar, getc, fputs, fgetc (s String, 

c Char) 

• fopen, fclose (Dateien); fread, fwrite (binär), . . . 

• man stdio 

Low-Level – ungepuffert 

• int (handle) 

• Nicht Teil des ISO-Standards, POSIX-Standard (Unix) 

• open, creat, close, unlink, read, write, lseek, . . . 

stdin stdout 

Programm 

stderr 




Standard I/O – Beispiel, Datei I/O /1 

Ziel 

• Datei einlesen, optional 

Dateiname als 

Kommandzeilenparameter, 

sonst stdin 

• Datei out.strip schreiben 

• Zeilenweise 

• Innerhalb einer Zeile keine 

Wiederholungen von 

Whitespaces 

Umsetzung 

• stdio, ctype 

• Kommaoperator vermeiden 

1 #include 

2 #include 

3 

4 const char *outfname = "out.strip"; 

5 


7 FILE *fpin = stdin; 

8 FILE *fpout = fopen(outfname, "w"); 

9 int last_space = 0; 

10 

11 if (argc >= 2) { 

12 fpin = fopen(argv[1], "r"); 

13 } 

14 if (!fpin || !fpout) { 

15 fprintf(stderr, "oopps\n"); 

16 return -1; 

17 } 




Standard I/O – Beispiel, Datei I/O /2 

1 while (!feof(fpin)) { 

2 int c = fgetc(fpin); 

3 if (c == EOF) 

4 break; 

5 if (isspace(c)) { 

6 last_space=1; 

7 if (c == ’\n’) 

8 fputc(c, fpout), last_space = 0; 

9 } else { 

10 if (last_space) { 

11 fputc(’ ’, fpout); last_space = 0; 

12 } 

13 fputc(c, fpout); 

14 } 

15 } 

16 fclose(fpin); fclose(fpout); 

17 return 0; 

18 } 




Standard-Bibliothek – Speicherblöcke und Strings 

Speicherfunktionen, extra Parameter size 

• memchr: Puffer nach Zeichen durchsuchen 

• memcmp: Speicherblöcke vergleichen 

• memmove: Speicherblock verschieben 

• memset: Speicher füllen 

Stringfunktionen, nur Anfangsadresse (n max. Zeichen) 

• strcat, strncat: Zeichenkette anhängen 

• strchr: String nach Zeichen durchsuchen 

• strcmp, strncmp: String vergleichen 

• strcpy, strncpy: String kopieren 

• strdup: String kopieren, neuer Speicher 

• strlen: Länge eines Strings 

• strstr: Nach Teilstring suchen 

• . . . 

Speicherfunktionen 

0x..0x..0x..0x..0x..0x.. 

Speicherblöcke beliebiger Länge, 

beliebige Struktur (void *) 

Stringfunktionen 

H A L L O \0 

Speicherblöcke beliebiger Länge, 

0-terminiert, aus Zeichen (char *) 




Strings – Beispiel /1 

Ziel 

• Zeichenkette der 

Kommandozeile zu einem 

dynamisch allokierten String 

zusammenfügen 

Umsetzung 

• string-Funktionen 

• stdlib-Funktionen 

Bemerkung 

• Viele strlen-Aufrufe nicht 

effizient 

• Was ist die Komplexität? Wie 

geht es besser? 

1 #include 

2 #include 

3 #include 

4 


6 int i; 

7 int len=1; 

8 char *s = malloc(sizeof(char)); 

9 s[0] = 0; 




Strings – Beispiel /2 

Komplexität 

• Aufwendig wegen strlen 

• Viele Allokationen trotz Trick mit 

Verdopplung 

• Kopieren eines immer wieder 

wachsenden Teils 

Besser 

• Zweimal durchlaufen, einmal 

Speicher berechnen, dann 

allokieren und füllen 

• Linear 

1 for (i=1; i

Programmieren in Python 

Einführung 

Python 

Pseudocode that runs 

Was ist Python? 

• Objektorientierte Skriptsprache (“Perl by a sane person”) 

• Einfach erlernbar (Einsteigersprache), interaktiv, Open Source 

• Um Größenordnung schnellere Entwicklung, auch für Prototypen geeignet 

• Plattformunabhängig, interpretiert, Bytecode (JIT mit pypy) 

Features 

• Dynamische Typisierung, Garbage Collection 

• Eingebaute Datenstrukturen (Listen, Tupel, Dictionaries, String, . . . ) 

• Mächtige Ausdrucksweise und Werkzeuge (Verketten, abbilden, slicen) 

• Klassische Kontrollstrukturen (imperativ), Objektorientierung und funktionale 

Primitive 

• Unterstützung für große Projekte (Module, Ausnahmen, . . . ) 

• Integration (C, C++, Java, XMLRPC, REST, SOAP, . . . ) 

• Bibliotheken (Web, Email, reguläre Ausdrücke, XML, GUI, Threading, Unittesting, 

Bildbearbeitung, . . . ) 



Einführung 

Historie 

Background 

• Treibende Kraft: Guido van Rossum, BDFL 

• Name von “Monty Python Flying Circus” 

Historie 

90: Als Skriptsprache für verteiltes BS konzipiert 

91: Erste Veröffentlichung 

94: comp.lang.python 

Heute 

Implementierungen: 

99: Jython, Java VM 

01: psyco, native Code 

06: IronPython, .Net 

07: PyPy, Python in Python, JIT 

10: Python on Android 

• Aktuell CPython 2.7/3.3, jython 2.7a, IronPython 2.7, PyPy 1.9 (2.7) 

• Aktive Entwicklergemeinde, sehr viele Bibliotheken, python.org 



Einführung 

Verbreitung 

Plattform für Anwendungen 

• Hunderte Skripte in /usr/bin 

• Blender, Maya: 3D-Graphik 

• Mercurial: Versionsmanagement 

• Trac: Projekt/Software Management 

• Google App Engine, Django, 

Raspberry Pi 

Interner Einsatz 

• Google, NASA, Yahoo, ILM 

Entwickler 

• Sehr weit verbreitet 

• Die meist genutzte “general purpose” 

Skriptsprache 

• Top Ten in TIOBE 

http://www.tiobe.com/index.php/content/ 

paperinfo/tpci/index.html 



Einführung 

Umgebung 

Interpreter und Tools 

• www.python.org/2.7.3 

• Integrierte Entwicklungsumgebung 

(IDLE), und interaktiver Interpreter 

Interaktive “Shell” in IDLE 

• Lernen der Sprache 

• Experimentieren mit der Bibliothek 

• Testen der eigenen Programme 

• Auswerten von allen Ausdrücken 

Alternativen: Emacs, eclipse pydev 

Online-Lektüren (neben Buch) 

• docs.python.org/2/tutorial/ 

• wiki.python.org/moin/BeginnersGuide 

• pythonchallenge.com, checkio.org 



Einführung 

IDLE Übersicht 

Interaktive Shell und Editoren 

• Im Editor mit F5 Programm in 

interaktiver Shell ausführen 

• Interaktive Shell ist kein Editor 

Integrierter Debugger 

• Stop, Over, Out 

• Mitlaufen Source 

• Anzeige Stack, lokale/globale 

Variablen 

• Seltener benötigt als in C 

• Interaktives Testen 

• Weniger Fehler in Python ;-) 

Alternativen 

• Emacs: solide, interaktiv 

• Eclipse pydev: mächtig, nicht interaktiv 



Einführung 

Encoding bei Python Skripten – Unicode einstellen 

Angabe der Zeichenkodierung 

• Erste Zeile im Skript 

# -*- coding: -*- 

oder zweite Zeile, falls erste 

#!/usr/bin/python 

• Spezieller Kommentar 

• Teilt python (und IDLE) das Encoding 

des Quelltexts mit 

Verfügbare Zeichenkodierungen 

• utf-8, empfohlen 

• Unicode: alle Sprachen 

• Ab Python 3.0 Standard 

• Sehr stark empfohlen 

• iso-8859-1, vermeiden 

1 #!/usr/bin/python 

2 # -*- coding: utf-8 -*- 

3 

4 print "Hello Python World" 

1 Shebang: Starte den 

Python-Interpreter mit dem folgenden 

Zeilen als interaktive Eingabe 

2 Encoding: Der ganze Quelltext, 

inklusive Kommentare und den Texten 

in Strings, ist in dem angegebenen 

Encoding 

Alle ausführbaren Programme 

mit Zeilen 1 und 2 beginnen 

• Standard Westeuropa, latin1 

• Böse: Mac-Roman, cp1285 



Erste Schritte 

Erste Schritte – Zahlen und Ausdrücke 

1 >>> print "Hallo Python Welt" 

2 Hallo Python Welt 

3 

4 >>> # Kommentare 

5 

6 

7 >>> 2 # Integer-Zahlen 

8 2 

9 

0 >>> 3.14 # Fliesskommazahlen 

1 3.14 

2 

3 >>> "String" # Zeichenketten 

4 ’String’ 

5 

6 >>> 0xff # Hex 

7 255 

8 

9 >>> 0377 # Oktal 

0 255 

1 >>> 6+2 # Ausdruecke 

2 8 

3 

4 >>> 6*2 

5 12 

6 

7 >>> 6/2 

8 3 

9 

10 >>> 6/5 # Vorgabe ganzzahlig (2.x) 

11 1 

12 

13 >>> 6//5 # Explizit ganzzahlig ([23].x) 

14 1 

15 

16 >>> 3**4 # Exponenten 

17 81 

18 

19 >>> 3+1j # Komplexe Zahlen 

20 (3+1j) 




Erste Schritte – Zuweisungen und Tests 

1 >>> x = 1 # Variablenzuweisung 

2 >>> x # hat den zugewiesenen Wert 

3 1 

4 

5 >>> x = y = 2 # Mehrfachzuweisung 

6 >>> x 

7 2 

8 >>> y 

9 2 

0 

1 >>> abs(-3) # eingebaute Funktionen 

2 3 

3 

4 >>> 0 < 1 # Tests 

5 True 

6 >>> 1 < 0 

7 False 

1 >>> True == 1 # Bool neuer Typ 

2 True 

3 >>> False == 0 

4 True 

5 

6 >>> 0 < 5 < 10 # Mehrfachtest 

7 True 

8 

9 >>> True and False 

10 False 

11 >>> True or False 

12 True 

13 

14 >>> not "eins" 

15 False 

16 >>> not False 

17 True 

18 

19 >>> "eins" and "zwei" # letzter Wert 

20 ’zwei’ 




Erste Schritte – Binäres Rechnen und Division 

1 >>> x = 2 # binaer ...000010 

2 

3 >>> x >> x & 0xff # binaeres Und 

7 2 

8 

9 >>> x | 1 # binaeres Oder 

0 3 

1 

2 >>> ~x # Komplement 

3 -3 

4 

5 >>> x^3 # binaeres XOR 

6 1 

1 >>> 3/2 # ganzzahlige Division (2.x) 

2 1 

3 >>> 3//2 # ganzzahlige Division ([23].x) 

4 1 

5 >>> 3.0/2 # Hochkonvertieren 

6 1.5 

7 >>> 3.0//2 # Abschneiden 

8 1.0 

9 >>> 3./2 # 0 nicht notwendig 

10 1.5 

11 >>> 10 % 3 # Module, Rest 

12 1 

13 >>> 10 // 3 # ganzzahlig 

14 3 

15 >>> 3*(10//3) + (10%3) 

16 10 

17 >>> 10.0//3 # erzwungen ganzzahlig 

18 3.0 # anderer Typ 

19 >>> 10.0/3 

20 3.3333333333333335 




Große Zahlen und Konvertierung 

1 >>> 3e10 # Exponentenschreibweise 

2 30000000000.0 

3 

4 >>> 2**10 # Potenzieren 

5 1024 

6 >>> 2**20 # grosse ganze Zahl 

7 1048576 

8 >>> 2**1000 # sehr grosse ganze Zahl 

9 107150860718626732094842504906000181 

0 056140481170553360744375038837035105 

1 112493612249319837881569585812759467 

2 291755314682518714528569231404359845 

3 775746985748039345677748242309854210 

4 746050623711418779541821530464749835 

5 819412673987675591655439460770629145 

6 711964776865421676604298316526243868 

7 37205668069376L 

1 >>> 3L # explizit grosse Zahlen 

2 3L 

3 >>> float(3) # explizite Konvertierung 

4 3.0 # in double 

5 >>> int(3.0) # und zurueck 

6 3 

7 >>> long(3.0) # explizite Konvertierung 

8 3L 

9 >>> int("12") # auch fuer Strings 

10 12 

11 >>> int("11", 16) # explizite Basis 

12 17 

13 

14 >>> int("zwoelf") # nur wenn moeglich 

15 # ansonsten Ausnahme 

16 Traceback (most recent call last): 

17 File "", line 1, in 

18 ValueError: invalid literal for int() 

19 with base 10: ’zwoelf’ 



Datentypen, Zahlen 

Zahlen und Operationen 

Zahlentypen 

• ganze Zahlen, int und long (beliebig lang) 

• Gleitkommazahlen, float mit double Genauigkeit, 

komplexe Zahlen 

• Intuitive Darstellung und Eingabe 

Alle üblichen arithmetischen Operationen 

• Standardarithmetik: +, -, * , /, ** , %, // 

• Logische Arithmetik: ~, ^, |, &, 

• Vorrangregeln und Klammern wie gewohnt 

1 Python 2.7.3 

2 >>> 3/2 

3 1 

4 >>> 3//2 

5 1 

1 Python 3.2.3 ... 

2 >>> 3/2 

3 1.5 

4 >>> 3//2 

5 1 

Boolesche Werte: False, True 

• Entspricht 0 und 1 (Historie) 

1 

2 

>>> 0 or "" 

or "Hallo" 

• Oder leerer String, nichtleerer String, . . . 

3 or "Welt" 

Logische Ausdrücke: and, or, not 

• Erstes bestimmendes Element wird zurück gegeben 

• Die andere Argumente werden nicht ausgewertet 

4 ’Hallo’ 




Ausdrücke 

Aufrufe von Funktionen und Methoden 

• Funktionsaufrufe 

• Methodenaufrufe 

• Interaktive Ausgabe des Wertes 

• Zusammengesetzte Ausdrücke 

• Bereichstests 

Werte ausgeben in der interaktiven 

Kommandozeile 

• Zuweisungen haben keinen Wert 

• Wert von Ausdrücken wird 

ausgegeben 

• print für explizite Ausgabe 

1 >>> lis = [3,1,2] 

2 >>> len(lis) # Funktionsaufruf 

3 3 

4 >>> lis.append(8) # Methode 

5 >>> lis # Ausgabe 

6 [3, 1, 2, 8] 

7 >>> len(lis) < 6 and len(lis) 

8 # Zusammengesetzt 

9 4 

10 >>> 1 < len(lis) < 8 # Bereich 

11 True 

1 >> lis 

2 [3, 1, 2] 

3 >>> print lis # 2.x 

4 [3, 1, 2] 

5 >>> print(lis) # 2.x, 3.x 

6 [3, 1, 2] 




Ausgabe mit print 

Ausgabe von Objekten mit print 

• Lesbare Ausgabe von Objekten 

• Ausgabe aller Objekte durch 

Leerzeichen getrennt 

• Mit Komma am Ende wird 

Zeilenumbruch unterdrückt 

• Ausgabe mit Formatstring, wie in C, 

%-Operator 

• Python 3.x, nur noch in Klammern 

(jetzt schon möglich) 

Alternative 

• Ausgabe wie in Java 

1 >>> lis = [1,2,3] 

2 >>> print lis, "zwei", 4 

3 [1, 2, 3] zwei 4 

4 >>> print lis,"zwei",4; print "weiter" 

5 [1, 2, 3] zwei 4 

6 weiter 

7 >>> print lis,"zwei",4,; print "weiter" 

8 [1, 2, 3] zwei 4 weiter 

9 >>> print "%s %s" % ("Hallo", "Welt") 

10 Hallo Welt 

11 >>> print(lis) 

12 [1, 2, 3] 

1 >>> import sys 

2 >>> sys.stdout.write("Hallo Welt\n") 

3 Hallo Welt 



Datentypen, Strings 

Zeichenkette, Strings – Darstellung 

Syntax 

• Einfache oder doppelte 

Anführungszeichen 

• Nicht limitierendes Anführungszeichen 

nutzbar 

• Alternativ Escape-Zeichen verwenden 

Backslash \ 

1 >>> "hallo" 

2 ’hallo’ 

3 >>> ’hallo’ 

4 ’hallo’ 

1 >>> "spam’s" 

2 "spam’s" 

3 >>> ’spam"s’ 

4 ’spam"s’ 

5 >>> ’spam\’s’ 

6 "spam’s" 

Mehrzeilige Strings 

• Drei Anführungszeichen am Anfang 

und am Ende 

• Zeilenendezeichen als \n verfügbar 

• Alle Anführungszeichen verwendbar 

1 >>> """hallo 

2 ... du "tolle" 

3 ... ’perfekte’ Welt """ 

4 ’hallo\n du "tolle"\n 

\’perfekte\’ Welt ’ 




Strings – Operationen 

Alle üblichen Operationen vorhanden 

+ Konkatenation 

* Wiederholung 

[+i] Indizierung 

positive Zahl, 0 ist erstes Zeichen 

[-i] Indizierung von hinten 

negative Zahl, -1 ist letztes Zeichen 

• Slicing 

[von:bis] Ausschnitt von inklusive, bis exklusive 

[von:] Ausschnitt bis Ende 

[:bis] Ausschnitt ab Anfang 

[:] Gesamt (Kopie) 

1 >>> "Hallo" + " Welt" 

2 ’Hallo Welt’ 

3 >>> "Hallo"*3 

4 ’HalloHalloHallo’ 

5 >>> "Hallo"[0] 

6 ’H’ 

7 >>> "Hallo"[-1] 

8 ’o’ 

1 >>> "Hallo"[1:3] 

2 ’al’ 

3 >>> "Hallo"[1:] 

4 ’allo’ 

5 >>> "Hallo"[:-1] 

6 ’Hall’ 




Slicing 

"SLICEOFSPAM"[von:bis] 

• von, einschließend 

• bis, ausschließend 

Vorzeichen 

• Positive Zahlen, von links, ab 0 

• Negative Zahlen, von rechts, ab -1 

Dritter Parameter Schrittweite 

• "SLICEOFSPAM"[von:bis:step] 

• Schrittweite, normalerweise 1 

Geht auch mit Listen (später) 

0 1 2 3 4 5 6 7 8 9 10 

s l i c e o f s p a m 

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 

1 >>> "sliceofspam"[2:-1] 

2 ’iceofspa’ 

3 >>> "sliceofspam"[5:] 

4 ’ofspam’ 

5 >>> "sliceofspam"[:5] 

6 ’slice’ 

7 >>> "sliceofspam"[2:5] 

8 ’ice’ 

1 >>> "sliceofspam"[2:-1:3] 

2 ’iop’ 

3 >>> "sliceofspam"[::4] 

4 ’sep’ 

5 >>> lis = [0,1,2,3,4,5,6,7] 

6 >>> lis[::2], lis[1::2] 

7 ([0, 2, 4, 6], [1, 3, 5, 7]) 




Strings – Formatierung und Builtins 

Formatierung 

• Formatstring und Argumente 

• Ähnlich zu C, printf 

• %s String 

• %d Zahl 

• %x Hexadezimal 

• %e, %f, %g Gleitkommaformate 

• %% Prozentzeichen 

Benamtes Argument 

• %() 

• Durch bestimmter Wert in 

Abbildung als Argument 

• Gefolgt von Argumenttyp 

1 >>> "ein %s Papagei" % "toter" 

2 ’ein toter Papagei’ 

3 >>> "%d %s Papageie" % (2, "tote") 

4 ’2 tote Papageie’ 

5 >>> "%x" % 42 

6 ’2a’ 

7 >>> "%X" % 42 

8 ’2A’ 

9 >>> "%e %f %g" % (1.1, 1.2, 1.3) 

10 ’1.100000e+00 1.200000 1.3’ 

11 >>> "%%%s%%" % "hallo" 

12 ’%hallo%’ 

1 >>> "%(name)s heisst %(name)s" % 

2 {"name": "Eric"} 

3 ’Eric heisst Eric’ 




Strings – Builtins und raw Strings 

Eingebaute Funktionen, Builtins 

• Länge mit len 

• Standardoperationen für Vergleich 

• Test auf Enthaltensein mit in 

raw Strings 

• Steuerzeichen quotieren 

• Hilfreich bei regulären Ausdrücken, 

später 

1 >>> len("Hallo") 

2 5 

3 >>> "hallo" < "wallo" 

4 True 

5 >>> "al" in "Hallo" 

6 True 

1 >>> r"raw \n string" 

2 ’raw \\n string’ 

3 >>> print r"raw \n string" 

4 raw \n string 

5 >>> "normaler \n string" 

6 ’normaler \n string’ 

7 >>> print "normaler \n string" 

8 normaler 

9 string 




Strings – weitere Features 

string-Modul 

• als Modul “importieren” 

• Funktionen oder String-Methoden 

• Groß- und Kleinschreibung 

• Suchen, finden, ersetzen 

• Konvertieren, splitten, kleben 

• Konkatenation automatisch 

• Leerzeichen entfernen 

Kommandozeilenargumente 

• Modul sys 

• Liste von Argumente sys.argv 

$ python argv.py a b c d 

[’argv.py’, ’a’, ’b’, ’c’, ’d’] 

1 >>> import string 

2 >>> "ab".upper(), string.upper("ab") 

3 (’AB’, ’AB’) 

4 >>> string.find("spammify", "mm") 

5 3 

6 >>> string.atoi("42") # int("42") besser 

7 42 

8 >>> string.split("spammify"), "mm") 

9 [’spa’, ’ify’] 

10 >>> "XX".join(["spa", "ify"]) 

11 ’spaXXify’ 

12 >>> "spa" "XX" "ify" 

13 ’spaXXify’ 

14 >>> string.strip(" Meaning of Life ") 

15 ’Meaning of Life’ 

1 #!/usr/bin/python 

2 import sys 

3 print sys.argv 




Eigenschaften von Strings 

Strings sind unveränderlich 

• Operation mit Strings (+, [], etc.) 

erzeugen immer neue Strings 

• Vorhandene Strings werden niemals 

verändert 

Strings sind Sequenzen 

• Geordnet, die Position der Elemente 

ist wichtig 

• Klare Menge von unterstützten 

Operationen 

• Sequenz von Zeichen 

Unicode Strings 

• u vor dem String 

• Typ unicode, nicht str 

1 >>> s = "hallo" 

2 >>> s[0] = "H" 



5 TypeError: ’str’ object does not 

6 support item assignment 

1 >>> s = u"hallo" 

2 >>> s 

3 u’hallo’ 

4 >>> s == "hallo" 

5 True 

6 >>> type("hallo"), type(u"hallo") 

7 (, ) 

8 >>> u"hallo" == "hallo" 

9 True 

>>> "hällo" == u"hällo" 

__main__:1: UnicodeWarning: Unicode 

equal comparison failed... 



Datentypen, Typhierarchie 

Typhierarchie eingebauter Typen 

object als Wurzel für alle Typen 

isinstance zum Testen 

1 >>> isinstance(3, int) 

2 True 

3 >>> isinstance(3, object) 

4 True 

object 

Ganze 

Zahlen 

Zahlen 

float 

Kollektionen 

Sequenzen Mengen Abbildungen 

unveränderlich veränderlich set dict 

int 

complex 

str 

list 

long 

fractions. 

Fraction 

unicode 

tuple 



Kollektionen 

Kollektionen 

Eingebaute Kollektionen 

• Eingebaute Typen zum Verwalten von mehreren Objekten 

• Teil der Sprache, nicht nur der Bibliothek 

Vorteile 

• Effiziente Implementierung 

• Einfache Formulierung 

• Konzentration aufs Problem 

nicht auf technische 

Implementierungsdetails 

Umfangreich 

• Alles was man braucht 

• Ungefähr java.util.* 

• Strings, Listen, Tupel, 

Mengen, Wörterbücher 

object 

Kollektionen 

Sequenzen Mengen Abbildungen 

unveränderlich 

str 

unicode 

tuple 

veränderlich 

list 

set 

dict 



Kollektionen, Tupel 

Tupel – Sequenz 

Tupel sind eine Sequenz 

• Syntax n-Tupel, n≥ 2 wie erwartet 

• 1-Tupel hat spezielle Syntax 

(1) wäre nur ein arithmetischer 

Ausdruck mit Klammerung 

• Leeres Tupel wie erwartet 

Beliebig kombinierbar 

• Beliebige Typen, schachtelbar 

Indizierung 

• mit [] 

• Slicing (wie mit allen Sequenzen) 

Ergebnis ist wieder Tupel 

1 >>> (1, 2) 

2 (1, 2) 

3 >>> (1, 1, 1) 

4 (1, 1, 1) 

5 >>> (1, ) 

6 (1,) 

7 >>> (1) 

8 1 

9 >>> () 

10 () 

11 >>> (1, "eins", 2.0, (34, 4)) 

12 (1, ’eins’, 2.0, (34, 4)) 

13 >>> tup = (1, "zwei", (3, 4)) 

14 >>> tup[0] 

15 1 

16 >>> tup[2][1] 

17 4 

18 >>> tup[1:] 

19 (’zwei’, (3, 4)) 




Tupel – Builtins 

Builtins von Sequenzen 

• Länge mit len 

• Konkatenation mit + 

• Wiederholung mit * 

• Test auf Enthaltensein mit in 

Automatisch Tupel 

• Auch ohne Klammern 

Tupelzuweisung 

• Nette Syntax 

• Geht auch ohne Klammern 

• Gut bei Rückgabewerten 

1 >>> tup = (1, "zwei", (3, 4)) 

2 >>> len(tup) 

3 3 

4 >>> tup + tup 

5 (1, ’zwei’, (3, 4), 1, ’zwei’, (3, 4)) 

6 >>> tup*2 

7 (1, ’zwei’, (3, 4), 1, ’zwei’, (3, 4)) 

8 >>> (3, 4) in tup 

9 True 

1 >>> 1, 2 

2 (1, 2) 

3 >>> (1, 2) 

4 (1, 2) 

5 >>> (a, b) = (1, 2) 

6 >>> print a, b 

7 1 2 

8 >>> b, a = a, b 

9 >>> a, b 

10 (2, 1) 




Tupel – Unveränderliche Sequenz 

Tupel sind unveränderlich 

• Operationen mit Tupel erzeugen 

neue Tupel 

• Achtung! Tupel kann veränderliche 

Werte als Tupelelemente haben 

Tupel sind Sequenzen 

• Geordnet 

• Klare Menge unterstützter 

Operationen 

• Sequenz von Werten beliebigen Typs 

im Gegensatz zu Strings (nur Zeichen) 

1 >>> tup = (1,2,3) 

2 >>> tup[1] = "zwei" 



5 TypeError: ’tuple’ object does not 

6 support item assignment 

7 >>> tup = (1, [], 3) 

8 >>> tup[1].append("zwei") 

9 >>> tup 

10 (1, [’zwei’], 3) 



Kollektionen, Listen 

Listen – Sequenz 

Syntax wie Tupel 

• Umschlossen mit [ und ] 

• Keine spezielle Syntax mehr für 

einelementige Listen 

• Leere Liste mit [] 

Beliebig kombinierbar und schachtelbar 

• Auch mit Tupel 

Sonst wie Tupel 

1 >>> [1, 2, 3] 

2 [1, 2, 3] 

3 >>> [1], [] 

4 [1], [] 

5 >>> [1, [2, "zwei"], (3, "drei")] 

6 [1, [2, ’zwei’], (3, ’drei’)] 

7 >>> lis = [1, [2, "zwei"], (3, "drei")] 

8 >>> lis[0] 

9 1 

10 >>> lis[1:] 

11 [[2, ’zwei’], (3, ’drei’)] 

12 >>> lis[2][0], len(lis) 

13 (3, 3) 

14 >>> lis + [4,5] 

15 [1, [2, ’zwei’], (3, ’drei’), 4, 5] 

16 >>> 1 in lis 

17 True 

18 >>> (lis*2)[1:-2] 

19 [[2, ’zwei’], (3, ’drei’), 1] 




Listen – Veränderliche Sequenz 

Ändern 

• Zuweisung von Teilen 

• Löschen 

Kopien und Zuweisung 

• Operationen erzeugen Kopien 

• Nachträgliches Verändern der 

Parameter ohne Einfluss 

Flache Kopien 

• Kopien nur auf oberster Ebene 

• Erzeugen neuer Listenstruktur 

• Die Elemente werden nicht kopiert, 

sondern nur Referenzen 

• Ändern der Elemente ist sichtbar 

1 >>> lis = [1, 2, 3] 

2 >>> lis[0] = "eins" 

3 >>> lis 

4 [’eins’, 2, 3] 

5 >>> del lis[0] 

6 >>> lis 

7 [2, 3] 

1 >>> lis, kat = ["a", "b"], ["c", "d"] 

2 >>> lk = lis + kat 

3 >>> lk 

4 [’a’, ’b’, ’c’, ’d’] 

5 >>> lis[0] = "X" 

6 >>> lis, lk 

7 ([’X’, ’b’], [’a’, ’b’, ’c’, ’d’]) 

8 >>> tup = (lis, kat) 

9 >>> tup 

10 ([’X’, ’b’], [’c’, ’d’]) 

11 >>> lis[1] = "Y" 

12 >>> tup 

13 ([’X’, ’Y’], [’c’, ’d’]) 




Listen – Zuweisungen 

Zuweisungskompatibilität 

• Sequenzen sind untereinander 

zuweisungskompatibel 

Slice-Zuweisung möglich 

• Der Bereich wird durch Sequenz als 

Liste ersetzt 

Destruktive Methoden 

• append und extend ändern gegebene 

Liste, kein Rückgabewert 

• del ändert Liste 

• Zuweisung an Index ändert Liste 

1 >>> lis = [1, 2, 3] 

2 >>> lis[1:2] = ("zwei", "two") 

3 >>> lis 

4 [1, ’zwei’, ’two’, 3] 

5 >>> lis[1:2] = ["zwei", "two"] 

6 >>> lis 

7 [1, ’zwei’, ’two’, ’two’, 3] 

8 >>> lis.append(4) 

9 >>> lis 

10 [1, ’zwei’, ’two’, ’two’, 3, 4] 

11 >>> lis.extend([5, 6]) 

12 >>> lis 

13 [1, ’zwei’, ’two’, ’two’, 3, 4, 5, 6] 

14 >>> del lis[1:3] 

15 >>> lis 

16 [1, ’two’, 3, 4, 5, 6] 

17 >>> lis[1] = 2 

18 >>> lis 

19 [1, 2, 3, 4, 5, 6] 




Listen – Weitere Methoden 

range generiert Zahlenliste 

• Anfang, erstes Argument, optional 

(default 0) 

• Ende, zweites Argument 

• Schrittweite, drittes Argument, optional 

(default 1) 

Weitere destruktive Methoden 

• pop, insert 

Kellerverhalten und mehr 

• reverse, sort, sorted 

klassische Listenoperationen 

1 >>> lis = [4, 3, 2.5, 2, 1, 0, -1] 

2 >>> sorted(lis) 

3 [-1, 0, 1, 2, 2.5, 3, 4] 

4 >>> lis.sort(); lis 

5 [-1, 0, 1, 2, 2.5, 3, 4] 

1 >>> range(5) 

2 [0, 1, 2, 3, 4] 

3 >>> range(1, 5) 

4 [1, 2, 3, 4] 

5 >>> range(0, 50, 10) 

6 [0, 10, 20, 30, 40] 

7 >>> lis = range(5) 

8 >>> lis.append(5); lis 

9 [0, 1, 2, 3, 4, 5] 

10 >>> lis.pop() 

11 5 

12 >>> lis 

13 [0, 1, 2, 3, 4] 

14 >>> lis.insert(0, -1); lis 

15 [-1, 0, 1, 2, 3, 4] 

16 >>> lis.insert(4, 2.5); lis 

17 [-1, 0, 1, 2, 2.5, 3, 4] 

18 >>> lis.reverse(); lis 

19 [4, 3, 2.5, 2, 1, 0, -1] 




Listen – Eine weitere Sequenz, veränderlich 

Listen sind veränderlich 

• Sequenz-Operationen 

unveränderlicher Operationen mit 

Listen erzeugen neue Listen auf 

oberster Ebene 

• Spezielle destruktive 

Listen-Operationen, ohne Wert 

Listen sind Sequenzen 

• Ähnlich zu Feld (ArrayList) in Java 

• Laufzeitverhalten ähnlich zu Feld 

Warum Listen und Tupel? 

• Bei gemischten Typen eher Tupel; 

bei Liste möglich, nicht intuitiv 

• Unveränderliches Tupel effizienter 

• Tupel kann als Schlüssel im 

Wörterbuch genutzt werden 

1 >>> lis = [1, 2, 3] 

2 >>> lis[1] = "zwei" 

3 >>> lis 

4 [1, ’zwei’, 3] 


6 >>> lis 

7 [1, ’zwei’, 3, 4] 

1 >>> (1, "ab") 

2 (1, ’ab’) 

3 >>> [1, "ab"] 

4 [1, ’ab’] 



Kollektionen, Wörterbücher 

Dictionaries, Wörterbücher 

Dictionary, Wörterbuch 

• Abbildung unveränderlicher Werte 

(Schlüssel) auf beliebigen Werten 

• Syntax für Zugriff und Zuweisung wie 

beim Feld 

• Realisiert über Hashing 

Vorteile 

• Verwendung einfach und intuitiv 

11 

• Schlüssel nicht beschränkt auf Zahlen >>> dic.keys() 

12 [’eggs’, ’spam’] 

• Keine Feldgröße notwendig 

13 >>> dic.values() 

Dictionaries und Sequenzen 

14 [42, 3] 

• Schlüsselmenge (Sequenz), 

Wertemenge und Tupelmenge 

Schlüssel/Wert erzeugbar 

• Test auf Enthaltensein gegen 

Schlüsselmenge 

1 >>> dic = {} 

2 >>> dic = { ’spam’ : 2 } 

3 >>> dic[’spam’] 

4 2 

5 >>> dic[’spam’] = 3 

6 >>> dic 

7 {’spam’: 3} 

8 >>> dic[’eggs’] = 42 

9 >>> dic 

10 {’eggs’: 42, ’spam’: 3} 

15 >>> dic.items() 

16 [(’eggs’, 42), (’spam’, 3)] 

17 >>> ’eggs’ in dic 

18 True 

19 >>> dic.has_key(’spam’) 

20 True 




Dictionaries – Builtins und Schlüsseleigenschaften 

Eingebaute Funktionen 

• len für Anzahl Schlüssel 

• del zum Löschen 

• Keine Slicing-Operationen 

Dictionary ist keine Sequenz 

Schlüssel unveränderlich 

• Intern mit Hashing realisiert 

• Zahlen, Strings, etc. 

• Tupel (auch tiefe Strukturen) sind 

erlaubt 

Ausnahme bei nicht vorhandenem 

Schlüssel 

1 >>> dic = {’eggs’: 42, ’spam’: 3} 

2 >>> len(dic) 

3 2 

4 >>> del dic[’eggs’]; dic 

5 {’spam’: 3} 

6 >>> dic[0:] 



9 TypeError: unhashable type 

10 >>> dic[(1,2)] = ’tupel’ 

11 >>> dic 

12 {(1, 2): ’tupel’, ’spam’: 3} 

13 >>> dic[[1,2]] = ’liste’ 



16 TypeError: unhashable type: ’list’ 

17 >>> dic[’cheese’] 



20 KeyError: ’cheese’ 




Dictionaries – Veränderliche Abbildungen 

Dictionaries sind veränderlich 

• Zuweisung mit neuem Schlüssel fügt neue Elemente hinzu 

• Zuweisung mit existierendem Schlüssel überschreibt Wert 

• del löscht Schlüssel/Wert Zuordnung 

Dictionaries sind die einzigen Abbildungen 

• Ungeordnet (keine Sequenz), Zugriff nur über Schlüssel 

• Feste Menge von unterstützten Operationen 

• Zugriff zu beliebigen Objekten beliebigen Typs (Werte) 

• Zugriff über beliebige unveränderliche Objekte (Schlüssel) 

• Unveränderlicher Schlüssel 

• Wegen interner Implementierung mit Hashing 

• Sonst würde man Wert nicht wiederfinden 

• Siehe Algorithmen und Datenstrukturen 



Kollektionen, Mengen 

Mengen – Veränderlich, keine Reihenfolge 

Mengen 

• Keine doppelten Elemente 

• Keine Reihenfolge, keine Sequenz 

• Realisiert wie Dictionaries, 

nur ist der Wert egal 

Eingebaute Funktionen und Operationen 

• len für Anzahl Elemente 

• in für Test auf Enthaltensein 

• Mengenoperationen mit | und & 

1 >>> s = set() 

2 >>> s.add(1) 

3 >>> s 

4 set([1]) 

5 >>> s.add(2); s.add(3) 

6 >>> s 

7 set([1, 2, 3]) 

8 >>> s.add(2) 

9 >>> s 

10 set([1, 2, 3]) 

11 >>> 2 in s 

12 True 

13 >>> 4 in s 

14 False 

15 >>> len(s) 

16 3 

17 >>> s | set([2,3,4]) 

18 set([1, 2, 3, 4]) 

19 >>> s & set([2,3,4]) 

20 set([2, 3]) 



Dateien 

Dateien 

Modul os für Systemoperationen 

• chdir um Verzeichnis zu wechseln 

• getcwd um Verzeichnis anzuzeigen 

• Unix und Windows Notation 

Dateien 

• 

8 

file ist eigener Datentyp 

938848 

9 >>> inhalt[700539:700600] 

• Konstruktor mit Dateiname und 

10 "python\npython’s\npythons\npyx\npyx’s 

Bearbeitungsart (r lesen, w schreiben, 

11 \npyxes\nq\nqua\nquack\nquack’s\nq" 

a erweitern) 

12 >>> eingabe.close() 

• read zum Lesen der gesamten! Datei 

• readlines für String-Liste der Zeilen 

• close Schließen optional, über 

Garbage Collector 

• Schreiben funktioniert ähnlich 

1 >>> import os 

2 >>> os.chdir(’/usr/share/dict’) 

3 >>> os.getcwd() 

4 ’/usr/share/dict’ 

5 >>> eingabe = file("words", "r") 

6 >>> inhalt = eingabe.read() 

7 >>> len(inhalt) 

13 >>> os.chdir(’/tmp’) 

14 >>> ausgabe = file(’wordskopie’, ’w’) 

15 >>> ausgabe.write(inhalt) 

16 >>> ausgabe.close() 



Typen 

Typ-Überprüfung und Konversion 

Test welcher Typ 

• type gibt Typ zurück 

• isinstance testet ob von Typ 

• Vergleich und Auswahl von Typen 

Typkonvertierung 

• Typname als Funktionsaufruf 

Typen 

• int, long, float, complex 

• str, list, tuple 

• dict, . . . 

Konversion von/zu Zeichen 

• Zeichen in Python keine Zahl, 

nicht vorhanden 

• ord und chr 

1 >>> type([]) 

2 

3 >>> lis = [1,2,3]; type(lis) 

4 

5 >>> type(lis)==list, type(lis)==type({}) 

6 True, False 

7 >>> isinstance(lis, list) 

8 True 

9 >>> int, long, float, complex 

10 (, , 

11 , ) 

12 >>> str, list, tuple, dict 

13 (, , 

14 , ) 

15 >>> int("12") 

16 12 

17 >>> list("123") 

18 [’1’, ’2’, ’3’] 

19 >>> ord(’A’), chr(65) 

20 (65, ’A’) 



Typen 

Die Doku ist Dein Freund 

Dokumentation 

• docs.python.org 

• Tutorial, sehr guter Einstieg 

• Bibliothek, die Referenz für 

alle eingebauten und 

anderen Objekte, 

Funktionen, Module 



Variablen 

Variablen 

Verwendung 

• Müssen nicht deklariert werden 

• Müssen vor erster Verwendung 

initialisiert werden 

Typ, dynamisch und streng 

• Dynamische Typisierung, Variable an 

alles bindbar 

• Strenge Typisierung, Gebundenes 

Objekt hat Typ 

Syntaxspezialitäten 

• Zuweisung hat keinen Wert 

• Mehrfachzuweisung möglich 

• Tupelzuweisung 

Gültige Variablenbezeichner wie in Java, 

keine Schlüsselwörter 

1 >>> x = 3 

2 >>> x 

3 3 

4 >>> y 

5 NameError: name ’y’ is not defined 

6 >>> x = 3 

7 >>> x = "Hallo" 

8 >>> x = 3; x + 3 

9 6 

10 >>> x = "3"; x + 3 

11 TypeError: cannot concatenate 

12 ’str’ and ’int’ objects 

1 >>> x = y = 3 

2 >>> x, y = 3, 4 

3 >>> x, y 

4 (3, 4) 



Variablen 

Zuweisung und Ausdrücke 

Gleichheit und Identität 

• Alles ist ein Objekt 

• Gleichheit ==, Objektidentität is 

Zuweisung 

• Variablen sind Namen, die an Objekte 

gebunden sind 

• Rechte Seite einer Zuweisung gibt 

Objekt (vorhandenes oder neues) 

9 

10 

[1, 2, 3] 

>>> lis = [1, 2, 3] 

zurück 

11 >>> kat = lis[:] # Kopie 

12 >>> lis == kat, lis is kat 

• Linke Seite einer Zuweisungen ist eine13 (True, False) 

Name an den Objekt gebunden wird 

Ausdrücke evaluieren zu neuen Objekten 

• Die Sequenz von Anfang bis Ende ist 

ein Ausdruck 

• [:] macht eine (flache) Kopie 

1 >>> lis = [1, 2, 3] 

2 >>> kat = [1, 2, 3] 


4 (True, False) 


6 >>> lis 

7 [1, 2, 3, 4] 

8 >>> kat 

lis 

kat 

1 2 3 

1 2 3 

4 



Variablen 

Referenzsemantik 

Referenzsemantik 

• Variablen sind Namen, die an Objekte 

gebunden sind 

• Rechte Seite einer Zuweisung gibt 

Objekt (vorhandenes oder neues) 

zurück 

• Linke Seite einer Zuweisungen ist eine 

Name an den Objekt gebunden wird 

Namen evaluieren zu dem gebundenem 

Objekt 

• Änderungen von Objekten über alle 

Referenzen sichtbar 

1 >>> lis = [1, 2, 3] 

2 >>> kat = lis 


4 (True, True) 


6 >>> lis 

7 [1, 2, 3, 4] 

8 >>> kat 

9 [1, 2, 3, 4] 

lis 

kat 

1 2 3 

4 




Kontrollstrukturen – Verzweigung 

Verzweigung 

• Schlüsselwörter: if, elif, else 

• : Ausdruck, der als 

Wahrheitswert interpretiert wird 

• : Beliebige Folge von 

Anweisungen 

Syntax 

• Bedingung endet mit Doppelpunkt, 

Keine Klammern notwendig 

• ACHTUNG! Einrückung ist signifikant 

und Teil der Syntax 

• Block durch Einrücktiefe bestimmt 

• Einrückung Tabulator oder gleiche 

Anzahl an Leerzeichen 

• Keine (geschweiften) Klammern! 

Einzeiler möglich, vermeiden 

if : 

 

[elif : 

]* 

[else: 

] 

1 if 0 == 0: 

2 print "ja" 

3 if "nichtleerer String": 

4 print "ja" 

5 else: 

6 print "nein" 

7 if 0: 

8 print "eins" 

9 print "zwei" 

10 print "drei" 

11 if 1: print "eins" 




if/else Ausdruck statt ?-Operator 

Syntax ungewöhnlich 

• Erst Ergebniswert im “normalen” 

Fall 

• Dann Bedingung 

• Dann “alternativer” Fall 

Alternative mit booleschem 

Ausdruck 

• and und or evaluieren nur so 

weit wie notwendig 

• Nachbau mit and/ormöglich 

• Problematisch wenn “normaler” 

Wert äquivalent zu falsch ist 

• Nicht mehr statt if/else 

verwenden 

if else 

// in Java, C 

? : 

1 >>> x, y = 1, 2 

2 >>> e = "kleiner" if x>> e 

4 ’kleiner’ 

and or 

1 >>> x, y = 1, 2 

2 >>> e = x>> e 

4 ’kleiner’ 




Kontrollstrukturen – while-Schleife 

while-Schleife 

• Schlüsselwörter: while, else, break, 

continue, pass 

• else-Zweig nur, wenn Schleife ohne 

break verlassen wurde 

• pass, leere Anweisung, macht nichts, 

Ersatz für {} 

Syntax 

• Wieder Einrücken als integraler 

Bestandteil der Schleifensyntax 

while : 

 

[else: 

] 

1 lis = [1, 2, 3, 4] 

2 while lis: 

3 print lis.pop() 

4 else: 

5 print "Ende" 

4 

3 

2 

1 

Ende 




Kontrollstrukturen – for-Schleife 

for-Schleife 

• Schlüsselwörter: for, in, break, 

continue, pass 

• Iterieren über Elemente in Sequenzen 

• in wählt Elemente aus Sequenz 

sukzessive aus und weist sie je 

Durchlauf der Variable zu 

• Klassische Schleife über Indexe nur 

nach als Nachbau mit range 

range 

• range(von, bis, step) 

• Erzeugt eine Liste von Zahlen von 

inklusive, bis exklusive 

• von optional, default 0 

• step optional, default 1 

for in : 

 

[else: 

] 

1 for ele in ["Hallo", "Welt"]: 

2 print ele 

3 for idx in range(1, 4): 

4 print idx 

5 for ch in "Hi": 

6 print ch 

Hallo 

Welt 

1 

2 

3 

H 

i 




Kontrollstrukturen – for-Schleife, Dictionaries 

for-Schleife und Dictionaries 

• Fragt Objekte, ob sie auch eine 

Sequenz sein können 

• Das Dictionary sagt, ja, dann bin ich 

eine Sequenz der Schlüssel 

• Dann wird über die Schlüssel iteriert 

Auch nett mit items und Tupelzuweisung 

1 dic = { 1: ’eins’, 2: ’zwei’ } 

2 for key in dic: # wie dic.keys() 

3 print key, dic[key] 

1 eins 

2 zwei 

1 dic = { 1: ’eins’, 2: ’zwei’ } 

2 print dic.items() 

3 for key, value in dic.items(): 

4 print key, value 

[(1, ’eins’), (2, ’zwei’)] 

1 eins 

2 zwei 




Kontrollstrukturen – for-Schleife, typischer Einsatz 

Klassische for-Schleife 

• Durchlaufen von Index-Werten 

• Sequenz von Index-Werten, mit range 

erzeugt 

• Selten benötigt 

• Java/C Idiom, weniger Python 

Feldzugriff vermeiden 

• Keine expliziten Indexvariablen 

• Eleganter 

• Kein Indexfehler möglich! 

• Funktioniert für alle Sequenzen 

1 for idx in range(100): # 0-99 in Python 

2 print idx 

1 // 0-99 in Java 

2 for(int i=0; i < 100; i+=1) { 

3 System.out.println(idx); 

4 } 

1 for ele in arr: # Feldzugriff in Python 

2 print ele 

1 // Feldzugriff in Java 

2 for(int i=0; i < arr.length; i+=1) { 

3 System.out.println(arr[i]); 

4 } 

1 for e in (0, 1, 2, 3): # alle Sequenzen 

2 print e 




Schleifenbeispiel – Dateiinhalte durchlaufen 

Dateien mit while 

• Endlosschleife mit break 

• Einlesen bis Fehlschlag 

• Schließen optional, aber guter Stil 

Dateien mit for 

• Eleganter 

• Alles Einlesen in eine Liste 

Noch Eleganter 

• Default Datei-Aktion ist lesen 

• Default ist zeilenweise einlesen 

• Automatisch schließen, da offene 

Datei nicht gebunden 

1 # C-Style :-( 

2 eingabe = file("dat.txt", "r") 

3 while True: 

4 line = eingabe.readline() 

5 if not line: 

6 break 

7 print line 

8 eingabe.close() 

1 # Besser :-| 

2 eingabe = file("dat.txt", "r") 

3 for line in eingabe.readlines(): 

4 print line 

5 eingabe.close() 

1 # Python-Style :-) 

2 for line in file("dat.txt"): 

3 print line 




Hinweise zu Kontrollstrukturen 

Beim Editieren 

• Vergessen Sie die Doppelpunkte nicht 

• Beginnen Sie immer in der ersten Spalte 

• Rücken Sie konsistent ein (nur Leerzeichen oder nur Tabulatoren) 

• Rücken Sie immer gleich weit ein (4 Zeichen) 

• Oder am besten alles mit der IDLE 

Leerzeilen beenden im interaktiven Modus einen Anweisungsblock 

Erwarten Sie nicht immer ein Ergebnis 

• Beispiel: append 

Schreiben Sie nicht Java/C in Python! 



Funktionen 

Funktionen 

Definition mit def 

• Erstellt Funktionsobjekt und bindet 

Namen daran 

• return für Rückgabe, ansonsten 

automatisch None 

• Eins oder mehrere 

Argumente/Parameter werden 

per Namensbindung übergeben 

def ([ [, ...]]): 

[] 

 

[return ] 

1 def mult(x, y): 

2 "Multipliziere zwei Objekte x, y" 

3 return x*y 

• Dokumentationsstring 

eingebaut, optionale erste Zeile 

Auch interaktiv eingebbar 

• Leerzeile zum Beenden 



Funktionen 

Funktionen – Beispiel, intersect 

Ziel 

• Schnittmenge von Sequenzen 

• Abstraktion als Funktion 

Lösung 

• Python-Funktion intersect 

• Ergebnis initial eine leere Sequenz 

• Für alle Elemente in erster Sequenz 

• Suche dieses Element in zweiter 

Sequenz 

• Wenn vorhanden, dann ist es ein 

gemeinsames Element; füge es zum 

Ergebnis hinzu 

• Gib Ergebnis zurück 

Beispiele 

• Strings, Listen, Tupel sind Sequenzen 

1 def intersect(seq1, seq2): 

2 """Schnittmenge von Sequenzen 

3 seq1 und seq2""" 

4 res = [] 

5 for ele in seq1: 

6 if ele in seq2: 

7 res.append(ele) 

8 return res 

1 >>> intersect("spam", "scam") 

2 [’s’, ’a’, ’m’] 

3 >>> intersect([1,2,3], (4,2,6)) 

4 [2] 



Funktionen 

Gültigkeitsbereiche in Funktionen 

Funktionsaufrufe sind Namensraum 

• Jeder Funktionsaufruf bietet einen 

neuen Gültigkeitsbereich 

(Namensraum) 

• Die Definition auch 

Beispiel f, g 

• Variable g wird nicht verändert 

• Weder bei der Definition 

• Noch bei dem Aufruf 

• g in der Funktion ist eine neue lokale 

Variable 

1 >>> g = 1 

2 >>> def f(x, y): 

3 g=2 

4 return x+y 

5 

6 >>> g 

7 1 

8 >>> f(5, 6) 

9 11 

10 >>> g 

11 1 



Funktionen 

Gültigkeitsbereiche in Funktionen – Durchgriff 

Durchgriff auf globale Variable 

• Schlüsselwort global 

• Variable vom “globalen” Namensraum 

wird verwendet 

• Durchgriff immer nur auf äußerste 

“globale” Ebene möglich 

• Wenn möglich vermeiden* 

1 >>> g = 1 

2 >>> def f(x, y): 

3 global g 

4 g=2 

5 return x+y 

6 

7 >>> g 

8 1 

9 >>> f(5, 6) 

10 11 

11 >>> g 

12 2 

*Bei OpenGL muss man dann leider doch mal ab 

und zu. . . 



Funktionen 

Gültigkeitsbereiche Funktionen – Überschreiben 

Überschreiben Global/lokal Eigenschaft 

• Überschreiben der global/lokal 

Eigenschaft nicht möglich 

• In f1 ist g als Parameter lokal, kann 

nicht auch global sein 

Nur lesen automatisch möglich 

• Direkter Zugriff auf globalen 

Namensraum möglich wie in f2 

• Syntaktisch ok, stilistisch unschön 

Nachträglich global machen 

• Wenn vorher nur gelesen wurde, dann 

wurde globaler Wert gelesen, f3 

• Wenn vorher geschrieben wurde, dann 

geht lokaler Wert verloren, f4 

• Warnung: unschön, vermeiden 

1 >>> def f1(x, g): 

2 global g 

3 SyntaxError: name ’g’ is local and global 

1 >>> g = 1 

2 >>> def f2(x, y): 

3 return g+1 

4 >>> f2(5, 6) 

5 2 

1 >>> def f3(x): 

2 y = g 

3 global g 

4 SyntaxWarning: name ’g’ is used 

5 prior to global declaration 

6 >>> def f4(x): 

7 g = 3 

8 global g 

9 SyntaxWarning: name ’g’ is 

10 assigned to before global 



Funktionen 

Regeln für Gültigkeitsbereiche 

Lokal 

• Jeder Funktionsaufruf bietet einen 

neuen lokalen Gültigkeitsbereich 

(Namensraum) 

• Jeder Aufruf, Rekursion funktioniert 

• Zugewiesene Namen sind lokal im 

aktuellen Gültigskeitsbereich 

• können explizit global werden 

• Blöcke (Einrückungen) sind kein 

eigener Gültigkeitsbereich 

Global 

• Das einschließende Modul ist ein 

globaler Gültigkeitsbereich 

• Der interaktive Modus ist ein Modul, 

hat den Namen ’__main__’ 

Reservierte Namen sind Teil der Sprache 

Reserviert 

Modul 

Modul 

Funktionsdefinition 

Funktionsaufruf 










Funktionen 

Namensauflösung, LGB-Regel 

Namen in drei Bereichen suchen 

• Erst Lokal 

zum Beispiel Variablen und Parameter 

in def 

• Dann Global 

zum Beispiel Funktionsdefinition, 

Variablen auf oberster Ebene 

• Dann eingeBaute 

builtin, reservierte Namen, zum 

Beispiel len, file 

Namensbindungen 

• In Funktionen lokal 

• In Moduln global 

• Für reservierte Namen vermeiden 

1 >>> a,b = 1,2 

2 >>> def f(): 

3 a = 3 

eingeBaut 

4 print a,b 

5 >>> f() 

6 3 2 

7 >>> a,b 

8 (1, 2) 

Global 

Lokal 

9 >>> list = "kein Typ mehr, vermeiden" 



Funktionen 

Parameterübergabe 

Parameterübergabe ist Namensbindung 

• Parameternamen werden an 

übergebene Objekte gebunden 

• Neue lokale Namen 

• Bindung von Namen an Objekt 

beeinflusst Objekt nicht 

Verwendung 

• Call by Reference 

• Das Ändern eines änderbaren Objekts 

hat Auswirkungen (Seiteneffekte) 

• Bei unveränderlichen Objekten kann 

es keine Auswirkungen haben, wie call 

by value 

1 def aendern(x, y): 

2 x = 2 

3 y[1] = 1 

1 >>> x, y = ([1,2], [3,4]) 

2 >>> aendern(x, y) 

3 >>> x, y 

4 ([1, 2], [3, 1]) 



Funktionen 

Parameterübergabe – Vorgabewerte 

Vorgabewerte (Default) 

• Vorgabewert kann optional bei jedem 

Parameter angegeben werden 

• Zusätzlich = und Ausdruck, der zu 

Vorgabewert evaluiert 

• Parameter mit Vorgabewerten hinter 

die Parameter ohne Vorgabewerte 

• Stellungsparameter, 

Positionsparameter 

Aufruf 

• Wert für Parameter mit Vorgabewert 

kann weggelassen werden 

• Falls Wert weggelassen, wird 

Vorgabewert eingesetzt 

1 def ink(x, a=1): 

2 return x+a 

1 >>> ink(3) 

2 4 

3 >>> ink(3, 1) 

4 4 

5 >>> ink(3, 17) 

6 20 



Funktionen 

Vorgabewerte – Anwendungsbeispiel 

Suche von Elementen in Sequenz 

• Vorgabewerte für start und ende 

des Suchbereichs 

• Sinnvolle Vorgabe ist 0 für start 

und Länge der Sequenz für ende 

Nutzung 

• Automatische Belegung von 

links nach rechts 

• Ergänzung nach Position, 

um ende zu übergeben muss 

man auch start übergeben 

1 def suche(seq, ele, start=0, ende=None): 

2 if ende is None: 

3 ende = len(seq) 

4 for pos in range(start, ende): 

5 if seq[pos] == ele: 

6 return pos 

1 >>> suche([1,2,3,4,5,6], 3) 

2 2 

3 >>> suche([1,2,3,4,5,6], 3, 0) 

4 2 

5 >>> suche([1,2,3,4,5,6], 3, 4) 

6 >>> suche([1,2,3,4,5,6], 3, 0, 6) 

7 2 

8 >>> suche([1,2,3,4,5,6], 3, 0, 1) 



Funktionen 

Vorgabewerte – Besonderheiten 

Gültigkeit 

1 

2 

def suche(seq,ele,start=0,ende=len(seq)): 

for pos in range(start, ende): 

• Parametername während der 

3 

Definition der Vorgabewerte noch nicht 4 

... 

Traceback (most recent call last): 

nutzbar 


• Umgehen durch Markieren mit None 

und dynamische Berechnung 

Lebenszyklus 

• Vorgabewert wird nur einmal 

ausgewertet, bei der 


• Überraschungen bei änderbaren 

Vorgabewerten 

• Änderungen bleiben über Aufrufe 

hinweg enthalten 

• Vermeiden durch Markieren mit None 

und dynamische Berechnung 

6 NameError: name ’seq’ is not defined 

1 >>> def oh(l, a=[]): 

2 a.append("ende") 

3 return l+a 

4 >>> oh([1,2],[3,4]) 

5 [1, 2, 3, 4, ’ende’] 

6 >>> oh([1,2],[3,4,5]) 

7 [1, 2, 3, 4, 5, ’ende’] 

8 >>> oh([1,2]) 

9 [1, 2, ’ende’] 

10 >>> oh([1,2]) 

11 [1, 2, ’ende’, ’ende’] 

12 >>> oh([1,2]) 

13 [1, 2, ’ende’, ’ende’, ’ende’] 



Funktionen 

Parameterübergabe mit Schlüsselwort 

Ziel 

• Viele Vorgabewerte verwenden, aber 

einige Parameter anders 

• Zwang Angabe aller früheren 

Parameter auflösen 

Schlüsselwortparameter 

• Parameter über Namen zuweisen 

• Name des Parameters als linke Seite 

einer Zuweisung im Aufruf 

• Reihenfolge der Parameter beliebig 

• Für alle Argumente außer den 

Schlüsselwortparametern Vorgabe 

• Parameter ohne Vorgabewert müssen 

als Positions- oder Schlüsselwortparameter 

übergeben werden 

1 def suche(seq, ele, start=0, ende=None): 

2 if ende is None: 

3 ende = len(seq) 

4 for pos in range(start, ende): 

5 if seq[pos] == ele: 

6 return pos 

1 >>> lis = [1, 2, 3, 4, 5, 6] 

2 >>> suche(lis, 2, start=0, ende=len(lis)) 

3 1 

4 >>> suche(lis, 2, 0, len(lis)) 

5 1 

6 >>> suche(lis, 2, ende=len(lis)) 

7 1 

8 >>> suche(lis, 2, start=1, ende=len(lis)) 

9 1 

10 >>> suche(lis, ende=len(lis), ele=2) 

11 1 

12 >>> suche(lis, 2, ende=1) 

13 >>> 



Funktionen 

Argumente sammeln mit * und ** 

Weitere Positionsparameter * 

• Eine Variable am Ende kann mit einem 

Stern * versehen werden 

• In dieser Variable werden dann alle 

weiteren Positionsparameter 

gesammelt als Tupel gesammelt 

• Realisiert beliebig viele Parameter, wie 

zum Beispiel print 

Weitere Schlüsselwortparameter ** 

• Eine Variable ganz am Ende kann mit 

zwei Sternen ** versehen werden 

11 SyntaxError: non-keyword arg after 

• Darin werden alle weiteren 

12 keyword arg 

Schlüsselwortparameter als Dictionary 

gesammelt 

• Die Schlüssel sind die 

Variablennamen als Strings 

1 def params(x, y, *pos, **key): 

2 print x, y, pos, key 

1 >>> params(1, 2) 

2 1 2 () {} 

3 >>> params(1, 2, 3, 4, 5) 

4 1 2 (3, 4, 5) {} 

5 >>> params(1, 2, 3, 4, drei=3, vier=4) 

6 1 2 (3, 4) {’drei’: 3, ’vier’: 4} 

7 >>> params(1, 2, 3, 4, vier=4, fuenf=5) 

8 1 2 (3, 4) {’fuenf’: 5, ’vier’: 4} 

9 >>> params(1, 2, 3, fuenf=5, 4, vier=4) 

10 File "", line 1 



Funktionen 

Funktionen in Funktionen und die LEGB-Regel 

Funktionsdefinitionen während 

Funktionsausführung 

• Sind erlaubt und sinnvoll 

• Umfassen aktuellen Namensraum und 

halten ihn fest (Enclosing) 

• Von innen nach außen 

LEGB-Regel 

• LGB-Regel erweitert 

• Zwischen Lokal und Global 

• Man sucht im umschließenden 

Namensraum, in dem die Funktion 

definiert wurde 

• Dies ist entweder der globale 

Namensraum oder ein anderer 

Funktionsaufruf als Namensraum 

g 1 2 3 

e 6 5 3 

l 4 5 3 

eingeBaut 

1 x, y, z = 1, 2, 3 

2 def f(): 

3 x, y = 4, 5 

4 def g(): 

5 x = 6 

Global 

Eingekapselt 

Lokal 

6 print "e", x, y, z # 6, 5, 3 

7 g() 

8 print "l", x, y, z # 4, 5, 3 

9 print "g", x, y, z # 1, 2, 3 

10 f() 



Funktionen 

Design-Prinzipien für Funktionen 

Parameter verwenden 

• Keine globalen Variablen verwenden 

• Flexible Gestaltung der übergebbaren 

Parameter möglich 

• Reduziert Abhängigkeiten 

Rückgaben verwenden 

• Keine globalen Variablen verwenden 

• Modifikation von Parametern meiden 

• Mehrere Werte als Tupel zurückgeben 

• Modifikation ok in Klassen/Methoden 

Verschachtelte Funktionen mit Vorsicht 

• Definition einer Funktion in einer 

Funktion nur wenn notwendig 

• Anonyme Funktionen sind meist 

Alternative 

1 x, y = 1, 2 

2 def sehrboese(): 

3 global x 

4 x = x*y 

5 sehrboese() 

6 

7 x, y = 1, 2 

8 def besser(x, y): 

9 return x*y 

10 x = besser(x, y) 



Funktionale Programmierung 

Anonyme Funktion, Lambda-Ausdrücke 

Funktionen sind auch Objekte 

• Funktionsobjekte sind normale 

Objekte, “first class citizens” 

• Funktionsnamen sind an 

Funktionsobjekte gebunden 

• Definition von Funktionsobjekten und 

Bindung an einen Namen mit def 

Funktionsobjekte 

• Erzeugen eines anonymen 

Funktionsobjekte mit lambda 

• lambda : 

• Funktion mit als Parameter 

• Wert der Funktion durch , 

der verwendet 

• Zuweisung an Namen und Aufruf 

möglich 

1 >>> def ink(x): 

2 return x+1 

3 >>> ink(3) 

4 4 

5 >>> ink 

6 

7 >>> x+1 

8 NameError: name ’x’ is not defined 

1 >>> lambda x: x+1 

2 

3 >>> ink2 = lambda x: x+1 

4 >>> ink2 

5 

6 >>> ink2(3) 

7 4 

8 >>> (lambda x: x+1)(3) 

9 4 



Funktionale Programmierung 

Funktionales Programmieren 

Funktionales Programmieren, 

Funktionsaufrufe 

• Programm als applikativer 

Algorithmus, sukkzesive Reduktion 

von Ausdrücken 

• Nur Funktionsaufrufe, statt 


• Primitive zum flexiblen Aufrufen von 10 >>> apply(plus, tup) 

Funktionen mit Parametern notwendig 

Flexible Parameter 

• Erweitere Call Syntax 

• * für Positionsparameter, “ausbreiten” 

der Parameter 

1 >>> def plus(x, y): 

2 return x+y 

• ** für Schlüsselwortparameter 

18 >>> apply(plus, ptub + (4,)) 

• Alternative: Eingebaute Funktion apply19 6 

für Positionsparameter 

3 

4 >>> tup = (2, 4) 

5 >>> plus(tup) 

6 TypeError: plus() takes exactly 

7 2 arguments (1 given) 

8 >>> plus(*tup) 

9 6 

11 6 

12 >>> ptup = (2, ) 

13 >>> plus(*(ptup + (4,))) 

14 6 

15 >>> dic = {’x’:2, ’y’:4} 

16 >>> plus(**dic) 

17 6 



Funktionale Primitive 

Funktionale Primitive – map 

Funktion auf allen Elementen 

• Für alle Objekte von Sequenzen eine 

Funktion anwenden 

• Schlüsselwort map 

6 [2, 3, 4] 

• Erster Parameter die Funktion 

7 >>> map(lambda x: x+3, [1, 2, 3]) 

• Ab zweiten Parameter die Sequenzen, 8 [4, 5, 6] 

so viele Sequenzen wie die Funktion 9 >>> map(lambda x,y: x+y, 

Parameter hat 

10 [1, 2, 3], [4, 5, 6]) 

11 [5, 7, 9] 

• Ergebnis ist Liste Funktionsergebnis je 

12 >>> 

Element der Eingabesequenz 

• Kürzeste Sequenz bestimmt Länge 

des Ergebnisses 

Beispiele 

• Erhöhe alle Werte um 1 

• Addiere die Inhalte einer Liste 

paarweise 

1 >>> def ink(x): 

2 return x+1 

3 >>> map(ink, [1, 2, 3]) 

4 [2, 3, 4] 

5 >>> map(lambda x: x+1, [1, 2, 3]) 




Einsatzbeispiel für map 

Aufgabe 

• Berechne die Liste der Quadratzahlen 

von 1 bis 10 

Lösung 

• for-Schleife 

• Liste zusammenbauen 

• Zurückgeben 

Funktionale Lösung 

• Einzeiler mit map 

• Liste der Zahlen mit range 

• Quadrieren als Lambda-Funktion 

• Keine Schleifen 

1 def quadratzahlen(von=1, bis=10): 

2 lis = [] 

3 for i in range(von, bis+1): 

4 lis.append(i*i) 

5 return lis 

6 

7 print quadratzahlen() 

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 

1 def quadratzahlen(von=1, bis=10): 

2 return map(lambda x: x*x, 

3 range(von, bis+1)) 

4 

5 print quadratzahlen() 




map illustriert 

1 2 3 2 3 4 4 8 16 

lambda x, y, z: x+y+z 

7 13 23 

1 >>> map(lambda x, y, z: x+y+z, [1, 2, 3], [2, 3, 4], [4, 8, 16]) 

2 [7, 13, 23] 




Funktionale Primitive – filter 

Nur Elemente für die Funktion ok ist 

• Für alle Objekte einer Sequenz eine 

Funktion anwenden, nur die 

durchlassen, für die der Funktionswert 

äquivalent zu wahr ist 

• Schlüsselwort filter 


• Zweiter Parameter die Sequenz 

• Ergebnis ist Liste der ursprünglichen 

Elemente, deren Funktionswert 

äquivalent zu wahr ist 

Beispiele 

• Test ob Zahl größer 0 

• Test ob Zahl zwischen 1 und 2 

• Test ob gerade Zahl 

1 >>> def groesser0(x): 

2 return x>0 

3 >>> filter(groesser0, [1,-1,2,-2,3,-3,4]) 

4 [1, 2, 3, 4] 

5 >>> filter(lambda x: x>0, 

6 [1, -1, 2, -2, 3, -3, 4]) 

7 [1, 2, 3, 4] 

8 >>> filter(lambda x: x>0 and x>> filter(lambda x: x%2 == 0, 

12 [1, 2, 3, 4, 5]) 

13 [2, 4] 




Einsatzbeispiel für filter 

Aufgabe 

• Berechne die Liste der Primzahlen 

zwischen 2 und 100 

Lösung 


• Liste zusammenbauen 

• Zurückgeben 

Funktionale Lösung 

• Einzeiler mit filter 

• Liste der Zahlen mit range 

• Funktion zum Testen ob Primzahl wie 

bei for-Schleife 

• Keine Schleifen 

1 def is_prim(zahl): 

2 for teiler in range(2, zahl): 

3 if zahl%teiler == 0: 

4 return False 

5 return True 

6 def prims(): 

7 primzahlen = [] 

8 for zahl in range(2, 100): 

9 if is_prim(zahl): 

10 primzahlen.append(zahl) 

11 return primzahlen 

12 print prims() 

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 

31, 37, 41, 43, 47, 53, 59, 61, 67, 

71, 73, 79, 83, 89, 97] 

1 def prims(): 

2 return filter(is_prim, range(2, 100)) 




Funktionale Primitive – reduce 

Alle Elemente einer Sequenz mit 

einer Funktion kombinieren 

• Kumuliere alle Objekte einer 

Sequenz über Funktionswerte 

auf (foldl) 

• Schlüsselwort reduce 


1 >>> def add(x, y): 

2 return x+y 

3 >>> def summe(lis): 

4 ret = 0 

5 for e in lis: 

6 ret = e + ret 

7 return ret 

8 >>> summe(range(101)) 

9 5050 

• Zweiter Parameter die Sequenz 10 >>> reduce(lambda x,y : x+y, range(101), 0) 

11 5050 

• Dritter Parameter der 

12 >>> fak = lambda x: reduce(lambda x,y: x*y, 

Anfangswert, meist neutral 

13 range(1, x+1), 1) 

• Ergebnis ist Auswertung der 

linksassoziativen sukkzesiven 

Funktionsanwendung 

14 

15 

16 

>>> fak(3) 

6 

>>> fak(6) 

17 720 

Beispiele: Summieren, Fakultät, 

18 >>> reduce(lambda x,y : x+" "+y, 

Stringkonkatenation 

19 ["Hallo", "tolle", "Welt"], "") 

20 ’ Hallo tolle Welt’ 




reduce illustriert 

Initialer 

Wert 

0 

1 2 3 

4 5 6 

0 + 1 

1 

2 + 1 

3 

Kumulierte 

Werte 

3 + 3 

6 + 4 

6 

10 

10 + 5 

15 

15 + 6 

21 

lambda x, y: x+y 

1 >>> add = lambda x,y: x+y 

2 >>> reduce(add, [1, 2, 3, 4, 5, 6], 0) 

3 21 

4 >>> add(add(add(add(add(add(0, 1), 2), 3), 4), 5), 6) # foldl 

5 21 




Definition von map 

Primitive für funktionales Programmieren 

1 

2 

def mymap(func, seq): 

ret = [] 

• Können selbst implementiert werden 

3 

• Keine Schlüsselwörter, nur vordefiniert 4 

for ele in seq: 

ret.append(func(ele)) 

mymap selbst gemacht 

5 return ret 


• Funktion als Parameter 

• Aufbau der Ergebnisliste 

Verwenden wie eingebautes map 

• Implementierung mit mehreren 

Sequenzen auch einfach möglich 

• Gute Hausaufgabe 

1 >>> ink = lambda x: x+1 

2 >>> map(ink, [1, 2, 3]) 

3 [2, 3, 4] 

4 >>> mymap(ink, [1, 2, 3]) 

5 [2, 3, 4] 

6 >>> mymap(lambda x: x+1, [1, 2, 3]) 

7 [2, 3, 4] 




Definition von filter 

myfilter selbst gemacht 



• Aufbau der Ergebnisliste 

Verwenden wie eingebautes filter 

1 def myfilter(func, seq): 

2 ret = [] 

3 for ele in seq: 

4 if func(ele): 

5 ret.append(ele) 

6 return ret 

1 >>> filter(lambda x: x>10, range(20)) 

2 [11, 12, 13, 14, 15, 16, 17, 18, 19] 

3 >>> filter(lambda x: x%2, range(20)) 

4 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] 

5 >>> myfilter(lambda x: x>10, range(20)) 

6 [11, 12, 13, 14, 15, 16, 17, 18, 19] 

7 >>> myfilter(lambda x: x%2, range(20)) 

8 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] 

9 >>> myfilter(lambda x: x%2==0, range(20)) 

10 [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 




Definition von reduce 

myreduce selbst gemacht 



• Aufbau des Ergebniswerts 

Verwenden wie eingebautes reduce 

1 def myreduce(func, seq, init=None): 

2 if init == None: 

3 init = seq[0] 

4 seq = seq[1:] 

5 wert = init 

6 for ele in seq: 

7 wert = func(wert, ele) 

8 return wert 

1 >>> add = lambda x,y: x+y 

2 >>> reduce(add, range(101)) 

3 5050 

4 >>> myreduce(add, range(101)) 

5 5050 

6 >>> sub = lambda x,y: x-y 

7 >>> myreduce(sub, [1,2,3,4,5], 100) 

8 85 

9 >>> reduce(sub, [1,2,3,4,5], 100) 

10 85 



List Comprehension 


Listentransformation 

• Anwendungsgebiet wie funktionales 

Programmieren 

• Einfachere Verwendung der 

Möglichkeiten von map und filter 

zusammen mit lambda und for 

Syntax [ for in ] 

• statt lambda-Ausdruck 

• Durch for wird sukkzesive ein 

Wert aus zugewiesen 

• Zusätzlich if , als Filter 

• Beliebig kombinierbar 

Ausdrucksweisen 

• Statt verschachtelte for-Schleifen 

• Ähnelt math. Mengenschreibweise 

1 >>> map(lambda x: x+1, [1,2,3,4]) 

2 [2, 3, 4, 5] 

3 >>> [x+1 for x in [1,2,3,4]] 

4 [2, 3, 4, 5] 

5 >>> filter(lambda x:x>3, [1,5,2,6,7]) 

6 [5, 6, 7] 

7 >>> [x for x in [1, 5, 2, 6, 7] if x>3] 

8 [5, 6, 7] 

1 >>> [x**2 for x in range(1, 11) 

2 if x % 2 == 0] 

3 [4, 16, 36, 64, 100] 

{x 2 |1 ≤ x ≤ 10, x mod 2 = 0} = 

{4, 16, 36, 64, 100} 




List Comprehension – Beispiele mit Zahlen 

Quadratzahlen 

• Zahlen von 0 bis 9; 1 bis 10 

• Ausdruck statt Funktion 

Komplexe Definition 

• Mischen von Filtern und 

Funktionsapplikation 

• Aufzählen durch for 

Kartesisches Produkt 

• Sequenzen kombinieren 

• Kartesisches Produkt, 

Vollkombination 

• Nicht so bei funktionalem 

Primitiv map 

zip 

• Builtin, generiert Tupel 

1 >>> [x for x in range(10)] 

2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

3 >>> [x*x for x in range(1, 11)] 

4 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 

1 >>> [(x,y) for x in range(4) 

2 for y in range(0,5,2) 

3 if x < y] 

4 [(0, 2), (0, 4), (1, 2), (1, 4), 

5 (2, 4), (3, 4)] 

1 >>> map(lambda x,y: x+y, range(5), range(5)) 

2 [0, 2, 4, 6, 8] 

3 >>> [x+y for x in range(5) for y in range(5)] 

4 [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 

5 3, 4, 5, 6, 7, 4, 5, 6, 7, 8] 

1 >>> [x+y for (x,y) in zip(range(5),range(5))] 

2 [0, 2, 4, 6, 8] 

3 >>> zip(range(5), range(5)) 

4 [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] 




List Comprehension – Beispiele mit Text 

Wörter ersetzen 

• Kleine Zahlen durch Wörter ersetzen 

• Für alle Worte, falls das Wort 1,2 oder 

3 ist, 

• dann ersetze durch Zahlwort und 

setze neuen String zusammen 

Datei von Zahlen zeilenweise lesen 

• Zeilenweise einlesen und aufteilen 

(splitten) 

• Alle Strings aus Ziffern je Zeile in Liste 

von Zahlen umwandeln 

• Tupel aus Liste machen 

1 >>> trans = {’2’:’zwei’, ’3’: ’drei’, 

2 ’4’: ’vier’} 

3 >>> s = """2 Sachen und 3 Sachen sind 

4 nicht 4 Sachen""" 

5 >>> print " ".join([trans[w] 

6 if w in trans else w 

7 for w in s.split()]) 

8 zwei Sachen und drei Sachen sind 

9 nicht vier Sachen 

1 >>> d = "zahlen.dat" 

2 >>> file(d).readlines() 

3 [’1 2 3\n’, ’42 343 12\n’, 

4 ’8 77 223\n’, ’23 43\n’, 

5 ’45 3 3 66 7\n’] 

6 >>> [tuple(map(int, line.split())) 

7 for line in file(d)] 

8 [(1, 2, 3), (42, 343, 12), (8, 77, 223), 

9 (23, 43), (45, 3, 3, 66, 7)] 




Funktionale Programmierung – Zusammenfassung 

Vorteile 

• Verminderung der Fehleranfälligkeit, zum Beispiel sind viele Indexfehler gar nicht 

mehr formulierbar 

• Kompakter, ausdrucksstarker Code nahe an der Spezifikation 

• Gut zu lesen und zu verstehen, wenn nicht zu viel in einer Zeile passiert 

• Seiteneffektfrei, muss man natürlich auch darauf achten 

Nachteile 

• Syntax/Ausdrucksweise etwas gewöhnungsbedürftig 

• Funktionales Denken erfordert etwas Einarbeitungszeit 

Verbreitung 

• Funktionale Primitive in allen höheren Programmiersprachen zu finden (Ruby, Perl, 

Lisp, C#) 

• Lambda-Ausdrücke sind in C# für LINQ, in Java ab 8 

• MapReduce, Framework (Google) zum Suchen in riesigen Datenmenge 

Online-Referenzen 

• http://www-106.ibm.com/developerworks/linux/library/l-prog.html 

• http://www.freenetpages.co.uk/hp/alan.gauld/tutfctnl.htm 

• . . . 




Module 

Warum Module? 

• Wiederverwendung von Code 

• Bereitstellung von allgmein 

nutzbaren Diensten und 

Bibliotheken 

• Unterteilung des Namensraums 

bei großen Projekten 

Python Module 

• Jede Python-Datei (Endung mit 

.py) ist ein Modul 

• C-Erweiterungen sind Modul 

• Nutzen mit import, from 

Suche nach Dateien/Module 

• Umgebungsvariable PYTHONPATH 

• Abhängig von Wert in sys.path 


2 >>> sys.path 

3 [’’, # sucht auch im akt. Verzeichnis 

4 ’/usr/lib/python2.7’, 

5 ’/usr/lib/python2.7/plat-linux2’, 

6 ’/usr/lib/python2.7/lib-tk’, 

7 ’/usr/lib/python2.7/lib-old’, 

8 ’/usr/lib/python2.7/lib-dynload’, 

9 ’/usr/local/lib/python2.7/dist-packages’, 

10 ’/usr/lib/python2.7/dist-packages’, 

11 ’/usr/lib/python2.7/dist-packages/PIL’, 

12 ’/usr/lib/python2.7/dist-packages/gst-0.10’, 

13 ’/usr/lib/python2.7/dist-packages/gtk-2.0’, 

14 ’/usr/lib/pymodules/python2.7’] 




Definieren von Modulen 

Ein Modul ist eine Datei 

• Mit der Endung .py, 

oder vorkompiliert .pyc 

• In einem Verzeichnis 

• Beliebiger Python-Code 

• Keine Python-Schlüsselwörter als 

Dateiname 

Im Suchpfad erreichbar 

• Vorgabe ist aktuelles Verzeichnis und 

Standard-Bibliothek von Python 

• sys.path 

meinmodul.py 

1 # Modul meinmodul, meinmodul.py 

2 # Variablen und Funktionen 

3 

4 deutsch = "deutsch" 

5 englisch = "englisch" 

6 

7 sprache = deutsch 

8 

9 def drucke(x): 

10 print x 

11 

12 def gruss(): 

13 if sprache == deutsch: 

14 drucke("Hallo Modul Welt") 

15 else: 

16 drucke("Hello module world") 

17 

18 print "meinmodul geladen" 




Importieren von Modulen 

Modul importieren 

• Im aktuellen Verzeichnis 

• Wechseln mit os.chdir() 

• Importiert Modul mit dem 

Namen 

• Objekte nur über den 

Modul-Präfix erreichbar 

Namen von Modulen importieren 

• Modul selbst nicht sichtbar 

• Alle Namen im aktuellen 

Namensraum verfügbar 

• Aber an Objekt in Modul 

gebunden 

• * für alle Namen außer Namen, 

die mit einem Unterstrich _ 

beginnen 

import [, ]* 

1 $ ls meinmodul.py 

2 meinmodul.py 

3 $ python 

4 >>> import meinmodul 

5 meinmodul geladen 

6 >>> meinmodul.gruss() 

7 Hallo Modul Welt 

8 >>> meinmodul.sprache=meinmodul.englisch 

9 >>> meinmodul.gruss() 

10 Hello module world 

11 >>> meinmodul.sprache = englisch 

12 NameError: name ’englisch’ is not defined 

from import [, ]* 

1 >>> from meinmodul import gruss 

2 >>> gruss() 





Module und Namensräume 

Ausführung beim Import 

• Modulanweisungen laufen nur beim 

ersten Import einmal ab 

• Achtung bei Entwicklung, IDLE 

restart führt neu aus, ohne restart 

werden Module nicht neu ausgeführt 

Modulattribute 

• Zuweisungen und 

10 {’drucke’: >> import meinmodul 


3 >>> dir(meinmodul) 

4 [’__builtins__’, ’__doc__’, ’__file__’, 

5 ’__name__’, ’__package__’, ’deutsch’, 

6 ’drucke’, ’englisch’, ’gruss’, 

7 ’sprache’] 


9 >>> meinmodul.__dict__ 




Hauptprogramm mit main 

Ziel 

• Ausführen eins Code-Blocks nur, wenn 

es als Hauptprogramm gestartet 

wurde; nicht wenn es importiert wurde 

• Simulieren der main-Funktion/Methode 

von C/Java 

• Häufig zum Testen eines Moduls 

verwendet 

Umsetzung, Idiom 

• Der Name des interaktiven oder 

Haupt-Moduls ist ’__main__’ 

• Test auf Name und bedingt ausführen 

main.py 

1 import sys 

2 

3 def drucke(x): 

4 print "|%s|" % x 

5 

6 if __name__ == ’__main__’: 

7 print "drucker" 

8 for ele in sys.argv[1:]: 

9 drucke(ele) 

1 >>> import main 

2 >>> main.drucke("hallo") 

3 |hallo| 

4 >>> main.drucke("hello") 

5 |hello| 

$ python main.py hallo hello 

drucker 

|hallo| 

|hello| 




Qualifikation von Namen 

Einfacher Name 

• Auflösung über LEGB-Regel 

Qualifikation 

• . 

• Im Geltungsbereich des Moduls 

• Die gleiche Notation wie bei Objekten 

Qualifikationspfade 

• .. 

• Nur im genau spezifizierten 

Geltungsbereich 

Qualifikation funktioniert für alle Objekte: 

Module, Klassen, Typen, . . . 

qual.py 

1 import os 

2 name = "Name" 

1 >>> import qual 

2 >>> name 

3 NameError: name ’name’ is not defined 

4 >>> qual.name 

5 ’Name’ 


7 NameError: name ’os’ is not defined 

8 >>> qual.os.getcwd() 

9 ’/home/mi/ssinn001/prog3’ 




Erzwingen von Neuladen 

Import von Modulen 

• Module werden beim ersten Import 

ausgeführt 

• Beim zweiten importieren wird nur ein 

neuer Namen wieder an das 

Modulobjekt gebunden 

• Zweiter Import sinnvoll um Modul im 

aktuellen Namensraum zu haben 

reload() 

• Lädt Modul neu, erstellt neues 

Modulobjekt 

• Wichtig beim Entwicklen, IDLE kein 

restart 

• Code-Änderungen werden erst dann 

wirksam 

m1.py 

1 import meinmodul 

m2.py 

1 import meinmodul 

m3.py 

1 import m1 

2 import m2 

3 print m1.meinmodul.gruss 


5 m2.meinmodul = reload(m2.meinmodul) 


1 $ python m3.py 


3 

4 


6 




Warum nicht from import * 

Verunreinigung des Namensraums 

• Namenskonflikte möglich 

• Gleiche Namen in Modulen würden im 

importierenden Modul überschreiben, 

der letzte gewinnt 

Importieren ist Namensbindung 

• Ist nicht immer was erwartet wird 

• Im Beispiel wird der Name sprache 

importiert 

• Die Funktion gruss verwendet natürlich 

noch sprache im Modul meinmodul 

from import * vermeiden 

Wenn Modulname zu lang, as 

1 >>> from meinmodul import * 


3 >>> gruss() 


5 >>> sprache = "englisch" 

6 >>> gruss() 



9 >>> meinmodul.sprache = "englisch" 

10 >>> gruss() 


import as 

1 >>> import meinmodul as mm 


3 >>> mm.gruss() 





Warum nicht from import * 

1 >>> from meinmodul import * 


3 >>> gruss() 


5 >>> sprache = "englisch" 

6 >>> gruss() 



9 >>> meinmodul.sprache = "englisch" 

0 >>> gruss() 


import as 

1 >>> import meinmodul as mm 




__main__ 

deutsch 

englisch 

sprache 

drucke 

gruss 

meinmodul 

deutsch 

englisch 

sprache 

drucke 

gruss 

__main__ 

meinmodul 

mm 

“deutsch“ 

“englisch“ 

lambda... 

lambda... 




Datenkapselung und Daten verstecken 

meinmodul.py (Erweiterung) 

Datenkapselung 

1 #... 

• Kapselung ist Ziel von Modulen 

2 def andere_sprache(s): 

3 

• 

global sprache 

Nicht erzwungen in Python, kein 

4 if s in [deutsch, englisch]: 

public, private, protected 

5 sprache = s 

• Nur “unhöflich”, gegen Konvention 

6 else: 

Daten verstecken 

7 raise Exception("Sprache %s" % s) 

• Konvention mit _ 

• 

1 

Durchgriff möglich 

>>> import meinmodulgross as mm 


• Nicht importiert bei * 


Konventionen 

4 >>> mm.andere_sprache(mm.englisch) 

5 

• Keine Modulattribute ändern, nur lesen >>> mm.gruss() 


• Nur Funktionen verwenden 

7 >>> mm.andere_sprache("portugiesisch") 

• Keine Funktionen mit _ am Anfang 8 Exception: Sprache portugiesisch 




Pakete/Packages – Ordner als Module 

Flache Struktur 

• Viele Module flach im Ordner ok 

• In großem Projekt nicht ausreichend 

• Standardbibliotheken so nicht gut 

strukturierbar 

• Besser Hierarchie von Ordnern 

Package 

• Ordner als Hierachiestufen bei der 

Namensqualifikation (wie Java) 

• Wenn ein Ordner die Datei 

__init__.py enthält, dann ist der 

Ordner ein Package 

• __init__.py kann Initialisierungscode 

der Package enthalten, zum Beispiel 

Module nachladen und Namensraum 

ausgestalten 

paket/a.py 

1 s = "hallo" 

2 def machgross(s): 

3 return s.upper() 

paket/b.py 

1 import string 

2 def machklein(s): 

3 return s.lower() 

paket/__init__.py 

1 import a 

2 from a import s 




Pakete/Packages – Beispiel Verwendung 

paket/a.py 

1 >>> import paket 

1 s = "hallo" 

2 >>> paket.a 

2 def machgross(s): 

3 

3 return s.upper() 

4 >>> paket.a.machgross("ab") 

5 ’AB’ 

paket/b.py 

6 >>> paket.a.s, paket.s 

1 import string 

7 (’hallo’, ’hallo’) 

2 def machklein(s): 

8 >>> paket.b 

3 return s.lower() 

9 AttributeError: ’module’ object has 

10 no attribute ’b’ 

paket/__init__.py 

11 >>> import paket.b 

12 >>> paket.b 

1 import a 

13 

2 from a import s 

14 >>> paket.b.string.lower("hallo") 

15 ’hallo’ 



Objektorientierung 

Objektorientierung in Python 

Ähnlich zu Java 

• Schlüsselworte, Referenzsemantik 

• Attribute, Vererbung, Polymorphismus 

• Einfach, Sprache mit OO konzipiert 

Unterschiede, neue Features 

• Dynamische Attribute, Attributsuche 

• Mehrfachvererbung, keine Schnittstellen 

• Kapselung (Komposition) nur per Konvention, 

aber Properties 

• Operatorenüberladung, Duck-Typing (reagieren auf 

Index-Zugriff, Ausgabe, Slicen) 

• Selbst erstellte Klassen verhalten sich wie 

eingebaute Typen 

• Alles! ist ein Objekt (Zahlen, Module, . . . ) 

1 >>> i=3 

2 >>> type(i) 

3 

4 >>> isinstance(i, int) 

5 True 

6 >>> i.__add__ 

7 

9 >>> i.__add__(4) 

10 7 

11 >>> i.__mul__(4) 

12 12 

13 >>> object 

14 

15 >>> issubclass(int, object) 

16 True 




Klassen 

Klassendefinition 

• class: Schlüsselwort 

• : Name für die Klasse 

• object: Wurzelklasse, immer angeben 

• : Dokumentationsstring 

• : Funktionsdefinitionen für Methoden 

Besonderheiten 

• Erstes Methodenargument ist immer Instanzobjekt 

• Per Konvention der Name self, in Java wäre es this 

• Spezielle Methode __init__ statt Konstruktor 

• Attribute sind Klassenattribute und nicht, wie von 

Java erwartet, Instanzattribute 

• Instanzattribute dynamisch (__init__) in 

Namensraum self schreiben 

class (object): 

[] 

 

klasse.py 

1 class A(object): 

2 "Eine Klasse A" 

3 def __init__(self): 

4 self.a = 17 

5 def inca(self): 

6 self.a += 1 

7 print A 

$ python klasse.py 

 

Ausführung erzeugt 

Klassenobjekt (Klassen 

sind Objekte!), binden 

Klassenname an 

Klassenobjekt 




Klassendefinition – Beispiel Stack 

Stack auf Basis von Listen (Komposition) 

• Initialisierung der Instanzvariable 

liste mit leere Liste 

• self ist immer das erste Argument bei 

Methoden 

• self muss explizit aufgeführt werden 

bei der Definition 

• self ist Namensraum einer Instanz 

• Weitere Argumente bei Methoden 

erlaubt 

• Manipulation der Instanzattribute in 

self sollte nur durch Methoden 

erfolgen 

• Keine get/set Methoden schreiben! 

• Später mit Properties 

1 class Stack(object): 

2 "Stack-Klasse mit Python Listen" 

3 


5 self.liste = [] 

6 

7 def push(self, elem): 

8 self.liste.append(elem) 

9 

10 def pop(self): 

11 del self.liste[-1] 

12 

13 def top(self): 

14 return self.liste[-1] 

15 

16 def clear(self): 

17 self.liste = [] 

18 

19 def empty(self): 

20 return self.liste == [] 




Generieren und Nutzen von Instanzen 

Klassendefinition 

• Klassenname ist Name gebunden an 

Klassenobjekt 

• Im Beispiel Stack in stack.py 

Instanziierung 

• Neue Instanz durch Aufruf 

Klassennamen (kein new) 

• Implizit wird __init__ aufgerufen 

• Zuweisung der Instanz an Namen 

• Name referenziert dann Instanzobjekt 

Nutzen wie gewohnt 

• Kapselung nicht erzwungen aber 

Konvention 

>>> from stack import Stack 

>>> Stack 

 

>>> s = Stack() 

 

>>> s.empty() 

True 

>>> s.push(1); s.push(2); s.push(3) 

>>> s.liste # Boese, nicht machen 

[1, 2, 3] 

>>> s.empty() 

False 

>>> s.top() 

3 

>>> s.pop() 

>>> s.top() 

2 




Vererbung und Mehrfachvererbung 

Vererbung 

• Superklassen in Klammern dahinter 

• object nur dann nicht mehr notwendig 

1 

class ( [, ]*): 

... 

fancystack.py 

from stack import Stack 

• Ganz ohne Superklassen werden es 

2 

Old-Style Klassen, deprecated 

3 class FancyStack(Stack): 

• Mehrfachvererbung möglich 

Mehrfachvererbung 

4 

5 

def peek(self, i): 

return self.liste[i] 

• Suche nach Attribut oder 

Methodenname 

• Erst in aktueller Klasse 

• Dann in Superklassen wie definiert 

• Erst alle Superklassen der 

Superklassen 

• Kurz: von links nach rechts, 

Tiefensuche* 

9 1 

*In der Realität etwas komplizierter 

http://www.python.org/download/releases/2.3/mro/ 

1 >>> from fancystack import FancyStack 

2 >>> s = FancyStack() 

3 >>> s 

4 >> s.push(1); s.push(2); s.push(3) 

6 >>> s.peek(2) 

7 3 

8 >>> s.peek(0) 




Klassen- und Instanzvariablen 

Instanzvariablen 

• Zuweisung an durch self 

aufgespannten Namensraum 

• 

5 

Unabhängig von allen anderen Namen def show_verbose(self): 

6 print "Klasse", K.verbose 

• Entspricht Instanzvariablen in Java 

7 print "Instanz", self.verbose 

Klassenvariablen 

• Initialisierung als Attribute 

• In durch Klassennamen 

aufgespannten Namensraum 

• Entspricht static Variablen in Java 

• Achtung: Syntax wie Instanzvariablen 

in Java 

1 class K(object): 

2 verbose = 1 

3 def __init__(self, v): 

4 self.verbose = v 

1 >>> K.verbose 

2 1 

3 >>> i = K(2) 

4 >>> i.verbose 

5 2 


7 1 

8 >>> i.show_verbose() 

9 Klasse 1 

10 Instanz 2 




Klassen- und Instanzvariablen – Attributsuche 

Suchordnung 

• Erst Instanz, dann Klasse, dann 

Superklassen 

Suche in self 

• Wenn keine Instanzvariable vorliegt, 

wird die der Klasse gelesen, 

Zeile 2 

Zur Laufzeit änderbar 

• Instanzvariable zur Laufzeit 

hinzufügbar, Zeile 4 

Klassenvariable nur noch qualifiziert 

• Zugriff über Namensraum der Klasse, 

Zeile 7 


2 verbose = 1 


4 pass 

1 >>> k = K() 

2 >>> k.verbose 

3 1 

4 >>> k.verbose = 2 

5 >>> k.verbose 

6 2 


8 1 




Klassenmethoden 

Statische Methoden 

• Klassenmethode, bezieht sich nicht 

auf Instanz, in Java static 

• Syntax: Dekorator @staticmethod 

• Kein erstes Argument self mehr 

vorhanden 

Klassenmethode 

• Klassenmethode, wobei das erste 

Argument die Klasse ist 

• Syntax: Dekorator @classmethod 

• Überschreiben möglich, 

fortgeschrittenes Konzept, vermeiden 


2 zaehle = 1 


4 self.zahl = 17 

5 @staticmethod 

6 def statisch(x): 

7 K.zaehle += x 

8 @classmethod 

9 def klassenmethode(cls, x): 

10 cls.zaehle += x 

1 >>> k = K() 

2 >>> k.zaehle, K.zaehle 

3 (1, 1) 

4 >>> k.statisch(3) 

5 >>> K.zaehle 

6 4 

7 >>> k.klassenmethode(3) 


9 7 




Dekorator 

Dekoratorfunktion 

• Funktion, die mindestens eine 

Funktion als Argument hat und eine 

Funktion zurückgibt; einpacken 

• Ziel: Verhalten und Syntax einer 

Funktion ändern 

• Beispieleinsatz: statische Methoden 

• Beispiel: statisch in Zeilen 6-8, in 

Python



Alternative zu Klassenmethoden 

1 _kzaehle=1 # nicht importieren bei 

Klassenscope meist nicht notwendig 

* 


• In Java kein umfassende 

3 global _kzaehle 

Modulkonzept vorhanden, keine Werte 4 _kzaehle += x 

auf globaler Ebene 


6 

• Statische Methoden und 

def __init__(self): 


Klassenvariablen um zu kompensieren 

• In Python Kompensation nicht 

notwendig 

Nutzen Modulkonzept 


2 K.zaehle += x 


• Statt Klassenvariable Modulvariable 

4 zaehle = 1 


• Statt statische Methode Modulfunktion 


• Häufig passender 

1 >>> k = K() 

2 >>> statisch(3) 


4 4 




Klassen und Instanzen sind Namensräume 

Nicht qualifizierte Namen nach 

Geltungsbereichen 

• x=wert; weist an lokalen Namen zu 

• x; Zugriff mit LEGB-Regel 

Qualifizierte Namen 

• Namensraum des Objekts 

1 x = 4 

2 class K1(object): 


4 self.x = 1 

5 class K2(K1): 

6 x = 3 


8 K1.__init__(self) 

9 

• def f(self): 

Suche erst in aktueller Instanz, 

10 self.x = 2 

beinhaltet was durch Superklassen an 

11 def showx(self): 

Instanz geändert wurde, 

12 print self.x, 

dann erst in Klassenscope 

13 k = K2(); k.showx() 

• Nicht im definierenden Modul 

14 k.f(); k.showx() 

15 del k.x; k.showx() 

16 del K2.x; k.showx() 

1 1 2 3 

2 AttributeError: ’K2’ object 

3 has no attribute ’x’ 




Klassen, Selbstbeobachtung 

Umsetzung, Interna 

• Attribute mit doppelten Unterstrichen 

• Direkter Zugriff nur wenn notwendig 

Klassen 

• Name, Superklassen 

Instanzen 

• Klasse der Instanz 

• Namensraum mit __dict__ 

• Realisiert mit Dictionaries 

Selbst ausprobieren! 


2 verbose = 1 

3 def __init__(self): pass 

1 >>> from klasse import K 

2 >>> K.__name__ # der Name 

3 ’K’ 

4 >>> K.__bases__ # die Superklassen 

5 (,) 

6 >>> k = K() 

7 >>> k.__class__, k.__dict__ 

8 (, {}) 

9 >>> dir(k) 

10 [’__class__’, ’__delattr__’, ’__dict__’, 

11 ’__doc__’, ’__format__’, ’__getattribute_ 

12 ’__hash__’, ’__init__’, ’__module__’, 

13 ’__new__’, ’__reduce__’, ’__reduce_ex__’, 

14 ’__repr__’, ’__setattr__’, ’__sizeof__’, 

15 ’__str__’, ’__subclasshook__’, ’__weakref 

16 ’verbose’] 




Properties statt Getter und Setter 

Durchgriff auf Attribute 

• Ist in Python in Ordnung 

• Keine Getter und Setter 

• Man kann nachträglich ändern und 

Kontrolle wieder erlangen 

Properties 

• Eigentliches Attribut verstecken, _ am 

Namensanfang als Hinweis 

• Definition Getter, Setter und Löschen 

• Definition des Attributs mit 

property(get, set, delete, doc) 

1 class Name(object): 

2 


4 self._vorname = "Max" 

5 

6 def get_vorname(self): 

7 return self._vorname 

8 

9 def set_vorname(self, value): 

10 oktypes = [str, unicode]: 

11 if type(value) not in oktypes: 

12 msg = "vorname kein String" 

13 raise AttributeError(msg) 

14 self._vorname = value 

15 

16 vorname = property(get_vorname, 

17 set_vorname, 

18 None, 

19 "Vorname als String/Unicode") 




Properties verwenden 

Auf Klassenebene zugewiesenes Attribut 

wie Instanzvariable verwenden 

• Automatisch Aufruf der passenden 

Methode 

• Wenn nicht angegeben, dann 

Verwendung nicht möglich 

Durchgriff: Immer noch möglich, nicht 

machen 

1 >>> name = Name() 

2 >>> name.vorname 

3 ’Max’ 

4 >>> name.vorname = ’Susi’ 


6 ’Susi’ 

7 >>> name.vorname = 17 

8 AttributeError: vorname kein String 


10 ’Max’ 

11 >>> del name.vorname 

12 AttributeError: can’t delete attribute 


14 ’Max’ 

15 

16 >>> n._vorname = 17 

17 >>> n.vorname 

18 17 




Überladen von Operatoren – Motivation 

Ziel 

• Rechnen Modulo einer Zahl mod 

• Alle Ergebnisse sollen zwischen 0 und 

mod-1 liegen 

Lösung 

• Klasse Modulo 

• Initialisiert mit Wert mod 

• Implementierung der Operationen 

durch Standardoperationen, aber 

Anpassung modulo 

• Funktioniert, Benutzung nicht intuitiv 

Wunsch 

• Benutzen der Modulo-Instanzen wie 

eingebaute Zahlen 

1 class Modulo(object): 

2 "Rechnen modulo einer Zahl" 

3 def __init__(self, mod, zahl=0): 

4 self.mod = mod 

5 self.zahl = zahl 

6 def wert(self): 

7 return self.zahl 

8 def add(self, z): 

9 zahl, mod = self.zahl, self.mod 

10 self.zahl = (zahl+z) % mod 

1 >>> m = Modulo(7) 

2 >>> m.wert() 

3 0 

4 >>> m.add(4); m.wert() 

5 4 

6 >>> m.add(5); m.wert() 

7 2 




Überladen von Operatoren – Umsetzung 

Vordefinierte Funktionsnamen 

• Werden gerufen bei Anwendung von 

Operatoren 

• Beginnen und enden mit zwei 

Unterstrichen 

• Definition neuer Operatoren nicht 

möglich 

Beispiele 

• __repr__: Repräsentation bei 

interaktiver Ausgabe, es wird String 

erwartet, Java’s toString ist __str__ 

• __add__: Wird gerufen bei 

linksseitigem + Operator 

Achtung: Eingebautes + liefert immer 

ein neues Objekt, auch so machen 

1 ... 

2 def __repr__(self): 

3 return str(self.zahl) 

4 __str__ = __repr__ 

5 def __add__(self, z): 

6 n = Modulo(self.mod, self.zahl) 

7 n.add(z) 

8 return n 

1 >>> m = Modulo(7) 

2 >>> m 

3 0 

4 >>> m.add(4) 

5 >>> m 

6 4 

7 >>> m+5 

8 2 

9 >>> m 

10 4 




Überladbare Operatoren – Auszug 

• __init__: Konstruktorersatz, __init__ der Superklasse nicht automatisch gerufen 

• __del__: Destruktorersatz, beim expliziten Löschen und bei Garbage-Collection 

• __add__, __or__: Operator +, | 

• __repr__: Drucken (print), Konvertierung 

• __call__: Funktionsaufruf () 

• __getattr__, __getattribute__: Qualifikation 

• __getitem__: Indizierung, auch von in-Operator verwendet 

• __setitem__: Zuweisung über Index 

• __getslice__: Teilbereichsbildung 

• __len__: Länge 

• __cmp__: Vergleich 

• __eq__, __ne__: Gleichheit (==), Ungleichheit(!=) 

• __radd__: Rechtsseitiger Operator + 

Details und weitere Operatoren in der Dokumentation 




Von eingebauten Klassen ableiten 

Beispiel eigenes Wörterbuch 

• Verhalten wie dict, aber nur Strings 

als Schlüssel 

• Alles andere gleich 

Umsetzung 

• Von dict ableiten, Vererben alternativ 

zu Komposition 

• Überladen von __setitem__ 

• Nutzen von __setitem__ der 

Superklasse (Achtung: sonst 

unendliche Rekursion) 

1 class strdict(dict): 

2 def __setitem__(self, key, value): 

3 if type(key) != str: 

4 msg = "nur String als Key" 

5 raise AttributeError(msg) 

6 dict.__setitem__(self, key, value) 

1 >>> dic = dict() 

2 >>> dic[1] = 2 

3 >>> dic["eins"] = 2 

4 >>> dic 

5 {1: 2, ’eins’: 2} 

6 >>> strdic = strdict() 

7 >>> strdic[1] = 2 

8 AttributeError: nur String als Key 

9 >>> strdic["eins"] = 2 

10 >>> strdic 

11 {’eins’: 2} 




Iteratoren für eigene Klassen 

for-Kontrollstruktur 

• Einfaches Iterieren über Sequenzen 

• Funktioniert mit Iterator-Objekt 

• next gibt nächstes Element zurück 

• Ausname StopIteration, wenn kein 

Element mehr verfügbar 

• Ähnlich zu Java 

iter-Methode, eingebaut 

3 

• Holt von Objekt Iterator, wenn möglich 

>>> it 

4 

• Implizit und explizit verwendbar 

5 >>> it.next() 

• Beispiel mit Listen 

1 >>> l = [1, 2, 3] 

2 >>> lis = [1, 2, 3] 

3 >>> for ele in lis: 

4 print ele 

5 1 

6 2 

7 3 

1 >> lis = [1, 2, 3] 

2 >>> it = iter(l) 

6 1 

7 >>> it.next() 

8 2 

9 >>> it.next() 

10 3 

11 >>> it.next() 

12 StopIteration 




Iteratoren für eigene Klassen – Instanz selbst 

Selbst implementieren in der Klasse 

• Überladen von __iter__ 

• Erwartet Iterator-Objekt 

Bewertung 

• Zum Beispiel sich selbst, wenn 

Methode next definiert ist 

• Keine Schnittstellen, Duck-Typing 

• Einfach zu realisieren 

1 class Iterselbst(object): 


3 self.lis = [1,2,3] 

4 def __iter__(self): 

5 self.index = 0 

6 return self 

7 def next(self): 

8 if self.index >= len(self.lis): 

9 raise StopIteration 

10 self.index += 1 

11 

• return self.lis[self.index-1] 

Nachteil: Nur ein Iterator gleichzeitig je 

Instanz, da aktueller Zustand nur 

1 >>> its = Iterselbst() 

einmal in der Instanz gespeichert ist 

2 >>> for ele in its: 

3 print ele, 

4 1 2 3 

5 >>> its = Iterselbst() 

6 >>> it1, it2 = iter(its), iter(its) 

7 >>> it1.next(), it2.next() 

8 (1, 2) 




Iteratoren für eigene Klassen – Iterator-Klasse 

Separate Iterator-Klasse 

• Neu definierte Iterator-Klasse itk 

• Kann durchaus im normalen 

Codeblock dynamisch erfolgen 

• Instanz der Klasse initialisieren und 

zurückgeben 

Bewertung 

• Etwas komplexer zu realisieren 

• Erlaubt parallele Iteration 

• Ändern des Objekts während der 

Iteration erlaubt, da Kopie erstellt 

wurde 

• Kopie erstellen bewusste 

Entscheidung 

1 class Iterklasse(object): 


3 self.lis = [1,2,3] 


5 class itk(object): 

6 def __init__(self, lis): 

7 self.index = 0 

8 self.lis = lis[:] 

9 def next(self): 

10 if self.index >= len(self.lis): 


12 self.index += 1 

13 return self.lis[self.index-1] 

14 return itk(self.lis) 

1 >>> itc = Iterklasse() 

2 >>> it1, it2 = iter(itc), iter(itc) 


4 (1, 1) 




Iteratoren für eigene Klassen – Iterator von Standardtyp 

Iterator von Standardtyp verwenden 

• Standardtyp nehmen oder aufbauen 

• Davon Iterator zurückgeben 

Bewertung 

• Einfach, robust; bevorzugen 

in Tests 

• Sobald Iterator implementiert ist, ist 

auch automatisch der in-Operator 

realisiert 

• Iteriert über alle Element und 

vergleicht 

• Bessere Implementierung darf man 

angeben 

1 class Iterstd(object): 


3 self.lis = [1, 2, 3] 


5 return iter(self.lis) 

1 >>> its = Iterstd() 

2 >>> it1, it2 = iter(its), iter(its) 


4 (1, 1) 

1 >>> its = Iterstd() 

2 >>> 3 in its, 17 in its 

3 (True, False) 



Generatoren 

Generatoren – Motivation 

Iteratoren – Umsetzungskonzept 

• Iterator: Zwischen jedem next 

Anwendungscode ausführen 

• Iteratorklasse: Zustand halten und bei 

jedem next aktualisieren 

• Statt Iteratorklasse?: Einfache Schleife 

klappt nicht; man kann Ausführung 

nicht anhalten und Anwendungscode 

ausführen 

Lösungsansätze 

• Man kann den Anwendungscode, den 

man für jedes Objekt ausführen will 

“mitgeben”: Funktionales 

Programmieren 

• Man kann die Schleife doch anhalten; 

Generatoren 

1 i = 0 

2 def naechstes(): 

3 global i 

4 if i >= len(lis): 


6 ele = lis[i] 

7 i += 1 

8 return ele 

1 for ele in lis: 

2 # naechstes ele, Anwendungscode? 

3 pass 

1 def f(x): 

2 pass # Anwendungscode 

3 ### 

4 map(f, lis) 



Generatoren 

Generatoren – Konzept 

Generatoren in Python 

• yield statt return in Funktion 

• Nur eins von beiden in Funktion 

• Bei Funktionsaufruf wird automatisch 

Generatorobjekt erzeugt, das sich wie 

Iterator verhält 

• Bei next wird Wert bei yield 

zurückgegeben und Ausführung 

eingefroren 

• Bei jedem next zum nächsten Wert 

• StopIteration am Ende 

Vorteile 

• Keine großen Datenstrukturen im 

Speicher halten 

• Natürliche Realisierung von Iteratoren 

• Grundlage für die meisten Builtins 

quads.py 

1 def quads(): 

2 i = 1 

3 while True: 

4 yield i**2 

5 i += 1 

1 >>> q = quads() 

2 >>> q.next() 

3 1 

4 >>> q.next() 

5 4 

6 >>> q.next() 

7 9 



Generatoren 

Generatoren – Grundlage für viele Builtins 

Beispiel: Eine offene Datei ist ein 

Generator, der die Zeilen in der Datei 

sukkzesive zurückgibt 

1 >>> f = file("quads.py"); f 

2 

4 >>> f.next() 

5 ’def quads():\n’ 

6 >>> f.next() 

7 ’ i = 1\n’ 

8 .... 

9 >>> f.next() 

0 ’ i += 1\n’ 

1 >>> f.next() 


Beispiel: Das Ergebnis eines Aufrufs von 

reversed ist ein Generator, der die 

Elemente rückwärts aufzählt 

1 >>> lis = [1, 2, 3] 

2 >>> g = reversed(lis); g 

3 

5 >>> g.next() 

6 3 

7 >>> g.next() 

8 2 

9 >>> g.next() 

10 1 

11 >>> g.next() 




Generatoren 

Generatoren – Verwendung und weitere Beispiele 

Verwendung 

• Summe der Quadratzahlen, die zum 

ersten Mal 1.000.000 erreicht 

nquads 

• quads war unendlich, beschränkt geht 

auch 

• Mit list wird wieder eine Liste daraus, 

läuft ewig für unendliche Generatoren 

• Verwendung von for möglich und 

sinnvoll auch bei potentiell unendlich 

lange laufenden Generatoren 

• Abbruch mit StopIteration 

• Abbruch nicht notwendig 

1 def hoch4(): 

2 for ele in quads(): 

3 yield ele**2 

1 sum = 0 

2 for quad in quads(): 

3 sum += quad 

4 if sum > 1000000: 

5 break 

6 print sum # 1005720 

1 def nquads(n): 

2 for i in range(1, n+1): 

3 yield i**2 

1 def nquads(n): 

2 grenze = n**2 

3 for ele in quads(): 

4 yield ele 

5 if ele >= grenze: 


>>> list(nquads(10)) 

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 



Generatoren 

Generatoren – Fibonacci 

Folge der Fibonacci-Zahlen 

• Startwerte, zwei Mal die Eins 

• Die nächste Fibonacci-Zahl ist die 

Summe der beiden Vorherigen 

Umsetzung 

• Aktuelle und vorletzte Fibonacci-Zahl 

halten 

• Vorletzte zurück geben und dabei 

Zustand einfrieren 

Verwendung 

• Die ersten 10 Fibonacci-Zahlen 

1 def fib(): 

2 fn0, fn1 = 1, 1 

3 while True: 

4 fn0, fn1, fn2 = fn0+fn1, fn0, fn1 

5 yield fn2 

1 >>> f = fib() 

2 >>> for i in range(10): 

3 print f.next(), 

4 1 1 2 3 5 8 13 21 34 55 



Generatoren 

Generatoren – Baum traversieren 

Baum 

• Knoten als Drei-Tupel, Wert ist String 

• Iterator für In-Order normalerweise 

aufwendig, Warteschlange 

Baum traversieren mit Generatoren 

• Natürliche Formulierung 

• Nutzen von Schleifen mit neuen 

Generatoren im rekursiven Abstieg 

bintree 

b 

a 

c 

1 def inorder(node): 

2 if node == None: 


4 left, value, right = node 

5 for valueleft in inorder(left): 

6 yield valueleft 

7 yield value 

8 for valueright in inorder(right): 

9 yield valueright 

1 bintree = ( 

2 ((None, "d", None), 

3 "b", 

4 (None, "e", None)), 

5 "a", 

6 (None, "c", None)) 

d 

e 

1 >>> for value in inorder(bintree): 

2 print value, 

3 d b e a c 



Generatoren 

Generatoren – itertools, Slicen 

Generatoren sind keine Sequenzen 

• Generatoren sind potentiell unendlich 

• Umformung in Listen und Slicing nicht 

sinnvoll 

• Standard-Features von Sequenzen 

(Slicing, Syntax) nicht verfügbar 

Modul itertools 

• Wichtigste Funktionalität von 

Sequenzen für Generatoren zur 

Verfügung stellen 

• Slicen, Funktional Programmieren 

1 >>> list(quads()) 

2 ... # 1 GB, 2 GB, 3 GB, ... 

3 ... # ca. 3 Minuten auf 32 Bit-Rechner 

4 MemoryError 

islice( 

[, ], [, ]) 

1 >>> from itertools import islice 

2 >>> q = quads() 

3 >>> i = islice(q, 0, 10) 

4 >>> i.next(), i.next(), i.next() 

5 1, 4, 9 

6 >>> list(i) 

7 [16, 25, 36, 49, 64, 81, 100] 

Slicen mit islice 

8 >>> list(islice(q, 0, 10)) 

9 [121, 144, 169, 196, 225, 256, 289, 324, 

• Aufruf von islice mit start, stop, step 

10 >>> list(islice(q, 0, 10)) 

• Nachbau Funktionalität 

[start:stop:step] 

11 

12 

[441, 484, 529, 576, 625, 676, 729, 784, 

>>> list(islice(quads(), 0, 10)) 

13 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 



Generatoren 

Generatoren – itertools, Funktional Progammieren 

Funktional Programmieren 

• Etwas für alle Elemente einer 

Liste tun 

• Potentiell problematisch bei 

unendlichen Listen 

Spezielle Primitive für Generatoren 

• Primitive mit i am Anfang*, 

imap, ifilter, izip 

• Im Modul itertools 

• Geben Generatoren zurück 

• Gleiche Funktionalität wie 

funktionale Primitive, nur 

sukkzesive 

1 >>> from itertools import islice, imap, 

2 ifilter, izip 

3 >>> [i for i in islice(quads(), 0, 20) 

4 if i%2==0] 

5 [4, 16, 36, 64, 100, 144, 196, 256, 324, 400] 

6 >>> list(islice(ifilter(lambda x: x%2 == 0, 

7 quads()), 0, 10)) 

8 [4, 16, 36, 64, 100, 144, 196, 256, 324, 400] 

9 >>> gen = ifilter(lambda x: x%2 == 0, quads()) 

10 >>> gen 

11 

12 >>> gen.next() 

13 4 

14 >>> gen.next(),gen.next(),gen.next(),gen.next() 

15 (16, 36, 64, 100) 

16 >>> import math 

17 >>> list(islice(imap(math.sqrt, quads()), 9)) 

* Keine Assoziation zu Apple-Produkten, 

18 [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] 

geht auf allen Rechnern, patent pending... :-) 



Generatoren 

Generatoren – Generator Expressions 

List Comprehension für 

Generatoren 

• List Comprehension direkt 

wieder nicht sinnvoll, da 

potentiell unendlich 

7 (1, 4, 9) 

• Ausdruck mit runden Klammern 

8 >>> list(gq) 

() statt eckigen Klammern [] 

9 [16, 25, 36, 49, 64, 81] 

• Erzeugt dann Generator/Iterator 10 >>> gquads = (i for i in quads() if i%2 == 0) 

Mächtiges elegantes Konzept, 

nutzen! 

1 >>> gq = (i**2 for i in range(10)) 

2 >>> gq 

3 

4 >>> gq.next() 

5 0 

6 >>> gq.next(), gq.next(), gq.next() 

11 >>> gquads 

12 

13 >>> gquads.next() 

14 4 

15 >>> gquads.next(),gquads.next(),gquads.next() 

16 (16, 36, 64) 

17 >>> from itertools import islice 

18 >>> list(islice((i for i in quads() if i%2==0) 

19 ,0,10)) 

20 [4, 16, 36, 64, 100, 144, 196, 256, 324, 400] 



Ausnahmen 

Ausnahmen 

Ausnahmen – spezieller Kontrollfluss 

• Fokus auf Fehlerbehandlung 

• Erlaubt saubere Trennung von funktionalen Bestandteilen und “Rest” wie 

Fehlerbehandlung und Spezialfällen 

• Sollte nicht für allgemeinen Kontrollfluss verwendet werden 

Ausnahmen in Python 

• In Sprache integriert, einfach zu verwenden 

• Ähnlich zu Java 

Syntax 

• try, else, except, finally: Rahmen für Code-Strecken mit potentiellen 

Ausnahmen, Fangen und Verarbeiten der Ausnahmen 

• raise: Werfen von Ausnahmen 

• assert: Wie in C 



Ausnahmen 

Ausnahmen fangen – Schema 

• im try-Block ausführen 

• Falls Ausführung Ausnahme wirft mit 

expect fangen 

• Eine oder mehrere Ausnahmen als 

Tupel möglich 

• Mehrere except möglich 

• Mit optionalem an Ausnahme-Instanz 

an binden 

• Falls Ausnahme gefangen 

entsprechenden except-Block 

ausführen 

• else-Block (optional) falls keine 

Ausnahme geworfen wurde 

• finally-Block (optional) immer, ob 

Ausnahme geworfen wurde (und 

gefangen wurde oder nicht) oder nicht 

try: 

 

except : 

 

except ([, ]*): 

 

except as : 

 

else: 

 

finally: 

 



Ausnahmen 

Ausnahmen fangen – Beispiele, except, else 

1 >>> 3/0 

2 ZeroDivisionError: integer div.. by zero2 3/0 

3 >>> try: 

4 3/0 

5 except ZeroDivisionError: 

6 print "nicht durch Null" 

7 nicht durch Null 

8 >>> try: 

9 3/0 

0 except ZeroDivisionError as e: 

1 print type(e), e 

2 

3 integer division or modulo by zero 

4 >>> try: 

5 3/0 

6 except IndexError: 

7 print "IE" 


9 print "ZDE" 

0 ZDE 

1 >>> try: 


4 print "ZDE" 

5 else: 

6 print "OK" 

7 ZDE 

8 >>> try: 

9 3/1 


11 print "ZDE" 

12 else: 

13 print "OK" 

14 3 

15 OK 

ZeroDivisionError, builtin Ausnahmetyp 

Nicht gefangene Ausnahme propagiert 

zum TopLevel 



Ausnahmen 

Ausnahmen fangen – Beispiele, finally 

1 >> try: 

2 ... 3/0 

3 ... except ZeroDivisionError: 

4 ... print "ZDE" 

5 ... finally: 

6 ... print "immer" 

7 ... 

8 ZDE 

9 immer 

0 >>> try: 

1 ... 3/1 

2 ... except ZeroDivisionError: 

3 ... print "ZDE" 



6 ... 

7 3 

8 immer 

1 >>> try: 

2 ... 3/0 

3 ... except IndexError: 

4 ... print "IE" 



7 ... 

8 immer 

9 ZeroDivisionError: integer division 

10 or modulo by zero 

finally wird immer ausgeführt 

Beinhaltet meist Aufräumaktionen 



Ausnahmen 

Ausnahmen fangen – Datei-Beispiel 

Mit Ausnahmen arbeiten 

• Code unter der Annahme schreiben, 

dass alles funktioniert 

• 

5 

Ausnahme und Behandlung bei Fehler 

count += 1 

6 except IOError: 

Mit Dateien arbeiten 

7 count = 0 

• Zähle Zeilen in Datei 

8 return count 

• 0, wenn Datei nicht vorhanden 

1 def countlinesfile(filename): 

2 try: 

3 count = 0 

4 for _ in file(filename): 

1 >>> countlinesfile("/etc/passwd") 

2 44 

3 >>> countlinesfile("/GIBTESNICHT") 

4 0 



Ausnahmen 

Ausnahmeklassen – Exception, Hierarchie 

1 BaseException 

2 +-- SystemExit 

3 +-- KeyboardInterrupt 

4 +-- GeneratorExit 

5 +-- Exception 

6 +-- StopIteration 

7 +-- StandardError 

8 | +-- BufferError 

9 | +-- ArithmeticError 

0 | | +-- FloatingPointError 

1 | | +-- OverflowError 

2 | | +-- ZeroDivisionError 

3 | +-- AssertionError 

4 | +-- AttributeError 

5 | +-- EnvironmentError 

6 | | +-- IOError 

7 | | +-- OSError 

8 | | +-- WindowsError (Windows) 

9 | | +-- VMSError (VMS) 

0 | +-- EOFError 

1 | +-- ImportError 

2 | +-- LookupError 

3 | | +-- IndexError 

4 | | +-- KeyError 

5 | +-- MemoryError 

6 | +-- NameError 

7 | | +-- UnboundLocalError 

1 | +-- ReferenceError 

2 | +-- RuntimeError 

3 | | +-- NotImplementedError 

4 | +-- SyntaxError 

5 | | +-- IndentationError 

6 | | +-- TabError 

7 | +-- SystemError 

8 | +-- TypeError 

9 | +-- ValueError 

10 | +-- UnicodeError 

11 | +-- UnicodeDecodeError 

12 | +-- UnicodeEncodeError 

13 | +-- UnicodeTranslateError 

14 +-- Warning 

15 +-- DeprecationWarning 

16 +-- PendingDeprecationWarning 

17 +-- RuntimeWarning 

18 +-- SyntaxWarning 

19 +-- UserWarning 

20 +-- FutureWarning 

21 +-- ImportWarning 

22 +-- UnicodeWarning 

23 +-- BytesWarning 

Eigene Ausnahmeklassen passend 

ableiten 



Ausnahmen 

Ausnahmen werfen 

Ausnahmen werfen mit raise 

• raise : Wirft Ausnahme der 

Klasse , muss von 

BaseException erben 

• raise : Wirft Ausnahme der 

Instanz , muss Instanz von 

BaseException ein 

Instanzen oder Klassen werfen 

• Instanz um Daten mitzugeben 

• Häufig sind Daten ein String 

Vordefinierte Ausnahmen verwendbar 

1 >>> raise Exception("nix geht") 

2 Exception: nix geht 

1 >>> class MeineAusnahme(object): 

2 pass 

3 >>> raise MeineAusnahme 

4 TypeError: exceptions must be old-style 

5 classes or derived from 

6 BaseException, not type 

7 

8 >>> class MeineAusnahme(Exception): 

9 pass 

10 >>> raise MeineAusnahme 

11 __main__.MeineAusnahme 

12 

13 >>> try: 

14 msg="Weil es nicht geht" 

15 raise MeineAusnahme(msg) 

16 except MeineAusnahme as inst: 

17 print "Warum?", inst 

18 Warum? Weil es nicht geht 



Ausnahmen 

Ausnahmen mit assert 

Zusicherungen mit assert 

• : ein Test 

• Sobald Test äquivalent zu False 

evaluiert, AssertionError 

Optimierung 

• Gesteuert durch globale Variable 

__debug__ 

assert , 

if __debug__: 

if not : 

raise AssertionError() 

• Beim Übersetzen mit -O wird 

__debug__ = False gesetzt bzw. der 

Bytecode komplett entfernt 

Benutzung 

• Schleifeninvarianten, Vor- und 

Nachbedingungen 

• Frühzeitige Fehlererkennung 

• Lauffähige Dokumentation 



Ausnahmen 

Ausnahmen mit assert – Beispiel 

Zerlegen von einem String 

• Wir gehen davon aus, dass der String 

immer genau einen Doppelpunkt 

enthält 

• Was passiert im Fehlerfall? 

Defensiv programmieren 

• Früh fehlschlagen, statt erst mal weiter 

machen; assert 

• Fehlermeldungen werden besser 

1 def zerlege_nonsafe(s): 

2 l = s.split(":") 

3 return (l[0], l[1]) 

4 def zerlege_safe(s): 

5 l = s.split(":") 

6 assert len(l) == 2, l 

7 return (l[0], l[1]) 

1 >>> zerlege_nonsafe("a:b:c") 

2 (’a’, ’b’) 

3 >>> zerlege_safe("a:b:c") 


5 AssertionError: [’a’, ’b’, ’c’] 

6 >>> zerlege_nonsafe("a") 

7 return (l[0], l[1]) 

8 IndexError: list index out of range 

9 >>> zerlege_safe("a") 


11 AssertionError: [’a’] 



Ausnahmen 

Ausnahmen statt “Check then Act”-Fehler 

Aufgabe 

• Überprüfe die Existenz einer Datei 

• Falls vorhanden, erste Zeile zurück 

• Falls nicht vorhanden, hart beenden 

• Es darf kein IOError geworfen werden 

Ansätze 

• “Check then act”, fehlerhaft 

• Es kann passieren, dass jemand 

zwischen Check Zeile 4 und 

verwenden, die Datei entfernt 

• Es wird dann doch IOError geworfen 

• Mach es; melde, wenn es nicht geht 

• Kein Problem, sobald die Datei 

geöffnet werden konnte, ist sie da 

Ein IOError wäre natürlich doch die 

bessere Variante, statt hart zu beenden 

1 def get_status(fname): 

2 if not os.path.exists(fname): 

3 print "file not found" 

4 sys.exit(-1) 

5 return file(fname).readline() 

1 def get_status(fname): 

2 try: 

3 return file(fname).readline() 

4 except (IOError, OSError) as e: 

5 print "problem; exiting: "+str(e) 

6 sys.exit(-1) 



Bibliotheken 

Bibliotheken – Module in der Standardbibliothek 

Python-Bibliotheken – viel im Standard 

• Als Module/Pakete verfügbar 

• Breites Angebot, “Batteries included”, 

ausführlich dokumentiert 

Beispiele: 

• os: Systemnah, Verzeichnisse/Dateien 

sys: Python-Umgebung 

• unittest: Unit Testing 

pickle: Objektpersistenz 

urllib, cgi, imap, ftp, http: Web, 

Internet Protokolle 

PIL: Bildbearbeitung (nicht standard) 

turtle: Einfachstgraphik, Tkinter 

Tkinter, wx, qt: GUI, alle OS 

pygame: Spielend Spiele spielen 

re: Reguläre Ausdrücke 

1 >>> import os 


3 ’/home/mi/ssinn001’ 

4 >>> os.chdir("/usr/share/games/fortunes") 


6 ’/usr/share/games/fortunes’ 

7 >>> [x for x in os.listdir(os.getcwd()) 

8 if x.endswith(".dat")] 

9 [’fortunes.dat’, ’riddles.dat’, 

10 ’literature.dat’] 


12 >>> sys.argv 

13 [’’] 

14 >>> import re 

15 >>> re.findall(r’ab+c’, "abbcdsabcab") 

16 [’abbc’, ’abc’] 



Bibliotheken 

Unit Testing 

Ziel 

• Funktionalitäten feingranular testen 

• Automatisierung, einfache Verwaltung 

von Testfällen 

Umsetzung – unittest, Verwendung 

• Anlehnung an JUnit 

• Von Klasse TestCase erben 

• Testfunktionen mit test_ am Anfang 

des Namens 

• Zusicherung, self.: Erwartet 

• assert_: True, wie assert 

• assertEqual: Zwei gleich Parameter 

• assertRaises: Passende Ausnahme 

• setUp, tearDown: Vor/nach jedem Test, 

Test Fixture 

• Aufrufen mit unittest.main() 

import unittest 

class (unittest.TestCase): 

[def setUp(self): 

] 

... 

[def tearDown(self): 

] 

... 

[def test(self): 

... 

[self.assert_() | 

[self.assertEqual(, ) | 

[self.assertRaises()]* 

... 

]* 

if __name__ == ’__main__’: 

unittest.main() 

Anpassbar, flexibel, weitere Optionen 



Bibliotheken 

Unit Testing – Beispiel 

Beispieltest “Ist Primzahl?” 

• Importieren Modul 

• Zu testende Funktion is_prim, 

meist in anderem Modul 

• Testfunktionen 

• Start der Tests 

Ausgabe 

.. 

• Zwei Tests ok durchgelaufen 

------------------------------- 

Ran 2 tests in 0.000s 

OK 

1 import unittest 

2 

3 def is_prim(x): 

4 if x < 2: return False 

5 ts = [t for t in range(2, x) if x%t==0] 

6 return not ts 

7 

8 class PrimTest(unittest.TestCase): 

9 def setUp(self): 

10 self.r = range(1, 101) # 1..100 

11 self.ps = 25 # 25 Primzahlen 

12 def testPrim1(self): 

13 self.assert_(is_prim(2)) 

14 self.assert_(not is_prim(4)) 

15 self.assertEqual(is_prim(7), True) 

16 def testPrim2(self): 

17 prims = filter(is_prim, self.r) 

18 self.assertEqual(len(prims), self.ps) 

19 if __name__ == ’__main__’: 

20 unittest.main() 



Bibliotheken 

Pickle – Einfache Objektpersistenz 

Ziel 

• Serialisierung von Objektinstanzen 

• Plattform- und versionsunabhängig 

• Kein Persistenzframework 

Umsetzung – pickle 

• Für eingebaute Standardtypen 

• Hierarchien und Referenzen 

• Klassen, aber nur Instanzen 

Beispiel 

• Schreiben mit dump 

• Lesen mit load 

Aclass.py 

1 class A(object): 

2 def __init__(self, end=3): 

3 self.lis = range(1, end) 

4 def __str__(self): 

5 return "A["+str(self.lis)+"]" 

6 __repr__ = __str__ 

1 import pickle 

2 import Aclass 

3 

4 tup=(1, 1.0, 1+1j, (1,), "1", {1:2}) 

5 lis=[1,2,3] 

6 lis.append(lis) 

7 alis=[Aclass.A(i) for i in range(1, 6)] 

8 pickle.dump((tup, lis), 

9 file("tuplis.pickle", "wb")) 

10 pickle.dump(alis, 

11 file("alis.pickle", "wb")) 



Bibliotheken 

Pickle – Einlesen 

Beispiel 

• Referenzen, auch zirkuläre, 

werden richtig wiederhergestellt 

• Instanzen von Objekten werden 

richtig wieder instanziiert 

• Klasse/Modul muss verfügbar 

sein, wird nicht gepickelt 

• Einladen über import muss 

klappen 

Erweiterungen 

• Pickeln von Instanzen über 

Methoden beeinflussbar 

• Pickeln von Klassen oder 

Funktionen nicht möglich 

• cPickle, schneller 

• Unterschiedliche 

Protokollversionen 

1 >>> import pickle 

2 >>> f = file("tuplis.pickle", "rb") 

3 >>> t, l = pickle.load(f) 

4 >>> t 

5 (1, 1.0, (1+1j), (1,), ’1’, {’1’: ’eins’}) 

6 >>> l 

7 [1, 2, 3, [...]] 

8 >>> al = pickle.load(file("alis.pickle","rb")) 

9 >>> al 

10 [A[[]], A[[1]], A[[1, 2]], A[[1, 2, 3]], 

11 A[[1, 2, 3, 4]]] 

12 >>> al[0].__class__ 

13 



Bibliotheken 

Internetdaten verarbeiten 

• rfc822, mimetools, mimetypes, mailcap, imaplib, mailbox, smtplib, nntplib: 

Email- und News-spezifische Bibliotheken 

• uu, binascii: Konvertierungen 

• SocketServer, SimpleHTTPServer, ftplib: Protokollimplementierungen 

• urllib, urllib2, urlparse: URL-Manipulation, Anfragen 

1 >>> import urllib2, re 

2 >>> s = urllib2.urlopen("http://www.heise.de/newsticker/").read() 

3 >>> s[:100] 

4 ’\n\n\n\n \n 

5 \n\n 7-Tage-News | heise online\n\n ’ 

6 >>> hl = re.findall(r’(.*?)’, s) 

7 >>> for t in [t for t in hl if "Android" in t]: print t 

8 Unzuverlaessige Trojaner-Warnungen durch Android 4.2 

9 LTE-Smartphone mit Android 4.0 von HTC 

0 Java-IDE IDEA 12: neue Oberflaeche, neuer Compiler-Modus, neuer Android-Designer 

1 Gingerbread bleibt die am meisten benutzte Android-Version 

2 Aktualisierte Maps-API fuer Android-Entwickler 



Bibliotheken 

Turtle Graphics 

Turtle Graphics 

• Einfache Graphiken wie mit einem Stift 

erstellen, “Logo, Programming for 

Kids” 

• Zeichenfläche mit Mitte 0,0 

• Kommandos up (Stift hoch), down (Stift 

auf Papier), goto (Bewege Stift), . . . 

1 from turtle import * 

2 down() 

3 goto(100, 0) 

4 goto(0, -100) 

5 goto(100, -100) 

6 up() 

7 goto(0, 0) 

8 down() 

9 for i in range(100): 

0 goto(i, i**2/100.) 



Bibliotheken 

Bildbearbeitung mit PIL 

Python Imaging Library (PIL) 

• C-Erweiterung 

• Nicht im Standard 

• Einfach, mächtig 

• ([noch] nur Python 2.x) 

1 >>> import Image 

2 >>> im=Image.open("lena.png") 

3 >>> im.show() 

4 >>> im2=im.resize(map(lambda x: x*2, 

5 im.size)) 

6 >>> im2.show() 

7 >>> im3=im.rotate(45) 

8 >>> im3.show() 

9 >>> import ImageFilter 

0 >>> im4=im.filter(ImageFilter.FIND_EDGES) 

1 >>> im4.show() 



Bibliotheken 

Spiele mit pygame 

Spiele Programmieren mit pygame 

• Kombination von Bibliotheken 

• 2D/3D-Grafik, Sound, . . . 

• Abstraktionen (Sprites, Kollision) 

Beispiel 

• Viele, viele Logos 

1 import sys, pygame 

2 

3 pygame.init() 

4 bild = pygame.image.load("hsrm.png") 

5 groesse = breite, hoehe = 800, 600 

1 if __name__ == ’__main__’: 

2 main() 



Bibliotheken 

pygame – Ein Bild bewegt sich 

Bewegung: bewege 

• Innerhalb eines Rechtecks 

• Bei Wand (Ende Rechteck), 

ändere Bewegungsrichtung 

(wieder zurück) 

• Bewege! 

Anzeige, Animation: main 

• Initialisierung Bildschirm, 

Bewegungsrichtung 

• GameLoop 

• Bearbeite (ignoriere) Events 

• Hintergrund 

• Bewege Bild 

• Bild auf (virtuellen) Bildschirm 

• Bringe vorbereiteten 

(flackerfreien) Bildschirm zur 

Ansicht 

1 def bewege(rect, direction): 

2 if rect.left < 0 or rect.right > breite: 

3 direction[0] = -direction[0] 

4 if rect.top < 0 or rect.bottom > hoehe: 

5 direction[1] = -direction[1] 

6 return rect.move(direction) 

7 

8 def main(): 

9 screen = pygame.display.set_mode(groesse) 

10 bild_rect = bild.get_rect() 

11 direction = [1,1] # bewegungsrichtung 

12 while True: 

13 for event in pygame.event.get(): 

14 if event.type == pygame.QUIT: 

15 sys.exit() 

16 screen.fill((50, 130, 40)) # gruen 

17 bild_rect = bewege(bild_rect, direction) 

18 screen.blit(bild, bild_rect) 

19 pygame.display.flip() 



Bibliotheken 

pygame – Besser, Klasse für Spielobjekte 

Logo-Klasse 

• Spielobjekt, Bild parametrisiert 

• Taucht zufällig intial irgendwo 

auf 

• Bewegt sich bei 

Richtungsänderung an einer 

Wand zufällig (1–3) anders 

schnell weiter 

• Kann sich selbst zeichnen 

Logos, die verwendet werden 

• hsrm.png 

• hsrml.png 

• pygame.png 

1 class Logo(object): 

2 def __init__(self,screen,fname="hsrm.png"): 

3 self.screen = screen 

4 self.bild = pygame.image.load(fname) 

5 r = self.rect = self.bild.get_rect() 

6 r.left=random.randint(0,breite-r.width) 

7 r.top=random.randint(0,hoehe-r.height) 

8 self.dir = [random.randint(1,3), 

9 random.randint(1,3)] 

10 def bewege(self): 

11 if self.rect.left < 0: 

12 self.dir[0] = random.randint(1, 3) 

13 elif self.rect.right > breite: 

14 self.dir[0] = -random.randint(1, 3) 

15 if self.rect.top < 0: 

16 self.dir[1] = random.randint(1, 3) 

17 elif self.rect.bottom > hoehe: 

18 self.dir[1] = -random.randint(1, 3) 

19 self.rect = self.rect.move(self.dir) 

20 self.screen.blit(self.bild, self.rect) 



Bibliotheken 

pygame – Besser, Loop 

Game Loop, feste Framerate 

• Frames per Second (FPS) 

• Setzen mit clock.tick(FPS), 

• wartet/schläft gegebenenfalls 

Neues Feature 

• Neues Objekt bei jedem Klick 

(Maus loslassen) 

• Grosses Logo 

Position setzen 

class Logo(object): ... 

1 def setpos(self, pos): 

2 self.rect.left = pos[0] 

3 self.rect.top = pos[1] 

1 def main(): 

2 screen=pygame.display.set_mode(groesse) 

3 clock=pygame.time.Clock() 

4 logos=[Logo(screen) for i in range(17)] 

5 while True: 

6 clock.tick(60) 

7 for event in pygame.event.get(): 

8 if event.type == pygame.QUIT: 

9 sys.exit() 

10 if event.type == pygame.MOUSEBUTTONUP: 

11 if event.button == 1: 

12 logo=Logo(screen,"hsrml.png") 

13 logo.setpos(event.pos) 

14 logos.append(logo) 

15 screen.fill((50,130,40)) 

16 for logo in logos: 

17 logo.bewege() 

18 pygame.display.flip() 



Bibliotheken 

pygame – Mehr, Kollisionserkennung 

Kollisionserkennung 

• Wann berühren sich zwei 

Objekte 

• In pygame geschenkt 

Code-Änderung 

• Global merken, welche Objekte 

es gibt 

• Prüfen ob Kollision, wenn ja, 

dann alternatives Bild 

• Kollisionserkennung vieler 

Objekte hier naiv (quadratisch) 

• Bewegen über alle Objekte 

1 class Logo(object): 

2 logos = [] 

3 def __init__(self, ...): 

4 ... 

5 self.alt_bild=pygame.image.load("pygame.p 

6 Logo.logos.append(self) 

7 def bewege(self): 

8 ... 

9 bild = self.alt_bild 

10 if self._collides_with() 

11 else self.bild 

12 self.screen.blit(bild, self.rect) 

13 def _collides_with(self): 

14 return [logo for logo in Logo.logos 

15 if logo != self 

16 if self.rect.colliderect(logo.rect)] 

17 def main(): 

18 ... 

19 for logo in Logo.logos: 

20 ... 



Reguläre Ausdrücke 



• “Matchen”, finde passenden String 

• Flexibles Matchen auf “Pattern” mit Sonderzeichen 

• Erweiterte reguläre Ausdrücke, nicht Wildcards 

• In Java, Python, . . . verfügbar, Kommandozeile mit egrep 

Reguläre Ausdrücke in Skriptsprachen 

• Spezielle Bibliotheken (Python, PHP, Java) oder Teil der Sprache (Perl, awk) 

• Kompilation des Patterns, Ausführen auf C-basierter Engine 

Einsatz 

• Stringverarbeitung, Extraktion, Suchen/Ersetzen 

• Test auf syntaktische Korrektheit (Email-Adresse, Telefonnummer) 




Matchen mit einfachen Patterns 

Teil des Strings 

• Ein Pattern beschreibt einen Teil des 

zu durchsuchenden Strings 

Pattern – Zeichen matchen sich selbst 

• Zum Beispiel matcht das Pattern fahr 

den String erfahren 

Groß- und Kleinschreibung wird 

unterschieden 

• Das Pattern Fahr macht nicht den 

String erfahren 

Sonderzeichen haben spezielle 

Bedeutung 

• . ˆ$ * + ? { } [ ] \ | ( ) 

 

 

fahr 

erfahren 




Auswahlbereiche für ein Zeichen 

Auswahl mit [] 

[abcde] 

[a-z] 

[a-zA-Z] 

[abc$ˆ] 

[â-z] 

[ab\cd] 

Einzelnes Zeichen: Matcht entweder a, b, c, d oder e 

Bereich: Matcht jeden (einen) Kleinbuchstaben (ASCII) 

Bereich: Matcht Groß- und Kleinbuchstaben 

Sonderzeichen nicht aktiv in Bereichen. Matcht a, b, c, $ oder ˆ 

âm Anfang negiert den Bereich. Matcht alles außer Kleinbuchstaben 

\ hebt die besondere Bedeutung auf. Matcht a, b, \, c oder d 

Vordefinierte Auswahlbereiche 

\d Alle Ziffern, [0-9] 

\D Alles außer Ziffern, [ˆ0-9] 

\s Whitespace, [ \t\n\r\f\v] 

\S Alles außer Whitespace, 

[ˆ \t\n\r\f\v] 

\w Alphanumerische Zeichen, 

[a-zA-Z0-9] 

\W Alles außer alphanumerischen Zeichen, 

[â-zA-Z0-9] 

Auch für Nicht-ASCII Zeichensätze 

• Beispiel Deutsch: Umlaute 

äöüÄÖÜß werden von \w erkannt 

• Achtung: locale-Einstellungen 

werden berücksichtigt 

• Unicode? wieder alles anders... 




Wiederholungen und Gruppierungen 

matcht , , ... 

Pa*gei Pgei, Pagei, Paagei, ... 

Pa+gei Pagei, Paagei, ... 

Pa?gei 

Pgei, Pagei und sonst nichts 

P[ae]*gei, 

Pgei, Pagei, Pegei, Paagei, Paegei, Peagei 

wie P(a|e)*gei Peegei, Paaagei, ... 

(Pap|Mam)agei 

Papagei, Mamagei und sonst nichts 

(Pa)+gei Pagei, PaPagei, PaPaPagei, . . . 

Pa(pa)+gei Papagei, Papapagei, . . . 

Pa(pa){1,3}gei 

Papagei, Papapagei, Papapapagei und sonst nichts 




Besondere Zeichen und Bedeutung 

. beliebiges Zeichen {m,n} Wiederholung, mindestens 

m mal und maximal n mal 

* Wiederholung 0, 1 oder 

{n} Exakt n mal 

mehrfach 

? Wiederholung 0 oder 1 mal [ Beginn Auswahl aus Zeichen 

+ Wiederholung 1 oder mehrfach ] Ende Auswahl aus Zeichen 

( Beginn einer Gruppierung ˆ Anfang String/Zeile 

) Ende einer Gruppierung [ˆ Negation/Auswahl 

{ Beginn explizit gezählte 

$ Ende String/Zeile 

Wiederholung 

} Ende explizit gezählte 

Wiederholung 

| Oder-Auswahl von 

Gruppierungen 




Gierige Ausführung 

Von links nach rechts 

• Der erste passende Teilausdruck wird 

gematcht 

• Später passende Teilausdrücke 

werden ignoriert 

a[bc]+ 

xabdyaabc 

matcht ab, 

nicht abc 

So viel wie möglich 

• Bei dem ersten passenden 

Teilausdruck 

• So viel wie möglich Zeichen in den 

Match bringen 

a[bc]+ 

xadyaabbbcccd 

matcht abbbccc, 

nicht Teil davon 




Beispiele 

Binärzahlen (0|1[01]*) ohne führende Nullen 

Ganze Zahlen 0|([1-9][0-9]*) ohne führende Nullen 

Pi 3\.14 

Emailadresse \w+([.-]\w+)*@[a-z]\w+(\.[a-z]\w+)+ 

Einfaches Ausprobieren in der Shell (bash) 

• echo | egrep "" # matcht Teilstring 

• echo | egrep "ˆ()$" # exakter Match 

Beispiel 

• $ echo "11110" | egrep "ˆ(0|(1[01]*))$" 

11110 

$ 

• $ echo "011110" | egrep "ˆ(0|(1[01]*))$" 

$ 




Reguläre Ausdrücke und Wildcards 


Wildcards 

Matchen von Strings 

In Perl, Python, egrep, . . . 

(Meist) erweiterte reguläre Ausdrücke 

Beispiel Unterschiede 

a* passt auf beliebig viele a’s; * steht 

für die Wiederholung des vorherigen 

Zeichens 

Matchen von Strings 

In Shell, DOS, grep 

Standard Wildcards 

Beispiel Unterschiede 

a* passt auf jeden String der mit a 

beginnt; * steht für beliebige 

Zeichenfolge 

a? passt auf leeres Wort oder a a? passt auf jeden zwei Zeichen 

langen String, der mit a beginnt 

. . . 

Weitere Probleme 

• Groß-/Kleinschreibung unterschieden? 

• Das $-Zeichen als Beginn einer Variable 




Literatur und Online-Quellen für Reguläre Ausdrücke 

Reguläre Ausdrücke allgemein 

• http:// 

regexp-evaluator.de 

/tutorial/ 

• Die Referenz: 

Jeffrey E.F. Friedel 


O’Reilly 

Reguläre Ausdrücke in Python 

• http://docs.python.org/2.7/library/re.html 

• http://docs.python.org/dev/howto/regex.html 




re-Modul – Reguläre Ausdrücke in Python 

Reguläre Ausdrücke in Python 

• re-Modul 

• Matche, modifiziere, zerteile, ersetze, 

. . . 

• Kompilation des “Patterns” 

• Ausführen auf C-Engine 

Ausführlich dokumentiert – Lesen! 

Einfaches Beispiel 

• Pattern kompilieren 

• Matchen 

• Ergebnis ausgeben 

• oder alles auf einmal 


2 >>> pattern = re.compile("[a-z]+") 

3 >>> match = pattern.match("abc") 

4 >>> match.group() 

5 ’abc’ 

6 

7 >>> re.match(r’[a-z]+’, "abc").group() 

8 ’abc’ 




Beispiel – Kompilieren und Matchen 

Kompilieren 

• Modul-Funktion compile 

• Kompilieren eines regulären 

Ausdrucks erzeugt Patternobjekt 

Matchen 

• Methoden des Patternobjekts 

• Mit match Suche in einem String ab 

Anfang 

• Mit search Suche in einem String 

irgendwo 

• Ergebnis ist Matchobjekt wenn 

erfolgreich, sonst None 

• Aus Match-Objekt mit group den 

Match (String) extrahieren 


2 >>> pattern = re.compile(r’[a-z]+’) 

1 >>> match = pattern.match(’abcABC’) 


3 ’abc’ 

4 >>> match = pattern.match(’ABCabcABC’) 

5 >>> match 

6 >>> print match 

7 None 


9 AttributeError: ’NoneType’ object has no 

10 >>> match = pattern.search(’ABCabcABC’) 


12 ’abc’ 




Beispiel – Optionen und Kompakt 

Optionen 

• re.IGNORECASE ignorieren von 

Groß-/Kleinschreibung 

• Weitere Optionen: re.LOCALE, 

re.MULTILINE, re.DOTALL, 

re.UNICODE, . . . 

• Optionen mit Oder | verknüpft 

Kompakter Code 

• re-Modul stellt Funktionen zur 

Verfügung 

1 >>> pattern = re.compile(r’[a-z]+’, 

2 re.IGNORECASE) 

3 >>> match = pattern.search(’ABCabcABC’) 


5 ’ABCabcABC’ 

1 >>> re.search(’[a-z]+’, 

2 "ABCabcABC") 

3 

4 >>> re.search(’[a-z]+’, 

5 "ABCabcABC").group() 

6 ’abc’ 

7 

• Alles in einem Ausdruck möglich >>> re.search(’[a-z]+’, 

8 "ABCabcABC", 

9 re.IGNORECASE).group() 

10 ’ABCabcABC’ 




Backslash-Zirkus 

Problem 

• Mit \ (Backslash) werden Sonderzeichen Ihres besonderen Status beraubt 

• Viele Backslashes in Python sind ein Problem 

Lösung 

• Text \section matchen benötigt \\\\section als Pattern 

• Ein \ um das Backslash im Python String zu haben 

• Die beiden anderen um das zweite Backslash für den regulären Ausdruck zu haben 

• Benutze “raw” Strings in dem alle Zeichen ohne Sonderstatus vorkommen 

• r"\\section" entspricht "\\\\section" 

1 >>> re.search(’\\\\section’, "dies ist \\section wichtig").group() 

2 ’\\section’ 

3 >>> print re.search(’\\\\section’, "dies ist \\section wichtig").group() 

4 \section 

5 >>> re.search(r’\\section’, "dies ist \\section wichtig").group() 

6 ’\\section’ 




Gruppierungen 

Gruppierungen 

• Teilbereich im Pattern, die 

referenziert werden können 

• Klammern im Pattern 

Zugriff auf Gruppierungen 

• groups(): Alle Gruppierungen 

• groups(i): Die i.-te Gruppe, 

definiert durch i öffnende 

Klammern im Pattern 

• group(0), group(): Der gesamte 

Match 

Zurückreferenzieren durch \i im Pattern 

• Beispiel: Suche doppeltes 

Vorkommen 

1 >>> pat = r’(a(b)c)d’ 

2 >>> s = "abcd" 

3 >>> re.search(pat, s).groups() 

4 (’abc’, ’b’) 

5 >>> re.search(pat, s).group() 

6 ’abcd’ 

7 >>> re.search(pat, s).group(0) 

8 ’abcd’ 


10 ’abc’ 


12 ’b’ 


14 IndexError: no such group 

15 >>> re.search(pat, s).group(0, 1, 2) 

16 (’abcd’, ’abc’, ’b’) 

17 >>> s = "Ist doppelt doppelt drin" 

18 >>> pat = r’([a-z]+ )\1’ 

19 >>> print re.search(pat, s).group() 

20 doppelt doppelt 




Modifizieren von Strings 

Zerteilen von Strings 

• re.split(, ) 

• Gibt Liste von Strings zurück 

• Zerteilt bei jedem 

Match von 

Suchen und Ersetzen 

• re.sub(,,) 

• Gibt neuen String zurück 

• Bei jedem Match von 

in wird 

stattdessen eingesetzt 

1 >>> pat = r’\W+’ 

2 >>> s = "Das ist ein netter kleiner Test" 

3 >>> re.split(pat, s) 

4 [’Das’,’ist’,’ein’,’netter’,’kleiner’,’Test’] 

1 >>> pat = ’(blaue|weisse|rote)’ 

2 >>> neu = "bunte" 

3 >>> s = "Die blaue Socke und der rote Ball" 

4 >>> re.sub(pat, neu, s) 

5 ’Die bunte Socke und der bunte Ball’ 



Einführung 

Multitasking 

Multitasking 

• Mehrere Dinge “gleichzeitig” tun 

• Erwartetes Verhalten auf Rechnern 

• Musik, Web (+ Animation), Download 

• Ein “Ding” ist meist ein Prozess 

• Eigener Speicher 

• Eigener Ausführungsstrang/-faden 

• Beispiel: P1, P2 und P3/4 parallel; P4 nach nach P3 

Prozessoren/Kerne und Prozesse 

• Ausführung der Prozesse auf Prozessoren/Kernen 

• Multitasking auch bei einem Kern 

• Zeitscheiben unterteilen Prozessorzeit 

• Jeder Prozess erhält abwechselnd eine (sehr sehr 

kleine) Zeitscheibe 

• Bei vielen Kernen mehr (parallele Zeitscheiben) 

• Aus Benutzersicht alles quasi gleichzeitig 

Zeit 

Zeit 

P3 

P1 P2 

P4 

P3 

P1 P2 

P4 

Zeitscheibe 

Prozessor 



Einführung 

Threads 

Prozesse 

• Eigener Speicher, eigener Ausführungsfaden 

P1 

P2 

• Fehler in einem Prozess betrifft nur diesen Prozess 

• Bei C mit Speicherfehler (Segmentation fault) lief alles 

außer Ihrem Prozess weiter 

• Schwergewichtige Umschaltung der Zeitscheiben, 

viel Aufwand je Kontextwechsel 

Zeit 

Threads 

• Teilen sich Speicher, eigener Ausführungsfaden 

P1 

P2 

• Threads innerhalb eines Prozesses 

• Leichtgewichtiges Umschalten der Zeitscheiben, 

weniger Aufwand je Kontextwechsel 

T1 T2 T3 

T4 

T5 

T6 

T7 

• Verteilung Zeitscheiben auf alle Threads aller 

Prozesse (bei Betriebssystemunterstützung) 

Zeit 

• Nebenläufigkeit als Programmiermodell 



Einführung 


Programmieren mit Nebenläufigkeit 

• Mehrere Ausführungsstränge/-fäden quasi gleichzeitig bei 

gemeinsamen Daten/Ressourcen 

• Tausende von Threads möglich, leichtgewichtiger 

• Komplex und mächtig bei Verwendung 

Weit verbreitet in Programmierumgebungen 

• In C/C++ mit Bibliotheken, nutzen Betriebssystemunterstützung 

• In Java Teil der Sprache/JVM mit Bibliotheken 

• In Python ähnliche API wie in Java 

Einsatzgebiete 

• Kein Warten bei I/O-Operationen, Überbrücken Latenzen bei 

Netzwerkkommunikation; zum Beispiel bei UI kein “Einfrieren der UI” mehr 

• Nutzung von Mehrkernarchitekturen, parallele Algorithmen, Verteilen der 

Arbeitslast auf mehrere Kerne 

• Leider nicht mit CPython (oder PyPy) aber mit Jython 

• In CPython ist Alternative multiprocessing-Modul 

Globale Daten 

T1 T2 T3 

T4 



Thread-Programmierung in Python 


Java-Style 

• Thread-API modelliert nach Java 

• threading-Modul, Thread-Klasse 

• Methode run überschreiben 

Beispiel – die i.-te Primzahl 

• Primzahlgenerator prim gegeben 

• Klasse erbt von threading.Thread 

• Bei Initialisierung i merken 

• Methode run, solange Primzahlen bis 

i.-te erreicht, Ausgabe 

• Instanzvariablen und lokale Variablen 

für den Thread 

• p und e sind thread-lokale Variablen 

(auf dem Stack) 

1 import threading, sys 

2 from primegen import primes 

3 

4 class IthPrime(threading.Thread): 

5 def __init__(self, i): 

6 threading.Thread.__init__(self) 

7 self.i = i 

8 def run(self): 

9 p = primes() 

10 for _ in range(self.i): 

11 e = p.next() 

12 self.ith_prime = e 

13 print "done %d, %d" % (self.i, e) 

14 def get_ith_prim(): 

15 return self.ith_prime 




Wiederholung – Primzahlgenerator 

Generieren von Primzahlen 

• 2 und 3 sind Primzahlen 

• Ab da in Zweier-Schritten, wenn 

teilerfrei 

primegen.py 

1 def _teiler(x): 

2 return [t for t in range(2, x) 

3 if x%t == 0] 

4 

5 def primes(): 

6 yield 2 

7 yield 3 

8 i = 5 

9 while True: 

10 if _teiler(i) == []: 

11 yield i 

12 i += 2 




Thread starten und auf Ende warten 

Thread starten 

• Instanz erzeugen und Methode start 

• Asynchron, kehrt sofort zurück 

• Seiteneffekt ist, dass Thread los läuft 

• 

6 

Thread beendet sobald run beendet ist t = IthPrime(i) 

7 t.start() 

Auf Ende warten 

8 print "compute in background" 

• Eventuell würde Haupt-Thread sich 9 t.join() 

beenden (ohne weitere Maßnahme) 10 s = "Die %d.te Primzahl ist %d" 

11 print s % (i, t.ith_prime) 

• Methode join auf Thread-Instanz 

12 print "ready" 

blockiert und wartet auf das Ende des 

Threads 

Zugriff auf Daten 

• Zuweisungen Python: atomar, sichtbar 

(nicht wie in Java) 

• Direkter Zugriff auf Attribute in 

Ordnung 

1 

2 if __name__ == ’__main__’: 

3 i = 3 

4 if sys.argv[1:]: 

5 i = int(sys.argv[1]) 

$ python ith_prime.py 1000 

compute in background 

done 1000, 7919 

Die 1000.te Primzahl ist 7919 

ready 




Mehrere Threads 

Mehrere Threads 

• Beispiel 3 Threads für 1000.te, 

1001.te und 1002.te Primzahl 

• Jeweils auf Threads warten 

• Ausgabe der Strings (in richtiger 

Reihenfolge) 

Reihenfolge in den Threads 

• Nicht vorhersagbar 

• Reihenfolge der done Ausgabe 

variiert 

1 if __name__ == ’__main__’: 

2 i = int(sys.argv[1]) 

3 ts = [IthPrime(j) 

4 for j in range(i, i+3)] 

5 for t in ts: 

6 t.start() 


8 t.join() 


10 s = "Die %d.te Primzahl ist %d" 

11 print s % (t.i, t.ith_prime) 

$ python ith_prime_mehrere.py 1000 

done 1000, 7919 

done 1002, 7933 

done 1001, 7927 






Kontrolle Ablauf 

Threads – Kontrolle Ablauf 

Unmöglich Thread von außen zu stoppen 

• Es kann keine Möglichkeit geben, die 

immer funktioniert 

• Anwendungsentwickler muss entsprechende 

Möglichkeiten vorsehen 

Ansatz 

• Methoden zum Setzen von Variablen 

• Periodische Überprüfung der 

Variablen 

• Synchronisation ok (in Python) 

• Ein Thread liest, anderer schreibt 

• Bool immer komplett geändert 

• Aktuelle Werte in CPython immer 

gleich sichtbar (nicht in Java) 

1 from threading import Thread 

2 from time import sleep 

3 

4 class Incer(Thread): 


6 Thread.__init__(self) 

7 self.weiter = True 


9 x = 0 

10 while self.weiter: 

11 x += 1 

12 sleep(1) # 1 Sekunde schlafen 

13 print "x", x 

14 def anhalten(self): 

15 self.weiter = False 




Threads– Kontrolle Ablauf, Verwendung 

Beispiel Ausgabe 

• isAlive, läuft Thread? 

• join verwenden 

1 from incer import Incer 


3 

4 inc = Incer() 

5 inc.start() 

6 sleep(3) 

7 inc.anhalten() 

8 print "Lebt?", inc.isAlive() 

9 inc.join() 

10 print "Lebt?", inc.isAlive() 

x 1 

x 2 

Lebt? True 

x 3 

Lebt? False 




Threads – Ende erreicht? 

Niemals aktiv warten! 

• CPU-Zeit mit Nichtstun/Warten 

verschwendet, hohe Last 

• Nie, nie, nie tun 

Thread.join ist ok 

• Wartet, dass Thread beendet wird 

• Aktuell laufender Thread hält, 

verschwendet aber keine 

Prozessorzeit 

Nachteil von Thread.join 

• Aktueller Thread läuft nicht weiter 

(aber das ist Intention) 

• Falls # was sinnvolles lange dauert, 

dann wird nicht gleich reagiert sobald 

der Thread zu Ende ist 



3 


5 # Thread beginnt zu laufen 

6 inc.start() 

7 while inc.isAlive(): # busy wait, boese 

8 pass 

9 # weiter nach Thread-Ende 



3 


5 inc.start() 

6 # was sinnvolles 

7 inc.join() 

8 # Ergebnis des Threads verwenden 




Aktion nach Ende Thread – Naja 

Ziel 

• Etwas nach Ende eines Threads tun 

• Direkt, wenn die Berechnung im 

Thread zu Ende ist 

Fragwürdige Umsetzung 

• Verarbeitung im Haupt-Thread 

• Warten bis Berechnungs-Thread am 

Ende 

Problem 

• Falls # was sinnvolles lange dauert 

• Keine sofortige Reaktion falls 

Berechnung zu Ende 

1000.te Primzahl ist 7919 

1 import threading, primegen 

2 class Langlaeufer(threading.Thread): 

3 def __init__(self, iteprim): 


5 self.iteprim = iteprim 


7 p = primegen.primes() 

8 for _ in range(self.iteprim): 

9 e = p.next() 

10 self.prim = e 

11 def get_prim(self): 

12 return self.prim 

13 if __name__ == ’__main__’: 

14 ite = 1000 

15 t = Langlaeufer(ite) 

16 t.start() 

17 # was anderes sinnvolles 

18 t.join() 

19 tup = (ite, t.get_prim()) 

20 print "%d.te Primzahl ist %d" % tup 




Aktion nach Ende Thread – Besser 

Bessere Umsetzung 

• Verarbeitung noch im 

Berechnungs-Thread 

• Callback-Funktion mit übergeben 

Vorteile 

• Es wird sofort bei Ende der 

Berechnung mit dem 

Berechnungsergebnis weiter 

gearbeitet 

• Main-Thread wird nicht beansprucht 

• Durch Übergabe “Callback” bleibt 

Implementierung unabhängig 

1000.te Primzahl ist 7919 

1 import threading, primegen 

2 class Langlaeufer(threading.Thread): 

3 def __init__(self, itep, ende=None): 


5 self.iteprim = itep 

6 self.am_ende = ende 


8 p = primegen.primes() 

9 for _ in range(self.iteprim): 

10 e = p.next() 

11 self.prim = e 

12 self.am_ende(self.prim) 

13 if __name__ == ’__main__’: 

14 ite = 1000 

15 def print_prim(iteprim): 

16 tup = (ite, iteprim) 

17 print "%d.te Primzahl ist %d" % tup 

18 t = Langlaeufer(ite, print_prim) 

19 t.start() 

20 # was anderes sinnvolles 



Kritischer Wettlauf, Race Condition 

Reihenfolgeproblem 

Thread-Ausführung ist nicht-deterministisch 

• Keine Aussage welcher Thread zuerst beendet wird möglich 

• Keine Aussage welcher Thread(Teil) vor/nach anderem Thread(Teil) ausgeführt 

• Keine Aussage wann welche Anweisung in einem Thread unterbrochen wird 

Problem bei gemeinsam geschriebenen (shared) Daten 

• Bei getrennt genutzten oder Nur-Lese-Daten kein Problem 

• Wann immer möglich Thread-lokale Daten verwenden, idealerweise keine shared 

Daten oder nur lesbare Daten 

• Falls shared Daten nur lesbar sind und bei gemeinsamer Verwaltung sicher initialisiert 

sind, keine Inkonsistenz möglich 

• Reihenfolge des Schreibens bei gemeinsamen Daten potenziell problematisch 

• Zusätzliche Ablauf-Fehler bei ansonsten “sequenziell korrektem” Programm möglich 

• Kritischer Wettlauf (race condition) 

Lösungsansatz 

• Kritische Sektionen identifizieren und synchronisieren 

• Nur ein Ausführungsstrang in kritischer Sektion (Sperren) 




Kritischer Wettlauf – Beispiel Incer 

Globale Variable x 

• Initial 0 

• Durch zwei Threads um 1 erhöht 

Problem 

• x+=1 sind drei unterbrechbare 

Anweisungen 

• Lese (read/r) x in y 

• Berechne y = y + 1 

• Schreibe (write/w) y in x 

• Lesen und Schreiben der gleichen 

Variable x, Race condition 

• y unkritisch, thread-lokal, zwei Mal y 

y 

6 

7 

Thread-1 

x+=1 

x+=1 

x+=1 

x+=1 

x+=1 

x+=1 

y=r(x) 

y+=1 

x 

0 

? 12 ? 

x 

6 

Thread-2 

x+=1 

x+=1 

x+=1 

x+=1 

x+=1 

x+=1 

y=r(x) 

y+=1 

y 

6 

7 

Kritischer Wettlauf 

7 

x=w(y) 

y=w(y) 

7 

• Quasi gleichzeitiges Ausführen in 

kritischem Bereich 

Kritischer 

Bereich 

7 

statt 8 




Unsynchronisierter Incer in Python 

Incer 

• x ist globale Variable auf Modulebene, 

die mehrmals erhöht wird 

• Instanzvariable runs (thread-lokal), wie 

häufig wird x je Thread erhöht 

• In run jedes Threads das 

Inkrementieren jeweils runs mal 

Ausführen 

• Zwei Threads 

• 1 Million Mal erhöhen je Thread 

• Laufen lassen, Überraschung 

• Unvorhersagbares Verhalten 

• x meist < 2 Millionen 

• Falsch, Nebenläufigkeits-Bug 

Oooops 1488923 statt 2000000 


2 x=0 


4 def __init__(self, runs): 


6 self.runs = runs 


8 global x 

9 for _ in xrange(self.runs): 

10 x += 1 

11 if __name__ == ’__main__’: 

12 runs = 10**6 

13 inc1, inc2 = Incer(runs), Incer(runs) 

14 inc1.start() 

15 inc2.start() 

16 inc1.join() 

17 inc2.join() 

18 if x != 2*runs: 

19 print "Oooops",x,"statt",2*runs 




Kritischer Bereich 

Kritischer Wettlauf 

• Potenzieller Fehler durch quasi-gleichzeitiges 

Ausführen von kritischen Bereichen 

Kritischer Bereich 

• Anweisungsfolge, mit zusammenhängendem Lesen 

und Schreiben auf geteilten Daten 

• Zusammengesetzte Aktionen wie zum Beispiel 

“check then act” 

• Synchronisation um sicherzustellen, dass immer nur 

ein Thread sich in einem kritischen Bereich befindet 

Beispiele für kritischen Bereich 

• x += 1, Lesen/ Schreiben gemeinsamer Variable 

• “check” (Warteschlange nicht leer?) “then act” (hole 

erstes Element der Warteschlange), nicht-leere 

Warteschlange nicht garantiert (durch anderen 

Thread zwischenzeitlich geleert) 

1 # Beginn kritischer Bereich 

2 x += 1 

3 # Ende kritischer Bereich 


2 y = x 

3 y += 1 

4 x = y 



2 if not queue.empty(): 

3 v = queue.get_nowait() 




Sperren 

Synchronisation mit Sperren 

Kritischer Bereich: x+=1 

Sperr-Objekt 

• Bietet sichere Sperre, atomare 

Operation zur Sperrverwaltung 

• acquire: Belegt Sperre (Anfrage), falls 

Sperre schon belegt, wird aktuell 

6 

7 

Thread.__init__(self) 

self.runs = runs 


anfragender Thread suspendiert 

9 global x 

(schlafen gelegt) 


• release: Gibt belegte Sperre wieder 11 sperre.acquire() # Start sicher 

frei (sollte durch diesen Thread belegt 12 x += 1 # kritischer Bereich 

worden sein, sonst wird es schwierig 

zu durchschauen) 

13 

14 

sperre.release() # Ende sicher 

if __name__ == ’__main__’: 

15 runs = 10**6 

• Best-Practice: acquire/release-Block 

16 inc1, inc2 = Incer(runs), Incer(runs) 

umschließt kritischen Bereich, 11–13 

17 inc1.start(); inc2.start() 

gut, da alles gesichert ;-) 

1 from threading import Thread, Lock 

2 x = 0 

3 sperre = Lock() # Guard 


5 def __init__(self, runs): 

18 inc1.join(); inc2.join() 

19 if x == 2*runs: 

20 print "gut, da alles gesichert ;-)" 



Sperren 

Sperren ist aufwendig 

Sperren ist aufwendig 

• Unterstützung des Betriebssystems, 

der Hardware (spezielle Instruktionen) 

• Kontextwechsel bei Suspendierung 

des Threads durch belegte Sperre 

5 

6 

inc1, inc2 = Incer(runs), Incer(runs) 

inc1.start(); inc2.start() 


• Beispiel, hohe Wahrscheinlichkeit 

8 if __name__ == ’__main__’: 

blockierter Bereich (hohe “Contention”) 

9 runs = 10**7 

• (eine Größenordnung langsamer) 

Best-Practice 

• Sperren so kurz und gezielt wie 

möglich, nur so lange wie nötig 

• Zugriff auf eine gemeinsame Variable 

immer mit derselben Sperre (dem 

Guard/Wächter) 

• Sperren kritischer Bereich für 

Korrektheit notwendig 

1 from incerunsync import Incer as UIncer 

2 from incermitlock import Incer as SIncer 

3 from timeit import default_timer as now 

4 def runit(Incer, runs): 

10 start = now() 

11 runit(UIncer, runs) 

12 t = now()-start 

13 print "Unsynced: %6.2f s" % t 

14 start = now() 

15 runit(SIncer, runs) 

16 t = now()-start 

17 print "Synced : %6.2f s" % t 

Unsynced: 1.67 s 

Synced : 14.97 s 



Sperren 

Sperren Lock und RLock 

Lock – Sperrobjekt, exklusiv 

• acquire(blocked=True), default 

• Sperre belegen wenn verfügbar und True zurück 

• Wenn belegt, Thread blockieren (schlafen legen) 

• acquire(blocked=False) 

• Sperre belegen wenn verfügbar und True zurück 

• Wenn Sperre schon belegt, dann False zurück 

• Erlaubt auf belegte Sperren zu reagieren 

• release() 

• Gibt belegtes Sperrobjekt frei 

• Ausnahme, falls Sperre nicht belegt 

RLock – Sperrobjekt, reentrant, wie Lock plus 

• Erlaubt verschachtelte acquire/release Aufrufe 

• Sonst acquire();acquire() Deadlock 

• Bei RLock wird nur ein Zähler erhöht 

• Verwendung: Sichere Methode in sicherer Methode 

• Verhalten wie in Java 

1 from threading import RLock 

2 sperre = RLock() 

3 class C(object): 

4 def a(self): 

5 sperre.acquire() 

6 print "methode a" 

7 self.b() 

8 sperre.release() 

9 def b(self): 

10 sperre.acquire() 

11 print "methode b" 

12 sperre.release() 

13 

14 if __name__ == ’__main__’: 

15 c = C() 

16 c.a() 

methode a 

methode b 



Sperren 

Sichere Objekte, Monitor 

Bisher: Konventionen 

• Globale Objekte x und sperre 

• Konvention, dass jeder, der auf x 

zugreift diesen Bereich mit sperre 

sperren muss 

• Fehleranfällig (nicht perfekter 

Entwickler) 

Besser: Kapselung in sicherem Objekt 

• Eigene Klasse mit sicheren 

Zugriffsmethoden 

• synchronized in Java 

• Lokales Sperrobjekt in Instanz der 

Klasse 

• In Java meist Instanzobjekt selbst 

• Typisches Pattern bei Methode value, 

sonst release schwierig 

counter.py 


2 class Counter(object): 


4 self.count = 0 

5 self._lock = RLock() 

6 def inc(self): 

7 self._lock.acquire() 

8 self.count += 1 

9 self._lock.release() 

10 def value(self): 

11 self._lock.acquire() 

12 ret = self.count 

13 self._lock.release() 

14 return ret 

Counter ist ein Monitor 



Sperren 

Sichere Objekte, Monitor, Verwendung 

Incer mit Counter 

• Counter als sicheres Objekt 

• Instanz von Counter zum Zählen 

Vorteile 

• Verwender (Entwickler) von Counter 

muss keine Sperren verwenden 

• Entwickler kann keine Sperren 

vergessen 

RLock teurer in Python, 

Beispiel 2,5 Mal langsamer 

gut, da alles gesichert ;-) 


2 from counter import Counter 


4 def __init__(self, counter, runs): 


6 self.counter = counter 

7 self.runs = runs 



10 self.counter.inc() 

11 if __name__ == ’__main__’: 

12 runs = 10**6 

13 counter = Counter() 

14 inc1 = Incer(counter, runs) 

15 inc2 = Incer(counter, runs) 

16 inc1.start(); inc2.start() 


18 if 2*runs == counter.value(): 

19 print "gut, da alles gesichert ;-)" 



Sperren 

Das with-Statement 

with-Statement, ein Block 

• Default-Operationen bei Eintritt 

__enter__ Austritt __exit__ aus Block 

• Beispiele: Bei Datei öffnen/schließen, 

bei Sperre belegen/freigeben 

• Seit Python 2.6 

Beispiel: Counter-Objekt aufgeräumter 

• Ausführung, hohe Contention 


2 from counterwith import Counter 

3 from IncerCounter import Incer 

4 no_incers, incruns = 300, 1000 

5 counter = Counter() 

6 incers = [Incer(counter, incruns) for _ in range(no_incers)] 

7 for incer in incers: incer.start() 

8 for incer in incers: incer.join() # barrier 


2 class Counter(object): 


4 self.count = 0 

5 self._lock = RLock() 

6 def inc(self): 

7 with self._lock: 

8 self.count += 1 

9 def value(self): 


11 return self.count 

got 300000 expected 300000 

9 print "got", counter.value(), "expected", no_incers*incruns 



Sperren 

Zwei sichere Objekte kombiniert nicht unbedingt sicher 

Zwei sichere Objekte 

• Zwei Counter 

• Jeder Counter für sich sicher 

• Egal wie viele Threads gleichzeitig 

erhöhen, jede Erhöhung wird gezählt 

• Neuer kritischer Bereich wenn beide 

Counter immer gleichzeitig erhöht 

werden sollen 

Sichern 

• Neue Sperre, während Erhöhung 

stattfindet 

• Alte Sperren jetzt nutzlos, nur noch 

Aufwand 

47786 Oopps von 100000 Tests: 47% 

1 from threading import Thread, RLock 

2 from counter import Counter 

3 c1, c2 = Counter(), Counter() 

4 class ZweiCounter(Thread): 


6 for _ in range(10**5): 

7 c1.inc(); c2.inc() 

8 class Peeker(Thread): 


10 tests, oops = 0, 0 

11 for _ in range(10**5): 

12 tests += 1 

13 if c1.value() != c2.value(): 

14 oops += 1 

15 s = "%d Oopps von %d Tests: %d%%" 

16 prozent = oops*100./tests 

17 print s % (oops, tests, prozent) 

18 zc, p = ZweiCounter(), Peeker() 

19 zc.start(); p.start() 



Gefahren bei der Thread-Programmierung 


Safety, Sicherheit 

• Vermeide Fehler, die durch Lese/Schreib-Zugriff verschiedener Threads auf 

gemeinsame Variable entstehen (Reihenfolge) 

• Kein Problem, falls keine gemeinsamen Variablem oder Nur-Lese Variablen 

• Ansonsten Einsatz von Sperren 

Liveness, Fortschritt 

• Irgend etwas sinnvolles wird irgendwann passieren 

• Beispiele: Deadlock (wie in DBMS) oder Starvation (Verhungern) 

• Schwer zu erkennen und zu beseitigen, sporadisches Auftreten 

Performance 

• Mehrkosten zur Laufzeit (Ressourcen/Speicher je Thread, Kontextwechsel, 

Synchronisation) 

• Wenige Threads (bei Berechnung nicht deutlich mehr als Kerne) 

• Wenige und kurze Sperren 

• Anpassen Algorithmen an verteilte Umgebung 




Deadlock 

Deadlock, Verklemmung 

• Threads warten auf Freigabe von 

Ressourcen, die nicht erfolgt 

• Kein Fortschritt mehr, unendliches 

Warten 

• Verschiedene Szenarios möglich 

Zweimal sperren auf einer Sperre 


• In einem Thread Sperre erhalten 

11 self.mach() 

• Nochmal Sperre holen, sperrt auf ewig12 def run(self): 

Posix Sperren 

• Sperren müssen freigegeben werden, 

auch wenn derselbe Thread die 

Sperre anfordert 

• Java-Verhalten mit RLock, dann läuft 

Beispiel durch 


2 class Deadlock(Thread): 



5 self._lock = Lock() 

6 def mach(self): 


8 pass 

9 def do(self): 

13 self.do() 

14 print "fertig" 

15 d = Deadlock() 

16 d.start() 

17 d.join() 

18 # haengt, nie fertig 




Deadlock – Verschränkte Sperren 

Verschränkt Sperren auf zwei Sperren 

• Ein Thread macht erst l1, dann l2 

• Ein Anderer erst l2, dann l1 

• Deadlock, sobald do und mach 

verschränkt ausgeführt werden 

Lösung 

• mach: l1 gesperrt, Threadwechsel 

• do: l2 gesperrt, warte auf l1 

• mach: warte auf l2 

• Sperrordnung, wie bei DBMS 

• Zum Beispiel l1 immer vor l2 

d1 

l1 

l2 

d2 

deadlockverschr.py 


2 l1, l2 = Lock(), Lock() 

3 class Deadlock(Thread): 

4 def __init__(self, doDo=True): 


6 self.d = doDo 

7 def mach(self): 

8 with l1: 

9 with l2: 

10 print "mach" 

11 def do(self): 

12 with l2: 

13 with l1: 

14 print "do" 


16 f = self.do if self.d else self.mac 

17 for _ in range(10**4): f() 




Deadlock – Verschränkte Sperren, Ausführung 

Verwendung 

• Zwei Instanzen 

• Eine mit Sperrreihenfolge 

l1, dann l2 

• Eine mit Sperrreihenfolge 

l2, dann l1 

• Meist kein Ende sondern Deadlock, 

verschränktes Sperren 

1 from deadlockverschr import Deadlock 

2 

3 d1 = Deadlock(True) # do 

4 d2 = Deadlock(False) # mach 

5 d1.start() 

6 d2.start() 

7 d1.join() 

8 d2.join() 

9 

10 # passiert wahrscheinlich nie 

11 print "Ganz Fertig" 



Besonderheiten bei Threads in Python 

Besonderheiten bei Threads in Python 

GIL in CPython-Implementierung (und PyPy) 

• Global Interpreter Lock (GIL) 

• Nur ein Python-Thread kann zu einem Zeitpunkt auf Python-Strukturen zugreifen 

• Nur ein Python-Thread läuft zu jedem Zeitpunkt 

• Keine effektive Nutzung von Mehrkernsystemen möglich 

• Trotzdem sinnvolle Nutzung von Wartezeiten bei Langläufern 

• GIL wird bei Warten auf externe Ereignisse (IO) losgelassen 

• Thread-Scheduling von Laufzeitumgebung 

• Alle 100 Bytecode-Anweisungen 

• sys.getcheckinterval, sys.setcheckinterval 

• Alternative ab Python 2.6: multithreading 

• Arbeitet mit mehreren Python-Prozessen 

• Effektive Nutzung von Mehrkernsystemen möglich 

Basiert auf thread-Modul 

• Low-Level API, für die meisten Umgebungen verwendbar 

• Empfehlung: threading verwenden, Wissen für Java-Programmierung verwendbar 



Producer/Consumer Pattern 

Producer/Consumer 

Situation 

• Ein Produzent erzeugt Werte 

• Ein Konsument verwendet Werte 

• Beide können unabhängig voneinander laufen 

• Problem: Konsument muss warten, bis Produzent 

fertig; Produzent muss warten, bis Konsument fertig 

Warteschlange 

• Entkopplung von Produzent und Konsument 

• Produzent legt fertige Werte in Warteschlange 

• Konsument holt Werte aus der Warteschlange 

• Warteschlange ist gemeinsames Objekt, Zugriffe 

müssen synchronisiert werden 

• Bei leerer Warteschlange muss Konsument warten 

• Bei voller Warteschlange (begrenzte Größe) muss 

Produzent warten 

• Einfügen/Entfernen nur einer gleichzeitig 

Produzent 

Konsument 

Warteschlange 

flexible 

Größe 




Producer 

Aufgabe 

• Erzeuge Zahlen von 1 bis anz 

Klasse Producer 

• Ein Thread 

Gemeinsame Objekte 

• Warteschlange, queue 

• Sperre auf Warteschlange, qlock 

Ausführung, run 

• Immer kurz warten 

• Zugriff auf Warteschlange als 

kritischer Bereich mit Sperren 

umschließen 

• Jeweils nächstes Element einfügen 

producer.py 


2 import time, random 

3 class Producer(Thread): 

4 def __init__(self, anz, queue, qlock): 


6 self.anz = anz # endlich viele 

7 self.queue = queue 

8 self.qlock = qlock 


10 for i in range(1, self.anz+1): 

11 # etwas Zeit lassen... 

12 time.sleep(random.random()/100.) 

13 with self.qlock: 

14 self.queue.insert(0, i) 




Consumer 

Aufgabe 

• Alle Elemente aus 

Warteschlange aufsummieren 

Klasse Consumer, ein Thread 


• Warteschlange, queue 

• Sperre auf Warteschl., qlock 

Ausführung, run 

• Solange noch was kommen 

kann oder noch was da ist 

• Entferne nächstes Element von 

queue und summiere es auf 

• Falls kein Element in queue, 

ein bisschen warten 

consumer.py 



3 class Consumer(Thread): 

4 def __init__(self, queue, qlock): 


6 self.queue, self.qlock = queue, qlock 

7 self.summe, self.misses = 0,0 

8 self.done = False # soll stoppen 


10 while not self.done or self.queue: 

11 value = None 

12 with self.qlock: 

13 if self.queue: 

14 value = self.queue.pop() 

15 if value: 

16 self.summe += value 

17 else: 

18 time.sleep(random.random()/100.) 

19 self.misses += 1 




Producer / Consumer 

1 from producer import Producer 

Gemeinsame Objekte anlegen 

2 from consumer import Consumer 

• Warteschlange, list 

3 from threading import Lock 

• Warteschlangensperre, Lock 

4 

5 anz = 100 

Producer/Consumer erzeugen, starten 

6 queue = [] 

• Erste beide erzeugen 

7 qlock = Lock() 

• 

8 

Dann beide starten (fast gleichzeitig) 

9 producer = Producer(anz, queue, qlock) 

Producer/Consumer join 

10 consumer = Consumer(queue, qlock) 

• Auf Ende des Produzenten warten, nur11 

anz viele werden erzeugt 

12 producer.start() 

13 consumer.start() 

• Dem Konsumenten mitteilen, dass 

14 

keine weiteren Werte kommen werden 

15 producer.join() 

• Auf Ende Consumer warten 

16 consumer.done = True 

Ergebnis ist fertig 

misses: 91 

17 consumer.join() 

18 

19 print "misses:", consumer.misses 




Performance Problem 

Producer produziert zu schnell 

• Sehr viel Speicher wird verschwendet 

• Lösung: Begrenzte Warteschlange 

Warteschlange voll oder leer 

• Warteschlange leer: Konsument findet keinen Wert 

• Warteschlange voll: Produzent generiert keinen Wert 

• Aber in beiden Fällen wir Schleife durchlaufen 

• Rechenzeit wird verbraucht ohne Effekt 

(Teil-)Lösung bisher 

• Wenn Extremsituation eintritt, dann ein bisschen schlafen 

• Ist aber nur raten/flicken 

Lösungsansatz 

• Thread schlafen legen und wieder aufwecken 

• Wenn Warteschlange leer, dann soll Konsument schlafen 

• Wenn Element eingefügt wird, dann soll Konsument geweckt werden 

• Spezielle Konstrukte für Schlafen/Aufwecken sind wait/notify 



wait/notify 

wait/notify 

Condition 

• Klasse von threading 

• Hält intern Sperre, kann sie auch 

beim Initialisieren bekommen 

• Implementiert Lock-Interface, 

acquire, release 

c.acquire() 

erzeuge() 

c.notify() 

c.release() 

c = Condition() 

c.acquire() 

while nixda(): 

wait() 

verwende() 

c.release() 

• Weitere Methoden wait, notify, notifyAll 

wait() 

• Lässt Sperre los (Sperre muss belegt sein), legt aktuellen Thread schlafen 

• Weiterlaufen erst, wenn notify oder notifyAll auf Condition gerufen wurde 

notify() 

• Sperre muss belegt sein 

• Informiert einen der wartenden Threads, dass es weiter gehen könnte 

• Programmierer lässt danach Sperre meist wieder los (release) 

notifyAll(): wie notify, nur werden alle Threads informiert 

Jedes Java Objekt implementiert wait, notify, notifyAll 



wait/notify 

Producer mit wait/notify 

Aufgabe 

• Produzent ohne aktives Warten 


• Warteschlange queue als Liste 

• Condition cond als Sperre 

Producer, Thread 

• Von außen abbrechbar mit self.do 

• Falls Element in queue, dann keins 

mehr produzieren; de facto 

Warteschlange mit Länge 1 

• Falls ein Element drin ist, dann wird 

ein auf cond wartender Thread 

geweckt (nach release) 

• Es wird langsamer produziert 

• Am Ende des Threads werden alle 

wartenden Threads geweckt 

produceroaw.py 




4 def __init__(self, queue, cond): 


6 self.do = True 


8 self.cond = cond 


10 i=0 

11 while self.do: 

12 with self.cond: 

13 if not self.queue: 

14 self.queue.append(i) 

15 self.cond.notify() 

16 i += 1 

17 # time.sleep(0.01) 

18 with self.cond: 

19 self.cond.notifyAll() 



wait/notify 

Consumer mit wait/notify 

Aufgabe 

• Schlafen legen, falls nichts 

verfügbar 


• Warteschlange queue als Liste 

• Condition cond als Sperre 

Consumer, Thread 

• Wenn queue leer, dann schlafen 

mit wait 

• Schlafen immer in 

while-Schleife 

• Nach Aufwecken in gesperrtem 

Zustand 

consumeroaw.py 



3 def __init__(self, queue, cond, id): 


5 self.do, self.id = True, id 

6 self.queue, self.cond = queue, cond 


8 summe = 0 


10 self.cond.acquire() 

11 while not self.queue and self.do: 

12 self.cond.wait() 

13 value = None 

14 if self.queue: 

15 value = self.queue.pop() 

16 self.cond.release() 

17 if value: summe += value 

18 msg = "done %d %6d" % (self.id, summe) 

19 print msg 



wait/notify 

Producer/Consumer mit wait/notify 

Aufgabe 

• Ein Produzent 

• Zwei Konsumenten, jeder liest 

• Keine Garantie, dass abwechselnd 

gelesen wird 

• Verhungern (Starvation) möglich 

Anmerkungen 

• notifyAll bei Producer, damit beide 

Konsumenten wach werden am Ende 

• Ergebnis bei jedem Durchlauf anders 

• Wie viele Zahlen insgesamt addiert 

• Wie auf Konsumenten aufgeteilt 

• Es ist möglich, dass Zahlen ignoriert 

werden beim Generieren 

done 1 740240716 

done 2 753020403 

1 from produceroaw import Producer 

2 from consumeroaw import Consumer 

3 from threading import Condition 

4 import time 

5 

6 queue = [] 

7 cond = Condition() 

8 producer = Producer(queue, cond) 

9 c1 = Consumer(queue, cond, 1) 

10 c2 = Consumer(queue, cond, 2) 

11 producer.start() 

12 c1.start(); c2.start() 

13 

14 time.sleep(2) # 2 Sek. schlafen 

15 

16 producer.do = False 

17 c1.do, c2.do = False, False 

18 c1.join(); c2.join() 



Spezielle Datentypen für Threading 

Spezieller Warteschlangen-Datentyp 

Producer/Consumer 

• Typisches Pattern bei nebenläufigem Programmieren 

• Zentrale Datenstruktur ist Warteschlange 

• Umgeben von Synchronisations- und Warte-Idiomen 

Idee – spezielle Queue als vorgefertigter Datentyp 

• Sicheres Objekt 

• Sperre in Datentyp eingebaut 

• Automatisches Sperren bei Einfügen, Holen und Löschen 

• Warte-Idiome integriert, automatisch schlafen legen 

• Blockierender Zugriff beim Holen, falls noch nichts da 

• Blockierender Zugriff beim Einfügen, falls Warteschlange voll 

• Optional Pollen zum Zugriff 

• Nicht blockierend, Ausnahme, falls voll/leer 

• Achtung! Nicht falsch verwenden (Check then act) 

Ergebnis: Einfacheres Producer/Consumer Pattern 

put_nowait put 

Wenn 

voll 

Queue 

Wenn 

leer 

get_nowait get 




Queue 

Datenstruktur für Thread-Prog. 

• Klasse Queue im Modul Queue 

• Warteschlange für konkurrierenden 

Zugriff 

• Schreiber und Leser 

Queue 

• put(e)/get() 

• Schlüsselwortparameter block=True, 

default blockierender Zugriff 

• Schlüsselwortparameter 

timeout=, default None (ewig), 

Maximal Sekunden warten bis 

Ausnahme 

Wenn möglich dedizierte 

Datenstrukturen/Bibliotheken verwenden 

consumerqueue.py 


2 from Queue import Empty 


4 def __init__(self, queue, id): 


6 self.do, self.id = True, id 



9 summe = 0 


11 try: # 1 Sek. Timeout 

12 val = self.queue.get(True,1) 

13 summe += val 

14 except Empty: 

15 pass 

16 msg = "done %d %6d" 

17 print msg % (self.id, summe) 

• In Java java.util.concurrent 




Consumer/Producer mit Queue 

producerqueue.py 



3 def __init__(self, queue): 


5 self.do = True 



8 i=0 


0 self.queue.put(i) 

1 i += 1 

1 from consumerqueue import Consumer 

2 from producerqueue import Producer 

3 from Queue import Queue 

4 import time 

5 

6 queue = Queue() 

7 p = Producer(queue) 

8 c1 = Consumer(queue, 1) 

9 c2 = Consumer(queue, 2) 

10 p.start(); 

11 c1.start(); c2.start() 

12 

13 time.sleep(2) 

done 2 15994664301 

done 1 14952448204 

• Es geht nichts verloren 

• Effizienter 

14 

15 p.do = False 

16 c1.do, c2.do = False, False 

17 

18 c1.join(); c2.join() 



Worker-Thread Pattern 

Arbeits-Threads, Worker-Threads 

Parallelisierung 

• Serialisierung, Hintereinanderausführung, ein Thread 

• Parallelisierung: Ein Thread per Aufgabe (Task) 

• Problem: Zu extrem, zu viele Threads gleichzeitig, zu 

viel Overhead (Kontextwechsel) 

Ziel 

• Parallelisierung mit wenigen Threads, Worker 

• Ein Thread übernimmt mehrere Aufgaben 

• Auslastung der wenigen Worker-Threads, Auslastung 

des Gesamtsystems, wenig Overhead 

Umsetzung 

• Warteschlange (Queue) mit Arbeitsaufträgen 

• Jeder Thread holt sich (threadsicher) Aufträge und 

arbeitet diese ab 

• Ohne Arbeit schlafen oder beenden 

jetzt 

Worker 

Thread 




Worker Thread zum Addieren / 1 

Thread-Verwaltung 

• Klassenvariable counter, ein Monitor 

zur Thread-ID Verwaltung 

• Thread-IDs zwischen 1 und max. 

Anzahl Threads 

Idee 

• Erster Thread (id==1) läuft am 

längsten 

• Sobald irgendein anderer Thread eine 

leere Warteschlange trifft, wird dieser 

Thread beendet; es ist ja weniger zu 

tun 

• Erster Thread läuft aber noch weiter 

worker.py 


2 from counterext import Counter 

3 from Queue import Empty 

4 

5 class Worker(Thread): 

6 

7 count = Counter() 

8 

9 def __init__(self, queue): 



12 self.id = Worker.count.inc() 

13 





Worker Thread zum Addieren / 2 

Umsetzung – Schleife 

• Schleife, beendet Threads mit 

hoher ID, nie 1 

• Hole erst v1, dann v2 

• Holen klappt nicht? Beenden! 

• Nur wenn id != 1 

• v1 zurück wenn v2 nicht klappt 

• Holen klappt? Summiere und 

Zahl wieder in Warteschlange 

Umsetzung – Beenden 

• Zähler wie viele Threads am 

Ende erniedrigen 

1 while Worker.count.value() >= self.id: 

2 v1, v2 = None, None 

3 try: 

4 v1 = self.queue.get(timeout=.1) 


6 if self.id > 1: break 

7 continue 

8 try: 

9 v2 = self.queue.get(timeout=.1) 


11 if (self.id > 1 or 

12 self.id==self.count.value()==1): 

13 if self.queue.empty(): 

14 self.queue.put(v1) 

15 break 

16 

• self.queue.put(v1) 

Noch ein Element, noch ein 

17 continue 

Thread (id==1) und keine Arbeit 

18 v = v1 + v2 

mehr? Ganz fertig, beende auch 

19 self.queue.put(v) 

letzten Thread 

20 Worker.count.dec() 




Worker Thread zum Addieren – Verwendung 

Verwendung 

• Zu addierende Zahlen in queue 

• Alle Worker starten, dann warten 

• Interessant ist eigentlich nur der mit 

id=1, da der sich als Letztes beendet 

Kein gutes Beispiel 

• Aufwand je Task zu gering (Addition) 

• Wohl zu viele Threads für reine 

Berechnung (ohne I/O) 

• Keine Nutzung von vielen Kernen mit 

CPython 

Besseres Beispiel nächstes Semester 

• Servlet Engine, Thread-Pool 

• Web-Request (I/O) im Worker-Thread 

1 from worker import Worker 

2 from Queue import Queue 

3 anzworker, bis = 100, 10**5 

4 queue = Queue() 

5 for ele in xrange(1, bis+1): 

6 queue.put(ele) 

7 workers = [] 

8 for _ in xrange(anzworker): 

9 workers.append(Worker(queue)) 

10 for worker in workers: 

11 worker.start() 

12 for worker in workers: 

13 worker.join() 

14 summe = queue.get() 

15 print "Summe ist %d" % summe 

16 summe = sum(range(1, bis+1)) 

17 print "Summe sollte sein %d" % summe 

Summe ist 5000050000 

Summe sollte sein 5000050000

Programmieren 3 Skript - Medieninformatik - Hochschule RheinMain

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?