Према Питхоновој документацији, Итертоолс је Питхон модул који пружа скуп брзих и меморијско ефикасних алата за рад са Питхон итераторима. Ови алати се могу користити сами или у комбинацији, и они омогућавају сажето и ефикасно креирање и рад са итераторима на брз и меморијски ефикасан начин.
Модул Итертоолс садржи функције које олакшавају рад са итераторима, посебно када се рукује великим скуповима података. Функције Итертоолс могу да раде на постојећим итераторима да би креирале још сложеније Питхон итераторе.
Поред тога, Итертоолс може помоћи програмерима да смање грешке при раду са итераторима и напишу чистији, читљивији и одржаван код.
На основу функционалности коју итератори у модулу Итертоолс пружају, могу се класификовати у следеће типове:
Преглед садржаја
#1. Бесконачни итератори
Ово су итератори који вам омогућавају да радите са бесконачним низовима и бесконачно изводите петљу ако није стављен услов за излазак из петље. Такви итератори су корисни када се симулирају бесконачне петље или генеришу неограничени низ. Итертоолс има три бесконачна итератора, који укључују цоунт(), цицле() и репеат().
#2. Комбинаторски итератори
Комбинаторски итератори обухватају функције које се могу користити за рад на картезијанским производима и извођење комбинација и пермутација елемената садржаних у итерабле. Ово су функције које се користе када покушавате да пронађете све могуће начине да уредите или комбинујете елементе у итерабле. Итертоолс има четири комбинаторичка итератора. То су производ(), пермутације(), комбинације() и комбинације_са_заменом().
#3. Итератори завршавају на најкраћем улазном низу
Ово су завршни итератори који се користе на коначним секвенцама и генеришу излаз на основу типа функције која се користи. Примери ових завршних итератора укључују: акумулирати(), цхаин(), цхаин.фром_итерабле(), цомпресс(), дропвхиле(), филтерфалсе(), гроупби(), ислице(), паирвисе(), стармап(), такевхиле (), тее() и зип_лонгест().
Хајде да погледамо како различите функције Итертоолс функционишу према њиховом типу:
Бесконачни итератори
Три бесконачна итератора укључују:
#1. цоунт()
Функција цоунт(старт, степ) генерише бесконачан низ бројева почевши од почетне вредности. Функција узима два опциона аргумента: старт и степ. Аргумент старт поставља где треба да почне низ бројева. Подразумевано, почиње од 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. циклус()
Цицле(итерабле) функција узима итерабле као аргумент, а затим кружи кроз итерабле омогућавајући приступ ставкама у итерабле редоследу којим се појављују.
На пример, ако прођемо [“red”, “green”, “yellow”] у циклус(), у првом циклусу, имаћемо приступ „црвеном”; у другом циклусу ћемо имати приступ „зеленом“, па „жутом“. У четвртом циклусу, пошто су сви елементи исцрпљени у итерабле-у, почећемо испочетка од „црвеног“, а затим наставити бесконачно.
Када позивате циклус() његов резултат чувате у променљивој да бисте креирали итератор који одржава његово стање. Ово осигурава да циклус не почиње сваки пут изнова, дајући вам приступ само првом елементу.
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. понављање()
репеат(елем,н) узима два аргумента, елемент за понављање (елем) и колико пута желите да поновите елемент(н). Елемент који желите да поновите може бити једна вредност или итерабле. Ако не прођете, н, елемент ће се понављати бесконачно.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Излаз:
10 10 10
Комбинаторски итератори
Комбинаторски итератори укључују:
#1. производ()
продуцт() је функција која се користи за израчунавање картезијанског производа итеративног елемента који му је прослеђен. Ако имамо два итерабле или скупа, на пример, к = {7,8} и и = {1,2,3}, картезијански производ к и и ће садржати све могуће комбинације елемената из к и и, где је први елемент је из к, а други из и. Декартов производ к и и у овом случају је [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
продуцт() узима опциони параметар који се зове понављање који се користи за израчунавање картезијанског производа итерабле са самим собом. репеат специфицира број понављања за сваки елемент из улазних итераблеа приликом израчунавања картезијанског производа.
На пример, позивање продуцт(‘АБЦД’, репеат=2) даје комбинације као што су (‘А’, ‘А’), (‘А’, ‘Б’), (‘А’, ‘Ц’), и тако на. Ако је понављање постављено на 3, функција би дала комбинације као што су (‘А’, ‘А’, ‘А’), (‘А’, ‘А’, ‘Б’), (‘А’, ‘А’ , ‘Ц’), (‘А’, ‘А’, ‘Д’) и тако даље.
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. пермутације()
пермутатионс(итерабле, гроуп_сизе) враћа све могуће пермутације итерабле који је прослеђен у њега. Пермутација представља број начина на које се елементи у скупу могу наручити. пермутатионс() узима опциони аргумент величина_групе. Ако гроуп_сизе није наведена, генерисане пермутације ће бити исте величине као дужина итерабле прослеђеног у функцију
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 пермутација: АБ, АЦ, БА, БЦ, ЦА, ЦБ али само 3 комбинације АБ, АЦ, БЦ.
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. комбинације_са_заменом()
Комбинације_са_реплацементом(итерабле, сизе) генерише све могуће комбинације итерабле дате дужине из итерабле прослеђеног у функцију и дозвољава понављање елемената у излазним комбинацијама. Величина одређује величину генерисаних комбинација.
Ова функција се разликује од комбинације() по томе што даје комбинације у којима се елемент може поновити више пута. На пример, можете добити комбинацију као што је (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. акумулирати()
акумулирати(итерабле, фунцтион) узима итерабле и други опциони аргумент који је функција. Затим враћа акумулирани резултат примене функције у свакој итерацији на елементе на итерабле. Ако ниједна функција није прослеђена, врши се сабирање и акумулирани резултати се враћају.
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. ланац()
цхаин(итерабле_1, итерабле_2, …) узима вишеструке итерабле и повезује их заједно стварајући један итерабле који садржи вредности из итерабле које се прослеђују функцији цхаин()
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. цхаин.фром_итерабле()
цхаин.фром_итерабле(итерабле) ова функција је слична цхаин(). Међутим, разликује се од ланца по томе што узима само један итерабле који садржи под-итерабле и повезује их заједно.
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. стиснути ()
цомпресс(подаци, селектори) узима два аргумента, податке који су итеративни и селектори који су итеративни који садрже логичке вредности труе и фалсе. 1, 0 се такође могу користити као алтернативе логичким вредностима труе и фалсе. цомпресс() затим филтрира прослеђене податке користећи одговарајуће елементе прослеђене у селектору.
Вредности у подацима које одговарају вредности труе или 1 у селектору се бирају, док се остале које одговарају вредности фалсе или 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. дропвхиле()
дропвхиле(функција, секвенца) преузима функцију са условом који враћа тачно или нетачно и низ вредности. Затим испушта све вредности све док прослеђени услов не врати Фалсе. Када услов врати нетачно, остали елементи су укључени у његове резултате без обзира да ли би вратили Тачно или Нетачно.
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. филтерфалсе()
филтерфалсе(функција, секвенца) преузима функцију, са условом који процењује на тачно или нетачно и низ. Затим враћа вредности из низа које не задовољавају услов у функцији.
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. група од()
гроупби(итерабле, кеи) узима итерабле и кључ, а затим прави итератор који враћа узастопне кључеве и групе. Да би функционисао, итерабле који му је прослеђен треба да буде сортиран на истој функцији кључа. Рачунар функције кључа је кључна вредност за сваки елемент у итерабле.
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. ислице()
ислице(итерабле, старт, стоп, степ) вам омогућава да исечете итерабле користећи прослеђене вредности почетка, заустављања и корака. Аргумент корак је опциони. Бројање почиње од 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. у пару()
паирвисе(итерабле) враћа узастопне парове који се преклапају преузете из итерабле који му је прослеђен редоследом којим се појављују у итерабле. Ако итерабле који му је прослеђен има мање од две вредности, резултат из паирвисе() ће бити празан.
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. стармап()
стармап(фунцтион, итерабле) је функција која се користи уместо мап() када су параметри аргумената већ груписани у тупле. стартмап() примењује функцију на елементе итерабле који су јој прослеђени. Итерабле треба да има елементе груписане у тупле.
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. узми ()
такевхиле(функција, итерабле) ради на супротан начин од дропвхиле(). такевхиле() преузима функцију са условом за процену и итерабле. Затим укључује све елементе у итерабле који задовољавају услов у функцији док се не врати Фалсе. Када се врати Фалсе, сви следећи елементи у итерабле се занемарују.
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. мајица ()
тее(итерабле, н) узима итерабле и враћа више независних итератора. Број итератора за враћање је постављен са н, што је подразумевано 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. зип_лонгест()
зип_лонгест(итераблес, филлвалуе) узима више итератора и филлвалуе. Затим враћа итератор који агрегира елементе из сваког од итератора који су му прослеђени. Ако итератори нису исте дужине, вредности које недостају се замењују вредностима попуњавања које се прослеђују функцији док се не исцрпи најдужи итерабле.
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 -
Закључак
Питхон итертоолс су важан скуп алата за Питхон програмере. Питхон итертоолс се у великој мери користи у функционалном програмирању, обради података и трансформацији, филтрирању и селекцији података, груписању и агрегацији, комбиновању итерабле, комбинаторици и када се ради са бесконачним низовима.
Као програмер Питхон-а, имаћете велику корист од учења о итертоолс-у, па обавезно користите овај чланак да бисте се упознали са Питхон-овим Итертоол-има.