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

Operatorul is în Python

În această lecție vei învăța diferența dintre egalitatea valorilor și identitatea obiectelor și vei folosi operatorul is în situațiile în care trebuie să verifici dacă două variabile indică exact același obiect.

Valoare egală sau același obiect?

Două obiecte pot conține aceleași valori fără să fie același obiect în memorie.

prima = [1, 2, 3]
a_doua = [1, 2, 3]
print(prima == a_doua)
print(prima is a_doua)
True
False

Operatorul == compară valorile. Operatorul is compară identitatea obiectelor.

Ce verifică operatorul is?

Operatorul is verifică dacă două expresii indică exact același obiect.

lista = ["Python", "SQL"]
copie = lista
print(lista is copie)
True

Nu a fost creată o listă nouă. Ambele variabile indică aceeași listă.

Operatorul == compară valorile

prima = ["Python", "SQL"]
a_doua = ["Python", "SQL"]
print(prima == a_doua)
True

Listele conțin aceleași elemente în aceeași ordine.

Operatorul is compară obiectele

prima = ["Python", "SQL"]
a_doua = ["Python", "SQL"]
print(prima is a_doua)
False

Listele au fost create separat, deci sunt două obiecte diferite.

Atribuirea nu creează o copie

prima = [10, 20]
a_doua = prima
print(prima is a_doua)
True

Atribuirea face ca a_doua să indice obiectul existent.

Modificarea obiectului comun

prima = [10, 20]
a_doua = prima
a_doua.append(30)
print(prima)
print(a_doua)
[10, 20, 30]
[10, 20, 30]

Modificarea este vizibilă prin ambele variabile deoarece ele indică aceeași listă.

Crearea unei copii separate

prima = [10, 20]
a_doua = prima.copy()
print(prima == a_doua)
print(prima is a_doua)
True
False

Valorile sunt egale, dar listele sunt obiecte diferite.

Operatorul is not

Operatorul is not verifică dacă două expresii nu indică același obiect.

prima = [1, 2]
a_doua = [1, 2]
print(prima is not a_doua)
True

Verificarea valorii None

Cea mai importantă utilizare a operatorului is este verificarea valorii None.

rezultat = None
if rezultat is None:
    print("Nu există rezultat")
Nu există rezultat

De ce folosim is cu None?

None este un obiect unic. Verificarea recomandată este:

valoare is None

Nu este recomandată forma:

valoare == None

Verificarea că valoarea nu este None

utilizator = "Ana"
if utilizator is not None:
    print(utilizator)
Ana

None nu este același lucru cu False

valoare = False
print(valoare is None)
False

None nu este același lucru cu zero

valoare = 0
print(valoare is None)
False

None nu este același lucru cu un string gol

valoare = ""
print(valoare is None)
False

Toate aceste valori sunt falsy, dar numai None este None.

Exemplu cu o funcție

def cauta_utilizator(nume):
    if nume == "Ana":
        return {"nume": "Ana"}
    return None
rezultat = cauta_utilizator("Mihai")
if rezultat is None:
    print("Utilizatorul nu există")

Parametru opțional cu None

def afiseaza_mesaj(text=None):
    if text is None:
        text = "Mesaj implicit"
    print(text)
afiseaza_mesaj()
Mesaj implicit

De ce este util None ca valoare implicită?

None poate semnala că apelantul nu a transmis o valoare.

def configureaza(tema=None):
    if tema is None:
        tema = "light"
    return tema

Identitatea dicționarelor

primul = {"curs": "Python"}
al_doilea = {"curs": "Python"}
print(primul == al_doilea)
print(primul is al_doilea)
True
False

Identitatea seturilor

primul = {1, 2, 3}
al_doilea = {1, 2, 3}
print(primul == al_doilea)
print(primul is al_doilea)
True
False

Identitatea obiectelor returnate de o funcție

def creeaza_lista():
    return []
prima = creeaza_lista()
a_doua = creeaza_lista()
print(prima is a_doua)
False

Fiecare apel creează o listă nouă.

Aceeași valoare returnată direct

lista = []
def obtine_lista():
    return lista
prima = obtine_lista()
a_doua = obtine_lista()
print(prima is a_doua)
True

Nu folosi is pentru compararea numerelor

a = 1000
b = 1000
print(a == b)
True

Pentru valori numerice folosește ==. Unele implementări Python pot reutiliza anumite obiecte numerice, iar rezultatul operatorului is nu trebuie folosit pentru egalitatea valorilor.

Nu folosi is pentru compararea stringurilor

prima = "Python"
a_doua = "Python"
print(prima == a_doua)
True

Pentru conținutul stringurilor folosește ==, nu is.

De ce uneori is pare să funcționeze cu valori?

Python poate reutiliza intern anumite obiecte imuabile pentru eficiență. Acest comportament se numește interning.

Reține

Interning-ul este un detaliu de implementare. Nu construi logica programului pe rezultatul lui is pentru numere sau stringuri.

== poate fi personalizat

Clasele pot defini modul în care operatorul == compară obiectele.

Operatorul is nu poate fi redefinit: el verifică întotdeauna identitatea.

Funcția id()

Funcția id() returnează identificatorul unui obiect pe durata existenței sale.

lista = [1, 2]
copie = lista
print(id(lista))
print(id(copie))

Cele două valori id sunt egale deoarece variabilele indică același obiect.

Legătura dintre is și id()

a is b

verifică aceeași idee ca:

id(a) == id(b)

În codul obișnuit, operatorul is este mai clar.

Aliasuri pentru același obiect

cursuri = ["Python", "SQL"]
favorite = cursuri
recomandate = cursuri
print(cursuri is favorite)
print(favorite is recomandate)
True
True

Cele trei variabile sunt aliasuri pentru aceeași listă.

Copiere superficială

original = [1, 2, 3]
copie = original[:]
print(original == copie)
print(original is copie)
True
False

Copii cu elemente interioare comune

original = [[1, 2], [3, 4]]
copie = original.copy()
print(original is copie)
print(original[0] is copie[0])
False
True

Listele exterioare sunt diferite, dar elementele interioare sunt încă aceleași obiecte.

Exemplu din viața reală: cache

cache = None
def obtine_date():
    global cache
    if cache is None:
        cache = ["date încărcate"]
    return cache

None arată că datele nu au fost încă încărcate.

Exemplu din viața reală: rezultat opțional

def gaseste_job(titlu):
    if titlu == "Java Developer":
        return {
            "titlu": titlu
        }
    return None
job = gaseste_job("Python Developer")
if job is None:
    print("Nu a fost găsit niciun job")

Când este util is?

Operatorul is este util când identitatea obiectului contează, nu doar conținutul.

În practică, îl vei folosi cel mai des pentru verificări cu None și, mai rar, pentru a verifica dacă două variabile indică același obiect mutabil.

Când folosești ==?

Folosește == când vrei să compari valori:

numere
stringuri
liste
tuple
dicționare
seturi

Când folosești is?

Folosește is când vrei să verifici:

valoare is None
valoare is not None
prima_variabila is a_doua_variabila

Greșeli frecvente

Folosești is în loc de ==

is nu verifică dacă valorile sunt egale.

Folosești == None

Forma recomandată este is None.

Crezi că atribuirea copiază obiectul

Atribuirea creează încă o referință spre același obiect.

Te bazezi pe interning

Nu folosi is pentru numere sau stringuri doar pentru că unele exemple par să returneze True.

Rezumat

== compară valori

Două obiecte separate pot avea valori egale.

is compară identitatea

Verifică dacă variabilele indică același obiect.

None

Folosește is None și is not None.

Atribuire și copiere

Atribuirea păstrează obiectul, copierea creează altul.

Exercițiul lecției

Creează variabila rezultat cu valoarea None. Folosește exact patru instrucțiuni de atribuire, un singur operator ==, trei operatori is și patru apeluri print(). Nu folosi is not, !=, copy(), list(), id(), if, for, while, funcții definite cu…

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