more typos fixed

dodonator · dodonator · commit c6002212687b · 2022-10-08T13:12:25.000+02:00
diff --git a/Glossar.md b/Glossar.md
@@ -9,7 +9,7 @@ Ein Interpreter ist ein Programm, dass Anweisungen in einer Programmiersprache e
 Ein Compiler übersetzt Programmcode einer höheren **[Programmiersprache](#programmiersprache)** aus einer Datei in eine, vom Computer lesbare Sprache und speichert diese Übersetzung. Somit wird der Programmcode erst in eine Datei geschrieben, was es ermöglicht komplizierteren Code zu schreiben und zu schreiben. Da der Programmcode in Menschen lesbarer Form gespeichert wird, ist es möglich das Programm auf verschiedenen Systemen und an verschiedenen Zeitpunkten auszuführen.
 ## Level 1:
 ### Ausdruck
-Ein Ausdruck (alternativ: Expression) ist ein grundlegender Bestandteil jedes Programms. Ein Ausdruck beschreibt einen **[Wert](#wert)** durch das Verknüpfen von **[Funktionen](#funktion)** oder **[Operatoren](#operator)** in Verbindung mit Werten oder **[Variabeln](#variable)**. Ein Ausdruck ist dabei immer Bestandteil einer **[Anweisung](#anweisung)**.
+Ein Ausdruck (alternativ: Expression) ist ein grundlegender Bestandteil jedes Programms. Ein Ausdruck beschreibt einen **[Wert](#wert)** durch das Verknüpfen von **[Funktionen](#funktion)** oder **[Operatoren](#operator)** in Verbindung mit Werten oder **[Variablen](#variable)**. Ein Ausdruck ist dabei immer Bestandteil einer **[Anweisung](#anweisung)**.
 ### Anweisung
 Eine Anweisung (alternativ: Befehl) ist grundlegender Bestandteil jedes Programms. Eine Anweisung kann verschiedene **[Ausdrücke(#ausdruck)** miteinander durch Funktionsaufrufe oder **[Operatoren](#operator)** verbinden aber auch einer **[Variable](#variable)** zuweisen. Im Allgemeinen enthält eine Codezeile eine Anweisung.
 ### Variable
@@ -45,13 +45,13 @@ Als Index bezeichnet man die Position, bei 0 beginnend, eines **[Elementes](#ele
 Eine Liste ist ein **[Typ](#typ)**, der in Python mitgeliefert wird. In einer Liste können beliebig viele **[Werten](#wert)** mit beliebigen **[Typen](#typ)** gespeichert werden. Dabei kann ein Wert beliebig häufig in der selben Liste auftreten. Ebenso können Werte verschiedenen Typs in der selben Liste gespeichert werden. Häufig werden die Werte in einer Liste als **[Elemente](#element)** bezeichnet. Auf die Elemente einer Liste wird über deren Position in der Liste (ihren **[Index](#index)**) zugegriffen. Die Zählung der Indexe beginnt dabei bei `0`, d.h. das erste Element einer Liste mit `n` Elementen hat den Index `0` und das letzte Element den Index `n-1`. Zu beachten ist, das im Gegensatz zu den Typen **[Integer](#integer)**, **[String](#string)**, **[Float](#float)** und **[Boolean](#boolean)** die Liste ein dynamischer Typ ist.
 ### Tupel
 Ein Tupel ist ein **[Typ](#typ)**, der von Python mitgeliefert wird. Er besitzt ähnliche Eigenschaften wie der Typ **Liste**. Der markante Unterschied zwischen diesen
-beiden Typen ist, dass ein Tupel unveränderlich ist, sowohl bezüglich der Anzahl der **[Elemente](#element)** als auch bezgl. der Elemente. Der Zugriff geschieht wie bei dervListe über den **[Index](#index)** eines Elements.
+beiden Typen ist, dass ein Tupel unveränderlich ist, sowohl bezüglich der Anzahl der **[Elemente](#element)** als auch bezüglich der Elemente. Der Zugriff geschieht wie bei dervListe über den **[Index](#index)** eines Elements.
 ### Dictionary
 Ein Dictionary ist ein **[Typ](#typ)**, der von Python mitgeliefert wird. Es ist ebenso wie die **[Liste](#liste)** oder das **[Tupel](#tupel)**, ein iterativer Typ. Im Gegensatz zu diesen beiden Typen wird auf ein **[Element](#element)**, dass in einem Dictionary gespeichert wird nicht über einen **[Index](#index)**, sondern über ein Schlüssel zugegriffen.
 ### Schleife
 Eine Schleife ist eine **[Kommandostruktur](#kommandostruktur)** und dient dazu eine Folge von Anweisungen wiederholt auszuführen, bis eine **[Bedingung](#bedingung)** erreicht ist. Diese Bedingung nennt man Abbruchbedingung. In Python gibt es zwei Arten von Schleifen, die in ihren Möglichkeiten gleichwertig sind, sie unterscheiden sich jedoch in der **[Syntax](#syntax)**, und Handhabung.
 #### while Schleife
-Eine while-Schleife ist eine **[Schleife](#schleife)** , die einen **[boolschen](#boolean)** Ausdruck entgegennimmt, diesen auf Wahrheit prüft und dann einen Codeblock wiederholt ausführt. Nach jedem Durchlauf wird der boolsche Ausdruck erneut geprüft. Sollte der Ausdruck nicht mehr den **[Wert](#wert)** `True`ergeben, wird das Durchlaufen der Schleife beendet. 
+Eine while-Schleife ist eine **[Schleife](#schleife)** , die einen **[boolschen](#boolean)** Ausdruck entgegennimmt, diesen auf Wahrheit prüft und dann einen Codeblock wiederholt ausführt. Nach jedem Durchlauf wird der boolsche Ausdruck erneut geprüft. Sollte der Ausdruck nicht mehr den **[Wert](#wert)** `True`ergeben, wird das Durchlaufen der Schleife beendet.
 #### for Schleife
 Eine for-Schleife ist eine **[Schleife](#schleife)** die ein iterierbares **[Objekt](#objekt)** durchläuft. Beispielsweise lassen sich somit **[Strings](#string)**, **[Listen](#liste)**, **[Tupel](#tupel)** oder **[Dictionaries](#dictionary)** durchlaufen. Durch die `range()` **[Funktion](#funktion)** lassen sich sehr Zählschleifen implementieren.
 ## Level 5:
diff --git a/Home.md b/Home.md
@@ -54,7 +54,7 @@ Level 1 beginnt mit dem Programmieren einfacher Programme in Python und klärt G
 * Kommentar
 
 ### Level 2
-Level 2 führt eine erste Kontrollstruktur ein, welche ein wichtiges Element jeder Programmiersprache darstellt. Desweiteren wird ein neuer Typ eingeführt.
+Level 2 führt eine erste Kontrollstruktur ein, welche ein wichtiges Element jeder Programmiersprache darstellt. Des Weiteren wird ein neuer Typ eingeführt.
 #### Stichwörter:
 * Programmablauf
 * if-Bedingung
@@ -104,7 +104,7 @@ Dieses Level beschäftigt sich mit Themen, die in bisherigen Level nicht behande
 
 ### Level 6
 
-In Level 6 geht es um Konsolenanwendungen. Diese kann man grob in zwei Arten unterteilen:
+In Level 6 geht es um Konsolen-Anwendungen. Diese kann man grob in zwei Arten unterteilen:
  * Programme, die nur Parameter entgegennehmen und etwas ausgeben
  * Programme, die interaktiv arbeiten
 
@@ -115,7 +115,7 @@ Einfache Formen des letzteren Typs kamen bereits in den vorigen Level vor.
  * `curses`
 
 ### Level 7 (OOP 1)
-Level 7 widmet sich den fortgeschritterenen Bereich der Objektorientierten Programmierung. Dieses Konzept hat auch in vielen anderen Programmiersprachen eine große Bedeutung. In diesen Level werden die Kompetenzen vermittelt um eigene Typen zu definieren, Klassen oder Module zu schreiben, sowie ein grundsätzliches Verständnis von Objektorientierter Programmierung.
+Level 7 widmet sich dem Bereich der Objektorientierten Programmierung. Dieses Konzept hat auch in vielen anderen Programmiersprachen eine große Bedeutung. In diesen Level werden die Kompetenzen vermittelt um eigene Typen zu definieren, Klassen oder Module zu schreiben, sowie ein grundsätzliches Verständnis von Objektorientierter Programmierung.
 
 #### Stichwörter:
 * Klassen
diff --git a/Level10.md b/Level10.md
@@ -26,7 +26,7 @@ import sys
 
 ## `QApplication`-Objekt erstellen
 
-Um überhaupt irgendetwas mit Qt machen zu können, brauchen wir eine Instanz von `QApplication`. (Bei reinen Konsolenanwendungen kann man auch `QCoreApplication` verwenden.)
+Um überhaupt irgendetwas mit Qt machen zu können, brauchen wir eine Instanz von `QApplication`. (Bei reinen Konsolen-Anwendungen kann man auch `QCoreApplication` verwenden.)
 
 ``` python
 app = QApplication(sys.argv)
diff --git a/Level2.md b/Level2.md
@@ -3,7 +3,7 @@
 In Level 1 hast du gelernt Eingaben in der Konsole vom Benutzer entgegen zu nehmen und, diese EIngaben zu verarbeiten und die Ergebnisse dieser Verarbeitung in der Konsole auszugeben.
 
 In Level 2 wirst die `if`-Bedingung kennenlernen, die es dir ermöglicht Bedingungen zu prüfen, die erfüllt sein müssen, damit ein Codeabschnitt ausgeführt werden kann.
-Desweiteren wirst du die `while`-Schleife kennenlernen, welche einen Codeabschnitt wiederholt ausführt, solange eine Bedingung erfüllt ist.
+Des Weiteren wirst du die `while`-Schleife kennenlernen, welche einen Codeabschnitt wiederholt ausführt, solange eine Bedingung erfüllt ist.
 Im Zusammenhang mit der `if`-Bedingung und der `while`-Schleife wirst du den Datentypen `boolean` kennenlernen. Dieser Datentyp beinhaltet Wahrheitswerte.
 Am Ende des Levels wirst bereits in der Lage sein komplexere Programme umzusetzen.
 
diff --git a/Level3.md b/Level3.md
@@ -12,7 +12,7 @@ Eine Liste wird mit `[]` definiert.
   Viele Objekte lassen sich mit `list()`in eine Liste umwandeln, dabei wird eine neue
   Liste erstellt.
 
-``` python 
+``` python
 >>> print(list("abcd"))
 	['a', 'b', 'c', 'd']
 ```
@@ -224,7 +224,7 @@ Ein Dictionary kann man mit `{}` definieren:
 	{'eins':'one', 'zwei':'two'}
 ```
 Es ist allerdings auch möglich ein Dictionary über die Funktion `dict()` zu definieren.
-Dabei kann man der `dict()` Funktion eine zweidimensionale Liste der  Form: 
+Dabei kann man der `dict()` Funktion eine zweidimensionale Liste der  Form:
 ``` python
 a = [[key, value], [key2, value2]]
 ```
@@ -237,8 +237,8 @@ t = ((key, value), (key2, value2))
 #### Zugriff1
 
 
-Anders als bei Listen und Tupeln, wird auf ein Wert in einem Dictonary nicht über den Index
-sondern über den Schlüssel zugegriffen. Praktischerweise ähnelt sich die Syntax dem 
+Anders als bei Listen und Tupeln, wird auf ein Wert in einem Dictionary nicht über den Index
+sondern über den Schlüssel zugegriffen. Praktischerweise ähnelt sich die Syntax dem
 Zugriff auf eine Liste oder ein Tupel.
 ``` python
 >>> d = {"eins":"one", "zwei":"two", "drei":"three"}
diff --git a/Level4.md b/Level4.md
@@ -33,12 +33,10 @@ text = file_object.read()
 file_object.close()
 ```
 Die Methode `read()` liefert dabei einen String zurück, der den Inhalt der Datei enthält.
-Alternativ kann auch die Methode `readlines()` benutzt werden. Diese gibt eine Liste von Zeilen 
+Alternativ kann auch die Methode `readlines()` benutzt werden. Diese gibt eine Liste von Zeilen
 zurück.
 
-Wichtig zu beachten ist, dass die Datei gelesen wird, indem ein Zeiger durch sie durch läuft,
-was bedeutet, dass nach dem vollständigen Lesen der Datei der Zeiger zurück gesetzt werden 
-muss, da sonst ein leerer String zurückgegeben werden wird. 
+Wichtig zu beachten ist, dass die Datei gelesen wird, indem ein Zeiger durch sie durch läuft, was bedeutet, dass nach dem vollständigen Lesen der Datei der Zeiger zurück gesetzt werden muss, da sonst ein leerer String zurückgegeben werden wird.
 
 ``` python
 filename = "loremipsum.txt"
@@ -69,8 +67,7 @@ file_object.close()
 Wenn die Datei mit dem Dateinamen nicht vorhanden ist, wird sie in diesem Modus erstellt.
 Wichtig ist, dass die Datei dabei überschrieben wird, falls sie schon vorhanden war.
 
-Es ist auch möglich einzelne Zeilen in die Datei zu schreiben, was grade bei größeren Texten 
-sinnvoll sein kann.
+Es ist auch möglich einzelne Zeilen in die Datei zu schreiben, was grade bei größeren Texten sinnvoll sein kann.
 
 ``` python
 content = 10*["spam"]
@@ -92,8 +89,7 @@ file_object.close()
 ```
 
 ## An eine Datei anfügen
-Beim Anhängen an eine Datei wird beim Öffnen der Datei der Zeiger auf das Dateiende gelegt,
-sodass etwas, das in die Datei geschrieben wird, an das Ende der Datei dran gehangen wird.
+Beim Anhängen an eine Datei wird beim Öffnen der Datei der Zeiger auf das Dateiende gelegt, sodass etwas, das in die Datei geschrieben wird, an das Ende der Datei dran gehangen wird.
 
 ``` python
 content = 100*"spam\n"
@@ -104,5 +100,4 @@ file_object.close()
 ```
 
 Ebenso wie beim Schreiben, wird die Datei erstellt, sollte sie nicht vorhanden sein.
-Das Verhalten der Methoden `writeline()`und `writeline()`ist in diesem Modus analog zu ihrem
-Verhalten im Schreiben Modus.
+Das Verhalten der Methoden `writeline()`und `writeline()`ist in diesem Modus analog zu ihrem Verhalten im Schreiben Modus.
diff --git a/Level4_Aufgaben.md b/Level4_Aufgaben.md
@@ -17,7 +17,7 @@ Schreibe ein Programm, dass seinen Quellcode ausgibt.
 
 * einen Integer `n` einliest,
 * die Häufigkeitstabelle der Buchstaben aus der, zuvor erstellten, Datei `chars.txt`einliest,
-* die `n` häufigsten und die `n` seltesten Buchstaben ausgibt.
+* die `n` häufigsten und die `n` seltenen Buchstaben ausgibt.
 
 ### c)
 **Schreibe ein Programm, dass:**
diff --git a/Level5.md b/Level5.md
@@ -35,7 +35,7 @@ Nun wollen wir unsere Funktion ein wenig aufpeppen, indem wir ihr einen Paramete
 ``` python
 >>> def new_print(text):
 ...     print(text)
-... 
+...
 >>> inp_text = input("Eingabe: ")
     Testeingabe
 >>> new_print(inp_text)
@@ -68,7 +68,7 @@ Diese Unterscheidung ist sehr wichtig, da die Verwendung von mehreren Parametern
 ``` python
 >>> def diff(a, b):
 ...     return a - b
-... 
+...
 >>> print(5, 3)
     2
 >>> print(3, 5)
@@ -80,9 +80,9 @@ Nun möchte ich aber einer Funktion eine beliebige Anzahl an Parametern übergeb
 
 ``` python
 >>> def string_add(*elemente):
-...     result = "" 
+...     result = ""
 ...     for e in elemente:
-...         result += str(e)	
+...         result += str(e)
 ...     return result
 ...
 >>> print( string_add(0, 1, "test"))
@@ -95,7 +95,7 @@ Das `*elemente` steht dabei für ein Tupel und kann innerhalb der Funktion als T
 ...     for summand in more_summands:
 ...         result += summand
 ...     return result
-... 
+...
 >>> print( add_int(1, 5, 6) )
     12
 ```
@@ -116,7 +116,7 @@ Es ist auch möglich, eine beliebige Anzahl von keyword arguments zu benutzen. D
 >>> def fun(**kwargs):
 ...     print(kwargs.keys())
 ...     print(kwargs.values())
-... 
+...
 >>> fun(test1 = "foo", test2 = "test")
     dict_keys(['test1', 'test2'])
     dict_values(['foo', 'test'])
diff --git a/Rekursion_Vs._Iteration.md b/Rekursion_Vs._Iteration.md
@@ -1,32 +1,22 @@
 # Rekursion Vs. Iteration
 ## Einleitung
-Zum Anfang betrachten wir, was genau Rekursion ist. Im Grunde ist Rekursion
-nämlich nur ein Sprachfeature, dass eine Funktion sich selber aufrufen kann.
-Jedoch ist eine Programmiersprache auch ohne Rekursion Turing komplett, d.h. ich
-kann jedes Programm auch ohne Rekursion implementieren. Das wird unter anderem
-dadurch deutlich, dass eine rekursive Funktion beim Übersetzen in Maschinencode
-als Schleife ausgeführt wird. Zusammenfassend kann man also sagen:
+Zum Anfang betrachten wir, was genau Rekursion ist. Im Grunde ist Rekursion nämlich nur ein Sprachfeature, dass eine Funktion sich selber aufrufen kann. Jedoch ist eine Programmiersprache auch ohne Rekursion Turing komplett, d.h. ich kann jedes Programm auch ohne Rekursion implementieren. Das wird unter anderem dadurch deutlich, dass eine rekursive Funktion beim Übersetzen in Maschinencode als Schleife ausgeführt wird. Zusammenfassend kann man also sagen:
 
 > Alles was sich iterativ implementieren lässt, lässt sich auch rekursiv
 > implementieren und anders herum.
 
-Rekursion bietet sich an, da viele Algorithmen rekursiv definiert sind und daher
-rekursiv leichter zu implementieren sind als iterativ. Damit ist jedoch nicht
-gesagt, dass die rekursive Implementierung die effizientere ist.
-Ein einfaches Beispiel dafür sind die Fibonacci-Zahlen.
+Rekursion bietet sich an, da viele Algorithmen rekursiv definiert sind und daher rekursiv leichter zu implementieren sind als iterativ. Damit ist jedoch nicht gesagt, dass die rekursive Implementierung die effizientere ist. Ein einfaches Beispiel dafür sind die Fibonacci-Zahlen.
 
 ## Die Fibonacci-Zahlen
-Die Fibonacci-Zahlen tauchen in der Natur auf und sind eine relativ schnell
-wachsende Zahlenfolge, die folgendermaßen definiert ist:
+Die Fibonacci-Zahlen tauchen in der Natur auf und sind eine relativ schnell wachsende Zahlenfolge, die folgendermaßen definiert ist:
 ```
 fib(0) = 1
 fib(1) = 1
 fib(n) = fib(n-2) + fib(n-1)
 ```
 ### Einfache rekursive Implementierung
 
-Die Definition ist eindeutig rekursiv, folglich wäre der simpelste Ansatz diese
-Zahlenfolge zu implementieren die folgende:
+Die Definition ist eindeutig rekursiv, folglich wäre der simpelste Ansatz diese Zahlenfolge zu implementieren die folgende:
 ``` python
 def fibR(n): # Fibonacci Rekursiv
 	if n == 0 or n == 1:
@@ -37,13 +27,14 @@ def fibR(n): # Fibonacci Rekursiv
 ### Probleme
 
 Dieser Code funktioniert, ist leicht zu lesen hat aber einige Nachteile:
+
 #### Rekursionslimit
-Der Rekursion ist ein Limit gesetzt, weshalb der Code bei größeren Zahlen in
-einen `RecursionError`laufen wird. In diesem Fall passiert dies schon sehr früh,
-weil es zwei rekursive Aufrufe in der Funktion gibt.
+
+Der Rekursion ist ein Limit gesetzt, weshalb der Code bei größeren Zahlen in einen `RecursionError`laufen wird. In diesem Fall passiert dies schon sehr früh, weil es zwei rekursive Aufrufe in der Funktion gibt.
+
 #### Laufzeit
-Das weitaus größere Problem ist die Laufzeit, denn dadurch, dass fibR(n-2) und
-fibR(n-1) aufgerufen werden, wird fibR() immer häufiger aufgerufen:
+
+Das weitaus größere Problem ist die Laufzeit, denn dadurch, dass fibR(n-2) und fibR(n-1) aufgerufen werden, wird fibR() immer häufiger aufgerufen:
 ```
 n = 5
 fibR(5) wird 1 mal aufgerufen
@@ -53,15 +44,12 @@ fibR(2) wird 3 mal aufgerufen
 fibR(1) wird 5 mal aufgerufen
 fibR(0) wird 8 mal aufgerufen
 ```
-Wenn man sich die Anzahl der Aufrufe genau anschaut, stellt man fest dass es
-sich um die Fibonaccifolge handelt. Die rekursive Implementation berechnet also
-ihre eigene Laufzeit. Da die Fibonaccifolge aber relativ schnell wächst, wächst
-auch die Laufzeit relativ schnell.
+Wenn man sich die Anzahl der Aufrufe genau anschaut, stellt man fest dass es sich um die Fibonaccifolge handelt. Die rekursive Implementation berechnet also ihre eigene Laufzeit. Da die Fibonaccifolge aber relativ schnell wächst, wächst auch die Laufzeit relativ schnell.
 
 ### Lösung
-Da jeder Algorithmus sowohl rekursiv, als auch iterativ implementiert werden
-kann und die rekursive Implementation Probleme aufwies, versuchen wir jetzt die
-Fibonacci Folge iterativ zu implementieren:
+
+Da jeder Algorithmus sowohl rekursiv, als auch iterativ implementiert werden kann und die rekursive Implementation Probleme aufwies, versuchen wir jetzt die Fibonacci Folge iterativ zu implementieren:
+
 ```
 def fibI(n): # Fibonacci Iterativ
 	last = 1
@@ -70,13 +58,8 @@ def fibI(n): # Fibonacci Iterativ
 		current, last = current + last, current
 	return current
 ```
-Diese Funktion implementiert die Folge iterativ, läuft daher nicht in einen
-`RecursionError` benötigt `n` Durchläufe der Schleife, ist also deutlich
-schneller als die rekursive Implementierung.
+
+Diese Funktion implementiert die Folge iterativ, läuft daher nicht in einen `RecursionError` benötigt `n` Durchläufe der Schleife, ist also deutlich schneller als die rekursive Implementierung.
 
 ### Fazit
-Die beiden gezeigten Implementierungen eines einfachen Problems, waren ungefähr
-gleich komplex, haben sich aber in der Laufzeit stark unterschieden.
-Beide Möglichkeiten der Implementation haben jedoch ihre Vorzüge, weshalb im
-Einzelfall entschieden werden muss, mit welcher Methode ein Algorithmus
-implementiert wird.
+Die beiden gezeigten Implementierungen eines einfachen Problems, waren ungefähr gleich komplex, haben sich aber in der Laufzeit stark unterschieden. Beide Möglichkeiten der Implementation haben jedoch ihre Vorzüge, weshalb im Einzelfall entschieden werden muss, mit welcher Methode ein Algorithmus implementiert wird.
diff --git a/Shell.md b/Shell.md
diff --git a/Versionskontrolle.md b/Versionskontrolle.md
diff --git a/random.md b/random.md
