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

# <h1>Table of Contents<span class="tocSkip"></span></h1>
# <div class="toc"><ul class="toc-item"><li><span><a href="#for-Schleifen" data-toc-modified-id="for-Schleifen-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>for-Schleifen</a></span><ul class="toc-item"><li><span><a href="#break-und-continue" data-toc-modified-id="break-und-continue-1.1"><span class="toc-item-num">1.1&nbsp;&nbsp;</span><strong>break</strong> und <strong>continue</strong></a></span></li><li><span><a href="#Nützliche-built-in-Funktionen" data-toc-modified-id="Nützliche-built-in-Funktionen-1.2"><span class="toc-item-num">1.2&nbsp;&nbsp;</span>Nützliche built-in Funktionen</a></span></li></ul></li><li><span><a href="#while-Schleife" data-toc-modified-id="while-Schleife-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>while Schleife</a></span></li><li><span><a href="#Comprehensions" data-toc-modified-id="Comprehensions-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Comprehensions</a></span><ul class="toc-item"><li><span><a href="#für-Listen-(list-comprehension)" data-toc-modified-id="für-Listen-(list-comprehension)-3.1"><span class="toc-item-num">3.1&nbsp;&nbsp;</span>für Listen (list comprehension)</a></span></li><li><span><a href="#für-Wörterbücher-(dictionary-comprehension)" data-toc-modified-id="für-Wörterbücher-(dictionary-comprehension)-3.2"><span class="toc-item-num">3.2&nbsp;&nbsp;</span>für Wörterbücher (dictionary comprehension)</a></span></li><li><span><a href="#für-Mengen-(set-comprehension)" data-toc-modified-id="für-Mengen-(set-comprehension)-3.3"><span class="toc-item-num">3.3&nbsp;&nbsp;</span>für Mengen (set comprehension)</a></span></li><li><span><a href="#für-Generatoren" data-toc-modified-id="für-Generatoren-3.4"><span class="toc-item-num">3.4&nbsp;&nbsp;</span>für Generatoren</a></span></li><li><span><a href="#geschachtelter-Aufruf" data-toc-modified-id="geschachtelter-Aufruf-3.5"><span class="toc-item-num">3.5&nbsp;&nbsp;</span>geschachtelter Aufruf</a></span></li></ul></li><li><span><a href="#Funktionen-mit-beliebig-vielen-Argumenten" data-toc-modified-id="Funktionen-mit-beliebig-vielen-Argumenten-4"><span class="toc-item-num">4&nbsp;&nbsp;</span>Funktionen mit beliebig vielen Argumenten</a></span><ul class="toc-item"><li><span><a href="#Packing-und-Unpacking-mit-*" data-toc-modified-id="Packing-und-Unpacking-mit-*-4.1"><span class="toc-item-num">4.1&nbsp;&nbsp;</span>Packing und Unpacking mit *</a></span></li></ul></li></ul></div>

# # Schleifen (loops)
# 
# Schleifen sind Strukturelemente, die ein wiederholtes Durchlaufen von Programmblöcken ermöglichen. Man unterscheidet zwischen <code>while</code>-Schleifen und <code>for</code>-Schleifen.
# 
# In der letzten Woche hatten wir gesehen, dass auch mit rekursiven Funktionsaufrufen ein wiederholtes Abarbeiten von Anweisungen möglich ist. Oft sind Schleifen aber naheliegender.

# ## for-Schleifen
# Der Aufbau einer for Schleife ist wie folgt, wobei das <code> else </code> optional ist
# ```python
#     for element in iterierbarers_objekt:
#         block von anweisungen
#     [else:]
#         block von anweisungen
# ```

# In[1]:


for i in [1, 2, 4]:
    print(i)


# In[2]:


for i in (1, 2, 3):
    print(i)


# Das geht einfacher mit dem Range Objekt (siehe Blatt 1). Damit erhält man alle ganzen Zahlen in einem Bereich.
# ```python 
# range([anfang],ende)
# ```
# Wird der optionale Anfangsindex <code>anfang</code> nicht angegeben, beginnt der Bereich bei 0. Der Endeindex <code>ende</code> ist wieder exklusiv.

# In[3]:


for i in range(1, 4):
    print(i)


# Auch Wörterbücher, Mengen und Zeichenketten sind iterierbar

# In[4]:


wb = {1: 'a', 2: 'b', (1, 2): 'a+b', 0: 'Null'}
# Iteration über die Schlüssel (keys)
for k in wb:
    print(f'Key {k=} \t Eintrag: {wb[k]}')


# In[5]:


menge =  {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
for element in menge:
    print(element)


# In[6]:


for zeichen in '+-+-':
    print(zeichen)


# <code>print</code> beendet jede Ausgabe mit einer neuer Zeile. Mit dem <code>end</code> Paramater kann man das Ende der Ausgabe festlegen.

# In[7]:


for zeichen in '+-+-':
    print(zeichen, end=',')


# ### __break__ und __continue__ 
# Mit <code>break</code> verlässt man eine Schleife vorzeitig, mit <code>continue</code> springt man zum Anfang und überspringt den Rest.

# In[8]:


for n in range(1, 10):
    if n % 4 == 0:
        print(f'{n=} teilbar durch 4:{n} = 4*{n//4}')
        break
    if n % 2 == 0:
        print(f'{n=} teilbar durch 2:{n} = 2*{n//2}')


# In[9]:


for n in range(1, 10):
    if n % 4 == 0:
        print(f'{n=} teilbar durch 4: {n} = 4*{n//4}')
        continue
    if n % 2 == 0:
        print(f'{n=} teilbar durch 2: {n} = 2*{n//2}')


# Das optionale <code>else</code> in einer for-Schleife wird selten verwendet. Es ist vermutlich nur nützlich, wenn man mit einem <code>break</code> eine Schleife abbricht.
# 
# Beispiel aus https://docs.python.org/3/tutorial/controlflow.html Abschnitt 4.5

# In[10]:


for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:  # x teilt n
            print(f'{n} ist {x} * {int(n/x)}')
            break


# In[11]:


for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:  # x teilt n
            print(f'{n} ist {x} * {int(n/x)}')
            break
    else:  # die Schleife  x in 2..n-1 wurde nicht abgebrochen oder die Schleife ist leer
        print(f'{n} ist prim')


# Es kommt etwas anderes raus, wenn wir das <code>else</code> ein- oder ausrücken

# In[12]:


for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:  # x teilt n
            print(f'{n} ist {x} * {int(n/x)}')
            break
        else:  # hier gehört das else zum if, also falls x kein Teiler von n ist
            print(f'{n} ist prim')


# ### Nützliche built-in Funktionen
# Built-in Funktionen, die das Programmieren mit <code>for</code>-Schleifen vereinfachen, sind
# <code>zip(), enumerate(), reversed(), sorted()</code>.
# 
# 
# <code>zip()</code> Reißverschluss: Verbindet Elemente aus mehreren Listen oder Iterables

# In[13]:


str1 = 'AEIOU'
lst1 = ['Affe', 'Esel', 'Igel', 'Otter', 'Uhu', 'Zebra']

for i, j in zip(str1, lst1):
    print(f'{i} wie {j}')


# <code>reversed()</code> dreht die Reihenfolge um. 

# In[14]:


for i in reversed(lst1):
    print(i)


# <code>enumerate()</code> zählt zusätzlich die durchiterierten Elemente ab

# In[15]:


for index, element in enumerate(lst1):
    print(index, element)


# In[16]:


for i, element in enumerate(lst1, start=1):  # fängt bei start zu zählen an
    print(i, element)


# In[17]:


list(enumerate(zip(str1, lst1)))


# ## while Schleife

# Der Aufbau einer <code>while</code>-Schleife ist wie folgt, wobei das <code>else</code> optional ist. Der Block anweisung1 wird ausgeführt solange <code>bedingung</code> ein Ausdruck ist, der __True__ ist.
# ```python
#     while bedingung:
#         anweisung1
#     [else]
#         anweisung2
# ```
# Wieder kann man mit <code>break</code>  die Schleife abbrechen, oder mit <code>continue</code> zum Anfang der Schleife springen. 

# In[18]:


a = 1
print(a)
while a <= 10:
    a = a + (a + 1)
    print(a)


# In[19]:


a = 1
print(a)
while True:
    if a > 10:
        break
    a = a + (a + 1)
    print(a)


# In[20]:


def arek(a):
    print(a)
    if a > 10:
        return a
    return arek(a + (a + 1))


a = arek(1)


# In[21]:


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 zwischen 1 und 7 (exklusive) 


# In[22]:


zaehler = 0
summe = 0
while summe < 100:
    summe += 1 + rng.integers(1, 7)  # += inplace plus (summe = summe + 1 + random integer in [1,6]
    zaehler += 1 # zaehler = zaehler + 1
print(f'Nach {zaehler} mal würfeln ist die Augensumme {summe}')


# ## Comprehensions
# ### für Listen (list comprehension)
# Statt

# In[23]:


a = []
for j in range(5):
    a.append(2 * j + 1)
a


# verwendet man auch die kompaktere Form

# In[24]:


aa = [2*j+1 for j in range(5)] 
aa


# ### für Wörterbücher (dictionary comprehension)

# In[25]:


{i: i**2 for i in range(5)}


# ### für Mengen (set comprehension)
# Die Menge der Quadratzahlen bis $4^2$ 
# 
# $\{i^2 : i \in \mathbb{N}_0 \land i < 5\}$

# In[26]:


{i**2 for i in range(5)}


# man kann dabei auch Bedingungen abfragen
# $\{i^2 : i \in \mathbb{N}_0 \land i < 5 \land ggT(i^2,2)=1\}$

# In[27]:


{i**2 for i in range(5) if (i**2) % 2 != 0}  # alle ungeraden Quadratzahlen bis 16


# In[28]:


from math import gcd #gcd greatest common divisor (deutsch ggT) 
{i**2 for i in range(5) if gcd(i**2,2)== 1}  # alle ungeraden Quadratzahlen bis 16


# ### für Generatoren 

# In[29]:


g = (i**2 for i in range(5)) # !!keine tuple comprehension!!


# In[30]:


g


# In[31]:


list(g)


# Generatoren brauchen weniger Speicher, da Sie faul (lazy) sind und das jeweils nächste Element erst berechnen, wenn es benötigt wird.

# ### geschachtelter Aufruf
# Primzahlen bis N

# In[32]:


N = 20
[n for n in range(2, N) if all((n % m > 0 for m in range(2, n)))]


# ## Funktionen mit beliebig vielen Argumenten
# 
# Ein Beispiel: Minimum

# In[33]:


def mymin(a, b):
    """ Berechnet das Minimum von zwei Argumenten"""
    if a < b:
        return a
    else:
        return b


# In[34]:


mymin(3.2, 2.1)


# ### Packing und Unpacking mit *
# 

# In[35]:


*b, = 1, 2, 3
b


# In[36]:


lst = list(range(5))
a, b, *c, = lst
c


# Der <code>*</code> hier wird als unpacking operator bezeichnet. Die rechte Seite (der Tupel (1,2,3) bzw. die Liste [0,1,2,3,4,5]) wird entpackt und in b bzw c gespeichert.

# In[37]:


def mymin(*eingabewerte):
    ''' Berechnet das betragsweise Minimum von beliebig vielen Argumenten
        mymin(1, -1, 1+j) 
        Output: 1
    '''
    #print(eingabewerte, type(eingabewerte))
    minimum = abs(eingabewerte[0])
    for a in eingabewerte:

        assert isinstance(
            a, (float, int, complex)), 'Eingabewerte müssen Zahlen sein'

        if abs(a) < minimum:
            minimum = abs(a)

    return minimum


# In[38]:


mymin(2, 2.1, 3, 1 + 2j)


# Der Stern <code>*</code> hier wird als packing operator bezeichnet, weil er die Argumente 2, 2.1, 3, 1 + 2j in das Tupel eingabewerte packt.

# In[39]:


liste = [2, 3, 4, 1]


# In[40]:


mymin(*liste) #unpacking


# In[41]:


mymin(liste)


# In[42]:


min(liste) 


# In[43]:


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


# In[44]:


min(*liste)

