class Countdown:
def __init__(self, start):
self.start = start
def __iter__(self):
return self
def __next__(self):
if self.start <= 0:
raise StopIteration
self.start -= 1
return self.start + 1
# Create a custom iterator
countdown = Countdown(5)
# Use the iter() function to get the iterator object
countdown_iterator = iter(countdown)
# Use the next() function to iterate over the custom iterator
print(next(countdown_iterator))
print(next(countdown_iterator))
print(next(countdown_iterator))
# Iterate over the custom iterator using a for loop
for number in Countdown(3):
print(number)In diesem Beispiel haben wir eine benutzerdefinierte Klasse
Countdown erstellt, die das Iterator-Protokoll
implementiert. Die Klasse enthält die Methoden __iter__ und
__next__, die für das Iterator-Protokoll erforderlich sind.
Die __iter__-Methode gibt das Iterator-Objekt zurück, in
diesem Fall self. Die __next__-Methode gibt
das nächste Element in der Sequenz zurück oder wirft eine
StopIteration-Ausnahme, wenn keine weiteren Elemente
vorhanden sind.
Wir erstellen ein Countdown-Objekt und verwenden die
iter()-Funktion, um ein Iterator-Objekt zu erhalten.
Anschließend verwenden wir die next()-Funktion, um über den
benutzerdefinierten Iterator zu iterieren. Schließlich zeigen wir, wie
man mit einer for-Schleife über den benutzerdefinierten
Iterator iteriert.
# List iterator
my_list = [1, 2, 3, 4, 5]
for item in my_list:
print(item)
# Tuple iterator
my_tuple = (6, 7, 8, 9, 10)
for item in my_tuple:
print(item)
# String iterator
my_string = "hello"
for char in my_string:
print(char)
# Dictionary iterator
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
print(key, value)
# Set iterator
my_set = {4, 5, 6, 7, 8}
for item in my_set:
print(item)
# Using enumerate() function
my_list = ['apple', 'banana', 'orange']
for index, item in enumerate(my_list):
print(index, item)
# Using zip() function
my_list1 = [1, 2, 3]
my_list2 = ['a', 'b', 'c']
for item1, item2 in zip(my_list1, my_list2):
print(item1, item2)In diesem Beispiel haben wir verschiedene Arten von Iteratoren für
Listen, Tupel, Strings, Wörterbücher und Mengen gezeigt. Wir haben auch
die enumerate()-Funktion verwendet, um sowohl den Index als
auch den Wert einer Liste zu erhalten, sowie die
zip()-Funktion, um Elemente aus zwei verschiedenen Listen
zu kombinieren.
Die items()-Methode eines Dictionaries wird verwendet,
um Schlüssel-Wert-Paare aus einem Dictionary abzurufen, während
enumerate() und zip() zur Kombination von
Elementen aus Listen oder anderen iterierbaren Objekten verwendet
werden. Die Iteratoren sind sehr nützlich, da sie es uns ermöglichen,
über die Elemente eines Objekts zu iterieren, ohne die Länge oder die
interne Implementierung des Objekts kennen zu müssen.
# Generator function
def countdown(start):
while start > 0:
yield start
start -= 1
# Use generator function to create a generator object
countdown_generator = countdown(5)
# Use a for loop to iterate over the generator
for number in countdown_generator:
print(number)
# Comparison of generators and lists
my_list = [i**2 for i in range(10)]
my_generator = (i**2 for i in range(10))
print(my_list) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(my_generator)) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Advantages of generators: memory efficiency and lazy evaluation
def fibonacci(limit):
a, b = 0, 1
while a < limit:
yield a
a, b = b, a + b
# Use a for loop to iterate over the generator
for number in fibonacci(100):
print(number)In diesem Beispiel haben wir eine Generatorfunktion
countdown erstellt, die das Schlüsselwort
yield verwendet, um ein Generatorobjekt zurückzugeben. Wir
haben dann ein Generatorobjekt countdown_generator mit der
Generatorfunktion erstellt und haben es dann mit einer for-Schleife
durchlaufen, um die Zahlen von 5 bis 1 zu drucken.
Wir haben auch den Unterschied zwischen Generatoren und Listen gezeigt. Die List comprehensions erstellen eine vollständige Liste im Speicher, während Generatoren Objekte erstellen, die nur auf Anforderung erzeugt werden, was die Speichereffizienz erhöht und eine Lazy Evaluation ermöglicht.
Schließlich haben wir die Vorteile von Generatoren hervorgehoben. Der Speicherbedarf von Generatoren ist viel geringer als der von Listen, da sie nur die aktuellen Elemente im Speicher halten und nicht die gesamte Sequenz. Generatoren ermöglichen auch eine Lazy Evaluation, bei der nur die benötigten Elemente berechnet werden, wenn sie benötigt werden, was die Geschwindigkeit erhöht und die Ressourcennutzung optimiert.
# Generator expression
my_generator = (i**2 for i in range(10))
# Use a for loop to iterate over the generator
for number in my_generator:
print(number)
# Comparison of generator expressions and list comprehensions
my_list = [i**2 for i in range(10)]
my_generator = (i**2 for i in range(10))
print(my_list) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(my_generator)) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]In diesem Beispiel haben wir die Syntax und Verwendung von Generator-Expressions gezeigt. Eine Generator-Expression ist ähnlich wie eine List Comprehension, aber anstatt eine Liste zu erstellen, erstellt sie einen Generator. Eine Generator-Expression wird in Klammern eingeschlossen und enthält eine oder mehrere Iterationsanweisungen, gefolgt von einer Ausdrucksanweisung.
Wir haben auch den Unterschied zwischen Generator-Expressions und List Comprehensions gezeigt. Generator-Expressions sind speichereffizienter als List Comprehensions, da sie nur auf Anforderung ein Element erzeugen, anstatt eine vollständige Liste im Speicher zu erstellen. In diesem Beispiel haben wir eine List Comprehension und eine Generator-Expression verwendet, um dieselben Zahlen zu generieren, und haben dann die Ergebnisse der beiden Ausdrücke verglichen, indem wir sie jeweils in eine Liste umgewandelt und ausgegeben haben.
import itertools
# Count function
for i in itertools.count(10, 2):
print(i)
if i > 20:
break
# Cycle function
my_list = [1, 2, 3]
for i in itertools.cycle(my_list):
print(i)
if i == 3:
break
# Chain function
my_list1 = [1, 2, 3]
my_list2 = ['a', 'b', 'c']
for i in itertools.chain(my_list1, my_list2):
print(i)
# islice function
for i in itertools.islice(itertools.count(), 5):
print(i)
# takewhile function
my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8]
for i in itertools.takewhile(lambda x: x < 6, my_list):
print(i)
# dropwhile function
my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8]
for i in itertools.dropwhile(lambda x: x < 6, my_list):
print(i)
# Product function
for i in itertools.product([1, 2], ['a', 'b']):
print(i)
# Permutations function
for i in itertools.permutations([1, 2, 3]):
print(i)
# Combinations function
for i in itertools.combinations([1, 2, 3], 2):
print(i)In diesem Beispiel haben wir einige häufig verwendete Funktionen aus
dem itertools-Modul gezeigt. Diese Funktionen können nützlich sein, um
iterierbare Objekte in verschiedenen Situationen zu manipulieren. Wir
haben auch die kombinatorischen Funktionen product(),
permutations() und combinations() gezeigt, die
verwendet werden können, um Kombinationen von Elementen aus iterierbaren
Objekten zu erzeugen.
Die Funktion count() erzeugt eine unendliche Sequenz von
Zahlen, während cycle() eine Sequenz von Elementen in einer
Schleife wiederholt. chain() verbindet mehrere iterierbare
Objekte zu einer einzigen Sequenz, während islice() einen
Teil einer Sequenz zurückgibt. takewhile() gibt die
Elemente zurück, solange die Bedingung erfüllt ist, und
dropwhile() gibt die Elemente zurück, nachdem die Bedingung
nicht mehr erfüllt ist.
Das itertools-Modul kann in verschiedenen Szenarien nützlich sein, insbesondere bei der Verarbeitung von Daten und der Erstellung von iterativen Algorithmen.