Grundlagen_fstring_added.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7c04a295-5911-4631-bc24-6dc2975f2a35",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Einleitendes Thema**</font>\n",
    "Python ist eine Programmiersprache, die unter anderem in den Ingenieurswissenschaften weite Verbreitung gefunden hat. Python besitzt einen eingebauten Packetmanager, mit dem Zusatzfunktionalität schnell und einfach installiert werden kann. Z.B. Funktionen zum Auslesen oder Erstellen von Excel-Datein, Anbindun an verschiedene Datenbanksysteme oder Programmbibliotheken zur grafischen Ausgabe. Zum einen können in Python klassische Anwendungen programmiert werden, Python bietet allerdings auch einen interaktiven Modus. Dieser eignet sich sehr gut für Datenanalyse oder das Erstellen von Diagrammen aus verschiedenen Datenquellen.\n",
    "Python besitzt eine Syntax, die vergleichsweise gut von Menschen lesbar ist und eine strukturierte Darstellung des Quelltextes erzwingen soll. So ist in Python z.B. eine Zeile ein zusammenhängender Ausdruck der mit der Zeile endet, sodass nicht mehrere Programmzeilen in eine Textzeile geschreiben werden können. Zusammenhängende Zeilen bzw. Code-Blöcke werden durch Einrückung der Zeilen mit Leerzeichen definiert.\n",
    "Python selbst ist ursprünglich eine Scriptsprache, d.h. das Programm wird als Quelltext verteilt und der Benutzer des Programms benötigt einen sogenannten Python-Interpreter, um es auf seinem Computer laufen zu lassen. Das führt dazu, dass Python-Programme relativ unabhängig vom verwendeten Betriebssystem oder der verwendeten Computerarchitektur funktionieren, so lange ein Python-Interpreter für das Zielsystem existiert. Python selbst bietet viel Funktionalität um Programme zu schreiben, die unanhängig des verwendeten Betriebssystems funktioniern. Ob diese benutzt werden liegt allerdings auch beim Programmierer.\n",
    "Mit Python lassen sich auch Programmteile steuern, die in anderen Programmiersprachen geschrieben wurden. Da Python-Programme selbst relativ langsam sind, ist diese Möglichkeit für eine Verwendung im wissenschaftlichen Rahmen sehr wichtig, da oft große Datenmengen bearbeitet werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4356c612-2040-4567-8d97-b11bcc16d234",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Übersicht - Python Grundlagen**</font>\n",
    "Das folgende Notebook beschreibt einige Grundlagen der Programmiersprache Python, die für die erste Übung benötigt werden. Es ist eine Art mini-Referenz von den bereits verwendeten Teilen der Programmiersprache. Im laufe der ersten paar Übungen werden wir die einzelnen Abschnitte des Dokuments noch etwas erweitern, sodass es zum Schluss eine Referenz der strukturierten Programmierung in Python darstellt, die alle in den Übungen enthaltenen Aspekte der Programmiersprache enthält. Unter den einzelnen Abschnitten findest du einige Dinge etwas detaillierter beschrieben, als in den Übungen besprochen. Insgesammt sind allerdings alle Themen kurz gehalten. Das Dokument soll nicht als Eratz zur Übung dienen, sondern als Nachschlagewerk für die Bearbeitung der Aufgaben."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c407ee4-f407-4c18-ab8b-dfbbea4a8680",
   "metadata": {
    "tags": []
   },
   "source": [
    "### <font color='blue'>*Lernziele des Notebooks*</font>\n",
    "Das Notebook ist in mehrere thematische Abschnitte gegliedert.\n",
    "\n",
    "* [Syntax](#Syntax)\n",
    "* [Literale](#Literale)\n",
    "* [Variablen](#Variablen)\n",
    "* [Wichtige Funktionen](#Funktionen)\n",
    "* [Operatoren](#Operatoren)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a43032b-9076-4f88-92cc-98ddb86cfa76",
   "metadata": {},
   "source": [
    "# <font color='blue'> **Syntax** </font> <a name=\"Syntax\"> </a>\n",
    "## <font color='blue'>*Kommentare*</font>\n",
    "Es ist möglich, den Quelltext direkt zu kommentieren. Kommentare dienen nur der Nachvollziebarkeit des Quelltextes und werden vom Python-Interpreter ignoriert.\n",
    "Es gibt es zwei Möglichkeiten Kommentare zu schreiben, die beide in der nächsten Code-Zelle dargestellt sind. Mit einem #-Zeichen, wird der Rest der Zeile zum Kommentar. Der Kommentar endet also mit dem nächsten Zeilenumbruch. Um mehrzeilige Kommentare zu schreiben, kann ein dreifaches Anführungszeichen am Anfang einer Zeile verwendet werden. Der Kommentar endet durch drei weitere Anführungszeichen. Ein mehrzeiliger Kommentar muss innerhalb der selben Code-Zelle beendet werden, in der er beginnt, ansonsten wird ein Fehler ausgelöst\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "25992d88-dc99-461e-a987-cd611ff70c04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "x=3+2 #das hier ist ein Kommentar.\n",
    "#eine ganze Zeile als Kommentar\n",
    "\"\"\"\n",
    "das ist ein \n",
    "mehrzeiliger Kommentar. Er kann sich über beliebig\n",
    "viele Zeilen der Zelle erstrecken\n",
    "\"\"\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1448301e-51b6-4e3d-934f-248d2a0934c7",
   "metadata": {},
   "source": [
    "## <font color='blue'>*Reihenfolge der Auswertungen in einer Zeile*\n",
    "Wenn mehrere Operatoren in einer Zeile stehen, bzw. mehrere Funktionen ausgewertet werden müssen, kann die Reihenfolge in der das passiert wichtig werden. Operatoren folgen den Punkt vor Strich Rechenregeln. Trotzdem kann die Reihenfolge manchmal sehr schwer nachvollziebar sein. Es ist daher möglich, wie in mathematischer Schreibweise, runde Klammern einzusetzen, um die Auswertereihenfolge festzulegen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "ec2c445f-2763-4608-bda0-33e044f900e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39\n",
      "63\n"
     ]
    }
   ],
   "source": [
    "x=4+5*7\n",
    "y=(4+5)*7\n",
    "print (x)\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c49646f-9210-4860-9605-8dfc4f7c59a0",
   "metadata": {},
   "source": [
    "## <font color='blue'>*Zeilenumbrüche*\n",
    "\n",
    "Ein \"Ausdruck\" in Python ist normalerweise eine Zeile im Quelltext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "640fc218-ed8a-4f24-8e1d-c9a2898559d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "x=3+4+7\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22ed06fe-2e87-448f-bb6c-7f592c1fee65",
   "metadata": {},
   "source": [
    "Sollte es passieren, dass eine Zeile zu lang wird und aus optischen Gründen auf mehrere Zeilen aufeteilt werden soll, kann mit einem \\ am Ende der Zeile der folgende Zeilenumbruch ignoriert werden, er existiert für den Python-Interpreter nicht. Das \\\\-Zeichen muss am Ende der Zeile stehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "12a585f2-7dcf-49e9-af78-6684cf5e6049",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "x=3+4+\\\n",
    "   7 #Die nächste Zeile darf eingerückt werden, muss aber nicht. Es sieht allerdings besser aus\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f0b7f16-d7b0-46b2-951a-227763a91d8b",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Literale**</font> <a name=\"Literale\"> </a>\n",
    "\n",
    "Literale sind feststehende Werte, die in den Programmcode eingebaut werden können. Z.B. Zahlen oder Texte. Sie können verwendet werden, um Variablen einen initialen Wert zu geben oder Textabschnitte zu definieren, die im Rahmen der Benutzerinteraktion vom Programm ausgegeben werden. Mit Literalen können diese Werte in einer für den Programmierer praktischen Formatierung eingegeben werden. Gerade bei numerischen Literalen gibt es daher verschiedene Möglichkeiten eine Zahl zu schreiben, die in unterschiedlichen Szenarien sinnvoll werden können. Literale, bzw. die Werte die sie beschreiben, haben, wie auch Variablen, einen Typ. Literale sind unveränderbare (bzw. konstante) Werte. Das heißt, sie können niemals auf der linken Seite einer Zuweisung stehen.\n",
    "Einige Beispiele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "af634aba-0393-4480-9905-9b05d23ab8a9",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to literal (1432500936.py, line 9)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn [138], line 9\u001b[1;36m\u001b[0m\n\u001b[1;33m    3=x ##Funktioniert nicht. Ein Literal darf nicht auf der linken Seite einer Zuweisung stehen\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to literal\n"
     ]
    }
   ],
   "source": [
    "3 #Eine ganze Zahl\n",
    "7e9 #Eine Fließkommazahö\n",
    "5.234 #Eine Fließkommazahl\n",
    "0b1001010 #Eine ganze Zahl in binärer Schreibweise\n",
    "0o2347 #Eine ganze Zahl in oktaler Schreibweise\n",
    "0xAF #Eine ganze Zahl in hexadezimaler Schreibweise\n",
    "\"Ich bin eine Zeichenkette\"\n",
    "(2+4j) #Eine komplexe Zahl\n",
    "3=x ##Funktioniert nicht. Ein Literal darf nicht auf der linken Seite einer Zuweisung stehen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1afdb19b-0b12-4aed-b642-5d8cd7317260",
   "metadata": {},
   "source": [
    "## <font color='blue'>*Numerische Literale*</font>\n",
    "\n",
    "Es gibt drei Arten von numerischen Literalen in Python:\n",
    "\n",
    "* Fließkommawerte\n",
    "* ganzzahlige Werte\n",
    "* imaginäre Werte\n",
    "\n",
    "\n",
    "Bei allen numerischen Literalen ist ein führendes \"-\"-Zeichen für eine negative Zahl zulässig. Bei genauer Betrachtung ist das Minus jedoch nicht Teil des Literals, siehe Abschnitt Operatoren.\n",
    "\n",
    "### *Fließkommawerte*\n",
    "\n",
    "Fliekommawerte beschreiben eine Zahl mit Nachkommastellen. Fließkommazahlen besitzen in Python den Typ 'float'. Die Nachkommastellen dürfen auch alle 0 sein, womit der Wert technisch gesehen eine Ganzzahl ist. Die Unterscheidung bei Computern liegt allerdings nicht nur im Vorhandensein von Nachkommastellen, sondern auch in der Arithmetik und dem möglichen Wertebereich, der sich von Ganzzahlen unterscheidet. Wie groß oder klein eine Fließkommazahl ist, hängt auch vom Verwendeten Prozessor ab. Normalerweise liegt der gültige Bereich zwischen plus und minus 10 hoch 308.\n",
    "\n",
    "Fließkommazahlen werden in Python als Kommazalen in englischer Notation (mit \".\" als Komma) eingegeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9a30ddf4-cc88-403f-8cf7-ba18dbf69d3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=3.5434 #ein Beispiel für eine Kommazahl\n",
    "y=-2.4 #eine negative Zahl kann mit einem führenden Minus angegeben werden"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cad863d6-84f2-4b62-83f0-6805d83a23ef",
   "metadata": {},
   "source": [
    "#### Einige praktische Hinweise\n",
    "Falls die Zahl mit einer 0 vor dem Komma beginnt, kann die 0 optional weggelassen werden. Gleiches gilt, für die 0 nach dem Komma, falls alle Nachkommastellen 0 sind. Außerdem kann am Ende der Zahl optional ein \"e\" gefolgt von einer ganzen Zahl angegeben werden. Die Zahl wird als Exponent zur Basis 10 interpretiert (ein e3 nimmt die eingegebene Zahl mal 10 hoch 3. Das \"e\" kann dabei groß oder klein geschrieben werden).\n",
    "\n",
    "Es ist zulässig Unterstriche \"_\" an beliebigen Stellen der Zahl zu verwenden, um Ziffern zu gruppieren. Die Unterstriche werden bei der Interpretation ignoriert. Sie dienen nur dem Programmierer, um z.B. Zahlen mit vielen aufeinanderfolgenden identischen Ziffern besser lesbar zu machen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "4b84c21c-3065-4aba-a69a-f77fdfb6e038",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.43\n",
      "32000.0\n",
      "0.00032\n",
      "1.000000001\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "x=.43 #führende Nullen können optional weggelassen werden ist identisch mit x=0.43\n",
    "y=3.2e4 #Hat als Ergebnis 3.2*10**4\n",
    "z=3.2E-4 #Das funktioniert auch mit negativen Zahlen. Das e darf wahlweise groß oder klein geschrieben werden\n",
    "a=1.000_000_001 #Unterstriche können zur besseren Darstellung für den Programmierer verwendet werden, um Ziffern zu gruppieren. Sie werden ignoriert\n",
    "b=3. #eine 0 nach dem Komma kann weggelassen werden\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edca5fcc-10a6-475c-afa4-6fa165b5bf9c",
   "metadata": {},
   "source": [
    "Eine Besonderheit der Notation mit dem \"E\" als Zehnerpotenz ist, dass der resultierende Wert immer als Fließkommazahl interpretiert wird, auch wenn er keine Nachkommastellen besitzt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cf98f7e0-b393-4104-a0f7-f5faca365f86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x=3e5#Wird als Fließkommazahl interpretiert\n",
    "print(type(x))# gibt den Typ von x aus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b44b3fe4-7146-4d79-8a53-3ea903000cb5",
   "metadata": {},
   "source": [
    "### *Ganze Zahlen*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3a6fa24-f6a2-44f2-b209-7a9827f7f13d",
   "metadata": {},
   "source": [
    "Für die Eingabe von ganzen Zahlen gibt es mehrere Möglichkeiten. Der Wertebereich der ganzen Zahlen in Python ist unbegrenzt, ihr Typ heißt 'int' (Kurzform von Integer). Die einfachste Möglichkeit ist, die Zahl einfach im Dezimalsystem einzugeben. Auch hier dürfen \"_\" Zeichen zur Zahlengruppierung eingesetzt werden, die vom Python-Interpreter ignoriert werden. Führende Nullen, also die Zahl 15 als 015 zu schreiben, ist nicht zulässig!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "30f6e8d0-907c-4ba1-bdcd-c4969634ecd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1032454 #Einge ganze Zahl\n",
    "y=-223_322_023_000 #Eine negative Zahl. Zur besseren Lesbarkeit des Quelltextes in 3er Gruppen gruppiert\n",
    "z=0 #Die Null ist in Ordnung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8d9e9c64-acd5-499c-b4a9-d64a910ff137",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers (1519621152.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn [15], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    a=010\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers\n"
     ]
    }
   ],
   "source": [
    "a=010 #Diese Zelle löst einen Fehler aus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7cd09f0-0438-4d43-8acf-af5386ed22e2",
   "metadata": {},
   "source": [
    "#### Eingaben in anderen Zahlensystemen\n",
    "Neben Eingaben im Dezimalsystem sind auch Zahleneingaben im binärsystem (mit den Ziffern 0 und 1), im Octalsystem (mit den Ziffern 0...7) und im Hexadezimalsystem (mit den \"Ziffern\" 0..9 A..F) möglich. Dazu werden vor die Zahl 0b für binär, 0o für Octal pder 0x für Hexadezimal geschrieben. Alle Buchstaben dürfen hierbei wahlweise groß oder klein geschrieben werden. Der resultierende Wert ist unabhängig der Eingabeform immer ein normaler Zahlenwert. Die Ausgabe von Ganzzahlen erfolgt normalerweise im Zehnersystem (was einstellbar ist). Die folgende Zelle definiert den gleichen Wert über unterschiedliche Literale.\n",
    "\n",
    "Diese Möglichkeit existiert, da Computer im allgemeinen im Binärsystem rechnen und dadurch manche Werte in diesen Zahlensystemen aussagekräftiger oder praktischer dargestellt werden können."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c630976e-2a71-4332-9b2f-d8ab469bab65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4863\n",
      "4863\n",
      "4863\n"
     ]
    }
   ],
   "source": [
    "x=0x12FF #Eine Hexadezimale Zahl\n",
    "y=0o11377 #Eine Oktalzahl\n",
    "z=0b0001_0010_1111_1111 #eine binäre Zahl\n",
    "print (x)\n",
    "print (y)\n",
    "print (z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a08a900-fff9-4e47-be61-3d5d3c9be955",
   "metadata": {},
   "source": [
    "### *Imaginäre Zahlen*\n",
    "Python kann auch mit imaginären Zahlen umgehen. Statt einem \"i\" wird allerdings ein \"j\" an die imaginäre Zahl angehängt. Der Type der komplexen Zahlen in Python heißt 'complex'. Es gibt kein spezielles Literal, um komplexe Zahlen mit realteil zu erzeugen. Diese müssen durch Addieren von Real- und Imaginärteil selbst \"zusammengebaut\" werden. Damit z.B. bei komplitzierteren Ausdrücken mit Multiplikationen etc. keine Fehler passieren, ist es empfehlenswer,t eine Imaginäre Zahl mit Realteil in einer Klammer zu schreiben, wie bei der Variable z. Das ist aber kein Muss. Komplexe Zahlen sind in Python immer aus zwei Fließkommazahlen zusammengesetzt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d56aec6e-c337-4d28-bc9c-f33bfc81dfca",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=12j#Eine komplexe Zahl\n",
    "y=3+4j#Eine komplexe Zahl mit dem Realteil \n",
    "z=(3+4j)#Am besten die ganze komplexe Zahl in Klammern schreiben, um Fehler zu vermeinden"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d16809c-aa29-4e74-a5c4-70ba94c33e9f",
   "metadata": {},
   "source": [
    "## <font color='blue'>*Zeichenketten*</font>\n",
    "Zeichenketten haben in Python den Typen \"str\". Es sind Aneinanderreihungen von lesbaren Buchstaben beliebiger Länge. Python unterstützt die meisten Sonderzeichen (verwendet sogenannte Unicode-Zeichen). Es ist zu beachten, dass Eine Zeichenkette auch Ziffern enthalten kann. Auch wenn die Zeichenkette nur Ziffern enthält, bleibt sie eine Zeichenkette. Python unterscheidet, wie die allermeisten Programmiersprachen, Zeichenketten strikt von Zahlen. Man kann mit diesen Zeichenketten nicht rechnen (man kann sie allerdings in Zahlen umwandeln). Eine Zeichenkette wird in einfache oder doppelte Anführungzeichen gesetzt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4af6d5fd-c62a-4a34-814e-4c6c29762e2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=\"Ich bin ein Text\"\n",
    "b='Ich bin ein Text'#beide Möglichkeiten sind gleichwertig"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "104718ca-9145-46b1-8a05-d839aa0da608",
   "metadata": {},
   "source": [
    "Ein Problem dabei ist, dass je nach verwendeter Schreibweise das einfache oder doppelte Anführungszeichen nicht innerhalb der Zeichenkette verwendet werden kann, da die Zeichenkette damit beendet werden würde. Aus diesem Grund wird innerhalb von Zeichenketten das \\\\-Zeichen als sogenannter Escape-Character verwendet. Das Zeichen nach dem \\ hat eine besondere Bedeutung. Z.b. kann über \\\\\" Ein Anführungszeichen innerhalb der Zeichenkette als Buchstabe verwendet werden. um ein \\ als Buchstaben zu erhalten muss \\\\\\\\ verwendet werden. Über diesen Mechanismus werden auch weitere Zeichen dargestellt, die ansonsten nicht verwendbar wären. ein \\n ist zum Beispiel ein Zeilenumbruch. Es gibt neben dem \\n noch weitere sogenannte Steuerzeiche. Die nächste Zelle soll das Verhalten verdeutlichen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "0a8ec550-dab3-45e6-9c22-426441d68709",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ein doppeltes Anführungszeichen: \". \n",
      "ein einfaches Anführungszeichen kann in dieser Zeichenkette einfach geschrieben werden ' es ist allerdings auch als ' möglich\n",
      "Hier ist ein \" einfach. Ein einfaches Anführungszeichen muss hier ein ' sein\n",
      "Ein Rückstrich ist nur durch \\ schreibbar\n"
     ]
    }
   ],
   "source": [
    "a=\"Ein doppeltes Anführungszeichen: \\\". \\nein einfaches Anführungszeichen kann in dieser Zeichenkette einfach geschrieben werden ' es ist allerdings auch als \\' möglich\"\n",
    "b='Hier ist ein \" einfach. Ein einfaches Anführungszeichen muss hier ein \\' sein'\n",
    "c=\"Ein Rückstrich ist nur durch \\\\ schreibbar\"\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08406a63-b7bf-4b99-8d7d-acc8f95b5a37",
   "metadata": {},
   "source": [
    "### Weitere Möglichkeiten\n",
    "Es gibt in Python noch weitere Möglichkeiten rund um das Thema Zeichenkettenliterale. Wie bei den ganzen Zahlen ist allerdings nur die Schreibweise eine andere.\n",
    "\n",
    "Sehr nützlich ist der \"f-String\". Dieser wird mit ````f\"```` begonnen. Dann können Ausdrücke und Variablen in geschweiften Klammern direkt in den String gesetzt werden und mit einer Formatierungsangabe versehen werden:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "07f53ca4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Die Zahl 123.45678 mit nur 1 Nachkommastellen: 123.5, in Exponentialdarstellung mit 3 Nachkommastellen: 1.235e+02\n"
     ]
    }
   ],
   "source": [
    "zahl = 123.45678\n",
    "a = f\"Die Zahl {zahl} mit nur 1 Nachkommastellen: {zahl:.1f}, in Exponentialdarstellung mit 3 Nachkommastellen: {zahl:.3e}\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "661532cf",
   "metadata": {},
   "source": [
    "Für die Formatoptionen stehen sehr viele Optionen zur Verfügung (Bei Interesse gerne entsprechende Dokumentationen ansehen). Hier werden nur die wichtigsten für Fließkommazahlen gezeigt, da sie sie für uns am nützlichsten sind. Mit ````.n```` werden n Nachkommastellen definiert. Dahinter kommt entweder ````f````, ````e````, ````g````, oder ````%````. Die Bedeutung ist:\n",
    "\n",
    "|Zeichen|Bedeutung|\n",
    "|----|----|\n",
    "|f| Fließkommazahl |\n",
    "|e| Exponentialschreibweise |\n",
    "|g| f bei kleinen, e bei großen Exp. |\n",
    "|%| Prozentwert (z.B. 0.1 wird zu \"10%\" |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cff61752",
   "metadata": {},
   "source": [
    "Zwei Optionen für Zeichenketten die in Sonderfällen praktisch sein können sind hier noch aufgeführt:\n",
    "\n",
    "Es ist möglich Zeichenketten mit drei Anführungszeichen zu beginnen und zu beenden, wie bei mehrzeiligen Kommentaren. Auch hier sind einfache und doppelte Anführungszeichen möglich. Der Effekt ist, dass die Zeichenkette Zeilenumbrüche enthalten kann. Sie ist also für lange Texte besser geeignet. Die Zeilenumbrüche befinden sich als Steuerzeichen in der Zeichenkette, werden also mit print auch ausgegeben\n",
    "\n",
    "Außerdem kann vor das erste Anführungszeichen ein R oder r gesetzt werden. Dann wird das \\\\-Zeichen als normales Zeichen interpretiert. Es ist nicht mehr möglich Steuerzeichen oder Anführungszeichen über das \\\\ zu schreiben. Diese Version wird gerne verwendet, wenn eine Zeichenkette keine Anführungszeichen aber viele Rückstriche enthält (z.B. Dateinamen bei Windows-Betriebssystemen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "29be2463-0542-402e-916d-ce79e3d54a2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Es sind auch drei Anführungszeichen möglich, damit sind bis zu 2 Anführungszeichen in Reiche innerhalb der Zeichenkette normal schreibbar \"\". Sie wird durch drei Anführungszeichen beendet\n",
      "Dieser String kann über mehrere Zelen gehen, was bei langen Texten sehr praktisch ist\n",
      "bei einem R oder r vor der Zeichenkette ist das \\ ein normales Zeichen. Damit sind allerdings Steuerzeichen und Anführungszeichen nicht mehr schreibbar\n"
     ]
    }
   ],
   "source": [
    "a=\"\"\"Es sind auch drei Anführungszeichen möglich, damit sind bis zu 2 Anführungszeichen in Reiche innerhalb der Zeichenkette normal schreibbar \"\". Sie wird durch drei Anführungszeichen beendet\n",
    "Dieser String kann über mehrere Zelen gehen, was bei langen Texten sehr praktisch ist\"\"\" #geht auch mit einfachen Anführungszeichen. Kann sich über mehrere Zeilen erstrecken\n",
    "b=R\"bei einem R oder r vor der Zeichenkette ist das \\ ein normales Zeichen. Damit sind allerdings Steuerzeichen und Anführungszeichen nicht mehr schreibbar\"\n",
    "print (a)\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7a36225-e2eb-4dae-8eee-bacc2e6b8ced",
   "metadata": {},
   "source": [
    "## <font color='blue'>Boolsche Werte</font>\n",
    "Boolsche Werte können Wahr oder Falsch sein. Die Zugehörigen Literale sind \"True\" und \"False\". Boolsche Werte werden immer dort verwendet, wo zwischen zwei Optionen unterschieden werden muss. Z.B sind sie das Ergebnis von Vergleichsoperatoren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "7b7d000c-3d5c-450e-b808-1f59b3e5538b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=True\n",
    "b=False#Literale für boolsche Werte"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763734b2-222a-45a2-a4c3-dc160db9622c",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Variablen**</font> <a name=\"Variablen\"> </a>\n",
    "Variablen speichern Werte unter einem Namen, den der Programmierer frei wählen kann (unter Einhaltung einiger Regeln). Eine Varaible wird bei der ersten Zuweisung eines Wertes erstellt. Der Wert kann dabei ein Literal, der Wert einer anderen Variable oder auch das Ergebnis eines Funktionsaufrufs sein. Jede Variable hat einen Typ (z.B. Ganzzahl, Fließkommazahl, Zeichenkette). Sie übernimmt den Typ vom zugewiesenen Wert. Damit besitzt eine Variable also einen Wert und einen Namen (auch als Identität bezeichnet). Der Name einer Variable darf beliebig lang sein und Buchstaben, Zahlen und das Sonderzeichen \"\\_\" enthalten. Er darf nicht mit einer Zahl anfangen. Außerdem sollte er nicht mit einem \"\\_\" angangen, da der Unterstrich am Anfang einer Variablen im Kontext der objektorientierten Programmierung eine spezielle Bedeutung hat. Das ist allerdings eine Übereinkunft bzw. Empfehlung und kein Muss. Nach Möglichkeit sollten Variablen gerade in komplizierteren Programmen sinnvolle Namen gegeben werden! Ohne sinnvolle Variablennamen sind selbst kurze Quelltextabschnitte teilweise extrem schwer nachzuvollziehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "11133077-4508-4129-9e9a-7d187c9d11ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "x=7 #Erstellt eine Variable mit dem Namen x und weist ihr den Wert 7 als Ganzzahl zu\n",
    "Variable_2=x #Erstellt eine Variable mit dem Namen Variable_2 und weist ihr den Wert von x zu (das ist in diesem Fall die 7). Auch Variable_2 ist damit eine Ganzzahl \n",
    "print (x)#Gibt den Wert von x aus\n",
    "print (Variable_2)#Gibt den Wert von Variable2 aus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379be8b7-faae-4697-b890-553fd65d9690",
   "metadata": {},
   "source": [
    "Einer Variable kann jederzeit ein neuer Wert zugewiesen werden. Da Python eine sogenannte schwach-typisierende Programmiersprache ist, kann der neue Wert auch einen anderen Typ besitzen als die Variable. Sie verändert dann ihren Typ. Variablen sind außerdem nicht statisch. Das heißt, sie existieren erst, wenn ihnen ein Wert zugewiesen wird. Vorher ist der Variablenname nicht bekannt. Außerdem können Variablen auch wieder gelöscht werden. Sie hören dann auf zu existieren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4a5c12c6-8c5f-4919-86e6-8279f6ce6ddb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ich bin jetzt ein Text\n"
     ]
    }
   ],
   "source": [
    "x=\"Ich bin jetzt ein Text\" #x kann ein neuer Wert zugwiesen werden. Der Wert kann einen anderen Typ besitzen. x war vor der Zuweisung eine Ganzzahl, jetzt ist x eine Zeichenkette\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "6c9f0d01-5909-41f7-a1a0-e54ef3ab4c8f",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [61], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m(x) \u001b[38;5;66;03m#Löscht die Variable x\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[43mx\u001b[49m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "del(x) #Löscht die Variable x\n",
    "print (x) #Löst jetzt einen Fehler aus, da keine Variable mit dem Namen x bekannt ist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8fbb20-8f01-459e-b952-38e304dc5346",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Wichtige Funktionen**</font> <a name=\"Funktionen\"> </a>\n",
    "Funktionen werden auch als Methoden, Routinen oder Unterprogramme bezeichnet. Über sie wird ein großer Teil der Funktionalitäten von Python bereitgestellt.\n",
    "Funktionen besitzen einen Namen, der den gleichen Regeln wie Variablennamen unterliegt.\n",
    "\n",
    "Das Prinzip der Funktionen soll an einem Beispiel erklärt werden:\n",
    "Die Funktion print gibt einen Wert in Textform aus. Damit sie einen Wert ausgeben kann, muss sie aufgerufen werden und benötigt den auszugebenden Wert (z.B. ein Literal, der Wert einer Variablen, etc). Optional können Funktionen auch einen Wert als Ergebnis zurückliefern, was print nicht tut. Aufgerufen werden Funktionen über ihren Namen, gefolgt von runden Klammern. Innerhalb der runden Klammern können Parameter an die Funktion übergeben werden. Bei mehreren Parametern sind die einzelnen Parameter durch Kommas getrennt. Falls kein Parameter übergeben wird, bleiben die Klammer leer. Das Beispiel print wurde bereits in vielen Beispielen verwendet. Ob eine Funktion Parameter benötigt, bzw. wie viele Parameter sie erwartet, ist allein von der Funktion abhängig. Es gibt auch Funktionen, die mit einer variablen Zahl an Parametern umgehen können. Die Reihenfolge der Parameter ist durch die Funktion festgelegt. Teilweise gibt es auch benannte Parameter (siehe print). Funktionen können durch den Programmierer selbst in Python geschrieben werden, aus sogenannten Paketen importiert werden oder fest zum Sprachkern von Python gehönren (sogenannte built-in Funktionen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "c9b6ee6f-1c3c-4816-ac95-759f67b6233e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4\n",
      "Hallo Welt\n",
      "3 Hallo 4.3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(3.4)#Ruft die Funktion \"print\" auf. Als Parameter wird der Wert 3.4 übergeben\n",
    "eineVariable=\"Hallo Welt\"\n",
    "print(eineVariable)#Statt eines Literals kann auch eine Variable verwendet werden. Die Funktion bekommt dann den Wert der Variable übergeben\n",
    "print(3,\"Hallo\",4.3)#print kann mit beliebig vielen Parametern aufgerufen werden, das ist nicht bei allen Funktionen so\n",
    "print()#beliebige Anzahl heißt in diesem Fall auch kein Parameter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d8feb3f-ff99-411f-b004-f6aafed61f20",
   "metadata": {},
   "source": [
    "## <font color='blue'>*print*</font>\n",
    "\"print\" ist eine Funktion, die Werte als Text ausgeben kann. Die Funktion kann beliebig viele Parameter übergeben bekommen. Im Fall von keinem Parameter, wird eine leere Zeile ausgegeben. Bei mehreren Parametern werden die Parameter mit einem Trennzeichen getrennt in einer Zeile ausgegeben. \"print\" kann Werte mit beliebigen Typ übergeben bekommen. Sie werden vor der Ausgabe in eine geeignete Textform überführt. Je nach Datentyp kann das besser oder schlechter funktionieren. Zahlen und Text lassen sich jedoch sehr gut ausgeben.\n",
    "Das Trennzeichen zwischen den Einzelwerten kann über einen sogenannten \"benannten Parameter\" frei gewählt werden und hat ein Leerzeichen als Standardwert, falls kein eigenes Trennzeichen angegeben wird. Das Trennzeichen muss auch kein einzelnes Zeichen sein, sondern kann eine beliebige Zeichenkette sein. Im Beispiel in der nächsten Codezeile ist das Trennzeichen auf :-: gesetzt. Das ist ein Beispiel für die Verwendung eines benannten Parameters. In den allermeisten Fällen wird print allerdings mit nur einem Parameter verwendet. \"print\" gibt keinen Wert zurück"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "763c5bfe-48f8-4cc4-9f7b-03c49cd3aea7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "A:-:3:-:4:-:5.4\n"
     ]
    }
   ],
   "source": [
    "x=3\n",
    "print(x)\n",
    "print(\"A\",x,4,5.4,sep=\":-:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7115d783-39af-4953-98f6-590b4ff5d108",
   "metadata": {},
   "source": [
    "## <font color='blue'>*help*</font>\n",
    "\"help\" ist eine Funktion, die zu einer Funktion einen Hilfetext liefert. Es ist sozusagen ein Hilfe-System, das in die Programmiersprache eingebaut ist. Programmierer können ihre Funktionen so dokumentieren, dass help automatisch den verfassten Hilfetext findet. Es ist also möglich, dass nicht zu jeder Funktion ein Hilfetext gefunden wird. Die Funktion \"help\" gibt den Hilfetext direkt aus und wird meistens bei der interaktiven Verwendun von Python genutzt. \"help\" kann auch ohne Parameter aufgerufen werden, was ein interaktives Hilfeprogramm startet das läuft, bis quit zum Beenden eingegeben wird. Du kannst es in diesem Notebook ausprobieren, auch wenn die Verwendung der interaktiven Hilfe in einem Jupyter-Notebook eher weniger zu empfehlen ist. Die Code-Zelle blockiert den Python-Kernel des Notebooks, bis die interaktive Hilfe beendet wurde\n",
    "\n",
    "Wie hilfreich die ausgegebenen Texte sind variiert sehr stark, da die Texte durch die jeweiligen Programmierer verfasst wurden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "9551e0bc-0884-41bb-987e-25c66bec55c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)#gibt den Hilfetext der Funktion print aus."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "580a0764-0558-496e-b34b-d5052053534c",
   "metadata": {},
   "source": [
    "## <font color='blue'>*type*</font>\n",
    "\"type\" ist eine Funktion, mit der man den Typ von Variablen oder Werten ermittel kann. Die Verwendung von \"type\" in Programmen ist bei Python eher unüblich und wird selten benötigt. Es kann aber eine sehr praktische Hilfe sein, um die Funktion von Python näher zu betrachten.\n",
    "\"type\" erwartet einen Parameter, von dem der Typ bestimmt werden soll. Die Funktion gibt den Typ nicht aus, sondern gibt ihn als Ergenis des Funktionsaufrufs zurück. Das Ergebnis kann dann mit \"print\" ausgegeben werden. Das Ergebnis kann auch in einer Variable gespeichert werden. Das ist ein Beispiel, wie ein Funktionsaufruf rechts des Zuweisungsoperators genutzt werden kann"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "1f199866-0c60-447f-9184-d69c3c8b9324",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(\"Hallo\"))\n",
    "x=4\n",
    "print(type(x))\n",
    "erg=type(2.3)\n",
    "print(erg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38023d3c-888b-470d-b738-c36564043da4",
   "metadata": {},
   "source": [
    "\"type\" funktioniert auch bei Funktionen und anderen Objekten. Die Ausgabe kann aber unter Umständen etwas schwierig zu interpretieren sein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "38241019-1cc6-44e2-9115-4f0e15b970cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'builtin_function_or_method'>\n"
     ]
    }
   ],
   "source": [
    "print(type(print))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adc5e372-f5ea-41b4-a179-61520da3f655",
   "metadata": {},
   "source": [
    "## <font color='blue'>Typenumwandlung</font>\n",
    "Gelegentlich muss der Inhalt einer Variablen in einen anderen Typ konvertiert werden. Zwischen ganzen Zahlen und Fließkommazahlen passiert das automatisch. Zwischen Zeichenketten und Zahlen generell nicht. Es gibt für jeden dieser Datentypen ein Funktion, die so heißt wie der zugehörige Typ, der die Umwandlung, sofern sinvoll möglich, durchführt. Der umgewandelte Wert wird als Ergebnis zurückgegebe\n",
    "\n",
    "### str\n",
    "Mit der Funktion können Zahlen in Zeichenketten umgewandelt werden. Z.B. um sie für die Ausgabe in einem Text vorzubereiten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "f9cdd943-cdb9-4a81-8f70-13f052ef5f24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Die Zahl ist:3.45\n"
     ]
    }
   ],
   "source": [
    "x=3.45\n",
    "als_Zeichenkette=str(x)\n",
    "print(\"Die Zahl ist:\"+als_Zeichenkette)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62d5e48-c1b1-44af-922f-ad5883d4c43e",
   "metadata": {},
   "source": [
    "### float\n",
    "Wandelt eine Zeichenkette oder eine ganze Zahl in eine Fließkommazahl um. Die Zeichenkette muss dafür eine Zahl darstellen, also keine Buchstaben enthalten (genau genommen gelten die Regeln der Fließkomma-Literale hier auch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "c2990bb3-9f5f-4f72-9930-c9e5d297b882",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.22345\n"
     ]
    }
   ],
   "source": [
    "eine_Zeichenkette=\"3.22345\"\n",
    "x=float(eine_Zeichenkette)\n",
    "x+=1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f33e38d9-40d7-4ee4-b87d-eb9c78229cd0",
   "metadata": {},
   "source": [
    "### int\n",
    "Wandelt eine Fließkommazahl oder eine Zeichenkette in eine ganze Zahl um. Bei einer Zeichenkette muss der Inhalt eine ganze Zahl sein im Dezimalsystem sein (Binär-,Oktal- oder Hexadezimalzahlen funktionieren nicht). Wenn eine Fließkommazahl umgewandelt wird, wird sie grundsätzlich abgerundet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "bf1e790b-36a9-4ffa-b962-51d53d579ef6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1244\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "zeichenkette=\"1234\"\n",
    "x=int(zeichenkette)\n",
    "print(x+10)\n",
    "y=3.9\n",
    "print(int(y))#Fließkommazahlen werden immer abgerundet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb7a2164-a37b-47cf-a53e-247b50647746",
   "metadata": {},
   "source": [
    "# <font color='blue'>**Operatoren**</font> <a name=\"Operatoren\"> </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1190808f-7277-4002-b4c3-611ad3b6c741",
   "metadata": {},
   "source": [
    "Operatoren bzw. die Operatorenschreibweise ist in Programmiersprechen üblich, um den Quelltext an die Gewohnheiten des natürlichen Sprachgebrauchs anzupassen. Sie benötigt im Vergleich zur Funktionsschreibweise weniger Platz Ein Beispiel ist das +-Zeichen, das einen Operator darstellt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "e67d9706-a563-4685-9765-dd204852cf35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4+3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49b40984-af01-456e-a4a4-c138c2f922c4",
   "metadata": {},
   "source": [
    "Operatoren funktionieren ähnlich wie Funktionen. Das Plus hat zwei Parameter und ein Ergebnis. Der Operator steht allerdings zwischen den Parametern. Operatoren wie das Plus heißen binärer Operator, da sie zwei Parameter benötigen (im Beispiel die 4 und die 3). Der Operator selbst steht zwischen den Parametern. Neben den binären Operatoren gibt es auch unäre Operatoren, die nur ein Parameter erwarten. Sie stehen vor ihrem Parameter. Ein Beispiel ist das - als Vorzeichen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "334fc718-6847-42c5-865c-a7a0c4955ab3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7c1f1d3-8996-4808-973b-b1daa9b5b668",
   "metadata": {},
   "source": [
    "Im Gegensatz zu vielen anderen Programmiersprachen ist das Minus bei Python nicht Teil des Literals, sondern ein unärer Operator vor dem Literal (auch wenn praktische Auswirkungen dieses Unterschieds eher nicht vorhanden sind und es eine technische Spitzfindigkeit ist).\n",
    "\n",
    "Es gibt verschiedene Operatoren in Python. Welche Zeichen ein Operator sind ist vordefiniert und nicht erweiterbar. Es ist allerdings in manchen Fällen möglich zu verändern, was der Operator tut (im Kapitel über objektorientierte Programmierung beschreiben). Die für arithmetische Operationen genutzten Operatoren (+,-,*,etc.) werden in der Potenz vor Punkt vor Strich Reihenfolge ausgeführt, wenn sie in einer Zeile stehen! Das ist bei Rechnungen praktisch, in anderen Fällen evtl. nicht erwünscht. Im Zweifelsfall Klammer setzen.\n",
    "## <font color='blue'>*Zuweisungsoperator*</font>\n",
    "Der Zuweisungsoperatpor ist in Python das =-Zeichen. Der Zuweisungsoperator weist den Wert, der auf seiner rechten Seite steht der Variablen auf seiner linken Seite zu. Er wird immer als letztes Ausgewertet. Das heißt, sollten auf der rechten Seite der Zuweisung mehrere Operationen stehen werden alle zu erst Ausgewertet. Der resultierende Wert wird dann der Variable auf der linken Seite zugewiesen. Sollte die Variable auf der linken Seite nicht existieren, wird sie angelegt. Literale können nicht auf der linken Seite der Zuweisung stehen. Python folgt einer \"Alles ist eine Variable\" logik. Daher sind technisch betrachtet auch alle Funktionen Variablen. Es sollte vermieden werden wichtige Funktionen wie print o.ä. mit Werten zu überschreiben. Es ist möglich, aber bis zum neustart des Python-Interpreters ist dann die Funktion nicht mehr verfügbar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9b5a15fb-a387-446d-9d19-f8c9ed15dc69",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=4 #Falls x unbekannt ist wird eine Variable x erstellt\n",
    "x=4+3*9*11#Auf der rechten Seite des Zuweisungsoperators können auch komplexe Ausdrücke stehen. Der Wert von x wird überschrieben\n",
    "y=x*4#Die rechte Seite wird vor Zuweisung ausgewertet. Das Ergebnis wird in y geschrieben. Wenn x verändert wird, bleibt y unverändert, da bei der Auswertung der rechten Seite nur der Wert relevant ist, der momentan in x gespeichert ist!"
   ]
  },