Függvényparaméterek.

A 7. modulban a paraméterek egyszerű, pozicionális formáját használtuk: a hívás argumentumai sorrendben kerülnek a paraméterekbe – az első az elsőbe, a második a másodikba –, és pontosan annyi argumentum kell, ahány paraméter van. Ebben a modulban ezt rugalmasabbá tesszük:

Ezeket valójában már használtad: a print("a", "b", sep=", ") tetszőleges számú értéket fogad (*args), a sep pedig egy alapértelmezett értékkel rendelkező, név szerint megadott paraméter. A sorted(lista, reverse=True) ugyanígy.

Ha a paraméter neve után = jellel egy értéket írunk, az lesz az alapértéke: ha a hívás nem ad neki argumentumot, ezt kapja. Így a ritkán változó beállításokat nem kell minden hívásnál megadni.

def koszont(nev, udvozles="Szia"):
    return f"{udvozles}, {nev}!"

print(koszont("Anna"))
print(koszont("Béla", "Jó reggelt"))

def brutto(netto, afa=0.27):
    return round(netto * (1 + afa))

print(brutto(1000), brutto(1000, 0.05))

def koszont(udvozles="Szia", nev):
    return f"{udvozles}, {nev}!"

def hozzaad(elem, lista=[]):
    lista.append(elem)
    return lista

print(hozzaad("alma"))
print(hozzaad("körte"))

def hozzaad(elem, lista=None):
    if lista is None:
        lista = []
    lista.append(elem)
    return lista

print(hozzaad("alma"))
print(hozzaad("körte"))

Híváskor az argumentum elé írhatjuk a paraméter nevét: f(nev="Anna"). Ilyenkor a párosítás a név alapján történik, a sorrend nem számít. Két előnye van: a hívás olvashatóbb (szamla(1000, afa=0.05) elárulja, mi a 0.05), és a középső alapértékes paramétereket át lehet ugrani.

def beir(tanulo, targy, jegy=5, felev=False):
    tipus = "félévi" if felev else "évközi"
    return f"{tanulo} – {targy}: {jegy} ({tipus})"

print(beir("Anna", "matek"))
print(beir("Anna", "matek", 4))
print(beir("Bence", "fizika", felev=True))
print(beir(targy="kémia", tanulo="Csilla", jegy=3))

def f(a, b=2, c=3):
    return a * 100 + b * 10 + c

print(f(1, c=9))

Ha egy paraméter neve elé csillagot írunk, az összegyűjti az összes „fölös” pozicionális argumentumot egy tuple-be. Így a függvény akárhány értéket fogadhat – akár nullát is. A név bármi lehet (*szamok, *nevek); az args csak megszokott elnevezés.

def atlag(*szamok):
    print("A szamok tuple:", szamok)
    if len(szamok) == 0:
        return None
    return sum(szamok) / len(szamok)

print(atlag(4, 5, 3))
print(atlag(2, 4))
print(atlag())

A lépésenkénti nézetben a szamok paraméter egy tuple-re mutat, benne a hívás összes argumentumával. Előtte állhatnak „rendes” paraméterek is: def kiir(cim, *sorok): – az első argumentum a cim-be, a többi a sorok-ba kerül.

def kiir(cim, *sorok):
    print(cim.upper())
    for i, sor in enumerate(sorok, start=1):
        print(f"  {i}. {sor}")

kiir("Bevásárlás", "kenyér", "tej", "alma")
kiir("Üres lista")

Az enumerate(sorok, start=1) az elemek mellé sorszámot is ad: (1, "kenyér"), (2, "tej"), … – a ciklus fejében rögtön kicsomagoljuk.

A két csillagos paraméter a „fölös” név szerinti argumentumokat gyűjti össze egy szótárba: a kulcs a megadott név (szövegként), az érték az argumentum. Akkor hasznos, ha a függvény előre nem ismert beállításokat vagy adatmezőket fogad.

def adatlap(nev, **adatok):
    print(f"--- {nev} ---")
    for kulcs, ertek in adatok.items():
        print(f"{kulcs}: {ertek}")

adatlap("Anna", kor=17, varos="Pécs")
adatlap("Bence", szak="informatika", evfolyam=2, kollegista=True)

Példa: beállítások alapértékekkel

Gyakori minta, hogy a függvény egy alapbeállítás-szótárat a kapott **kwargs-szal frissít – így csak az eltérő beállításokat kell megadni:

def polo(**valasztas):
    beallitas = {"szin": "fehér", "meret": "M", "anyag": "pamut"}
    beallitas.update(valasztas)
    return beallitas

print(polo())
print(polo(szin="kék", meret="L"))
print(polo(anyag="len", zseb=True))

A csillag a hívás oldalán is használható, fordított értelemben: f(*lista) a lista elemeit külön argumentumokként adja át, f(**szotar) pedig a szótár párjait név szerinti argumentumokként.

def terfogat(a, b, c):
    return a * b * c

meretek = [2, 3, 4]
print(terfogat(*meretek))
print(*meretek)
print(*meretek, sep=" × ")

def koszont(nev, udvozles="Szia"):
    return f"{udvozles}, {nev}!"

adatok = {"nev": "Dóra", "udvozles": "Helló"}
print(koszont(**adatok))

def db(*elemek):
    return len(elemek)

lista = [1, 2, 3]
print(db(), db(lista), db(*lista))

A paraméterfajták kötött sorrendben állhatnak a fejlécben:

def f(kotelezo, alapertekes=1, *args, csak_nev_szerint=2, **kwargs):
    ...

A *args után álló paraméterek csak név szerint kaphatnak értéket – hiszen minden további pozicionális argumentumot az *args „elnyel”. Ha erre nem figyelünk, nehezen észrevehető hibát kapunk:

def rendezes(sorrend="növekvő", *szamok, **beallitasok):
    szamlista = list(szamok)
    if beallitasok.get("abszolut", False):
        szamlista.sort(key=abs)
    else:
        szamlista.sort()
    if sorrend == "csökkenő":
        szamlista.reverse()
    return szamlista

print(rendezes(5, 1, -3, 2))
print(rendezes("csökkenő", 5, 1, -3, 2))

Az első hívástól a [-3, 1, 2, 5] listát várnánk, a valódi eredmény viszont [-3, 1, 2]: az első argumentum (az 5) pozíció szerint a sorrend paraméterbe került, és kimaradt a rendezésből. Kövesd lépésenként, és nézd meg a hívás keretében a paraméterek értékét. A javítás: a sorrend kerüljön a *szamok mögé, így csak név szerint lehet megadni.

def rendezes(*szamok, sorrend="növekvő", **beallitasok):
    szamlista = list(szamok)
    if beallitasok.get("abszolut", False):
        szamlista.sort(key=abs)
    else:
        szamlista.sort()
    if sorrend == "csökkenő":
        szamlista.reverse()
    return szamlista

print(rendezes(5, 1, -3, 2))
print(rendezes(5, 1, -3, 2, sorrend="csökkenő"))
print(rendezes(5, 1, -3, 2, abszolut=True))

A sort(key=abs) az elemeket az abszolút értékük szerint rendezi: a key egy függvény, amelyet a rendezés minden elemre meghív, és az eredmények alapján sorol.