# Definition
# def bezeichner([para1[, para2[, ...]]]) :
#   anweisung(en)
# bezeichner (Syntax):
# beginnt mit einem Buchstaben oder Unterstrich
# gefolgt von weiteren Buchstaben, Unterstrichen oder Ziffern
# Konventionen
# Beginnen mit Buchstaben
# danach alles, wie oben
# camelCasing vs. snake_casing

# Parameter
# Parameter sind optional,
# wurden sie allerdings definiert,
# müssen i. d. R. Argumente angegeben werden
def begruesse(gruss, name) :
  ''' Diese Funktion gibt eine Grussformel aus
      Eingabe: 2 Parameter vom Typ string
      Ausgabe: Gruss
      Rueckgabe: None 
  '''
  print("{:10s} {:5s}".format(gruss, name))

# falscher Aufruf:
# begruesse("Fritz")
# falscher Aufruf:
# begruesse("Hallo", "Fritz", "Willy")
begruesse("Hallo", "3")
# print(help(begruesse))

# Rückgabewert
# Jede Funktion gibt einen Wert zurück
# Dieser Wert ist "None", wenn kein explizizter Typ angegeben wurde
# Der Rückgabewert kann verarbeitet werden, muus aber nicht
def addiere(a, b) :
  ''' Diese Funktion addiert zwei Zahlen
   und liefert die Summe zurück
   Eingabe: zwei Zahlen
   Ausgabe : Summe
   Rueckgabe : Summe beider Zahlen
  '''
  summe = a + b
  print("Die Summe von {} und {} ist {}".format(a, b, summe))
  return summe

# Aufruf ohne Verarbeitung der Rückgabe:
addiere(2, 3)
# Aufruf mit Verarbeitung der Rückgabe
summe = addiere(3, 4)
print("Ergebnis:", summe)

# Lokalität der Variablen
def multipliziere(p, q) :
  # Berechnung
  produkt = p*q
  # boshaftes Veändern der Parameter
  p = p+2
  q = q*3
  print("innerhalb {} mal {} ist {}".format(p, q, produkt))
# Rückgabe des Ergebnisses
  return produkt

p = 3
q = 2
print("Produkt von {} und {} ist {}".format(p, q, multipliziere(p, q)))

# lokal/global
zaehler = 0
schritt = 1

def zaehle(schritt) :
  # Zugriff auf globale Variable zaehler
  global zaehler
  zaehler = zaehler + schritt
  # zaehler = 2
  return zaehler

zaehler = zaehle(schritt)
print("Zaehle:", zaehler)
zaehler = zaehle(schritt)
print("Zaehle:", zaehler)
# weiteres Zählen
zaehle(schritt)
zaehle(schritt)
zaehle(schritt)
print("Zaehle:", zaehler)

# variable Parameterzahl
# Variante 1
# explizites einpacken beliebig vieler Argumente
def summiere_1(zahlen) :
  '''
  Diese Funktion summiert beliebig viele Zahlen
  und gibt die Summe zurück
  Eingabe: Sammlung(!) von Zahlen
  Rueckgabe : Summe der beinhalteten Zahlen
  '''
  summe = 0
  for zahl in zahlen :
    summe += int(zahl)
  return summe

# Aufruf der Summation 1
zahlen = [1, 2, 3, 4, 5]
print("Die Summe von {} ist {}".format(zahlen, summiere_1(zahlen)))

# Zeichenketten sind iterabel!
zahlen = "12345"
print("Die Summe von {} ist {}".format(zahlen, summiere_1(zahlen)))

# einzelne Zahlen sind nicht iterierbar
# zahlen = 1
# print("Die Summe von {} ist {}".format(zahlen, summiere_1(zahlen)))

zahlen = (1, 2, 3, 4, 5)
print("Die Summe von {} ist {}".format(zahlen, summiere_1(zahlen)))
# so kein automatisches Einpacken!
# print("Die Summe von {} ist {}".format(zahlen, summiere_1( 2, 3, 4, 5)))

# Diese Funktion kann ich mit beliebig vielen Argumenten aufrufen
# "variadische Funktion"
# "varargs"
def summiere_2(*zahlen) :
  '''
  Diese Funktion summiert beliebig viele Zahlen
  und gibt die Summe zurück
  Eingabe: beliebig viele Zahlen
  Rueckgabe : Summe der Zahlen
  '''
  # print("Der Parameter ist vom Typ", type(zahlen))
  summe = 0
  for zahl in zahlen :
    summe += int(zahl)
  return summe

# Aufrufe
print("Die Summe_2 ist {}".format(summiere_2(1, 2, 3, 4, 5)))
zahlen = [1, 2, 3, 4, 5]
print("Die Summe_2 ist {}".format(summiere_2(*zahlen)))

# Aufgabe:
# Erweitern Sie die Funktion summiere_2 als "statistik" dahingehend,
# dass nicht nur die Summe, sondern auch das Maximum, das Minimum und der Durchschnittswert
# zurückgegeben werden

# Lösung
def statistik(*zahlen) :
  # Überprüfung der Parameter
  if len(zahlen) < 1 : return {"Minimum":None, "Maximum":None, "Summe":None, "Durchschnitt":None}
  # Definition der lokalen Variablen
  minimum = int(zahlen[0])
  maximum = int(zahlen[0])
  summe   = 0

  # Berechnung
  for zahl in zahlen :
    if minimum > int(zahl) : minimum = int(zahl)
    if maximum < int(zahl) : maximum = int(zahl)
    summe += int(zahl)
  durchschnitt = float(summe/len(zahlen))

  # Rückgabe
  return {"Minimum":minimum, "Maximum":maximum, "Summe":summe, "Durchschnitt": durchschnitt}

# Aufruf
zahlen = (1, 5, 7, 2, 3, 4, 6)
ergebnis = statistik(*zahlen)
print("Statistik {} ist {}".format(zahlen, ergebnis))
print("Summe ist {}".format(ergebnis['Summe']))
# Aufruf mit leerer Liste
zahlen = []
ergebnis = statistik(*zahlen)
print("Statistik {} ist {}".format(zahlen, ergebnis))
print("Summe ist {}".format(ergebnis['Summe']))
# Aufruf mit einem Argument
ergebnis = statistik(1)
print("Statistik {} ist {}".format(zahlen, ergebnis))
print("Summe ist {}".format(ergebnis['Summe']))
# Aufruf mit Zeichenkette
ergebnis = statistik(*"123400500600")
print("Statistik {} ist {}".format(zahlen, ergebnis))
print("Summe ist {}".format(ergebnis['Summe']))
# negative Zahlen
ergebnis = statistik(-1, -3, 56, -5, -7)
print("Statistik {} ist {}".format(zahlen, ergebnis))
print("Summe ist {}".format(ergebnis['Summe']))





# Weiteres
# benannter Aufruf / Reihenfolge ändern
def begruesse(gruss, vorname, name) : 
  print("{} {} {}!".format(gruss, vorname, name))

# "klassischer" Aufruf
begruesse("Guten Morgen", "Adam", "Meier")
begruesse(vorname="Eva", gruss="Hallo", name="Wagner")

# Vorgabewerte
# Definition mit Vorgabewerten
# Neudefinition der Funktion "begruesse"
# Default-Parameter stehen immer am Schluss
def begruesse(vorname, name, gruss="Hallo") :
  print("mit default: {} {} {}!".format(gruss, vorname, name))
begruesse("Adam", "Meier", "Guten Morgen")
begruesse(vorname="Eva", gruss="Guten Tag", name="Wagner")
begruesse(vorname="Otto", name="Schmitz")
begruesse("Anna", "Mueller")


# beliebige Anzahl von Argumenten
# Begrüßung von Menschen mit beliebig vielen Vornamen
def begruesse(gruss, *vornamen, name) :
  print("{}".format(gruss), end=" ")
  for vorname in vornamen :
    print("{}".format(vorname), end=" ")
  print(name)
begruesse("Hallo", "Hans", "Werner", "Friedrich", name="Meier")

# Funktionen sind auch Objekte
# Zuweisung zu weiterem Namen
def addiere(a, b) :
  return a+b

# Definition eines zusätzlichen Namens
plus = addiere

# Aufruf
print("Die Summe von {} und {} ist {}".format(3, 5, addiere(3, 5)))
print("Die Summe von {} und {} ist {}".format(3, 5, plus(3, 5)))

addiere = None
# print("Die Summe von {} und {} ist {}".format(3, 5, addiere(3, 5)))
print("Die Summe von {} und {} ist {}".format(3, 5, plus(3, 5)))

# Funktionen als Parameter
def berechne(funktion, parameter1, parameter2) :
  ergebnis = funktion(parameter1, parameter2)
  return ergebnis

# Aufrufe
def addiere(a, b) : return a+b
def multipliziere(a, b) : return a*b
print("{} + {} = {}".format(3, 4, berechne(addiere, 3, 4)))
print("{} * {} = {}".format(3, 4, berechne(multipliziere, 3, 4)))

# Beispiel sortieren
def kriterien(wert) :
  wochentage = {"Mo":1, "Di":2, "Mi":3, "Do":4, "Fr":5, "Sa":6, "So":7}
  return wochentage[wert]

wochentage = {"Mo":1, "Di":2, "Mi":3, "Do":4, "Fr":5, "Sa":6, "So":7}
liste = ["So", "Do", "Mi", "Sa", "Mo"]
print("Tage: {}, sortiert: {}".format(liste, sorted(liste, key=kriterien)))


# Funktionen als Rückgabe