03 — Funkcje własne

# Schemat definicji
def nazwa_funkcji(parametr1, parametr2):
    """Opis funkcji (docstring) — opcjonalny."""
    # ciało funkcji
    wynik = parametr1 + parametr2
    return wynik

# Wywołanie
rezultat = nazwa_funkcji(3, 5)
print(rezultat)   # 8

# Funkcja bez parametrów i bez return
def przywitaj():
    print("Cześć!")

przywitaj()        # Cześć!
przywitaj()        # Cześć! — można wywołać wiele razy

# Parametry pozycyjne
def dodaj(a, b):
    return a + b

print(dodaj(3, 5))          # 8
print(dodaj(b=5, a=3))      # 8 — nazwane, kolejność nieważna

# Parametry z wartością domyślną
def przywitaj(imie, pozdrowienie="Cześć"):
    print(f"{pozdrowienie}, {imie}!")

przywitaj("Kasia")              # Cześć, Kasia!
przywitaj("Marek", "Hej")       # Hej, Marek!

# *args — dowolna liczba argumentów
def suma(*liczby):
    return sum(liczby)

print(suma(1, 2, 3))        # 6
print(suma(1, 2, 3, 4, 5))  # 15

# **kwargs — argumenty nazwane
def info(**dane):
    for klucz, wartosc in dane.items():
        print(f"{klucz}: {wartosc}")

info(imie="Kasia", wiek=17, miasto="Kraków")

# Funkcja z return
def kwadrat(x):
    return x ** 2

wynik = kwadrat(5)
print(wynik)            # 25
print(kwadrat(3) + 1)   # 10 — wynik od razu użyty

# Wiele return — warunki
def znak(x):
    if x > 0:
        return "dodatnia"
    elif x < 0:
        return "ujemna"
    else:
        return "zero"

print(znak(-5))         # ujemna
print(znak(0))          # zero

# Zwracanie wielu wartości
def min_max(lista):
    return min(lista), max(lista)

mini, maxi = min_max([3, 1, 7, 2, 9])
print(mini, maxi)       # 1 9

# Funkcja bez return → None
def nic_nie_zwraca():
    print("Działam!")

x = nic_nie_zwraca()    # Działam!
print(x)                # None

x = 10   # zmienna globalna

def pokaz():
    print(x)   # można CZYTAĆ globalną

pokaz()          # 10

def sprobuj_zmienic():
    x = 99     # to NOWA zmienna lokalna, nie globalna!
    print(x)   # 99

sprobuj_zmienic()
print(x)         # 10 — globalna niezmieniona

# Użycie global (niezalecane)
def zmien_global():
    global x
    x = 99

zmien_global()
print(x)         # 99 — teraz zmieniona

# Lepsze podejście: parametr + return
def dodaj_do(wartosc, ile):
    return wartosc + ile

x = 10
x = dodaj_do(x, 5)
print(x)         # 15

# Zwykła funkcja vs lambda
def kwadrat(x):
    return x ** 2

kwadrat_l = lambda x: x ** 2

print(kwadrat(5))    # 25
print(kwadrat_l(5))  # 25

# Lambda z wieloma parametrami
dodaj = lambda a, b: a + b
print(dodaj(3, 4))   # 7

# Lambda jako key w sorted
osoby = [("Kasia", 17), ("Marek", 15), ("Zofia", 19)]

wg_wieku = sorted(osoby, key=lambda osoba: osoba[1])
print(wg_wieku)
# [('Marek', 15), ('Kasia', 17), ('Zofia', 19)]

wg_imienia = sorted(osoby, key=lambda osoba: osoba[0])
print(wg_imienia)

# Lambda w filter i map
liczby = [1, 2, 3, 4, 5, 6]
parzyste = list(filter(lambda x: x % 2 == 0, liczby))
kwadraty = list(map(lambda x: x ** 2, liczby))
print(parzyste)   # [2, 4, 6]
print(kwadraty)   # [1, 4, 9, 16, 25, 36]

# Silnia: n! = n * (n-1)!  ;  0! = 1
def silnia(n):
    if n == 0:          # warunek bazowy
        return 1
    return n * silnia(n - 1)

print(silnia(5))        # 120
# 5 * 4 * 3 * 2 * 1 * 1

# Fibonacci: F(n) = F(n-1) + F(n-2)  ;  F(0)=0, F(1)=1
def fibonacci(n):
    if n <= 1:          # warunek bazowy
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(8):
    print(fibonacci(i), end=" ")
# 0 1 1 2 3 5 8 13

# NWD — algorytm Euklidesa
def nwd(a, b):
    if b == 0:          # warunek bazowy
        return a
    return nwd(b, a % b)

print(nwd(48, 18))      # 6
print(nwd(100, 75))     # 25