doc/2-2-syntax-errors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Konzept 2: Syntax und Fehler\n",
    "\n",
    "## Syntax\n",
    "\n",
    "Jedes Computerprogramm ist -- so wie die mathematische Formelsprache -- eine [formalisierte Sprache](http://en.wikipedia.org/wiki/Formal_language).\n",
    "Das heißt, jeder Buchstabe und jedes Zeichen muss strengen formalen Regeln genügen,\n",
    "um vom Compiler oder Interpreter der Programmiersprache korrekt verstanden zu werden.\n",
    "Das heißt, bevor ein Programm überhaupt gestartet werden kann,\n",
    "darf es keinerlei Syntaxfehler enthalten.\n",
    "Dies ist die fundamentale erste Hürde, wenn man ein funktionstüchtiges Programm schreiben möchte.\n",
    "Syntaxfehler sind daher die am häufigsten auftretenden Fehler und gleichzeitig auch die am einfachsten zu korrigierenden.\n",
    "Die jeweiligen Syntaxfehlermeldungen liefern konkrete Informationen über die Position und Art des Fehlers.\n",
    "\n",
    "Bevor die weiteren Grundkonzepte genauer erklärt werden, erstmals Python's wichtiste Syntaxregeln:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ausdruck (engl. expression)\n",
    "\n",
    "Das sind Einzeiler, die aus Rechenzeichen, Variablen, eingebauten Befehlen, Klammern und sonstigen Zeichen wie einem Punkt besteht. \n",
    "Ein Befehl ist hierbei üblicherweise ein Aufruf, der durch nachgestellte runde Klammern signalisiet wird.\n",
    "Innerhalb der Klammern sind die Argumente dieses Aufrufs.\n",
    "Verschachtelte Aufrufe werden von innen nach außen Ausgewertet.\n",
    "Ein Punkt \"`.`\" ist ein Trennzeichen, um ein Attribut des zuerst angegebenen Objektes aufzurufen.\n",
    "Ist dieses Attribut aufrufbar, so kann es ganz normal mit Klammern aufgerufen werden.\n",
    "\n",
    "Beispiele: \n",
    "```python\n",
    "2 + 1.5\n",
    "f(5.5)\n",
    "max(1, 4, 11)\n",
    "min(max(4, 1000), max(-60, 1))\n",
    "geschwindigkeit.diff(x)\n",
    "```\n",
    "\n",
    "**<font color=\"red\">Beispiele für Syntaxfehler</font>**\n",
    "\n",
    "Fehlerhaft sind u.A. Ausdrücke mit nicht-ausbalancierten Klammern, falschen Anführungszeichen und Operatoren (unäre und binäre) mit fehlenden Argumenten. Achtung, Ausdrücke können auch problemlos über mehrere Zeilen gehen.\n",
    "\n",
    "```python\n",
    "f2((1+a)\n",
    "sqrt(x + ) * sin(1 - x)\n",
    "print(\"Hallo)\n",
    "{ \"abc\" : [ 1, 2, 3, \"xyz\" : range(9) }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zuweisung (engl. assignment)\n",
    "\n",
    "Das \"`=`\" Zeichen ist von besonderer Bedeutung.\n",
    "Es weist der Variablen auf der linken Seite den evaluierten Ausdruck der rechten Seite zu.\n",
    "Später im Programmcode, kann auf diesen evaluierten Ausdruck durch anschreiben des Variablennames zugegriffen werden. Gleichzeitige Zuweisungen sind auch möglich, wenn links und rechts des Gleichzeitszeichens die selbe Anzahl von Elementen steht.\n",
    "\n",
    "```python\n",
    "variable = <Ausdruck>\n",
    "```\n",
    "\n",
    "Beispiele: \n",
    "```python\n",
    "apfel = 11 + 7\n",
    "birne = 2 * apfel + 1\n",
    "x, y = 9, 10\n",
    "a = b = \"gleichzeitige Zuweisung\"\n",
    "y = max(2, min(99, x))\n",
    "v = geschwindigkeit(t = 1.4)\n",
    "```\n",
    "\n",
    "\n",
    "**<font color=\"red\">Beispiele für Syntaxfehler</font>**\n",
    "\n",
    "```python\n",
    "x + y = 9\n",
    "funktion2(x) = 3.14\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dabei ist zu beachten,\n",
    "dass es **reservierte Schlüsselwörter** gibt,\n",
    "welche nicht für Zuweisungen verwendet werden können.\n",
    "Diese Wöter sind essentieller Teil der Programmiersprache\n",
    "um die Struktur des Programmablaufs anzugeben:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del, elif, else, except, exec,\n",
    "    finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or,\n",
    "    pass, print, raise, return, try, while, with, yield\n",
    "    \n",
    "Insbesondere sticht hierbei aus der Sicht des Naturwissenschaftlers  `lambda` heraus.\n",
    "Will man ein $\\lambda$ als Variablennamen verwenden,\n",
    "so wählt daher in der Praxis üblicherweise entweder `lambda_` oder `lmbda`.\n",
    "\n",
    "Die genauere Bedeutung dieser eingebauten Schlüsselwörter wird im Rahmen dieses Skripts erklärt.\n",
    "Allgemeiner werden sie in Python's Dokumentation hier erklärt:\n",
    "[Version 2](https://docs.python.org/2/library/functions.html)\n",
    "bzw. [Version 3](https://docs.python.org/3/library/functions.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Blöcke (engl. block, suite)\n",
    "\n",
    "Ein Codeblock ist eine zeilenweise Liste von Ausdrücken, welche allesamt **gleich weit eingerückt sein müssen**.\n",
    "Die Zeile vor so einem Block beinhaltet immer eine Funktions- oder Klassendefinition, bzw. eine Kontrollstruktur -- erkennbar an dem Doppelpunkt am Ende der Zeile.\n",
    "\n",
    "```python\n",
    "if x > 0:\n",
    "    y = 2*x + 1\n",
    "    birne = apfel - x\n",
    "    \n",
    "```\n",
    "Verschachtelung von eingerückten Blöcken:\n",
    "\n",
    "```python\n",
    "def f(x):\n",
    "    k = 0\n",
    "    if x > 0:\n",
    "        k = k + 2*x\n",
    "        \n",
    "    elif x < 0:\n",
    "        for i in range(-x):\n",
    "            k = k - i**2\n",
    "            x = x + (2*i + x)\n",
    "```\n",
    "\n",
    "Wichtig ist, dass die Einrückungen konsistent sind und am Ende eines eingerückten Blocks wieder mindestens auf das Niveau des umschließenden Blocks zurückgerückt wird. \n",
    "\n",
    "**Tipp:** müheloses hin- und herrücken von Codeblöcken lässt sich so bewerkstelligen,\n",
    "dass die zu verrückenden Zeilen markiert werden und die `Tab` bzw. `Shift-Tab` Taste gedrückt werden.\n",
    "\n",
    "**<font color=\"red\">Beispiele für Syntaxfehler</font>**\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    x = 9\n",
    "   y = 11\n",
    "```\n",
    "\n",
    "```python\n",
    "for x in range(10):\n",
    "    for y in range(10):\n",
    "        z += x * y\n",
    "   print(z)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bemerkung**: Wer sich mit den syntaktischen Feinheiten von Python genauer beschäftigen will,\n",
    "kann dies in der\n",
    "[offiziellen Dokumentation](https://docs.python.org/2/reference/grammar.html), bzw.\n",
    "[Version 3](https://docs.python.org/3/reference/grammar.html) machen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fehlertypen\n",
    "\n",
    "Neben diesen Syntaxfehlern (in Python: `SyntaxError`) gibt es auch noch *[Laufzeitfehler](https://docs.python.org/2/tutorial/errors.html)* und *logische Fehler*.\n",
    "\n",
    "### Laufzeitfehler (Error)\n",
    "\n",
    "Ist der Syntax korrekt, kann das Programm ausgeführt werden.\n",
    "Während dessen kann es zu den unterschiedlichsten Problemen kommen:\n",
    "\n",
    "* eine Variable ist nicht definiert worden, wird jedoch verwendet\n",
    "    * gleichbedeutend damit: eine Funktion existiert nicht\n",
    "* es wird versucht eine nicht definierte Berechnung auszuführen, z.B. Division durch Null, Wurzel aus einer negativen Zahl, ...\n",
    "* der Typ eines Objektes passt nicht bzw. die gewünschte Operation kann mit dem Objekt nicht ausgeführt werden,\n",
    "* es wird versucht, auf ein Objekt zuzugreifen das nicht existiert, z.B. 10tes Element in einer Liste mit nur 5 Elementen, ...\n",
    "* es wird versucht ein nicht existierendes Objekt zu löschen, ...\n",
    "* usw.\n",
    "\n",
    "**<font color=\"red\">Beispiele für Laufzeitfehler</font>**\n",
    "\n",
    "```\n",
    "8 / 0                ZeroDivisionError: integer division or modulo by zero\n",
    "[1,2,3,4][5]         IndexError: list index out of range\n",
    "z = 1 + x            NameError: name 'x' is not defined\n",
    "\"Hallo\"(1.25)        TypeError: 'str' object is not callable\n",
    "float(\"Hallo\")       ValueError: could not convert string to float\n",
    "```\n",
    "\n",
    "* [Python 2 Dokumentation über Errors](https://docs.python.org/2/tutorial/errors.html)\n",
    "* [Python 2's Liste von eingebauten Exceptions](https://docs.python.org/2/library/exceptions.html)\n",
    "\n",
    "Abschließend muss erwähnt werden, dass auch eigene Errors und Exceptions programmiert werden können.\n",
    "Dies dient dazu, dem Anwender des Programmes (bzw. dem Programmierer, der eine Programmbibliothek verwendet) eine genaue Information zu liefern,\n",
    "warum eine bestimmte Aktion so nicht funktioniert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logische Fehler\n",
    "\n",
    "Logische Fehler sind die mühevollsten!\n",
    "Das sind diejenigen Fehler, wo ein Programm nicht das gewünschte Verhalten zeigt bzw. ein falsches Ergebnis liefert,\n",
    "aber es keinen der bisher vorgestellten Fehler ausgibt.\n",
    "\n",
    "**<font color=\"red\">Beispiel für logischen Fehler</font>**\n",
    "\n",
    "Das folgende Programm soll den Mittelwert von 3 Zahlen berechnen:\n",
    "\n",
    "```python\n",
    "a, b, c = 9, -1, 3.3\n",
    "summe = a + b + c\n",
    "mittelwert = summe / 2.0\n",
    "print(mittelwert)\n",
    "```\n",
    "Ergibt: `5.65`\n",
    "\n",
    "Wo ist der logische Fehler?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}