<jupyter_start><jupyter_text>VariablenVariablen werden benutzt, um Daten zu speichern und wieder abzurufen. Im Laufe eines Programmablaufs kann eine Variable verschiedene Werte annehmen und wieder ausgelesen werden.Dabei kann mit Werten von Variablen gerechnet werden, als wären es die Zahlen, die ihnen zuletzt zugewiesen wurden.  Definition und ZuweisungenWir weisen zwei Variablen jeweils eine Zahl zu und werten dann diese beiden Variablen sowie ihre Summe und ihr Produkt aus:<jupyter_code>a := 19
b := 23
println(a)
println(b)
println(a+b)
println(a*b)<jupyter_output>19
23
42
437<jupyter_text>**Anmerkung:** Ein Ausdruck wie ```println(a)``` sorgt dafür, dass der Wert von ```a``` auf eine eigene Zeile ausgegeben wird. Lässt man oben die ```println(...)```-Teile weg, werden zwar alle Ausdrücke ausgewertet, aber nur die letzte Zeile wird ausgegeben.  Typangabe bei der DefinitionBei der Definition einer Variablen muss klar sein, welchen *Datentyp* (oder kurz *Typ*) die Variable hat.Es gibt verschiedene Datentypen wie z.B. `int` für ganze Zahlen oder `string` für Zeichenfolgen.Die Angabe bei der Definition ist wichtig, weil davon abhängt, wie viel Speicher für die Variable gebraucht wird.Im obigen Beispiel definieren und initialisieren wir Variablen z.B. mit dem Ausdruck `a:=19`. Mit diesem Ausdruck legen wir zwei Dinge auf einmal fest:1. `a` soll eine neue Variable sein.2. Der Wert von `a` soll am Anfang 23 sein.Aus dem Anfangswert bestimmt der Compiler den Typ von `a`, in diesem Fall `int`. Damit kann er Speicher reservieren und die Variable initialisieren.In der Regel werden wir Variablen auf diese Weise definieren.Manchmal ist es jedoch nützlich oder notwendig, den Typ einer Variablen explizit anzugeben. Die folgende Anweisung definiert eine Variable bom Typ `int`, ohne diese explizit zu initialisieren:<jupyter_code>var a int<jupyter_output><empty_output><jupyter_text>Rechnen mit VariablenDas Zuweisen und Auslesen von Werten in Variablen alleine ist noch nicht sehr nützlich. Im obigen Beispiel haben wir schon die Summe und das Produkt zweier Variablen ausgegeben. Genau so kann man an Variablen auch direkt ein Rechenergebnis zuweisen.<jupyter_code>a = 19 + 23
a
b = a + 15
b
c := 3
d := c + b * a
d<jupyter_output><empty_output><jupyter_text>**Anmerkung:** Man beachte, dass oben für Zuweisungen zu ```a``` und ```b``` nur das Gleichheitszeichen (```=```) verwendet wird, für ```c``` und ```d``` aber der Ausdruck "```:=```".Auch hier sieht man, dass man die erste Verwendung (*Definition*) einer Variablen von allen weiteren Verwendungen unterscheiden muss.  Ein komplexeres Beispiel: Addieren der Zahlen von 1 bis nWir wollen die Summe der Zahlen von 1 bis zu einer gegebenen Zahl n addieren. Also z.B. für $n = 6$ die Summe $1+2+3+4+5+6$ berechnen.Für ein festes $n$ kann man natürlich einfach genau diese Summe hinschreiben. Will man flexibel bleiben, sollte man sich zuerst überlegen, wie man die Aufgabe schrittweise angehen kann. Ein Mensch berechnet solch eine Summe im Kopf, indem er Zwischenergebnisse berechnet und sich merkt. Dies machen wir auch beim Programmieren, indem wir Variablen benutzen:<jupyter_code>sum := 0

sum = sum + 1
sum = sum + 2
sum = sum + 3
sum = sum + 4
sum = sum + 5
sum = sum + 6
sum<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07488584474885844, 'fraction_numerical': 0.012785388127853882, 'mean_word_length': 5.331406551059731, 'pattern_counts': {'":': 0, '<': 16, '<?xml version=': 0, '>': 16, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '12449', 'license': 'MIT', 'n_tokens_mistral': 1139, 'n_tokens_neox': 1139, 'n_words': 453, 'path': 'konzepte/01_Variablen.ipynb', 'repo_name': 'TimonKnuttel/DHBWGrundlagen', 'size': '3285'}