Einführung in Python

Einführung in Python
Proseminar Softwaretechnologie
David Voigt
[email protected]
Beispiele:
1. Grundlegende Konzepte
&
Bei Python handelt es sich um eine imperative
Programmiersprache, welche die Programmierparadigmen von
funktionalen und objektorientierten Programmiersprachen vereint.
Diese Sprache wird interpretiert, das heißt der Code wird von
einem Compiler in Python Byte-Code übersetzt und dann auf
einer virtuellen Maschine (Python-Interpreter) ausgeführt. Dies
ermöglicht eine Ausführungen auf allen gängigen Plattformen,
wie Windows, Linux und Mac.
Python kann einfach erweitert werden, was sich besonders bei
Problemen lohnt, welche maschinennah oder zeitkritisch gelöst
werden müssen. Für diesen Fall kann einfach eine Erweiterung in
C geschrieben werden.
Desweiteren wird Python unter PSF-Lizenz veröffentlicht, welche
es kommerziellen Nutzern ermöglicht den Python-Interpreter
lizenzkostenfrei zu nutzen.
|
0
1
1
0
1
1
0
1
109
1
0
1
1
0
1
0
1
181
0
0
1
0
0
1
0
1
37
0
1
1
0
1
1
0
1
109
1
0
1
1
0
1
0
1
181
1
1
1
1
1
1
0
1
253
Gleitkommazahlen (float)
Hierbei handelt es sich um reele Zahlen.
Boolesche Werte (bool)
Variablen diesen Typs können nur die Wahrheitswerte true und
false annehmen.
Operationen:
Operation
not x
x and y
x or y
2. Datentypen
NoneType
Hierbei handelt es sich um einen leeren Datentyp, dessen einzige
Instanz die Konstante None ist.
Operationen:
var = None
 prüfen auf None:
if var is None:
print(“var ist None”)
Numerische Datentypen
ganze Zahlen (int und long)
Bei dem Datentyp int handelt es sich um ganze Zahlen im Bereich
von -231 bis 231-1. Bei dem Datentyp long handelt es sich um
ganze Zahlen, welche theoretisch unbegrenzt sind.
Operationen:
Operation
x=x+y
x=x–y
x=x*y
x=x/y
x=x%y
x = +x
x = -x
x = x ** y
x = x // y
Operator
x=x&y
x=x|y
x=x^y
x = ~x
x = x << n
x = x >> n
Kurzschreibweise
x += y
x -= y
x *= y
x /= y
x %= y
x **= y
x //= y
Kurzschreibweise
x &= y
x |= y
x ^= y
x <<= n
x >>= n
Vergleichsoperationen
x == y
x != y
x<y
x <= y
x>y
x >= y
Bedeutung
Bitweise UND von x und y
Bitweise OR von x und y
Bitweise XOR von x und y
Bitweise Komplement von x
Bitverschiebung um n Stellen nach
links
Bitverschiebung um n Stellen nach
rechts
Wahrheitswerte bei anderen Datentypen:
Basisdatentyp
NoneType
int, long
float
complex
str
list
tuple
dict
set, frozenset
False-Wert
None
0
0.0
0 + 0j
„“
[]
()
{}
set(), frozenset()
True-Wert
alle Zahlen außer 0
alle Zahlen außer 0
alle Zahlen außer 0
jeder nicht leere String
jede nicht leere Liste
jedes nicht leere Tupel
jedes nicht leere Dictionary
jede nicht leere Menge
komplexe Zahlen (complex)
Dieser Datentyp kann komplexe Zahlen speichern. Zu beachten ist
hier, dass der Imaginärteil nicht mit einem i, sondern mit einem j
gekennzeichnet wird.
Darstellung: x + yj
Methoden und Attribute:
Methoden und Attribute
x.real
x.imag
x.conjugate()
Rückgabewert
liefert den Realteil von x
liefer den Imaginärteil von x
liefert die zu x konjugiert
komplexe Zahl
sequentielle Datentypen
Operationen:
Operation
s in x
s not in x
x + y (x += y)
x * n oder n * x
(x *= n)
Erklärung
prüft, ob s in x ist (liefert Wahrheitswert)
prüft, ob s nicht in x ist (liefert Wahrheitswert)
Verkettung von x und y (Verkettung von x und
y wird x zugewiesen)
Verkettung, welche n Kopien von x enthält
(Verkettung, welche n Kopien von x enthält
wird x zugewiesen)
Operation
x[n]
x[n:m]
Erklärung
liefert das n-te Element von x
liefert eine Sequenz mit den Elementen von n
bis m
liefert eine Sequenz mit den Elementen von n
bis m, wobei nur jedes k-te Element beachtet
wird
gibt die Anzahl der Elemente von x zurück
gibt das kleinste Element zurück, sofern eine
Ordnungsreleation def. ist
gibt das größte Element zurück, sofern eine
Ordnungsrelation def. ist
x[n:m:k]
len(x)
min(x)
max(x)
Strings (str, unicode)
Die Typen str und unicode dienen zur Darstellung beliebiger
Zeichenketten. Der Typ unicode hat im Vergleich zum Typ str
variable Kodierungslängen und kann daher mehr Zeichen
darstellen. In diesem Dokument soll aber nicht auf die
Unterschiede eingegangen werden, daher wird hier nur am
Beispiel des Datentyp str gearbeitet.
String-Erzeugung:
str1=”...”
str2=’...’
str3=
”””zeile1
zeile2“““
str4=( „zeile1“
„zeile2“)
Erklärung
erzeugt Signalton
Backspace
Seitenvorschub
Linefeed
Carriage Return
horizontaler Tab
vertikaler Tab
Doppeltes Hochkomma (erscheint als Zeichen)
Einfaches Hochkomma (erscheint als Zeichen)
Backslash (erscheint als Zeichen)
Methoden zum Trennen von Strings:
Methode
s.split([sep[, maxsplit]])
s.rsplit([sep[, maxsplit]])
s.splitlines([keepends])
s.partition(sep)
s.rpartition(sep)
s.rfind(sub[, start[, end]])
s.index(sub[, start[, end]])
s.rindex(sub[, start[, end]])
s.count(sub[, start[, end]])
Erklärung
zerteilt einen String anhand des im
Parameter sep angegebene Zeichen und
gibt eine Liste zurück (der Parameter
maxsplit kann die Anzahl der Teilungen
begrenzen)
macht das selbe wie die Funktion split,
nur das rsplit am Ende des String mit
dem Teilen beginnt
Gibt eine Liste mit den Zeilen des String
zurück (Um Zeilenvorschübe am Ende
zu erhalten ist der Parameter keepends
auf True zu setzen)
Der String wird in drei Teile geteilt,
welche in einem Tupel zurück gegeben
werden. Der erste Teil ist die
Zeichenkette vor dem String sep, der
zweite Teil ist der String sep und der
dritt Teil ist der hinter dem String sep.
macht das selbe wie die Funktion
partition, nur das rpartition am Ende des
String beginnt
Methoden zum Suchen in Strings:
Die optionalen Parameter start und end dienen dazu, den
Sichbereich im String einzugrenzen
Erklärung
Es wird der Index des ersten
Vorkommens von sub in s zurück
geben (falls sub nicht in s vorkommt
wird -1 zurück gegeben).
Macht dasselbe wir find, nur das die
Suche am Ende des Strings begonnen
wird.
Macht dasselbe wie find, nur das hier
im Fehlerfall eine ValueError
Exception geworfen wird.
Macht dasselbe wie rfind, nur das hier
im Fehlerfall eine ValueError
Exception geworfen wird.
Zählt die Anzahl der Vorkommen von
sub in s
Methoden zum Ersetzen von Teilstrings:
Methode
s.replace(old, new[, count])
s.lower()
s.upper()
s.swapcase()
Escape-Sequenzen:
Escape-Sequenz
\a
\b
\f
\n
\r
\t
\v
\“
\\‘
\\
Methode
s.find(sub[, start[, end]])
s.capitalize()
s.title()
s.expandtabs([tabsize])
Erklärung
Rückgabe eines Strings, indem alle
Vorkommen von old durch new
ersetzt wurden (durch count kann die
Anzahl der Ersetzungen begrenzt
werden)
Rückgabe eines Strings, indem nur
Kleinbuchstaben sind
Rückgabe eines Strings, indem nur
Großbuchstaben sind
Rückgabe eines Strings, indem die
Großbuchstaben nun klein sind und
die Kleinbuchstaben nun groß sind
Rückgabe eines Strings, indem der
erste Buchstabe ein Großbuchstabe ist
Rückgabe eines Strings, indem jeweils
alle
Wörter
mit
einem
Großbuchstaben beginnen
Rückgabe eines Strings, indem alle
Tabulatoren durch Leerzeichen ersetzt
wurden (optional kann durch tabsize
die
Anzahl
der
Leerzeichen
angegeben werden)
Beispiele:
str1 = „a,b,c,d,e,f,g“
str1.split(„,“)
#[a,b,c,d,e,f,g]
str1 = „a,b,c,d,e,f,g“
str1.count(„,“)
#6
str1 = „www.google.de“
str1.partition(„.“)
#(„www“,“.“,“google.de“)
str1.rpartition(„.“)
#(„www.google“,“.“,“de“)
str1 = „a,b,c,d,e,f,g“
str1.replace(„,“,“.“)
# „a.b.c.d.e.f.g“
str1 = „a,b,c,d,e,f,g“
str1.find(„c“)
#4
str1 = „a,b,c,d,e,f,g“
str1.upper()
# „A,B,C,D,E,F,G“
Formatierung von Strings:
„…%...X…%...Y…“ % (Wert1,Wert2)
Kennung
d
i
o
u
x
X
e
E
Erklärung
Ganzzahl mit Vorzeichen
siehe d
Oktalzahl ohne Vorzeichen
Ganzzahl ohne Vorzeichen
Hexadezimalzahl ohne Vorzeichen
siehe x
Fließkommazahl in wissenschaftl. Format (kleines „e“)
Fließkommazahl in wissenschaftl. Format (großes „e“)
Kennung
f
F
g
Erklärung
Fließkommazahl in Dezimalschreibweise
siehe f
Fließkommazahl in wissenschaftl. Schreibweise, wenn
Exponent < -4
siehe g
Zeichen (Länge 1)
String (durch Methode repr)
String (durch Methode str)
Ausgabe des Prozentzeichen
G
c
r
s
%
Umwandlungsflags:
Flag
#
0
(Leerzeichen)
+
Erklärung
Ausgabe im alternativen Modus
Bei einer Unterschreitung der Mindestlänge bei
numerischen Werten wird mit Nullen aufgefüllt
Bei Unterschreitung wird von rechts aufgefüllt
Bei numerischen Werten, welche positiv sind, wird
ein Leerzeichen davor geschrieben
Bei numerischen Werten wird das Vorzeichen
immer angegeben
Beispiele:
str = „Preis: %5.2f EUR“ %(8.443)
#Preis: 8.44 EUR
str = „Preis: %+5.2f EUR“ %(8.443)
#Preis: +8.44 EUR
str = „Preis: %06d EUR“ %(28)
#Preis: 000028 EUR
str = „Preis: %-6d EUR“ %(28)
#Preis: 28
EUR
l.remove(x)
l.reverse()
Sortierung:
l.sort([key[,reverse]])
Der Parameter key kann verwendet werden, um eine Funktion
anzugeben, welche als Rückgabe einen Wert liefert, für den eine
Ordnungsrelation definiert ist. Die Liste wird dann entsprechend
der Rückgaben sortiert.
Der Parameter reverse dient zum Sortieren in umgekehrter
Reihenfolge.
def real_teil(z):
return z.real
l[n:m] = t
l[n:m:k] = t
del l[n]
del l[n:m]
del l[n:m:k]
unveränderliche Listen (tuple)
Dieser Datentyp hat weniger Funktionen als die normalen Listen,
da alle Funktionen wegfallen, welche die Liste verändern würden.
Es gilt aber zu beachten, dass eine unveränderliche Liste durchaus
veränderlichen Datentypen, wie Listen beinhalten kann.
Mappings
Dictonary (dict)
Bei einem Dictonary handelt es sich um eine Zuordnung von
Schlüssel zu Wert. Der Schlüssel muss eindeutig sein.
Dictonary-Erzeugung:
d={
Erklärung
Das Element von l mit dem Index n wird durch x
ersetzt
Die Elemente der Liste von n bis m-1 werden durch
t ersetzt (t muss iterierbar sein)
Die Elemente der Liste von n bis m-1 werden durch
t ersetzt, wobei nur jedes k-te Element beachtet
wird (t muss iterierbar sein)
Das Element an der Stelle n wird entfernt
Die Elemente der Liste von n bis m-1 werden
entfernt
Die Elemente der Liste von n bis m-1 werden
entfernt, wobei nur jedes k-te Element beachtet
wird
Methoden:
Methode
l.append(x)
l.extend(t)
l.count(x)
l.index(x[,m[,k]])
l.insert(n,x)
l.pop([n])
liste = [5, 8, 6, 2, 4]
liste.sort(reverse=True)
# [8, 6, 5, 4, 2]
liste = [10 + 12j, 3 + 6j, 8
+ 22j, 5-2j]
liste.sort(key=real_teil)
# [3 + 6j, 5 – 2j, 8 + 22j,
10 + 12j]
Listen (list)
Operationen:
Operator
l[n] = x
Das erste Vorkommen von x in der Liste wird
gelöscht
Die Reihenfolge der Elemente in der Liste wird
umgekehrt
Erklärung
Das Element x wird an das Ende der Liste
angeangen
Es werden alle Elemente von t an das Ende der
Liste angehangen
Gibt an, wie oft das Element x in der Liste
vorkommen
Der Index i des ersten Vorkommens des
Element x wird ausgegeben (optional kann
Suchbereich angegeben werden, es wird dann
entweder ab m oder von m bis k-1 gesucht)
Das Element x wird in der Liste an die Stelle n
eingefügt. Alle folgenden Element werden eine
Stelle nach hinten geschoben)
Das n-te Element der Liste wird zurück gegeben
(falls n nicht angegeben das letzte), anschließen
wird das Element aus der Liste gelöscht
„Sachsen“ : „Dresden“,
„Thüringen“ : „Erfurt“,
}
Operationen:
Operation
len(d)
d[k]
del d[k]
k in d
k not in d
Erklärung
Gibt die Anzahl der Element von d zurück
Gibt den Wert mit dem Schlüssel k zurück
Löscht den Schlüssel k und den dazugehörigen
Wert
liefert Wahrheitswert, ob der Schlüssel k in d
enthalten ist
liefert Wahrheitswert, ob der Schlüssel k nicht in d
enthalten ist
Methoden:
Methode
d.clear()
d.copy()
d.items()
d.keys()
d.values()
d.update(e)
d.fromkeys(l[, v])
d.get(k[, a])
d.setdefault(k[, a])
d.popitem()
Erklärung
Löscht den gesamten Inhalt des Dictonarys
Kopiert das Wörterbuch (aber nicht den Inhalt)
Erzeugt eine Liste von Tupeln (Schlüssel,
Wert) mit allen Paaren aus d
Erzeugt eine Liste, welche alle Schlüssel
enthält
Erzeugt eine Liste, welche alle Werte enthält
Fügt dem Wörterbuch d das Wörterbuch e
hinzu
Rückgabe ist ein neues Wörterbuch, welches
seine Schlüssel aus der Liste l bezieht (optional
können die Werte mit v initialisiert werden)
Falls der Schlüssel k existiert wird der Wert
von k geliefert, sonst a
Falls der Schlüssel k nicht existiert wird er mit
a initialisiert
Rückgabe ist ein zufälliges Tupel (Schlüssel,
Wert), Paar wird anschließend aus d entfernt
Mengen
Operationen:
Operation
len(s)
e in s
e not in s
Erklärung
Gibt die Anzahl der Element von s zurück
Liefert Wahrheitswert, ob e in s enthalten ist
Liefert Wahrheitswert, ob e nicht in s enthalten
ist
Mengenoperationen:
Operation
s <= m
s<m
s >= m
s>m
s|m
s&m
s-m
s^m
Erklärung
Liefert True, wenn s Teilmenge von m
Liefert True, wenn s echte Teilmenge von m
Liefert True, wenn m Teilmenge von s
Liefert True, wenn m echte Teilmenge von s
Rückgabe einer Menge, welche Vereinigung von
s und m bildet
Rückgabe einer Menge, welche Schnittmenge
von s und m bildet
Rückgabe einer Menge, welche Differenz von s
und m bildet
Rückgabe einer Menge, welche symmetrische
Differenz von s und m bildet
Mengen (set)
Hierbei handelt es sich um Mengen, denen beliebig viele
Elemente hinzugefügt werden können. Zu beachten gilt aber, dass
ein Element nur einmal in einer Menge vorkommen kann.
unveränderliche Mengen (frozenset)
Hierbei handelt es sich um Mengen, welche zum Beginn einmal
mit bestimmten Elementen initialisiert werden und dann nicht
mehr verändert werden können.
3. Kontrollstrukturen
If, elif, else
if Bedingung:
…
elif Bedingung:
…
else:
…
While-Schleife
while Bedingung:
…
else:
…
For-Schleife
for Variable in Objekt:
...
if x==1:
print(“x=1”)
elif x==2:
print(“x=2”)
else:
print(“x ungleich 1”)
#abkürzende Schreibweise:
y = (1 if x == 2 else 2)
x=4
while x>1:
print (x)
x=x-1
else:
print („x ist 1“)
for i in range (1, 5, 2):
print (i)
#1
#3
Schleifenabbruch
vorzeitiger Abbruch einer
Schleife
break
vorzeitiger Abbruch eines
Schleifendurchlauf
continue
while Bedingung:
while Bedingung:
…
…
break
continue
…
…
else:
else:
…
…
…
…
eigene Funktionen definieren
def Funktionsname (Parameter 1, ..., Parameter n):
...
def sum1 (a, b):
return Wert
print (a+b)
def sum2 (a,b):
return a+b
optionale Parameter:
(Parameter 1 = Standardwert, ...)
def mult (a, b, c, d=0): def mult (a, b, c, d=0):
return (a*b*c)+d
return (a*b*c)+d
print (mult(c=2, b=4, a=3))
print (mult(2, 4, 3))
# 24
# 24
print (mult(d=2, a=4, b=3, c=8))
print (mult(2, 4, 3, 8)) # 98
# 32
Variablenzugriff innerhalb einer Funktion:
Durch das Schlüsselwort global ist der Zugriff auf globale
Variablen möglich.
def funktion ():
a = „lokal“
a = „global“
funktion()
print (a)
# global
def funktion ():
global a
a = „lokal“
a = „global“
funktion()
print (a)
# lokal
anonyme Funktionen:
funktion = lambda a, …, z: Rückgabewert
mult = lambda a, b, c: a*b*c
d = mult (1,2,4)
print (d)
#8
del-Anweisung:
Diese Anweisung löscht Variablen oder Teile von sequentiellen
Datenstrukturen.
a = [2, 3, 8]
del a[1]
print (a)
# [2, 8]
del a
print (a)
# NameError: name 'a' is not defined
pass-Anweisung:
Diese Anweisung hat keine
Funktion und dient lediglich
als Platzhalter.
def funktion():
pass
y=1
if y==1:
pass
else:
pass
4. Ausnahmebehandlung
Exceptions in Python
Alle Exceptions in Python erben von der Klasse BaseException.
wichtige Exceptions:
 ArithmeticError
o OverflowError
o ZeroDivisionError
 LookupError
o IndexError
 SyntaxError
 KeyboardInterrupt
Abfangen einer Exception
def funktion (liste, n):
try:
try:
…
back = liste[n]
except Exceptiontyp:
except IndexError:
...
print („Fehler“)
else:
back = 0
else:
...
print („kein Fehler“)
finally:
finally:
...
return back
eigene Exceptions
In Python besteht die Möglichkeit eigene Exception-Klassen zu
definieren, welche dann geworfen werden können.
class ExceptionName(Exception):
…
end
file
Funktion dir
dir(object)
Diese Funktion liefer alle Attribute und Methoden zu einem
Objekt.
Funktion help
help(object=““)
 Ohne einen Parameter wird die interaktive Hilfe von
Python gestartet.
 Bei Angabe eines Parameters wird die Hilfe zu diesem
Objekt angezeigt.
6. Module und Pakete
Module und Pakete importieren
Module und Pakete dienen dazu, ein Programm zu strukturieren
und übersichtlicher zu machen.
Variante des Importes
import Mod1
import Mod1, Mod2
import Mod1 as Name1
from Mod1 import *
from Mod1 import fkt1,
fkt2
raise Ausnahme()
#Traceback (most recent call last):
#File „…", line 25, in <module>
#__main__.Ausnahme
from Mod1 import fkt1 as
Funktion1
Funktion print
print(*value, sep=„ “, end=„\n“, file=sys.stdout)
sep
a = „Ich bin ein String!“
if isinstance(a,str):
print(„Ja, du bist wirklich ein String“)
class Ausnahme(Exception):
pass
5. Built-in Funktionen
Parameter
*value
Funktion input
input(prompt=„“)
Diese Funktion dient zum einlesen eines Wertes über die
Eingabeaufforderung. Der optionale Parameter promt dient zum
Anzeigen eines Textes vor der Eingabe.
Funktion isinstance
isinstance(object, class-or-type-or-tuple)
isinstance(a, (A, B, C)) prüft ob a Instanz von A, B oder C
Erklärung
Angabe einer oder mehrerer Strings, welche
ausgegeben werden sollen
Angabe eines String, welche zwischen den Strings von
*value ausgegeben werden soll
Angabe eines String, welche nach dem letzten String
von *value ausgegeben werden soll
Angabe, wohin die Strings ausgegeben werden sollen
print(„ein String“, „noch ein String“)
#ein String noch ein String
print(„Str1“, „Str2“, sep=„_“, end=„“)
print(„Str3“,“Str4“,sep=„.“)
#Str1_Str2Str3.Str4
import math
x=math.sin(math.pi)
Erklärung
Das Modul Mod1 wird importiert
Die Module Mod1 und Mod2 werden
importiert
Mod1 wird unter dem Namen Name1
importiert
Es wird alles aus Mod1 in den
globalen Namensraum importiert
Es werden nur die Funktionen fkt1
und fkt2 in den globalen Namensraum
importiert
Es wird nur die Funktionen fkt1 unter
dem Namen Funktion1 in den
globalen Namensraum importiert
import math
from math import sin as Sinus
x=Sinus(math.pi)
eigene Module
Module werden durch Dateien realisiert.
Der Modulname entspricht dem Dateinamen.
Die eigenen Module müssen im gleichen Ordner, wie das
Hauptprogramm liegen.
def fkt1(a, b)
return a+b
def fkt2(a, b)
return a*b
python.py
import funktionen
c=funktionen.fkt(2,3)
d=funktionen.fkt(2,3)
print(c)
print(d)
#5
#6
Zusammenfassung von Modulen in Paketen
Pakete werden durch Ordner realisiert.
Der Paketname entspricht dem Ordnernamen.
In jedem Ordner muss die Datei „__init__.py“ vorhanden sein.
from paket1.paket1 import modul1
from paket1 import paket1
from paket1 import modul1
from paket1 import modul2
from paket2 import modul1
Iteratoren
Iteratoren sind Klassen, welche die Möglichkeit bieten Reihen von
Werten zu verarbeiten.
class Iteratorname(object)
def __init__(self, Parameterliste):
…
def __iter__(self):
…
def __next__(self):
if Bedingung:
…
else
raise StopIteration
class Iter:
def __init__(self, max):
self.max=max
self.aktuell=0
def __iter__(self):
return self
def __next__(self):
if self.aktuell<self.max:
self.aktuell=self.aktuell+1
return self.aktuell+3
else:
raise StopIteration
for i in Iter(3):
print(i)
import paket1
import paket2
print(paket1.modul2.fkt(2,3))
#5
7. Weitere Spracheigenschaten
List Comprehensions
List Comprehensions erstellen aus einer Liste mehrere Listen.
[neues_Element for Variable in Liste]
[neues_Element for Variable in Liste if Bedingung]
[neues_Element for Var1 in Liste1 for Var2 in Liste2]
liste = [1, 2, 3, 4]
liste2 = [x+2 for x in liste if x<4]
print(liste2)
#3, 4, 5
ls1 = [1, 2]
ls2 = [3, 4]
ls3 = [a+b for a in ls1 for b in ls2]
# 4, 5, 5, 6
liste1 = [2, 4, 6, 8]
liste2 = [1, 3, 4, 2]
liste3 = [liste1[i]+liste2[i] for i in range(4)]
print(liste3)
#3, 7, 10, 10
Generatoren
Generatoren sind Funktionen, welche eine Möglichkeit bieten
Reihen von Werten zu verarbeiten.
Das yield-Statement in der Generator-Funktion sorgt dafür, dass
ein entsprechender Wert zurück gegeben wird und die Funktion an
dieser Stelle fortgesetzt wird.
def quad_gen(max):
i=1
while i <= max:
x = i*i
yield x
i = i+1
for i in quad_gen(3):
print(i)
def name_gen(more1):
yield „Name1“
if more1==False:
return
yield „Name2“
yield „Name3“
Copyright
Es besteht die Berechtigung dieses Dokument für den
persönlichen Gebrauch oder Unterrichtszwecke zu kopieren. Für
alle anderen Verwendungszwecke ist eine schriftliche
Genehmigung des Autors nötig.
Haftungsausschluss
Für eventuelle Fehler in diesem Dokument wird keine Haftung
übernommen.
Verbesserungsvorschläge und Kommentare können gern an die
oben genannte E-Mail-Adresse gesendet werden.
Quellen
•
•
Python – Das umfassende Handbuch von Peter Kaise
und Johannes Ernesti
http://www.python.org