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

itertools.permutations() în Python

În această lecție vei învăța cum folosești itertools.permutations() pentru a crea toate aranjamentele posibile în care ordinea elementelor contează.

Ce este o permutare?

O permutare este un aranjament al unor elemente într-o anumită ordine.

Elemente: A, B
Aranjamente:
A B
B A

Cele două rezultate conțin aceleași elemente, dar ordinea lor este diferită.

Ce face permutations()?

Funcția permutations() produce toate aranjamentele ordonate posibile ale elementelor unui iterabil.

from itertools import permutations
litere = ["A", "B", "C"]
aranjamente = permutations(litere)
print(list(aranjamente))
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

Importarea funcției permutations

from itertools import permutations

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

Sintaxa de bază

permutations(iterable)

Dacă nu transmiți o lungime, fiecare rezultat conține toate elementele iterabilului.

Ordinea contează

from itertools import permutations
print(list(permutations(["A", "B"])))
[('A', 'B'), ('B', 'A')]

Tuplele ("A", "B") și ("B", "A") sunt rezultate diferite.

Rezultatul este un iterator

from itertools import permutations
aranjamente = permutations(["A", "B", "C"])
print(next(aranjamente))
print(next(aranjamente))
('A', 'B', 'C')
('A', 'C', 'B')

Stabilirea lungimii rezultatelor

Al doilea argument stabilește câte elemente conține fiecare permutare.

permutations(iterable, r)
from itertools import permutations
rezultate = permutations(["A", "B", "C"], 2)
print(list(rezultate))
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

Elementele nu se repetă în aceeași permutare

from itertools import permutations
print(list(permutations([1, 2, 3], 2)))
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

Rezultate precum (1, 1) sau (2, 2) nu apar, deoarece aceeași poziție din iterabil nu este folosită de două ori.

Diferența față de product()

product() poate folosi aceeași valoare de mai multe ori când același iterabil este repetat.

from itertools import product
print(list(product(["A", "B"], repeat=2)))
[('A', 'A'), ('A', 'B'), ('B', 'A'), ('B', 'B')]

permutations() nu repetă aceeași poziție în cadrul unui rezultat.

from itertools import permutations
print(list(permutations(["A", "B"], 2)))
[('A', 'B'), ('B', 'A')]

Permutări de lungime 1

from itertools import permutations
print(list(permutations(["A", "B", "C"], 1)))
[('A',), ('B',), ('C',)]

Chiar și rezultatele cu un singur element sunt tuple.

Lungimea egală cu zero

from itertools import permutations
print(list(permutations(["A", "B"], 0)))
[()]

Există o singură permutare de lungime zero: tuple-ul gol.

Lungime mai mare decât numărul elementelor

from itertools import permutations
print(list(permutations(["A", "B"], 3)))
[]

Nu pot fi selectate trei poziții distincte dintr-un iterabil cu doar două elemente.

Folosirea cu stringuri

from itertools import permutations
rezultate = permutations("ABC", 2)
print(list(rezultate))
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

Transformarea tuplelor în stringuri

from itertools import permutations
for litere in permutations("ABC", 2):
    print("".join(litere))
AB
AC
BA
BC
CA
CB

Folosirea cu numere

from itertools import permutations
cifre = [1, 2, 3]
for prima, a_doua in permutations(cifre, 2):
    print(prima, a_doua)
1 2
1 3
2 1
2 3
3 1
3 2

Elemente duplicate în sursă

from itertools import permutations
print(list(permutations(["A", "A", "B"])))

permutations() tratează elementele după poziția lor, nu după unicitatea valorii. Din acest motiv, pot apărea tuple cu aceleași valori.

Eliminarea rezultatelor duplicate

from itertools import permutations
rezultate = set(permutations(["A", "A", "B"]))
print(rezultate)

Un set poate elimina tuplele duplicate după generare.

Crearea ordinii de prezentare

from itertools import permutations
participanti = ["Ana", "Mihai", "Ioana"]
for ordine in permutations(participanti):
    print(ordine)

Fiecare rezultat reprezintă o ordine posibilă a celor trei participanți.

Crearea codurilor fără caractere repetate

from itertools import permutations
caractere = "ABC"
for cod in permutations(caractere, 2):
    print("".join(cod))
AB
AC
BA
BC
CA
CB

Numărul permutărilor complete

Pentru 3 elemente distincte există 6 permutări complete.

3 × 2 × 1 = 6

Pentru 4 elemente distincte există:

4 × 3 × 2 × 1 = 24

Numărul permutărilor parțiale

Pentru 4 elemente din care alegem câte 2, există:

4 × 3 = 12

Prima poziție are 4 opțiuni, iar a doua mai are 3 opțiuni.

Ordinea rezultatelor

permutations() păstrează ordinea elementelor din iterabilul sursă pentru a stabili ordinea în care produce rezultatele.

from itertools import permutations
print(list(permutations(["B", "A", "C"], 2)))

Primele rezultate vor începe cu B, deoarece B este primul element al sursei.

Datele sunt pregătite înaintea iterării

permutations() păstrează intern elementele sursei pentru a putea crea aranjamentele.

Atenție

Nu folosi permutations() cu iteratoare infinite. Funcția trebuie să consume sursa înainte să producă rezultate.

Iteratorul este consumabil

from itertools import permutations
aranjamente = permutations(["A", "B", "C"], 2)
print(list(aranjamente))
print(list(aranjamente))

A doua parcurgere produce o listă goală, deoarece iteratorul a fost deja consumat.

Datele originale nu sunt modificate

from itertools import permutations
litere = ["A", "B", "C"]
rezultate = list(permutations(litere, 2))
print(litere)
['A', 'B', 'C']

Când este util permutations()?

permutations() este util când ordinea elementelor schimbă sensul rezultatului.

Îl poți folosi pentru ordini de execuție, clasamente, trasee, coduri fără repetare, așezarea participanților și testarea tuturor aranjamentelor posibile.

Greșeli frecvente

Confunzi permutările cu produsul cartezian

permutations() nu reutilizează aceeași poziție în același rezultat.

Crezi că ordinea nu contează

În permutări, ("A", "B") și ("B", "A") sunt rezultate diferite.

Te aștepți la o listă

Funcția returnează un iterator de tuple.

Folosești o lungime prea mare

Dacă r este mai mare decât numărul elementelor, nu există rezultate.

Rezumat

Ordinea contează

Schimbarea ordinii produce o permutare diferită.

Fără reutilizare

Aceeași poziție nu apare de două ori într-un rezultat.

Lungime opțională

Argumentul r stabilește numărul elementelor din tuplu.

Iterator

Aranjamentele sunt produse pe rând.

Exercițiul lecției

Pentru următoarele permutări folosește numele: a_doua_1, a_doua_2, a_treia_1, a_treia_2, a_patra_1, a_patra_2, a_cincea_1, a_cincea_2, a_sasea_1 și a_sasea_2. Folosește exact un import, opt instrucțiuni de atribuire, un apel permutations(),…

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