Függvényargumentumok ebben a kurzusban:

A(z) Függvényargumentumok fogalomról

A függvényargumentumok alapjairól lásd a függvény fogalmát.

Paraméternevek

A paraméterneveknek, akárcsak a változóneveknek, betűvel vagy aláhúzásjellel kell kezdődniük, és tartalmazhatnak betűket, aláhúzásjeleket vagy számokat. A paraméternevek nem tartalmazhatnak szóközt vagy írásjelet.

Pozicionális argumentumok

A pozicionális argumentumok olyan értékek, amelyeket a függvénynek ugyanabban a sorrendben adunk át, mint amilyen sorrendben a hozzájuk tartozó paraméterek következnek. A pozicionális argumentumokat a paraméternevük megadásával is átadhatjuk:

def concat(greeting, name):
    return f"{greeting}{name}"

# Passing data to the function by position.
print(concat("Hello, ", "Lilly"))
#->  Hello, Lilly

# Passing data to the function using the parameter name.
print(concat(name="Glenn", greeting="Hello, "))
#-> Hello, Glenn

A concat első meghívása pozíció szerint adja át az argumentumokat. A concat második meghívása név szerint adja át az argumentumokat, így a pozíciójuk is megváltoztatható.

Ne feledd, hogy a pozicionális argumentumok nem követhetnek név szerint átadott argumentumokat (más néven kulcsszó-argumentumok. Nem keverendők össze a var-pozicionális paraméterekkel vagy a **kwargs**).

Ez az argumentumkészlet:

print(concat(greeting="Hello, ", "Gregor"))

Ezt a hibát eredményezi:

SyntaxError: positional argument follows keyword argument

Ha azt szeretnénk, hogy egy függvény meghívásakor csak pozicionális argumentumokat lehessen használni, azt a paraméterlistában a / operátor segítségével érhetjük el:

# Parameters showing a position-only operator. 
def concat(greeting, name, /):
    return f"{greeting}{name}"

print(concat("Hello, ", "Ginnie"))
#-> Hello, Ginnie

# Call to the function using keyword arguments.
print(concat(name="Franklin", greeting="Hello, "))
Traceback (most recent call last):
    print(concat(name="Franklin", greeting="Hello, "))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting, name'

Kulcsszó-argumentumok

A kulcsszó-argumentumok a függvény meghívásakor a paraméter nevét használják. Opcionálisan pozíció szerint is megadhatók:

def concat(greeting, name):
    return f"{greeting}{name}"

# Function call using parameter names as argument keywords.
print(concat(name="Eliza", greeting="Hello, "))
#-> Hello, Eliza

# Function call with positional data as arguments.
print(concat("Hello, ", "Tim"))
#-> Hello, Tim

Ha azt szeretnénk, hogy egy függvény meghívásakor csak kulcsszó-argumentumokat lehessen használni, azt a paraméterlistában a * operátor segítségével érhetjük el:

# Function definition requiring keyword-only arguments.
def concat(*, greeting, name):
    return f"{greeting}{name}"

# Keyword arguments can be in an arbitrary order.
print(concat(name="Kimmie", greeting="Hello, "))
#-> Hello, Kimmie

# Calling the function with positional data raises an error.
print(concat("Hello, ", "Coleen"))
Traceback (most recent call last):
    print(concat("Hello, ", "Coleen"))
TypeError: concat() takes 0 positional arguments but 2 were given

Alapértelmezett argumentumértékek

Egy vagy több argumentum alapértelmezett értéke megadható a paraméterlistában. Ez lehetővé teszi, hogy szükség esetén kevesebb argumentummal hívjuk meg a függvényt. Az alapértelmezett értékek felülírhatók, ha a függvényt új argumentumértékkel hívjuk meg, felülírva ezzel az alapértéket:

# Function with default argument values.
def concat(greeting, name="you", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(concat("Hello"))
#-> Hello, you!

# Overriding the default values
print(concat("Hello", name="Polly", punctuation="."))
#-> Hello, Polly.

Pozicionális vagy kulcsszó-argumentumok

Egy argumentum lehet pozicionális vagy kulcsszó-argumentum, ha a paraméterdefiníciókban sem a /, sem a * operátort nem használjuk. Másik lehetőség, hogy a pozicionális vagy kulcsszó argumentumokat a bal oldali csak pozicionális paraméterek és a jobb oldali csak kulcsszó paraméterek közé helyezzük:

# Position-only argument followed by position-or-keyword, followed by keyword-only.
def concat(greeting, /, name, *, ending):
    return f"{greeting}{name}{ending}"

print(concat("Hello, ", "Mark", ending="!"))
#-> Hello, Mark!

print(concat("Hello, ", name="Rachel", ending="!"))
#-> Hello, Rachel!

print(concat(greeting="Hello, ", name="JoJo", ending="!"))
Traceback (most recent call last):
    print(concat(greeting="Hello, ", name="JoJo", ending="!"))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting'

*args

A kódpéldákban gyakran szerepel egy ehhez hasonló függvénydefiníció:

def my_function(*args, **kwargs):
    # code snipped

*args egy kétrészes név, amely egy tuple-t jelöl benne határozatlan számú különálló pozicionális argumentummal, más néven variadic argument. args a tuple-nek adott név, de bármilyen más érvényes Python-név is lehet, például my_args, arguments, stb. A * az az operátor, amely a különálló argumentumok csoportjából tuple-t csinál.

Mivel egy tuple bejárható, az args átadható bármely más függvénynek, amely iterálható értéket vár. Bár a *args gyakran a **kwargs mellett szerepel, ez nem kötelező:

def add(*args):
    # args is passed to the sum function, which iterates over it.
    return sum(args)

print(add(1, 2, 3))
#-> 6

Ha a *args egy vagy több pozicionális argumentum után következik, akkor a *args az lesz, ami a pozicionális argumentumok után megmarad:

def add(first, *args):
    # first will be 1, leaving the values 2 and 3 in *args
    return first + sum(args)

print(add(1, 2, 3))
#-> 6

Ha egy vagy több alapértelmezett argumentum van definiálva a *args után, azok elkülönülnek a *args értékeitől:

def add(first, *args, last=0):
    return first + sum(args) + last
 
print(add(1, 2, 3))
#-> 6

print(add(1, 2, 3, last=4))
#-> 10

# This uses the unpacking operator * to separate the list elements into positional arguments.
# It does not have the same behavior as the * (packing) in *args.
print(add(*[1, 2, 3]))
#-> 6

Vedd figyelembe, hogy amikor egy argumentum már egy iterable belsejében van (például egy tuple vagy list), ki kell csomagolni, mielőtt átadnánk egy olyan függvénynek, amely tetszőleges számú különálló argumentumot fogad. Ezt a * használatával érjük el, amely a kicsomagoló operátor.

A * ebben a helyzetben kicsomagolja a tárolót különálló elemeire, amelyekből aztán a *args egy tuple-t készít. Ahol csak pozicionális argumentumok vannak, a kicsomagolásnak ugyanannyi argumentumot kell eredményeznie, mint ahány formális paraméter definiálva van.

Ha nem csomagoljuk ki az add-nak átadott listát, a program hibát jelezne:

def add(first, *args, last=0):
    return first + sum(args) + last

print(add([1, 2, 3]))
Traceback (most recent call last):
    print(add([1, 2, 3]))
    return first + sum(args) + last
TypeError: can only concatenate list (not "int") to list

**kwargs

**kwargs egy kétrészes név, amely határozatlan számú különálló kulcs-érték pár argumentumot jelöl. A kwargs az argumentumok csoportjának a neve, és bármilyen más név is lehet, például my_args, arguments, stb. A ** a megnevezett argumentumok csoportját {argument name: argument value} párokból álló dictionary-ba alakítja.

Mivel egy szótár bejárható, a kwargs átadható bármely más függvénynek, amely iterálható értéket vár. Bár a **kwargs gyakran a *args mellett szerepel, ez nem kötelező:

def add(**kwargs):
    return sum(kwargs.values())

print(add(one=1, two=2, three=3))
#-> 6

Vedd figyelembe, hogy a dict.values() metódust azért hívjuk meg, hogy végigiteráljunk a kwargs szótár values értékein. Amikor egy szótáron iterálunk, alapértelmezés szerint a keys elemein iterálunk, ezért a dict.values()-t explicit módon meg kell adni:

def concat(**kwargs):
    # Join concatenates the tuples from `kwargs.items()`
    return " ".join((str(item) for item in kwargs.items()))

print(concat(one=1, two=2, three=3))
#-> ('one', 1) ('two', 2) ('three', 3)