Aufgaben (mit Lösung) - TU Bergakademie Freiberg

TU Bergakademie Freiberg
Institut für Informatik
Modul „Einführung in die Informatik“
Poolübung
2. Pool-Übung zum Modul „Einführung in die Informatik“
Aufgaben (mit Lösung)
Thema:
Erste Schritte in Python
Besondere Probleme der Poolübungen und speziell der 2. Poolübung:
- Die sieben Poolübungen erstrecken sich jeweils über zwei Wochen. Der Inhalt der Poolübungen
bezieht sich stets auf den Stand der Vorlesung zum Zeitpunkt der ersten entsprechenden Poolübung.
- Erst ab der 3. Poolübung wird die Vorlesung genügend Vorlauf bezüglich Python gegenüber der
Übung besitzen. Um trotzdem möglichst schnell mit Python arbeiten zu können, benutzen wir in der
2. Poolübung einige Sprachkonstrukte, die erst in den nächsten Vorlesungen detailliert erläutert
werden. Aus gleichem Grunde enthalten die Aufgaben zur 2. Poolübung bereits die Lösung.
Generell gilt für alle Übungen:
I)
II)
Die Aufgaben der Übungen sind gründlich vorzubereiten. Dazu ist auch die Vorlesung zu studieren.
Die Hausaufgaben sind selbstständig zu lösen
(im Rahmen der 7 Curriculum Points, d.h. der (im Mittel) 210 Aufwandsstunden für das Modul).
In der Regel kann aus Zeitgründen in den Übungen nicht auf die Hausaufgaben eingegangen
werden. (Die Lösung ist selbst durch gut gewählte Testbeispiele auf Korrektheit zu prüfen.)
III)
Alle in der Übung nicht geschafften Aufgaben sind ebenfalls Hausaufgabe.
IV)
Es ist zu empfehlen, mit den in der Übung erarbeiteten Quelltexten selbstständig zu
"experimentieren", d.h. sinnvolle Veränderungen vorzunehmen und diese wieder zu testen.
V)
Ausgewählte Lösungen der Poolübungsaufgaben sowie eine Testklausur (ohne Lösung) werden zum Ende des Semesters veröffentlicht (keine Veröffentlichung von Lösungen im WWW).
-------------------------------------------------------------------------------------------------------------------------
0) Vorbemerkung:
Python-Entwicklungsumgebungen, Compiler und Interpreter
0.1
Python Standard-Software:
Homepage:
http://www.python.org
In der Lehrveranstaltung verwenden wir im WS 2011/12 noch nicht die neue Version Python 3.x,
da das von uns verwendete Bildbearbeitungs-Modul PIL bisher vom Hersteller noch nicht an
V.3.x angepasst wurde (PIL unterstützt zur Zeit Python bis zur Version 2.7).
In den Pools RAM-2119 und KKB-2097 ist Python, Version 2.5.2, installiert.
Bei Benutzung von Lehrbüchern, die sich auf Python 3.x beziehen, ist zu beachten, dass die Neuerungen
von Version 3.x gegenüber der Version 2.x in dieser Lehrveranstaltung nicht verwendet werden. Für
unsere Lehrveranstaltung entstehen dadurch keine Nachteile.
Hinweis: Das Installationsfile python-2.5.2.msi , mit dessen Hilfe man ohne Probleme Python auf
seinem Heim-PC installieren kann, liegt im Pool auf der Festplatte unter
Y:\lehre\Modul_Einf_in_die_Informatik_WS1112_Jung\
Installationsfiles_Python und_Module\Installationsfile_Python_2_5_2
Nach der Installation auf einem Windows-PC findet man über Start/All Programs/Python 2.5
die beiden folgenden Einträge:
- IDLE (Python GUI)
… Integrated DeveLopment Environment for Python
(Der Name IDLE bezieht sich zugleich auf: Eric IDLE … Komödiant aus “Monty Python’s Flying Circus“.
Die Entwickler der Sprache waren große Verehrer dieser englischen Fernsehserie mit schwarzem Humor,
woraus sich auch die Bezeichnung „Python“ ergab.) In der Übung wird stets die IDLE benutzt.
(Das Startfile für die IDLE heißt idle.pyw und liegt im Python-Unterverzeichnis Lib\idlelib.)
- Python (command line)
… Kommandozeilen-Interpreter für Python (wird von uns nicht verwendet)
1
1011
0.2
Weitere Python-Umgebungen
Es gibt einige weitere Freeware-Entwicklungsumgebungen für Python, die in der Lehrveranstaltung allerdings nicht verwendet werden.
0.3
Dokumentationen, Tutorials usw. zu Python
Auf den Festplatten finden Sie unter Y:\lehre\Modul_Einf_in_die_Informatik_WS1112_Jung\
Pooluebungen\Ausgewaehltes_Material_zu_Python einige Tutorials, Dokumentationen usw.
Im Internet finden Sie zahlreiche weitere Materialien zu Python.
0.4
Compiler versus Interpreter
Wesentlicher Unterschied zwischen Compiler und Interpreter aus praktischer Sicht:
- Ein Compiler (Beispiel: C-Compiler) ist ein Programm, das ein Quellprogramm in einer höheren Programmiersprache vollständig in ein äquivalentes Maschinenprogramm, d.h. in die Sprache eines konkreten Hardware-Prozessors, überführt. Das Zielprogramm liegt nach der Compilierung als abarbeitbares
File vor (z. B. unter MS-Windows als abarbeitbares exe-File). Dieses vom Compiler einmal erzeugte
abarbeitbare File kann dann beliebig oft (und relativ schnell) auf dem Prozessor abgearbeitet werden,
ohne dazu noch einmal den Compiler zu benötigen.
- Ein Interpreter (Beispiel: Python) arbeitet im Gegensatz zum Compiler stückweise (etwa wie ein
Simultandolmetscher). Der Interpreter übersetzt der Reihe nach jede Anweisung des Quelltexts in
Maschinencode und arbeitet diesen zur Laufzeit sofort ab. Ein Interpreter erzeugt dabei kein
abarbeitbares Programm in der Maschinensprache (z.B. unter MS-Windows kein abarbeitbares exe-File).
Bei jeder neuen Abarbeitung des Quellprogramms wird also erneut ein Interpreter benötigt.
Der Python-Interpreter ist, genauer gesagt, ein Bytecode-Interpreter. Die Arbeitsweise eines
Bytecode-Interpreters wird im Dokument Y:\lehre\Modul_Einf_in_die_Informatik_WS1112_Jung\
Pooluebungen\Lehrfolien_zur_Uebung\Compiler und Interpreter.pdf beschrieben (siehe dort).
Ein Vorteil eines Interpreters gegenüber einem Compiler ist, dass er auch unvollständige Programme
(z.B. einzelne Anweisungen, siehe interaktiver Modus von Python!) abarbeiten kann. Damit eignen
sich Interpreter gut für Testzwecke und zur Fehlersuche. Dies werden wir auch in der Übung nutzen.
------------------------------------------------------------------------------------------------------------------------------
1)
Python im interaktiven Modus
(mit Python-IDLE)
- Öffnen Sie dann die IDLE (Python-GUI) - GUI bedeutet dabei Graphical User Interface - gemäß:
Start/All Programs/Python 2.5/IDLE (Python GUI)
- Nach dem Laden öffnet sich die Python-Shell mit ihrem Prompt (Eingabeaufforderung):
>>>
Nun kann man im interaktiven Modus des Interpreters arbeiten:
Hinter das Prompt wird jeweils eine Anweisung eingegeben (eine Python-Anweisung reicht in
der Regel bis zum Zeilenende und wird nicht durch ein besonderes Syntax-Zeichen abgeschlossen). Jede
Anweisung wird mit <ENTER> abgeschlossen und im interaktiven Modus danach sofort vom
Interpreter abgearbeitet.
Wir experimentieren jetzt damit.
(Achtung: Groß- und Kleinschreibung ist in Python signifikant!!!)
************************************************************************************
Vorwort:
Kurzerklärungen zu ausgewählten einfachen Python-Datentypen:
(1) Computer verarbeiten Daten (Objekte). Daten besitzen Typ und Wert. Ein Datentyp ist (grob gesagt)
ein festgelegter Wertebereich, aus denen die Daten Werte annehmen können. Für jeden Typ sind zugelassene Operatoren und deren Wirkung erklärt.
(2) Einige ausgewählte Typen in Python (mehr dazu in der Vorlesung):
- Ganze Zahlen (Typ „int“):
z.B. 1, 2, 5, -100, ... (hier: Dezimalzahlen!)
Python kennt auch ganze oktale Zahlen (beginnen mit 0, d.h. Null): 032, 0711, ...
und ganze hexadezimale Zahlen (beginnen mit 0x):
0x3A, 0x5c4, ...
2
1011
- Reelle Zahlen (Typ „float“):
z.B. 0.34, 4.8, 20.0, -93.66, ...
(mit Dezimalpunkt und nicht mit einem Komma!)
- Zeichenketten (Typ „string“):
z.B. 'Python', "TU Bergakademie Freiberg"
(d.h. Strings werden in einfache oder doppelte Anführungszeichen eingeschlossen)
- Logischer Typ (Typ „bool“):
mögliche Werte:
True, False
(3) Ausgewählte Operatoren:
- für Operanden vom Typ int, float: + (Addition), - (Subtraktion), * (Multiplikation), / (Division)
wenn in Ausdrücken alle Operanden vom Typ int:
Resultat auch vom Typ int (auch Division!)
wenn mindestens ein Operand vom Typ float:
Resultat vom Typ float
- nur für Operandentyp int: % (ganzzahliger Divisionsrest)
- Logische Operatoren:
and, or, not
- Vergleichsoperatoren:
== (Gleichheitszeichen in Python: zwei aufeinanderfolgende „=“)
<, <=, >, >=
************************************************************************************
a)
Ausdruckanweisungen:
Arithmetische, logische u. Zeichenkettenausdrücke
Geben Sie die folgenden Ausdruckanweisungen ein und schließen Sie diese mit ENTER ab.
Kommentieren Sie die Ausgaben des Interpreters:
Arithmetische Ausdrücke:
>>>34
<ENTER>
#34 vom Typ int
(Erklärung: alle Zeichen in derselben Zeile nach „#“ gelten als Kommentar (Erklärung)
und werden von Python nicht ausgewertet)
>>>5+83
#Ausgabe des Resultatwertes vom Typ int
>>>type(5+83)
#Ausgabe des Resultattyps (hier: int)
#Achtung: Groß- u. Kleinschreibung ist signifikant!
>>>5.0+83
>>>type(5+83.0)
>>>(2+5)*(7-3)
#Wert vom Typ float
#Ausgabe des Resultattyps (hier: float)
#Abarbeitung von links nach rechts; Klammern zuerst;
#Punkt- vor Strichrechnung (* / vor +-)
>>>2+5*7-3
#Erlaeutern Sie die unterschiedlichen Resultate
>>>22.0/5
#reellwertiges Divisionsresultat
#(mit Rundungsfehler durch Konvertierung Dezimal-> Dual und umgekehrt)
>>>22/5
#ganzzahliges Divisionsresultat
>>>22%5
#ganzzahliger Divisionsrest
>>>22/0
#Fehlerausgabe: ZeroDivisionError
>>>6*(7-4)/3-3*(6+1)
#Berechnen Sie vorher das Resultat auf dem Papier!
>>>6*7-4/3-3*6+1
#Berechnen Sie vorher das Resultat auf dem Papier!
>>>2**6
#Potenz: 26
>>>3.4**2.9
#Potenz: 3.42.9
>>>011
#Ausgabe der Oktalzahl 011 als Dezimalzahl
>>>0x1F
#oder: 0x1f; Ausgabe der Hexadezimalzahl 0x1F als Dezimalzahl
>>>0x1f-0x3
#Subtraktion zweier Hexadezimalzahlen
>>>07+01
#Addition zweier Oktalzahlen
>>>0xA*0x10
#Multiplikation zweier Hexadezimalzahlen
Logische Ausdrücke:
>>>4>=2
>>>7<5
>>>"Tag"=="Nacht"
>>>'Tag'>='Nacht'
>>>(5>3) and (8>12)
>>>5>3 and 8>12
#Zeichenketten in "..." oder '...'
#Klammern nicht notwendig, da Vergleichsoperatoren
#
vor logischen Operatoren abgearbeitet werden
1011
3
Zeichenketten-Ausdrücke:
>>>'Freiberg'
>>>"Frei"+"berg"
#String ist Sequenz von Zeichen
#Konkatenation von Strings
b)
Aufruf ausgewählter Python-Standardfunktionen (ohne Import eines Moduls nutzbar):
>>>abs(-34.6)
#Liefert absoluten Wert einer Zahl (ganz, reell oder komplex)
>>>float(4)
#konvertiert Zahl (oder Zahlenstring) in Gleitkommazahl
>>>int(19.8)
#konvertiert Zahl (oder Zahlenstring) in ganze Zahl (ganzer Anteil)
>>>pow(5.1,4)
#5.14
( Potenzfunktion; entspricht: 5.1**4 )
>>>len("Freiberg") #gibt Länge (Anzahl der Zeichen) des String zurück (len ... length)
>>>chr(67)
#Gibt Zeichen mit ASCII-Nr. 67 zurück (chr … character)
# ASCII ... American Standard Code for Information Interchange
>>>ord("B")
#Gibt die ASCII-Nr. des ASCII-Zeichens "B" zurück
c)
Standardausgabe mit der Anweisung print sowie (Wert-)Zuweisung an Variable
>>>print 459
#Standardausgabe
>>>print 34.555
#Dezimalpunkt verwenden (Komma ist Trennzeichen bei Eingabe)
>>>print 459,34.555
#Standardausgabe zweier Werte
#(Bildschirmausgabe wird getrennt durch ein Leerzeichen!)
>>>print "Freiberg"
>>>x=5.99
#Wertzuweisung an die Variable x;
# = ... Operator fuer (Wert-)Zuweisung (sprich: „ergibt sich aus“)
>>>print x
#Standardausgabe des akt. Wertes von x auf Bildschirm (so viele Stellen nach
# Dezimalpunkt, wie vorhanden; bei mehr als 12 Stellen gerundet auf 12.Stelle nach dem Punkt)
>>>zkette="Hello world" #Zuweisung eines String an Variable zkette
>>>print zkette
#Standardausgabe des aktuellen Wertes der Variablen zkette
-------------------------------------------------------------------------------------------------------------------------
Hausaufgabe: Die gesamte Aufgabe 1) kann man auch mit dem Standard-PythonKommandozeileninterpreter (Aufruf: Start/All Programs/Python 2.5/Python (command line) ) lösen.
Führen Sie dies als Hausaufgabe durch.
------------------------------------------------------------------------------------------------------------------------------
2)
Das berühmte „Hello world“ (vgl. 1. Vorlesung)
(mit Python-IDLE)
im interaktiven Modus und im Programm-Modus (jeweils ohne bzw. mit Funktion)
Das „Hello world“-Einführungsprogramm wurde in dem klassischen Buch „The C Programming
Language“ von Kernighan und Ritchie (1978) eingeführt. Seitdem beginnt fast jedes Programmierbuch
zu beliebigen Sprachen mit „Hello world“.
Dieses simple Programm gibt die Zeichenkette (String) "Hello world" auf dem Bildschirm aus.
Wir beziehen uns im Folgenden auf das in der ersten Vorlesung behandelte Programm „Hello world“.
************************************************************************************
Vorbemerkungen:
(1) Ein Python-Programm („Python-Skript“) besteht aus einer Folge von Anweisungen.
Die Anweisungen eines Programms kann man bei einem Interpreter auf zwei Arten eingeben:
- im interaktiven Modus ( vgl. Kapitel 1) ): (bei einem Compiler gibt es keinen interaktiven Modus)
Anweisungen der Reihe nach eingeben und jeweils durch <ENTER> abschließen;
jede einzelne Anweisung wird sofort nach <ENTER> abgearbeitet;
Nachteil: bei wiederholter Abarbeitung bzw. Modifizierung muss alles erneut eingegeben werden.
1011
4
- im Programm-Modus:
alle Anweisungen des Programms zunächst in ein ASCII-Textfile eingeben und speichern mit dem Typ
„.py“ (Python besitzt einen einfachen Editor; auch jeder andere Editor verwendbar); dieses Programm
(Skript) dann vom Python-Interpreter (zeilenweise) abarbeiten lassen;
Vorteil: Programmquelltext ist gespeichert und kann beliebig oft abgearbeitet bzw. modifiziert werden.
(2) Python-Programm:
Hauptprogramm und Funktion(en)
- Ein Python-Programm (Skript) kann aus einer oder mehreren Funktionen, aus einem Hauptprogramm
(HP) und einer oder mehreren Funktionen bzw. auch nur aus einem Hauptprogramm bestehen.
- Der Anweisungsblock eines HP beginnt stets in der ersten Spaltenposition.
- Skripte werden stets anweisungsweise von der ersten bis zur letzten Anweisung ausgeführt.
- Eine Funktion hat die Grundform:
############################
def funktionsname(liste_der_formalen_parameter):
anweisungsblock
############################
Jede Anweisung eines Anweisungsblocks (auch „Suite“ genannt) einer Funktion muss um die gleiche
Anzahl von Leerzeichen (oder Tabulatoren) eingerückt sein (Empfehlung: 4 Leerzeichen).
Die Python-IDLE rückt (nach einem Doppelpunkt) Anweisungsblöcke automatisch (um je 4 Zeichen)
ein. Nach dem Ende eines Blocks muss der Nutzer allerdings (z.B. durch zweimaliges ENTER oder mit
der Backspace-Taste) wieder auf die benötigte Einrückungsebene zurückgehen.
- In dieser Übung gehen wir davon aus, dass die oben genannte Parameterliste leer ist.
Eine solche parameterlose Funktion hat folgende Gestalt:
############################
def funktionsname():
anweisungsblock
############################
- Die Aktivierung einer Funktion erfolgt stets durch einen Funktionsaufruf. Für parameterlose Funktionen hat er die Form (eine Möglichkeit):
funktionsname( )
Wenn der Aufruf vom Hauptprogramm aus erfolgt, muss die aufgerufene Funktion vor dem
Hauptprogramm stehen, damit sie dem Interpreter zum Aufrufszeitpunkt bekannt ist.
************************************************************************************
a)
Im interaktiven Modus (ohne Funktion)
Versuchen Sie es zunächst selbst!
(vgl. Vorlesung):
>>>print "Hello World"
b)
Im interaktiven Modus als Funktion plus Funktionsaufruf
(vgl. 1. Vorlesung):
Zur Beachtung: Die gesamte Funktion zählt (im höheren Sinne) als eine Anweisung. Deshalb kommt
man im interaktiven Modus erst nach Eingabe der gesamten Funktion zum Prompt „>>>“ zurück.
>>>def hello():
print "Hello world"
>>>hello()
Hello world
>>>
#<ENTER>
#<ENTER>
#<ENTER>
#<ENTER>; Aufruf der Funktion hello()
#Ausgabe des Python-Interpteters
Indem die Funktion vor dem Aufruf abgearbeitet wurde (ohne Ausgabe auf dem Bildschirm), „kennt“ der Interpreter diese Funktion. Damit kann die (nun bekannte) Funktion hinter dem zweiten Prompt aufgerufen werden.
c)
Als Python-Programm ( zunächst als (Haupt-)Programm ohne Funktion ):
(1) In Python-Shell (IDLE) ausführen:
File/New Window
Ein Edit-Fenster (ASCII-Editor) öffnet sich.
5
1011
(2) Geben Sie im Edit-Fenster das aus der Vorlesung bekannte gesamte (Haupt-)Programm ein.
Beachten Sie dabei die farbige Darstellung.
(Prinzipiell könnte dazu ein beliebiger ASCII-Editor verwendet werden.)
# Erstes Programm: Hello world
print "Hello world"
Das (Haupt-)Programm (ohne Funktion) besteht aus einer Anweisung (siehe Abschnitt a)), ergänzt
durch einen Kommentar.
(3) Im Edit-Fenster ausführen:
File/Save As...
- In Save As-Fenster eingeben:
<Hier Ihr Arbeitsverzeichnis, z.B. W:\Python, auswählen>
Save in:
File name:
hello.py
(Name: frei, Typ: py)
Save as type: *.py
(4) Quelltext auf Fehler prüfen:
- Im Edit-Fenster ausführen:
Run/Check Module
Als Folge gibt es zwei Möglichkeiten:
a) Falls im Quelltext hello.py ein Syntaxfehler vorhanden ist, öffnet sich in der IDLE ein Syntax errorFenster für den ersten erkannten Syntaxfehler mit einer entsprechenden Fehlerausschrift.
- Klicken Sie dann mit der Maus of OK. Der Kursor steht nun im Edit-Fenster. Die Quelltextstelle, an
der der Syntaxfehler erkannt wurde, ist rot markiert. In der Regel liegt der Fehler vor der roten Markierung. Verbessern Sie den Fehler.
Setzen Sie wieder mit (4) fort
(Schleife: solange bis kein Syntaxfehler mehr gefunden wird)
(Hinweis: Im schwarzen Kommandozeileninterpreter python.exe wird die Stelle, an der der Fehler
erkannt wurde, durch einen kleinen „Pfeil“ markiert.)
oder b) Es wurde kein Syntaxfehler erkannt und der Kursor steht (ohne eine neue Ausschrift) im Python
Shell-Fenster.
Die vom System gefundenen Syntaxfehler wurden also korrigiert.
(5) Abarbeitung des Programms hello.py
Im Edit-Fenster:
Run/Run Module
Die Ausgabe des Programms erscheint im Python Shell-Fenster.
-----------d)
Als Python-Skript mit Hauptprogramm (enthält Aufruf) und Funktion:
Alle Schritte entsprechend zu Abschnitt c), d.h. führen Sie auch hier die Schritte (1) bis (5) aus !!!
Geben Sie dabei als Python-Programm ein:
#"Hello world" als Programm mit Funktion und Funktionsaufruf
def hello():
#Funktion ohne formale Parameter
print "Hello world"
#Hauptprogramm:
hello()
#Aufruf der Funktion hello()
Speichern Sie das Programm z.B. als hellofkt.py
usw. (d.h. Schritt (1) bis (5) wie unter c) )
( Das Python-Programm mit Funktion besteht also aus den beiden Einzelkommandos aus b),
d.h. vom interaktiven Modus mit Funktion. Im Programm wurden noch Kommentare hinzugefügt. )
6
1011
3)
Python-Skript für:
Summe zweier einzugebender reeller Zahlen
(falls in der Poolübung keine Zeit mehr vorhanden:
Hausaufgabe)
Abschließend soll noch einmal die Arbeit mit der Python-Entwicklungsumgebung geübt werden. Da in einigen
Übungsgruppen noch der Vorlesungsvorlauf fehlt, wird ein Struktogramm und das sich daraus ergebende PythonProgramm gegeben. (Das Programm enthält noch keine Steuerstrukturen wie Selektion und Schleife.)
Aufgabe: In einem Python-Skript ist die Summe zweier einzugebender reeller Zahlen zu bestimmen
und auf dem Bildschirm auszugeben.
Das Python-Skript soll die Form eines Hauptprogramms (ohne Funktion) besitzen (vergleiche 2.c).
Lösung:
- Struktogramm:
A("Erste reelle Zahl eingeben: ")
E(a)
A("Zweite reelle Zahl eingeben: ")
E(b)
summe=a+b
A("Summe = ", summe)
- Python-Skript dazu (hier als Hauptprogramm ohne Funktion):
# Zweites Programm: Summe zweier reeller Zahlen
a=input("Erste reelle Zahl eingeben: ")
b=input("Zweite reelle Zahl eingeben: ")
summe = a + b
print "Summe = ",summe
Erklärung zur zweiten und dritten Programmzeile:
- Die zweite und dritte Programmzeile haben jeweils die Form einer Zuweisung (Ergibtanweisung). In
diesen Zuweisungen werden die erste und zweite Zeile bzw. die dritte und vierte Zeile des obigen
Struktogramms zusammengefasst. Eine Zuweisung wird wie folgt abgearbeitet:
1) Erster Zeitschritt:
Wert des Ausdrucks auf der rechten Seite bestimmen
2) Zweiter Zeitschritt:
Diesen Wert der links stehenden Variablen zuweisen
Zur zweiten Programmzeile: Der zuerst abgearbeitete Ausdruck auf der rechten Seite hat hier die Form
einer input-Eingabeanweisung:
input(("prompt")
Die Zeichenkette "Erste reelle Zahl eingeben: " wird (als Prompt) auf dem Bildschirm
ausgegeben. Dann gibt der Nutzer über die Tastatur dahinter die erste reelle Zahl ein
(mit Dezimalpunkt) und schließt die Eingabe mit <Enter> ab. Nun wird (im zweiten Zeitschritt) der
eingelesene reelle Wert der Variablen a auf der linken Seite der Ergibtanweisung zugewiesen.
(Danach wird die nächste Anweisung abgearbeitet.)
Geben Sie das Programm ein, und arbeiten Sie es ab.
Verfahren Sie dabei, wie es in Abschnitt 2.c beschrieben wurde.
Experimentieren mit diesem Programm:
(1) Die vorletzte Programmanweisung kann gestrichen werden, wenn man als letzte Anweisung schreibt:
print "Summe = ",a+b
(2) Die 2. und 3. Programmzeile können wie folgt zu einer Programmzeile zusammengefasst werden:
(a,b) = input ("Zwei reelle Zahlen eingeben: ")
Hier sind zwei reelle Zahlen - getrennt durch ein Komma! - eingeben (danach <Enter>), z. B:
Zwei reelle Zahlen eingeben: 34.5,44.8 <ENTER>
7
1011