⚙️ Funkcijas

# Pamata funkcija
def sveiciens():
    print("Sveika, pasaule!")

sveiciens()   # Sveika, pasaule!

# Funkcija ar parametriem un atgriešanas vērtību
def saskaitīt(a, b):
    return a + b

rezultāts = saskaitīt(3, 5)
print(rezultāts)   # 8

# Noklusējuma parametri
def sveikt(vārds, sveiciens="Sveika"):
    return f"{sveiciens}, {vārds}!"

print(sveikt("Anna"))           # Sveika, Anna!
print(sveikt("Jānis", "Čau"))   # Čau, Jānis!

# Nosauktie argumenti (keyword arguments)
def profils(vārds, vecums, pilsēta):
    return f"{vārds}, {vecums} g., {pilsēta}"

# Var norādīt jebkādā kārtībā
print(profils(vecums=25, pilsēta="Rīga", vārds="Anna"))

# Atgriezt vairākas vērtības (kā tuple)
def sadalīt(skaitlis, dalītājs):
    quotient = skaitlis // dalītājs
    remainder = skaitlis % dalītājs
    return quotient, remainder   # Atgriež tuple

dalikums, atlikums = sadalīt(17, 5)
print(f"17 / 5 = {dalikums} atlikums {atlikums}")

# *args – mainīgs positional argumentu skaits
def summēt(*skaitļi):
    return sum(skaitļi)

print(summēt(1, 2, 3))         # 6
print(summēt(1, 2, 3, 4, 5))   # 15

# **kwargs – mainīgs keyword argumentu skaits
def konfigurēt(**iestatījumi):
    for atslēga, vērtība in iestatījumi.items():
        print(f"  {atslēga} = {vērtība}")

konfigurēt(krāsa="sarkana", izmērs=12, treknraksts=True)
# krāsa = sarkana
# izmērs = 12
# treknraksts = True

# Kombinēšana – kārtība: paramtri, *args, **kwargs
def pilna_funkcija(obligāts, *args, **kwargs):
    print(f"Obligāts: {obligāts}")
    print(f"Extra args: {args}")
    print(f"Extra kwargs: {kwargs}")

pilna_funkcija("A", "B", "C", x=1, y=2)
# Obligāts: A
# Extra args: ("B", "C")
# Extra kwargs: {"x": 1, "y": 2}

# Izsaiņošana pie izsaukšanas ar * un **
skaitļi = [1, 2, 3]
print(summēt(*skaitļi))    # Tas pats kā summēt(1, 2, 3)

params = {"krāsa": "zila", "izmērs": 10}
konfigurēt(**params)        # Tas pats kā konfigurēt(krāsa="zila", izmērs=10)

# Anonīma funkcija vienā rindā
# Sintakse: lambda argumenti: izteiksme

kvadrāts = lambda x: x ** 2
print(kvadrāts(5))   # 25

saskaitīt = lambda a, b: a + b
print(saskaitīt(3, 4))   # 7

# Galvenokārt izmanto kā argumentu citām funkcijām
skaitļi = [3, 1, 4, 1, 5, 9, 2, 6]

# sorted() un sort() ar key=
sakārtots = sorted(skaitļi)
print(sakārtots)   # [1, 1, 2, 3, 4, 5, 6, 9]

sakārtots_apgriezts = sorted(skaitļi, reverse=True)
print(sakārtots_apgriezts)   # [9, 6, 5, 4, 3, 2, 1, 1]

# Kārtot pēc absolūtās vērtības
negatīvi = [-5, 3, -1, 8, -2]
print(sorted(negatīvi, key=lambda x: abs(x)))   # [-1, -2, 3, -5, 8]

# Kārtot tuple sarakstu pēc otrā elementa
studenti = [("Anna", 9), ("Jānis", 7), ("Kārlis", 10)]
print(sorted(studenti, key=lambda s: s[1]))
# [("Jānis", 7), ("Anna", 9), ("Kārlis", 10)]

# map() un filter()
skaitļi = [1, 2, 3, 4, 5]

kvadrāti = list(map(lambda x: x**2, skaitļi))
print(kvadrāti)   # [1, 4, 9, 16, 25]

pāra = list(filter(lambda x: x % 2 == 0, skaitļi))
print(pāra)   # [2, 4]

# Slēgums – iekšējā funkcija "atceras" ārējās funkcijas mainīgos

def reizinātājs(n):
    def reizināt(x):
        return x * n   # n ir "aizslēgts" no ārpuses
    return reizināt   # Atgriežam funkciju (ne vērtību!)

divkārtot = reizinātājs(2)
trijkārtot = reizinātājs(3)

print(divkārtot(5))     # 10
print(trijkārtot(5))    # 15
print(divkārtot(10))    # 20

# Slēgums ar skaitītāju
def veidot_skaitītāju():
    n = 0
    def palielināt():
        nonlocal n   # nonlocal – ļauj modificēt ārējo mainīgo
        n += 1
        return n
    return palielināt

skaitītājs = veidot_skaitītāju()
print(skaitītājs())   # 1
print(skaitītājs())   # 2
print(skaitītājs())   # 3

cits = veidot_skaitītāju()
print(cits())   # 1 – jauns neatkarīgs stāvoklis

# Pamata dekorators
def logošana(funkcija):
    def obertne(*args, **kwargs):
        print(f"Izsauc: {funkcija.__name__}({args}, {kwargs})")
        rezultāts = funkcija(*args, **kwargs)
        print(f"Atgriež: {rezultāts}")
        return rezultāts
    return obertne

@logošana   # Ekvivalents: pievienot = logošana(pievienot)
def pievienot(a, b):
    return a + b

pievienot(3, 5)
# Izsauc: pievienot((3, 5), {})
# Atgriež: 8

# Laika mērīšanas dekorators
import time

def laika_mērs(funkcija):
    def obertne(*args, **kwargs):
        sākums = time.time()
        rezultāts = funkcija(*args, **kwargs)
        beigas = time.time()
        print(f"{funkcija.__name__}: {beigas - sākums:.4f}s")
        return rezultāts
    return obertne

@laika_mērs
def lēns_aprēķins(n):
    summa = 0
    for i in range(n):
        summa += i
    return summa

lēns_aprēķins(1000000)
# lēns_aprēķins: 0.0523s

# functools.wraps – saglabā oriģinālās funkcijas metadatus
from functools import wraps

def labāks_dekorators(funkcija):
    @wraps(funkcija)
    def obertne(*args, **kwargs):
        return funkcija(*args, **kwargs)
    return obertne