A *args és **kwargs paraméterek használata a kódban: Python 3 útmutató

Pranay Kapgate2022-02-14 · 10 min read

A *args és **kwargs paraméterek használata a kódban: Python 3 útmutató

Bevezetés

Python az egyik legnépszerűbb programozási nyelv világszerte. A Pythonban a paraméterek a függvénydefiníciók részét képezik. Lehetővé teszik, hogy meghatározott argumentumokat adj meg egy függvényhez. Az argumentumot a függvény képes fogadni és alkalmazni.

A kódolás idején azonban nem tudhatod, hogy pontosan milyen használati esetek fognak megvalósulni a kódoddal. Ezért a jövőbeli programozók és a programod felhasználói érdekében célszerű változó számú argumentumot átadni egy függvénynek. Ehhez speciális paramétereket kell használnod. Ezek a következők: *args és **kwargs. Ebben az útmutatóban mindent megtanulunk a *args és **kwargs paraméterekről Pythonban. Azt is megtanuljuk, hogyan rendezzük az argumentumokat, és hogyan alkalmazzuk őket függvényhívásokban.

Előfeltételek

Ahhoz, hogy követni tudd az útmutató lépéseit, elő kell készítened néhány dolgot. Először is, rendelkezned kell egy szerverre telepített Python 3-mal és egy működő programozási környezettel. Szükséged van továbbá az adott operációs rendszeredhez tartozó program telepítésére is (Ubuntu, CentOS, Debian stb.).

Mi az az *args és hogyan működik?

Kezdjük azzal, hogy megértjük, hogyan működik az *args paraméter. A paraméter egycsillagos verziója arra szolgál, hogy kulcsszó nélküli, változó hosszúságú argumentumlistákat küldjünk a függvényeknek. Tartsd szem előtt, hogy a csillag a legfontosabb elem ebben a paraméterben.

A jobb megértés érdekében vegyünk egy példát. Az alábbi egy tipikus függvény, amelyet a kódodban találhatsz, két argumentumot használva:

def multiply(x, y):
  print (x * y)

1 2	def multiply(x, y): print (x * y)

Mint látható, a fenti függvényben az argumentumaink a következők: x és y. A függvény hívásakor az x és y értékeknek megfelelő számokat fogod használni. Tegyük fel, hogy az 5 és 4 egészeket adjuk át az x és y változóknak rendre:

def multiply(x, y):
  print (x * y)

multiply(5, 4)

def multiply(x, y):

print (x * y)

multiply(5, 4)

Most már futtathatjuk a kódot:

python lets_multiply.py

1	python lets_multiply.py

A kapott kimenet a következő lesz:

Kimenet:

20

Output:

A kimenet azt mutatja, hogy az 5 és 4 egészek összeszorzásra kerültek. Ez azt jelenti, hogy a multiply(x, y) függvény működött.

Most tegyük fel, hogy végül három számot szeretnénk megszorozni kettő helyett. Sajnos, ha egy extra számot adunk a fenti függvényhez, az ilyen hibát fog eredményezni:

def multiply(x, y):
  print (x * y)

multiply(5, 4, 3)

def multiply(x, y):

print (x * y)

multiply(5, 4, 3)

Output:

TypeError: multiply() takes 2 positional arguments but 3 were given

Output:

TypeError: multiply() takes 2 positional arguments but 3 were given

Ezért, ha van elképzelésed arról, hogy később esetleg további argumentumokat kell hozzáadnod, akkor a kényelem érdekében alkalmazd az *args paramétert. Így használhatod:

def multiply(*args):
  z = 1
  for num in args:
    z *= num
  print(z)

multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)

def multiply(*args):

z = 1

for num in args:

z *= num

print(z)

multiply(4, 5)

multiply(10, 9)

multiply(2, 3, 4)

multiply(3, 5, 10, 6)

Egyszerűen lecseréltük az x és y függvényparamétereket az *args paraméterrel. Ennek a kódnak a futtatása megadja a szorzatot minden egyes függvényhívásra, így:

Kimenet:

20
90
24
900

Output:

900

Így az *args használata ideális, ha változó hosszúságú argumentumlistákat szeretnél küldeni a függvényednek. Képességének köszönhetően tetszőleges számú argumentumot adhatsz át a függvényhívásoknak. Ez a paraméter lehetővé teszi, hogy rugalmasabb kódot építs, amely nagy mennyiségű változó, kulcsszó nélküli argumentumot képes fogadni a függvényben.

Mi az a **kwargs és hogyan működik?

Következőként a paraméterek kétcsillagos verziója következik, ami a **kwargs. Az előző formával ellentétben ez a paraméter lehetővé teszi kulcsszavas, változó hosszúságú argumentumszótárak átadását a függvénynek. Hasonlóan az *args, a dupla csillag a paraméter legfontosabb eleme.

Ahogy az előző részben is tettük, tetszőleges számú argumentumot adhat hozzá. A különbség az, hogy kulcsszavakat kell hozzárendelnie. A jobb megértés érdekében vegye figyelembe a következő példát. Itt azzal kezdjük, hogy kiíratjuk a **kwargs argumentumokat, amelyeket át akarunk adni a függvénynek:

def print_kwargs(**kwargs):
  print(kwargs)

1 2	def print_kwargs(**kwargs): print(kwargs)

Most pedig hívjuk meg a függvényt. Mint látható, kulcsszavas argumentumokat adtunk hozzá:

def print_kwargs(**kwargs):
 print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

def print_kwargs(**kwargs):

print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

A program futtatása ezen a ponton ezt a kimenetet fogja mutatni:

python print_kwargs.py

1	python print_kwargs.py

Kimenet:

{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Kimenet:

{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Azonban fennáll a lehetősége annak, hogy a szótár adattípusa rendezetlen. Ez nagymértékben függ a használt Python 3 verziótól. Például a Python 3.6 utáni verziók sorrendben adják vissza a kulcs-érték párokat. Az ezt megelőző verziók véletlenszerű sorrendben jelenítik meg a kimenetet. Az Ön által létrehozott szótár neve kwargs lesz. Vegye figyelembe, hogy ezt ugyanúgy használhatja és módosíthatja, mint bármely más szótárat a rendszerben. Lássuk, hogyan tudja a **kwargs paramétert még jobban kihasználni és alkalmazni.

A következő példában megpróbálunk létrehozni egy új függvényt, amely nevek szótárát fogadja. A mintaszótárunk két nevet fog tartalmazni:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("The value of {} is {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

def print_values(**kwargs):

for key, value in kwargs.items():

print("The value of {} is {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

A program futtatása ezt a kimenetet fogja eredményezni:

python print_values.py

1	python print_values.py

Kimenet:

The value of your_name is Casey
The value of my_name is Sammy

Kimenet:

The value of your_name is Casey

The value of my_name is Sammy

Az előző példához hasonlóan a szótárak itt is tűnhetnek rendezetlennek. Emiatt a Casey és Sammy nevek sorrendje bizonyos esetekben felcserélődhet.

Ezután további argumentumokat adunk át a függvénynek. Ez be fogja bizonyítani, hogy a **kwargs paramétert tetszőleges számú argumentum fogadására is képessé teheti:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("The value of {} is {}".format(key, value))

print_values(
name_1="Alex",
name_2="Gray",
name_3="Harper",
name_4="Phoenix",
name_5="Remy",
name_6="Val")

def print_values(**kwargs):

for key, value in kwargs.items():

print("The value of {} is {}".format(key, value))

print_values(

name_1="Alex",

name_2="Gray",

name_3="Harper",

name_4="Phoenix",

name_5="Remy",

name_6="Val")

A program futtatása ezt a kimenetet fogja mutatni:

Kimenet:

The value of name_2 is Gray
The value of name_6 is Val
The value of name_4 is Phoenix
The value of name_5 is Remy
The value of name_3 is Harper
The value of name_1 is Alex

Kimenet:

The value of name_2 is Gray

The value of name_6 is Val

The value of name_4 is Phoenix

The value of name_5 is Remy

The value of name_3 is Harper

The value of name_1 is Alex

Ez a kimenet is lehet rendezetlen. Ettől függetlenül ezek a példák azt mutatják, hogy a **kwargs rugalmasságot biztosít a programjának számos kulcsszavas argumentum használatához.

Hogyan rendezzük az argumentumokat

Fontos észben tartani a meghatározott sorrendet, amikor argumentumokat rendezünk egy függvényben vagy függvényhívásban. Ez a következő:

Formális pozicionális argumentumok
*args
Kulcsszavas argumentumok
**kwargs

Tegyük fel, hogy az *args és **kwargs paramétereket használja explicit pozicionális paraméterekkel. Ez azt jelenti, hogy a függvénye így fog kinézni:

def example(arg_1, arg_2, *args, **kwargs):
...

1 2	def example(arg_1, arg_2, args, *kwargs): ...

Másrészt, ha ezeket a paramétereket nevesített kulcsszó-paraméterekkel használja, a függvénye a következő általános struktúrát fogja kapni:

def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...

1 2	def example2(arg_1, arg_2, args, kw_1="shark", kw_2="blobfish", *kwargs): ...

A meghatározott sorrend be nem tartása szintaktikai hibát eredményez a kód futtatásakor. Ezért a legjobb, ha eleve elkerüli ezt a hibát.

Hogyan használjuk az *args és **kwargs paramétereket függvényhívásokban

Végezetül megmutatjuk, hogyan használhatja mindkét paramétert argumentumok átadására függvényeknek. Egy olyan példával kezdjük, amely bemutatja a *args:

def some_args(arg_1, arg_2, arg_3):
  print("arg_1:", arg_1)
  print("arg_2:", arg_2)
  print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")

some_args(*args)

def some_args(arg_1, arg_2, arg_3):

print("arg_1:", arg_1)

print("arg_2:", arg_2)

print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")

some_args(*args)

Ebben a függvényben három paraméter található: arg_1, arg_2, és arg_3. Létre kell hoznia egy változót, és be kell állítania egy iterálható objektumra. Ebben az esetben ez egy tuple lesz. Ezután a változót a csillag szintaxis használatával adhatja át a függvénynek.

Figyelje meg a kimenetet, amikor a programot a következő paranccsal futtatja: python some_args.py parancs:

Output:

arg_1: Sammy
arg_2: Casey
arg_3: Alex

Kimenet:

arg_1: Sammy

arg_2: Casey

arg_3: Alex

A programot át lehet alakítani úgy is, hogy egy iterálható lista adattípust használjon egy másik változónévvel. A következő kód kombinálja a *args paramétert egy nevesített paraméterrel:

def some_args(arg_1, arg_2, arg_3):
  print("arg_1:", arg_1)
  print("arg_2:", arg_2)
  print("arg_3:", arg_3)

my_list = [2, 3]

some_args(1, *my_list)

def some_args(arg_1, arg_2, arg_3):

print("arg_1:", arg_1)

print("arg_2:", arg_2)

print("arg_3:", arg_3)

my_list = [2, 3]

some_args(1, *my_list)

A program futtatásakor a kimenet a következő lesz:

Output:

arg_1: 1
arg_2: 2
arg_3: 3

Kimenet:

arg_1: 1

arg_2: 2

arg_3: 3

Másrészt kulcsszavas argumentumokat is alkalmazhat a **kwargs használatával. Ügyeljen arra, hogy egy olyan változót hozzon létre, amely egy szótárral egyenlő. Ennek 2 kulcs-érték párral kell rendelkeznie. Így adjuk át a változót egy 3 argumentummal rendelkező függvénynek:

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
  print("kwarg_1:", kwarg_1)
  print("kwarg_2:", kwarg_2)
  print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}

some_kwargs(**kwargs)

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):

print("kwarg_1:", kwarg_1)

print("kwarg_2:", kwarg_2)

print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}

some_kwargs(**kwargs)

Használja ismét a python some_kwargs.py parancsot a program futtatásához:

Output:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Kimenet:

kwarg_1: Val

kwarg_2: Harper

kwarg_3: Remy

Összegzés

Az útmutató végére már tisztában kell lennie azzal, hogy mik azok az *args és **kwargs paraméterek, és hogyan működnek. Most már alkalmazhatja ezeket a paramétereket a saját kódjában, hogy programját rugalmassá tegye a jövőbeli felhasználók számára. Ezek ideálisak olyan helyzetekben, amikor nem tudja előre, hány argumentumot fognak használni. Csak ügyeljen arra, hogy óvatos legyen a függvények és paraméterek kritikus elemeivel.

Végezetül, íme további források a blogunkról, amelyek segítenek a sikeres munkában a Pythonnal:

Kellemes programozást!

Pranay Kapgate

Szerző · CloudSigma

Preslav Dobrev a CloudSigma kreatív tervezője, aki hagyományos és innovatív marketingcsatornák segítségével következetes vállalati identitás kialakítására összpontosít. Kiemelkedően képes ötvözni a művészi látásmódot a stratégiai marketinggel, hogy hatásos márkatörténeteket hozzon létre.

A *args és **kwargs paraméterek használata a kódban: Python 3 útmutató

Bevezetés

Előfeltételek

Mi az az *args és hogyan működik?

Mi az a **kwargs és hogyan működik?

Hogyan rendezzük az argumentumokat

Hogyan használjuk az *args és **kwargs paramétereket függvényhívásokban

Összegzés

Pranay Kapgate

Hozzászólások