Syntaxe, exemples et cas d’utilisation

Découverte de la Fonction len() en Python : Un Guide Complet

Lorsque vous manipulez des collections de données en Python, il est fréquent de devoir connaître le nombre d’éléments qu’elles contiennent. Python met à disposition la fonction intégrée len() pour cela. Cet outil vous permet de déterminer la taille de vos itérables, allant des listes aux chaînes de caractères, en passant par les ensembles et les dictionnaires.

Python, avec sa richesse en structures de données et en méthodes, offre également des fonctions intégrées pratiques. Parmi celles-ci, len() se distingue par sa simplicité et son utilité, permettant de connaître instantanément le nombre d’éléments dans un itérable.

Dans ce guide, nous explorerons comment utiliser len() avec différentes structures, telles que les listes, les tuples et les chaînes. De plus, nous verrons comment cette fonction peut être appliquée dans divers contextes pratiques.

Alors, lançons-nous ! 🚀

Syntaxe de la fonction Python len()

Voici comment utiliser la fonction len() en Python :

len(iterable)

Comme vous pouvez le constater, len() prend un seul argument, qui doit être un itérable. Cet itérable peut être une liste, un tuple, une chaîne de caractères, ou tout autre type de données permettant l’itération.

La syntaxe de la fonction len() est donc très facile à comprendre et à mettre en œuvre. Voyons maintenant quelques exemples concrets.

📝 Pour les exemples de code de ce guide, vous pouvez utiliser un environnement REPL Python.

Utilisation de len() avec des Itérables

Avec des Séquences

La fonction len() est idéale pour déterminer la longueur des séquences, telles que les listes, les tuples et les chaînes de caractères.

Voici un exemple concret :

>>> nombres = [9, 3, 6, 1, 2]
>>> len(nombres)
5

>>> nombres_tuple = (9, 3, 6, 1, 2)
>>> len(nombres_tuple)
5

Avec ces types de données, vous accédez généralement aux éléments par leur index ou vous récupérez des sous-séquences (slices) selon vos besoins.

Avec d’autres Collections

Vous pouvez également utiliser len() avec d’autres collections Python comme les ensembles et les dictionnaires.

Ces structures sont des collections non ordonnées. Bien que l’ordre des éléments ne soit pas primordial, connaître le nombre total d’éléments reste très utile.

>>> nombres_ensemble = set(nombres)
>>> len(nombres_ensemble)
5

>>> prix = {'Cahier': 5, 'Trousse': 7, 'Marque-pages': 3, 'Stylos': 1, 'Marqueurs': 8}
>>> len(prix)
5

Cas d’Utilisation Courants de len()

Nous avons vu des cas simples où len() nous donne le nombre d’éléments d’un itérable. Voyons maintenant des exemples plus pratiques.

#1. Itération avec Boucles for

La boucle for de Python permet de parcourir les éléments d’un itérable. Mais si vous souhaitez accéder aux index de chaque élément (ou à la fois aux index et aux éléments), vous pouvez utiliser range() comme ceci :

>>> nombres = [9, 2, 4, 7, 8]
>>> for i in range(len(nombres)):
...    print(f"Index {i}: {nombres[i]}")

Puisque range(N) génère la séquence 0, 1, 2, …, N – 1, l’utilisation de range(len(nombres)) nous donne l’ensemble des index valides à parcourir.

# Output
Index 0: 9
Index 1: 2
Index 2: 4
Index 3: 7
Index 4: 8
    

Cependant, pour accéder à l’index et à l’élément, la méthode recommandée en Python est d’utiliser enumerate :

>>> nombres = [9, 2, 4, 7, 8]
>>> for index, nombre in enumerate(nombres):
...    print(f"Index {index}: {nombre}")

# Output
Index 0: 9
Index 1: 2
Index 2: 4
Index 3: 7
Index 4: 8
    

#2. Boucles Conditionnelles avec while

Imaginons que vous ayez une liste de nombres. La méthode pop() retire et retourne le dernier élément de la liste.

Tant que la longueur de la liste, obtenue avec len(nombres), est supérieure à zéro, il reste au moins un élément à retirer.

>>> nombres = [9, 2, 4, 7, 8]
>>> while len(nombres) > 0:
...   nombres.pop()

# Output
8
7
4
2
9
    

L’exemple ci-dessus peut être exprimé de manière plus concise :

>>> nombres = [9, 2, 4, 7, 8]
>>> while nombres:
...    nombres.pop()

while nombres: équivaut à « tant que la liste nombres n’est pas vide ».

#3. Vérification et Validation de la Longueur des Itérables

Une autre application de len() consiste à vérifier et à valider la longueur de certains itérables.

Ici, nous validons la longueur d’un nom d’utilisateur :

>>> nom_utilisateur = "utilisateur-aleatoire"
>>> if len(nom_utilisateur) > 10:
...   print("Nom d'utilisateur trop long; 10 caractères maximum.")
... elif len(nom_utilisateur) < 5:
...   print("Nom d'utilisateur trop court; au moins 5 caractères.")
... else:
...   print("Nom d'utilisateur valide !")

Nom d'utilisateur trop long; 10 caractères maximum.
    

#4. Compréhensions de Listes et de Dictionnaires

Les compréhensions en Python offrent une syntaxe compacte pour créer de nouveaux itérables à partir d’itérables existants. On peut y inclure des fonctions intégrées, telles que len().

Compréhension de Liste

Ici, len() calcule la longueur de chaque chaîne dans la liste langues :

>>> langues = ['Python', 'C', 'Rust', 'JavaScript']
>>> longueur_langues = [len(lang) for lang in langues]
>>> longueur_langues
[6, 1, 4, 10]

Compréhension de Dictionnaire

Cette compréhension utilise la liste des langues et len() pour créer un dictionnaire :

>>> langues = ['Python', 'C', 'Rust', 'JavaScript']
>>> langues_longueur = {lang: len(lang) for lang in langues}
>>> langues_longueur
{'Python': 6, 'C': 1, 'Rust': 4, 'JavaScript': 10}

Les clés et les valeurs sont ici les noms des langues et leur longueur, respectivement.

#5. Paramètre key dans le Tri Personnalisé

Python a la méthode intégrée sort() pour trier les listes et la fonction sorted() pour trier d’autres itérables.

Dans les deux cas, le paramètre key permet de personnaliser le tri.

Ici, nous trions une liste de langues par longueur :

>>> langues = ['Python', 'C', 'Rust', 'JavaScript']
>>> langues.sort(key=len)
>>> langues
['C', 'Rust', 'Python', 'JavaScript']

L’extrait suivant utilise sorted() pour obtenir une liste triée :

>>> langues = ['Hindi', 'Anglais', 'Allemand', 'Français']
>>> sorted(langues, key=len)
['Hindi', 'Allemand', 'Français', 'Anglais']

Ici, ‘Allemand’ et ‘Français’ ont 6 caractères. Comme sorted() effectue un tri stable, l’ordre d’origine est préservé.

#6. Longueur des Tableaux NumPy

La fonction len() peut également être utilisée avec des tableaux NumPy. Tableaux NumPy.

>>> import numpy as np
>>> tableau_np = np.array([3, 4, 6, 9])
>>> type(tableau_np)
<class 'numpy.ndarray'>
>>> len(tableau_np)
4

Dans cet exemple, tableau_np est un vecteur de 4 éléments. len(tableau_np) retourne donc 4.

Une matrice est un tableau bidimensionnel.

Dans l’exemple suivant, len(tableau_np) vaut 2, ce qui correspond au nombre de lignes :

>>> matrice = [[1, 2, 3], [4, 5, 6]]
>>> tableau_np = np.array(matrice)
>>> tableau_np
array([[1, 2, 3],
       [4, 5, 6]])
>>> len(tableau_np)
2

Pour comprendre, retournons à la matrice. Nous avons une structure de liste imbriquée où la liste externe contient deux listes imbriquées. Et la fonction len() renvoie le nombre d’éléments dans un conteneur (ici, il s’agit de deux listes) :

>>> help(len)
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

Cependant, pour des tableaux multidimensionnels, l’attribut shape est recommandé :

>>> tableau_np.shape
(2, 3)

Pièges Courants à Éviter avec len()

Pour conclure, voyons quelques erreurs courantes à éviter avec len().

Utiliser len() avec des Types de Données Non Itérables

La fonction len() n’accepte que des itérables valides. Si vous l’utilisez avec un type de données qui ne l’est pas (comme des entiers, des flottants ou des booléens), vous obtiendrez une erreur.

>>> len(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

>>> len(True)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'bool' has no len()

>>> len(3.14)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'float' has no len()

En Python, les générateurs sont efficaces en mémoire pour générer des séquences. Un générateur fournit des éléments à la demande, un par un. Mais ils n’ont pas de longueur définie.

Essayer d’obtenir la longueur d’un générateur provoquera une erreur :

>>> nombres_carres = (i * i for i in range(10))
>>> nombres_carres
<generator object <genexpr> at 0x0157DBC0>
>>> len(nombres_carres)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'generator' has no len()

Utiliser len() avec des Tuples de Longueur Un

Si vous initialisez un tuple avec un seul élément sans la virgule finale, Python le traitera comme un élément simple et non comme un tuple.

Par exemple :

>>> nombres = (1)
>>> len(nombres)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

Donc, pour un tuple d’un seul élément, utilisez la syntaxe : tuple_name = (element,) :

>>> nombres = (1,)
>>> len(nombres)
1

Résumé

Voici ce qu’il faut retenir de ce guide :

• La fonction len() en Python permet de déterminer le nombre d’éléments dans n’importe quel itérable. Sa syntaxe est : len(iterable_valide).
• Elle fonctionne avec les séquences (listes, tuples, chaînes) et d’autres collections (dictionnaires, ensembles).
• len() est couramment utilisée dans les boucles et les compréhensions.
• Elle peut aussi servir de paramètre key pour personnaliser le tri (par exemple, trier une liste de chaînes par longueur).

Maintenant, vous pouvez approfondir vos connaissances avec la fonction sum() de Python.