Според документацията на Python, Itertools е модул на Python, който предоставя набор от бързи и ефективни от паметта инструменти за работа с итератори на Python. Тези инструменти могат да се използват самостоятелно или в комбинация и правят възможно кратко и ефективно създаване и работа с итератори по бърз и ефективен от паметта начин.
Модулът Itertools съдържа функции, които улесняват работата с итератори, особено при работа с големи набори от данни. Функциите на Itertools могат да работят върху съществуващи итератори, за да създадат още по-сложни итератори на Python.
Освен това Itertools може да помогне на разработчиците да намалят грешките при работа с итератори и да пишат по-чист, четим и поддържаем код.
Въз основа на функционалността, която итераторите в модула Itertools предоставят, те могат да бъдат класифицирани в следните типове:
Съдържание
#1. Безкрайни итератори
Това са итератори, които ви позволяват да работите с безкрайни последователности и да изпълнявате безкрайно цикъл, ако няма поставено условие за излизане от цикъла. Такива итератори са полезни при симулиране на безкрайни цикли или генериране на неограничена последователност. Itertools има три безкрайни итератора, които включват count(), cycle() и repeat().
#2. Комбинаторни итератори
Комбинаторните итератори съдържат функции, които могат да се използват за работа върху декартови продукти и извършване на комбинации и пермутации на елементи, съдържащи се в итерируем. Това са основните функции, когато се опитвате да намерите всички възможни начини за подреждане или комбиниране на елементи в итерируем. Itertools има четири комбинаторни итератора. Това са продукт(), пермутации(), комбинации() и комбинации_с_замяна().
#3. Итератори, завършващи на най-късата входна последователност
Това са терминиращи итератори, които се използват върху крайни последователности и генерират изход въз основа на типа на използваната функция. Примери за тези завършващи итератори включват: collecte(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile (), tee() и zip_longest().
Нека да разгледаме как работят различните функции на Itertools според техния тип:
Безкрайни итератори
Трите безкрайни итератора включват:
#1. броя()
Функцията count(start, step) генерира безкрайна последователност от числа, започвайки от началната стойност. Функцията приема два незадължителни аргумента: начало и стъпка. Аргументът начало задава къде трябва да започне поредицата от числа. По подразбиране започва от 0, ако не е предоставена начална стойност. стъпка задава разликата между всяко поредно число. Стойността на стъпката по подразбиране е 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
Изход
4 6 8 10 12
#2. цикъл()
функцията cycle(iterable) приема итерируем като аргумент и след това преминава през итерируемия, позволявайки достъп до елементите в итерируемия в реда, в който се появяват.
Например, ако минем [“red”, “green”, “yellow”] в cycle(), в първия цикъл ще имаме достъп до „червено“; във втория цикъл ще имаме достъп до „зелено“, след това до „жълто“. В четвъртия цикъл, тъй като всички елементи са изчерпани в итерируемия, ще започнем отначало от „червено“ и след това ще продължим безкрайно.
Когато извиквате cycle(), вие съхранявате неговия резултат в променлива, за да създадете итератор, който поддържа неговото състояние. Това гарантира, че цикълът не започва отначало всеки път, като ви дава достъп само до първия елемент.
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))
Изход:
red green yellow red green yellow red
#3. повторение()
repeat(elem,n) приема два аргумента, елемент за повторение (elem) и броя пъти, които искате да повторите елемента(n). Елементът, който искате да повторите, може да бъде единична стойност или итерируем. Ако не подадете n, елементът ще се повтаря безкрайно.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Изход:
10 10 10
Комбинаторни итератори
Комбинаторните итератори включват:
#1. продукт()
product() е функция, използвана за изчисляване на декартовото произведение на итерируемото, което му се предава. Ако имаме две итерируеми или набори, например x = {7,8} и y = {1,2,3}, декартовото произведение на x и y ще съдържа всички възможни комбинации от елементи от x и y, където първият елемент е от x, а вторият от y. Декартовото произведение на x и y в този случай е [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() приема незадължителен параметър, наречен repeat, който се използва за изчисляване на декартовия продукт на итерируем със себе си. repeat указва броя на повторенията за всеки елемент от входните итерируеми елементи при изчисляване на декартовия продукт.
Например извикването на product(‘ABCD’, repeat=2) дава комбинации като (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’) и т.н. На. Ако повторението е зададено на 3, функцията ще даде комбинации като (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’ , ‘C’), (‘A’, ‘A’, ‘D’) и т.н.
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])))
Изход
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. пермутации()
permutations(iterable, group_size) връща всички възможни пермутации на iterable, предадени в него. Пермутацията представлява броя на начините, по които елементите в набор могат да бъдат подредени. permutations() приема незадължителен аргумент group_size. Ако group_size не е посочен, генерираните пермутации ще бъдат със същия размер като дължината на итерируемия, подадена във функцията
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)
Изход
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. комбинации()
комбинации (итерируем, размер) връща всички възможни комбинации на итерируем с дадена дължина от елементите в итерируемия, предадени във функцията. Аргументът размер определя размера на всяка комбинация.
Резултатите са подредени. Комбинацията се различава леко от пермутациите. При пермутацията редът има значение, но при комбинацията редът няма значение. Например, в [A, B, C] има 6 пермутации: AB, AC, BA, BC, CA, CB, но само 3 комбинации 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)
Изход:
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. комбинации_със_замяна()
combinations_with_replacement(iterable, size) генерира всички възможни комбинации от итерируем с дадена дължина от итерируемия, прехвърлен във функцията и позволява повтарящи се елементи в изходните комбинации. Размерът определя размера на генерираните комбинации.
Тази функция се различава от комбинации() по това, че дава комбинации, при които даден елемент може да се повтори повече от веднъж. Например, можете да получите комбинация като (1,1), която не можете с комбинация().
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)
Изход
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)]
Прекратяващи итератори
Това включва итератори като:
#1. натрупвам()
collect(iterable, function) приема итерируем и втори незадължителен аргумент, който е функция. След това връща натрупания резултат от прилагането на функцията във всяка итерация върху елементи на итерируемия. Ако не бъде подадена функция, добавянето се извършва и натрупаните резултати се връщат.
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))
Изход:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. верига()
chain(iterable_1, iterable_2, …) взема множество итерируеми и ги свързва вериги заедно, създавайки един итерируем, съдържащ стойности от итерируемите, предадени на функцията 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)
Изход:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) тази функция е подобна на chain(). Въпреки това, той се различава от веригата по това, че взема само един итерируем елемент, съдържащ под-итератори, и ги свързва във вериги.
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)
Изход:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. компрес ()
компресиране (данни, селектори) приема два аргумента, данни, които са итерируеми, и селектори, които са итерируеми, съдържащи булеви стойности true и false. 1, 0 също могат да се използват като алтернативи на булевите стойности true и false. compress() след това филтрира предадените данни, като използва съответните елементи, предадени в селектора.
Стойностите в данните, които съответстват на стойността true или 1 в селектора, се избират, докато останалите, които отговарят на false или 0, се игнорират. Ако подадете по-малко булеви стойности в селекторите от броя на елементите в данните, всички елементи извън предадените булеви стойности в селекторите се игнорират
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)
Изход:
['A', 'C', 'F', 'G', 'I']
#5. капка ()
dropwhile(функция, последователност) приема функция с условието, което връща true или false и последователност от стойности. След това премахва всички стойности, докато преминатото условие върне False. След като условието върне false, останалите елементи се включват в неговите резултати, независимо дали биха върнали True или False.
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)
Изход:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filterfalse()
filterfalse(функция, последователност) приема функция с условие, което се оценява на true или false и последователност. След това връща стойности от последователността, които не отговарят на условието във функцията.
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)
Изход:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. Групирай по()
groupby(iterable, key) приема итерируем и ключ, след което прави итератор, който връща последователни ключове и групи. За да работи, предаваният към него итерируем елемент трябва да бъде сортиран по същата ключова функция. Ключовата функция компютър ключова стойност за всеки елемент в итерируемия.
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))
Изход:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice(iterable, start, stop, step) ви позволява да разделите итерируем, като използвате предадените стойности за начало, стоп и стъпка. Аргументът стъпка не е задължителен. Броенето започва от 0 и елементът на номера на стоп не се включва.
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)
Изход:
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. по двойки()
pairwise(iterable) връща последователни припокриващи се двойки, взети от iterable, предадени му в реда, в който се появяват в iterable. Ако предаденият му итерируем елемент има по-малко от две стойности, резултатът от pairwise() ще бъде празен.
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)))
Изход:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. звездна карта ()
starmap(function, iterable) е функция, използвана вместо map(), когато параметрите на аргумента вече са групирани в кортежи. startmap() прилага функция към елементите на iterable, предадени му. Итерируемият трябва да има елементи, групирани в кортежи.
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)))
Изход:
[13, 5, 9, 16, 11]
#11. отнеме ()
takewhile(function, iterable) работи по обратния начин на dropwhile(). takewhile() приема функция с условие, което трябва да бъде оценено и итерируема. След това включва всички елементи в итерируемия, които отговарят на условието във функцията, докато не бъде върнато False. След като се върне False, всички следващи елементи в итерируемия се игнорират.
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)
Изход:
[1, 2, 3, 4]
#12. тениска()
tee(iterable, n) приема итерируем и връща множество независими итератори. Броят на итераторите за връщане се задава от n, което по подразбиране е 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))
Изход:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) приема множество итератори и fillvalue. След това връща итератор, който агрегира елементи от всеки от предадените му итератори. Ако итераторите не са с еднаква дължина, липсващите стойности се заместват от стойността за запълване, предадена на функцията, докато най-дългият итератор не бъде изчерпан.
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)
Изход:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Заключение
Python itertools са важен набор от инструменти за разработчик на Python. Python itertools се използват широко във функционално програмиране, обработка на данни и трансформация, филтриране и селекция на данни, групиране и агрегиране, комбиниране на итерируеми елементи, комбинаторика и при работа с безкрайни последователности.
Като разработчик на Python ще имате голяма полза, като научите за itertools, така че не забравяйте да използвате тази статия, за да се запознаете с Python Itertools.