seminar01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seminar Problemorientierte Programmierung\n",
    "\n",
    "\n",
    "## 1: Die ersten Programme\n",
    "\n",
    "siehe http://greenteapress.com/thinkpython2/html/thinkpython2002.html\n",
    "\n",
    "### Ihre Lernziele\n",
    "\n",
    "Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:\n",
    "\n",
    "- \n",
    "- \n",
    "- "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exkurs: Was mir an Python gefällt\n",
    "\n",
    "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
    "\n",
    "Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:"
   ]
  },
  {
   "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(\"Sie wurden an einem\", datum.strftime(\"%A\"), \"geboren.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Programme\n",
    "\n",
    "Was ist ein Programm?\n",
    "\n",
    "> a sequence of instructions that speci\u001c",
    "es how to perform a computation\n",
    "\n",
    "In jeder Programmiersprache sind die Details etwas anderes, aber es gibt ein paar grundlegende Instruktionen, die es in so gut wie jeder Programmiersprache gibt:\n",
    "\n",
    "- **input:** get data from keyboard, \u001c",
    "le, network, or some other device\n",
    "- **output:** display data on screen, save in a \u001c",
    "file, send over network, etc.\n",
    "- **math:** perform basic mathematical operations (addition, multiplication, ... )\n",
    "- **conditional execution:** check for certain conditions and run appropriate code\n",
    "- **repetition:** perform some action repeatedly, usually with some variation\n",
    "\n",
    "Das ist's im Wesentlichen. Jedes Programm welches Sie schon einmal verwendet haben, besteht im Grunde nur aus diesen Bausteinen. Programmieren heißt also, ein großes Problem in viele kleine Aufgaben zu zerlegen, die sich damit lösen lassen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### eine erste Anweisung\n",
    "\n",
    "Der Grundbaustein eines jeden Programs ist die **Anweisung** - jedes Programm ist eine Folge von Anweisungen. Ein einfaches Programm mit nur einer Anweisung ist das berühmte *Hello World* (Exkurs: [Warum \"Hello World\"?](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Sie können das Programm aufrufen, indem Sie in die Box mit dem Programm klicken und dann auf den \"Play\"-Button oben klicken oder die Tastenkombination `STRG+ENTER` drücken oder \"Run Cells\" im \"Cell\"-Menü aufrufen.)\n",
    "\n",
    "Diese Anweisung ruft die **Funktion** `print` auf und übergibt ihr das **Argument** \"Hello World!\", was in diesem Fall eine **Zeichenkette** ist (das erkennen wir an den Gänsefüßchen). Die Argumente einer Funktion werden immer nach dem Namen der Funktion in Klammern übergeben.  \n",
    "\n",
    "Das Ergebnis dieses Funktionsaufrufs ist, dass die Zeichenkette auf dem Bildschirm ausgegeben wird.\n",
    "\n",
    "Probieren Sie es nun selber und geben Sie eine Zeichenkette Ihrer Wahl aus, indem Sie die Zeichenkette in Gänsefüßchen der `print`-Funktion als Argument (zwischen den Klammern) übergeben: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zusammengefasst: `print(\"Hello World!\")` ist eine Anweisung, die eine Funktion aufruft und aus den folgenden Bestandteilen besteht:\n",
    "- dem Namen der Funktion, die aufgerufen wird - `print`\n",
    "- den Argumenten, die der Funktion übergeben werden - in Klammern `()` eingeschlossen\n",
    "- konkret, dem Argument `\"Hello World!\"` - einer Zeichenkette, die mit Gänsefüßchen `\"\"` eingeschlossen ist\n",
    "\n",
    "Jeglicher Aufruf einer Funktion besteht im Wesentlichen aus diesen Bestandteilen. \n",
    "\n",
    "### Python-Programme starten\n",
    "\n",
    "Wenn Sie ein Programm (eine der vielen Boxen mit Python-Code hier) starten, dann starten Sie im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches Ihren Python-Code liest, für den Computer übersetzt und ausführt. Sie können den Python-Interpreter auch ohne Jupyter aufrufen und dann direkt Python-Anweisungen eingeben oder Programme starten, die Sie 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",
    "### Arithmetik\n",
    "\n",
    "Neben Zeichenketten sind Zahlen ein wichtiges Mittel zur Informationsdarstellung. Sie können mit der `print`-Funktion auch Zahlen ausgeben, diese müssen Sie nicht in Gänsefüßchen einschließen:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die 17 ist eine **ganze Zahl** (Englisch: *Integer*), sie können aber auch Zahlen mit Dezimalanteil, sogenannte **Fließkommazahlen** (Englisch: *Float*) verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3.149265)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dazu verwenden wir als Dezimaltrennzeichen den Punkt `.`, nicht das Komma. (Weil das Komma eher in Deutschland verbreitet ist und der Punkt in den Ländern, in denen Python entwicklt wurde.)\n",
    "\n",
    "Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division) und `**` (Exponentiation). \n",
    "\n",
    "Wir können eine Berechnung direkt mit `print` ausgeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 + 2 + 3 + 4 + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probieren Sie es selbst aus für folgende Berechnungen:\n",
    "- 40 + 2\n",
    "- 43 - 1\n",
    "- 6 * 7\n",
    "- 84 / 2\n",
    "- `6**2 + 6`\n",
    "indem Sie die folgende Anweisung ändern oder ergänzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(40 + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tipp: Sie können auch mehrere Anweisungen hintereinander ausführen, indem Sie sie als **Folge** von Anweisungen zeilenweise untereinander schreiben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Der Umfang eines Kreises mit dem Radius 3 ist:\")\n",
    "print(2 * 3.1415926 * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Werte und Datentypen\n",
    "\n",
    "Ein **Wert**, also z.B. eine Zahl oder eine Zeichenkette, ist eines der grundlegenden Dinge, die in einem Programm verarbeitet werden. Beispiele für Werte, die Sie schon gesehen haben sind `\"Hello World!\"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:\n",
    "- `\"Hello World!\"` ist eine **Zeichenkette** (*string* auf Englisch)\n",
    "- `17` ist eine **ganze Zahl** (*integer* auf Englisch)\n",
    "- `3.1415926` ist eine **Fließkommazahl** (*float* auf Englisch)\n",
    "\n",
    "Wenn Sie sich nicht sicher sind, welchen Datentyp ein Wert hat, können Sie es mit der Funktion `type` herausfinden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese gibt Ihnen - je nach Datentyp - die englischen Abkürzungen `str`, `int` und `float` zurück (die *string*, *integer* und *float* entsprechen). Probieren Sie es selbst aus, mit verschiedenen Werten, z.B. 2, 42.0, usw.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Übrigens: `type` funktioniert auch mit anderen Arten von \"Typen\". Probieren Sie es mal aus, indem Sie der `type`-Funktion die `print`-Funktion übergeben: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was ist mit Werten wie z.B. `\"42\"` oder `\"3.14\"`? Sie sehen wie Zahlen aus, aber wir haben Sie mit Gänsefüßchen umfasst wie bei Zeichenketten? Finden Sie heraus, welchen Typ diese beiden Werte haben, indem Sie sie als Argument in den folgenden Funktionsaufruf einsetzen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sind es Zeichenketten oder Zahlen?\n",
    "\n",
    "### Formale und natürliche Sprachen\n",
    "\n",
    "Exkurs: Wenn Ihnen der Unterschied zwischen einer natürlichen Sprache (z.B. Englisch) und einer formalen Sprache (z.B., der Programmiersprache Python) noch nicht ganz klar ist, lesen Sie den [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) im Python-Kurs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exkurs: Programmierer\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",
    "![Real programmers set the universal constants at the start such that the universe evolves to contain the disk with the data they want.](https://imgs.xkcd.com/comics/real_programmers.png)\n",
    "\n",
    "([Real Programmers](https://xkcd.com/378/), Randall Munroe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "Unter der Rubrik \"Debugging\" werden wir uns regelmäßig am Ende eines Kapitels Tipps zum Finden und Beheben von Fehlern anschauen.\n",
    "\n",
    "Exkurs: Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Fehler sind ärgerlich und können zu bösartigen Gefühlen dem Computer gegenüber führen ... lesen Sie im [Abschnitt 1.7](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec12), wie Sie damit umgehen können.\n",
    "\n",
    "![Computerweitwurf](https://media.giphy.com/media/L4AQvif7x9fS8/giphy.gif)"
   ]
  },
  {
   "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",
    "- Anweisung: \n",
    "- Programm: \n",
    "- `print`-Funktion: gibt den übergebenen Wert auf dem Bildschirm aus\n",
    "- Argument:\n",
    "- Operator:\n",
    "- Wert: \n",
    "- Datentyp: \n",
    "- Zeichenkette:\n",
    "- ganze Zahl:\n",
    "- Fließkommazahl:\n",
    "- bug:\n",
    "- debugging:\n",
    "\n",
    "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zusammenfassung\n",
    "\n",
    "Neben vielen neuen Begriffen haben wir folgende wichtige Programmierfähigkeiten gelernt:\n",
    "- wir können Werte und Berechnungen durchführen und mit Hilfe der `print`-Funktion ausgeben\n",
    "- wir können die Datentypen Zeichenkette, ganze Zahl und Fließkommazahl voneinander unterscheiden und den Datentyp eines gegebenen Wertes mit Hilfe der `type`-Funktion herausfinden\n",
    "- wir können mehrere Anweisungen hintereinanderausführen, indem wir sie als Folge zeilenweise untereinander schreiben"
   ]
  },
  {
   "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.\n",
    "\n",
    "#### Aufgabe 1\n",
    "\n",
    "Wann immer Sie etwas neues ausprobieren, sollten Sie versuchen, absichtlich einen Fehler zu machen. Probieren Sie z.B. \n",
    "- Was passiert, wenn Sie im \"Hello World\"-Programm eines der Gänsefüßchen weglassen?\n",
    "- Was passiert, wenn Sie beide weglassen?\n",
    "- Was passiert, wenn sie `print` falsch schreiben?\n",
    "Probieren Sie es aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solche Experimente helfen Ihnen, sich das, was Sie gelesen haben, einzuprägen. Und Sie werden mit Fehlermeldungen vertraut und haben eine Ahnung, was Sie bedeuten können. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen Sie Programmieren nur, indem Sie es tun.\n",
    "\n",
    "Probieren Sie folgendes aus:\n",
    "\n",
    "- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")\n",
    "print(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Negative Zahlen können Sie mit einem Minuszeichen darstellen: `-2`. Was passiert, wenn Sie ein Plus-Zeichen vor eine Zahl stellen? Was ergibt `2++2`? Was ergibt `2+-+2`? Probieren Sie es mit verschiedenen Kombinationen von Plus- und Minus-Zeichen aus, bis Ihnen klar ist, was passiert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In der Mathematik ist es kein Problem, eine Null vor einer Zahl zu schreiben: 02 ist gleich 2. Was passiert, wenn Sie das in Python probieren?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Was passiert, wenn Sie zwei Werte ohne Operator dazwischen haben?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 2\n",
    "\n",
    "Nutzen Sie Python als Taschenrechner:\n",
    "\n",
    "- Wieviele Sekunden entsprechen 42 Minuten und 42 Sekunden?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Wieviele Meilen entsprechen 10 Kilometer (Hinweis: eine Meile ist 1.61 Kilometer lang)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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 Kilometer in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in Kilometer pro Stunde?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Smiley](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b9/Emblem-cool.svg/200px-Emblem-cool.svg.png)\n",
    "\n",
    "Herzlichen Glückwunsch! Sie haben das 1. Kapitel geschafft. Weiter geht es in [2: Variablen, Ausdrücke und Anweisungen](seminar02.ipynb)."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}