Pythonkurs (Lebrecht)

Programmierung mit Python (2.6)
Download: www.python.org/download
=>
Python 2.6.x Windows installer
Aufruf des Programms: Start => Alle Programme => Python 2.6
=> IDLE(Python) GUI)
Auf Bildschirm:
IDLE 2.6
>>>
Python als Rechenknecht
Eingabe: 2+2 ENTER
4
>>>
Eingabe: 2*(3+4)
14
>>>
Eingabe: from math import *
(damit ist der Gebrauch zahlreicher mathematischer Funktionen
möglich.
siehe F1 => Library Reference => 6.1 math –
Mathematical Functions)
Eingabe: sqrt(16)
4
Eingabe: sin(pi)
1.224606353822377e-016
Hotkeys: Alt + p und Alt+n : Springen in zuletzt eingegebenen Kommandos
Strg+C zum Abbruch eines Programms, wenn die Ausführung zulange dauert
Eingabe: zahl1=3
Eingabe: zahl2=5
Eingabe: zahl1+zahl2
8
Eingabe: zahl1*zahl2
15
Eingabe: zahl1**zahl2
243
(=35)
Der Name einer Variable beginnt mit einem Buchstaben und kann auch Ziffern und Unterstriche _
enthalten.
Programmierung mit Python
Im Menü FILE => New Window
SAVE AS
Ein Programm soll den Umfang und den Flächeninhalt eines Rechtecks berechnen!
FILE => New Window
SAVE AS rechteck.py
Python-Skript:
# rechteck.py
# Programm zur Berechung von A und U aus a und b
print “Programm zur Berechnung von Umfang und Flaecheninhalt aus Laenge und Breite“
a = input (“Geben Sie die Laenge ein: “)
b = input (“Geben Sie die Breite ein: “)
U = 2*(a+b)
A = a*b
print “Umfang: „“,U,“Flaecheninhalt: “,A
raw_input()
#Dadurch bleibt das Bild bis zur Eingabe von RETURN
Ausführung des Programms:
Menü RUN => Run Module F5
Die Eingabe von
Umlaute.
#-*-coding: cp1252 -*-
in der ersten oder zweiten Zeile erlaubt deutsche
Ausführung eines Programms
0.
Bei der Bearbeitung des Programms mit IDLE mit der Funktionstaste F5
Eventuell macht die eigene Firewall Schwierigkeiten, vor allem bei der Turtle-Grafik
1. Direkt über den Windows-Explorer
2. Über die Eingabeaufforderung. Genauen Pfad angeben, z.B.
c:\programme\python\pythonprogramme>rechteck.py
3. Über Start => Ausführen ... => genaue Pfadangabe
Übung: Schreibe ein Programm zur Berechnung von Oberfläche und Volumen eines Quaders.
Übung: Schreibe ein Programm zur Berechnung der Diagonale eines Rechtecks.
#diagonale.py
#Programm zur Berechnung der Diagonale eines Rechtecks aus Länge und Breite
print “Programm zur Berechnung der Diagonale eines Rechtecks“
a = input(“Laenge? “)
b = input(“Breite? “)
import math
d = math.sqrt(a*a+b*b)
print “Laenge der Diagonale: “,d
print “Programmende mit RETURN”
raw_input()
Kontrollstrukturen
Bedingte Anweisungen (Programmverzweigungen)
Die einseitige Verzweigung (if)
Format:
if bedingung:
anweisungsblock
Beispiel: Schreibe ein Programm, das zu einer eingegebene Zahl ihre Betrag ausgibt.
#Betrag.py
#Programm gibt den Betrag einer Zahl aus
print “Programm zur Bestimmung des Betrags einer Zahl“
z = input(“Geben Sie die Zahl ein: “)
if z < 0 :
z = -z
print “Betrag: “,z
raw_input()
Die zweiseitige Verzweigung (if-else)
Format:
if bedingung:
anweisungsblock 1
else:
anweisungsblock 2
Mehrfache Fallunterscheidungen (elif)
Format:
if bedingung1 :
anweisungsblock
elif bedingung2 :
anweisungsblock
elif bedingung3 :
anweisungsblock
...
[else:
anweisungsblock]
Übung: Ein Programm soll das Körpergewicht nach dem body-mass-index beurteilen.
#gewicht.py
print “Programm zur Beurteilung des Körpergewichts“
groe = input (“Groesse in m: “)
#Eingabe einer Dezimalzahl mit Dezimalpunkt
gew = input (“Gewicht in kg: “)
sex = raw_input (“weiblich (w) oder maennlich (m): “) #Eingabe einer Zeichenkette
BMI = gew/(groe*groe)
print “Dein BMI: “, BMI
if sex ==“w“ or sex ==“W“:
print “Du bist weiblich.”
if BMI > 24:
print “Du bist zu schwer!“
elif BMI < 19
print “Du hast Untergewicht!“
else:
print “Du hast normales Gewicht.“
elif sex ==“m“ or sex ==“M“:
print “Du bist maennlich.”
if BMI > 25:
print “Du bist zu schwer!“
elif BMI < 20
print “Du hast Untergewicht!“
else:
print “Du hast normales Gewicht.“
else:
print “Fehler bei der Eingabe“
raw_input()
Wiederholungen
Die bedingte Wiederholung (while-Schleife)
Format:
while Bedingung :
anweisungsblock
Übung: Schreibe ein Programm, das die Wurzeln eingegebener Zahlen berechnet.
#wurzel.py
print “Programm berechnet die Wurzel aus einer Zahl“
import math
antwort = ’j’
while antwort == ’j’ :
radikand = input (“Radikand: „)
if radikant >=0 :
wurzel = math.sqrt(radikand)
print “Wurzel aus “, radikand, “=“, wurzel
else:
print “Der Radikand ist negativ!“
antwort = raw_input(“Noch einmal? (j/n) “)
print “Programm beenden mit RETURN“
raw_input()
Die Zählschleife (for-Schleife)
Format: for name in Sequenz :
anweisungsblock
Übung: Schreibe ein Programm, das 10-mal den eingegebenen Text wiederholt.
#berliner.py
print “Programm schreibt zehnmal den eingegebenen Text.“
satz = raw_input(“Text: “),satz
for i in (1,2,3,4,5,6,7,8,9,10) :
print satz
print “Programm mit RETURN beenden.”
raw_input()
Vereinfachung: Ersetze die Klammer durch range(10)
Sequenzen
1. Listen
a) Erzeugen einer Liste
i)
Durch Aufzählen
>>> liste1 = [3,“rot“,5.0]
>>> liste1
[3, ’rot’, 5.0]
ii)
Durch Erweitern einer vorhandenen Liste
>>> liste1.append(8)
>>> liste1[3]
8
iii)
Durch Definition einer Liste vorgegebener Länge
>>> liste2 = [0]*5
#Erzeugt Liste der Länge 5; alle Elemente sind 0
>>> liste2
[0, 0 ,0, 0 ,0]
b) Methoden von Listen
i)
Ersetzen eines Listenelements durch ein anderes
>>> liste[4] = 9
>>> list2
[0, 0, 0, 9]
ii)
An die Liste wird ein neues Element angehängt
>>> liste.append(7)
>>> liste
[0, 0, 0, 9, 7]
iii)
liste.extend(5,8)
#Die Liste wird um das Tupel (5,8) erweitert
vi)
del liste[3]
#Das Element mit Index 3 wird aus der Liste
#entfernt und die Liste somit um 1 verkürzt
del liste[1:4]
#Die Elemente mit Index 1, 2, 3 werden entfernt
v)
letztes= liste.pop() #Das letzte Element wird aus der Liste entfernt
#und der Wert der Variablen letztes zugeordnet
vi)
liste.sort
#Die Liste wird sortiert
vii)
liste.remove(5)
#Die erste 5 wird aus der Liste entfernt
viii)
liste2 = liste1 + liste #Zwei Listen werden zu einer zusammengefügt
Zufallszahlen
from random import *
randrange(6)
randrange(1,7)
randint(1,6)
random()
uniform(a,b)
choice(folge)
erzeugt Zufallszahlen von 0 bis 5
erzeugt Zufallszahlen von 1 bis 6
erzeugt Zufallszahlen von 1 bis 6
erzeugt reelle Zufallszahl in [0.0, 1.0)
erzeugt reelle Zufallszahl in [a,b)
gibt ein Element der Liste folge an
Beispiel: Werfen eines Würfels
#augenzahl.py
# X[i] gibt an, wie oft die Augenzahl i beim wiederholten Werfen eines Wuerfels gefallen ist.
#Das Programm simuliert die Verteilung von X
print("Verteilung der Augenzahl X beim Werfen eines Wuerfels")
from random import *
n=input("Wie oft soll gewuerfelt werden? ")
x = [0]*7
for i in range(n) :
z=randint(1,6)
x[z]=x[z]+1
print("x
1
2
3
4
5
print("H(X=x) "),x[1],(" "),x[2],(" "), \
x[3],(" "),x[4],(" "),x[5],(" "), x[6]
6")
raw_input()
Programmausführung:
Verteilung der Augenzahl X beim Werfen eines Wuerfels
Wie oft soll gewuerfelt werden? 6000
x
H(X=x)
1
1013
2
1032
3
981
4
943
5
999
6
1032
Turtle-Grafik
Aufgabe: Zeichne ein Quadrat
#quadrat01.py
print"Programm zeichnet ein Quadrat"
from turtle import *
seite = input("Seitenlaenge: ")
farbe = raw_input("Farbe: (red, green, black, blue, yellow) :")
color(farbe)
forward(seite)
left(90)
forward(seite)
left(90)
forward(seite)
left(90)
forward(seite)
left(90)
Funktionen aus dem Modul turtle
forward(distanz)
Turtle geht um distanz Einheiten vorwärts
backward(distanz)
Turtle geht um distanz Einheiten rückwärts
left(winkel)
Turtle dreht sich um winkel Grad nach links
right(winkel)
Turtle dreht sich um winkel Grad nach rechts
up()
Turtle hebt den Zeichenstift an und bewegt sich ohne Spur
down()
Turtle senkt den Zeichenstift
width(dicke)
Stellt die Strichdicke für den Zeichenstift auf dicke Pixel ein
color(farbe)
Stellt die Farbe für den Zeichenstift ein, z.B. “red“, “blue“
fill(ein/aus)
Schaltet Füllmodus ein mit dem Wert 1 oder aus mit dem Wert 0
reset()
Löscht alle Zeichnungen im Grafik-Fenster und setzt Turtle auf Standard
clear()
Löscht alle Zeichnungen, aber der Zustand der Turtle bleibt erhalten
Aufgabe: Zeichne drei verschachtelte Dreiecke
#quadrat02.py
print"Zeichnen von Quadraten"
from turtle import *
def quadrat(seite,farbe):
color(farbe)
for k in range(4):
forward(seite)
left(90)
a=50
bunt = "red"
quadrat(a,bunt)
a=100
bunt = "blue"
quadrat(a,bunt)
a= 150
bunt = "green"
quadrat(a,bunt)
Aufgabe: Zeichne ein buntes Kleeblatt aus 4 Dreiecken
#klee.py
print"Zeichnen eines Kleeblatts aus 4 Dreiecken"
from turtle import *
def dreieck(seite,farbe):
color(farbe)
for k in range(3):
forward(seite)
right(120)
for bunt in ["green","red","blue","yellow"]:
dreieck(50,bunt)
left(90)
Aufgabe: Realisiere einen Kreis als n-Eck
#kreis.py
#Kreis als n-Eck
print"Zeichnen eines Kreises als n-Eck"
radius=input("Radius: ")
eckenzahl=input("Anzahl der Ecken: ")
eckenzahl = int(eckenzahl)
from math import *
from turtle import *
def kreis(r,n):
seite=2*pi*r/n
seite=int(seite)
winkel=360/n
for k in range(n):
forward(seite)
right(winkel)
kreis(radius,eckenzahl)
Funktionen
a) Funktionen ohne Parameter
Aufgabe: Beurteile die Rechenleistung des Anwenders
#leistung.py
def gruss():
print “Dieser Test wurde von Thomas Lebrecht erstellt“
name = raw_input (“Geben Sie Ihren Namen ein!“)
print “Hallo“,name,“, viel Erfolg beim Loesen!“ #name ist nur lokale Variable
def aufgabe():
global resultat
resultat = input(„4 + 5 = ? “)
return resultat #Der Wert von resultat wird dem Haupt-
#programm zur Verfuegung gestellt
def auswertung():
global resultat
#Es wird auf die Variable resultat des
#Hauptprogramms zurueckgegriffen
if resultat = =9:
print “Sie sind bist Klasse!“
else:
print “Du Versager!“
gruss()
aufgabe()
auswertung()
b) Funktionen mit Parameter
Aufgabe: Halbierung einer Zahl
#halb.py
def halbiere (zahl):
global halb
zahl = float(zahl)
halb = zahl/2
return halb
n = input("Zahl eingeben: ")
halbiere(n)
print halb
print n
#Eingabe: 7
#Ausgabe: 3.5
#Ausgabe: 7
Bemerkungen:
1. zahl ist eine lokale Variable.
2. Das als Parameter übergebene Objekt ist eine Zahl, also ebenso wie ein String oder ein
Tupel unveränderbar. n behält auch nach Durchführung der Funktion seinen Wert.
Beispiel: Quadriere eine Liste
#Quadrieren einer Liste
def quadriere (liste):
for i in range (len(liste)):
liste[i] = liste[i]*liste[i]
#Hauptprogramm
orglist = [3, 9, 12, 25]
print orglist
quadriere (orglist)
print orglist
#Ausgabe: [9, 81, 144, 625]
Bemerkungen:
Das Argument des Funktionsaufrufs ist als Liste ein
veränderbares Objekt. Diese wird innerhalb der Funktion
modifiziert. Dies wirkt sich auch auf das Hauptprogramm aus.
Erklärung: Das Objekt selbst ist nicht lokal, sondern existiert
außerhalb der Umgebung der Funktion.
c) Rekursive Prozeduren
Aufgabe: Zeichne einen selbstähnlichen Baum
#baum.py
print"Programm zeichnet einen selbstaehnlichen Baum"
laenge=input("Stammlaenge: ")
tiefe=input("Verschachtelungstiefe: ")
from turtle import *
def baum(a,t):
if t>=0:
forward(a)
left(45)
baum(a/2,t-1)
right(90)
baum(a/2,t-1)
left(45)
backward(a)
left(90)
baum(laenge,tiefe)
right(90)
Übungen
Aufgabe: Berechne eine Nullstelle eines Polynoms n-ter Ordnung mit dem Halbierungsverfahren
#Halbierungsverfahren.py
def eingabeDerFunktion():
global n
#Grad des Polynoms
global koeffliste
#Koeffizientenliste
koeffliste=[]
print "Berechnung einer Nullstelle eines Polynoms n-ten Grades"
print "der Form a(n)*x^n + a(n-1)*x^(n-1) + ... + a(0) "
print "mit dem Halbierungsverfahren"
n=input("n = ")
i=n
while i >= 0:
print "Eingabe von a(",i,")"
koeff=input("Koeffizient: ")
koeffliste.append(koeff) #An die Koeffizientenliste wird ein
i = i-1
#Element angehaengt
return koeffliste
def funkt(x):
global fvonx
fvonx = koeffliste[0]
for i in range(n):
fvonx = fvonx*x + koeffliste[i+1]
return fvonx
def anfang():
global a
global b
for i in range(10):
a=input("1. Anfangsnaeherung: ")
b=input("2.Anfangsnaeherung: ")
funkt(a)
fa = fvonx
funkt(b)
fb = fvonx
if fa*fb <0:
return a
return b
break
#Es wird solange nach nach Anfangsnaeherungen gesucht, bis
#ein Intervall gefunden ist, in dem eine Nullstelle liegt.
#Die Schleife wird dann mit break abgebrochen.
def neu(x1,x2):
global a,b
m = (x1+x2)/float(2)
fm = funkt(m)
f1 = funkt(x1)
if fm*f1 >= 0:
a=m
else:
b=m
return a
return b
eingabeDerFunktion()
anfang()
while abs(funkt(a))> 1E-6:
neu(a,b)
print a,b
Aufgabe ( Primzahltest): Schreibe ein Programm, das testet, ob eine vorgegebene Zahl eine Primzahl
ist.
#primzahltest.py
from math import *
#Definition der Funktionen:
def eingabe():
global n
n=0
while n<=2:
n=input("Zu pruefende Zahl: ")
n = int(n)
return n
#Eingabeaufforderung so lange bis n >2
def primtest(n):
grenze = int(sqrt(n))+1
for i in range(2,grenze):
if n%i==0:
print n, " = ", i, " * ", n/i
break
#Schleifenabbruch
else:
#Schleifen (for, while) können eine else-Klausel haben,
#die nur dann ausgeführt wird, wenn die Schleife nicht
print n, " ist eine Primzahl."
#mit break abgebrochen wurde.
#Hauptprogramm:
print "Programm prueft, ob eine eingegebene Zahl > 2 prim ist."
eingabe()
primtest(n)
Grafik
#grafik1.py
from Tkinter import *
fenster = Tk()
fenster.mainloop()
#alle Funktionen des Moduls Tkinter werden importiert
#Ein Objekt der Klasse Tk mit Namen fenster wird eingerichtet
#Die Methode mainloop aktiviert ein Tk-Fenster
#grafik2.py
from Tkinter import *
fenster= Tk()
fenster.etikett= Label(master=fenster,text= ‘Hallo!’)
fenster.etikett.pack()
#Ein Objekt der Klasse Label mit Namen
#fenster.etikett wird erzeugt.
#Mit der Methode pack() wird das neue
#Objekt etikett in die Darstellung des
#Anwendungsfensters fenster eingebaut.
fenster.mainloop()
#grafik3.py
from Tkinter import *
fenster= Tk()
fenster.etikett= Label(master=fenster,text= ‘Hallo!’,
font=(’Comic Sans MS’,14),fg=’blue’)
#als Schrifttyp wird Comic Sans MS
#in der Schriftgröße 14;
#Schriftfarbe ist Blau
fenster.etikett.pack()
fenster.title (’Formen’)
#Ueberschrift
leinwand=Canvas(fenster,width=800,height=600,bg=“yellow“)
#Mithilfe von Canvas-Objekten werden Kreise, Rechtecke, Linien oder Textobjekte generiert
leinwand.pack()
rechteck=leinwand.create_rectangle(40,20,160,80,fill=“Moccasin“)
kreis=leinwand.create_line(270,290,450,350,width=10,fill=“Lightblue“)
vieleck=leinwand.create_polygon(500,80,500,120,600,120,500,80, fill =“white“)
streckenzug=leinwand.create_line(270,290,450,350,300,200,
arrow = LAST, width =10, fill = “blue“)
#andere Werte fuer arrow:
#FIRST, BOTH
spruch=leinwand.create_text(300,50,text=“Aller Anfang ist schwer!“),
font=(’Arial’,14), fill=“green“)
fenster.mainloop()