Woche 04 WS 2025

Woche 04 WS 2025#

Vorschau auf Runde 2

Funktionen#

def fibonacci(N):
    L = []
    [a, b] = [0, 1]
    while len(L) < N:
        a, b = b, a + b
        L.append(a)
    return L

fibonacci(5)

[1, 1, 2, 3, 5]

L

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[3], line 1
----> 1 L

NameError: name 'L' is not defined

L2 = [ "Willkommen" ]
def fibonacci_2(N):
    #print("INFO  90", L2)
    L2 = []
    print("INFO  100", L2)
    [a, b] = [0, 1]
    while len(L2) < N:
        a, b = b, a + b
        L2.append(a)
    print("INFO  200", L2)
    return L2

f = fibonacci_2(5)
f

INFO  100 []
INFO  200 [1, 1, 2, 3, 5]

[1, 1, 2, 3, 5]

L2

['Willkommen']

L2 = [ "Hallo" ]

fibonacci_2(5)

INFO  100 []
INFO  200 [1, 1, 2, 3, 5]

[1, 1, 2, 3, 5]

L2

['Hallo']

L3 = [ "eins", "zwei" ]

def test():
    L3.append("neunzig")
    print(L3)

test()

['eins', 'zwei', 'neunzig']

L4 = 1

def test():
    L4 = L4 + 1
    print(L4)
    

L4 = 1

def test():
    #L4 = L4 + 1
    print(L4)
    

test()

1

test()

1

test()

1

L5 = 99

def test():
    global L5
    L5 = L5 + 1
    print(L5)

test()

100

for x in range(0,7):
    zweix = 2 * x
    print(zweix)

0
2
4
6
8
10
12

zweix

12

pi = 3.1415

def mein_volumen(x,y,z, typ):
    if typ == "Würfel":
        return x*y*z
    elif typ == "Kugel":
        return 4/3 * pi * x**3

mein_volumen(1,1,1, "Kugel")

4.188666666666666

mein_volumen(2,2,2, "Würfel")

8

pi = 3.14
def mein_volumen(*, laenge, breite, hoehe, typ="Kugel"):
    if typ == "Würfel":
        return laenge * breite * hoehe
    elif typ == "Kugel":
        return 4/3 * pi * laenge**3

mein_volumen(laenge=3, breite=7, hoehe=5)

113.03999999999999

mein_volumen(

  Cell In[26], line 1
    mein_volumen(
                 ^
SyntaxError: incomplete input

import v

v.mein_volumen(1,1,1, "Kugel")

4.188666666666666

print( 2 * v.pi )

6.283

from v import mein_volumen

mein_volumen(1,1,1, "Kugel")

4.188666666666666

import random
print(random.__file__)

/home/dsci/miniconda3/lib/python3.12/random.py

Aufgabe: erzeugen Sie eine Liste von 2-Tupeln der Form:

n = 4
zweitupel = [ (1,2), (1,3), ..., (1,n), (2, 3), (2,4), ..., (2, n) ] 
zweitupel

[(1, 2), (1, 3), Ellipsis, (1, 4), (2, 3), (2, 4), Ellipsis, (2, 4)]

for außen in range(1,n+1):
    print( f"{außen=}")
    for innen in range( außen+1, n+1):
        print(außen, innen)

außen=1
1 2
1 3
1 4
außen=2
2 3
2 4
außen=3
3 4
außen=4

zweitupel = []

for außen in range(1,n+1):
    print( f"{außen=}")
    for innen in range( außen+1, n+1):      
        #print(außen, innen)
        zweitupel.append( (außen, innen)  )
zweitupel

außen=1
außen=2
außen=3
außen=4

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

Woche 04 WS 2024#

Funktionen definieren

"hallo" * 2

'hallohallo'

def doppelt(x):
    return x * 2

doppelt( "hallo" )

'hallohallo'

doppelt(2)

4

doppelt( [ 1,2,3] )

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

def multi(x):
    n = 3 # n ist lokal in der Funktion, äußeres n wird nicht geändert
    return x * n

multi("hallo")

'hallohallohallo'

n = 99

multi("hallo") # n ist lokal in der Funktion, äußeres n wird nicht geändert

'hallohallohallo'

n

99

positional argument#

def x_mal_y( x, y):
    return x * y

# wirft fehler
# x_mal_y( "Hallo", "Welt")

# wift fehler
# x_mal_y(3)

def x_mal_y( x, y=2): # default wert
    return x * y

x_mal_y(3)

6

def p_plus_q_r_s(p,q,r,s):
    return p + q

p_plus_q_r_s(1,2,3,4)

3

p_plus_q_r_s( s=4, p=1, q=2, r=3)

3

# wirft Fehler
# p_plus_q_r_s( s=4, p=1, q=2)

def x_mal_y_hoch_z(x, y, *, z=1, p=1, q=1, r=1):
    return (x*y)**z

x_mal_y_hoch_z(2, 3)

6

Rückgabewert None#

def a_minus_b(a,b):
    ergebnis = a - b
    if ergebnis != 0:
        return ergebnis
    else:
        return None

a_minus_b(5,3)

2

a_minus_b(5,5)

z = a_minus_b(5,5)
z

Wiederholung: mutables#

l1 = [ 1,2,3]
l2 = l1
l2

[1, 2, 3]

l1.append(99)
l2

[1, 2, 3, 99]

l1 = [1,2,3]

#l2 = l1     # Pointer auf das selbe Objekt

#l2 = l1[:]  # Slicing erzeugt Kopie
#l2 = l1 + [] # "+" erzeugt Kopie
l1.extend( [] )  ## JB : liefert None zurück

l1.append(99)
l2

[1, 2, 3, 99]

l789 = [ 7,8,9]
l789.extend([10,11,12])

l789

[7, 8, 9, 10, 11, 12]

l8 = [1,2,3]
l9 = l8 * 2

l8 *2

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

l9

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

l9 is l8 *2

False

def doppelt(xx):
    xx = 2* xx
    return xx

a = 42
doppelt(a)

84

a

42

## wirft fehler, weil undefiniert
# xx

l1 = [1, 2,3]
l2 = doppelt(l)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[74], line 2
      1 l1 = [1, 2,3]
----> 2 l2 = doppelt(l)

NameError: name 'l' is not defined

l

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[75], line 1
----> 1 l

NameError: name 'l' is not defined

l2

[1, 2, 3, 99]

def list_append_99(xxx):
    return xxx.append(99)

l = [1,2,3]
list_append_99(l)  # Pointer auf l

l

[1, 2, 3, 99]

l = [1,2,3]
list_append_99( l[:] ) # Kopie von l

l

[1, 2, 3]

Wiederholung: Dicts#

d = { "Otto Müller": "2020-01-01" }
d["Otto Müller"]

'2020-01-01'

d = { ("Otto", "Müller") : "2020-01-01" }
Contents