11 Tipps zum Python-Looping

Open-Source-App für China, loslegen! Dies ist eine brandneue Version, die Sie noch nie zuvor gesehen haben.“

Dieser Artikel stammt aus dem „ Loop Skills Guide in Python “ der Huawei Cloud Community von Lemony Hug.

Wenn wir Daten verarbeiten, müssen wir manchmal mehrere Listen erstellen, um Daten unterschiedlichen Typs oder Zustands zu speichern. In Python können wir Schleifen verwenden, um diese Listen schnell und effizient zu erstellen. In diesem Artikel wird erläutert, wie Sie mithilfe von Schleifen mehrere Listen in Python erstellen, und es werden Codebeispiele bereitgestellt.

Python verwendet eine Schleife, um mehrere Listen zu erstellen

In Python können wir mithilfe von Listenverständnissen oder Schleifen in Kombination mit bedingten Anweisungen mehrere Listen erstellen. Hier sind einige häufige Szenarien und entsprechende Codebeispiele:

1. Erstellen Sie eine feste Anzahl leerer Listen

Angenommen, wir müssen mehrere leere Listen erstellen, können wir Listenverständnisse und Schleifen verwenden:

# Erstellen Sie mehrere leere Listen mithilfe von Listenverständnissen
num_lists = 5
empty_lists = [[] für _ im Bereich(num_lists)]

print(empty_lists)

Dadurch wird eine Liste mit 5 leeren Listen erstellt.

2. Erstellen Sie mehrere Listen basierend auf Bedingungen

Manchmal müssen wir basierend auf bestimmten Bedingungen unterschiedliche Listen erstellen. Wir wollen zum Beispiel ungerade und gerade Zahlen in zwei Listen speichern:

#Erstellen Sie ungerade und gerade Listen
Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = []
gerade_zahlen = []

für num in Zahlen:
    wenn Anzahl % 2 == 0:
        even_numbers.append(num)
    anders:
        odd_numbers.append(num)

print("Liste ungerader Zahlen:", odd_numbers)
print("Liste der geraden Zahlen:", even_numbers)

Dadurch werden zwei Listen basierend auf der Parität der Zahlen erstellt.

3. Erstellen Sie mehrere Listen basierend auf der Zeichenfolgenlänge

Manchmal müssen wir Zeichenfolgen basierend auf ihrer Länge klassifizieren und in verschiedenen Listen speichern:

#Erstellen Sie mehrere Listen basierend auf der Zeichenfolgenlänge
Wörter = ["Apfel", "Banane", "Orange", "Birne", "Traube", "Kiwi"]
short_words = []
medium_words = []
long_words = []

für Wort in Worten:
    wenn len(word) < 5:
        short_words.append(word)
    elif len(word) < 7:
        medium_words.append(word)
    anders:
        long_words.append(word)

print("Kurze Wortliste:", short_words)
print("Wortliste mittlerer Länge:", medium_words)
print("Lange Wortliste:", long_words)

Dadurch werden die Wörter basierend auf der Länge der Zeichenfolge in drei verschiedenen Listen gespeichert.

4. Erstellen Sie mehrere Listen basierend auf dem Datentyp

Manchmal müssen wir Daten je nach Typ in verschiedenen Listen speichern. Beispielsweise möchten wir Ganzzahlen, Gleitkommazahlen und Zeichenfolgen in separaten Listen speichern:

#Erstellen Sie mehrere Listen basierend auf dem Datentyp
data = [1, 2,5, „Apfel“, 4, „Banane“, 6,7, „Orange“, 8, 9, „Birne“]
ganze Zahlen = []
floats = []
Zeichenfolgen = []

für Artikel in Daten:
    if isinstance(item, int):
        integers.append(item)
    elif isinstance(item, float):
        floats.append(item)
    elif isinstance(item, str):
        strings.append(item)

print("Liste der Ganzzahlen:", Ganzzahlen)
print("Liste der Gleitkommazahlen:", floats)
print("Liste der Strings:", strings)

Dadurch werden die Daten je nach Typ in drei verschiedenen Listen gespeichert.

5. Erstellen Sie dynamisch mehrere Listen basierend auf Bedingungen

Manchmal müssen wir mehrere Listen basierend auf sich dynamisch ändernden Bedingungen erstellen. Beispielsweise möchten wir basierend auf der vom Benutzer eingegebenen Menge eine Liste entsprechender Mengen erstellen:

# Erstellen Sie dynamisch mehrere Listen basierend auf Benutzereingaben
num_lists = int(input("Bitte geben Sie die Anzahl der zu erstellenden Listen ein: "))
listet = [[] für _ im Bereich(num_lists)]

print("erstellt", num_lists, "leere Listen:", Listen)

Dadurch wird basierend auf der vom Benutzer eingegebenen Anzahl dynamisch eine entsprechende Anzahl leerer Listen erstellt.

6. Erstellen Sie mehrere Listen mit bestimmten Zahlenbereichen

Manchmal müssen wir mehrere Listen basierend auf einem bestimmten Zahlenbereich erstellen. Beispielsweise möchten wir Zahlen zwischen 0 und 9 in zehn Listen speichern, die auf einzelnen Ziffern basieren:

# Erstellen Sie mehrere Listen mit einem bestimmten Zahlenbereich
num_lists = 10
range_lists = [[] für _ im Bereich(num_lists)]

für num in range(10):
    range_lists[num % num_lists].append(num)

print("Einstellig gespeicherte Liste:")
für i, lst in enumerate(range_lists):
    print(f"List{i}:", lst)

Dadurch werden Zahlen zwischen 0 und 9 in zehn separaten Listen gespeichert, sortiert nach einzelnen Ziffern.

7. Erstellen Sie mehrere Listen basierend auf den Hash-Werten der Schlüssel

Manchmal möchten wir Daten basierend auf dem Hash-Wert eines Schlüssels in mehreren Listen gruppiert speichern. Wir haben beispielsweise eine Reihe von Schlüssel-Wert-Paaren und möchten diese basierend auf dem Hash der Schlüssel in verschiedenen Listen speichern:

# Erstellen Sie mehrere Listen basierend auf dem Hash-Wert des Schlüssels
data = {"Apfel": 3, "Banane": 5, "Orange": 2, "Birne": 4, "Traube": 6}
num_lists = 3
hash_lists = [[] für _ im Bereich(num_lists)]

für Schlüssel, Wert in data.items():
    hash_index = hash(key) % num_lists
    hash_lists[hash_index].append((key, value))

print("Liste nach Hashwert des Schlüssels gespeichert:")
für i, lst in enumerate(hash_lists):
    print(f"List{i}:", lst)

Dadurch werden die Schlüssel-Wert-Paare basierend auf dem Hash des Schlüssels in drei verschiedenen Listen gespeichert.

8. Erstellen Sie mehrere Listen basierend auf den Attributen der Elemente in der Liste

Manchmal müssen wir mehrere Listen basierend auf den Attributwerten der Elemente in der Liste erstellen. Nehmen wir zum Beispiel an, wir haben eine Reihe von Schülerobjekten und möchten sie basierend auf ihren Noten in zwei Listen, „Bestanden“ und „Nicht bestanden“, speichern:

#Erstellen Sie mehrere Listen basierend auf den Ergebnissen der Schülerobjekte
Klasse Schüler:
    def __init__(selbst, Name, Punktzahl):
        self.name = Name
        self.score = Punktzahl

Studenten = [
    Student("Alice", 85),
    Student("Bob", 60),
    Student("Charlie", 75),
    Student("David", 40),
    Student("Emma", 95)
]

passing_students = []
failing_students = []

für Studierende in Studierenden:
    wenn student.score >= 60:
        passing_students.append(student)
    anders:
        failing_students.append(student)

print("Liste der bestandenen Studenten:")
für Studierende im Vorbeigehen_Studenten:
    print(f"{student.name}: {student.score}")

print("\nListe der nicht bestandenen Schüler:")
für Schüler in failing_students:
    print(f"{student.name}: {student.score}")

Dadurch werden die Schüler basierend auf ihren Noten in zwei Listen gespeichert: „Bestanden“ und „Nicht bestanden“.

9. Erstellen Sie mehrere Listen basierend auf Indexbereichen

Manchmal müssen wir die Liste basierend auf dem Indexbereich in mehrere Unterlisten aufteilen. Wir haben beispielsweise eine Liste mit einer Reihe von Zahlen und möchten diese in mehrere kleinere Unterlisten aufteilen:

#Erstellen Sie mehrere Listen basierend auf Indexbereichen
Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
num_lists = 3
split_lists = []

für i in range(num_lists):
    start_index = i * len(numbers) // num_lists
    end_index = (i + 1) * len(numbers) // num_lists
    split_lists.append(Zahlen[start_index:end_index])

print("Liste teilen:")
für i, lst in enumerate(split_lists):
    print(f"List{i + 1}:", lst)

Dadurch wird die ursprüngliche Liste basierend auf dem Indexbereich in drei Unterlisten aufgeteilt.

10. Erstellen Sie mehrere Listen, indem Sie sie basierend auf den Werten der Listenelemente gruppieren

Manchmal müssen wir Listenelemente basierend auf ihren Werten gruppieren und sie in verschiedenen Listen speichern. Nehmen wir zum Beispiel an, wir haben eine Reihe von Ganzzahlen und möchten sie basierend auf ihrer Parität in zwei Listen speichern:

#Erstellen Sie mehrere Listen, indem Sie sie basierend auf den Werten der Listenelemente gruppieren
Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = []
gerade_zahlen = []

für num in Zahlen:
    wenn Anzahl % 2 == 0:
        even_numbers.append(num)
    anders:
        odd_numbers.append(num)

print("Liste ungerader Zahlen:", odd_numbers)
print("Liste der geraden Zahlen:", even_numbers)

Dadurch werden die Listenelemente basierend auf ihrer Parität in ungeraden bzw. geraden Listen gespeichert.

11. Erstellen Sie mehrere Listen basierend darauf, ob Elemente Bedingungen erfüllen

Manchmal müssen wir Elemente in verschiedenen Listen speichern, je nachdem, ob sie bestimmte Bedingungen erfüllen. Nehmen wir zum Beispiel an, wir haben eine Reihe von Zahlen und möchten Zahlen größer oder gleich 5 und Zahlen kleiner als 5 in zwei Listen speichern:

#Erstellen Sie mehrere Listen basierend darauf, ob die Elemente die Bedingungen erfüllen
Zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
größer_als_5 = []
kleiner_als_5 = []

für num in Zahlen:
    wenn Anzahl >= 5:
        größer_als_5.append(num)
    anders:
        less_than_5.append(num)

print("Liste der Zahlen größer oder gleich 5:", größer_als_5)
print("Liste der Zahlen kleiner als 5:", less_than_5)

Dadurch wird die Zahl in zwei verschiedenen Listen gespeichert, je nachdem, ob sie größer oder gleich 5 ist.

Zusammenfassen

Insgesamt wurden in diesem Artikel verschiedene Möglichkeiten zum Erstellen mehrerer Listen mithilfe von Schleifen in Python vorgestellt und diese anhand spezifischer Codebeispiele demonstriert und erklärt. Ausgehend von verschiedenen Perspektiven wie festen Mengen, Bedingungen, Datentypen, Attributen, Indexbereichen, Hash-Werten usw. haben wir untersucht, wie sich Schleifen in Kombination mit Listenverständnissen oder bedingten Anweisungen flexibel nutzen lassen, um mehrere Listen zu erstellen. Diese Methoden verbessern nicht nur die Flexibilität und Wartbarkeit des Codes, sondern beschleunigen auch den Entwicklungsprozess und verbessern die Leistung des Programms.

Durch das Studium dieses Artikels können Leser die Fähigkeiten erlernen, Daten in Python zu verarbeiten und in mehreren Listen zu organisieren, um Daten effektiver zu betreiben und zu verwalten. Gleichzeitig kann die flexible Nutzung von Python-Funktionen wie Schleifen und Listenverständnissen den Code prägnanter, klarer und eleganter machen. In tatsächlichen Projekten wird die Auswahl der geeigneten Methode zum Erstellen mehrerer Listen entsprechend spezifischer Anforderungen zu einer wichtigen Programmierfähigkeit und trägt dazu bei, die Qualität und Effizienz des Codes zu verbessern.

Klicken Sie hier, um zu folgen und so schnell wie möglich mehr über die neuen Technologien von Huawei Cloud zu erfahren~