Conform documentației Python, Itertools este un modul Python care oferă un set de instrumente rapide și eficiente din punct de vedere al memoriei pentru lucrul cu iteratoarele Python. Aceste instrumente pot fi utilizate singure sau în combinație și fac posibilă crearea și lucrul cu iteratoare în mod succint și eficient, într-un mod rapid și eficient din punct de vedere al memoriei.
Modulul Itertools conține funcții care facilitează lucrul cu iteratoare, în special atunci când se manipulează seturi mari de date. Funcțiile Itertools pot funcționa pe iteratoarele existente pentru a crea iteratoare Python și mai complexe.
În plus, Itertools poate ajuta dezvoltatorii să reducă erorile atunci când lucrează cu iteratoare și să scrie cod mai curat, care poate fi citit și care poate fi întreținut.
Pe baza funcționalității pe care o oferă iteratoarele din modulul Itertools, acestea pot fi clasificate în următoarele tipuri:
Cuprins
#1. Iteratori infiniti
Acestea sunt iteratoare care vă permit să lucrați cu secvențe infinite și să rulați o buclă la infinit dacă nu există nicio condiție pentru a ieși din buclă. Astfel de iteratoare sunt utile atunci când se simulează bucle infinite sau se generează o secvență nemărginită. Itertools are trei iteratoare infinite, care includ count(), cycle() și repeat().
#2. Iteratori combinatorici
Iteratoarele combinatorice cuprind funcții care pot fi utilizate pentru a lucra pe produse carteziene și pentru a efectua combinații și permutări ale elementelor conținute într-un iterabil. Acestea sunt funcțiile de bază atunci când încercați să găsiți toate modalitățile posibile de a aranja sau combina elemente într-un iterabil. Itertools are patru iteratoare combinatorii. Acestea sunt produs(), permutări(), combinații() și combinații_cu_înlocuire().
#3. Iteratoare care se termină pe cea mai scurtă secvență de intrare
Acestea sunt iteratoare de terminare care sunt utilizate pe secvențe finite și generează o ieșire pe baza tipului de funcție utilizată. Exemplele acestor iteratoare de terminare includ: accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile (), tee() și zip_longest().
Să ne uităm la modul în care funcționează diferitele funcții Itertools în funcție de tipul lor:
Iteratori infiniti
Cei trei iteratori infiniti includ:
#1. numara()
Funcția de numărare (start, step) generează o succesiune infinită de numere pornind de la valoarea de început. Funcția acceptă două argumente opționale: start și step. Argumentul start stabilește unde ar trebui să înceapă succesiunea de numere. În mod implicit, începe de la 0 dacă nu este furnizată o valoare de pornire. pasul stabilește diferența dintre fiecare număr consecutiv. Valoarea implicită a pasului este 1.
import itertools
# count starting at 4, making steps of 2
for i in itertools.count(4, 2):
# condition to end the loop avoiding infinite looping
if i == 14:
break
else:
print(i) # output - 4, 6, 8, 10, 12
Ieșire
4 6 8 10 12
#2. ciclu()
Funcția cycle(iterable) ia un iterabil ca argument și apoi parcurge iterabilul permițând accesul la elementele din iterabil în ordinea în care apar.
De exemplu, dacă trecem [“red”, “green”, “yellow”] în cycle(), în primul ciclu, vom avea acces la „roșu”; în al doilea ciclu vom avea acces la „verde”, apoi „galben”. În al patrulea ciclu, deoarece toate elementele au fost epuizate în iterabil, vom începe de la început la „roșu” și apoi vom continua la infinit.
Când apelați cycle() stocați rezultatul într-o variabilă pentru a crea un iterator care să-și mențină starea. Acest lucru asigură că ciclul nu începe de la capăt de fiecare dată, oferindu-vă acces doar la primul element.
import itertools
colors = ["red", "green", "yellow"]
# pass in colors into cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)
# range used to stop the infinite loop once we've printed 7 times
# next() used to return the next item from the iterator
for i in range(7):
print(next(color_cycle))
Ieșire:
red green yellow red green yellow red
#3. repeta()
repeat(elem,n) are două argumente, un element de repetat (elem) și de câte ori doriți să repetați elementul (n). Elementul pe care doriți să îl repetați poate fi o singură valoare sau un iterabil. Dacă nu treceți, n, elementul se va repeta la infinit.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Ieșire:
10 10 10
Iteratori combinatorici
Iteratoarele combinatorice includ:
#1. produs()
product() este o funcție folosită pentru a calcula produsul cartezian al iterabilului transmis acestuia. Dacă avem două iterabile sau mulțimi, de exemplu, x = {7,8} și y = {1,2,3}, produsul cartezian al lui x și y va conține toate combinațiile posibile de elemente din x și y, unde primul element este de la x și al doilea de la y. Produsul cartezian al lui x și y în acest caz este [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() ia un parametru opțional numit repetiție, care este folosit pentru a calcula produsul cartezian al unui iterabil cu el însuși. repetare specifică numărul de repetări pentru fiecare element din iterabilele de intrare atunci când se calculează produsul cartezian.
De exemplu, apelarea product(‘ABCD’, repeat=2) produce combinații precum (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’) și așa pe. Dacă repetarea a fost setată la 3, funcția ar produce combinații precum (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’) , „C”), („A”, „A”, „D”) și așa mai departe.
from itertools import product
# product() with the optional repeat argument
print("product() with the optional repeat argument ")
print(list(product('ABC', repeat = 2)))
# product with no repeat
print("product() WITHOUT an optional repeat argument")
print(list(product([7,8], [1,2,3])))
Ieșire
product() with the optional repeat argument
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() WITHOUT an optional repeat argument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]
#2. permutări ()
permutations(iterable, group_size) returnează toate permutările posibile ale iterabilului trecut în el. O permutare reprezintă numărul de moduri în care elementele dintr-un set pot fi ordonate. permutations() ia un argument opțional group_size. Dacă nu este specificat group_size, permutările generate vor avea aceeași dimensiune cu lungimea iterabilului trecut în funcție
import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))
print("Permutations with a size of 2")
print(sized_permutations)
print("Permutations with NO size argument")
print(unsized_permuatations)
Ieșire
Permutations with a group size of 2 [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)] Permutations with NO size argument [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
#3. combinatii()
combinații(iterabil, dimensiune) returnează toate combinațiile posibile ale unui iterabil de o lungime dată din elementele din iterabil trecute în funcție. Argumentul dimensiune specifică dimensiunea fiecărei combinații.
Rezultatele sunt ordonate. Combinația diferă ușor de permutări. Cu permutare, ordinea contează, dar cu combinație, ordinea nu contează. De exemplu, în [A, B, C] există 6 permutări: AB, AC, BA, BC, CA, CB dar doar 3 combinații AB, AC, BC.
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations(numbers,2))
size3_combination = list(itertools.combinations(numbers, 3))
print("Combinations with a size of 2")
print(size2_combination)
print("Combinations with a size of 3")
print(size3_combination)
Ieșire:
Combinations with a size of 2 [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)] Combinations with a size of 3 [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
#4. combinatii_cu_inlocuire()
combines_with_replacement(iterable, size) generează toate combinațiile posibile ale unui iterabil de o lungime dată din iterabilul trecut în funcție și permite elemente repetate în combinațiile de ieșire. Mărimea determină dimensiunea combinațiilor generate.
Această funcție diferă de combinații() prin aceea că oferă combinații în care un element poate fi repetat de mai multe ori. De exemplu, puteți obține o combinație precum (1,1) pe care nu o puteți obține cu combinație().
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinations_with_replacement => size 2")
print(size2_combination)
Ieșire
Combinations_with_replacement => size 2 [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
Terminarea iteratoarelor
Aceasta include iteratoare precum:
#1. acumula()
accumulate(iterable, function) ia un iterabil și un al doilea argument opțional care este o funcție. Apoi returnează rezultatul acumulat al aplicării funcției în fiecare iterație pe elemente de pe iterabil. Dacă nu trece nicio funcție, se face adăugarea și se returnează rezultatele acumulate.
import itertools
import operator
numbers = [1, 2, 3, 4, 5]
# Accumulate the sum of numbers
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumulate with no function")
print(list(accumulated_val))
print("Accumulate with multiplication")
print(list(accumulated_mul))
Ieșire:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. lanţ()
chain(iterable_1, iterable_2, …) preia mai multe iterabile și le conectează împreună, producând un singur iterable care conține valori din iterabilele transmise funcției chain()
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] # Chain letters and numbers together chained_iterable = list(itertools.chain(letters, numbers, colors)) print(chained_iterable)
Ieșire:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) această funcție este similară cu chain(). Cu toate acestea, diferă de lanț prin faptul că ia doar un singur iterabil care conține sub-iterabile și le conectează împreună.
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] iterable = ['hello',colors, letters, numbers] chain = list(itertools.chain.from_iterable(iterable)) print(chain)
Ieșire:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. comprima()
compress(data, selectors) preia două argumente, data care este un iterabil și selectors care este un iterabil care conține valori booleene true și false. 1, 0 pot fi, de asemenea, folosite ca alternative la valorile booleene true și false. compress() apoi filtrează datele transmise folosind elementele corespunzătoare transmise în selector.
Sunt selectate valorile din date care corespund valorii true sau 1 din selector, în timp ce restul care corespund cu fals sau 0 sunt ignorate. Dacă treceți mai puține valori booleene în selectoare decât numărul de elemente din date, toate elementele dincolo de booleenii trecuți în selectoare sunt ignorate
import itertools # data has 10 items data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] # passing in 9 selector items selectors = [True, False, 1, False, 0, 1, True, False, 1] # Select elements from data based on selectors filtered_data = list(itertools.compress(data, selectors)) print(filtered_data)
Ieșire:
['A', 'C', 'F', 'G', 'I']
#5. dropwhile()
dropwhile(funcție, secvență) preia o funcție cu condiția care returnează adevărat sau fals și o secvență de valori. Apoi scade toate valorile până când condiția trecută returnează False. Odată ce condiția returnează false, restul elementelor sunt incluse în rezultatele sale, indiferent dacă ar returna adevărat sau fals.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Ieșire:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filterfalse()
filterfalse(funcție, secvență) preia o funcție, cu o condiție care se evaluează la adevărat sau fals și o secvență. Apoi returnează valori din secvență care nu satisfac condiția din funcție.
import itertools numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3] # Filter elements for which condition is False filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers)) print(filtered_numbers)
Ieșire:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. a se grupa cu()
groupby(iterabil, cheie) preia un iterabil și o cheie, apoi face un iterator care returnează chei și grupuri consecutive. Pentru ca acesta să funcționeze, iterabilul transmis trebuie să fie sortat pe aceeași funcție cheie. Funcția cheie computer o valoare cheie pentru fiecare element din iterabil.
import itertools
input_list = [("Domestic", "Cow"), ("Domestic", "Dog"), ("Domestic", "Cat"),("Wild", "Lion"), ("Wild", "Zebra"), ("Wild", "Elephant")]
classification = itertools.groupby(input_list,lambda x: x[0])
for key,value in classification:
print(key,":",list(value))
Ieșire:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice(iterable, start, stop, step) vă permite să tăiați un iterabil folosind valorile de start, stop și pas transmise. Argumentul pas este opțional. Numărarea începe de la 0 și articolul de pe numărul de oprire nu este inclus.
import itertools
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
# Select elements within a range
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice without setting a step value")
print(selected_numbers)
print("islice with a step value of 2")
print(selected_numbers_step)
Ieșire:
islice without setting a step value [3, 4, 5, 6, 7, 8, 9, 10] islice with a step value of 2 [3, 5, 7, 9]
#9. perechi()
pairwise(iterable) returnează perechile succesive suprapuse luate din iterabilul transmis acestuia în ordinea în care apar în iterabil. Dacă iterabilul transmis are mai puțin de două valori, rezultatul de la pairwise() va fi gol.
from itertools import pairwise numbers = [1, 2, 3, 4, 5, 6, 7, 8] word = 'WORLD' single = ['A'] print(list(pairwise(numbers))) print(list(pairwise(word))) print(list(pairwise(single)))
Ieșire:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. hartă stelară()
starmap(funcție, iterabil) este o funcție folosită în locul map() atunci când parametrii argumentului sunt deja grupați în tupluri. startmap() aplică o funcție elementelor iterabilului care i-a fost transmis. Iterabilul ar trebui să aibă elemente grupate în tupluri.
import itertools iter_starmap = [(123, 63, 13), (5, 6, 52), (824, 51, 9), (26, 24, 16), (14, 15, 11)] print (list(itertools.starmap(min, iter_starmap)))
Ieșire:
[13, 5, 9, 16, 11]
#11. ia un timp()
takewhile(funcție, iterabil) funcționează în mod opus cu dropwhile(). takewhile() preia o funcție cu o condiție de evaluat și un iterabil. Apoi include toate elementele din iterabil care satisfac condiția din funcție până când este returnat False. Odată ce este returnat False, toate elementele următoare din iterabil sunt ignorate.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Ieșire:
[1, 2, 3, 4]
#12. tricou()
tee(iterable, n) preia un iterabil și returnează mai mulți iteratori independenți. Numărul de iteratoare de returnat este setat de n, care în mod implicit este 2.
import itertools numbers = [1, 2, 3, 4, 5] # Create two independent iterators from numbers iter1, iter2 = itertools.tee(numbers, 2) print(list(iter1)) print(list(iter2))
Ieșire:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) preia mai multe iteratoare și o valoare de umplere. Apoi returnează un iterator care agregează elemente din fiecare dintre iteratorii trecuți la acesta. Dacă iteratoarele nu au aceeași lungime, valorile lipsă sunt înlocuite cu valoarea de umplere transmisă funcției până la epuizarea celei mai lungi iterabile.
import itertools
names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]
# Combine name and ages, filling in missing ages with a dash
combined = itertools.zip_longest(names, ages, fillvalue="-")
for name, age in combined:
print(name, age)
Ieșire:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Concluzie
Python itertools sunt un set de instrumente important pentru un dezvoltator Python. Instrumentele itertool Python sunt utilizate pe scară largă în programarea funcțională, procesarea și transformarea datelor, filtrarea și selecția datelor, gruparea și agregarea, combinând iterabile, combinatorice și atunci când lucrați cu secvențe infinite.
În calitate de dezvoltator Python, veți beneficia foarte mult învățând despre itertools, așa că asigurați-vă că utilizați acest articol pentru a vă familiariza cu Python Itertools.