Python-Listenlänge: 8 Methoden, um die Länge einer Liste in Python zu ermitteln

Python-Listen sind eine grundlegende Datenstruktur, die sich ideal eignet, um Sammlungen von Elementen zu speichern und zu verarbeiten. Ihre Flexibilität und einfache Handhabung machen sie unverzichtbar für viele Programmieraufgaben – von der Datenanalyse bis zur Webentwicklung. Weil sie so häufig zum Einsatz kommen, steht oft die Frage im Raum, wie groß eine Liste ist. Die Funktion len() ist weithin bekannt, doch dank Pythons ausdrucksstarker Syntax und seines Ökosystems gibt es mehrere weitere Wege, das zu ermitteln – jeweils mit eigenen Nuancen und Einsatzfällen. In diesem Artikel schauen wir uns acht dieser Methoden an und vergleichen Funktionsweise und Effizienz.

Warum sind Python-Listen wichtig?

Listen in Python sind dynamische Arrays, die auch gemischte Datentypen aufnehmen können – ein vielseitiges Werkzeug für Datenspeicherung und -manipulation. Sie unterstützen Operationen wie Iteration, Slicing und zahlreiche bequeme Manipulationen mit eingebauten Methoden wie append(), remove() oder sort(). Mehr zu Listenoperationen findest du in diesem Tutorial.

So definierst du eine Liste in Python

Für dieses Tutorial nutzen wir eine einfache Liste, an der wir jede Methode demonstrieren. Die Liste my_list ist wie folgt definiert:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]Bereitgestellt von

Diese einfache Liste eignet sich perfekt, um verschiedene Techniken zur Längenbestimmung zu veranschaulichen.

8 Wege, die Größe einer Python-Liste zu ermitteln

1. Listenlänge mit der Funktion len() bestimmen

Die Funktion len() ist der direkteste Weg, die Größe einer Liste festzustellen. Sie ist prägnant und sehr effizient – in den meisten Fällen die erste Wahl.

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4Bereitgestellt von

2. Listenlänge mit einer For-Schleife ermitteln

Diese oftmals als naive Methode bezeichnete Vorgehensweise initialisiert einen Zähler und erhöht ihn für jedes Element, das in einer for-Schleife durchlaufen wird. Mehr zu for-Schleifen und anderen Schleifenarten findest du in diesem Tutorial.

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4Bereitgestellt von

3. Listenlänge mit einer List Comprehension berechnen

List Comprehensions bieten in Python eine kompakte Syntax, um Operationen auf Listen auszuführen. Hier kombinieren wir sie mit sum(), um die Elemente zu zählen.

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4Bereitgestellt von

4. Listenlänge mit reduce() ermitteln

Die Funktion reduce() ist etwas fortgeschrittener, aber sehr mächtig. Sie wendet eine Funktion mit zwei Argumenten kumulativ von links nach rechts auf die Elemente einer Liste an und reduziert sie so auf einen einzelnen Wert. Für unser Ziel nutzen wir sie, um die Anzahl der Elemente zu zählen.

Zur besseren Verständlichkeit teilen wir das in zwei Schritte auf:

1. Einfache Funktion definieren: Zuerst definieren wir eine Funktion mit zwei Argumenten: dem aktuellen Zählerstand (count_so_far) und einem Listenelement (das wir _ nennen, um zu zeigen, dass wir es nicht verwenden).
2. reduce() verwenden: Anschließend wenden wir reduce() auf jedes Element der Liste an und zählen so die Elemente.

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4Bereitgestellt von

5. Listenlänge mit iter() und next() bestimmen

Um mit iter() und next() zu zählen, musst du Iteratoren verstehen. Ein Iterator ist ein Objekt, das uns erlaubt, eine Liste Element für Element zu durchlaufen. iter() macht aus einer Liste einen Iterator, und next() springt zum nächsten Element.

So gehst du Schritt für Schritt vor:

1. Iterator erstellen: Wandle die Liste mit iter() in einen Iterator um. So gehst du nacheinander durch die Elemente.
2. Im Loop zählen: Richte eine Schleife ein, die läuft, bis keine Elemente mehr vorhanden sind. In der Schleife nutzt du next(), um das nächste Element zu holen. Gelingt das, erhöhst du den Zähler um 1.
3. Listenende behandeln: Am Ende der Liste löst next() eine StopIteration-Exception aus. Diese fängst du mit try/except und beendest die Schleife.

Hier ist der vereinfachte Code mit Kommentaren zu jedem Schritt:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4Bereitgestellt von

6. Listenlänge mit enumerate() bestimmen

Die Funktion enumerate() versieht ein Iterable mit einem Zähler und liefert ein enumerate-Objekt zurück. Sie wird häufig in Schleifen verwendet, um gleichzeitig Index und Wert zu erhalten. Auch wenn enumerate() normalerweise nicht zur Längenbestimmung dient, zeigt das Beispiel, wie flexibel Python ist.

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4Bereitgestellt von

7. Listenlänge mit NumPy bestimmen

NumPy ist eine leistungsstarke Python-Bibliothek für wissenschaftliches Rechnen. Sie unterstützt große, mehrdimensionale Arrays und Matrizen sowie zahlreiche mathematische Funktionen. Wer mit numerischen Daten arbeitet, kommt an NumPy kaum vorbei – es bietet effiziente Speicherung und Operationen auf großen Datensätzen. Um die Größe einer Liste mit NumPy zu bestimmen, nutzen wir das Attribut .size wie folgt.

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4Bereitgestellt von

8. Listenlänge mit map() und sum() ermitteln

Ähnlich wie bei einer List Comprehension verwendet diese Methode map(), um für jedes Element eine 1 zurückzugeben, und sum(), um die Werte aufzusummieren. Dafür solltest du mit Lambda-Funktionen in Python vertraut sein. Eine schnelle Auffrischung findest du im Python-Lambda-Tutorial.

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4Bereitgestellt von

Performancevergleich der Methoden zur Listenlänge in Python

Es ist das eine, alle acht Methoden zu kennen. Das andere ist, die beste Methode auszuwählen. Für den Performancevergleich nutzen wir Pythons Modul timeit, mit dem sich kleine Codefragmente einfach messen lassen. So sehen wir, wie schnell die einzelnen Ansätze sind. Beachte, dass die Messwerte je nach Rechner und Umgebung variieren können.

Versuchsaufbau

Zur Vereinfachung definieren wir unsere Liste und die Funktionen für jede Methode. Falls du mit Funktionen noch nicht vertraut bist: Wir strukturieren die Methoden nur, um sie leichter vergleichen zu können.

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))Bereitgestellt von

Die Messung

Als Nächstes nutzen wir timeit.timeit(), um jede Funktion in der angegebenen Reihenfolge zu messen:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")Bereitgestellt von

Wenn wir das in DataLab ausführen, erhalten wir folgende Ergebnisse:

Fazit

Diese Tour durch verschiedene Wege, die Größe einer Liste in Python zu ermitteln, zeigt nicht nur die Vielseitigkeit und Stärke der Sprache, sondern auch, wie wichtig es ist, Effizienz und Eignung der jeweiligen Methode zu verstehen.

Gerade für Einsteiger empfiehlt es sich, mit den einfachsten und effizientesten Ansätzen zu beginnen – allen voran der eingebauten Funktion len(), die auf Performance und Lesbarkeit optimiert ist. Wenn du noch tiefer in die Arbeit mit Listen einsteigen willst, schau dir diese Ressourcen an:

• Python Fundamentals Skill Track
• Introduction to Python Kurs
• Python-Spickzettel für Einsteiger