...
← Curs Python
Lecțiile 211–280

Continuă cu Python OOP

Primele 15 lecții din Curs Python sunt gratuite, fără card. Începe cu ele și vezi dacă ți se potrivește înainte să plătești ceva.

Începe gratuit de la lecția 1 →

Academia Programatorilor
Certificat de competență Seria PREVIZUALIZARE

Se certifică faptul că

Numele tău

a finalizat cu succes lecțiile 211–280 din Curs Python, cu exerciții practice rezolvate și verificate automat.

Diplomă Python OOP
Tudor Dumitrescu Tudor Dumitrescu Fondator · Trainer & formator autorizat
Data emiterii 19 noiembrie 2026 Verificare online academiaprogramatorilor.ro/certificat/PREVIZUALIZARE/
La finalul modulului primești Diplomă Python OOP
Lecția 244 · Python OOP

*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 flexibil

Funcția poate primi oricâte argumente poziționale.

Tuplu

Argumentele 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.

Exercițiul lecției

Î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.

Ce urmează în curs

  1. Python Începător Lecțiile 16–80 · 65 de lecții certificat
  2. Python Intermediar Lecțiile 81–140 · 60 de lecții certificat
  3. Python Avansat Lecțiile 141–210 · 70 de lecții certificat
  4. Python OOP Lecțiile 211–280 · 70 de lecții certificat
  5. Junior Python Developer Lecțiile 281–350 · 70 de lecții certificat

Ce primești

  • Lecții interactive în limba română, cu cod scris și rulat direct în browser
  • Exerciții verificate automat, cu feedback pe loc
  • Certificat la finalul fiecărui modul, verificabil online
  • Acces pe viață, în ritmul tău, fără abonament

4,9 din 5 · 128 de recenzii Google

Profesorii si colegii foarte prietenosi,modul in care se preda simplu si usor de inteles cu exemple practice incat oricine poate prinde usor.
Alex Cristian
Foarte profi si utile cursurile. Practica aplicata si explicata de traineri inarmati cu rabdare si cunostine solide.
Iulian Pahom
Cursuri foarte utile si profesori foarte pregatiti. Recomand cu toata increderea.
Catalina Ioana Dan
Toate recenziile pe Google