accumulate()
itertools.accumulate(iterable)
Diese Funktion erzeugt einen Iterator, der die Ergebnisse einer Funktion zurückgibt. Funktionen können ähnlich wie Variablen herumgereicht werden. Die accumulate() Funktion nimmt eine Funktion als Argument. Sie nimmt auch eine Iterable an. Sie gibt die akkumulierten Ergebnisse zurück. Die Ergebnisse sind selbst in einer Iterable enthalten. Das mag alles sehr verwirrend klingen. Ich versichere Ihnen, wenn Sie mit dem Code spielen, wird es Sinn machen.
Code
data = result = itertools.accumulate(data, operator.mul)
for each in result:
print(each)
Ausgabe
1
2
6
24
120
Der Operator.mul nimmt zwei Zahlen und multipliziert sie.
operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120
In diesem nächsten Beispiel wird die Funktion max verwendet.
Code
data = result = itertools.accumulate(data, max)
for each in result:
print(each)
Ausgabe
5
5
6
6
6
9
9
Die max Funktion gibt das größte Element zurück.
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
Die Übergabe einer Funktion ist optional.
Code
data = result = itertools.accumulate(data)
for each in result:
print(each)
Ausgabe
5
7
13
17
22
31
32
Wenn keine Funktion angegeben wird, werden die Elemente summiert.
5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32
Kombinationen()
itertools.combinations(iterable, r)
Diese Funktion nimmt eine Iterable und eine Ganzzahl. Damit werden alle eindeutigen Kombinationen erstellt, die r Mitglieder haben.
Code
shapes = result = itertools.combinations(shapes, 2)for each in result:
print(each)
In diesem Code werden alle Combos mit 2 Mitgliedern erstellt.
Output
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')
Code
shapes = result = itertools.combinations(shapes, 3)for each in result:
print(each)
In diesem Code machen wir alle Combos mit 3Mitgliedern. Es ist etwas weniger aufregend.
Ausgabe
('circle', 'triangle', 'square')
Kombinationen_mit_Ersetzung()
itertools.combinations_with_replacement(iterable, r)
Dies ist genau wie die combinations()-Funktion, aber hier können einzelne Elemente mehrfach wiederholt werden.
Code
shapes = result = itertools.combinations_with_replacement(shapes, 2)
for each in result:
print(each)
Ausgabe
('circle', 'circle')
('circle', 'triangle')
('circle', 'square')
('triangle', 'triangle')
('triangle', 'square')
('square', 'square')
count()
itertools.count(start=0, step=1)
Erzeugt einen Iterator, der gleichmäßig verteilte Werte zurückgibt, beginnend mit der Nummer start.
Code
for i in itertools.count(10,3):
print(i)
if i > 20:
break
Im obigen Code iterieren oder schleifen wir über eine Funktion. Wir sagen der Funktion, dass sie bei 10 beginnen und 3 Schritte machen soll.
Ausgabe
10
13
16
19
22
Diese erste Iteration hat den Wert 10. Im nächsten Schritt gehen wir einen Schritt weiter oder addieren 3. Dies hat den Wert 13. Das Gleiche machen wir bei der nächsten Iteration und erhalten den Wert 16. Das würde ewig so weitergehen, aber wir haben eine Pause eingefügt.
cycle()
itertools.cycle(iterable)
Diese Funktion durchläuft einen Iterator endlos.
Code
colors = for color in itertools.cycle(colors):
print(color)
Im obigen Code erstellen wir eine Liste. Dann durchlaufen wir diese Liste in einem Zyklus oder einer Schleife endlos. Normalerweise geht eine for-Schleife durch eine Iterable, bis sie das Ende erreicht hat. Wenn eine Liste 3 Elemente hat, wird die Schleife 3 Mal iterieren. Aber nicht, wenn wir die cycle() Funktion verwenden. Mit dieser Funktion fangen wir, wenn wir das Ende der Iterable erreichen, wieder von vorne an.
Ausgabe
red
orange
yellow
green
blue
indigo
violet
red
orange
yellow
green
...
Ich habe die endlose Ausgabe oben mit Ellipsen abgeschnitten.
chain()
itertools.chain(*iterables)
Diese Funktion nimmt eine Reihe von Iterablen und gibt sie als eine lange Iterable zurück.
Code
colors =
shapes = result = itertools.chain(colors, shapes)
for each in result:
print(each)
Ausgabe
red
orange
yellow
green
blue
circle
triangle
square
pentagon
compress()
itertools.compress(data, selectors)
Diese Funktion filtert eine Iterable mit einer anderen.
Code
shapes =
selections = result = itertools.compress(shapes, selections)
for each in result:
print(each)
Ausgabe
circle
square
dropwhile()
itertools.dropwhile(predicate, iterable)
Erzeuge einen Iterator, der Elemente aus der Iterable fallen lässt, solange das Prädikat wahr ist; Danach gibt er jedes Element zurück.
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. Das kann verwirrend sein. Der Code sagt, dass jedes Element fallen gelassen werden soll, solange das Element kleiner als 5 ist. Nachdem er auf ein Element stößt, das nicht kleiner als 5 ist, gibt er den Rest zurück. Deshalb wird das letzte zurückgegeben.
Schrittweise
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)
Diese Funktion erzeugt einen Iterator, der Elemente aus iterable filtert und nur die zurückgibt, für die das Prädikat False lautet.
Code
data =
result = itertools.filterfalse(lambda x: x<5, data)
for each in result:
print(each)
Ausgabe
5
6
7
8
9
10
Schritt für Schritt
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)
Einfach gesagt, diese Funktion gruppiert Dinge zusammen. Ok. Diese hier ist kompliziert. Und das Beispiel ist ein bisschen lang.
Code
robots = for key, group in itertools.groupby(bots, key=lambda x: x):
print(key)
print(list(group))
Ausgabe
autobot
decepticon
islice()
itertools.islice(iterable, start, stop)
Diese Funktion ist sehr ähnlich wie Slices. Mit dieser Funktion können Sie ein Stück aus einer Iterable ausschneiden.
Code
colors =
few_colors = itertools.islice(colors, 2)
for each in few_colors:
print(each)
Ausgabe
red
orange
Permutationen()
itertools.permutations(iterable, r=None)
Code
alpha_data = result = itertools.permutations(alpha_data)
for each in result:
print(each)
Ausgabe
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
product()
Diese Funktion erzeugt die kartesischen Produkte aus einer Reihe von Iterablen.
Code
num_data =
alpha_data = result = itertools.product(num_data, alpha_data)
for each in result:
print(each)
Ausgabe
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
Stellen Sie sich eine Tabelle wie folgt vor:
a b c
1 a1 b1 c1
2 a2 b2 c3
3 a3 b3 b3
repeat()
itertools.repeat(object)
Mit dieser Funktion wird ein Objekt immer wieder wiederholt. Es sei denn, es gibt ein times Argument.
Code
for i in itertools.repeat("spam"):
print(i)
Im obigen Code erzeugen wir eine Iterable, die einfach spam immer wieder wiederholt. Es wird dies endlos tun. So entsteht ein unendliches spam.
Ausgabe
spam
spam
spam
spam
spam
spam
...
Ich habe die endlose Ausgabe oben mit Ellipsen abgeschnitten.
Code
for i in itertools.repeat("spam", 3):
print(i)
Wenn wir das Argument times verwenden, können wir die Anzahl der Wiederholungen begrenzen.
Ausgabe
spam
spam
spam
In diesem Beispiel wiederholt sich spam nur dreimal.
starmap()
itertools.starmap(function, iterable)
Diese Funktion erzeugt einen Iterator, der die Funktion mit Hilfe von Argumenten aus der Iterable berechnet. Schauen wir uns das mal an.
Code
data =
result = itertools.starmap(operator.mul, data)
for each in result:
print(each)
Ausgabe
12
32
21
Schrittweise durch
operator.mul(2, 6)
12
operator.mul(8, 4)
32
operator.mul(7, 3)
21
takewhile()
itertools.takwwhile(predicate, iterable)
Dies ist sozusagen das Gegenteil von dropwhile(). Diese Funktion erzeugt einen Iterator und gibt Elemente aus dem Iterable zurück, solange das Prädikat wahr ist.
Code
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Ausgabe
1
2
3
4
Schrittweise durch
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)
Rückgabe von n unabhängigen Iteratoren aus einer einzigen 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)
Die Vorgabe ist 2, aber Sie können so viele machen, wie Sie brauchen.
Ausgabe
red
orange
yellow
green
blue
..
red
orange
yellow
green
blue
zip_longest()
itertools.zip_longest(*iterables, fillvalue=None)
Diese Funktion erzeugt einen Iterator, der Elemente aus jeder der Iterablen zusammenfasst. Wenn die Iterablen eine ungerade Länge haben, werden fehlende Werte mit fillvalue aufgefüllt. Die Iteration wird fortgesetzt, bis die längste Iterabel erschöpft ist.
Code
colors =
data = for each in itertools.zip_longest(colors, data, fillvalue=None):
print(each)
Ausgabe
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)