{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Kapitel 1: Programmieren als Denkweise\n",
"__[Chapter 1: Programming as a way of thinking](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)__\n",
"\n",
"**Wichtig:** Bevor Sie anfangen dieses Jupyter-Notebook zu bearbeiten schauen Sie sich bitte zuerst [das 0. Seminarnotebook](seminar00.ipynb) an. Es enthält wichtige Hinweise für das Verwenden von Jupyter-Notebooks. Wenn Sie das Notebook in das selbe Verzeichnis heruntergeladen und nicht umbenannt haben, können Sie den Link verwenden um es zu öffnen, andernfalls können Sie die Notebooks ebenfalls auf [Gitlab](https://scm.cms.hu-berlin.de/ibi/python/-/tree/master/notebooks) finden."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ihre Lernziele\n",
"Sie können eine Übersicht der Inhalte dieses Notebooks einblenden mit *Strg + Shift + k*. \n",
"\n",
"Beschreiben Sie in 2-3 Stichpunkten was Sie heute lernen wollen. Sie können diesen Text durch Doppelklick bearbeiten.\n",
"\n",
"- "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exkurs: Was mir an Python gefällt:\n",
"\n",
"Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:\n",
"\n",
"Bitte beachten Sie, dass Sie **erst den Code ausführen (Strg + Enter)** und anschließend in das neue Eingabefeld Ihren Geburtstag eingeben."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import datetime\n",
"\n",
"datum = input(\"Geben Sie Ihr Geburtsdatum im Format TT.MM.JJJJ an: \")\n",
"\n",
"# Zahlen für Tag, Monat und Jahr extrahieren\n",
"(tag, monat, jahr) = (int(d) for d in datum.split('.'))\n",
"# Datumsobjekt anlegen\n",
"datum = datetime.datetime(jahr, monat, tag)\n",
"\n",
"print(\"You were born on a\", datum.strftime(\"%A\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Python-Programme starten\n",
"\n",
"Wenn wir ein Programm (hier einer der Blöcke mit Python-Code) starten, dann starten wir im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches den Python-Code liest, für den Computer übersetzt und ausführt. Wir können den Python-Interpreter auch ohne Jupyter aufrufen und dort direkt Python-Anweisungen eingeben oder Programme starten, die wir in einer Datei gespeichert haben. Für den Anfang bleiben wir aber bei Jupyter, weil wir hier Programme und Erklärungen leicht kombinieren können.\n",
"\n",
"\n",
"**Tipp**: Nutzen Sie http://pythontutor.com, um Ihren Code nachvollziehen zu können und Fehler zu finden!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Herunterladen des unterstützenden Codes\n",
"Die folgende Zelle lädt eine Datei herunter und führt einen Code aus, der speziell für dieses Notebook verwendet wird. Sie müssen diesen Code nicht verstehen, aber Sie sollten die Zelle ausführen vor allen weiteren Zellen in diesem Notebook."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from os.path import basename, exists\n",
"\n",
"def download(url):\n",
" filename = basename(url)\n",
" if not exists(filename):\n",
" from urllib.request import urlretrieve\n",
"\n",
" local, _ = urlretrieve(url, filename)\n",
" print(\"Downloaded \" + str(local))\n",
" return filename\n",
"\n",
"download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');\n",
"\n",
"import thinkpython"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Programmieren als Denkweise\n",
"\n",
"Das erste Ziel dieses Buches ist es, Ihnen das Programmieren in Python beizubringen.\n",
"Programmieren zu lernen bedeutet allerdings, eine komplett neue Denkweise anzunehmen, daher ist das zweite Ziel, Ihnen dabei zu helfen, wie ein$*$e Informatiker$*$in zu denken.\n",
"Diese Denkweise vereint einige der besten Aspekte der Mathematik, des Ingenieurwesens und der Naturwissenschaft.\n",
"Wie Mathematiker$*$innen nutzen Informatiker$*$innen formale Sprachen, um Ideen – und insbesondere Berechnungen – zu bezeichnen.\n",
"Wie Ingenieure entwerfen sie Dinge, fügen Einzelteile zu Systemen zusammen und evaluieren Kompromisse zwischen verschiedenen Alternativen.\n",
"Wie Wissenschaftler$*$innen beobachten sie das Verhalten komplexer Systeme, bilden Hypothesen und testen Vorhersagen.\n",
"\n",
"Wir werden mit den grundlegendsten Elementen des Programmierens beginnen und uns nach und nach hocharbeiten.\n",
"In diesem Kapitel betrachten wir, wie Python Zahlen, Buchstaben und Wörter darstellt.\n",
"Außerdem werden Sie lernen, arithmetische Operationen durchzuführen.\n",
"\n",
"Sie werden zudem beginnen, das Programmiervokabular zu erlernen, welches Begriffe wie Operator, Ausdruck, Wert und Datentyp enthält.\n",
"Dieses Vokabular ist wichtig – Sie werden es brauchen, um den Rest des Buches zu verstehen, um mit anderen Programmierer$*$innen zu kommunizieren und um virtuelle Assistenten zu nutzen und zu verstehen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Arithmetische Operatoren\n",
"\n",
"Ein **arithmetischer Operator** ist ein Symbol, das eine arithmetische Berechnung repräsentiert. Das Plus-Zeichen, `+`, führt zum Beispiel eine Addition durch."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"30 + 12"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Das Minus-Zeichen, `-`, ist der Operator, der zur Subtraktion dient."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"43 - 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der Asterisk, `*`, führt eine Multiplikation durch."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"6 * 7"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Und der Schrägstrich, `/`, führt eine Division durch:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"84 / 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hier sollte Ihnen auffallen, dass das Ergebnis der Division `42.0` und nicht `42` ist. Das liegt daran, dass es in Python zwei verschiedene Arten von Zahlen gibt: \n",
"\n",
"* **Ganze Zahlen** (Englisch: _integer_) und \n",
"\n",
"* **Gleitkommazahlen** (Englisch: _float_), die Zahlen mit einem Dezimalanteil repräsentieren (in Python wird der Dezimalanteil anders als im Deutschen durch einen Punkt und kein Komma dargestellt).\n",
"\n",
"Wenn Sie zwei ganze Zahlen addieren, subtrahieren oder multiplizieren, ist das Ergebnis eine ganze Zahl.\n",
"Wenn Sie jedoch zwei ganze Zahlen dividieren, ist das Ergebnis eine Gleitkommazahl.\n",
"Python stellt einen weiteren Operator, `//`, bereit, der eine **ganzzahlige Division** durchführt.\n",
"Das Ergebnis einer ganzzahligen Division ist immer eine ganze Zahl."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"84 // 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Division von ganzen Zahlen wird auf Englisch auch als \"floor division\" (Dt.: \"Bodendivision\") bezeichnet, da hierbei immer abgerundet wird, sozusagen dem \"floor\" (Dt.: \"Boden\") entgegen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"85 // 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zuletzt gibt es noch den Operator `**`, der eine Potenzierung durchführt:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In manchen Sprachen wird das Caret, `^`, für die Potenzierung verwendet, in Python ist dieses allerdings ein bitweiser Operator namens XOR.\n",
"Wenn Sie sich nicht mit bitweisen Operatoren auskennen könnte das folgende Ergebnis unerwartet sein:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"7 ^ 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bitweise Operatoren werden hier nicht weiter behandelt, sollten Sie sich für diese interessieren können Sie hier mehr darüber lesen: <https://de.wikipedia.org/wiki/Bitweiser_Operator>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ausdrücke\n",
"\n",
"Eine Ansammlung von Operatoren und Zahlen heißt **Ausdruck**.\n",
"Ein Ausdruck kann eine beliebige Anzahl von Operatoren und Zahlen enthalten.\n",
"Hier ist beispielsweise ein Ausdruck, der zwei Operatoren enthält."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"6 + 6 ** 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ihnen sollte hier auffallen, dass die Potenzierung vor der Addition stattfindet.\n",
"Python folgt der Reihenfolge der Rechenschritte, die Sie wahrscheinlich im Mathematikunterricht gelernt haben: Potenzen werden vor Multiplikationen und Divisionen berechnet, welche wiederum vor Additionen und Subtraktionen durchgeführt werden.\n",
"Im folgenden Beispiel findet die Multiplikation vor der Addition statt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"12 + 5 * 6"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn Sie die Addition als ersten Schritt durchführen möchten, können Sie hierfür Klammern verwenden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(12 + 5) * 6"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jeder Ausdruck hat einen **Wert**.\n",
"Der Ausdruck `6 * 7` hat zum Beispiel den Wert `42`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Arithmetische Funktionen\n",
"\n",
"Zusätzlich zu den arithmetischen Operatoren gibt es in Python auch noch einige **Funktionen**, die mit Zahlen arbeiten.\n",
"Die `round` Funktion nimmt zum Beispiel eine Gleitkommazahl und rundet sie auf die nächste ganze Zahl ab."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"round(42.4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"round(42.6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die `abs` Funktion berechnet den Betrag einer Zahl.\n",
"Für eine positive Zahl ist der Betrag die Zahl selbst."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abs(42)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Für eine negative Zahl ist der Betrag positiv."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abs(-42)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn wir eine solche Funktion verwenden, bezeichnet man das als ein **Aufrufen** der Funktion.\n",
"Ein Ausdruck, der eine Funktion aufruft ist ein **Funktionsaufruf**.\n",
"\n",
"Wenn Sie eine Funktion aufrufen, sind Klammern notwendig.\n",
"Lassen Sie diese weg, erhalten Sie eine Fehlermeldung.\n",
"\n",
"Wir können einer Funktion **Argumente** übergeben, diese werden immer nach dem Namen der Funktion in Klammern übergeben. \n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Anmerkung**: Die folgende Zelle verwendet `%%expect`, einen *magischer Befehl* von Jupyter. Der Befehl wird verwendet, wenn wir erwarten, dass der Code in dieser Zelle einen Fehler erzeugt. Mehr hierzu finden Sie im [Einführungsnotebook](seminar00.ipynb)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%%expect SyntaxError\n",
"\n",
"abs 42"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Sie können die erste Zeile der Meldung ignorieren, diese enthält keine Information, die Sie jetzt schon verstehen müssen.\n",
"In der zweiten Zeile ist der Code, der den Fehler enthält. Darunter befindet sich ein Caret (`^`), um die Stelle zu markieren, wo der Fehler gefunden wurde.\n",
"\n",
"Die letzte Zeile zeigt auf, dass es sich um einen **Syntaxfehler** handelt, was bedeutet, dass etwas mit der Struktur des Ausdrucks nicht stimmt. In dem vorliegenden Beispiel ist das Problem, dass ein Funktionsaufruf Klammern erfordert.\n",
"\n",
"Schauen Sie jetzt was passiert, wenn Sie die Klammern *und* den Wert weglassen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"abs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der Name einer Funktion alleine ist ein erlaubter Ausdruck, der einen Wert hat.\n",
"Wenn er dargestellt wird zeigt der Wert an, dass `abs` eine Funktion ist. Er enthält auch einige zusätzliche Informationen, die später erklärt werden sollen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Zeichenketten\n",
"\n",
"Außer Zahlen kann Python auch Abfolgen von Buchstaben repräsentieren, welche **Zeichenketten** (Englisch: _String_) heißen, da die Buchstaben aneinandergereiht werden wie Perlen auf eine Kette.\n",
"Um eine Zeichenkette zu schreiben können wir eine Buchstabenfolge in einfache gerade Anführungszeichen setzen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'Hello'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es ist auch erlaubt, doppelte gerade Anführungszeichen zu verwenden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\"world\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Doppelte gerade Anführungszeichen machen es einfach eine Zeichenkette zu schreiben, die einen Apostroph enthält, da dieser das gleiche Symbol verwendet wie ein einfaches gerades Anführungszeichen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\"it's a small \""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zeichenketten können auch Leerzeichen, Punktuation und Ziffern enthalten."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'Well, '"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der `+` Operator arbeitet mit Zeichenketten, er fügt zwei Zeichenketten zu einer einzelnen zusammen. Dieser Vorgang heißt **Konkatenation** oder **Verkettung**."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'Well, ' + \"it's a small \" + 'world.'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der `*` Operator funktioniert ebenfalls mit Zeichenketten, er macht Kopien von einer Zeichenkette und konkateniert diese."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'Spam, ' * 4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die anderen arithmetischen Operatoren funktionieren nicht mit Zeichenketten.\n",
"\n",
"Python bietet eine Funktion namens `len`, die die Länge einer Zeichenkette berechnet."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"len('Spam')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Beachten Sie, dass `len` nur die Buchstaben zwischen den Anführungszeichen zählt, nicht die Anführungszeichen selbst.\n",
"\n",
"Wenn Sie eine Zeichenkette erstellen ist es wichtig, gerade Anführungszeichen zu verwenden.\n",
"Der Gravis oder auch Abwärtsakzent (Englisch: _back quote_) verursacht einen Syntaxfehler."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%%expect SyntaxError\n",
"\n",
"`Hello`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Typografische Anführungszeichen sind ebenfalls nicht erlaubt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"‘Hello’"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Werte und Datentypen"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=1WqFJ5wsA4o&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=5')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bis jetzt haben wir drei Arten von Werten gesehen:\n",
"\n",
"* `2` ist eine ganze Zahl (Integer),\n",
"\n",
"* `42.0` ist eine Gleitkommazahl (Float) und \n",
"\n",
"* `'Hello'` ist eine Zeichenkette (String).\n",
"\n",
"Eine Art von Wert wird **Datentyp** genannt.\n",
"Jeder Wert hat einen Datentyp -- oder, wie es machmal ausgedrückt wird, \"gehört\" zu einem Datentyp.\n",
"\n",
"Python bietet eine Funktion namens `type`, die Ihnen den Datentyp eines Werts mitteilen kann.\n",
"Der Datentyp einer ganzen Zahl (Integer) ist `int`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der Datentyp einer Gleitkommazahl ist `float`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(42.0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Und der Datentyp eines Zeichenkette ist `str`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type('Hello, World!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Datentypen `int`, `float`, und `str` können als Funktionen verwendet werden.\n",
"`int` kann beispielsweise eine Gleitkommazahl nehmen und diese in eine ganze Zahl umwandeln (rundet immer ab)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"int(42.9)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Und `float` kann eine ganze Zahl in eine Gleitkommazahl umwandeln."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"float(42)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nun kommt ein Punkt, der möglicherweise etwas verwirrend ist.\n",
"Was erhalten Sie, wenn Sie eine Zahlenabfolge in Anführungszeichen setzen?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'126'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es sieht wie eine Zahl aus, ist aber eigentlich eine Zeichenkette."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type('126')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn Sie versuchen, es wie eine Zahl zu verwenden, erhalten Sie möglicherweise eine Fehlermeldung."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%%expect TypeError\n",
"\n",
"'126' / 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dieses Beispiel generiert einen `TypeError`, das bedeutet, dass die Werte im Ausdruck, die als **Operanden** bezeichnet werden, den falschen Datentyp haben.\n",
"Die Fehlermeldung drückt aus, dass der `/` Operator die Datentypen der Werte, in diesem Fall `str` und `int`, nicht unterstützt.\n",
"\n",
"Wenn Sie eine Zeichenkette haben, die Ziffern enthält, können Sie `int` verwenden, um diese in eine ganze Zahl umzuwandeln."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"int('126') / 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn Sie eine Zeichenkette haben, die Ziffern und einen Dezimalanteil enthält, können Sie `float` verwenden, um diese in eine Gleitkommazahl umzuwandeln."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"float('12.6')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn Sie eine große ganze Zahl schreiben sind Sie möglicherweise versucht, Kommata zwischen Gruppen von Ziffern zu verwenden, wie beispielsweise bei `1,000,000` (die Kommata werden hier so verwendet, wie im Deutschen bei großen Zahlen Punkte verwendet werden würden).\n",
"Dies ist ein erlaubter Ausdruck in Python, das Ergebnis ist allerdings keine ganze Zahl."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"1,000,000"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python interpretiert `1,000,000` als eine Sequenz von ganzen Zahlen, die durch Kommata getrennt werden.\n",
"Wir werden über diese Art von Sequenz später noch mehr lernen.\n",
"\n",
"Sie können stattdessen Unterstriche verwenden, um große Zahlen besser lesbar zu machen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"1_000_000"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick: \n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Formale und natürliche Sprachen\n",
"\n",
"Besonders ausführlich wird der Unterschied zwischen natürlicher und formaler Sprache in [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) des englischen Buchs behandelt.\n",
"\n",
"Grundsätzlich jedoch sind **natürliche Sprachen** Sprachen, die gesprochen werden, wie zum Beispiel Deutsch, Englisch oder Französisch. Sie werden nicht von Menschen entworfen und entwickeln sich natürlich.\n",
"\n",
"**Formale Sprachen** sind von Menschen für bestimmte Zwecke entworfene Sprachen. Das hier relevanteste Beispiel sind **Programmiersprachen**.\n",
"Sie haben meist sehr strenge **Syntax-Regeln**, die ihre Struktur bestimmen. Dabei gibt es Regeln zu den erlaubten Zeichen und zu der erlaubten Struktur. Während der menschliche **Parser** häufig mit sprachlichen Regelbrüchen umgehen kann, kann es der **Parser** im Computer nicht.\n",
"\n",
">Die§ ist ein gr@mmatikalisch k0rrekter S@tz mit ungültigen Zeichen. Satz dieser nur erlaubte Zeichen aber Grammatik falsche hat. \n",
"\n",
"Wichtige Unterschiede sind, dass natürliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exkurs: Programmierer*innen\n",
"\n",
"Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wie hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden \"Streit\"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:\n",
"\n",
"\n",
"\n",
"([Real Programmers](https://xkcd.com/378/), Randall Munroe)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Debugging\n",
"\n",
"Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben nennt man **debugging**. Dies kann zu starken (negativen) Gefühlen führen. \n",
"Es lässt sich darauf zurückführen, dass wir Computer unterbewusst wie Menschen behandeln und darum auf unkooperative Computer genauso reagieren wie auf unkooperative Mitmenschen. Es kann helfen darauf vorbereitet zu sein und den Computer als Mitarbeiter zu sehen, der sehr schnell und gut rechnen kann aber sehr genaue Anweisungen braucht.\n",
"\n",
"Obwohl es sehr frustrierend sein kann, zu lernen wie man diese Fehler findet und behebt, ist es eine wertvolle Fähigkeit und wir werden uns in dieser Kategorie regelmäßig Tipps und Strategien des Debugging anschauen, die Ihnen hoffentlich helfen. \n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:\n",
"\n",
"- Programm:\n",
"- Operator:\n",
"- Wert: \n",
"- Datentyp: \n",
"- Zeichenkette:\n",
"- ganze Zahl:\n",
"- Gleitkommazahl:\n",
"- bug:\n",
"- debugging:\n",
"\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit. \n",
"Sollten Sie einmal nicht weiterkommen, schauen Sie im Glossar von *Think Python* nach oder fragen Sie noch einmal nach."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Übung\n",
"\n",
"Diese Übung ist ein wichtiger Teil des Seminars. Bitte fahren Sie erst fort, wenn Sie die Aufgaben selbständig lösen konnten. Sie geben Ihnen die Möglichkeit, das Gelernte zu überprüfen und zu vertiefen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Diese Zelle weist Jupyter an, detaillierte Debugging-Informationen bereitzustellen. \n",
"# Führen Sie diese aus, bevor Sie an den Übungen arbeiten.\n",
"%xmode Verbose\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fragen Sie einen virtuellen Assistenten\n",
"\n",
"Während Sie sich durch dieses Buch arbeiten gibt es verschiedene Arten, auf die Sie einen virtuellen Assistenten oder Chatbot nutzen können, um Ihnen beim Lernen zu helfen.\n",
"\n",
"* Wenn Sie mehr über ein in einem Kapitel behandeltes Thema wissen wollen, oder etwas noch nicht ganz verstanden haben, können Sie einen virtuellen Assistenten nach Erklärungen fragen.\n",
"\n",
"* Wenn Ihnen die Übungen Schwierigkeiten bereiten, können Sie um Hilfe fragen.\n",
"\n",
"Ich werde Ihnen in jedem Kapitel Übungen vorschlagen, die Sie mit einem virtuellen Assistenten bearbeiten können. Ich ermutige Sie aber auch dazu, selbst Dinge zu testen, um herausuzufinden, was für Sie am besten funktioniert.\n",
"\n",
"Sie können zum Beispiel die [Sprachmodelle der HU](https://ki.cms.hu-berlin.de/de/large-language-models-an-der-hu) nutzen, sofern Sie sich im Netz der HU befinden oder sich [per VPN verbunden](https://www.cms.hu-berlin.de/de/dl/netze/vpn) haben.\n",
"\n",
"Hier sind einige Themen, zu denen Sie einen virtuellen Assistenten befragen könnten:\n",
"\n",
"* Weiter oben habe ich bitweise Operatoren erwähnt, aber nicht erklärt warum der Wert von `7 ^ 2` 5 ist. Versuchen Sie zu fragen \"Was sind bitweise Operatoren in Python?\" oder \"Was ist der Wert von `7 XOR 2`?\".\n",
"\n",
"* Ich habe außerdem die Reihenfolge von Operationen erwähnt. Für mehr Details dazu, fragen Sie \"Was ist die Reihenfolge der Operationen in Python?\".\n",
"\n",
"* Die `round` Funktion, die wir verwenden um eine Gleitkommazahl zu nächsten ganzen Zahl zu runden, kann ein zweites Argument aufnehmen. Versuchen Sie zu fragen \"Was sind die Argumente der round-Funktion?\" oder \"Wie runde ich pi auf drei Nachkommastellen ab?\".\n",
"\n",
"* Es gibt einen weiteren arithmetischen Operator, den ich bisher nicht beschrieben habe. Versuchen Sie daher zu fragen: \"Was ist der modulus Operator in Python?\".\n",
"\n",
"Die meisten virtuellen Assistenten kennen Python, daher beantworten Sie Fragen wie diese in der Regel recht zuverlässig.\n",
"Aber denken Sie immer daran, dass diese Tools Fehler machen können.\n",
"Wenn Sie Code von einem Chatbot erhalten, testen Sie diesen!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 1\n",
"\n",
"Sie fragen sich vielleicht, was `round` tut, wenn eine Zahl mit `0.5` endet.\n",
"Die Antwort ist, dass es manchmal auf- und manchmal abrundet.\n",
"Testen Sie diese Beispiele und versuchen Sie herauszufinden, welcher Regel das Runden der Zahlen folgt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"round(42.5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"round(43.5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 2\n",
"\n",
"Wenn Sie ein neues Feature kennenlernen ist es sinnvoll, dieses auszuprobieren und dabei mit Absicht Fehler zu machen.\n",
"Auf diese Art lernen Sie die Fehlermeldungen und wissen bereits was diese bedeuten, wenn Sie Ihnen später erneut begegnen. Es ist besser, jetzt absichtlich Fehler zu machen, als später ausversehen.\n",
"\n",
"1. Sie können ein Minus-Zeichen verwenden, um eine negative Zahl wie `-2` darzustellen. Was passiert, wenn Sie ein Plus-Zeichen vor eine Zahl setzen? Was ergibt sich aus `2++2`?\n",
"\n",
"2. Was passiert, wenn Sie zwei Werte ohne Operator dazwischen haben, wie beispielsweise `4 2`?\n",
"\n",
"3. Wenn Sie eine Funktion wie `round(42.5)` aufrufen, was passiert, wenn Sie eine oder beide Klammern weglassen?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Aufgabe 3\n",
"\n",
"Nutzen Sie Python als Taschenrechner: Keine Sorge, während Sie hier zwar Textaufgaben lösen müssen ist dies nicht das Ziel der Übung. Wenn Sie nicht weiterkommen schauen Sie sich zuerst die Hinweise an und fragen Sie gegebenenfalls um Hilfe. Es geht hier darum zu verstehen, wie man diese Aufgabe in Python lösen kann, der Rechenweg ist eher Zweitrangig.\n",
"\n",
"- Wie viele Sekunden entsprechen 42 Minuten und 42 Sekunden?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
"\n",
"2562 Sekunden\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Wie viele Meilen entsprechen 10 Kilometern? \n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Eine Meile ist 1.61 Kilometer lang.\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
"\n",
"6.21 Meilen\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (**Zeit pro Meile** in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in **Meilen pro Stunde**?\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-info\">Hinweise</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"1. Zuerst müssen Sie herausfinden wie viele Meilen das Rennen lang ist. Das können Sie im vorherigen Teil der Aufgabe erfahren. <br> \n",
"2. Rechnen Sie zudem die Zeit in Sekunden um. Dazu können Sie wieder die Lösung aus dem vorherigen Teil der Aufgabe nehmen. <br>\n",
"3. Um die Zeit pro Meile zu errechnen, müssen Sie die Gesamtzeit durch die Anzahl an Meilen teilen. Rechnen Sie anschließend die Zeit von Sekunden in Minuten pro Meile um. <br>\n",
"4. Um dann die Geschwindigkeit in Meilen pro Stunde zu berechnen gehen Sie analog vor. Teilen Sie die Gesamtzahl an Meilen durch die Gesamtdauer des Rennens. Rechnen Sie anschließend das Ergebnis von **Meilen pro Sekunde** in **Meilen pro Stunde** um.\n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
" \n",
"Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde.\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü *File* den Punkt *Download as* → *Notebook* auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). \n",
"\n",
"\n",
"Herzlichen Glückwunsch! Sie haben das erste Kapitel geschafft!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/by-nc-sa.png\" alt=\"CC BY-NC-SA\" style=\"width: 150px;\"/>\n",
"\n",
"Der Text dieses Notebooks ist als freies Werk unter der Lizenz [CC BY-NC-SA 4.0 ](https://creativecommons.org/licenses/by-nc-sa/4.0/) verfügbar.\n",
"Der Code dieses Notebooks ist als freies Werk unter der Lizenz [MIT License](https://mit-license.org/) verfügbar.\n",
"\n",
"Es handelt sich um übersetzte und leicht veränderte Notebooks von [Allen B. Downey](https://allendowney.com) aus [Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html).\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "",
"name": ""
},
"language_info": {
"name": "python",
"pygments_lexer": "ipython3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}