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

itertools.filterfalse() în Python

În această lecție vei învăța cum folosești itertools.filterfalse() pentru a păstra elementele pentru care o funcție de verificare returnează o valoare falsă.

Ce problemă rezolvă filterfalse()?

Uneori nu vrei elementele care respectă o condiție, ci exact elementele care nu o respectă.

Numere: 10, 15, 20, 25
Condiție: numărul este cel puțin 20

Elementele pentru care această condiție este falsă sunt 10 și 15.

Ce face filterfalse()?

Funcția filterfalse() verifică fiecare element cu ajutorul unei funcții și păstrează elementele pentru care rezultatul este fals.

from itertools import filterfalse
numere = [10, 15, 20, 25]
rezultat = filterfalse(
    lambda numar: numar >= 20,
    numere
)
print(list(rezultat))
[10, 15]

Importarea funcției

from itertools import filterfalse

filterfalse() face parte din modulul itertools și returnează un iterator.

Sintaxa

filterfalse(function, iterable)

function verifică fiecare element.

iterable conține valorile care trebuie analizate.

Cum funcționează pas cu pas?

10 >= 20 → False → păstrat
15 >= 20 → False → păstrat
20 >= 20 → True  → ignorat
25 >= 20 → True  → ignorat

filterfalse() păstrează rezultatele False și le elimină pe cele True.

Diferența față de filter()

filter() păstrează elementele pentru care condiția este adevărată.

numere = [10, 15, 20, 25]
print(list(
    filter(lambda numar: numar >= 20, numere)
))
[20, 25]

filterfalse() păstrează exact partea opusă.

from itertools import filterfalse
print(list(
    filterfalse(
        lambda numar: numar >= 20,
        numere
    )
))
[10, 15]

Rezultatul este un iterator

from itertools import filterfalse
rezultat = filterfalse(
    lambda numar: numar % 2 == 0,
    [1, 2, 3, 4, 5]
)
print(next(rezultat))
print(next(rezultat))
1
3

Numerele impare sunt păstrate deoarece condiția „este par” este falsă pentru ele.

Selectarea numerelor impare

from itertools import filterfalse
numere = [1, 2, 3, 4, 5, 6]
impare = filterfalse(
    lambda numar: numar % 2 == 0,
    numere
)
print(list(impare))
[1, 3, 5]

Selectarea numerelor care nu sunt pozitive

from itertools import filterfalse
numere = [-3, 0, 4, -1, 8]
rezultat = filterfalse(
    lambda numar: numar > 0,
    numere
)
print(list(rezultat))
[-3, 0, -1]

Selectarea stringurilor scurte

from itertools import filterfalse
cuvinte = ["SQL", "Python", "Git", "Docker"]
scurte = filterfalse(
    lambda cuvant: len(cuvant) > 3,
    cuvinte
)
print(list(scurte))
['SQL', 'Git']

Selectarea cursanților inactivi

from itertools import filterfalse
cursanti = [
    {"nume": "Ana", "activ": True},
    {"nume": "Mihai", "activ": False},
    {"nume": "Ioana", "activ": False}
]
inactivi = filterfalse(
    lambda cursant: cursant["activ"],
    cursanti
)
for cursant in inactivi:
    print(cursant["nume"])
Mihai
Ioana

Folosirea unei funcții definite cu def

from itertools import filterfalse
def este_valid(cod):
    return len(cod) == 4
coduri = ["AB12", "XYZ", "P123", "A"]
invalide = filterfalse(este_valid, coduri)
print(list(invalide))
['XYZ', 'A']

Parcurgerea cu for

from itertools import filterfalse
preturi = [50, 120, 80, 200]
for pret in filterfalse(
    lambda valoare: valoare >= 100,
    preturi
):
    print(pret)
50
80

Predicatul poate întoarce valori truthy sau falsy

Funcția nu trebuie să returneze literal True sau False. Python interpretează rezultatul după regulile truthy și falsy.

from itertools import filterfalse
texte = ["Python", "", "SQL", ""]
goale = filterfalse(
    lambda text: text,
    texte
)
print(list(goale))
['', '']

Folosirea valorii None ca funcție

Dacă primul argument este None, filterfalse() verifică direct valoarea de adevăr a fiecărui element.

from itertools import filterfalse
valori = [0, 1, "", "Python", None, [], [1]]
false_values = filterfalse(None, valori)
print(list(false_values))
[0, '', None, []]

Ce păstrează filterfalse(None, ...)?

Sunt păstrate valorile falsy, precum:

False
None
0
0.0
""
[]
()
{}

Un iterabil gol

from itertools import filterfalse
print(list(
    filterfalse(lambda valoare: True, [])
))
[]

Dacă funcția returnează mereu True

from itertools import filterfalse
rezultat = filterfalse(
    lambda valoare: True,
    [1, 2, 3]
)
print(list(rezultat))
[]

Niciun element nu este păstrat.

Dacă funcția returnează mereu False

from itertools import filterfalse
rezultat = filterfalse(
    lambda valoare: False,
    [1, 2, 3]
)
print(list(rezultat))
[1, 2, 3]

Toate elementele sunt păstrate.

Folosirea cu tuple

from itertools import filterfalse
numere = (10, 15, 20, 25)
rezultat = filterfalse(
    lambda numar: numar % 10 == 0,
    numere
)
print(list(rezultat))
[15, 25]

Folosirea cu range()

from itertools import filterfalse
rezultat = filterfalse(
    lambda numar: numar < 5,
    range(1, 9)
)
print(list(rezultat))
[5, 6, 7, 8]

Folosirea cu un generator

from itertools import filterfalse
def genereaza():
    yield 10
    yield 20
    yield 30
    yield 40
rezultat = filterfalse(
    lambda numar: numar >= 30,
    genereaza()
)
print(list(rezultat))
[10, 20]

Verificarea se face doar când este nevoie

from itertools import filterfalse
def verifica(numar):
    print("Verific:", numar)
    return numar % 2 == 0
rezultat = filterfalse(
    verifica,
    [2, 4, 5, 7]
)
print(next(rezultat))
Verific: 2
Verific: 4
Verific: 5
5

Funcția verifică elementele până găsește unul pentru care rezultatul este fals.

Iteratorul sursă este consumat

from itertools import filterfalse
sursa = iter([1, 2, 3, 4])
rezultat = filterfalse(
    lambda numar: numar % 2 == 0,
    sursa
)
print(next(rezultat))
print(next(sursa))

Pentru a găsi rezultatele potrivite, filterfalse() consumă elementele sursei.

Iteratorul rezultat este consumabil

from itertools import filterfalse
rezultat = filterfalse(
    lambda numar: numar % 2 == 0,
    [1, 2, 3]
)
print(list(rezultat))
print(list(rezultat))
[1, 3]
[]

Datele originale nu sunt modificate

from itertools import filterfalse
numere = [1, 2, 3, 4]
rezultat = list(
    filterfalse(
        lambda numar: numar % 2 == 0,
        numere
    )
)
print(numere)
print(rezultat)
[1, 2, 3, 4]
[1, 3]

Diferența față de compress()

compress() primește deciziile de selecție într-un al doilea iterabil.

from itertools import compress
print(list(
    compress(
        ["A", "B", "C"],
        [True, False, True]
    )
))
['A', 'C']

filterfalse() calculează decizia pentru fiecare element cu ajutorul unei funcții.

Selectarea erorilor dintr-un raport

from itertools import filterfalse
rezultate = [
    {"mesaj": "Import reușit", "valid": True},
    {"mesaj": "Email lipsă", "valid": False},
    {"mesaj": "Telefon invalid", "valid": False}
]
erori = filterfalse(
    lambda rezultat: rezultat["valid"],
    rezultate
)
for eroare in erori:
    print(eroare["mesaj"])
Email lipsă
Telefon invalid

Selectarea fișierelor neacceptate

from itertools import filterfalse
fisiere = [
    "raport.pdf",
    "poza.jpg",
    "date.csv",
    "script.exe"
]
neacceptate = filterfalse(
    lambda fisier: fisier.endswith(
        (".pdf", ".jpg", ".csv")
    ),
    fisiere
)
print(list(neacceptate))
['script.exe']

Când este util filterfalse()?

filterfalse() este util când vrei partea respinsă de o regulă.

Îl poți folosi pentru valori invalide, utilizatori inactivi, produse indisponibile, fișiere neacceptate, numere care nu respectă un prag și elemente care au eșuat o verificare.

Greșeli frecvente

Te aștepți să păstreze rezultatele True

Acesta este comportamentul lui filter(). filterfalse() păstrează rezultatele False.

Negi condiția de două ori

Folosește condiția normală și lasă filterfalse() să păstreze partea opusă.

Te aștepți la o listă

Funcția returnează un iterator.

Reutilizezi iteratorul consumat

Creează un obiect filterfalse() nou pentru o altă parcurgere.

Rezumat

Funcție de verificare

Fiecare element este analizat separat.

Rezultat fals

Elementul este păstrat.

Rezultat adevărat

Elementul este ignorat.

Iterator

Valorile sunt produse doar când sunt cerute.

Exercițiul lecției

Folosește exact un import, patru instrucțiuni de atribuire, un singur apel filterfalse(), o singură expresie lambda, un singur operator >=, două apeluri next() și două apeluri print(). Nu folosi filter(), compress(), for, while, list(), com…

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