13_praxis_python_filled.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e0c58392",
   "metadata": {},
   "source": [
    "# Gleiche Konzepte, andere Sprache\n",
    "## Beispiel 1: Python\n",
    "#### Patrick Schnider, Marcel Lüthi<br/>Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8264f3ec-30b3-445b-8976-0fe83dc0b171",
   "metadata": {},
   "source": [
    "In diesem Notebook werden Sie sehen, dass Sie, wenn Sie die Grundkonzepte der Programmierung verstehen, auch mit neuen Programmiersprachen sehr schnell einfache Programme schreiben können. Die erste Sprache, an der wir das illustrieren ist Python.\n",
    "\n",
    "### Grundbausteine\n",
    "\n",
    "Das einzige, was Sie an dieser Stelle wissen müssen, ist, dass Python Codeblöcke nicht wie Java über Klammern ```{...}``` trennt, sondern über Einrückungen. Im Gegensatz zu Java ist es bei Python also wichtig, wie weit rechts eine Zeile Code steht.\n",
    "\n",
    "#### Übung\n",
    "* Gehen Sie Zelle für Zelle durch die folgenden einfachen Codebeispiele\n",
    "* Welche Grundbausteine der Programmierung werden hier verwendet?\n",
    "* Welche Ausgabe erwarten Sie? Lassen Sie die Zellen laufen und vergleichen Sie die tatsächliche Ausgabe mit Ihrer Erwartung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0743a18d-c481-42d3-96b6-8655ffbadc2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World\")\n",
    "print(1 + 1)\n",
    "# Dies ist ein Kommentar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e8feaa7-15f7-44b2-8b95-9bfec654eff2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 5\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80bb1b06-2504-4d8b-a6fc-005c41f3cf74",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4]\n",
    "print(l)\n",
    "print(l[2])\n",
    "l.append(5)\n",
    "l[2] = 7\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2ecd2dc-8e16-4e87-be71-e879c18acf0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "for element in l:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eb62194-f7b0-45a6-a1cb-b925ff1770b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edcc3244-a669-486a-8f61-fec7aa5116b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a,b):\n",
    "    return a + b\n",
    "\n",
    "c = add(3,5)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99542fb7-6145-4112-be16-2484116a2c64",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def circumference(r):\n",
    "    return 2 * math.pi * r\n",
    "\n",
    "print(circumference(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5060944-d53c-46a1-b99b-1321c1fa81ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_even(n):\n",
    "    if n % 2 == 0:\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "        \n",
    "is_even(5)\n",
    "is_even(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb9cef2-68ee-4273-94e7-f67912036c62",
   "metadata": {},
   "source": [
    "Die obigen Codebeispiele geben uns genügend Information über die Syntax von Python, dass wir selber kleine Programme schreiben können. Als Beispiel möchten wir eine Methode schreiben, die die $n$'te Fibonacci-Zahl $f_n$ berechnet. Zur Erinnerung, die Fibonacci-Zahlen sind wie folgt definiert:\n",
    "* $f_0=f_1=1$\n",
    "* $f_n=f_{n-1} + f_{n-2}$\n",
    "\n",
    "#### Übung\n",
    "* Schreiben Sie eine Methode, die die $n$'te Fibonacci-Zahl berechnet und zurückgibt.\n",
    "* Schreiben Sie danach eine Liste, die die Fibonacci-Zahlen $f_0$,...,$f_6$ enthält."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90f51012-1af2-420a-8635-be8e632d7968",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    return fibonacci(n-1) + fibonacci(n-2)\n",
    "\n",
    "fib_list = []\n",
    "for i in range(0,7):\n",
    "    fib_list.append(fibonacci(i))\n",
    "    \n",
    "print(fib_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0060762-0ad3-4e41-9f7e-d5ebdcdfa9b9",
   "metadata": {},
   "source": [
    "### Objektorientierung\n",
    "\n",
    "Auch in Python kann man eigen Klassen schreiben. Als Beispiel hier eine Klasse, die komplexe Zahlen repräsentiert, und Addition und Multiplikation erlaubt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22bd3263-d658-40d6-b458-d3d2af28976f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class complex_num:\n",
    "    \n",
    "    # Konstruktor\n",
    "    def __init__(self, real, imag):\n",
    "        self.real = real\n",
    "        self.imag = imag\n",
    "    \n",
    "    # Definiert Addition\n",
    "    def add(self, other):\n",
    "        new_real = self.real + other.real\n",
    "        new_imag = self.imag + other.imag\n",
    "        return complex_num(new_real, new_imag)\n",
    "    \n",
    "    # Definiert Multiplikation\n",
    "    def multiply(self, other):\n",
    "        new_real = self.real * other.real - self.imag * other.imag\n",
    "        new_imag = self.real * other.imag + self.imag * other.real\n",
    "        return complex_num(new_real, new_imag)\n",
    "    \n",
    "    # Definiert die Darstellung in einem String\n",
    "    def __str__(self):\n",
    "        return \"{} + {}i\".format(self.real, self.imag)\n",
    "    \n",
    "\n",
    "# Test    \n",
    "a = complex_num(3,4)\n",
    "b = complex_num(1,2)\n",
    "print(a.add(b))\n",
    "print(a.multiply(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0da17737-2e4a-4875-8197-be5c4895a9ec",
   "metadata": {},
   "source": [
    "#### Übung\n",
    "* Schreiben Sie eine Klasse ```complex_vec```, die 2-Dimensionale Vektoren von komplexen Zahlen repräsentieren, d.h., Tupel $(a,b)$, wobei $a,b\\in\\mathbb{C}$.\n",
    "* Die Klasse soll eine Methode ```scalar_product``` haben, die das Skalarprodukt von zwei Vektoren berechnet. Zur Erinnerung, das Skalarprodukt von zwei Vektoren $X=(x_1, x_2)$ und $Y=(y_1, y_2)$ ist definiert als $x_1\\cdot y_1 + x_2\\cdot y_2$. In unserem Fall ist das Ergebnis also eine komplexe Zahl."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81e4b5b5-c9c1-46cd-811b-c62d5da74a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class complex_vector:\n",
    "    \n",
    "    def __init__(self, z1, z2):\n",
    "        self.z1 = z1\n",
    "        self.z2 = z2\n",
    "        \n",
    "    def scalar_product(self, other):\n",
    "        prod1 = self.z1.multiply(other.z1)\n",
    "        prod2 = self.z2.multiply(other.z2)\n",
    "        return prod1.add(prod2)\n",
    "    \n",
    "a = complex_num(3,4)\n",
    "b = complex_num(1,2)\n",
    "c = complex_num(5,3)\n",
    "d = complex_num(1,1)\n",
    "X = complex_vector(a,b)\n",
    "Y = complex_vector(c,d)\n",
    "print(X.scalar_product(Y))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:python_eidp_env]",
   "language": "python",
   "name": "conda-env-python_eidp_env-py"
  },
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}