# Definition zweier integer Variablen
var_1 = 1
var_2 = 2

# Ausgabe der Summe auf dem Bildschirm
print("Die Summe der beiden Variablen ist: ", var_1 + var_2)

# Definition von String Variablen
var_1 = "Hello"
var_2 = "World!"

# Ausgabe der Summe auf dem Bildschirm
print("Der überraschende Text: ", var_1 + " " + var_2 + "\n" + "Das war überraschend!")

# Definition einer Funktion
def a_function(var_1, optional_var_1 = 10):
    
    # addiere 10 (oder einen anderen Term) zur eingegebenen Zahl
    output = var_1 + optional_var_1
    
    # was von der Funktion zurückgegeben wird
    return output

# verwende die Funktion
print("Ohne optionales Argument: ", a_function(1))
print("Mit optionalem Argument: ", a_function(1,5))

# Definition der Liste
a_list = [1,3,5,7,9]

# noch eine leere Liste
square_list = []

# For-Loop über Listen-Elemente
for an_element in a_list:
    
    # Ausgabe von Informationen zur Variable, über die der Loop läuft
    print(an_element, " zum Quadrat ist ", an_element**2)
    
    # Hänge ein Ergebnis an eine andere Liste an
    square_list.append(an_element**2)
    
# gib am Schluss auch die andere Liste aus
print("Die Quadrat-Liste ist jetzt ", square_list)

# Eine andere Art von Loop

# initialisiere einen Zähler
a_counter = 0

# While-Loop, bis der Zähler 10 erreicht
while a_counter < 10:
    
    # Ausgabe des Zählers
    print("die nächste Zahl ist ", a_counter)
    
    # Erhöhe den Zähler um 1
    a_counter += 1

# Loop über Elemente und indices einer Liste
for an_index, an_element in enumerate(square_list):
    
    # Ausgabe von Informationen, wobei man Index in der Liste und das Element nutzen kann
    print("die Zahl an der Stelle ", an_index, " ist ", an_element)
    

# Ein impliziter Loop erzeugt eine Liste
print("Die ersten paar Quadrate: ", [b**2 for b in range(100)])

# Variablen mit Wahrheitswert
is_it = True
it_is = False

# Ausgabe der Ergebnisse logischer Operationen
print("AND: ", it_is and is_it)
print("OR: ", it_is or is_it)

# IF-Statement, d.h. Abfrage ob etwas wahr oder falsch ist
if(it_is and is_it):
    
    # wenn Abfrage wahr ist, tu das:
    print("Kombiniert!")

# weitere Abfrage für zusätzliche Möglichkeiten
elif(it_is or is_it):
    
    # wenn das wahr ist, dann tu das:
    print("Nicht ganz!")
    
# und für alle andere Fälle
else:
    
    # wenn bisher nichts zugetroffen ist, dann tu das:
    print("Weder noch!")

# Definition eines Dictionary:
# Im Prinzip eine Sammlung von Zuordnungen von "values" zu "keys"
a_dict = {"Alice": 12, "Bob": 14}

# Ausgabe von Eigenschaften/values über keys
print("So alt ist Alice: ", a_dict["Alice"])

# Einträge in Dictionaries lassen sich hinzufügen
a_dict["Frank"] = 16

# und ändern
a_dict["Alice"] = 13

# Ausgabe des aktuellen Dictionary
print("Die aktuellen Werte: ", a_dict)

# values in Dictionaries können auch Dictionaries sein
another_dict = {"people": a_dict}

# so sieht ein verschachteltes Dictionary aus
print("Verschachteltes Dict: ", another_dict)

# Mathematische Funktionen ohne NumPy findet man hier:
import math as m

# andere Möglichkeiten für den Import:
# import math
# from math import sin, cos, exp

# Aber Achtung: Tun Sie das nie (Lebensgefahr!):
# from math import *

# Ausgabe des Sinus von Pi
print(m.sin(m.pi/2))

# Ausgabe der Exponentialfunktion von minus ein Halb
print(m.exp(-.5))

# NumPy stellt eine breite mathematische Funktionalität und Arrays bereit
import numpy as np

# Machen wir ein Array aus einer der Listen von oben
square_array = np.array(square_list)

# Ausgabe des Arrays
print(square_array)

# rechnen mit Arrays ist sehr intuitiv
# Hier die (elementweise) Multiplikation mit der Zahl 4
print(square_array*4)

# Hier das elementweise Quadrieren des Arrays
print(square_array**2)

# Hier der elementweise Logarithmus des Arrays
print(np.log(square_array))

# Hier die elementweise Exponentialfunktion des Arrays
print(np.exp(square_array))

# In NumPy findet man auch Zufallszahlen (mehr dazu in einer späteren Einheit), z.B.:

# Loop über 20 Runden
for i in range(20):
    
    # Wähle zwei Zahlen aus dem Array von vorhin, mit Zurücklegen
    a_selection = np.random.choice(square_array, 2, replace=True)
    
    # Gib das Ergebnis aus
    print(a_selection)
    
    # Überprüfe, ob die zwei gezogenen Zahlen zufällig gleich sind
    if a_selection[0] == a_selection[1]:
        
        # Wenn ja, bitte kurz jubeln!
        print("Yeee-Haaaa!")

# Arrays können auch mehrdimensional sein (die gewünschte Größe wird als Tupel angegeben):
another_array = np.random.random(size=(5, 5))

# Ausgabe dieses Zufallsarrays mit gleichverteilten Zahlen zwischen 0 und 1
print(another_array)

# Ein Array mit lauter 1en
some_ones = np.ones((5, 5))

# Ein Array mit lauter 0en
some_zeros = np.zeros((5, 5))

# Hier eine Art IF-Abfrage, aber elementweise für Arrays:
# wo das "andere Array" kleiner als 0.5 ist, schreibe eine 1 in den Check, 
# ansonsten schreibe dort eine 0 hinein
the_check = np.where(another_array < 0.5 * some_ones, some_ones, some_zeros)

# Ausgabe der 0en und 1en für das Check-Array
print(the_check)

# Summiere alle Fälle größer 0.5 und gib die Summe aus
print("größer als 1/2: ", np.sum(the_check))

# Die gleiche Summe, aber nur über die Spalten ausgeführt
# Die Ausgabe wird als Integer angefordert
print("pro Zeile: ", np.sum(the_check, axis=1).astype(int))

%matplotlib inline

# die vorige Zeile stellt den Ausgabe-Modus für Plots im Jupyter-Notebook ein

# Die Standart-Art, Matplotlib zu importieren
import matplotlib.pyplot as plt

# Beginne eine neue Figur/Grafik
fig = plt.figure()

# Zeichne rote Punkte von Daten aus dem Quadrat-Array, nochmals quadriert, mit Bezeichnung
plt.plot(np.arange(len(square_array)), square_array**2, "r.", label="Squares squared")

# Zeichne eine blaue Linie für Daten aus dem Quadrat-Array, mit Bezeichnung
plt.plot(np.arange(len(square_array)), square_array, "b-", label="Just Squares")

# Setze Beschriftung für die x-Achse fest
plt.xlabel("Numbers")

# Setze Beschriftung für die y-Achse fest
plt.ylabel("Squares?")

# Setze Beschriftung für den Plot fest
plt.title("A nice plot")

# Setze Skalierung für die y-Achse auf logarithmisch
plt.yscale("log")

# Erzeuge aus den Bezeichnungen eine Legende im Plot
plt.legend(loc=0)

# Speichere die Grafik als pdf-Datei ab
plt.savefig("test_plot.pdf")

# Zeige die Grafik außerdem hier an
plt.show()

# Erzeuge noch eine Figur
fig2 = plt.figure()

# Plotte die Werte im anderen Array als farbige Bild-Punkte bzw. -Quadrate
plt.matshow(another_array)

# zeige die Figur hier an
plt.show()

# Direkter Input durch den User, Achtung, das Resultat ist eine String-Variable
# an dieser Stelle wartet das Programm auf eine Eingabe
a_number = int(input("Bitte eine Zahl eingeben: "))

# Ausgabe des Quadrats der Eingabe
print("Das Quadrat Ihrer Zahl ist ", a_number**2)

# Lesen aus einer Datei (präzise, kann aber mühsam sein)
# Zunächst öffnen wir die Datei, diesmal mit der Fähigkeit zu Lesen ("r")
in_f = open("a_text_file.csv", "r")

# Ausgabe der Zeilen in der gelesenen Datei
print(in_f.readlines())

# Schließe die Datei wieder
in_f.close()

# NumPy hat eine gute und einfachere Alternative für das Einlesen
# von Dateien parat, z.B. im csv-Format:
new_array = np.genfromtxt("a_text_file.csv", dtype=int, delimiter=",", skip_header=1)

# Ausgabe des eingelesenen Dateiinhalts
print(new_array)

# initialisiere die Liste der Primzahlen mit 2, der einzigen geraden Primzahl
list_of_primes = [2]

# Berechne die derzeitige Anzahl der Primzahlen in der Liste
total_number = len(list_of_primes)

# Setze den Wert für den ersten zusätzlichen Kandidaten nach der 2
candidate = 3

# Ein While-Loop hilft dabei, die Abbruchbedingung (1000 Zahlen) umzusetzen
while total_number < 1000:
    
    # setzte die Eigenschaft "ist eine Primzahl" auf True
    is_prime = True
    
    # jetzt suchen wir nach Teilern, dadurch können wir diese Eigenschaft ggf. widerlegen
    # Loop über alle bisher gefundenen Primzahlen (denn nur die kommen eigentlich als
    # Teiler in Frage)
    for a_prime in list_of_primes:
        
        # checke, ob die momentane Primzahl größer ist als die Wurzel aus dem
        # Kandidaten, denn wenn das so wäre, kann sie kein Teiler mehr sein
        # (denn dann müsste es auch einen kleineren Teiler geben, und die
        # haben wir alle schon überprüft)
        if a_prime > np.sqrt(candidate):
            
            # Verlasse den innersten Loop, in dem wir uns gerade befinden
            break
        
        # checke, ob die momentane Primzahl den Kandidaten teilt
        if (candidate % a_prime == 0):
            
            # wenn wir einen Teiler finden, setzen wir die Prim-Eigenschaft auf False um
            is_prime = False
    
    # nachdem jetzt alle möglichen Teiler überprüft sind, checke die Prim-Eigenschaft
    if is_prime:
        
        # ist immer noch wahr, also hängen wir den Kandidaten an die Primzahl-Liste an
        list_of_primes.append(candidate)
        
    # wenn die Eigenschaft false ist, passiert nichts
    
    # berechne die aktuelle Anzahl der Primzahlen in der Liste
    total_number = len(list_of_primes)  
    
    # Erhöhe die Kandidaten-Zahl um 2 (d.h. gehe zur nächsten ungeraden Zahl)
    candidate += 2

# Gib die Primzahl-Liste aus
print(list_of_primes)

# Erzeuge eine neue Grafik
fig2 = plt.figure()

# Erzeuge ein Histogramm der ersten 1000 Primzahlen
plt.hist(list_of_primes, bins=50)

# Beschrifte die Achsen
plt.xlabel("Zahlenbereich")
plt.ylabel("Anzahl")

# Zeige die Grafik an
plt.show()