Comment déterminer la longueur d’une liste en Python : Un guide complet
Cet article explore différentes méthodes pour déterminer la longueur d’une liste en Python, en détaillant leur fonctionnement et en analysant leur efficacité.
Qu’est-ce qu’une liste en Python ?
En Python, une liste est une collection ordonnée d’éléments, capable de contenir divers types de données. Elle peut ainsi stocker des entiers, des nombres à virgule flottante, des chaînes de caractères, des booléens, voire même d’autres listes. C’est une structure de données flexible et très utilisée.
Voici quelques exemples illustrant la diversité des listes Python:
int_list = [1, 2, 3, 4, 5]
print(int_list) # Résultat -> [1, 2, 3, 4, 5]
float_list = [1.1, 2.2, 3.3, 4.4, 5.5]
print(float_list) # Résultat -> [1.1, 2.2, 3.3, 4.4, 5.5]
string_list = ['Geekflare', 'Cloudflare', 'Amazon']
print(string_list) # Résultat -> ['Geekflare', 'Cloudflare', 'Amazon']
boolean_list = [True, False]
print(boolean_list) # Résultat -> [True, False]
nested_list = [[1, 2], [1.1, 2.2], ['Geekflare', 'Cloudflare'], [True, False]]
print(nested_list) # Résultat -> [[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) # Résultat -> [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
Les listes peuvent être créées en utilisant des crochets ([]) ou en employant le constructeur list().
square_bracket_list = [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
print(square_bracket_list) # Résultat -> [1, 1.1, 'Geekflare', True, [1, 1.1, 'Geekflare', True]]
constructor_list = list((1, 1.1, 'toptips.fr', True, [1, 1.1, 'Geekflare', True]))
print(constructor_list) # Résultat -> [1, 1.1, 'toptips.fr', True, [1, 1.1, 'Geekflare', True]]
Les deux méthodes de création de listes produisent le même résultat. Une liste en Python est modifiable, elle peut contenir des doublons et ses éléments sont accessibles par leur index.
Méthodes pour déterminer la longueur d’une liste
Il existe plusieurs façons de déterminer la longueur d’une liste en Python:
- La fonction intégrée
len() - La méthode
length_hintdu moduleoperator - L’utilisation d’une fonction personnalisée avec un compteur
Méthode 1 : Utilisation de la fonction intégrée len()
La fonction len() est une fonction native de Python qui permet de calculer la longueur d’une liste, mais aussi d’autres objets itérables tels que les ensembles, les tuples et les dictionnaires.
Voici un exemple d’utilisation:
languages = ['Python', 'Java', 'C++', 'PHP', 'nodeJS']
languages_length = len(languages)
print('La longueur de la liste est :', languages_length)
Résultat :
La longueur de la liste est : 5
Si Python n’est pas installé sur votre système, vous pouvez utiliser un compilateur en ligne pour exécuter ce code.
Méthode 2 : La méthode length_hint du module operator
La méthode length_hint, disponible dans le module operator, est conçue pour renvoyer une estimation de la longueur d’un objet itérable (listes, ensembles, tuples, dictionnaires, etc.). Elle est un peu différente des opérateurs natifs, et doit être importée.
Voici un exemple d’utilisation :
import operator
languages = ['Python', 'Java', 'C++', 'PHP', 'nodeJS']
languages_length = operator.length_hint(languages)
print('Longueur de la liste avec operator.length_hint :', languages_length)
Résultat :
Longueur de la liste avec operator.length_hint : 5
Méthode 3 : Fonction personnalisée avec compteur
Cette méthode utilise une approche plus traditionnelle, en parcourant la liste avec une boucle for et en utilisant un compteur pour calculer la longueur.
On définit d’abord une fonction qui prend un objet itérable en argument et retourne sa longueur.
Voici la fonction personnalisée:
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
Et son exemple d’utilisation:
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('Longueur de la liste avec la fonction personnalisée :', languages_length)
Résultat:
Longueur de la liste avec la fonction personnalisée : 5
Analyse comparative des 3 méthodes
Pour analyser l’efficacité de chaque méthode, on mesure le temps d’exécution sur des listes de tailles différentes.
Analyse des performances pour une grande liste:
import timeit # pour mesurer le temps d'exécution
import operator
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
integer_list = list(range(1, 9999999))
# Mesure du temps avec len()
start_time = timeit.default_timer()
len_length = len(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec len() :',len_length)
# Mesure du temps avec operator.length_hint
start_time = timeit.default_timer()
len_length = operator.length_hint(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec length_hint :',len_length)
# Mesure du temps avec la fonction personnalisée
start_time = timeit.default_timer()
iterable_count_length = iterable_count(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec fonction personnalisée :',iterable_count_length)
Résultat:
3.957189619541168e-06 Longueur de la liste avec len() : 9999998
3.0621886253356934e-06 Longueur de la liste avec length_hint : 9999998
0.4059128537774086 Longueur de la liste avec fonction personnalisée : 9999998
On observe que length_hint est la plus rapide (environ 3.06e-06 secondes) pour les grandes listes, car elle est optimisée par le runtime CPython.
Analyse des performances pour une petite liste :
import timeit # pour mesurer le temps d'exécution
import operator
def iterable_count(iterable):
length = 0
for item in iterable:
length+=1
return length
integer_list = list(range(1, 100))
# Mesure du temps avec len()
start_time = timeit.default_timer()
len_length = len(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec len() :',len_length)
# Mesure du temps avec operator.length_hint
start_time = timeit.default_timer()
len_length = operator.length_hint(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec length_hint :',len_length)
# Mesure du temps avec la fonction personnalisée
start_time = timeit.default_timer()
iterable_count_length = iterable_count(integer_list)
print(timeit.default_timer() - start_time, 'Longueur de la liste avec fonction personnalisée :',iterable_count_length)
Résultat:
7.813796401023865e-07 Longueur de la liste avec len() : 99
1.1278316378593445e-06 Longueur de la liste avec length_hint : 99
3.462657332420349e-06 Longueur de la liste avec fonction personnalisée : 99
Pour les petites listes, la fonction len() est plus rapide (environ 7.81e-07 secondes). Dans les deux cas, la fonction personnalisée est la plus lente.
Conclusion
Cet article a exploré différentes méthodes pour calculer la longueur d’une liste en Python. On a vu que len() est rapide et pratique dans la plupart des cas. length_hint peut être plus performante pour les très grandes listes. La fonction personnalisée est moins efficace en termes de performance, mais permet de comprendre le fonctionnement de la mesure de longueur d’une liste. Le choix de la méthode dépendra de la situation, mais dans la plupart des cas, len() est la solution la plus simple et la plus rapide.