Grundlagen von Python

Inhalt

Dieses Kapitel hilft beim Einstieg in die Programmiersprache Python und deckt die folgenden Konzepte ab:

• Beispielprogramm: Hello World!

• Python-Interpreter

• Kommentare

• Grundlegende Datentypen

• Ausdrücke

• Variablen

• Duck-Typing

• Eingaben von Werte

Beispielprogramm: Hello World!

In Python schreibt die Funktion print() Ausgaben auf die Standard-Ausgabe des Systems. Die auszugebenden Zeichenketten sind in Anführungszeichen (“) oder Hochkommas (’) eingeschlossen. Im Gegensatz zu Sprachen wie Java und C genügt für ein ”Hello World!" mit Python eine einzelne Zeile Quelltext.

>>> print("Hello World!")
Hello World!

Der Inhalt der obigen Zelle wird vom Python Interpreter ausgeführt. Die Ausgabe wird direkt unterhalb der Zelle angezeigt. Man erreicht etwas ähnliches, wenn man einfach nur den String "Hello World!" eingibt.

>>> "Hello World!"
'Hello World!'

Der Unterschied ist, dass jetzt die Ausgabe mit Hochkommas eingeschlossen ist. Das bedeutet, dass es sich lediglich um die Rückmeldung des Interpreters handelt, nicht jedoch um eine echte Ausgabe. Die Rückmeldung des Interpreters ist oft nicht sichtbar.

Python-Interpreter

Die Umgebung, in der dieses Vorlesungsskript zur Verfügung gestellt wird, ist eine IDE namens PyCharm Edu®. PyCharm Edu (einfach PyCharm) ist ein kostenloses und professionelles Tool zum Lernen und Lehren von Programmieren mit Python. Zur eigentlichen Ausführung des Quelltextes wird der Python Interpreter benutzt. Bei interpretierten Sprachen wie Python, kann man daher den Quelltext direkt ausführen. Es muss nicht erst ein Compiler aufgerufen werden, der ausführbare Programme erstellt.

Um mit Python-Code in PyCharm zu arbeiten, muss man mindestens einen Python-Interpreter konfigurieren.

1. Man kann einen Systeminterpreter verwenden, der mit der Python-Installation verfügbar ist.

2. Man kann auch eine virtuelle Umgebung mit Virtualenv, Pipenv, Poetry oder Conda erstellen. Eine virtuelle Umgebung besteht aus einem Basisinterpreter und installierten Paketen.

Nach der Installation von PyCharm muss man beim Start der Software die Option learner auswählen, um mit der IDE zu beginnen. Dann muss man ein neues Projekt (z.B. pythonHelloWorld) erstellen und in dem erscheinenden Dialogfenster angeben, dass der Basisinterpreter auf die Python-Installation verweist.

Nachdem alle oben genannten Schritte ausgeführt wurden, wird ein Beispielprogramm "Hello World" erstellt und ausgeführt. Um das erstellte Programm auszuführen, klickt man auf den grünen Pfeil und das Ergebnis der Ausfuhrung wird darunter angezeigt.

Man kann den Interpreter auch direkt auf der Kommandozeile ausführen und Pythonquelltext eingeben. Sofern Python installiert ist, kann man einfach mit dem Befehl python3 den Interpreter starten. Im Interpreter kann Quelltext eingegeben und ausgeführt werden. Der Interpreter kann durch Eingabe des Befehls quit() geschlossen werden.

Da man in der Regel mehr als nur einzelne Befehle ausführen möchte, kann der Interpreter auch Dateien einlesen und den kompletten Quelltext innerhalb der Datei ausführen. Hierzu übergibt man dem Interpreter einfach die Datei als Kommandozeilenparameter. Die übliche Dateiendung von Pythonquelltext ist .py.

Kommentare

Kommentare sind Teile von Quelltext, die ignoriert werden, also für die Ausführung nicht relevant sind. Hierdurch sind Beschreibungen im Quelltext möglich. In Python werden Kommentare mit # eingeleitet. Der Text nach dem # wird vom Interpreter ignoriert.

>>> # Comments are ignored by the interpreter
>>> print("Hello World!") # Everything after a hash is a comment
Hello World!

Da mehrzeilige Kommentare jedoch an einigen Stellen wichtig sind, zum Beispiel um Programmierschnittstellen zu beschreiben, gibt es ein übliches Hilfskonstrukt in Python. Mit ’’’…’’’ kann man mehrzeilige Strings in Python definieren. Wenn diese Strings für sich stehen, führen Sie zu keinen Änderungen im Programmablauf, sie “stören” also nicht. Daher eignen sie sich um Behelfsweise als mehrzeilige Kommentare benutzt zu werden. Da der String jedoch vom Interpreter nicht komplett ignoriert wird, gibt es eine Ausgabe.

>>> '''
... Multiline comments are usually defined like this.
... HOWEVER! This is NOT really a comment, this is a string.
... '''

'\nMultiline comments are usually defined like this.\nHOWEVER! This is NOT really a comment, this is a string.\n'

Grundlegende Datentypen

1. Numerische Daten

Zahlen können in Python auf unterschiedliche Art und Weise dargestellt werden. Die beiden wichtigsten Varianten sind:

• int für ganze Zahlen. Der Datenbereich ist beliebig.

• float für Gleitkommazahlen. Die Zahlen sind üblicherweise als double Werte in C++ implementiert. Mit Hilfe der type Funktion kann man den Datentypen bestimmen.

>>> print(type(42))  # integer 42
<class 'int'>

>>> print(type(4.2)) # floating point number 4.2
<class 'float'>

Bei Bedarf kann man auch Daten von einem Typ in einen anderen Konvertieren. Mit Hilfe der Funktionen int() und float() kann man zum Beispiel zwischen Gleitkommazahlen in ganze Zahlen umwandeln, bzw. umgekehrt. Typumwandlungen werden üblicherweise cast genannt. Wenn man eine Gleitkommazahl in eine ganze Zahl konvertiert, werden alle Nachkommastellen ignoriert, die Zahl wird also abschnitten und nicht gerundet.

>>> print(int(4.2))  # casts the floating point number 4.2 into an integer 4.
4

>>> print(float(42)) # casts the integer 42 to the floating point number 42.0
42.0

Es gibt auch einen Datentyp complex für komplexe Zahlen, auf den hier nicht näher eingangen wird.

2. Zeichenketten (Strings)

Zeichenketten werden in der Programmierung üblicherweise als string bezeichnet und in Python durch den Datentyp str zur Verfügung gestellt. In diesem Kapitel wurden Zeichenketten bereits rudimentär zu Beginn behandelt. In diesem Abschnitt wird etwas genauer auf Zeichenketten eingegangen. Zur Definition kann man " und ’ für einzeilige Stringdefinition benutzen, bzw. """ und ''' für mehrzeilige Stringdefinitionen.

>>> print("String 1")
String 1

>>> print('String 2')
String 2

>>> print('''String 3
... String 4''')
String 3
String 4

Will man innerhalb eines Strings Anführungszeichen oder Hochkommas benutzen, so muss man sie eventuell escapen, das heißt mit einem ++ einleiten um dem String mitzuteilen, dass ein besonderes Zeichen kommt. Dies kann man jedoch häufig umgehen, da man nur das zur Stringdefinition benutzte Zeichen escapen muss.

>>> print("String with \"") # must escape "
String with "

>>> print('String with \'') # must escape '
String with '

>>> # " does not need to be escaped because ' is used to define the string
>>> print('String with "')
String with "

>>> print("String with '") # same as above
String with '

Bei Mehrzeiligen Strings ist es ähnlich, hier muss man lediglich drauf achten nicht drei Hochkommas in folge zu haben.

>>> # if we use multiline strings, we only have to escape if we have three ' in a row
>>> print('''String with " and '', but \''' ''')
String with " and '', but '''

Durch escapen kann man nicht nur Anführungszeichen und Hochkommas nutzen, sondern auch andere Sonderzeichen. Am wichtigsten sind:

• \n für eine neue Zeile.

• \t für einen Tabulator.

>>> print("Hello\nWorld!")
Hello
World!

>>> print("Hello\tWorld!")
Hello	World!

3. Wahrheitswerte (Boolean)

Wahrheitswerte sind die Grundlage von logischen Entscheidungen in Computerprogrammen, zum Beispiel um den Kontrollfluss zu steuern (Kapitel 3). Der Datentyp für Wahrheitswerte in Python heißt bool und kann die logischen Werte True und False annehmen.

>>> print(type(True))  # boolean value for true expressions
<class 'bool'>

>>> print(type(False)) # boolean value for false expressions
<class 'bool'>

Ausdrücke (Expressions)

Ausdrücke in Programmiersprachen sind dazu da, Objekte mit Hilfe von Operatoren zu bearbeiten und zu verbinden. Jeder Ausdruck liefert einen Wert zurück, der einen Typ hat. Die Syntax für einfache Ausdrücke in Python ist <object> <operator> <object>. Hier sind einige Beispiele für Ausdrücke.

ausdruecke.py
==============
# common expressions for numeric value
print(4+2)  # adds two numeric values
print(4-2)  # substracts two values
print(4*2)  # multiplies two values
print(4/2)  # divides two values --> result is a floating point number!
print(4**2) # takes four to the power of two, i.e., the square of four
print(5%3)  # the remainder of the first number when divided by the second number

# common expressions for strings
print("string"+" string 2") # concatenates two strings
print("string"*3)           # this actually works and concatenates the string three times with itself
print("string " + str(1))   # to concatenate other data types to strings they must be cast first

# common expressions for and with booleans
print(True and False) # logical and between two booleans: true if both are true
print(True or False)  # logical or between two booleans: true at least if one is true
print(not True)       # negation
print(5<10)           # logical comparisons of numbers (<, <=, >, >=, ==)

Wenn der obige Code (ausdruecke.py) ausgeführt wird, wird das folgende Ergebnis erzeugt:

>>> python3 ausdruecke.py
6
2
8
2.0
16
2
string string 2
stringstringstring
string 1
False
True
False
True

Operatoren werden immer in einer bestimmten Reihenfolge ausgewertet. Die Reihenfolge in welcher Operatoren ausgewertet werden, kann man der offizellen Pythondokumentation entnehmen. So hat der * Operator zum Beispiel vorrang vor dem + Operator. Bei arithmetrischen und logischen Operationen kann man dies, wie man es aus der Mathematik kennt, mit Hilfe von () beeinflussen.

>>> print(2+4*4)
18

>>> print((2+4))
6

Variablen

Variablen sind ein Kernkonzept der Programmierung und erlauben es Werte an Namen zu binden. In Python werden Variablen mit dem = Operator zugewiesen. Die den Variablen zugewiesenen Werte können einfach über ihren Namen wieder benutzt werden, zum Beispiel um Funktionen aufzurufen, Ausdrücke zu definieren, oder den Wert einer anderen Variablen zuzuweisen. Variablen haben auch immer einen Typ, der von dem referenzierten Objekt abhängt.

>>> pi = 3.14       # stores the floating point number 3.14 in the variable pi
>>> print(pi)       # retrieves the value of pi and prints it
3.14

>>> print(type(pi)) # the type of the variable pi, i.e., the type of the data that pi references
<class 'float'>

>>> print(pi*pi)    # multiplies pi with itself
9.8596

>>> other_pi = pi   # creates a copy of pi in the variable other_pi
>>> pi = 3.14159    # overwrites the value of pi
>>> print(pi)       # pi contains the new value
3.14159

>>> print(other_pi) # other_pi still contains the old value
3.14

Es ist in Python möglich mehrere Variablen gleichzeitig zuzuweisen. Hierfür trennt man sowohl die Namen, als auch die Werte, mit Kommas.

>>> var1, var2 = 1, "hi"
>>> print(var1)
1

>>> print(var2)
hi

Eine übliche Programmiersituation ist, dass man etwas zählen möchte und hierfür den Werte einer Variable erhöhen will. Um dies zu vereinfachen gibt es in Python +=. Analog gibt es auch -=, +=, /=, %= für die anderen arithmetrischen Operationen.

>>> count = 0
>>> print(count)
0

>>> count += 1             # same as count = count+1
>>> print(count)
1

>>> count += 20            # same as count = count+20
>>> print(count)
21

>>> my_string = "Hello"
>>> print(my_string)
Hello

>>> my_string += " World!" # += also works for strings
>>> print(my_string)
Hello World!

Duck-Typing

Wie man in den obigen Beispielen sieht, muss man den Typen von Variablen in Python nicht explizit deklarieren, wie man es zum Beispiel aus Java kennt. Der entsprechende Quelltext für die erste Zeile wäre in Java double pi = 3.14;, also der Variablen pi explizit einen Typ zuweisen. Variablen nehmen automatisch den Typ von dem Objekt an, was ihnen zugewiesen wird. Dies hat den Vorteil, das der Quelltext kürzer wird, da sämtliche Typdeklarationen entfallen.

Um dies umzusetzen, verwendet Python ein Konzept namens Duck-Typing. Dies führt dazu, dass erst beim Ausführen von Quelltext geprüft wird, ob ein Ausdruck korrekt ausführt werden kann oder ob dies nicht möglich ist, weil die Typen inkompatibel sind. Wenn Typen inkompatibel sind, gibt es einen Fehler während der Ausführung.

Das man eine Zeile als Zeichenkette einliest (zum Beispiel aus einer Textdatei) und sie später in Berechnungen nutzen möchte, ist jedoch ein häufiger Anwendungsfall. Hier helfen die oben behandelten casts. Wenn man die Zeichenkette explizit auf den Typ float castet, ist der Quelltext wieder ausführbar.

>>> pi_string = "3.14"
>>> pi = 3.14
>>> float(pi_string)+pi # this works
6.28

Eine weitere Nebenwirkung des Typsystems in Python ist, dass die selbe Variable zu unterschiedlichen Zeitpunkten, Daten mit unterschiedlichen Typen beinhalten kann. Man kann sich daher in Python nicht darauf verlassen, dass sich der Typ einer Variable nicht verändert, sondern muss dies explizit überprüfen oder garantieren.

>>> pi = 3.14
>>> print(type(pi))
<class 'float'>

>>> pi = "3.14"
>>> print(type(pi))
<class 'str'>

Eingabe von Werten

Ausgaben in Python haben wir mit dem print Befehl bereits kennen gelernt. Hiermit lassen sich Zeichenketten (oder andere Typen, die für die Ausgabe in eine Zeichenkette umgewandelt werden) ausgeben. Das Gegenstück hierzu ist der input Befehl, mit dem man Eingaben vom Benutzer abfragen kann.

eingabeLesen.py
===============

value = input("Please type something and hit enter to terminate the input: ")

print("You typed the following: " + value)

Wenn der obige Code (eingabeLesen.py) ausgeführt wird, wird das folgende Ergebnis erzeugt:

>>> python3 eingabeLesen.py
Please type something and hit enter to terminate the input: Hello World!
You typed the following: Hello World!

Will man mit Hilfe von Input eine Zahl einlesen, muss man den eingelesenen String entsprechend casten.

nummerLesen.py
==============

value = float(input("Please type a number: "))
square = value*value

print("The square of the number is: " + str(square))

Wenn der obige Code (eingabeLesen.py) ausgeführt wird, wird das folgende Ergebnis erzeugt:

>>> python3 nummerLesen.py
Please type a number: 4
The square of the number is: 16.0