Einführung in Python (2)

Kapitel 8:
Einführung in Python (2)
Einführung in die Informatik
Wintersemester 2007/08
Prof. Bernhard Jung
Übersicht
„
Definition von Funktionen
‰
‰
‰
‰
„
Definition einfacher Funktionen
lokale und globale Variablen
Parameterübergabe
Rekursive Funktionen
Import von Modulen
‰
‰
import-Anweisung
Ausgewählte Module der Python Standardbibliothek
Literatur
M. Weigend. Objektorientierte Programmierung mit Python. MITP. 2006.
„
J. Elkner and A. B. Downey. How to Think Like a Computer Scientist. Learning with
Python 2nd Edition. http://www.ibiblio.org/obp/thinkCSpy/
„
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
1
Python – Definition und Ausführung von Skripten
Öffnen des Editors
Ausführen/Laden mit: Run Module F5
Editor
Konsole/Shell
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Python – Definition und Ausführung von Skripten
„
Python-Skript:
„
Python-Skripte können enthalten
‰
‰
‰
‰
Text-Datei mit Endung .py
Definition von Funktionen
Definition von Klassen (später in VL)
beliebige weitere Anweisungen, die bei Laden des Skripts sofort ausgeführt
werden Æ Hauptprogramm
Skript:
Prof. B. Jung
Bei Laden/Ausführung des Skripts (in IDLE mit Taste F5):
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
2
Definition von Funktionen
def funktionsname(arg1, arg2, …):
anweisungsblock
„
Funktionskopf
„
Funktionskörper
‰
Schlüsselwort def, Funktionsname, Parameterliste in Klammern, Doppelpunkt
‰
Anweisungsblock, d.h. Folge von Anweisungen
‰
mit Schlüsselwert return kann ein Rückgabewert festgelegt werden
„
„
eingerückt!
Rückgabewert kann auch Tupel, Liste oder anderes Objekt sein
def summiereBis(n):
sum = 0
for i in range(1,n+1):
sum = sum + i
return sum
Prof. B. Jung
def sumAndMultiplyTo(n):
sum = 0
prod = 1
for i in range(1,n+1):
sum = sum + i
prod = prod * i
return (sum,prod)
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Definition von Funktionen:
Vom Struktogramm zum Programm
Beispiel: Euklidischer Algorithmus
ggt(a,b)
b != 0
ja
a>b
a = a-b
a
nein
b=b-a
def ggt(a,b):
while b != 0:
if a > b:
a = a-b
else:
b = b-a
return a
>>> ggt(35,14)
7
>>> ggt(25,35)
5
>>> ggt(50,100)
50
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
3
Muster: Einlesen von Zahlen
def lies_messwerte():
werte = []
messwert = 0
while messwert >= 0:
messwert = input("Geben Sie eine Zahl ein: ")
if messwert >= 0:
werte.append(messwert)
return werte
# Hauptprogramm
messwerte = lies_messwerte()
print "Eingebenen wurden die Werte:", messwerte
print "Max. Wert ist ", max(messwerte)
"Muster": Programmstück, das so oder in
leichter Abwandlung
häufig (wieder-)
verwendet
wird
Prof. B. Jung
„
„
„
Funktion liest
wiederholt jeweils
eine Zahl vom
Eingabe-Prompt
ein
Ende der Schleife
bei Eingabe einer
Zahl < 0
Rückgabe der
Eingabewerte als
Liste
Geben Sie eine Zahl ein: 4
Geben Sie eine Zahl ein: 2.5
Geben Sie eine Zahl ein: 8.25
Geben Sie eine Zahl ein: 0
Geben Sie eine Zahl ein: 1
Geben Sie eine Zahl ein: -1
Eingebenen wurden die Werte: [4, 2.5, 8.25, 0, 1]
TU Bergakademie Freiberg
Grundlagen der Informatik, WS 2007/08
Max. Wert ist 8.25
Ausführung von Funktionen Globale und lokale Namensräume
Definition einer lokalen Variable x
Definition globaler Variablen x, y
„
„
„
lokale Variablen sind nur innerhalb
der Funktionsdefinition sichtbar, d.h.
können außerhalb nicht verwendet
werden
innerhalb von Funktionen sind lokale
und globale Variablen sichtbar
bei Namensgleichheit einer lokalen mit
einer globalen Variable wird die
lokale Variable ausgewertet
Prof. B. Jung
def f():
x = 2
print "x in Funktion f(): ", x
print "y in Funktion f(): ", y
# Hauptprogramm
x = 1
y = 1
f()
print "x in Hauptprogramm: ", x
print "y in Hauptprogramm: ", y
>>>
x in
y in
x in
y in
>>>
Funktion f(): 2
Funktion f(): 1
Hauptprogramm: 1
Hauptprogramm: 1
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
4
Ausführung von Funktionen Globale und lokale Namensräume
def f():
x = 2
print "Globaler Namensraum von f(): ", globals()
print "Lokaler Namensraum von f(): ", locals()
Standardfunktionen
# Hauptprogramm
x = y = 1
f()
>>>
Globaler Namensraum von f(): {'f': <function f at
0x00B45830>, '__builtins__': <module '__builtin__'
(built-in)>, 'x': 1, 'y': 1, '__name__': '__main__',
'__doc__': None}
Lokaler Namensraum von f(): {'x': 2}
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Ausführung von Funktionen Globale und lokale Namensräume
„
„
Innerhalb von Funktionen können
globale Variablen gelesen, aber
nicht ohne Weiteres verändert
werden
Zur Veränderung einer globalen
Variable innerhalb einer Funktion
dient die global-Anweisung
(teilt Python mit, dass Zuweisung
an eine globale Variable erfolgen
soll)
Prof. B. Jung
def verdopple():
global x
x = x * 2
# Hauptprogramm
x = 10
verdopple()
print x
>>>
20
>>>
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
5
Zur Verwendung globaler Variablen
„
Globale Variablen sind scheinbar bequem, weil
sie im ganzen Programm sichtbar sind
‰
„
„
nicht notwendig, sie beim Aufruf einer Funktion als
Parameter zu übergeben
def f(x):
global count
count = count + 1
return x + count
Sie werden aber auch leicht zur Fehlerquelle!
count = 0
Z.B. Möglichkeit zur Definition von Funktionen, die
bei Aufruf mit gleichen Parametern
unterschiedliche Ergebnisse liefern (siehe rechts)
>>> f(1)
‰
‰
‰
manchmal effizienter Code
oft verwirrend !
dies verletzt Prinzip der referentiellen Transparenz:
Wert eines Ausdrucks sollte nur von seiner
Umgebung abhängen
2
>>> f(1)
3
>>> f(1)
4
Æ globale Variablen sollten sparsam, evtl. überhaupt nicht verwendet werden !
Prof. B. Jung
TU Bergakademie Freiberg
Grundlagen der Informatik, WS 2007/08
Ausführung von Funktionen Parameterübergabe (1)
„
Auf formale Parameter, d.h. Namen
der Parameter im Funktionskopf, kann
im Funktionskörper genau wie auf
lokale Variablen zugegriffen werden
„
Bei Aufruf der Funktion
halbiere() wird der Parameter
innerhalb der Funktion an eine andere
Variable gebunden
„
Sind die als Parameter übergebene
Objekte unveränderbar – z.B. Zahlen,
Strings, Tupel – dann haben
Veränderungen innerhalb der Funktion
keine Auswirkungen auf Objekte
außerhalb
Prof. B. Jung
def halbiere(zahl):
zahl = float(zahl)
zahl = zahl / 2
return zahl
>>>
>>>
2.5
>>>
5
>>>
>>>
>>>
>>>
2.5
>>>
n = 5
halbiere(n)
n
# n bleibt unverändert
n = halbiere(n)
print n
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
6
Ausführung von Funktionen Parameterübergabe (2)
„
Veränderbare Objekte, z.B. Listen,
können, wenn sie als Argumente
einer Funktion übergeben werden,
in dieser Funktion modifiziert
werden (die Veränderungen sind
auch außerhalb der Funktion
wirksam)!
def quadriere(l):
for i in range( len(l) ):
l[i] = l[i] * l[i]
# Hauptprogramm
liste = [1,2,3,4,5]
print liste
quadriere( liste )
print liste
Programmlauf:
>>>
[1, 2, 3, 4, 5]
[1, 4, 9, 16, 25]
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Voreingestellte Parameter
„
„
Manche Funktionen haben optionale Parameter, die bei Funktionsaufruf
weggelassen werden können
In der Funktionsdefinition werden für diese Default-Werte angegeben:
def funktionsname(arg1=wert1, arg2=wert2, …):
def wertetabelle(anzahl=3, schritt=0.5):
x = 0.0
for i in range(anzahl):
print x, '
', x*x
x = x + schritt
>>> wertetabelle()
0.0
0.0
0.5
0.25
1.0
1.0
>>>
Prof. B. Jung
>>> wertetabelle(3,1)
0.0
0.0
1.0
1.0
2.0
4.0
>>>
Grundlagen der Informatik, WS 2007/08
>>> wertetabelle(5)
0.0
0.0
0.5
0.25
1.0
1.0
1.5
2.25
2.0
4.0
>>>
TU Bergakademie Freiberg
7
Schlüsselwort-Argumente
„
Bisher: Aufruf von Funktionen mit Positionsargumenten
„
In Python auch möglich: Aufruf mittels Schlüsselwort-Argumente der Form
‰
Reihenfolge der Argumente bei Aufruf entsprechend Funktionsdefinition
funktionsname(arg1=wert1, arg2=wert2, …)
def wertetabelle(anzahl=3, schritt=0.5):
x = 0.0
for i in range(anzahl):
print x, '
', x*x
x = x + schritt
>>> wertetabelle(schritt=0.1)
0.0
0.0
0.1
0.01
0.2
0.04
>>>
Prof. B. Jung
>>> wertetabelle(schritt=0.1, anzahl=5)
0.0
0.0
0.1
0.01
0.2
0.04
0.3
0.09
0.4
0.16
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Rekursive Funktionen
„
Rekursive Funktion: Funktion, die sich selbst aufruft
„
z.B. Fakultät: n! = 1 * 2 * … * n
rekursive Formulierung der Fakultätsfunktion:
„
‰
‰
1! = 1
n! = n * (n-1)!, n > 1
>>>
120
3628800
2432902008176640000
>>>
Prof. B. Jung
def fak(n):
if n == 1:
return 1
else:
return n * fak(n-1)
# Hauptprogramm
print fak(5)
print fak(10)
print fak(20)
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
8
Rekursive Funktionen
„
Fibonacci-Folge:
‰
„
1, 1, 2, 3, 5, 8, 13, …
def fib(n):
if n == 1 or n==2:
return 1
else:
return fib(n-1) + fib(n-2)
Rekursive Formulierung
‰
‰
‰
Basisfall: fib(1) = 1
Basisfall: fib(2) = 1
Rekursionsfall (n>2):
fib(n) = fib(n-1) + fib(n-2)
Prof. B. Jung
mit Rückgabe als Liste:
def fib1(n):
if n == 1:
return [1]
elif n== 2:
return [1,1]
else:
bisher = fib1(n-1)
i = bisher[n-2] + bisher[n-3]
return bisher + [i]
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Dokumentation von Funktionen - Docstrings
„
„
Unterhalb des Funktionskopfes sollte ein Kommentar in dreifachen
Anführungszeichen angebracht werden
Dieser Docstring der Funktion kann im interaktiven Modus mit der help()Funktion zum Vorschein gebracht werden
def fak(n):
"""Berechnung der Fakultaet einer Zahl.
Eingabe: eine Zahl n
Ausgabe: Fakultaet n! der Zahl
Autor: Bernhard Jung, 15.11.2005
"""
if n == 1:
return 1
else:
return n * fak(n-1)
Prof. B. Jung
>>> help(fak)
Help on function fak in module __main__:
fak(n)
Berechnung der Fakultaet einer Zahl.
Eingabe: eine Zahl n
Ausgabe: Fakultaet n! der Zahl
Autor: Bernhard Jung, 15.11.2005
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
9
Programmieren im Großen
import - Anweisung
„
mittels import-Anweisung kann man Module (Python-Skripte) in andere Skripte
importieren
‰
„
„
import-Anweisungen o.ä. gibt es in allen gängigen Programmiersprachen
Import von
‰
‰
‰
„
Definitionen von Funktionen (und Klassen) anderer Module werden so im aktuellen Modul
verfügbar
Standardmodulen (ausgeliefert mit Python-Distribution)
von Dritten geschriebene Module (im Web zahlreich zu finden)
selbst geschriebenen Skripten
Formen (Python)
‰
import modul1, modul2, …
‰
from modul import name1, name2, …
„
„
„
‰
importiert nur die benannten Funktionsdefinitionen des Moduls
Zugriff auf Definitionen ohne Erwähnung des Modulnamens
from modul import *
„
„
‰
Zugriff auf Funktionsdefinitionen mittels modul1.definition
importiert alle Definitionen des Moduls
Zugriff auf Definitionen ohne Erwähnung des Modulnamens
Beispiele …
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Programmieren im Großen
import - Anweisung
„
Beispiel: Gewünscht ist Verwendung der Funktionen des Python-Skripts
(Moduls) "primzahlen.py" in anderem Python-Skript
"""Funktionen fuer Primzahlen"""
def prim(n):
"Testet, ob n Primzahl ist"
for teiler in range(2,n):
if n % teiler == 0:
return False
return True
primzahlen.py
primzahlen.py
def primListe(n):
u"liefert eine Liste der Primzahlen kleiner gleich n"
if n < 2:
return []
result = []
for zahl in range(2, n+1):
if prim(zahl):
result.append(zahl)
return result Grundlagen der Informatik, WS 2007/08
Prof. B. Jung
TU Bergakademie Freiberg
10
Programmieren im Großen
import – Anweisung, Beispiel (1)
Import des Moduls
primzahlen
Zugriff mit
Modulname
Zugriff ohne
Modulname
Æ Fehler
>>> import primzahlen
>>> primzahlen.prim(5)
True
>>> primzahlen.prim(8)
False
>>> prim(8)
Traceback (most recent call last):
File "<pyshell#8>", line 1, in -toplevelprim(8)
NameError: name 'prim' is not defined
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Programmieren im Großen
import – Anweisung, Beispiel (2)
Import der Funktion prim
aus Modul primzahlen
Zugriff ohne
Modulname
Æ jetzt ok
>>> from primzahlen import prim
>>> prim(9)
False
>>> l = primListe(8)
Zugriff auf nicht
importierte Funktion
Æ Fehler
Traceback (most recent call last):
File "<pyshell#12>", line 1, in -toplevell = primListe(8)
NameError: name 'primListe' is not defined
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
11
Programmieren im Großen
import – Anweisung, Beispiel (3)
Import aller Funktionen
aus Modul primzahlen
>>> from primzahlen import *
>>> prim(9)
False
>>> primListe(13)
[2, 3, 5, 7, 11, 13]
>>>
Zugriffe auf beide
Funktionen des Moduls
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Programmieren im Großen
import – Anweisung
„
Wo sucht Python die zu importierenden Module?
‰
im aktuellen Verzeichnis
„
‰
wo zuletzt eine .py – Datei geöffnet wurde
in den Verzeichnissen der sys.path Variable
„
Inspektion in IDLE: File >> Path Browser
„
Inspektion der sys.path Variable …
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
12
Inspektion und Erweitern von sys.path
>>> import sys
>>> sys.path
['C:\\Python25\\Lib\\idlelib', 'C:\\WINDOWS\\system32\\python25.zip',
'C:\\Python25\\DLLs', 'C:\\Python25\\lib', 'C:\\Python25\\lib\\plat-win',
'C:\\Python25\\lib\\lib-tk', 'C:\\Python25', 'C:\\Python25\\lib\\site-packages',
'C:\\Python25\\lib\\site-packages\\PIL']
>>> sys.path.append(r'C:\Dokumente und Einstellungen\Jung\Eigene
Dateien\MyPythonPrograms')
>>> sys.path
['C:\\Python25\\Lib\\idlelib', 'C:\\WINDOWS\\system32\\python25.zip',
'C:\\Python25\\DLLs', 'C:\\Python25\\lib', 'C:\\Python25\\lib\\plat-win',
'C:\\Python25\\lib\\lib-tk', 'C:\\Python25', 'C:\\Python25\\lib\\site-packages',
'C:\\Python25\\lib\\site-packages\\PIL', 'C:\\Dokumente und
Einstellungen\\Jung\\Eigene Dateien\\MyPythonPrograms']
>>> import primzahlen
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Standardbibliotheken in Python – welche gibt es?
IDLE: Help > Python Docs
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
13
Standardbibliotheken in Python – welche gibt es?
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Ausgewählte Standardbibliotheken:
Modul math
„
Definition von Konstanten
‰
‰
„
pi
e
Definition mathematischer Funktionen
‰
‰
‰
‰
‰
‰
‰
‰
ceil(x) – x wird aufgerundet
floor(x) – x wird abgerundet
sin(x), cos(x), tan(x) – Sinus, Cosinus, Tangens von x
asin(x), acos(x), atan(x)
degrees(x), radians(x)-Konversion zw. Bogenmaß und Grad
fabs(x) – Betrag von x (als float)
log(x), log10(x) – Logarithmus von x zur Basis 2 bzw. 10
…
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
14
Ausgewählte Standardbibliotheken:
Modul math
>>> from math import *
>>> fabs(-1.1)
1.1000000000000001
>>> pi
3.1415926535897931
>>> cos(pi)
-1.0
>>> sin(pi/2)
1.0
>>> floor(8.5)
8.0
>>> ceil(8.5)
9.0
>>> acos(0.5)
1.0471975511965976
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Ausgewählte Standardbibliotheken:
Modul random
„
Funktionen
‰
‰
‰
‰
‰
‰
randint(a, b) – liefert zufällige Integer-Zahl zw. a und b
(inklusive)
random() – liefert zufällige Realzahl zwischen 0 und 1
uniform(a,b) - liefert zufällige Realzahl zw. a und b (inklusive)
choice(Sammlung) – liefert ein zufälliges Element der Sammlung
(z.B. Liste, Menge)
sample( Sammlung, k) – liefert k Zufallselemente aus Sammlung
…
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
15
Ausgewählte Standardbibliotheken:
Modul random
>>> from random import *
>>> random()
0.79513661012444292
>>> random()
0.93153037147896656
>>> randint(30,39)
36
>>> sample( ['a', 'b', 'c', 'd', 'e'], 3)
['b', 'a', 'c']
>>> sample( ['a', 'b', 'c', 'd', 'e'], 3)
['c', 'a', 'b']
>>> sample( range(50), 10)
[23, 14, 43, 6, 29, 42, 24, 18, 28, 8]
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
Auswahl Python-Bibliotheken für Multimedia
„
Tkinter
‰
‰
„
graphische Benutzeroberflächen
Bilder
Winsound
‰
Sound auf Windows-Plattform
>>> import winsound
>>> winsound.PlaySound(r'C:\Dokumente und
Einstellungen\Jung\Eigene Dateien\Sounds\techno_mono.wav',
winsound.SND_ASYNC )
>>>
Prof. B. Jung
Grundlagen der Informatik, WS 2007/08
TU Bergakademie Freiberg
16