3. Pool-Übung zum Modul „Einführung in die Informatik“

TU Bergakademie Freiberg
Institut für Informatik
Modul „Einführung in die Informatik“
Poolübung
3. Pool-Übung zum Modul „Einführung in die Informatik“
- Aufgaben Thema: Programmieren in Python, Teil 1
(Selektion und Schleifen; einfache Typen; noch ohne gesonderte Funktionen)
0)
Vorbereitende Übungen im interaktiven Modus von Python
(mit IDLE oder Konsole)
(VOR der Übung durchzuarbeiten)
siehe Anhang A
---------------------------------------------------------------------------------------------------------------------------(Nochmals der Hinweis:
Groß- und Kleinschreibung ist in Python signifikant.)
1) Volumen und Oberfläche einer Kugel (vergleiche Aufg. zu Struktogrammen, Aufg. 1 )
Korrektur eines gegebenen fehlerhaften Quelltexts (mit der IDLE)
- Gegeben ist ein fehlerhaftes Python-(Haupt-)Programm (ohne Funktion) auf1_KugelMitFehlern.py
(siehe Übungsverzeichnis) für die Berechnung des Volumens und der Oberfläche einer Kugel.
Darin wird Folgendes behandelt:
-- Eingabe eines reellen Radius r (r>=0) (hier ohne Prüfung auf Eingabefehler)
-- Berechnung der Oberfläche s = 4*pi*r2 und des Volumens v = 4/3*pi*r3
(dabei wird pi aus dem Modul math verwendet)
-- Ausgabe der berechneten Ergebnisse
Der Python-Quelltext auf1_KugelMitFehlern.py enthält sowohl syntaktische als auch semantische
(logische) Fehler.
-------------------Hinweise dazu:
(1) Öffnen Sie den fehlerhaften Quelltext auf1_KugelMitFehlern.py mit der IDLE (File/Open), und
speichern Sie dieses File in Ihr Python-Arbeitsverzeichnis (z.B. Z:\Python oder W:\Python).
(2) Suchen Sie mit Run/Check Module nach syntaktischen Fehlern und korrigieren Sie diese.
Ein „Syntax error“-Fenster meldet gefundene Syntaxfehler. Klicken Sie auf OK. Ein roter Kursor steht
dann an der Stelle im Quelltext, wo Python den Fehler erkennen konnte. Der Fehler selbst befindet
sich unter dem Kursor oder davor. Korrigieren und überspeichern Sie den Quelltext.
(Auch mit Run/Run Module werden diese Syntaxfehler gemeldet.)
(3) Wenn keine syntaktischen Fehler mehr gefunden werden (d.h. wenn der schwarze Kursor in der
Python Shell erscheint), ist über Run/Run Module nach semantischen Fehlern im Quelltext zu suchen.
- Die Fehlermeldungen erscheinen jetzt im Python Shell-Fenster. Studieren Sie die Fehlermeldung,
korrigieren Sie diese Fehler, und überspeichern Sie den Quelltext.
- Auch wenn keine Fehlermeldungen mehr erscheinen, kann das Programm noch logisch falsch sein
(z.B. eine falsche Formel - wie in unserem Beispiel - die der Interpreter natürlich nicht erkennen
kann). Dazu muss man das Programm mit überlegt gewählten Eingabewerten (hier z.B. r=1) und bekannten Resultaten testen, ob das Programm auch diese Resultate erzeugt.
Mit dem Taschenrechner erhält man leicht, dass z.B. für r=1 folgende Resultate korrekt sind:
Oberflaeche = 12.57
Volumen
= 4.19
Prüfen Sie, ob das Programm diese Resultate erzeugt.
---------------------------------------------------------------------------------------------------------------------------1
1008
(Achtung:
Blöcke sind in Python stets einzurücken, z.B. auch der Block einer if-Anweisung.)
2) Bestimmung des Wertes eines Maximums (vgl. Struktogramme, Aufg. 3) (mit IDLE)
Achtung:
In dieser Aufgabe ist NICHT die Python-Standardfunktion max( ) zu benutzen!
a) Schreiben Sie ein Python-(Haupt-)Programm (ohne Funktion) für die Bestimmung des maximalen
Wertes zweier beliebiger (d.h. ganzer oder reeller) Zahlen.
(einfache Selektion)
b) Schreiben Sie ein Python-(Haupt-)Programm (ohne Funktion) für die Bestimmung des maximalen
Wertes dreier beliebiger Zahlen.
(geschachtelte Selektion)
Öffnen Sie zur Lösung von 2.b) in der IDLE (Python Shell) mit File/Open... den unvollständigen
Lösungs-Quelltext auf2b_unvollstaendig.py aus dem Übungsverzeichnis der Poolübung 3, und ergänzen Sie ihn.
----------------------------------------------------------------------------------------------------------------------------
3)
Tabellieren einer Funktion (Quadratwurzel; Abweis- und Zählschleife)
- Vorbereitende Übung zu Aufgabe 3) im interaktiven Modus von Python
(vor der Übung durchzuarbeiten)
siehe Anhang B
--------------------------------------------------
y=2 x
Die Funktion
ist im Bereich 1 <= x <= 20 mit der Schrittweite 1 zu tabellieren. Die
Ausgabe der Quadratwurzel soll mit 8 Stellen nach dem Dezimalpunkt erfolgen. Benutzen Sie für die
Quadratwurzel einer ganzen oder reellen Zahl x (x>=0) die Funktion sqrt(x) aus dem Modul math.
(vgl. Struktogramme, Aufg. 6)
a)
b)
mit einer Abweisschleife
mit einer Zählschleife
(while-Anweisung)
(for-Anweisung)
Hinweis: Die Bildschirmausgabe soll etwa in folgender Weise geschehen:
x
Quadratwurzel(x)
-----------------------------------------------1
1.00000000
2
1.41421356
usw.
-------------------------------------------------------------------------------------------------------------------------
4*)
Hausaufgabe 1: Tabellieren einer weiteren Funktion
(mit IDLE)
(vgl. Struktogramme, Aufg.7)
3x + 4
ist im Bereich xa <= x <= xe mit der Schrittweite xs zu tabellieren (mittels
2x − 1
einer Abweisschleife, d.h. einer while-Anweisung). Dabei sind die beliebigen reellen Werte für den
Anfangswert xa, den Endwert xe und die Schrittweite xs im Programm einzulesen. Beachten Sie die
Polstelle der Funktion (eine Funktionswertberechnung an der Polstelle x=0.5 ist nicht möglich).
-------------------------------------------------------------------------------------------------------------------------
Die Funktion y =
2
1008
5*)
Hausaufgabe 2: Ein simulierter Minicomputer
(mit IDLE)
(vgl. Struktogramme, Aufg. 4)
Schreiben Sie ein Python-(Haupt-)Programm für einen simulierten "Minicomputer", der einfache
<operand_1> <operator> <operand_2>
arithmetische Ausdrücke der Form
in folgender Weise berechnet (mit geschachtelter Selektion; Python kennt keine Fallauswahl):
- Einzugeben sind:
1. und 2. Operand, Operator
- Zugelassene Operatoren:
-- Addition:
+
-- Subtraktion:
-- Multiplikation:
* oder .
(d.h. Stern oder Satzpunkt)
-- Division
/ oder :
(d.h. Slash oder Doppelpunkt)
- Fehlerausschriften bei Division durch 0
sowie wenn ein nicht zugelassener Operator eingegeben wurde
- Die Ergebnisausgabe soll nur einmal im Programm erfolgen.
(Hinweis: Verwenden Sie statt der ganzzahligen Variablen ok im Struktogramm in Python besser eine
logische Variable ok (Python-Datentyp bool).)
- Testen Sie unbedingt die semantische Korrektheit durch gut gewählte Testbeispiele:
Sie sollten das Programm mit jedem Operator testen sowie auch einmal einen unzulässigen Operator
eingeben.
-------------------------------------------------------------------------------------------------------------------------
Eventuelle zusätzliche Hausaufgaben:
Aufgaben, die in der 3. Pool-Übung nicht geschafft werden, sind als zusätzliche Hausaufgaben zu
lösen.
-------------------------------------------------------------------------------------------------------------------------
Anhang A:
Vorbereitende Übungen im interaktiven Modus von Python (mit IDLE oder Konsole)
(VOR der Übung durchzuarbeiten)
Eine Einführung in die Python-Standardsoftware und in den interaktiven Modus von Python mit ersten
Übungen (arithmetische, logische und Zeichenkettenausdrücke, Python-Standardfunktionen sowie
Standardausgabe mit der Anweisung print) erfolgte in der 2. Poolübung.
Der interaktive Modus von Python (Interpreter-Fenster) eignet sich hervorragend, um schnell
Anweisungen zu testen. Man erhält sofort vom Python-Interpreter ein Resultat (manchmal aber auch
eine Fehlermeldung …).
Testen Sie die folgende Anweisungen im interaktiven Modus (Empfehlung: mit Python-IDLE):
a)
Aufruf ausgewählter mathematischer Funktionen aus dem Modul math
>>>import math
>>>math.e
#Eulersche Zahl e
>>>math.exp(3)
#e3
#Oder anders:
>>>from math import e
>>>e
>>>exp(3)
#Fehler! (nur e importiert)
#Oder anders:
>>>from math import *
#In Programmen i. Allg. nicht
#zu empfehlen wegen moeglicher Namenskonflikte
3
1008
>>>exp(3)
>>>pow(5.1,4)
>>>log(e)
>>>log10(1000)
>>>pi
>>>sqrt(100.0)
>>>sin(pi/2)
>>>fabs(-23.5)
#e3
#5.14
#ln(e)
#10log(1000)
#Die Zahl π
#Quadratwurzel aus 100.0
#Sinus
#Absolutwert einer Zahl (als Gleitkommazahl)
b)
Zuweisungen, Standardausgabe und formatierte Ausgabe mit print
>>>x=3.66666
#Zuweisung in Python intern anders als in prozeduralen Sprachen
#wie C und Pascal: Der Wert 3.66666 wird in einen Speicherbereich der
#Objekte (Daten) gespeichert, der Name x zusammen mit einem Verweis
#(„Adresse“) auf den Wert in einen anderen Speicherbereich.
#Kurz: Die Zuweisung bindet Namen (über Referenzen) an Objekte (Daten).
>>>x
#Ausgabe der ins Dezimalsystem konvertierten internen Zahlendarstellung
>>>id(x)
#Ausgabe des zum Namen x gehörenden Verweises auf den zugehörigen Wert
# Zu print( ): siehe auch Formatierte Ausgabe mit print in Python.pdf im Übungsverzeichnis
>>>print x
#Standardausgabe des Wertes von x auf Bildschirm (so viele Stellen nach
#Dezimalpunkt, wie vorhanden; bei mehr als 10 Stellen gerundet auf 11.Stelle nach dem Punkt)
>>>print "%8.4f" %x
#Formatierte Ausgabe im Datenfeld der Breite 8 mit 4 Stellen
#nach dem Dezimalpunkt (gerundet auf 4. Stelle nach dem Punkt)
#--> Rundung gemäß der internen Zahlendarstellung (siehe oben)
>>>print "%.5f" %x
#Formatierte Ausgabe mit 5 Stellen nach dem Dezimalpunkt
#(gerundet; vor dem Punkt so viele Stellen wie notwendig)
>>>print x,y
#Standardausgabe zweier Werte (getrennt durch ein Leerzeichen!)
>>>print "%.2f %.4f" %(x,y)
#Formatierte Ausgabe zweier Werte;
#Leerzeichen zwischen Formatangaben beachten!
>>>print "%.2f\n%.4f" %(x,y) #\n … Steuerzeichen Newline, d.h. Zeilenwechsel
>>>print x
#bisheriger Wert:
3.66666
4.66666
>>>x=x+1
#zugewiesen wird:
>>>print x
#aktueller Wert:
4.66666
>>>zkette="Freiberg"+"er"
#Konkatenation von Strings
>>>print zkette
#Standardausgabe des Wertes der Variablen zkette
>>>print zkette[0],zkette[9] #Ausgabe des 1. und letzten Zeichens von zkette;
#dazwischen fügt print ein Leerzeichen ein!
>>>komp1 = (2+4j)
>>>komp2 = (7+6j)
>>>print komp1+komp2
#komplexe Zahl zuweisen
#Standardausgabe der Summe zweier komplexer Zahlen
c)
Eingabe von Tastatur mit input()
>>>input("Reelle Zahl eingeben: ")
#Eingabe einer reellen Zahl von Tastatur
#Als Prompt wird ausgegeben: Reelle Zahl eingeben:
>>>input()
#Eingabe einer Zahl von Tastatur ohne Prompt (!)
>>> i=1
>>> input("Eingabe von x[%i]: " %i)
#in der input-Klammer:
#eine Zeichenkette oder eine formatierte Ausgabe
4
1008
>>>input("String eingeben: ") #Ein String muss mit input( )
#in Hochkommata (!!!) eingeben werden, sonst Fehler!
>>>a=input("Ganze Zahl eingeben: ")
#Zuweisung der Eingabe an a
>>>print a
#Standardausgabe des Wertes von a
>>>(a,b)=input("Zwei bel. Zahlen eingeben (Trennzeichen: Komma): ")
#Die Tupelklammer kann entfallen:
a,b=input("...")
>>>print a,b
#Standardausgabe der Werte von a und b (getrennt durch ein Leerz.)
>>>zk=raw_input("Zeichenkette eingeben: ")
#Eingabe eines raw-String (ohne Hochkommata!) von Tastatur und Zuweisung an zk
>>>print zk
#Standardausgabe des Wertes von zk
d)
if-Anweisung (Selektion)
>>>if 6>9:
#alle 4 Zeilen hinter ein Prompt!
print 6
#True-Zweig
else:
print 9
#False-Zweig
----------------------------------------------------------------------------------------------------------------------------
Anhang B:
Testen Sie die folgenden Schleifenanweisungen interaktiv im Shell-Window der IDLE,
und erläutern Sie, was abgearbeitet wird:
>>>list1=[1,2,3,4,5,6,7,8,9,10]
#Liste an list1 zuweisen
>>>list1
>>>for i in list1:
#for-Schleifenkopf (“Zaehlschleife”)
print i
#Eingerueckter Schleifenkoerper (Block)
>>>for i in range(1,11):
print i
#Zaehlschleife von 1 bis 10 (!!)
#mit der Standard-Schrittweite 1
>>>print range(1,11)
#range() erzeugt eine Liste mit
#den Listenelementen 1 bis 10
#Beginn der Liste jetzt bei 0
>>>print range(11)
>>>print range(2,20,2)
>>>print range(20,2,-2)
#########
>>>i=1
>>>while i<=10:
print i
i=i+1
#########
>>>while 0:
print "Hallo"
#########
>>>while 5:
print "Hallo"
#Anfangswertzuweisung (Anweisung 1)
#Abweisschleifenkopf (Anweisung 2)
#Abweisschleifenkoerper (2 Zeilen)
#Erhoehung der "Zaehlgroesse" i
#Zahl 0 wird als False interpretiert
# Schleifenblock wird 0-mal abgearbeitet!
#oder auch:
while False:
#Jede Zahl ungleich 0 wird als True interpretiert
# Endlosschleife! Abbruch mit Shell/Restart Shell
#oder auch:
while True:
5
1008