Używanie parametrów *args i **kwargs w swoim kodzie: samouczek Pythona 3

Pranay Kapgate2022-02-14 · 10 min read

Używanie parametrów *args i **kwargs w swoim kodzie: samouczek Pythona 3

Wprowadzenie

Python jest jednym z najpopularniejszych języków programowania na świecie. W Pythonie parametry są częścią definicji funkcji. Umożliwiają one określenie określonych argumentów dla funkcji. Argument może zostać zaakceptowany i zastosowany przez funkcję.

Jednak w momencie pisania kodu nie jest możliwe przewidzenie, jakie dokładnie przypadki użycia mogą zostać zaimplementowane przy użyciu Twojego kodu. W związku z tym, ze względu na przyszłych programistów i użytkowników Twojego programu, zaleca się przekazywanie do funkcji zmiennej liczby argumentów. Aby to zrobić, musisz użyć specjalnych parametrów. Są to *args oraz **kwargs. W tym samouczku dowiemy się wszystkiego o parametrach *args i **kwargs w Pythonie. Dowiemy się również, jak porządkować argumenty i jak stosować je w wywołaniach funkcji.

Wymagania wstępne

Aby móc postępować zgodnie z krokami opisanymi w samouczku, musisz przygotować kilka rzeczy. Po pierwsze, musisz mieć zainstalowanego Pythona 3 na swoim serwerze wraz z działającym środowiskiem programistycznym. Musisz mieć również zainstalowany program dla swojego konkretnego systemu operacyjnego (Ubuntu, CentOS, Debian itp.).

Co to jest *args i jak to działa?

Zacznijmy od zrozumienia, jak działa *args . Wersja parametru z pojedynczą gwiazdką służy do przesyłania do funkcji list argumentów o zmiennej długości bez słów kluczowych. Pamiętaj, że gwiazdka jest najważniejszym elementem tego parametru.

Aby lepiej to zrozumieć, rozważmy przykład. Poniżej znajduje się typowa funkcja, którą możesz znaleźć w swoim kodzie, używająca dwóch argumentów:

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

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

Jak widać, naszymi argumentami w powyższej funkcji są x oraz y. Podczas wywoływania funkcji użyjesz liczb odpowiadających x oraz y. Załóżmy, że przekazujemy liczby całkowite 5 i 4 dla x and y odpowiednio:

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

multiply(5, 4)

def multiply(x, y):

print (x * y)

multiply(5, 4)

Teraz możemy uruchomić kod:

python lets_multiply.py

1	python lets_multiply.py

Otrzymany wynik będzie następujący:

Wynik:

20

Wynik:

Wynik pokazuje, że liczby całkowite 5 i 4 zostały pomnożone. Oznacza to, że funkcja multiply(x, y) zadziałała.

Załóżmy teraz, że chcemy ostatecznie pomnożyć trzy liczby zamiast tylko dwóch. Niestety, dodanie dodatkowej liczby do powyższej funkcji spowoduje błąd taki jak ten:

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

Wynik:

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

Dlatego, jeśli przypuszczasz, że w przyszłości może zajść potrzeba dodania kolejnych argumentów, zastosuj dla własnej wygody parametr *args. Możesz go użyć w następujący sposób:

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)

Po prostu zastąpiliśmy parametry funkcji x i y parametrem *args. Uruchomienie tego kodu da wynik mnożenia dla każdego wywołania funkcji w następujący sposób:

Wynik:

20
90
24
900

Wynik:

900

Z tego względu *args jest idealny do użycia, gdy chcesz przesłać do funkcji listy argumentów o zmiennej długości. Dzięki jego możliwościom możesz przekazać do wywołań funkcji tyle argumentów, ile chcesz. W związku z tym parametr ten pozwala na budowanie bardziej elastycznego kodu, który może przyjmować do funkcji znaczną liczbę zmiennych argumentów bez słów kluczowych.

Co to jest **kwargs i jak to działa?

Następnie mamy wersję parametrów z podwójną gwiazdką, czyli **kwargs. W przeciwieństwie do poprzedniej formy, ten parametr umożliwia przekazywanie do funkcji słowników argumentów o zmiennej długości z nazwanymi słowami kluczowymi. Podobnie jak *args, podwójne gwiazdki są najważniejszym elementem parametru.

Podobnie jak w poprzedniej sekcji, możesz dodać tyle argumentów, ile chcesz. Różnica polega na tym, że musisz przypisać słowa kluczowe. Aby lepiej to zrozumieć, rozważ następujący przykład. Tutaj zaczniemy od wypisania **kwargs argumentów, które chcemy przekazać do funkcji:

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

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

Teraz wywołajmy funkcję. Jak widać, dodaliśmy argumenty nazwane (słów kluczowych):

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)

Uruchomienie programu w tym momencie pokaże następujące dane wyjściowe:

python print_kwargs.py

1	python print_kwargs.py

Wynik:

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

Wynik:

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

Istnieje jednak możliwość, że Twój słownikowy typ danych jest nieuporządkowany. Zależy to w dużej mierze od używanej wersji Pythona 3. Na przykład każda wersja nowsza niż Python 3.6 zwraca pary klucz-wartość w kolejności. Każda wcześniejsza wersja pokaże wynik w losowej kolejności. Słownik, który utworzysz, będzie się nazywał kwargs. Pamiętaj, że możesz go używać i modyfikować jak każdego innego słownika w systemie. Zobaczmy, jak możesz lepiej wykorzystać i zastosować parametr **kwargs w praktyce.

W poniższym przykładzie spróbujemy stworzyć nową funkcję, która przywita słownik z imionami. Nasz przykładowy słownik będzie zawierał dwa imiona:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("Wartość dla {} to {}".format(key, value))

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

def print_values(**kwargs):

for key, value in kwargs.items():

print("Wartość dla {} to {}".format(key, value))

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

Uruchomienie programu da następujący wynik:

python print_values.py

1	python print_values.py

Wynik:

Wartość dla your_name to Casey
Wartość dla my_name to Sammy

Wynik:

Wartość dla of your_name to Casey

Wartość dla of my_name to Sammy

Podobnie jak w poprzednim przykładzie, słowniki mogą wydawać się nieuporządkowane. W związku z tym kolejność imion Casey i Sammy może być w niektórych przypadkach odwrócona.

Następnie przekażemy do funkcji dodatkowe argumenty. Udowodni to, że możesz sprawić, by **kwargs akceptował dowolną liczbę argumentów:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("Wartość dla {} to {}".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("Wartość dla {} to {}".format(key, value))

print_values(

name_1="Alex",

name_2="Gray",

name_3="Harper",

name_4="Phoenix",

name_5="Remy",

name_6="Val")

Uruchomienie programu pokaże następujący wynik:

Wynik:

Wartość dla name_2 to Gray
Wartość dla name_6 to Val
Wartość dla name_4 to Phoenix
Wartość dla name_5 to Remy
Wartość dla name_3 to Harper
Wartość dla name_1 to Alex

Wynik:

Wartość dla of name_2 to Gray

Wartość dla of name_6 to Val

Wartość dla of name_4 to Phoenix

Wartość dla of name_5 to Remy

Wartość dla of name_3 to Harper

Wartość dla of name_1 to Alex

Ten wynik również może być nieuporządkowany. Niezależnie od tego, przykłady te pokazują, że **kwargs daje Twojemu programowi elastyczność w używaniu wielu argumentów nazwanych.

Jak porządkować argumenty

Ważne jest, aby pamiętać o ustalonej kolejności podczas porządkowania argumentów w funkcji lub wywołaniu funkcji. Jest ona następująca:

Formalne argumenty pozycyjne
*args
Argumenty nazwane
**kwargs

Załóżmy, że używasz *args oraz **kwargs z jawnymi parametrami pozycyjnymi. Oznacza to, że Twoja funkcja będzie wyglądać tak:

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

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

Z drugiej strony, użycie tych parametrów z nazwanymi parametrami kluczowymi nada Twojej funkcji następującą ogólną strukturę:

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): ...

Niezastosowanie się do ustalonej kolejności spowoduje błąd składniowy podczas uruchamiania kodu. Dlatego najlepiej jest unikać popełniania tego błędu na samym początku.

Jak używać *args i **kwargs w wywołaniach funkcji

Na koniec pokażemy, jak używać obu tych parametrów do przekazywania argumentów do funkcji. Zaczniemy od przykładu pokazującego *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)

W tej funkcji znajdują się trzy parametry: arg_1, arg_2, oraz arg_3. Musisz utworzyć zmienną i przypisać jej obiekt iterowalny. W tym przypadku będzie to krotka. Następnie możesz przekazać tę zmienną do funkcji, używając składni z gwiazdką.

Zaobserwuj dane wyjściowe po uruchomieniu programu za pomocą polecenia python some_args.py :

Wynik:

arg_1: Sammy
arg_2: Casey
arg_3: Alex

Wynik:

arg_1: Sammy

arg_2: Casey

arg_3: Alex

Możliwe jest również zmodyfikowanie programu tak, aby używał iterowalnego typu danych listy z inną nazwą zmiennej. Poniższy kod łączy *args z parametrem nazwanym:

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)

Po uruchomieniu programu wynik będzie następujący:

Wynik:

arg_1: 1
arg_2: 2
arg_3: 3

Wynik:

arg_1: 1

arg_2: 2

arg_3: 3

Z drugiej strony, możesz zastosować argumenty nazwane za pomocą **kwargs. Upewnij się, że utworzysz zmienną, która jest słownikiem. Powinna mieć 2 pary klucz-wartość. Oto jak przekażemy tę zmienną do funkcji z 3 argumentami:

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)

Użyj ponownie polecenia python some_kwargs.py , aby uruchomić program:

Wynik:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Wynik:

kwarg_1: Val

kwarg_2: Harper

kwarg_3: Remy

Podsumowanie

Po ukończeniu tego samouczka powinieneś dobrze orientować się w tym, czym są *args oraz **kwargs i jak działają. Możesz teraz zastosować te parametry we własnym kodzie, aby uczynić swój program elastycznym dla przyszłych użytkowników. Są one idealne w sytuacjach, gdy nie wiesz, ile argumentów może zostać użytych. Pamiętaj tylko, aby uważać na kluczowe elementy funkcji i parametrów.

Na koniec, oto więcej zasobów z naszego bloga które pomogą Ci skutecznie pracować z językiem Python:

Miłego programowania!

Pranay Kapgate

Autor · CloudSigma

Preslav Dobrev jest projektantem kreatywnym w CloudSigma, skupiającym się na spójnej tożsamości biznesowej przy wykorzystaniu tradycyjnych i innowacyjnych kanałów marketingowych. Biegle łączy wizję artystyczną ze strategicznym marketingiem, tworząc wywierające wpływ narracje marki.

Używanie parametrów *args i **kwargs w swoim kodzie: samouczek Pythona 3

Wprowadzenie

Wymagania wstępne

Co to jest *args i jak to działa?

Co to jest **kwargs i jak to działa?

Jak porządkować argumenty

Jak używać *args i **kwargs w wywołaniach funkcji

Podsumowanie

Pranay Kapgate

Komentarze