In diesem Beitrag werden wir uns ansehen, wie man die Größe einer Liste mit verschiedenen Methoden ermittelt und analysieren, welche Methode in bestimmten Szenarien am besten geeignet ist.
Was ist eine Python-Liste?
Eine Liste in Python ist eine flexible Datenstruktur, die es erlaubt, mehrere Elemente verschiedener Datentypen zu speichern. Sie kann Ganzzahlen, Fließkommazahlen, Zeichenketten, Boolesche Werte oder sogar andere Listen enthalten.
int_list = [1, 2, 3, 4, 5]
print(int_list) # Ausgabe -> [1, 2, 3, 4, 5]
float_list = [1.1, 2.2, 3.3, 4.4, 5.5]
print(float_list) # Ausgabe -> [1.1, 2.2, 3.3, 4.4, 5.5]
string_list = ['Geekflare', 'Cloudflare', 'Amazon']
print(string_list) # Ausgabe -> ['Geekflare', 'Cloudflare', 'Amazon']
boolean_list = [True, False]
print(boolean_list) # Ausgabe -> [True, False]
nested_list = [[1, 2], [1.1, 2.2], ['Geekflare', 'Cloudflare'], [True, False]]
print(nested_list) # [[1, 2], [1.1, 2.2], ['Geekflare', 'Cloudflare'], [True, False]]
different_datatype_list = [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
print(different_datatype_list) # Ausgabe -> [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
Python-Listen lassen sich auf zwei Arten erstellen: mit eckigen Klammern oder mithilfe der Listenkonstruktorfunktion.
square_bracket_list = [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
print(square_bracket_list) # Ausgabe -> [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
constructor_list = list((1, 1.1, 'wdzwdz', True, [1, 1.1, 'Geekflare', True]))
print(constructor_list) # Ausgabe -> [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
Die `square_bracket_list` wurde mit eckigen Klammern `[]` erstellt, während `constructor_list` mithilfe des Listenkonstruktors erzeugt wurde. Beide Methoden führen jedoch zum gleichen Ergebnis.
Listen sind in Python veränderbar, erlauben Duplikate und der Zugriff auf die einzelnen Elemente erfolgt über ihren Index.
Methoden zur Bestimmung der Listenlänge
- Die eingebaute Funktion `len()`
- Die Methode `length_hint` aus dem Modul `operator`
- Eine benutzerdefinierte Funktion mit einem Zähler
Methode 1: Die eingebaute Funktion `len()`
Die Funktion `len()` ist eine standardmäßig in Python verfügbare Funktion. Sie dient dazu, die Anzahl der Elemente in Listen, Mengen, Tupeln, Dictionaries und anderen iterierbaren Objekten zu bestimmen.
Beispielcode:
languages = ['Python', 'Java', 'C++', 'PHP', 'nodeJS']
languages_length = len(languages)
print('Die Länge der Sprachliste beträgt: ',languages_length)
Ausgabe:
Die Länge der Sprachliste beträgt: 5
Falls Python auf Ihrem System noch nicht installiert ist, können Sie auch einen Online-Python-Compiler verwenden, um den Code auszuprobieren.
Methode 2: Die `length_hint`-Methode aus dem Modul `operator`
Die `length_hint`-Methode wird verwendet, um die (geschätzte) Länge eines iterierbaren Objekts zurückzugeben. Sie ist Teil des `operator`-Moduls in Python und wird nicht standardmäßig wie andere eingebaute Operatoren geladen.
Beispielcode:
import operator
languages = ['Python', 'Java', 'C++', 'PHP', 'nodeJS']
languages_length = operator.length_hint(languages)
print('Die Länge der Sprachliste mit Operator ist: ',languages_length)
Ausgabe:
Die Länge der Sprachliste mit Operator ist: 5
Methode 3: Benutzerdefinierte Funktion und Zähler
Bei dieser Methode zur Ermittlung der Länge einer Liste verwenden wir eine traditionelle Methode, bei der eine `for`-Schleife und ein Zähler eingesetzt werden.
Dazu definieren wir eine Funktion in Python, die eine Liste (oder ein anderes iterierbares Objekt) als Argument akzeptiert und die Länge dieses Objekts zurückgibt.
Code für die benutzerdefinierte Funktion:
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
Beispielcode:
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
languages = ['Python', 'Java', 'C++', 'PHP', 'nodeJS']
languages_length = iterable_count(languages)
print('Die Länge der Sprachliste mit benutzerdefinierter Funktion ist: ',languages_length)
Ausgabe:
Die Länge der Sprachliste mit benutzerdefinierter Funktion ist: 5
Analyse der drei Methoden
Leistungsvergleich bei einer großen Liste:
import timeit # for benchmarking & profiling
import operator
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
integer_list = list(range(1, 9999999))
#Längenprüfung mit len()
start_time = timeit.default_timer()
len_length = len(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit len() ist: ',len_length)
#Längenprüfung mit operator.length_hint
start_time = timeit.default_timer()
len_length = operator.length_hint(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit length_hint ist: ',len_length)
start_time = timeit.default_timer()
iterable_count_length = iterable_count(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit benutzerdefinierter Funktion ist: ',iterable_count_length)
Ausgabe:
3.957189619541168e-06 Länge der Integer-Liste mit len() ist: 9999998
3.0621886253356934e-06 Länge der Integer-Liste mit length_hint ist: 9999998
0.4059128537774086 Länge der Integer-Liste mit benutzerdefinierter Funktion ist: 9999998
Wie wir sehen können, ist `length_hint` schneller (3.0621886253356934e-06), wenn es um große Datenmengen geht. Dies liegt daran, dass `length_hint` von der CPython-Laufzeit verwendet wird und intern als Wrapper um eine C-Implementierung arbeitet.
Leistungsvergleich bei einer kleinen Liste:
import timeit # for benchmarking & profiling
import operator
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
integer_list = list(range(1, 100))
#Längenprüfung mit len()
start_time = timeit.default_timer()
len_length = len(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit len() ist: ',len_length)
#Längenprüfung mit operator.length_hint
start_time = timeit.default_timer()
len_length = operator.length_hint(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit length_hint ist: ',len_length)
start_time = timeit.default_timer()
iterable_count_length = iterable_count(integer_list)
print(timeit.default_timer() - start_time, 'Länge der Integer-Liste mit benutzerdefinierter Funktion ist: ',iterable_count_length)
Ausgabe:
7.813796401023865e-07 Länge der Integer-Liste mit len() ist: 99
1.1278316378593445e-06 Länge der Integer-Liste mit length_hint ist: 99
3.462657332420349e-06 Länge der Integer-Liste mit benutzerdefinierter Funktion ist: 99
Wie wir sehen können, ist `len()` schneller (7.813796401023865e-07), wenn die Datenmenge klein ist (bis ca. 1000 Elemente).
In beiden Fällen benötigt unsere benutzerdefinierte Funktion mit Zähler deutlich mehr Zeit als die beiden anderen Methoden.
Fazit
In diesem Beitrag haben wir uns verschiedene Möglichkeiten zur Ermittlung der Länge einer Liste in Python angesehen. Wir haben auch untersucht, wie die Methoden in Bezug auf die Geschwindigkeit bei unterschiedlich großen Listen abschneiden.