# -*- coding: utf-8 -*-
"""
* Erstellt von python.in5min.de
* Nur für persönlichen Gebrauch.
* Bitte nicht ohne Erlaubnis vervielfältigen.
* Wir bieten Dir hochwertigen Inhalt und 
* freuen uns wenn Du unseren Kanal abonnierst:
https://www.youtube.com/channel/UCpXRCrf8o1JaRGN3zSXugMQ    
"""

####################################
# VIDEO 1: INSTALLATION
####################################
# Installiere Anaconda von
# https://www.anaconda.com/products/distribution
# Öffne dann Spyder
# mit # beginnt ein Kommentar für den Rest der Zeile
print("Hallo")

# Ausführen mit Menü -> Run -> Run (F5)
# oder Selektieren und dann Menü -> Run -> Run selection (F9)




####################################
# VIDEO 2: VARIABLEN
####################################
a = 10      # int variable a bekommt Wert 10
b = 3.141   # float variable b bekommt Wert 3.141
c = "abc"   # String variable c bekommt Wert abc
d = True    # boolean d = True oder False

# Rechnen
2+2     # Addition
17/3    # 17 = 5*3 + 2
17//3   # floor division
17%3    # rest 2
5**2    # 5^2

# Beispiel Rechteck
laenge = 10
breite = 5
flaeche = laenge * breite
print("Ergebnis",flaeche)

# Beispiel Steuer

netto = 10
steuer = 0.19
brutto = netto * (1+steuer)
brutto = round(brutto ,2)
print(brutto)

# Input
name = input("Bitte Name eingeben:") # User gibt String ein
print(name)
alter = int(input("Bitte Alter eingeben:"))
print("Sie sind ca.", alter*12, "Monate alt.")

# str -> int   int(text)
# str -> float float(text)
# int -> str   str(zahl)




# Task:
# Berechne Deinen Body-Mass-Index (BMI)
# BMI = Gewicht (kg)/Größe^2 (m^2)
gewicht = 73
groesse = 1.75
bmi = gewicht / (groesse**2)
print(round(bmi))


####################################
# VIDEO 3: TEXTE bzw. STRINGS
####################################


my_dir = "C:\new directory"  # \n -> new line
print(my_dir)
my_dir = r"C:\new directory"  # raw string
print(my_dir)

print("erste Zeile\nzweite Zeile")

print("""das hier
      ist ein langer
      Text""")   # String über mehrere Zeilen

print(3 * "Py" + "thon")

#  P  y  t  h  o  n
#  0  1  2  3  4  5
# -6 -5 -4 -3 -2 -1

text = "Python"
print(text[0])   # P
print(text[1:4]) # von 1 (inklusive) bis 4 (exklusive)
print(text[-3:]) # vom drittletzten bis Ende
print(text[:-3]) # Anfang bis drittletzten (exklusive)

text[0] = "M"    # Fehler; leider nicht möglich
print("M" + text[1:])


# Methoden für Strings
e = str(123)  # Zahl in String umwandeln
print("abc".capitalize())       # Abc
print("abcabc".count("ab"))     # 2
print("abc".find("b"))          # 1 -> an zweiter Stelle
print("b" in "abc")             # True
print("abc".isnumeric())        # False
print("123".isnumeric())        # True
print("abc".replace("b", "d"))  # adc
print("abc".split("b"))         # split bei b -> a,c
print("abc".upper())            # ABC
print(len("abc"))               # länge = 3


# Task:
# definieren einen String mit Deinem vollen Namen
# selektieren davon jeweils den Vorname und Nachname
name = "Peter Schanbacher"
print(name[:5])
print(name[6:])


# Task:
# Zählen wie viele Buchstaben "a" dein Name enthält
print(name.count("a"))

####################################
# VIDEO 4: LISTEN
####################################
quadrat = [1,4,9,16]

print(quadrat[0])
print(quadrat[2:])

quadrat.append(25)  # fügt 25 zur Liste hinzu
print(quadrat)

quadrat = quadrat + [36,48,64,81,100]
print(quadrat)

quadrat[6] = 49
print(quadrat)



buchstaben = ["a", "b", "c", "d", "e", "f", "g"]
print(buchstaben[2:5])
buchstaben[2:5] = ["x", "y", "z"]
print(buchstaben)
buchstaben[2:5] = []
print(buchstaben)
buchstaben[:] = []  # leere Liste
print(buchstaben)

len(buchstaben)     # Länge der Liste

# verschachtelte Listen
x = ["a", "b", "c"]
y = [1,2,3]
z = [x,y]
print(z)

print(z[0][1]) # erste Liste, zweites Element


# Task:
# Erstellen Sie eine Liste mit kubischen Zahlen
# d.h. 1^3, 2^3, 3^3,....
kub = [1**3, 2**3, 3**3, 4**3]
print(kub)

####################################
# VIDEO 5: DICTIONARIES und SETS
####################################
# Dictionaries sind key:value Paar
alter = {"Tim":20, "Tom":22, "Tina":3}
print(alter)


# operation
print(len(alter))   # len = length 
print(alter["Tim"])
alter["Tim"]=21      # key one hat Wert 0
del alter["Tom"]
print(alter)
print("Tina" in alter)
print(alter.keys())
print(alter.values())



# Sets {}
# ungeordnete Liste von eindeutigen Elementen
fruechte = {"Apfel", "Apfel","Apfel", "Birne"}
print(fruechte)

print("Apfel" in fruechte)
print("Orange" in fruechte)

set1 = set("aabbbcccccc")           
print(set1)
set2 = set("cccccdeeeeee")
print(set2)
print(set1-set2)    # ohne: elemente aus set1 ohne elemente aus set2
print(set1|set2)    # oder: elemente aus set1 ODER set2 (oder beides)
print(set1&set2)    # und: elemente aus set1 UND set2
print(set1^set2)    # exklusives oder: in set1 oder set2 aber nicht beides

# Task Sets:
# 1. Wie viele eindeutige Buchstaben hat ihr Name?
# 2. Geben Sie alle Buchstaben ohne Vokale aus.
name = set("Peter")
print(name)
print(len(name))  # 4 eindeutige Buchstaben
vokale = {"a", "e", "i", "o", "u"}
print(name-vokale)


# Task Dictionary:
# Erstelle ein Telefonbuch Dictionary 
# mit Namen und Telefonnummer Ihrer Freunde
# und gebe die Telefonnummer eines Freundes aus
tel = {"Tim":"0178", 
         "Tom":"0179", 
         "Tina": "0171"}
print(tel["Tim"])

####################################
# VIDEO 6: Stacks & Queues
####################################


# Stacks (Stapel)
# last-in first-out
stack = []
stack.append("Lisa")
stack.append("Lena")
stack.append("Lars")
print(stack)
# entferne 2 Personen
stack.pop()
stack.pop()
print(stack)

# Queues (Schlange)
queue = []
queue.append("Lisa")
queue.append("Lena")
queue.append("Lars")
print(queue)
# entferne 2 Personen
queue.pop(0)
queue.pop(0)
print(queue)


####################################
# VIDEO 7: Vergleiche
####################################

# Zuweisung vs. Gleichheit
a = 1   # d.h. a bekommt Wert 1
a == 1  # True: hat a Wert 1?

a <= 1  # True: ist a <= 1
a != 1  # False: ist a ungleich 1?


# Achtung copy
original = [1,2]
tmp = original
tmp[0] = 1000
print(original)  # original wurde verändert

# verwende .copy()
original = [1,2]
tmp = original.copy()
tmp[0] = 1000
print(original) # original wurde nicht verändert

# Vergleiche
# a < b == c -> a<b and b==c
# Hierarchie von Operatoren
# A and not B or C -> (A and (not B)) or C

# and / or
print(True and False) # Falsch
print(True or False)  #  True
(True and (not True)) or False # False
    
# Vergleich Sequenzen
print([1,2,3]<[1,2,4]) # True
print([1,3,0,0]<[1,2,9,9]) # False
print("ABC"<"C"<"Subscribe") # True
print([1,2] ==  [1.0,2.0]) # True   
    

# Task: Ratespiel
# 1.) wähle eine Zufallszahl (1-6)
# 2.) der Benutzer rät eine Zahl
# 3.) gebe aus, ob richtig geraten
#     (True oder False)

import numpy as np
nummer = np.random.randint(1,7) 

antwort=int(input("Wie lautet Ihre Zahl:"))
print(antwort == nummer)
    




####################################
# VIDEO 8: If Statement
####################################

# if ... elif ... elif ... else

x = int(input("Bitte Zahl eingeben:"))
if x < 0:   # if BEDINGUNG
    print("negativ")
elif x==0:  # else if BEDINGUNG
    print("Null")
else:       # sonst... 
    print("positiv")
    
# Task:
# Lassen Sie einen Namen eingeben
# Testen Sie mit der If-Abfrage
# ob der Name gleich Jonah, Lian oder Kira ist....

x = input("Name:")
if x == "Jonah":
    print("Sie heissen Jonah")
elif x == "Lian":
    print("Sie heissen Lian")
elif x == "Kira":
    print("Sie heissen Kira")
else:
    print("Sie heissen nicht Jonah, Lian oder Kira.")

# Alternativ    
x = input("Name:")
name = ["Jonah", "Lian", "Kira"]
if x in name:  # input in der Liste?
    print("Ihr Name ist in der Liste")
else:
    print("Name nicht in der Liste")
    



# Task: Ratespiel
# 1.) wähle eine Zufallszahl (1-6)
# 2.) der Benutzer rät eine Zahl
# 3.) gebe aus, ob zu hoch, 
#     zu tief oder richtig geraten


import numpy as np
nummer = np.random.randint(1,7) 

antwort=int(input("Wie lautet Ihre Zahl:"))
if antwort == nummer:
    print("richtig")
elif antwort < nummer:
    print("zu tief")
else:
    print("zu hoch")
    
    
####################################
# VIDEO 9: While
####################################

i = 0

# while BEDINGUNG:
while not (i==10):   # solange i nicht 10   
    print(i)
    i = i+1


# = : Zuweisung
# == : Vergleich

# Task:
# Definieren Sie einen String mit ihrem Namen
# Iterieren Sie mit einer While Schleife
# durch die Buchstaben
name = "Peter"

i = 0
while i < len(name):
    print(name[i])
    i = i+1
    
# Task:
# Addieren Sie alle Zahlen von 0 bis 100
# 0 + 1 + 2 + 3 + .... + 100 = ?

i = 0
summe = 0
while i <= 100:
    summe = summe + i
    print(i)    
    i = i+1
    
    
# Fibonacci-Zahlen
a,b = 0,1  # a = 0 und b = 1
while b < 100:
    print(b)
    a,b = b,a+b


# Vergleiche
# a < b == c -> a<b and b==c
# Hierarchie von Operatoren
# A and not B or C -> (A and (not B)) or C

# and / or
print(True and False) # Falsch
print(True or False)  #  True
(True and (not True)) or False # False
    
# Vergleich Sequenzen
print([1,2,3]<[1,2,4]) # True
print([1,3,-1]<[1,2,9]) # False
print("ABC"<"C"<"Python") # True
print([1,2] ==  [1.0,2.0]) # True   
    

# Task: Ratespiel
# wähle eine Zufallszahl (1-6)
# Lasse den Benutzer so lange raten
# bis die richtige Zahl getippt wurde

import numpy as np
nummer = np.random.randint(1,7) 
antwort = None
while antwort!=nummer:
    antwort=int(input("Wie lautet Ihre Zahl:"))
    if antwort < nummer:
        print("zu klein")
    elif antwort > nummer:
        print("zu groß")
print("Richtig, die Zahl war", nummer)


####################################
# VIDEO 10: For
####################################


for i in [0,1,2,3]:  # for VAR in AUFLISTUNG:
    print(i)

for i in range(0, 10, 2): # start, stop, schrittweite
    print(i)
    
    

summe = 0
for x in range(101):
    summe = summe + x    
print(summe)

tel = {"Peter":"0178", "Conny":"0176", 
       "Jonah":"0171"}
for k,v in tel.items():
    print(k, "hat die Nummer", v)
    

# Task:
# Geben Sie die Länge von allen Wörtern 
# in einem Satz an.
# Tipp: split(" ")
satz = "mit in5min lerne ich super Python"

woerter = satz.split(" ")
for w in woerter:
    print(w, len(w))




####################################
# VIDEO 11: List Comprehensions
####################################


# Erstellen Sie eine Liste
# mit Quadratzahlen 1^2, 2^2, ... 10^2
quadrat = []
for i in range(11):
    quadrat.append(i**2)
print(quadrat)


# list comprehension
quadrat = [x**2 for x in range(11)]

# komplexes Beispiel
bsp = [(x,y)   for x in [1,2,3] 
               for y in [2,3,4]
               if x!=y]
print(bsp)


from math import pi
print("Pi:", [round(pi,i) for i in range(6)])

vec = [-4,-2,0,2,4]
print("Verdoppeln", [x*2 for x in vec])
print("Nicht-negativ", [x for x in vec if x>=0])
print("Betrag", [abs(x) for x in vec])

satz = "heute lerne Python programmieren"
print([w.upper() for w in satz.split()])

# Dictionaries
squares = {x:x**2 for x in range(5)}
print(squares)

# Task:
# Erstelle eine Liste mit allen
# Wurzeln von 1 bis 100,
# d.h. wurzel(1), wurzel(2),...,wurzel(100)
wurzel = [x**0.5 for x in range(1,101)]
print(wurzel) 

####################################
# VIDEO 12: break, continue
####################################



# break
i = 0
while True:
    print(i)
    i = i+1
    if i > 10:
        break  # beendet While Schleife
        
# continue
# Task:
# Geben Sie für alle Zahlen von 1 bis 10 aus
# ob die Zahl gerade oder ungerade ist
# Tipp: i%2==0
for i in range(1,11):
    if i%2 == 0:    # check ob gerade
        print(i,"ist gerade")
        continue
    print(i,"ist ungerade")



# Task
# gegeben ist eine Zahl n (bsp. n = 143)
# testen Sie ob n eine Primzahl ist
# n ist keine Primzahl wenn sich n 
# durch eine Zahl von 2 bis n-1 teilen lässt

n = 12
prime = True
for x in range(2,n):
    if n%x==0: # lässt sich n durch x teilen -> keine Primzahl
        print(n,"=", x,"*",n//x)
        prime = False
        break
if prime:
    print(n,"ist eine Primzahl")
else:
    print(n, "ist keine Primzahl")        

    
# Task: Alle Primzahlen von 2 bis 100 ausgeben
for n in range(2,101):    
    prime = True
    for x in range(2,n):
        if n%x==0: # lässt sich n durch x teilen -> keine Primzahl
            #print(n,"=", x,"*",n//x)
            prime = False
            break
    if prime:
        print(n,"ist eine Primzahl")
    
    


####################################
# VIDEO 13: Funktionen
####################################


def meineSumme(x,y):
    print(x+y)
meineSumme(3,5)


def meineSumme2(x,y):
    return(x+y)
erg = meineSumme(3,5)
print("Das Ergebnis ist", erg)



# Task:
# Erstellen Sie eine Funktion 
# division(zaehler,nenner)
# welche Ihnen zaehler/nenner zurückgibt

def div(zaehler,nenner=1): # nenner=1 default
    """gibt zaehler/nenner zurück"""
    quotient = zaehler/nenner
    return quotient

print(div(5,2))  # Positionsargument
print(div(nenner = 2, zaehler = 5)) # Keyword Argument


print(div(5)) # =5, da zaehler=5, nenner=1 (default)

# Positional vs. Keyword Argument
def satz(subj, verb, obj):
    print(subj,verb,obj)
# positional arguments
satz("Peter", "lernt", "Python")
# keyword arguments: Variablen der Funktion werden direkt angesprochen.
satz(obj="den Ball", verb="wirft", subj="Peter")


# Task:
# Lassen Sie Größe und Gewicht eingeben
# übergeben Sie diese an eine Funktion
# BMI welche Ihnen den BMI zurückgibt
# (gewicht/groesse^2)

def bmi(groesse,gewicht):
    bmi_value = gewicht/groesse**2
    return bmi_value


h = float(input("Bitte Groesse (m)"))
w = int(input("Bitte Gewicht (kg)"))

print(bmi(h,w))


####################################
# VIDEO 13: Module & Pakete laden
####################################
    
# Module im Arbeitspfad erstellen
# hier mein_modul.py
import mein_modul

# MODUL.FUNKTION()
print(mein_modul.meine_summe(2, 3))

# lokale Funktion
summe = mein_modul.meine_summe
summe(3,4)


# PAKETE
# numpy
#   fft.py      -> fourier-transform-modul
#   linalg.py   -> lineare Algebra modul
#   matlib.py   -> matrix modul
#   random.py   -> random modul
#       rand()  -> rand funktion
#       randint() -> randint funktion
#       ...

# 3 Varianten um Funktion randint() zu laden
from numpy.random import randint # einbinden funktion
print(randint(0,2))

import numpy.random # einbinden von modul
print(numpy.random.randint(0,2))
# Aufruf mit PAKET.MODUL.FUNKTION()

import numpy.random as r # importiere modul 
                         # mit Bezeichnung r
print(r.randint(0,2))


# Task:
# Definieren Sie sich selbst eine Funktion
# im Modul und rufen Sie diese auf
print(mein_modul.meine_differenz(2, 3))

####################################
# VIDEO 15: Mathematik & Statistik
####################################


####################################
# VIDEO 16: Zeiten
####################################




####################################
# VIDEO 17: Grafiken
####################################


####################################
# VIDEO 18: Debuggen 
####################################



####################################
# VIDEO 19: Fehlerbehandlung 
####################################

####################################
# VIDEO 21: Vererben
####################################



####################################
# VIDEO 21: Daten
####################################



# DATEIEN schreiben und lesen
import os
print(os.getcwd())
# pfad in welchen die Datei geschrieben wird

# attribute: w(rite), r(ead), a(ppend)
f = open("meine_datei.txt", "w") 
f.write("Meine Information \nzweite Zeile")
f.close()

# alternativ: automatisch close 
# hinzufügen -> a = append
with open("meine_datei.txt", "a") as f:
    f.write("\nneue Information")

# lese -> r = read    
with open("meine_datei.txt", "r") as f:
    lese = f.read()
    
print(lese)

# Json für Daten
import json
daten = [1,2,"Test"]

with open("info.txt", "w") as f:
    json.dump(daten,f)
    
import os
if os.path.isfile("info.txt"):
    with open("info.txt", "r") as f:
        daten2 = json.load(f)
    print(daten2)
else:
    print("File not there")
    daten2 = []
# Task:
# schreiben Sie einen Text oder Daten in eine
# Datei und laden dieses anschließend wieder