Programmierung in Python - ki.informatik.uni-frankfurt.de · Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales

Programmierung in Python

imperativ,

objekt-orientiert

dynamische Typisierung

rapid prototyping

Script-Sprache

Funktionales und rekursives Programmieren

Praktische Informatik 1, WS 2004/05, Folien Python−1, (6. Dezember2004) Seite 1

Programmierung in Python

Datentypen: ganze Zahlen, Gleitkommazahlen (Double), Strings.

Tupel, Listen, Arrays,

vordefinierte Listenfunktionen: map, filter, sort, reverse,...

Fehlerbehandlung zur Laufzeit: Exception-Handling

Objektorientierung: Klassen, Methoden


Python: Struktur eines imperativen Programms

Python-Programm-File besteht aus:

Deklarationen

Definitionen von Funktionen.

Funktionsdefinitionen: Wesentlich Bestandteile:

Befehle (Anweisungen, Kommandos),

wie Zuweisungen, Sprungbefehle, Ein/Ausgabebefehle

mit Seiteneffekten

Ausdrucke mit Returnwert


Python als Taschenrechner

Eingabe in den Interpreter: Beispiele

>>> a = 3

>>> b = 4

>>> c = a**2 + b**2

>>> c

25

>>> print math.sqrt(c)

5.0

>>>


Syntax von wesentlichen Konstrukten

fur weitere Konstrukte sowie Details zur Syntax siehe Tutorials und Handbucher

Zuweisung (Assignment)

Variable = Ausdruck

Auswertung:1. Berechne: Wert des Ausdruckes

dazu: Werte von Variablen im Speicher nachschauenResultat: ein im Speicher liegendes

”Objekt“

2. Zuweisung: Wert zu Namen der Variablen

Ein Objekt kann mehrere Namen besitzen.

Deklaration von Variablen(namen) in einer Funktionsdefinition erfolgt

automatisch


Zuweisung mit Arithmetische Operatoren

Variable op= Ausdruck

Hierbei kann op einer der vordefinierten Operatoren sein: +,*,-,/, ...

>>> a= 100

>>> a /= 5

>>> a

20

>>> a *= 5

>>> a

100


Mehrfach-Zuweisung

(scheinbar parallele) Mehrfach-Zuweisung:

x1, . . . xn = e1, . . . , en

wobei xi Variablen und ei Ausdrucke sind

Auswertung des Ausdrucks x1, . . . xn = s1, . . . , sn:

1. Wert aller Ausdrucke si2. Zuweisung der Werte si zu den Variablennamen xi


if-then-else-Konstrukt in Python

if Bedingung:Anweisungen wenn Bedingung wahr

else:

Anweisungen, wenn Bedingung falsch

Doppelpunkte”:“statt Schlusselwort then

Einruckung bestimmt die Blockstruktur

weitere Varianten von if-then-else:

ohne else Zweig

mit zusatzlichen Abfragen (elif-Zweigen).


while-Schleife zur Iteration

while Bedingung:Schleifenkorper

Der Anweisungsblock des Schleifenkorpers wird solange ausgefuhrt, bis

die Bedingung nicht (mehr) erfullt ist.

Im Schleifenrumpf verwendbar:

break

continue


Beispiel zu while

>>> a=10

>>> while a > 0:

... print a

... a = a-1

...

10

9

8

7

6

5

4

3

2

1


Funktions- und Prozedurdefinitionen

def Funktioname(parameter1,parameter2, . . .):Anweisungen

Ruckgabewert mittels: return e

None, falls return-Anweisung weggelassen wurde

Prozeduraufruf: f(s1, . . . , sn) bei n-stelligem f .mit voller Argumentanzahlund Argumenten eingeklammert


Komplexe Zahlen

Paar von zwei Double-Zahlen: Real- und Imaginar-Teil

>>> a=1.5+0.5j

>>> a.real

1.5

>>> a.imag

0.5

>>> abs(a)

1.5811388300841898

>>> a*a

(2+1.5j)

>>>


Strings

einfache Strings”Hello world“

und

Unicode Strings:

>>> u’Hello World !’

u’Hello World !’


Module

Benutzung durch import-Anweisungen und qualifizierte Aufrufe:

>>> import cmath

>>> a=1.5+0.5j

>>> cmath.sin(a)

(1.1248012470579227+0.036860823712804462j)

>>>

Wird noch besprochen


Beispiel: wurzel ala Python:

def wurzel(x): return wurzeliter(1.0,x)

def wurzeliter(schaetzwert,x):

if gutgenug(schaetzwert,x):

return schaetzwert

else: return wurzeliter(verbessern(schaetzwert, x), x)

def quadrat(x): return x*x

def gutgenug(schaetzwert,x):

return (abs ((quadrat(schaetzwert) - x) / x) < 0.00001)

def verbessern(schaetzwert,x):

return mittelwert(schaetzwert, (x / schaetzwert))

def mittelwert(x,y): return (x + y) / 2.0

>>> wurzel(2.0)

1.4142156862745097

>>>


Referentielle Transparenz gilt nicht in Python:

count = 0

def f(x):

global count

count = count + x

return count

f (1) == f (1) ergibt 0

Seiteneffekt andert die globale Variable count.


Flussdiagramm am Beispiel ggt

Der großte gemeinsame Teiler kann durch die Prozedur ggtpy berechnet

werden:

def ggtpy(x,y):

if x <= 0 or y <= 0:

print ’Eingabe in GGT muss positiv sein’

else:

while x != y:

if x > y:

x = x - y

else:

y = y - x

return x


ggt: schnellere Version

def ggt(x,y):

if y == 0:

return x

else: return ggt(y, (x % y))

Einige Beispielauswertungen:

>>> ggtpy(1234,4321)

1

>>> ggtpy(1243,3421)

11


Flussdiagramm zu ggt

x := a; y := b

x = ydrucke x

Stop

Ja nein

x > yJa

x := x-y

nein

y := y-x

Flussdiagramme sind oft von begrenztem Nutzen, da sie zu groß werden


Wert-Vertauschung ohne Hilfsvariable

Vertauschung von Variablenwerten ohne Hilfsvariable:

>>> a = 1

>>> b = 2

>>> a,b = b,a

>>> a

2

>>> b

1

>>>


Wert-Vertauschung mit Hilfsvariable

c = a

a = b

b = c

####### Im Python Interpreter:

>>> a = 1

>>> b = 2

>>> c = a

>>> a = b

>>> b = c

>>> a

2

>>> b

1

>>>


Mehrfachzuweisung ist sequentiell

>>> a,b,a = 1,2,3

>>> a

3

>>>


Fibonacci in Python, iterativ

def fib(n):

a,b = 0,1

while b < n:

print b,

a,b = b,a+b

>>> fib(1000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987


Boolesche Funktionen

>>> a = 1

>>> not a

False

>>> a = 0

>>> b = 1

>>> a or b

1

>>> a and b

0

>>> del b

>>> b

Traceback (most recent call last):

File "<input>", line 1, in ?

NameError: name ’b’ is not defined

>>> a

1

>>> a or b

1


Boolesche Funktionen

not, or, and wirken (fast) wie die Booleschen Operatoren.

or, and werten von links nach rechts aus

Ersatzdefinitionen:

def or(x,y):

if x: return x

else: return y

def and(x,y):

if x: return y

else: return x

def not(x):

if x == 0: return 1

else: return 0


Iterative Prozesse und Iterative Funktionen

def fakultaetlin(n):

a = faktiter(1,1,n)

return a

def faktiter(produkt,zaehler,max):

if zaehler > max:

return produkt

else: return faktiter(zaehler * produkt,zaehler + 1,max)

def faktwhile(n):

produkt = 1

zaehler = 1

max = n

while zaehler <= max:

produkt = (zaehler * produkt)

zaehler = zaehler + 1

return produkt


Module in Python

Module dienen zur

• Strukturierung / Hierarchisierung

• Kapselung:

• Wiederverwendung


Module in Python

Jede Python-Programm-File ist ein Modul

Kein eigener Modulkopf mit export-Liste

Modulimport mittels import:

import Modulname

Re-Initialisierung:

reload(Modulname)


Beispiel in Python

Datei Fib.py, Modul Fib:

def fib(n):

a,b = 0,1

while b < n:

print b,

a,b = b,a+b

X=10 # Diese Zeilen werden beim Import

fib(X) # ausgefuehrt

Beim Import des Moduls Fib

>>> import Fib

1 1 2 3 5 8


Aufruf von Funktionen aus Modul

Zugriff auf Namen aus importierten Modulen: qualifiziert: Modul-

name.Name


Zugriff auf importierte Variablen

Nach import Fib:

>>> X

Traceback (most recent call last):

File "<stdin>", line 1, in ?

NameError: name ’X’ is not defined

>>> Fib.X

10

>>> Fib.fib(5)

1 1 2 3


Lokale Aliase fur Modulnamen

Importier unter Alias-Namen ist moglich:

>>> import Fib as Fibonacci

1 1 2 3 5 8

>>> Fibonacci.fib(5)

1 1 2 3


Importieren mittels from

Nur selektierte Funktionen importieren:

from Modulname import Definitionsliste from Modulname import *

Beispiel:

>>> from Fib import fib

1 1 2 3 5 8

>>> fib(5)

1 1 2 3


Importieren mittels from ... *: Beispiel

Vorsicht: Unerwartete Effekte dabei

X = 10;

def printer():

global X:

print X

>>> from Printer import *

>>> X

10

>>> printer()

10

>>> X = 20

>>> printer()

10

>>> X

20


Datenkapselung in Python

Ist in der Verantwortung des Programmierers.

In Python gibt es kein (echtes) Verstecken von Funktionen.

Man kann auf samtliche definierten Namen des importierten Moduls

qualifiziert zugreifen.

Konvention: Namen, die mit _ beginnen gelten als versteckt.


Documents

Programmierung in Python - ki.informatik.uni-frankfurt.de · Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales