#!/usr/bin/env python
# coding: utf-8

# <h1>Inhalt<span class="tocSkip"></span></h1>
# <div class="toc"><ul class="toc-item"><li><span><a href="#Kopieren--(Wiederholung)" data-toc-modified-id="Kopieren--(Wiederholung)-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Kopieren  (Wiederholung)</a></span></li><li><span><a href="#Kopieren-II-(Wiederholung)" data-toc-modified-id="Kopieren-II-(Wiederholung)-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Kopieren II (Wiederholung)</a></span></li><li><span><a href="#Operationen-auf-Listen" data-toc-modified-id="Operationen-auf-Listen-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Operationen auf Listen</a></span></li><li><span><a href="#Boolsche-Variablen-und-Operationen" data-toc-modified-id="Boolsche-Variablen-und-Operationen-4"><span class="toc-item-num">4&nbsp;&nbsp;</span>Boolsche Variablen und Operationen</a></span></li><li><span><a href="#Vergleiche" data-toc-modified-id="Vergleiche-5"><span class="toc-item-num">5&nbsp;&nbsp;</span>Vergleiche</a></span></li><li><span><a href="#Verzweigungen,-If-Anweisungen" data-toc-modified-id="Verzweigungen,-If-Anweisungen-6"><span class="toc-item-num">6&nbsp;&nbsp;</span>Verzweigungen, If Anweisungen</a></span></li><li><span><a href="#Formatierte-Strings" data-toc-modified-id="Formatierte-Strings-7"><span class="toc-item-num">7&nbsp;&nbsp;</span>Formatierte Strings</a></span></li><li><span><a href="#Funktionen" data-toc-modified-id="Funktionen-8"><span class="toc-item-num">8&nbsp;&nbsp;</span>Funktionen</a></span></li><li><span><a href="#Rekursionen" data-toc-modified-id="Rekursionen-9"><span class="toc-item-num">9&nbsp;&nbsp;</span>Rekursionen</a></span><ul class="toc-item"><li><span><a href="#erstes-Beispiel" data-toc-modified-id="erstes-Beispiel-9.1"><span class="toc-item-num">9.1&nbsp;&nbsp;</span>erstes Beispiel</a></span></li><li><span><a href="#zweites-Beispiel" data-toc-modified-id="zweites-Beispiel-9.2"><span class="toc-item-num">9.2&nbsp;&nbsp;</span>zweites Beispiel</a></span></li></ul></li></ul></div>

# # Lektion 2
# ## Kopieren  (Wiederholung)
# 
# Wir weisen a den Wert 1 zu

# In[25]:


a = 1
a


# Zuweisung von b

# In[2]:


b = a
b


# id gibt die Identität aus

# In[3]:


id(a), id(b)  # a und b haben dieselbe Identität


# hier wird a ein neuer Wert zugewiesen

# In[6]:


a = 2
a


# b bleibt

# In[7]:


b


# a ist jetzt neu

# In[9]:


id(a), id(b)


# ## Kopieren II (Wiederholung)
# 
# Erzeuge Liste al

# In[16]:


al = [1, 2, [3, 4]]


# bl wird al zugewiesen

# In[17]:


bl = al


# Jetzt verändern wir in bl die 3 in der Unterliste [3, 4] und die 2.

# In[24]:


bl[2][0] = "Hallo"
bl[1] = 22
bl


# Dadurch wurde auch al verändert, weil bl __keine__ Kopie von al ist, sondern ein Name für das gleiche Listenobjekt. 

# In[19]:


al


# Hier wird eine Kopie von al erstellt

# In[26]:


cl = al[:]
cl


# Jetzt ersetzen wir die 1 in al durch 42

# In[27]:


cl[0] = 42
cl


# Ist das ok?

# In[28]:


al


# Klappt das?

# In[29]:


cl[2][0] = 2018
cl


# Warum?

# In[24]:


al


# Hier brauchen wir deepcopy, eine tiefe Kopie, siehe Übungsaufgabe 5.

# ## Operationen auf Listen
# max, min, len, sorted, ...

# In[38]:


zahlen = [1, 2, 3, 1, 6, 5, 6]


# In[39]:


max(zahlen)


# In[40]:


min(zahlen)


# In[41]:


len(zahlen)


# In[42]:


sorted(zahlen)


# Listen bringen ihre eigenen Funktionen mit, z.B. append, remove und pop.

# In[ ]:


zahlen.


# In[30]:


zahlen.append(4)  # anfügen
zahlen


# In[31]:


zahlen.remove(6)  # entfernt den ersten Eintrag mit Wert 6
zahlen


# In[32]:


zahlen.pop(1)    # entfernt das Element mit Index 1 und gibt es zurück


# In[33]:


zahlen.pop(-1)   # entfernt das letzte Element und gibt es zurück


# In[34]:


zahlen


# ## Boolsche Variablen und Operationen
# 
# Eine boolesche Variable kann zwei Werte annehmen: 
# ```python
# True oder False
# ``` 
# 
# Boolesche Variablen werden verwendet, um Bedingungen zu überprüfen und innerhalb eines Programms zu entscheiden, wie es weitergeht.

# In[43]:


True


# In[44]:


False


# Die drei wichtigsten Operatoren sind 
# ```python
#     and (und)  or (oder)  und  not (nicht)
# ```

# "und" Verknüpfung 

# In[62]:


True and True


# In[63]:


True and False, False and True, False and False


# In[65]:


True & True  # bitweises und


# "oder" Verknüpfung

# In[66]:


True or False  # logisches oder


# In[67]:


True | False  # bitweises oder


# Verneinung (Negation)

# In[51]:


not True  # Negation


# ## Vergleiche

# In[56]:


2 <= 2


# In[59]:


2 < 2


# Gleichheit

# In[60]:


1 == 2


# In[61]:


1 + 1 == 2


# das geht nicht nur zwischen Zahlen

# In[ ]:


'a' == 'a'


# In[68]:


[1, 2] == [2, 3]


# ungleich

# In[69]:


1 != 2


# ## Verzweigungen, If Anweisungen
# 
# Bedingte Anweisungen (If-Anweisungen) dienen dazu, den Programmfluss zu verzweigen. Damit kann man, während das Programm ausgeführt wird, entscheiden, ob bestimmte Programmteile ausgeführt werden oder nicht.
# ```python
# if bedingung1:
#     anweisung1
# ```
# Ist <code>bedingung1</code> wahr wird <code>anweisung1</code> ausgeführt.

# ```python
# if bedingung1:
#     anweisung1
# else:
#     anweisung2
# ```
# Ist <code>bedingung1</code> wahr wird <code>anweisung1</code> ausgeführt, sonst <code>anweisung2</code>.

# ```python
# if bedingung1:
#     anweisung1
# elif bedingung2:
#     anweisung2
# ```
# Ist <code>bedingung1</code> wahr wird <code>anweisung1</code> ausgeführt. Ist <code>bedingung1</code> falsch aber <code>bedingung2</code> wahr wird <code>anweisung2</code> ausgeführt. <code>elif</code>s dürfen beliebig viele vorkommen und am Ende auch ein <code>else</code>.   

# In[85]:


import numpy as np
rng = np.random.default_rng() # Zufallszahlengenerator (random number generator)
c = rng.integers(1, 7) # integers(1,7) "würfelt" zufällig Zahl zwische 1 und 7 (exklusive) 
c


# In[122]:


c = rng.integers(1, 7)
print(f'c = {c} zu Anfang')

if c > 2:
    c = -c

print(f'c = {c} zu Ende')


# In[123]:


a = []
if not a:
    print('a ist eine leere Liste')


# Eine leere Liste hat den Wahrheitswert `False`

# ## Formatierte Strings
# 
# Formatierte Strings (f-Strings) sind die einfachste und schnellste Methode, um Variablen und Ausdrücke direkt in einen Text einzubauen.
# 
# Um einen f-String zu erstellen, setzt schreibt man den Buchstaben f oder F direkt vor die Anführungszeichen des Strings. Variablen oder Ausdrücke, die in den Text eingefügen werden sollen, schreibt man in geschweifte Klammern {}.

# In[184]:


name = "Anna"
alter = 25

# Ein normaler f-String
text = f"Hallo, ich heiße {name} und bin {alter} Jahre alt."
print(text)


# In[190]:


x = 10
y = 25

print(f" x + y = {x+y}")


# ## Funktionen
# 
# Funktionen fassen Programmteile zusammen, um Code übersichtlicher und weniger fehleranfällig zu machen.
# Ein Kernmerkmal ist die Rückgabe von Werten an das aufrufende Programm über die <code>return</code>-Anweisung. Sobald diese erreicht wird, verlässt das Programm die Funktion und liefert das nachfolgende Objekt zurück. Fehlt eine <code>return</code>-Anweisung, wird automatisch <code>None</code> zurückgegeben.
# ```python
# def funktionsname(parameter):
#     anweisungen
# ```
# ```python
# def funktionsname(parameter):
#     etwas = wird berechnet
#     return etwas
# ```
# In Python beginnen Funktionen mit dem Schlüsselwort <code>def</code>, gefolgt vom Funktionsnamen und optionalen Parametern in Klammern. Ein Doppelpunkt schließt die Zeile ab; alle folgenden Anweisungen werden eingerückt.
# 

# In[153]:


def mypar(x):
    return x**2 + x + 1


# In[154]:


mypar(2)


# In[155]:


def myparn(x):
    erg = x**2 + x + n
    return erg


# In[156]:


n = 1/2
myparn(2)


# besser

# In[167]:


def myparn(x, n=1/2):
    """ Berechnet x**2 + x + n. Falls n nicht gegeben ist, wird x**2 + x + 1/2 berechnet """
    erg = x**2 + x + n
    return erg


# In[166]:


get_ipython().run_line_magic('pinfo', 'myparn')


# In[170]:


ydefault, y = myparn(2), myparn(2, 3)
ydefault, y


# Achtung !

# In[175]:


def f(a, L=[]):
    print(f'Liste in der Funktion {L}')
    L.append(a)
    return L


# In[176]:


L = 23
f(1)


# In[ ]:


print(f'L ausserhalb {L}')


# In[ ]:


f([1, 2])


# In[ ]:


f([1, 2, 3])


# In[182]:


def f(a, L=[]):
    print(f'Liste in der Funktion {L}')
    L.append(a)
    return L


# In[183]:


# Der default Wert wird nur einmal ausgewertet und L ist hier veränderlich
print(f'Rückgabe f(1) = {f(1)}')
print(f'Rückgabe f(2) = {f(2)}')
print(f'Rückgabe f(3) = {f(3)}')
print(f'Rückgabe f(4,[1,2,3]) = {f(4,[1,2,3])}')


# Besser initialisiert man mit `None` statt mit einem veränderlichen Objekt wie einer leeren Liste.
# 

# In[ ]:


def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L


# In[ ]:


print(f(1))
print(f(2))
print(f(3))
print(f(4, [2, 3, 1]))


# ## Rekursionen
# ### erstes Beispiel
# Rekursive Funktionen sind Funktionen, die sich selbst aufrufen. Ein einfaches Beispiel ist die Fakultätsfunktion
# 
# $$𝑛!=𝑛(𝑛−1)! \quad \mbox{und} \quad  0! =1$$

# In[206]:


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


# In[207]:


factorial(4)


# Rekursive Funktionen bestehen aus einer Rekursionsbasis, 
# d.h. einer Beschreibung des kleinsten Falls ( $0!=1$ ), 
# und einem rekursivem Aufruf 
# 
# $$𝑛!=𝑛 \cdot (𝑛−1)!$$

# In[208]:


def factorial(n):
    print(n)
    if n == 0:
        print(f'Basis {n}')
        return 1
    print(f'berechne {n} * {n-1}!')
    return n * factorial(n - 1)


# In[205]:


factorial(4)


# In[210]:


def fakultaet(n):
    return 1 if n==0 else n*factorial(n-1)
fakultaet(5)


# ### zweites Beispiel
# 
# Berechne rekursiv die Summe der Einträge einer Liste. (Das kann <code>sum</code> eigentlich schon.)
# 
# - Basisfall: $\sum_{j=0}^{-1} a_j = 0$
# 
# - Für nichtnegative ganze Zahlen $n$ ist $$\sum_{j=0}^{n}  a_j = a_n + \sum_{j=0}^{n-1} a_j$$

# In[220]:


def rek_sum(seq):
    if not seq:
        return 0
    elem = seq.pop()
    assert isinstance(
        elem, (int, float, complex)
    ), f'Die Liste darf nur Zahlen enthalten aber {elem} ist {type(elem)}'
    return elem + rek_sum(seq)


# In[221]:


seq1 = [1, 2., 1j]
rek_sum(seq1), sum(seq1)


# In[222]:


seq1 = [1, 2., 1j]
seq2 = seq1.copy()
rek_sum(seq1), sum(seq2)


# Eingabeüberprüfung
# ```python 
#     assert Bedingung, Fehlermeldung
# ``` 
# Wirft einen Fehler, einen sogenannten <code>AssertionError</code>, falls Bedingung nicht erfüllt ist.

# In[223]:


seq2 = ['a', 1, 2]
rek_sum(seq2)


# In[227]:


seq2 = ['a', 1, 2]
sum(seq2)

