accumulate()
itertools.accumulate(iterable)
Deze functie maakt een iterator die de resultaten van een functie teruggeeft. Functies kunnen net als variabelen worden doorgegeven. De accumulate() functie neemt een functie als argument. Hij neemt ook een iterabel. Het geeft de geaccumuleerde resultaten terug. De resultaten zelf zitten in een iterable. Dit klinkt misschien allemaal erg verwarrend. Ik verzeker u dat, wanneer u met de code speelt, het logisch zal zijn.
Code
data = result = itertools.accumulate(data, operator.mul)
for each in result:
print(each)
Output
1
2
6
24
120
De operator.mul neemt twee getallen en vermenigvuldigt ze.
operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120
In dit volgende voorbeeld zal de max functie gebruikt worden.
Code
data = result = itertools.accumulate(data, max)
for each in result:
print(each)
Output
5
5
6
6
6
9
9
De max functie geeft het grootste item terug.
5
max(5, 2)
5
max(5, 6)
6
max(6, 4)
6
max(6, 5)
6
max(6, 9)
9
max(9, 1)
9
Het opgeven van een functie is optioneel.
Code
data = result = itertools.accumulate(data)
for each in result:
print(each)
Uitvoer
5
7
13
17
22
31
32
Als er geen functie wordt aangewezen, worden de items bij elkaar opgeteld.
5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32
combinaties()
itertools.combinations(iterable, r)
Deze functie neemt een iterable en een geheel getal. Hiermee worden alle unieke combinatie gemaakt die r leden hebben.
Code
shapes = result = itertools.combinations(shapes, 2)for each in result:
print(each)
In deze code maken we alle combo’s met 2 leden.
Output
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')
Code
shapes = result = itertools.combinations(shapes, 3)for each in result:
print(each)
In deze code maken we alle combo’s met 3 leden. Het is iets minder spannend.
Uitvoer
('circle', 'triangle', 'square')
combinaties_met_vervanging()
itertools.combinations_with_replacement(iterable, r)
Deze is net als de combinations() functie, maar deze staat toe dat individuele elementen meer dan eens herhaald kunnen worden.
Code
shapes = result = itertools.combinations_with_replacement(shapes, 2)
for each in result:
print(each)
Output
('circle', 'circle')
('circle', 'triangle')
('circle', 'square')
('triangle', 'triangle')
('triangle', 'square')
('square', 'square')
count()
itertools.count(start=0, step=1)
Maakt een iterator die gelijkmatig verdeelde waarden teruggeeft, beginnend met nummer start.
Code
for i in itertools.count(10,3):
print(i)
if i > 20:
break
In de bovenstaande code itereren of lussen we over een functie. We vertellen de functie om te beginnen bij 10 en stap 3.
Output
10
13
16
19
22
Deze eerste iteratie heeft de waarde 10. In de volgende stap doen we er 3 bij. Dit heeft de waarde 13. We doen hetzelfde voor de volgende iteratie en krijgen een waarde van 16. Dit zou eindeloos doorgaan, maar we hebben een pauze toegevoegd.
cycle()
itertools.cycle(iterable)
Deze functie doorloopt een iterator eindeloos.
Code
colors = for color in itertools.cycle(colors):
print(color)
In de bovenstaande code maken we een lijst. Vervolgens lopen we eindeloos door deze lijst. Normaal gesproken doorloopt een for lus een iterable tot het einde is bereikt. Als een lijst 3 items heeft, zal de lus 3 keer itereren. Maar niet als we de cycle() functie gebruiken. Met deze functie beginnen we weer van voren af aan als we het einde van de iterable hebben bereikt.
Uitvoer
red
orange
yellow
green
blue
indigo
violet
red
orange
yellow
green
...
Ik heb de eindeloze uitvoer hierboven afgekapt met ellipsen.
chain()
itertools.chain(*iterables)
Deze functie neemt een serie iterables en geeft ze als één lange iterable terug.
Code
colors =
shapes = result = itertools.chain(colors, shapes)
for each in result:
print(each)
Output
red
orange
yellow
green
blue
circle
triangle
square
pentagon
compress()
itertools.compress(data, selectors)
Deze functie filtert de ene iterable met de andere.
Code
shapes =
selections = result = itertools.compress(shapes, selections)
for each in result:
print(each)
Output
circle
square
dropwhile()
itertools.dropwhile(predicate, iterable)
Maak een iterator die elementen uit de iterable laat vallen zolang het predicaat waar is; en daarna elk element teruggeeft.
Code
data = result = itertools.dropwhile(lambda x: x<5, data)
for each in result:
print(each)
Output
5
6
7
8
9
10
1
Ok. Dit kan verwarrend zijn. De code zegt elk item te laten vallen zolang het item kleiner is dan 5. Nadat het een item tegenkomt dat niet kleiner is dan 5, geeft het de rest terug. Daarom wordt dat laatste item teruggegeven.
Doorlopen
1 < 5: True, drop
2 < 5: True, drop
3 < 5: True, drop
4 < 5: True, drop
5 < 5: False, return surviving items
filterfalse()
itertools.filterfalse(predicate, iterable)
Deze functie maakt een iterator die elementen uit de iterable filtert en alleen die teruggeeft waarvoor het predicaat False is.
Code
data =
result = itertools.filterfalse(lambda x: x<5, data)
for each in result:
print(each)
Output
5
6
7
8
9
10
Stap er doorheen
1 < 5: True, drop
2 < 5: True, drop
3 < 5: True, drop
4 < 5: True, drop
5 < 5: False, keep
6 < 5: False, keep
7 < 5: False, keep
8 < 5: False, keep
9 < 5: False, keep
10 < 5: False, keep
groupby()
itertools.groupby(iterable, key=None)
Eenvoudig gezegd, deze functie groepeert dingen. Ok. Deze is ingewikkeld. En het voorbeeld is een beetje lang.
Code
robots = for key, group in itertools.groupby(bots, key=lambda x: x):
print(key)
print(list(group))
Output
autobot
decepticon
islice()
itertools.islice(iterable, start, stop)
Deze functie lijkt erg veel op slices. Met deze functie kun je een stuk uit een iterable knippen.
Code
colors =
few_colors = itertools.islice(colors, 2)
for each in few_colors:
print(each)
Output
red
orange
permutaties()
itertools.permutations(iterable, r=None)
Code
alpha_data = result = itertools.permutations(alpha_data)
for each in result:
print(each)
Output
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
product()
Deze functie maakt de cartesische producten van een reeks iterabelen.
Code
num_data =
alpha_data = result = itertools.product(num_data, alpha_data)
for each in result:
print(each)
Output
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
Stel je een tabel als volgt voor:
a b c
1 a1 b1 c1
2 a2 b2 c3
3 a3 b3 b3
repeat()
itertools.repeat(object)
Deze functie zal een object steeds opnieuw herhalen. Tenzij er een times argument is.
Code
for i in itertools.repeat("spam"):
print(i)
In de bovenstaande code maken we een iterable die gewoon spam keer op keer herhaalt. Het zal dit eindeloos doen. Zo wordt oneindig spam gemaakt.
Uitvoer
spam
spam
spam
spam
spam
spam
...
Ik heb de eindeloze uitvoer hierboven afgekapt met ellipsen.
Code
for i in itertools.repeat("spam", 3):
print(i)
Als we het times argument gebruiken, kunnen we het aantal keren dat het zich zal herhalen beperken.
Uitvoer
spam
spam
spam
In dit voorbeeld herhaalt spam zich maar drie keer.
starmap()
itertools.starmap(function, iterable)
Deze functie maakt een iterator die de functie berekent met argumenten die uit de iterable worden verkregen. Laten we eens een kijkje nemen.
Code
data =
result = itertools.starmap(operator.mul, data)
for each in result:
print(each)
Output
12
32
21
Step Through
operator.mul(2, 6)
12
operator.mul(8, 4)
32
operator.mul(7, 3)
21
takewhile()
itertools.takwwhile(predicate, iterable)
Dit is een beetje het tegenovergestelde van dropwhile(). Deze functie maakt een iterator en retourneert elementen uit de iterable zolang het predicaat waar is.
Code
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Output
1
2
3
4
Step Through It
1 < 5: True, keep going
2 < 5: True, keep going
3 < 5: True, keep going
4 < 5: True, keep going
5 < 5: False, stop and drop
tee()
itertools.tee(iterable, n=2)
Return n onafhankelijke iterators van een enkele iterable.
Code
colors =
alpha_colors, beta_colors = itertools.tee(colors)for each in alpha_colors:
print(each)print('..')for each in beta_colors:
print(each)
De standaardwaarde is 2, maar je kunt er zo veel maken als nodig is.
Output
red
orange
yellow
green
blue
..
red
orange
yellow
green
blue
zip_longest()
itertools.zip_longest(*iterables, fillvalue=None)
Deze functie maakt een iterator die elementen van elk van de iterables bij elkaar optelt. Als de iterabelen van ongelijke lengte zijn, worden ontbrekende waarden opgevuld met fillvalue. De iteratie gaat door tot de langste iterable is uitgeput.
Code
colors =
data = for each in itertools.zip_longest(colors, data, fillvalue=None):
print(each)
Output
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)