...
← 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 254 · Python OOP

Modele alternative în match-case

În această lecție vei învăța cum folosești operatorul | în structurile match / case pentru a executa aceeași ramură atunci când valoarea analizată se potrivește cu oricare dintre mai multe modele alternative.

Ramuri diferite cu același rezultat

Uneori mai multe valori trebuie să execute exact același cod.

zi = "sambata"
match zi:
    case "sambata":
        print("Weekend")
    case "duminica":
        print("Weekend")
    case _:
        print("Zi lucratoare")

Mesajul Weekend este repetat în două ramuri separate.

Combinarea modelelor cu |

zi = "sambata"
match zi:
    case "sambata" | "duminica":
        print("Weekend")
    case _:
        print("Zi lucratoare")
Weekend

Ramura este executată dacă valoarea este sambata sau duminica.

Sintaxa

match valoare:
    case model_1 | model_2:
        instructiuni

Modelele separate prin | sunt alternative ale aceleiași ramuri.

Operatorul | înseamnă „oricare dintre modele”

case "start" | "pornire":

Ramura acceptă atât stringul start, cât și stringul pornire.

Nu este operatorul boolean or

Într-un model case se folosește operatorul |, nu cuvântul or.

case "start" | "restart":
    print("Pornire")

Forma următoare nu reprezintă un model alternativ valid:

case "start" or "restart":

Combinarea numerelor

optiune = 2
match optiune:
    case 1 | 2 | 3:
        print("Optiune principala")
    case _:
        print("Alta optiune")
Optiune principala

Mai mult de două alternative

status = "asteptare"
match status:
    case "nou" | "asteptare" | "procesare":
        print("Comanda activa")
    case "finalizat":
        print("Comanda inchisa")
    case _:
        print("Status necunoscut")

Ordinea alternativelor nu schimbă rezultatul

case "admin" | "editor":

și

case "editor" | "admin":

acceptă aceleași două valori.

Prima ramură case compatibilă câștigă

rol = "admin"
match rol:
    case "admin" | "editor":
        print("Acces extins")
    case "admin":
        print("Administrator")
Acces extins

A doua ramură nu poate fi atinsă pentru valoarea admin.

Modelele specifice trebuie scrise înainte

rol = "admin"
match rol:
    case "admin":
        print("Administrator")
    case "admin" | "editor":
        print("Acces extins")
Administrator

Alternative cu valori booleene

valoare = True
match valoare:
    case True | False:
        print("Valoare booleana")
    case _:
        print("Alt tip")

Alternative cu None

valoare = None
match valoare:
    case None | "":
        print("Valoare lipsa")
    case _:
        print("Valoare existenta")

Alternative pentru comenzi sinonime

comanda = "quit"
match comanda:
    case "exit" | "quit" | "stop":
        print("Aplicatia se inchide")
    case _:
        print("Aplicatia continua")

Alternative pentru extensii de fișiere

extensie = "jpg"
match extensie:
    case "jpg" | "jpeg" | "png":
        print("Imagine")
    case "pdf":
        print("Document")
    case _:
        print("Tip necunoscut")

Modele alternative pentru secvențe

comanda = ["start"]
match comanda:
    case ["start"] | ["pornire"]:
        print("Pornire")
    case _:
        print("Alta comanda")

Alternative pentru tuple

eveniment = ("click",)
match eveniment:
    case ("click",) | ("tap",):
        print("Selectare")
    case _:
        print("Alt eveniment")

Capturarea variabilelor în alternative

comanda = ["adauga", "Python"]
match comanda:
    case ["adauga", curs] | ["creeaza", curs]:
        print("Curs:", curs)
    case _:
        print("Comanda invalida")
Curs: Python

Aceleași variabile trebuie capturate

Toate alternativele unei ramuri trebuie să lege aceleași nume de variabile.

case ["adauga", curs] | ["creeaza", curs]:

Ambele modele capturează variabila curs.

Capturări incompatibile

case ["adauga", curs] | ["lista"]:

Primul model capturează curs, iar al doilea nu. Python nu permite această combinație și produce SyntaxError.

Capturarea mai multor valori

actiune = ["muta", "fisier.txt", "arhiva"]
match actiune:
    case ["muta", sursa, destinatie] | ["copiaza", sursa, destinatie]:
        print(sursa, destinatie)
    case _:
        print("Actiune invalida")

Alternative cu modelul as

status = 404
match status:
    case (400 | 404) as cod:
        print("Eroare client:", cod)
    case _:
        print("Alt status")
Eroare client: 404

Parantezele grupează alternativele

case (400 | 404) as cod:

Mai întâi este potrivit unul dintre coduri, apoi valoarea completă este capturată în cod.

Alternative împreună cu un guard

rol = "editor"
activ = True
match rol:
    case "admin" | "editor" if activ:
        print("Acces permis")
    case _:
        print("Acces refuzat")

Guard-ul este evaluat după potrivirea uneia dintre alternative.

Guard-ul se aplică întregii ramuri

case "admin" | "editor" if activ:

Condiția activ trebuie să fie adevărată indiferent dacă valoarea este admin sau editor.

Alternative și ramura implicită

limbaj = "Go"
match limbaj:
    case "Python" | "Java":
        print("Predat in curs")
    case "SQL":
        print("Baze de date")
    case _:
        print("Alta tehnologie")

Nu combina case _ cu alte alternative

case "Python" | _:

Modelul _ acceptă orice valoare, deci alternativa Python nu mai adaugă nimic util. Folosește case _ separat și ultimul.

Alternative versus operatorul in

if rol in ("admin", "editor"):
    print("Acces extins")

În match / case, aceeași idee poate fi exprimată astfel:

match rol:
    case "admin" | "editor":
        print("Acces extins")

Când este mai potrivit in?

Pentru o verificare simplă într-o condiție if, operatorul in poate fi mai scurt și mai clar.

Modelele alternative sunt utile când lucrezi deja într-o structură match și ai mai multe ramuri.

Exemplu din viața reală: metode HTTP

metoda = "POST"
match metoda:
    case "POST" | "PUT" | "PATCH":
        print("Cerere care modifica date")
    case "GET":
        print("Cerere de citire")
    case "DELETE":
        print("Cerere de stergere")
    case _:
        print("Metoda necunoscuta")

Exemplu din viața reală: coduri de status

status = 404
match status:
    case 200 | 201 | 204:
        print("Succes")
    case 400 | 401 | 403 | 404:
        print("Eroare client")
    case 500 | 502 | 503:
        print("Eroare server")
    case _:
        print("Alt status")

Exemplu din viața reală: roluri

rol = "moderator"
match rol:
    case "admin" | "moderator":
        print("Poate administra")
    case "editor" | "autor":
        print("Poate publica")
    case _:
        print("Acces limitat")

Când sunt utile modelele alternative?

Sunt utile când mai multe valori sau structuri trebuie să execute aceeași ramură.

Le poți folosi pentru sinonime, roluri, coduri de status, comenzi, extensii, metode HTTP și structuri de date echivalente.

Când trebuie evitate?

Dacă lista alternativelor devine foarte lungă sau se schimbă frecvent, o colecție și operatorul in pot fi mai ușor de întreținut.

Greșeli frecvente

Folosești or în loc de |

Modelele alternative se separă cu operatorul |.

Capturezi variabile diferite

Toate alternativele trebuie să lege aceleași nume.

Repeți aceeași valoare în mai multe ramuri

Prima ramură compatibilă este executată.

Pui case _ într-o alternativă

Ramura implicită trebuie păstrată separat și la final.

Rezumat

Alternative

| combină mai multe modele în aceeași ramură.

Același rezultat

Oricare dintre modele execută același bloc.

Capturări identice

Alternativele trebuie să lege aceleași variabile.

Ordine

Prima ramură case compatibilă este aleasă.

Exercițiul lecției

Folosește exact o atribuire, un singur match, trei ramuri case, trei operatori | și exact trei apeluri print() în source code. Nu folosi if, elif, else, for, while, break, continue, guard-uri, operatorul or, operatorul in, funcții definite…

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