*args în Python
În această lecție vei învăța cum folosești *args atunci când o funcție trebuie să poată primi un număr diferit de argumente poziționale la fiecare apel.
Problema parametrilor fixați
O funcție obișnuită primește un număr stabilit de argumente.
def aduna(a, b):
return a + b
print(aduna(10, 20)) Funcția poate primi exact două argumente. Un al treilea argument produce TypeError.
Ce este *args?
Scrierea *args permite unei funcții să primească oricâte argumente poziționale.
def afiseaza(*args):
print(args)
afiseaza("Python", "Java", "SQL") ('Python', 'Java', 'SQL') Toate argumentele sunt adunate automat într-un tuplu.
Semnul * este partea importantă
Numele args este doar o convenție.
def afiseaza(*valori):
print(valori) Și acest cod funcționează. Totuși, numele args este cel mai des întâlnit și este ușor de recunoscut.
*args devine un tuplu
def verifica(*args):
print(type(args))
verifica(10, 20) <class 'tuple'>
Apel fără argumente
def afiseaza(*args):
print(args)
afiseaza() ()
Dacă nu transmiți argumente, args este un tuplu gol.
Apel cu un singur argument
def afiseaza(*args):
print(args)
afiseaza("Python") ('Python',) Virgula arată că rezultatul este un tuplu cu un singur element.
Apel cu mai multe argumente
def afiseaza(*args):
print(args)
afiseaza("Python", "Java", "SQL", "Git") ('Python', 'Java', 'SQL', 'Git') Parcurgerea argumentelor
def afiseaza(*args):
for valoare in args:
print(valoare)
afiseaza("Python", "Java", "SQL") Python Java SQL
Calcularea unei sume
def aduna(*numere):
total = 0
for numar in numere:
total += numar
return total
print(aduna(10, 20, 30)) 60
Folosirea funcției sum()
def aduna(*numere):
return sum(numere)
print(aduna(5, 10, 15, 20)) 50
Argumente de tipuri diferite
def afiseaza(*args):
print(args)
afiseaza("Python", 10, True, 4.5) ('Python', 10, True, 4.5) Python nu impune ca toate argumentele să aibă același tip.
Parametri obișnuiți înainte de *args
def prezinta(titlu, *elemente):
print(titlu)
for element in elemente:
print(element)
prezinta(
"Tehnologii",
"Python",
"SQL",
"Git"
) Primul argument este atribuit parametrului titlu. Toate argumentele rămase intră în elemente.
Ordinea parametrilor
def functie(parametru_obisnuit, *args):
pass Parametrii poziționali obișnuiți trebuie scriși înainte de *args.
Mai mulți parametri obișnuiți
def creeaza_mesaj(prefix, separator, *cuvinte):
return separator.join(cuvinte)
print(
creeaza_mesaj(
"Ignorat",
" - ",
"Python",
"SQL",
"Git"
)
) Python - SQL - Git
Accesarea elementelor din args
def primul(*args):
return args[0]
print(primul("Python", "Java")) Python
args este un tuplu, deci permite indexare și slicing.
Atenție la tuplul gol
def primul(*args):
return args[0]
primul() Apelul produce IndexError deoarece tuplul args este gol.
Verificarea numărului de argumente
def primul(*args):
if len(args) == 0:
return "Nu există argumente"
return args[0]
print(primul()) Nu există argumente
Numărarea argumentelor
def numara(*args):
return len(args)
print(numara("Python", "Java", "SQL")) 3
Găsirea valorii maxime
def maxim(*numere):
return max(numere)
print(maxim(10, 45, 20, 30)) 45
Crearea unui mesaj
def mesaj(*cuvinte):
return " ".join(cuvinte)
print(
mesaj(
"Învăț",
"Python",
"pas",
"cu",
"pas"
)
) Învăț Python pas cu pas
Despachetarea unei liste la apel
Semnul * poate fi folosit și când apelezi funcția.
def aduna(a, b, c):
return a + b + c
numere = [10, 20, 30]
print(aduna(*numere)) 60
Lista este despachetată în trei argumente poziționale.
Două roluri diferite pentru *
def functie(*args):
print(args)
valori = [1, 2, 3]
functie(*valori) În definiție, * adună argumentele într-un tuplu.
În apel, * despachetează o colecție în argumente separate.
Despachetarea unui tuplu
def inmulteste(a, b):
return a * b
valori = (6, 7)
print(inmulteste(*valori)) 42
Numărul valorilor trebuie să fie corect
def inmulteste(a, b):
return a * b
valori = (2, 3, 4)
inmulteste(*valori) Funcția primește trei argumente, dar acceptă doar două. Apare TypeError.
*args și parametrii opționali
def afiseaza(prefix="Valoare", *args):
for valoare in args:
print(prefix, valoare)
afiseaza("Curs:", "Python", "Java") Curs: Python Curs: Java
Primul argument pozițional este folosit pentru prefix.
Argumente keyword-only după *args
def afiseaza(*args, separator=", "):
print(separator.join(args))
afiseaza(
"Python",
"Java",
"SQL",
separator=" | "
) Python | Java | SQL
Parametrii scriși după *args trebuie transmiși prin nume.
Exemplu din viața reală: totalul unei comenzi
def total_comanda(*preturi):
return sum(preturi)
print(total_comanda(120, 75, 40)) 235
Exemplu din viața reală: participanți
def inscrie_la_curs(curs, *participanti):
print("Curs:", curs)
for participant in participanti:
print("-", participant)
inscrie_la_curs(
"Python",
"Ana",
"Mihai",
"Ioana"
) Exemplu din viața reală: loguri
def log(nivel, *mesaje):
print(nivel, ":", " ".join(mesaje))
log(
"INFO",
"Utilizatorul",
"s-a",
"autentificat"
) INFO : Utilizatorul s-a autentificat
Când este util *args?
*args este util când numărul argumentelor poziționale nu este cunoscut dinainte.
Îl poți folosi pentru sume, mesaje, liste de participanți, valori de configurare, produse, coordonate și funcții care trebuie să accepte un număr flexibil de date.
Când nu este necesar?
Dacă funcția are mereu exact doi parametri cu roluri clare, este mai bine să îi definești explicit.
def calculeaza_aria(lungime, latime):
return lungime * latime Numele clare fac funcția mai ușor de înțeles.
Greșeli frecvente
Uiți semnul *
Fără *, args este un parametru obișnuit care primește o singură valoare.
Crezi că args este o listă
args este întotdeauna un tuplu.
Pui un parametru pozițional după *args
Parametrii obișnuiți poziționali trebuie scriși înainte.
Confunzi colectarea cu despachetarea
În definiție, * colectează. În apel, * despachetează.
Rezumat
Număr flexibilFuncția poate primi oricâte argumente poziționale.
TupluArgumentele sunt colectate într-un tuplu.
Ordine păstratăValorile rămân în ordinea în care au fost transmise.
Despachetare* poate transforma o colecție în argumente separate.
În interiorul funcției, creează variabila total cu valoarea 0. La final, returnează variabila total. Apelează funcția o singură dată cu valorile 120, 75, 40 și 15 și salvează rezultatul în variabila rezultat.
Exercițiul, editorul și verificarea automată se deblochează cu Python OOP.

Alex Cristian
Iulian Pahom
Catalina Ioana Dan