Einstieg in Python#

Bevor wir mit der Programmierung von ABM loslegen können, müssen wir erstmal grob verstehen, wie Python funktioniert und was die allgemeine Logik von Programmiersprachen ist. Damit du die folgenden Ausführungen sowie alle anderen Kapitel dieses Kurses nachverfolgen und vielleicht sogar mittippen kannst, solltest du am besten Spyder geöffnet haben, wenn du diesen Kurs durcharbeitest.

Python als Taschenrechner#

Den intuitivsten Einstieg erhält man, wenn man Python zunächst einfach als Taschenrechner verwendet. Python kann zwar als Programmiersprache vieles mehr, dennoch machen wir auch mit Python oft das, was was man auch mit einem Taschenrechner oder im Kopf hätte machen können: Wir verrechnen irgendwelche Zahlen auf irgendeine Art und Weise. Du kannst das Ausprobieren, indem du einfach typische Berechnungen, die du auch in einen klassischen Taschenrechner eintippen könntest, in die Konsole eintippst und Enter drückst.

Zum Beispiel:

(20 + 20 - 54) / 2 + 40 * 65

2593.0

Wir sehen, Python weiß also was Zahlen bedeuten und weiß auch über die Bedeutung von bestimmten mathematischen Operatoren, wie +, -, * und / Bescheid. Diese beiden Elemente von Berechnungen - Zahlen und Operatoren - vermitteln auch einen intuitiven Eindruck davon, woraus letztlich jedes Computerprogramm besteht: nämlich aus irgendwelchen Daten und irgendwelchen Funktionen, die irgendwas mit den Daten machen. In diesem Falle sind die Daten die eingegebenen Zahlen und die Funktionen sind die mathematischen Operatoren, die vorgeben, wie die Daten verrechnet werden sollen. Es gibt jedoch neben Zahlen und mathematischen Operatoren eine ganze Reihe an anderen Datentypen und Funktionen, dennoch werden wir diese fast in jedem Programm benutzen. Dazu später mehr.

Übrigens ist all das, was in Python existiert, also auch die obigen Zahlen und Operatoren bzw. Daten und Funktionen, auch ein sogenanntes Software-Objekt bzw. Objekt. Objekte sind die kleinsten Einheiten in Python, aus dem alles besteht. Dabei gibt es verschiedene Klassen bzw. Typen von Objekten, welche bestimmen, was ein bestimmtes Objekt machen kann und was nicht. Auch dazu werden wir im Verlauf des Kurses noch mehr lernen.

Variablen#

Geben wir Berechnungen wie oben oder auch einfach nur irgendwelche Werte in die Konsole ein, dann bekommen wir das Ergebnis unmittelbar ausgegeben. Wir können aber einzelne Werte oder das Ergebnis einer Berechnung auch speichern, indem wir diese einer sogenannten Variable zuweisen. Dadurch können wir die so abgelegten Werte später immer wieder unter dem angegebenen Variablennamen aufrufen und im Programm weiter verwenden.

Eine Variablenzuweisung erfolgt mithilfe des Gleichheitszeichens, wobei auf der rechten Seite der Wert und auf der linken Seite der Name, unter dem der Wert auf der rechten Seite aufzurufen ist, geschrieben. Unten weisen wir beispielsweise den Wert 1500 dem Variablennamen income zu. Führen wir diesen Code aus, passiert erstmal nichts. Zumindest nichts, was für uns sichtbar ist.

income = 1500

Tippen wir nun den entsprechenden Variablennamen in die Konsole ein und drücken Enter, erhalten wir den eingespeicherten Wert zurück.

income

1500

Wie gesagt können wir die Variable nun in Berechnungen verwenden und auch die Ergebnisse von Berechnungen selbst wieder einer Variable zuweisen:

remaining_money = income - 700
remaining_money

800

Zudem können wir auch innerhalb unseres Programmes einen Variablennamen immer wieder überschreiben:

remaining_money = remaining_money - 500
remaining_money

300

Gerade speichern wir immer nur Zahlen als Variablen ein. In Python kann man aber eigentlich alles, d.h. jede Form eines Software-Objektes einer Variable zuweisen. Das werden wir weiter unten noch sehen.

Übrigens kann man ein und dasselbe Objekt auch mehrmals unter verschiedenen Variablennamen einpeichern:

x = 100
y = 100

Man könnte denken, dass sich im Speicher nun zweimal der Wert 100, einmal an dem Ort x und einmal an dem Ort y befindet. Doch die Variablenzuweisung in Python funktioniert anders. Stattdessen befindet sich die 100 immer noch nur genau einmal im Speicher an genau einem Ort. Dieser eine Ort im Speicher, an dem die 100 liegt, kann nun aber mit zwei Variablennamen gefunden werden: x und y. Variablen sind in Python also immer nur “Zeiger” auf Werte bzw. Objekte, die irgendwo im Speicher liegen. Diese Eigenschaft von Python ist zu diesem Zeitpunkt noch nicht so wichtig, später aber wird dies sowohl eine sehr verwirrende als auch hilfreiche Eigenschaft sein.

Datentypen#

Die grundlegensten Software-Objekte in Python sind Daten. Daten können in verschiedener Form vorliegen bzw. gespeichert sein. Man nennt die unterschiedlichen Formen, in denen Datenwerte vorliegen können, auch Datentyp. Ein Datentyp gibt vor, was man mit bestimmten Datenwerten machen kann d.h. welche Funktionen auf diesen Datentyp anwendbar sind. Beispielsweise gehört eine 2 in Python zum Datentyp “Integer”, also “ganze Zahl”. Für diesen Datentyp ist zum Beispiel das Addieren mit einem weiteren Datenelement vom Typ “Integer” eine zulässige Verarbeitung, wie wir bereits im Taschenrechner-Beispiel gesehen haben.

In Python gibt es eine Reihe grundlegender Datentypen, die fast in jedem Programm verwendet werden und wir deren Eigenschaften daher gut kennen sollten. Hier ist eine Auswahl an Datentypen, die wir von Anfang an brauchen werden und ich daher ganz kurz vorstellen möchte.

  • Integer

  • Float

  • String

  • Boolean

  • List

Integer#

Integers sind “ganze Zahlen” und werden in Python mit int abgekürzt. Eine 42 ist beispielsweise eine ganze Zahl.

Float#

Floats heißen in Python alle “Kommazahlen” bzw. “Fließkommazahl”. In Python wird als Trennzeichen jedoch kein Komma, sondern ein Punkt verwendet. Beispielsweise gehört die 42.35, aber auch die 42.0 zum Datentyp float.

String#

Strings sind “Zeichen” oder “Zeichenketten”. Diese werden in Python über die Einbettung in Anführungszeichen gekennzeichnet. Der Datentyp wird in Python mit str abgekürzt. Beispielsweise gehören "Haus", "jhfe93f39jh3129f", aber auch eine "10", weil in Anführungszeichen, zum Datentyp String.

Das Besondere an Strings ist, dass diese für den Computer - anders als beispielsweise Integers oder Floats - zunächst keine “inhaltliche” d.h. “mathematische” Bedeutung haben. Bei Integers und Floats weiß der Computer, dass man damit rechnen kann und ein bestimmter Zahlenwert eine bestimmte Bedeutung bei den Berechnungen hat. Wenn aber ein Symbol, das aus mathematischer Sicht eine verrechenbare Zahl darstellt, in Anführungszeichen und somit als String verwendet wird, dann interpretiert Python dieses nicht mehr als Zahl, wodurch damit auch nicht mehr klassischerweise gerechnet werden kann.

Unten addiere ich mal zwei Einsen vom Typ int:

1 + 1

2

Aha, das funktioniert also. Jetzt addiere ich eine 1 vom Typ int und eine "1" vom Typ str. Mal schauen was passiert:

1 + "1"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-8-b780703cc5f9> in <module>
----> 1 1 + "1"

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Aha, ein Fehler. Man sieht, Python kann mit einem String nicht rechnen. Was passiert, wenn ich zwei Einsen vom Typ str addiere?

"1" + "1"

'11'

Juhu, kein Fehler, aber das Ergebnis einer Addition zweier Einsen ist das auch nicht. Stattdessen hat Python nun den String "1" und den String "1" zum String "11" zusammengefügt. Wir sehen, zwar kann man mit Strings nicht “mathematisch rechnen”, aber dennoch kann man zumindest den Plus-Operator für das unkomplizierte Zusammenfügen zweier Strings verwenden. Diese Funktion kann an der ein oder anderen Stelle nützlich sein.

Allgemein wird deutlich: Achte darauf, in welchem Datentyp die Werte vorliegen! Zum einen können bestimmte Operationen nur mit bestimmten Datentypen vollzogen werden, zum anderen kann sich die Funktionsweise eines Operators, wie dem Plus-Operator, je nach Datentyp ändern.

Booleans#

Booleans heißen in Python logische Wahrheitswerte. Es gibt genau zwei Wahrheitswerte: Wahr und Falsch. In Python heißen diese True und False.

Wir werden Booleans später brauchen, um angeben zu können, ob eine bestimmte Bedingung erfüllt ist oder nicht. Beispielsweise könnte es an einer bestimmten Stelle im Programm wichtig sein zu wissen, ob das Einkommen einer Person größer als 1000€ ist. Um das herauszufinden, würde man Python fragen, ob die Variable, die das Einkommen repräsentiert, größer als 1000€ ist. Das Ergebnis ist dann entweder True oder False.

income > 1000

True

Wir werden solche Vergleiche später v.a. in sogenannten If-Statements, über die es ein eigenes Kapitel geben wird, benötigen.

Listen#

Eine Liste ist ein sogenannter Datencontainer, also ein Objekt, in welchem wir andere Objekte ablegen können und so auf sehr gute Weise strukturieren können. Listen werden in Python durch zwei eckige Klammern erzeugt. Dies ist beispielsweise eine leere Liste: [] . Die Objekte in den Listen werden durch Kommata getrennt. Die Objekte einer Liste nennt man Element. Wir können übrigens alles Mögliche in Listen als Elemente ablegen. Hier lege ich beispielsweise alles mögliche in einer Liste ab und speichere diese unter dem Variablennamen my_stuff ab:

my_stuff = [1, remaining_money , False, 6, "Haus", "Auto", income, True]

my_stuff

[1, 300, False, 6, 'Haus', 'Auto', 1500, True]

Praktisch an Listen ist, dass wir dort Objekte ablegen und speichern können, ohne dass wir jedes einzelne Element als Variable speichern müssen. Das ist praktisch, weil wir es oft mit sehr vielen Daten bzw. Objekten zu tun haben, die wir zwar alle brauchen, aber nicht alle einzeln als Variable benennen wollen. Legen wir alle Objekte in einer Liste ab, so brauchen wir nur die Liste zu speichern und wir haben dennoch alle Daten gespeichert. Da Listen wirklich sehr praktisch sind, gibt es später ein eigenes Kapitel zu Listen. Dort zeige ich euch auch, wie man auf die in der Liste gespeicherten Elemente zugreifen kann, um sie für irgendwas zu benutzen.

Funktionen#

Wir haben nun schon eine ganze Reihe von Datentypen kennengelernt. Doch Programme bestehen ja aus Daten sowie Funktionen, die irgendwas mit den Daten machen. Deshalb werfen wir nun kurz einen Blick auf Funktionen.

  • Allgemein ist eine Funktion eine bestimmte Art von Objekt, das “Anweisungen” enthält, wie bestimmte Daten bzw. Objekte verarbeitet werden sollen.

  • Meist erwarten Funktionen eine gewisse Form von Input, auch Argumente genanannt, die in Regel das Objekt, das verarbeitet werden soll, enthalten. Manchmal müssen auch keine Argumente explizit in eine Funktion eingegeben werden, weil die Daten selbst schon in der Funktion vorhanden sind. In der Regel gibt eine Funktion am Ende auch einen gewissen Output zurück.

  • Funktionen selbst sind immer unter einem bestimmten Variablennamen abgespeichert. Über diesen Namen können wir die Funktion aufrufen und anwenden.

  • Funktionen kann man oft daran erkennen, dass diese mit zwei runden Klammern enden. In diese runden Klammern werden die Argumente eingegeben.

  • Rufen wir die Funktion auf, so werden die Anweisungen ausgeführt.

Ein Beispiel für eine Funktion ist len(). Diese misst u.a. die Länge von Listen und Strings. In die runden Klammern gibt man die Input-Daten, also eine Liste oder ein String und die Funktion gibt die Länge des eingegebenen Objekts zurück.

Hier messe ich die Länge der Liste my_stuff, welche oben definiert wurde:

len(my_stuff)

8

Wie man unten überprüfen kann, hat die Liste my_stuff wirklich 8 Elemente.

my_stuff

[1, 300, False, 6, 'Haus', 'Auto', 1500, True]

Als wir Python als Taschenrechner benutzt haben, haben wir ja bereits auch was mit den Daten gemacht: gerechnet. Tatsächlich haben wir dort bereits eine besondere Form von Funktionen verwendet: Mathematische Operatoren. So ist beispielsweise die Anweisung, wie zwei Zahlen verrechnet werden, wenn diese addiert werden, unter dem Variablennamen + eingespeichert. Das besondere ist, dass die Argumente nicht wie bei der Funktion len() in die runden Klammern übergeben werden, sondern links und rechts von dem Plus-Zeichen stehen. Meist nennen wir solche besonderen Funktionen einfach Operatoren und meinen mit dem Begriff Funktion meist all das, was so aussieht wie die Funktion len(). Genaugenommen sind aber auch all die vielen Operatoren in Python eine Form von Funktion.

Was ansonsten noch wichtig ist zu wissen: Die Klammern nach einer Funktion dienen nicht nur dazu, Argumente in die Funktion einzugeben, sondern signalisieren Python auch, dass die Funktion nun auch ausgeführt werden soll. Denn tatsächlich kennt Python die Funktion auch allein unter dem Funktionsnamen ohne die Klammern. Gibt man beispielsweise nur len ein, dann behandelt Python die Funktion einfach wie jedes andere Objekt und gibt mir dieses wieder zurück, ohne es auszuführen:

len

<function len(obj, /)>

Erst wenn die Klammern angehängt werden, versucht Python auch die Funktion auszuführen:

len()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-15-adf3103c7c3e> in <module>
----> 1 len()

TypeError: len() takes exactly one argument (0 given)

Jetzt hat Python versucht die Funktion auszuführen, hat aber gemerkt, dass die Funktion len() zwingend ein Argument erwartet - nämlich ein Objekt, dessen Länge gemessen werden kann.

Im Folgenden werden ein paar Funktionen, die am Anfang wichtig sind, vorgestellt. Im Verlauf des Kurses werden wir immer wieder neue Funktionen kennenlernen. Später werden wir auch unsere eigenen Funktionen schreiben.

len()#

Gibt die Länge von sequentiellen Datentypen, also z.B. Listen und Strings, an.

len("agent-based modeling")

20

len(["agent-based modeling", 2000, [], True])

4

type()#

Gibt den Datentyp eines Objekts zurück.

type("agent-based modeling")

str

type(["agent-based modeling", 2000, [], True])

list

help()#

Gibt einem nähere Informationen über ein Objekt. Auch Funktionen können als Argument eingegeben werden, dafür müssen aber die runden Klammern weggelassen werden, damit die Funktion nicht ausgeführt wird, sondern als normales Objekt behandelt wird.

help(len)

Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

help(help)

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |      Call self as a function.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

int(), float(), str()#

Die Namen dieser Variablen bezeichnen nicht nur den jeweiligen Datentyp, sondern versuchen als Funktion auch ein eingegebenes Objekt in den jeweilgen Datentyp zu konvertieren. Hier wird beispielsweise eine Zahl im Integer-Format in einen String umgewandelt:

str(100)

'100'

Hier wird eine Zahl im String-Format in einen Integer umgewandelt:

int("200")

200

Der Versuch einen Buchstaben in einen String umzuwandeln, ist jedoch zum scheitern verurteilt:

int("Zweihundert")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-24-cce3fd583dcd> in <module>
----> 1 int("Zweihundert")

ValueError: invalid literal for int() with base 10: 'Zweihundert'

Man kann also nicht alle möglichen Werte bzw. Datentypen in alle möglichen anderen Datentypen umwandeln. So kann man z.B. auch einen Float niemals in eine Liste umwandeln. Bei den Datentypen int, float und str kann man aber zumindest Zahlen-Symbole relativ problemlos ineinander umwandeln.

print()#

Eine äußerst nützliche Funktion ist zudem die Funktion print(). Diese Funktion bewirkt, dass der Wert einer Variable bzw. eines Ausdrucks in der Konsole ausgegeben wird. Du fragst dich bestimmt, wofür wir das brauchen, denn bisher konnten wir uns die Werte ja auch einfach durch das eingeben des Variablennamens oder der Berechnung in der Konsole unmittelbar ausgeben lassen. Das funktioniert in Spyder aber nur in der interaktiven Konsole!

Wenn wir längere Programme im Editor-Fenster schreiben und wollen, dass während der Laufzeit des Programms bestimmte Werte in der Konsole angezeigt werden, dann brauchen wir die Funktion print(). Außerdem müssen wir dann nicht immer wieder den Namen der Variable in die Konsole eingeben, sondern bekommen, wenn wir den print()-Befehl in unserem Programm haben, den Wert immer wieder automatisch ausgegeben. Insgesamt kann es sinnvoll sein, die Funktion print() zur Kontrolle des Verhaltens unseres Programmes zu nutzen, indem wir beispielsweise während der Laufzeit des Programms bestimmte Werte, mit denen wir die Funktionalität oder den Status unseres Programms ablesen können, ausgeben zu lassen.

In die Funktion print() kann eine unbegrenzte Anzahl an Argumenten eingegeben werden, deren Wert dann in der Konsole ausgegeben wird.

print("hello world")

hello world

print(" 'hello world' hat", len("hello world"), "Buchstaben.")

 'hello world' hat 11 Buchstaben.

Dieses Dokument ist übrigens in einem Jupyter Notebook verfasst worden. Da auch in Jupyter Notebooks die Werte von Variablen, zumindest wenn sie am Ende eines ausgeführten Code-Blocks stehen, durch das Eintippen ihrer Namen automatisch auch angezeigt werden, verwende ich hier auch nur, wenn es notwendig ist, die Funktion print().

Kommentare#

Wenn wir Code im Editor schreiben, ist es sinnvoll, diesen zu kommentieren. Denn Programme können sehr schnell sehr kompliziert werden und nach ein paar Tagen wissen selbst die besten Programmierer*innen nicht mehr, was denn eigentlich ihr schönes Programm da macht, wenn man den Code nicht gut kommentiert hat. Das kennst du möglicherweise auch schon von SPSS oder R. Kommentare dienen allein der besseren Strukturierung/Erklärung des Codes für uns Menschen. Python überliest diese Kommentare bei der Ausführung des Programms.

Einzeilige Kommentare können mit einem # eingefügt werden:

# Hier könnte ein Kommentar stehen

Mehrzeilige Kommentare können zwischen zwei dreifache Anführungszeichen """ """ geschrieben werden:

""" 
Hier könnte ein 
mehrzeiliger Kommentar stehen.
:)
"""