01_Datenobjekte.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datenobjekte/Variablen\n",
    "In der Vorlesung haben wir Datenobjekte kennen gelernt, die dazu dienen, einen Wert unter einem bestimmten Namen zu speichern. In der praktischen Programmierung werden diese fast ausschließlich Variablen genannt.\n",
    "\n",
    "In Python werden Variablen bei der ersten Verwendung erzeugt. Sie müssen nicht mit einem extra Befehl erzeugt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nHeim = 10\n",
    "print(nHeim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine Variable kann verschiedene Arten von Daten aufnehmen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 23461342\n",
    "print(a)\n",
    "\n",
    "b = 234.452\n",
    "print(b)\n",
    "\n",
    "t = \"Informatik\"\n",
    "print(t)\n",
    "\n",
    "r = True\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python wird der Zuweisungsoperator als <code>=</code> geschrieben.\n",
    "\n",
    "Wie die Daten dann tatsächlich im Speicher abgelegt werden, sehen wir uns später noch genauer an. Wichtig ist momentan nur, dass verschiedene Inhalte unterschiedlich gespeichert werden müssen. Ein Text beispielsweise benöigt eine andere Anzahl an Speicherstellen wie eine natürliche Zahl, die wieder anders gespeichert wird als eine reelle Zahl.\n",
    "\n",
    "Zusätzlich zum Namen und zum Inhalt der Variable gibt es also noch eine dritte Eigenschaft. Diese ist der Datentyp.\n",
    "\n",
    "Welchen Datentyp eine Variable hat, kann in Python mit der Funktion <code>type()</code> herausgefunden werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(t))\n",
    "print(type(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die wichtigsten Datentypen sind:\n",
    "* **Integer** für ganze Zahlen\n",
    "* **Float** für fließkommazahlen\n",
    "* **String** für Texte oder einzelne Zeichen\n",
    "* **Boolean** für das Ergebnis eines Vergleichs (kann nur zwei Zustände annehmen: <code>True</code> oder <code>False</code>)\n",
    "\n",
    "In Python muss der Datentyp der Variable nicht explizit bei der initialisierung angegeben werden. Sobald der Variablen ein Wert zugewiesen wird, passt sich der Typ der Variablen automatisch an die Daten an. Der Datentyp kann sich also auch ändern. Man nennt diese Eigenschaft einer Programmiersprache auch \"dynamische Typisierung\".\n",
    "\n",
    "Im Gegensatz dazu steht die statische Typisierung, bei der eine Variable einen zu Beginn festgelegten Typ hat, der sich nicht ändern kann (Beispielsweise in der Programmiersprache C: <code>int i = 3;</code> Die Variable i bekommt hier den Datentyp Integer zugewiesen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "print(\"a hat den Typ\")\n",
    "print(type(a))\n",
    "print(\"a hat den Wert\")\n",
    "print(a)\n",
    "\n",
    "a = 3.14\n",
    "print(\"a hat den Typ\")\n",
    "print(type(a))\n",
    "print(\"a hat den Wert\")\n",
    "print(a)\n",
    "\n",
    "a = \"Hallo, Welt\"\n",
    "print(\"a hat den Typ\")\n",
    "print(type(a))\n",
    "print(\"a hat den Wert\")\n",
    "print(a)\n",
    "\n",
    "a = False\n",
    "print(\"a hat den Typ\")\n",
    "print(type(a))\n",
    "print(\"a hat den Wert\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zuweisung mit einer Berechnungsformel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nHeim = 10\n",
    "nGast = 15\n",
    "\n",
    "nGesamt = nHeim + nGast\n",
    "print(nGesamt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe\n",
    "\n",
    "Probieren Sie aus, die Addition durch eine andere Operation zu ersetzen. Suchen Sie dazu in der Python online Dokumentation (https://docs.python.org/3/library/index.html Kapitel \"Built-in Types\"), welche Operatoren es gibt und auf welche Arten von Daten sie sich anwenden lassen.\n",
    "\n",
    "In der Vorlesung haben wir kennen gelernt, Wie der Wert einer Variable um eins erhöht werden kann. Sehen Sie sich dazu den unten stehenden Code an. Bei jeder erneuten Ausführung wird eine andere Ausgabe erzeugt.\n",
    "\n",
    "Probieren Sie, was geschieht, wenn anstatt der Addition andere Operatoren verwendet werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nHeim = nHeim + 1\n",
    "print(nHeim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auswertung von Variablen\n",
    "Die Auswertung als mathematischer Vergleich funktioniert in Python ganz so, wie wir es in der Vorlesung kennen gelernt haben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nHeim > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ist der Wert, der in nHeim durch die Ausführung der vorherigen Code-Zellen gespeichert ist, größer als 5 wird als ausgabe <code>True</code> zurückgegeben, Andernfalls <code>False</code>.\n",
    "\n",
    "Dieses Ergebnis können wir nun ebenfalls in einer Variable speichern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IstTeamGut = nHeim > 5\n",
    "print(IstTeamGut)\n",
    "print(type(IstTeamGut))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe\n",
    "Finden Siemit Hilfe der Python Dokumentation heraus, welche anderen Vergleichsoperatoren ebenfalls von Python unterstützt werden. Wie sieht der Operator aus, mit dem geprüft wird, ob zwei Werte gleich sind?"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}