python_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Crashcourse\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "#### Gabi Röger, Marcel Lüthi, Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Python\n",
    "\n",
    "* interpretierte High-Level-Programmiersprache\n",
    "* unterstützt imperative, objekt-orientierte und funktionale Programmierung\n",
    "* gut lesbarer Code\n",
    "* Produktiv: \"Knapper Code für viel Funktionalität\"\n",
    "* umfangreiche Bibliotheken\n",
    "* Ausführung oftmals langsamer als mit kompilierten Sprachen\n",
    "* Nicht geeignet für grosse Programme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##  Grundlagen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Kommentare\n",
    "\n",
    "Inline-Kommentare beginnen mit `#`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dies ist ein Kommentar.\n",
    "a = 3 # das geht auch am Ende einer Zeile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Man kann aber auch mehrzeilige Kommentare\n",
    "# schreiben, indem man einfach mehrere einzeilige\n",
    "# hintereinanderschreibt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Variablen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Variablen haben keinen Typ, sondern nur die Objekte, auf die sie referenzieren. Die Typprüfung passiert erst zur Laufzeit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 3\n",
    "a/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = \"jetzt referenziert die Variable einen String\"\n",
    "a/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Einrückung\n",
    "\n",
    "*Einrückung ist wichtig!*\n",
    "* Zusammengehörende Blöcke müssen gleich eingerückt sein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Richtig\n",
    "a = 5\n",
    "b = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Falsch\n",
    "a = 5\n",
    "  b = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Kontrollstrukturen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### if/elif/else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x ist positiv\")\n",
    "elif x == 0:\n",
    "    print(\"x ist Null\")\n",
    "else:\n",
    "    print(\"x ist negativ\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Einrückungen\n",
    "\n",
    "Einrücken definiert zusammenhängende Blöcke (statt {} in Java)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "\n",
    "if x > 0:\n",
    "    print(\"in if\")\n",
    "    print(\"noch in if\")\n",
    "    \n",
    "print(\"nicht mehr in x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### while- und for-Schleife"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while x > 0:\n",
    "    print(x)\n",
    "    x = x - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for x in range(5, 0):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Range\n",
    "\n",
    "`range(start, stop[, step])` generiert Zahlen von start bis (exklusive) stop mit Schrittweite step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(4, 16, 2):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(5, -5, -3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Break und Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sprung aus der Schleife mit `break`, Sprung zur nächsten Schleifeniteration mit `continue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0, 10):\n",
    "    if x % 2 == 1:\n",
    "        continue\n",
    "    if x == 3:\n",
    "        break\n",
    "    print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Logische Verknüpfungen\n",
    "\n",
    "Logische Verknüpfung in Bedingungen erreicht man mit `and`, `or`, `not`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "y = 3\n",
    "\n",
    "print((x > 5) and (y < 3) or (not x == 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listen und Tupel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listen\n",
    "\n",
    "*Listen* enthalten Folgen von Objekten\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [3, \"Hund\", \"Katze\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tupel\n",
    "\n",
    "Wie Listen, aber nicht veränderbar. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (\"Superpapagei\", 31, \"Bob\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Indizierung\n",
    "Sequenzen können von vorne (nicht-negative Zahlen) oder hinten (negative Zahlen) indiziert werden.\n",
    "\n",
    "Das vorderste Element hat Index 0, das letze Index -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (4, 5, 2, 9)\n",
    "print(t[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Listenoperationen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [\"Hund\", \"Katze\", 32]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Zuweisung\n",
    "l[2] = \"Superpapagei\"\n",
    "print(\"nach Zuweisung\", l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Erweitern\n",
    "l.append(\"cat\")\n",
    "print(\"nach Erweiterung: \", l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "## Länge bestimment\n",
    "print(len(l))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tupel unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Tupel unpacking* \"entpackt\" Werte auf der rechten Seite, um sie Variablen in Tupel auf der linken Seite zuzuweisen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(number, name) = (3, \"Johann Gambolputty\")\n",
    "print(number)\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variablen vertauschen\n",
    "\n",
    "Mit Tupel unpacking können Variablen elegant vertauscht werden:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 7\n",
    "(a, b) = (b, a)\n",
    "print((a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funktioniert auch ohne Klammer:\n",
    "```a, b = b, a```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funktionen und Klassen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funktionen \n",
    "\n",
    "Funktionen werden wie folgt deklariert:\n",
    "\n",
    "(Beachten Sie den Doppelpunkt nach der Methodensignatur)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(base, exponent):\n",
    "    return base ** exponent   # base \"hoch\" exponent\n",
    "\n",
    "power(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Klassen \n",
    "\n",
    "* Werden mit dem Schlüsselwort ```class``` deklariert\n",
    "* Methoden bekommen explizite Referenz auf ```self``` (```this```in Java)\n",
    "* Konstruktor ist spezielle Methode ```__init__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fraction:\n",
    "    \n",
    "    numerator = 0\n",
    "    denominator = 0\n",
    "    \n",
    "    def __init__(self, numerator, denominator):\n",
    "        self.numerator = numerator\n",
    "        self.denominator = denominator\n",
    "            \n",
    "    def printFraction(self):\n",
    "        print(self.numerator, \"/\", self.denominator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Objekte\n",
    "\n",
    "* Instanzen von Klassen werden durch Aufruf von Klassennamen und Konstruktorargumente (aber ohne ```new```) erzeugt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Fraction(3, 5)\n",
    "f.printFraction()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Übungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* Schreiben Sie ein Programm, welches das kleine 1 x 1 berechnet (also die 1-er bis 9-er Reihe ausgibt). Nutzen Sie dazu zwei ineinander verschachtelte ```for```-loops. \n",
    "    * Um etwas auszugeben nutzen Sie die ```print``` Funktion. \n",
    "    * Wenn Sie keinen Zeilenumbruch wollen, schreiben Sie ```print(\"mein test\", end='')``` \n",
    "* Definieren Sie eine Funktion ```bmi``` welche für ein gegebene Grösse und Gewicht den BMI berechnet\n",
    "* Experimentieren Sie mit der Sichtbarkeit von Variablen. Sind Variablen ausserhalb eines Blocks sichtbar? Und Ausserhalb einer Funktion?\n",
    "* Schreiben Sie eine Funktion, die eine Liste von Zahlen entgegennimmt und das Minimum und Maximum davon zurückgibt. \n",
    "* Ergänzen Sie die Klasse ```Fraction```, so dass Brüche multipliziert und addiert werden können. Schreiben Sie auch eien Methode ```reduce```, welche einen neuen, gekürzten Bruch zurückgibt. \n",
    "* Versuchen Sie selection sort zu implementieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}