Einstieg ins Programmieren mit Python 3.1

Einstieg ins Programmieren mit Python 3.1
Dierk Schröder, 16.12.2010
Inhaltsverzeichnis:
1
Vorbereitung
1.1 Warum Python? -------------------------------------------------------1.2 Python installieren ----------------------------------------------------1.3 Arbeitsordner einrichten ---------------------------------------------1.4 Starten des Programms -----------------------------------------------
2
2
2
2
2
Ein- und Ausgabe - EVA lässt grüßen
2.1 Ausgabe auf dem Bildschirm ------------------------------------------ 2
2.2 Eingabe über die Tastatur --------------------------------------------- 3
3
Entscheidungen: wenn ... dann ... sonst ... -------------------------- 3
4
Was sind Variablen?
4.1 Die Sache mit den Schubladen --------------------------------------4.2 Zahlen und Zeichenketten ineinander umwandeln -----------------4.3 Rechnen mit Zahlen und Variablen ----------------------------------4.4 Benutzung von Strings-------------------------------------------------
4
5
6
7
5
Wiederholungen: ... und noch einmal ...
5.1 for-Schleife … ---------------------------------------------------------- 8
5.2 while-Schleifen … ------------------------------------------------------ 9
6
Ausnahmen: try ... except ... ------------------------------------------ 9
7
Datentypen
7.1 Tuples, Listen --------------------------------------------------------- 10
7.2 Wörterbücher --------------------------------------------------------- 11
8
Funktionen und Prozeduren: Definitionen
8.1 Funktionen ----------------------------------------------------------- 12
8.2 Prozeduren ----------------------------------------------------------- 13
9
Module – Erweiterungen für fast alles ------------------------------13
10
Dateien ---------------------------------------------------------------14
11
Quellen -------------------------------------------------------------------15
12
Aufgaben -----------------------------------------------------------------15
1
1 Vorbereitung
1.1
Warum Python?
•
Python ist leicht zu lernen. Der Code ist stets gut strukturiert und gut lesbar.
•
Python ist eine Interpretersprache mit interaktiver Oberfläche, die die
Erforschung der Sprache ermöglicht.
•
Python ist eine moderne Sprache, von Grund auf objektorientiert.
•
Python ist kostenlos und plattformunabhängig: Windows, Linux und Mac.
•
Es gibt viele Anleitungen und Hilfen im Internet:
http://abop-german.berlios.de/
http://igs-hassee.lernnetz.de/Silverstripe/informatik
1.2
Python installieren
Du kannst Python 3.1 kostenlos im Internet herunterladen: http://www.python.org
Achtung: Achtung: Python 3.1 ist nicht mehr abwärtskompatibel zu Python 2.x
1.3
Arbeitsordner einrichten
Erstelle einen geigneten Ordner auf deinem USB-Stick oder im Netzwerk, in den du
deine fertigen Python-Programme speicherst.
Wähle .py als Dateiendung. (beispiel.py)
1.4
Starten des Programms
Starte die Benutzeroberfläche IDLE.
Jetzt hast du zwei Möglichkeiten:
1. Probiere einige Befehle direkt aus, indem
du sie in die Eingabezeile schreibst und
mit <ENTER> ausführst (interaktiv).
2. Wähle File-New Window, um eine
Programmliste zu schreiben.
Wenn du die unteren Befehlszeilen in den Editor eingibst und auf Run klickst, wird ein
Quadrat in einem eigenen Ausgabefenster gezeichnet.
Die Befehle musst du noch nicht verstehen.
Den Text hinter dem # musst du nicht schreiben.
Der Text hinter # ist ein Kommentar und wird vom Programm nicht beachtet.
Du kannst also Text und Bilder mit Python ausgeben.
2
2 Ein- und Ausgabe
2.1
Ausgabe auf dem Bildschirm
Die Anweisung
print ('Hallo Welt!')
bewirkt, dass der Satz auf den Bildschirm geschrieben wird. Dasselbe erreicht man
auch mit der folgenden Anweisung.
print("Hallo Welt!")
Achtung: Python unterscheidet Groß- und Kleinschreibung.
Print('Hallo Welt!')
führt zu einer Fehlermeldung.
Im Gegensatz zu älteren Versionen, musst du
bei print() Klammern verwenden.
2.2
Eingabe über die Tastatur
Damit ein Computerprogramm den Benutzer nach dem Vornamen fragt, kannst du
folgende Anweisung schreiben.
name = input('Wie heißt du? ')
Das Programm schreibt dann die Frage "Wie heißt du?" auf den Bildschirm und wartet
auf eine Eingabe von der Tastatur. Wenn du z.B. "Monty" eingibst und <Enter>
drückst, speichert das Programm die Zeichenkette Monty in der Variablen name.
Python definiert diese Variable automatisch als Textvariable (String).
Das einfache = bedeutet, dass der Variablen name etwas zugeordnet wird und zwar
in diesem Fall das Ergebnis der Tastatureingabe.
Wenn du anschließend
print('Hallo', name) # Probier auch das: print('Hallo', name,sep='#')
eingibst, wird die Begrüßung auf dem Bildschirm angezeigt.
3 Entscheidungen: wenn ... dann ... sonst
if name == 'Paula':
print ('Hallo', name)
print('Guten Tag')
oder
if name == 'Paula':
print ('Hallo', name)
elif name == 'Paul':
#oder wenn
print('Hallo', name,'bist du nicht mein Nachbar?')
else:
#in allen anderen Fällen
print ('Ich kenne dich nicht!', name)
3
Das doppelte == wird in Python für Vergleiche benutzt. Hier wird der Inhalt der
Variablen name mit der Zeichenkette Paula verglichen. Wenn in der Variablen name der
Name Paula gespeichert ist, dann macht das Programm das, was danach eingerückt
ist - also in diesem Fall schreibt es "Hallo Paula" auf den Bildschirm. Anderenfalls
macht das Programm das, was hinter else: eingerückt ist.
Die Liste der Vergleichsoperatoren findest du unter 5.2.
Achtung: Eine Zeile mit if, elif und else muss immer mit einem Doppelpunkt enden.
So macht man Einrückungen:
Benutze auf keinen Fall einen Mix von Tabulatoren und Leerzeichen zur Einrückung.
Wähle einheitlich den Tabulator. Programmfehler sind schwer zu identifizieren, wenn
es sich um Einrückungsfehler handelt.
Aufgaben 1 bis 3
4 Was sind Variablen?
4.1 Die Sache mit den Schubladen
4.1.1 Übersicht
Integer
i=1
Ganzzahl
Float
f=0.1
Gleitkommazahl
String
s="hallo"
Zeichenkette
Boolean
B=12<20
>>> True
True/False
Oben war schon von Variablen die Rede. Wenn zum Beispiel etwas über die Tastatur
eingegeben wird, dann soll sich das gerade laufende Computerprogramm die Eingabe
merken. Dazu muss es die Eingabe irgendwo ablegen, so dass sie jederzeit
wiedergefunden werden kann. Genau das passiert in der folgenden Zeile.
schule = input('Welche Schule besuchst du? ') # String
Der Computer bewahrt das, was über die Tastatur eingegeben wird, in einer
"Schublade" mit der Aufschrift schule auf. Statt Schublade spricht man in der
Informatik von Variablen. Wenn man etwas Neues in eine Informatik-Schublade legt,
wird automatisch alles, was bislang darin war entsorgt.
Oben ist ein Beispiel angeführt, wie man den Programm-Benutzer dazu auffordern
kann, etwas in die Schublade zu legen. In der Informatik würde man eher sagen
"etwas in der Variablen speichern". In der Mathematik sagt man "etwas in eine
Variable einsetzen".
Man kann auch direkt in einer Programmzeile etwas in einer Variablen speichern. Der
Variablenname muss mit einem Buchstaben beginnen. (zahl2, A_quadrat, ...)
schule = 'GemS Hassee'
alter = 13
gewicht = 53.7
größe = 1.65
geschlecht = 'm'
#string
#integer
#float
#float
#string
Hier sieht man, dass es unterschiedliche Dinge (Typen) gibt, die man in Variablen
speichern kann. In der Variablen schule wird die Zeichenkette (String) GemS Hassee
4
gespeichert. Damit das Programm weiß, wo die Zeichenkette anfängt und wo sie
aufhört, muss man Anführungszeichen setzen. In der Variablen alter wird die Zahl 13
(ohne Anführungszeichen) gespeichert. In der Variablen gewicht wir die
Fließkommazahl (rationale Zahl) 53,7 gespeichert.
Achtung, verwende bei „Kommazahlen“ immer den Dezimalpunkt!
Wenn das Programm den Inhalt einer Schublade wieder anzeigen soll, muss man dem
Programm nur sagen, in welcher Schublade es nachsehen soll.
print(schule, 'ist meine Schule.')
print('Ich bin',alter,'Jahre alt')
4.2 Zahlen und Zeichenketten ineinander umwandeln
Oft ist es nötig, Zeichenketten in Zahlen zu verwandeln und umgekehrt.
Stell dir ein Computerspiel vor, das nur für Kinder interessant ist. Das
Computerprogramm möchte Jugendliche ab 16 Jahre warnen, dass sie wahrscheinlich
schon zu alt für das Spiel sind.
alter = input('Wie alt bist du? ')
if alter >= 16:
print('Du bist schon zu alt für dieses Spiel.')
In diesen Zeilen ist ein Fehler versteckt. Eine Eingabe mit input liefert immer eine
Zeichenkette. In diesem Beispiel sollte in der Variablen alter allerdings eine ganze
Zahl enthalten sein (integer). Also muss man die Zeichenkette, die von der Tastatur
kommt, in eine Zahl (integer) umwandeln. Man kann die Zeichenkette (string) von der
Tastatur erst einmal in einer Variablen speichern und danach in eine Zahl verwandeln.
alter_str = input('Wie alt bist du? ')
alter = int(alter_str)
if alter >= 16:
print('Du bist schon zu alt für dieses Kinderspiel.')
Hat der Anwender des Programms beispielsweise die Tasten <1> und <7> und
<Enter> gedrückt, dann ist in der Variablen alter_str die Zeichenkette (string)
'17' und in der Variablen alter die Zahl 17 enthalten.
b='18'
zahl = int(b)
#String
Die Zeichenkette aus der String-Schublade b wird gelesen, in eine Zahl umgewandelt
und dann das Ergebnis in der Variablen zahl gespeichert.
Hätte jemand als Alter 16.5 eingegeben, dann würde eine Fehlermeldung erscheinen;
denn 16.5 ist keine ganze Zahl sondern eine rationale Zahl (Fließkommazahl/float).
Hierfür gilt die Funktion
kommazahl = float(b)
Achtung: Die Vor- und Nachkommastellen werden durch einen Punkt getrennt.
Manchmal braucht man auch die Verwandlung einer Zahl in eine Zeichenkette:
text = str(16.5)
5
4.3 Rechnen mit Zahlen und Variablen
Du kannst in der interaktiven Eingabezeile sofort mit dem Rechnen bzw. Verknüpfen
von Strings beginnen.
Im Programm musst du es etwa so schreiben:
print(2+3)
print(3*(4-2)+7)
print (7*'Hallo ')
ergebnis = 2+9
print(ergebnis)
Was dir jetzt noch fehlt sind die Operatoren und die
Verwendung.
Operator
Name
Erklärung
Beispiele
+
Plus
Addiert bzw. verkettet die
beiden Objekte
3 + 5 ergibt 8. 'a' + 'b' ergibt 'ab'.
-
Minus
Ergibt entweder eine
negative Zahl, oder
subtrahiert zwei Zahlen
-5.2 ergibt eine negative Zahl.
50 - 24 ergibt 26.
*
Multipliziert zwei Zahlen
miteinander oder gibt eine
Multiplikation
mehrfache Wiederholung
eines Strings zurück.
**
Potenz
Gibt die Potenz x hoch y
zurück
3 ** 4 ergibt 81 (d.h. 3 * 3 * 3 * 3)
/
Division
Dividiert zwei rationale
Zahlen
4/3 ergibt 1.3333333333333333
//
Ganzzahlige
Division
Liefert das Ergebnis der
ganzzahligen Division
zurück
5 // 3 ergibt 1
%
Modulo
Liefert den Rest bei einer
ganzzahligen Division
zurück
8%3 ergibt 2.
2 * 3 ergibt 6.
3*'la' ergibt 'lalala'.
Wenn das Programm rechnen soll, dann passiert oft beides in einem Befehl. Der
Computer sieht in einer oder mehreren Schubladen nach und legt das Ergebnis in eine
andere Schublade.
ergebnis = gewicht/(3*alter)
print(ergebnis)
a = 9
a = a+1 # oder a+=1
a_quadrat = a**2
print (a,a_quadrat)
#a**2=a²
In der Zeile a = a+1 wird die Schublade a geöffnet. Die darin enthaltene Zahl wird
um eins erhöht. Das Ergebnis kommt dann wieder in die selbe Schublade.
6
Wenn du schon etwas Erfahrung mit anderen Programmiersprachen hast, solltest du
jetzt schon das Thema 8, Prozeduren und Funktionen, durcharbeiten
Aufgaben 4 und 5
4.4 Benutzung von Strings
Wie man mit Strings umgeht, kannst du sehr gut mit der folgenden Übersicht
verstehen:
Die Ausgabe erhältst du mit print(text), print(x) oder print(a)
Beispielstring: text = 'Hallo Welt'
Befehl
Ausgabe
text
>>> Hallo Welt
a=len(text)
>>> 10
a=text.index('W')
>>> 6
a=text.count('l')
>>> 3
x=text[0]
>>> H
x=text[-1]
>>> t
x=text[1:3]
>>> al
x=text[::-1]
>>> tleW ollaH
x=text[4]+'Ho'
>>> oHo
x=text[6]+text[0]
>>> WH
x=text.lower()
>>> hallo welt
x=text.upper()
>>> HALLO WELT
x=text.center(20)
>>> ·····Hallo Welt·····
x=text.replace('Welt','Du')
>>> Hallo Du
x='auto'.capitalize()
>>> Auto
Strings lassen sich nach dem ASCII-Code vergleichen (sortieren).
print('Hans'<'Karl')
print('zielen'<'Anfang')
print('9'<'anfangen)
>>> True
>>> True
>>> True
Umwandeln von Strings:
Zahl in String: text = str(zahl)
Liste in String: text =''.join(liste)
(Siehe Benutzung von Listen)
Aufgaben 6-7
7
#zentriert
5 Wiederholungen
5.1 For-Schleife
Wenn dein Programm einen Befehl 7 mal wiederholen soll, verwendest du folgenden
Befehl:
for i in range(7)
range(7) erzeugt eine Liste von 7 Zahlen [0, 1, 2, 3, 4, 5, 6].
Diese Liste enthält also 7 Elemente von 0 bis 6. Die Liste ['Sonne', 'Mond', 'Sterne'J
besteht nicht aus Zahlen, sondern aus Zeichenketten. Sie enthält drei Elemente.
Die Bedeutung und den Gebrauch der for-Schleife verstehst du am besten, indem du
die folgenden Programmzeilen ausprobierst.
liste = range(7)
for i in range(10):
print(i)
for w in ['Sonne', 'Mond', 'Sterne']:
print(w)
# mehr zu solchen Listen bei Datentypen
for x in liste:
print(x)
for bs in 'Hallo Welt':
print(bs)
# Ein Text ist eine Liste aus Buchstaben
for a in 'Dieser Text ist gesperrt':
print(a,end=' ')
# probiere auch end='.' usw.
Achtung, hinter der for-Anweisung muss immer ein Doppelpunkt stehen.
Die Befehle in der Wiederholung müssen gleichmäßig eingerückt sein.
Probiere auch folgende Listen aus:
range(7); range(5,17);range(-5,17); range(3,20);
range(3,20,2);range(20,3,-1)
So kannst du die Listen direkt ausgeben: print(list(range(-10,10)))
Hier ein Beispiel wie du die Zeichen des Ascii-Codes erhälts:
for i in range(255):
print(i,':',chr(i),sep='',end=' ')
for b in 'Hallo Welt':
print(b,': ',ord(b))
Aufgaben 8-15
5.2 While-Schleifen
Es gibt auch Wiederholungen, die so lange ausgeführt werden sollen, bis eine
Bedingung erfüllt ist. Solche Schleifen programmiert man in Python mit der Anweisung
while.
8
antwort = input('Wie heißt die Hauptstadt von Frankreich?')
while antwort != 'Paris':
# != bedeutet ungleich
print('Die Antwort war falsch.')
antwort = input('Nächster Versuch: ')
print ('Richtig!')
Die Zeile mit while könnte man umgangssprachlich etwa so übersetzen:
"Solange die Antwort nicht richtig ist, mache folgendes:"
Die eingerückten Zeilen werde so oft wiederholt, bis Paris eingegeben wird.
Wenn man Bedingungen formulieren will, muss man vor allen Dingen vergleichen
können. Deshalb folgt hier eine Tabelle mit Vergleichsoperatoren in Python.
Operator
Bedeutung
Beispiel
==
Gleich?
name == 'Paulina'
!=
Ungleich?
antwort != 'Paris'
<=
Kleiner oder gleich?
zahl<=20
>=
Größer oder gleich?
zahl>=50
<
Kleiner?
zahl<45
>
Größer?
zahl>9.8
not
Logisches NICHT
not 5>3 ergibt False
and
Logisches UND
5>3 and 7>6 ergibt True
or
Logisches ODER
3<1 or 8>5 ergibt True
Aufgaben 16 - 19
6 Ausnahmen: try ... except ...
Ihr kennt die Situation, dass ein Programm fehlerhaft ist und irgendwann abgebrochen
wird. Dann erscheinen normalerweise ein paar mehr oder weniger merkwürdige Zeilen
in roter Farbe im Fenster, wo eigentlich das Programm ausgeführt werden sollte. Das
ist die Standardbehandlung für Laufzeitfehler. Das sind Fehler, die erst beim Ausführen
auftreten. Das kann man auch ändern.
while True:
try:
eingabe = input('Gib eine ganze Zahl ein: ')
zahl = int(eingabe)
break
except:
print ('Bitte ganze Zahl eingeben.')
print(zahl*'Super! ')
while True: Wiederhole das was danach eingerückt ist unendlich oft. Wenn in dem
nach try: eingerückten Block ein Fehler auftritt, wird das Programm nicht
abgebrochen, sondern der eingerückte Block nach except ausgeführt. Mit break wird
die Endlosschleife verlassen.
9
Ein anderes Beispiel:
eingabe = input('Gib eine Zahl zwischen 113 und 254 ein: ')
fehler=0
try:
zahl=int(eingabe)
except:
fehler = 1
if fehler==1:
print ('Das war keine Zahl.')
else:
if zahl > 113 and zahl < 254:
print ('Danke.')
else:
print ('Zählen müsste man können.')
Hier wird im Fall einer falschen Eingabe nur die Variable fehler auf den Wert 1
gesetzt. Dann geht das Programm normal weiter. Die Ausgabe von "Das war keine
Zahl." passiert im normalen Programmablauf.
7 Datentypen
Übersicht:
Tuple
t=(1, 2, 3)
Unveränderbare Liste
Liste
l=[1, 2, 3]
Veränderbare Liste
Dictionary
d={1: "eins", 2: "zwei", 3: "drei"}
Auch Array genannt
7.1
Tuples und Listen
Tuples können nicht verändert werden. Sie sind statisch. Man kann aber einzelne
Einträge auslesen, wie bei den Listen.
Listen sind veränderbar, dynamisch. Es können beliebige Listeneinträge hinzugefügt
oder entfernt werden. Die Länge muss nicht wie in vielen anderen
Programmiersprachen vorher definiert (dimensioniert) werden.
Dir sind oben schon Listen begegnet. Zum Beispiel [0,1,2,3,4,5,6] und ['Sonne',
'Mond', 'Sterne']. Die erste Liste kann man auch mit range(7) erzeugen.
l=list(range(7))
Listen kommen aber auch noch an anderen Stellen vor. In anderen
Programmiersprachen wird eine Liste oft mit dem englischen Wort Array bezeichnet.
In Listen dürfen auch verschiedenartige Dinge stehen.
mix = ['Mozart',1756,1791,'Musiker','Salzburg']
Wenn man mit einer Liste arbeiten will, dann braucht die Liste einen Namen.
planeten = ['Merkur','Venus','Erde','Mars']
Um auf das zweite Element aus der Liste zuzugreifen und es auf dem Bildschirm
auszugeben, schreibt man folgende Zeile ins Programm:
10
print(planeten[1])
Achtung: das erste Element einer Liste hat die Nummer 0!
Um in der Liste "Mars" durch "Milky Way" zu ersetzen, geht man so vor:
planeten[3] = 'Milky Way'
Benutzung von Listen
Wie man mit Listen umgeht, kannst du sehr gut mit der folgenden Übersicht
verstehen:
Beispielliste: a = ['das', 'macht', 'spaß', 250], text ='Hallo Welt'
Befehl
Ausgabe mit print()
b=a
>>> ['das', 'macht', 'spaß', 250]
x=len(a)
>>> 4
b=a[0]
>>> das
b=a[-1]
>>> 250
b=a[::-1]
>>> [250, 'spaß', 'macht', 'das']
b=a[1:3]
>>> ['macht', 'spaß']
a.append('!!')
>>> ['das', 'macht', 'spaß', 250, '!!']
a.insert(2,'ja')
>>> ['das', 'macht', 'ja', 'spaß', 250]
a.remove('das')
>>> ['macht', 'spaß', 250]
x=a.index('spaß')
>>> 2
a[1:3]=[]
>>> ['das', 250]
a[:]=[]
>>> []
z=a[3]+9
>>> 259
b=a[2]+a[0]
>>> spaßdas
a[1]='ist'
>>> ['das', 'ist', 'spaß', 250]
c=list('HALLO')
>>> ['H', 'A', 'L', 'L', 'O']
c.reverse()
>>> ['O', 'L', 'L', 'A', 'H']
c.sort()
>>> ['A', 'H', 'L', 'L', 'O']
t=text.split()
>>> ['Hallo', 'Welt']
x=c.count('l')
>>> 2
Wortliste in Satz (String) umwandeln:
Satz (String) in Wortliste umwandeln:
satz=' '.join(liste)
liste=satz.split()
Aufgaben 6, 7, 30 - 32
11
7.2 Wörterbücher
Hier ein paar Beispiele für Wörterbücher (Dictionaries).
vokabeln = { 'Haus' : 'house', 'Wohnung' : 'flat', 'eben' : 'flat',
'Küche' : 'kitchen' }
telefonbuch = { 'Hans K.' : '0511 1596374', 'Lena Z.' : '0551 35674',
'Andreas M.' : '030 69753', 'Kerstin Sch.' : '0431 749253' }
zahlen = {1 : 'one', 2 : 'two', 3 : 'three', 4 : 'four' }
In einem Wörterbuch kann hinter dem Doppelpunkt mehrmals das gleiche stehen. Vor
dem Doppelpunkt darf das nicht sein. Das erste Wörterbuch wäre also umgekehrt mit
den englischen Wörtern an erster Stelle nicht erlaubt, weil zweimal 'flat' vorkommt.
Das was vor dem Doppelpunkt steht heißt Schlüssel. Der Eintrag hinter dem
Doppelpunkt wird Wert genannt.
Benutzung von Wörterbüchern
Eintrag ändern, Eintrag zu einem Wörterbuch hinzufügen:
vokabeln['Wohnzimmer'] = 'living room'
telefonbuch['Rolf Z.'] = '0251 4598349'
Wenn es vorher schon einen Rolf Z. im Wörterbuch gab, wird kein zweiter hinzugefügt,
sondern die Nummer geändert.
Eintrag aus einem Wörterbuch löschen:
del vokabeln['flach']
Im Wörterbuch nachschlagen:
print ('Die Telefonnummer von lna ist', telefonbuch['lna Z.'])
Auf diese Weise kann man nur zu dem was vor dem Doppelpunkt steht auf das was
hinter dem Doppelpunkt steht zugreifen. Nicht umgekehrt.
Überprüfen, ob ein Eintrag im Wörterbuch steht:
if 'Kerstin Sch.' in telefonbuch:
print ('Die Telefonnummer von Kerstin Sch. lautet')
print (telefonbuch['Kerstin Sch.'])
else:
print ('Kerstin Sch. ist nicht im Telefonbuch')
Aufgabe 34
8. Funktionen und Prozeduren
Python unterscheidet nicht zwischen Prozeduren und Funktionen.
Beide werden mit def name() definiert.
Funktionen:
Python enthält viele Standardfunktionen. Du kannst aber auch eigene Funktionen
12
definieren.
def summe(a,b):
return(a+b)
def wurzel(zahl):
w=zahl**(1/2)
return (w)
def A_quadrat(a):
A=a*a
return(A)
print (summe(3,4))
print (wurzel(16))
print (A_quadrat(9))
x=wurzel(4)*5
print(x)
return() gibt den Wert der Funktion zurück.
Funktionen müssen bekannt sein, bevor sie benutzt werden. Zeilen, die Funktionen
oder Prozeduren benutzen, müssen unterhalb bzw. am Programmende stehen.
Alle klar? Probiere einfach ein paar eigene Funktionen aus.
Prozeduren:
In Prozeduren werden bestimmte Aufgaben in einem Programmblock
zusammengefasst. Sie werden genauso geschrieben wie Funktionen.
def zeichneViereck():
print(10*'#')
for i in range(8):
print('#',8*' ','#')
print(10*'#')
Die Prozedur wird mit dem Namen aufgerufen. Wenn keine Variable übergeben
werden soll, muss eine leere Klammer geschrieben werden.
zeichneViereck()
Auch hier erfolgt der Aufruf unterhalb der Prozedur.
Mit Parameter:
def zeichneViereck(größe):
print((größe*'#')
for i in range(größe-2):
print('#',(größe-4)*' ','#') # warum -4?
print(größe*'#')
Die Ausführung der Prozedur erfolgt mit
zeichneViereck(20) # experimentiere mit unterschiedlichen Parametern
Aufgaben 20 – Ende
13
9. Module
Der Befehlsumfang von Python kann durch eine Vielzahl von Modulen erweitert
werden. Zum Beispiel um viele mathematische Funktionen:
from math import *
print(sqrt(16))
Mit dem Modul random kannst du Zufallszahlen oder Zufallslisten erzeugen:
from random import *
for i in range(6):
print (randint(1,6), end=' | ')
namensliste = ['Peter', 'Susanne', 'Anne', 'Hans', 'Tanja']
shuffle(namensliste)
# mischt Elemente der Liste
for text in namensliste:
print (text,end=', ')
a=choice(namensliste)
print()
print(a)
# wählt zufällig ein Element der Liste
#neue Zeile statt ,
Mit dem Modul time erhälts die Zeit- und Datumserweiterugen.
from time import *
sleep(3) # Das Programm wartet 3 Sekunden
Das Modul turtle hast du schon zu Beginn der Einführung kennen gelernt.
from turtle import *
Für dieses Modul gibt es eine eigene Einführung.
Im Internet erhältst du mit den entsprechen Suchbegriffen für fast jedes Problem
Erweiterungen und Hilfen zu Python.
10 Dateien – ohne Worte
datei=open('i:/test/text.txt','w')
# öffnet Datei zum Schreiben (w)
for i in range(10):
datei.writelines(str(i)+'. Zeile'+'\n') # \n erzeugt neue Zeile
datei.close()
# schließt Datei
datei=open('i:/test/text.txt','a')
# öffnet Datei zum Anhängen (a)
for i in ['Sonne', 'Mond', 'Sterne']:
datei.write(str(i)+'\n')
datei.close()
datei=open('i:/test/text.txt','r')
inhalt=datei.read()
datei.close()
print(inhalt)
# öffnet Datei zum Lesen (r)
# Lies die gesamte Datei
Aufgabe 34
14
11. Quellen:
Internet:
Bernd Grave, 2007: Programmieren mit Python – Erste Schritte
http://www.uni-math.gwdg.de/bgr/informatikunterricht.php
Bernd Hengelein u. a., 2005: A Byte Of Python, deutsche Übersetzung
http://abop-german.berlios.de/read/
Thomas Güttler: Python, Programmieren macht Spaß
http://www.thomas-guettler.de/vortraege/python/einfuehrung.html
Walter Spiegel: Programmieren in Python
http://www.wspiegel.de/pykurs/pykurs.htm
Gregor Lingl, 2003: Einstieg ins Programmieren mit Python
http://ada.rg16.asn-wien.ac.at/~python/Py4KidsFolien1.ppt
http://docs.python.org/3.1/tutorial/index.html
12. Aufgaben
1.
Schreibe ein Programm, das den Computer dazu veranlasst folgendes zu tun:
Der Computer fragt dich nach deinem Namen. Wenn du deinen Vornamen
eingegeben hast, reagiert der Computer und schreibt "Hallo name, wie geht es
dir?". Wenn du einen anderen Namen eingegeben hast, dann reagiert der
Computer und schreibt "name, ich kenne dich nicht. Dies ist nicht dein
Computer."
2.
Das Programm fragt nach dem Vornamen, Nachnamen, und dem Alter und gibt
folgendes aus: „Hallo vorname nachname, du bist alter Jahre alt.“
3.
Der Name und das Alter des Benutzers soll abgefragt werden.
a) Es soll folgendes ausgegeben werden:
alter< 6: „name, kannst du schon lesen?“
alter>15 und alter <18: „name, du darfst den Mofaführerschein machen“
alter>=18: „name, du darfst den Führerschein B machen“
in allen anderen Fällen: 10 mal „Milchbubi“
b) Erfinde weitere Fälle und Texte
4.
Das Programm soll den Bodymassindex mit folgender Formel berechnen:
Gewicht (kg)
BMI = -------------------Größe² (m)
a) Ausgabe: „name, dein BMI ist bmi“
b) Die Ausgabe soll entsprechend der BMI-Tabelle bewertet werden.
5.
a) Das Programm soll nach zwei Zahlen fragen und die größe Zahl ausgeben.
b) Das Programm soll nach drei Zahlen fragen und den arithmetischen Mittelwert
ausgeben
c) Die Ausgabe soll mit erklärendem Text versehen werden.
6.
a) Die Buchstaben eines Wortes sollen untereinander ausgegeben werden.
15
b) Die Buchstaben eines Wortes sollen g e s p e r r t ausgegeben werden.
c) Die Buchstaben eines Wortes sollen rückwärts ausgegeben werden.
d) Wenn das Wort ein Palindrom (LAGER-REGAL) ist, soll eine entsprechende
Ausgabe erfolgen.
e) Es soll ausgegeben werden, wie viele Vokale im Wort enthalten sind.
f) Es sollen alle Vokale durch ein 'i' ersetzt werden.
g) Das Wort soll mit ASCII-Code ausgegeben werden.
h) Ein Wort soll nur mit Großbuchstaben/Kleinbuchstaben angezeigt werden.
i) Löse die oberen Aufgaben mit dem Datentyp Liste.
7.
Schreibe eine Prozedur, mit dem ein Satz eingegeben werden kann und folgendes
ausgegeben wird:(Einfacher geht’s mit den Datentyp Liste)
a) Der Satz ….. hat … Buchstaben.
b) Das 4. Wort ist: …...
c) Der Satz hat … Wörter.
d) Die Wörter eines Satzes sollen gemischt werden.
e) Alle Buchstaben eines Wortes sollen vermischt werden.
f) Bis auf den ersten und letzten Buchstaben sollen alle Buchstaben des Wortes
vermischt werden
8.
a) Erzeuge mit range() eine Liste für einen Countdown.
b) Erzeuge mit range() ein liste von ganzen Zahlen von -10 bis 10.
9.
a) Es sollen die Zahlen 1-50 untereinander ausgegeben werden.
b) Es sollen nur die geraden Zahlen bis 50 ausgegeben werden.
c) Es sollen nur die Vielfachen von 10 ausgegeben werden (bis 500 ).
10. Der Computer soll von 100 bis 120 zählen
a) Die Zahlen werden untereinander ausgeben
b) Die Zahlen werden nebeneinander ausgeben (durch Komma getrennt).
c) Es sollen die Zahlen von 1 bis n nebeneinander ausgegeben werden. Die letzte
Zahl n wird vom Benutzer über n=input() eingegeben.
11. Erzeuge eine Tabelle der ersten 25 Quadratzahlen.
Ausgabe: 1² = 1, 2² = 4, 3² = 9, 4² = 16, …. oder untereinander.
12. Schreibe ein Programm, das 13 mal "Viel Glück!" wünscht.
13. Überlege, welche Ausgabe das folgende Programm auf dem Bildschirm erzeugt.
Prüfe, ob du richtig gelegen hast.
for i in range(10):
print (i, '* 17 =' i*17)
14. Schreibe ein Programm, das alle Multiplikationen des kleinen Einmaleins auf dem
Bildschirm ausgibt.
15. a) Schreibe ein Programm, das die Summe der natürlichen Zahlen von 1 bis 100
berechnet.
b) Der Benutzer legt die Endzahl n fest.
16. Schreibe ein Programm, das immer wieder eine Tastatureingabe erwartet ,
einliest und ausgibt bis Ende eingetippt wird.
17. Schreibe ein Programm, das immer wieder die Eingabe eines Wortes mit 5
Buchstaben fordert und erst Ruhe gibt, wenn es eine Eingabe aus 5 Zeichen
bekommen hat.
16
18. Schreibe ein Lernprogramm:
a) Eine Additionsaufgabe wird solange gestellt, bis die richtige Antwort
eingegeben wird.
b) Es sollen 5 Aufgaben gestellt werden und die Zahlen im Bereich 1-10 jeweils
zufällig erzeugt werden. (from random import *, randint(1,10)).
c) Die Anzahl der Fehler soll gezählt werden und am Ende der Übung angezeigt
werden.
19. Programmiere ein kleines Quiz. Dabei soll das Programm die Fragen stellen und
erkennen, ob die eingegebene Antwort richtig oder falsch ist und entsprechend
reagieren.
20. Schreibe ein Menü, mit dem der Benutzer deine Prozeduren aufrufen kann.
21. a) Schreibe die Prozedur Aquadrat, mit der die Seitenlänge des Quadrats vom
Benutzer eingegeben und der Flächeninhalt berechnet und ausgegeben wird
b) Schreibe ebenfalls Prozeduren für Uquadrat, Urechteck, Arechteck.
c) Schreibe eine Funktion differenz(a,b) die die Differenz der Zahlen a und b
zurückgibt. print(differenz(3,4)) >>> 7
d) Schreibe eine Funktion rom(d) die eine römische Zahl zurückgibt (bis 10).
print(rom(6)) >>> VI
e) Schreibe die Funktion gross(text). print(gross('hallo') >>> HALLO
f) Programmiere weitere Funktionen.
22. a) Eine Prozedur addieren soll zwei Zahlen von der Tastatur einlesen (INPUT),
ihre Summe berechnen und das Ergebnis auf dem Bildschirm ausgeben (PRINT).
b) Schreibe eine Prozedur multiplizieren.
c) Schreibe eine Prozedur quader, die das Volumen und die Oberfläche eines
Quaders berechnet.
23. Spiele die folgenden Anweisungen mit einem Partner durch und übersetze es in
Python.
wiederhole 10 mal
wähle eine Zahl zwischen 1 und 10 und nenne sie a
wähle eine Zahl zwischen 10 und 20 und nenne sie b
wiederhole folgende Anweisungen bis das ergebnis richtig ist
Schreibe eine Malaufgabe aus den Zahlen a und b auf
Lass Partner das Ergebnis der Aufgabe eingeben
schreibe: "Prima, du hast fleißig das Einmaleins geübt!"
24. Es soll die Höhe der monatlichen Stromkosten eines 4 - Personenhaushalts mit
Hilfe des Computers ausgerechnet werden.
Nach Eingabe des Verbrauchs in Kilowattstunden berechnet der Computer die
Höhe der monatlichen Stromkosten.
Tarife findest du im Internet.
25. a) Schreibe eine Prozedur wertetab, mit der der Computer für dich das
Ausrechnen der Funktionswerte nach Eingabe von x für folgende Funktionen
übernimmt:
f1: y = 0.5 x – 1.4
f2: y = 0.23 x² + 3.45
f3: y = 2/7 x -5/9
b) Verbessere die Prozedur, indem du 15 Werte von x = -7 bis x= +7 der
Funktion f1 errechnen und ausgeben lässt.
Die Werte sollen tabellarisch untereinander ausgegeben werden.
17
26*. Entwirf eine Prozedur, mit der man die Lösungsmenge eines Gleichungssystems
berechnen kann, wenn die Gleichungen in folgendender Form
I.
y = m 1X + b 1
II.
y = m 2X + b 2
Es sollen die Parameter m1, m2, b1, b2 eingegeben werden und das Ergebnis in
der Form L={(x,y)} ausgegeben werden.
Hinweis: Subtrahiere die Gleichungen I und II, um eine Formel für den x-Wert zu
finden. Du erhältst eine Formel für y, indem du x in die erste Gleichung einsetzt
Für die folgenden Aufgaben benötigst du randint(1,6) aus dem Modul random.
27. a) Es soll so lange 'gewürfelt' werden und das Ergebnis angezeigt werden, bis
eine sechs gewürfelt wird.
b) Es soll zum Schluss die Anzahl der 'Würfe' angezeigt werden.
28. a) Der Computer soll 1 mal würfeln. Fällt eine 6, soll er "Gratuliere, gewonnen!"
schreiben, sonst : "Leider verloren!"
b) Er soll bei 6 oder 1 "Gratuliere, gewonnen!" schreiben
29. a) Der Computer wählt zufällig eine Zahl zwischen 1 und 10, die du erraten
sollst.
b) Der Computer soll solange würfeln, bis die Augensumme aller Würfe größer
oder gleich 100 ist.
c) Die Anzahl der Würfe und das Zwischenergebnis sollen nebeneinander
ausgegeben werden.
d) Die Augensumme soll vorher mit INPUT erfragt werden.
e) Die Prozedur soll so erweitert werden, dass dem Rater der Hinweis "Meine
Zahl ist kleiner" bzw. "Meine Zahl ist größer" gegeben wird. Die gedachte Zahl
soll zwischen 1 und 1000 liegen.
30. Schreibe ein kurzes Sortierprogramm:
a) Es sollen mindestens zwei Wörter eingegeben werden, die alphabetisch
sortiert, hintereinander, mit Komma getrennt, ausgegeben werden.
31. Probiere die Listen-Methoden für eine Namensliste aus.
namensliste = ['Peter', 'Susanne', 'Anne', 'Hans', 'Tanja']
for text in namensliste:
print ('Der Name', text,)
print ('besteht aus', len(text) , 'Buchstaben.')
32. Gib einen beliebigen Satz ein.
a) Es soll die Anzahl der Wörter ausgegeben werden.
b) Es sollen alle Wörter vermischt angezeigt werden
c) Der Satz soll rückwärts angezeigt werden.
d) Es soll das zweite Wort angezeigt werden.
33. Gedächtnisspiel: Der Computer wählt zufällig eine Ziffer zwischen 0 und 9. Diese
Ziffer wird kurz auf dem Bildschirm angezeigt und der Spieler wird aufgefordert
diese Ziffer einzugeben. Bei richtiger Lösung hängt der Computer eine neue Ziffer
an die vorhergehenden an und zeigt sie wieder kurz.
Nach Eingabe einer falschen Ziffernfolge endet das Programm mit einer Wertung.
Verwende als Ausgabefenster das Turtle-Fenster:
18
from turtle import *
Statt print('text') verwende write('text')
Statt e=input('Eingabe: ') verwende e=textinput('Eingabe: ')
Für die Pause verwende sleep(3) aus dem Modul time
34. Schreibe ein Vokabellernprogramm mit folgenden Funktionen:
a) Eingabe neuer Vokabeln
b) Abfrage von Vokabeln (lernen)
c) Speichern der Vokabeln in einer Datei
d) Ändern und ergänzen von Vokabeln
35. Schreibe ein Geometrieprogramm, das die Berechnung von Volumen und
Oberfläche folgender Körper übernimmt:
Quader, Zylinder, Kegel, Pyramide, Kugel
a) Der Benutzer gibt die Maße ein und V und O werden ausgegeben.
b) Der Benutzer gibt gegebene Größen ein und die fehlenden Größen werden
berechnet und ausgegeben.
c) Der Körper wird zusätzlich maßstabsgerecht gezeichnet.
36. a) Das Programm soll den Body-Mass-Index des Benutzers berechnen.
Formel:
Gewicht (kg)
BMI = -------------------Größe² (m)
b) Das Programm soll folgende Rückmeldungen geben:
Untergewicht, Normalgewicht, Übergewicht, Adipositas, starke Adipositas.
c) BMI unter 17 und BMI über 30: Bitte suche umgehend einen Arzt auf
d) Vergleich mit optimalen BMI nach Alter
BMI m.
BMI w.
Alter
optimaler BMI
Untergewicht
unter 20
unter 19
19-24
19-24
Normalgewich
t
20-25
19-24
25-34
20-25
Übergewicht
26-30
25-30
35-44
21-26
Adipositas
31-40
31-40
45-54
22-27
starke
Adipositas
größer 40
größer 40
55-64
23-28
älter als 64
24-29
19