Lorsque vous travaillez avec des itérables Python, trouver le nombre d’éléments que les itérables contiennent est une opération courante. Apprenez à utiliser la fonction len intégrée à Python pour trouver la longueur des itérables et bien d’autres choses encore.

Python propose une série de structures de données intégrées et un ensemble de méthodes pour les utiliser. En outre, il existe des fonctions intégrées qui s’avèrent pratiques lorsque vous travaillez avec ces structures de données. L’une de ces fonctions est len(), qui donne le nombre d’éléments présents dans une table itérative.

Dans ce tutoriel, nous apprendrons à utiliser la fonction len() avec des listes, des tuples, des chaînes de caractères, etc. Nous verrons également quelques cas d’utilisation courants.

Commençons!👩‍🏫

Syntaxe de la fonction Python len()

Voici la syntaxe de la fonction len de Python :

len(iterable)

Comme vous l’avez vu, la fonction len() nécessite un paramètre, qui est un itérable valide. L’itérable est souvent une liste, un tuple ou une chaîne de caractères. Mais il peut également s’agir de tout autre type valide.

Nous voyons que la syntaxe d’utilisation de la fonction len() est très simple. Passons maintenant au codage de quelques exemples.

📑 Pour les exemples de code de ce tutoriel, vous pouvez coder dans un REPL Python.

Utilisation de la fonction len() avec des itérables

Using-the-len-function-with-Iterables

Avec des séquences

Vous pouvez utiliser la fonction len() pour trouver la longueur des itérables tels que les listes, les tuples et les chaînes de caractères.

Voici un exemple :

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

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

Pour ces structures de données qui stockent une séquence, vous accédez généralement aux éléments à l’aide de leur index ou vous obtenez une tranche (sous-séquence) selon vos besoins.

Avec d’autres collections

Vous pouvez également utiliser la fonction len() avec d’autres collections Python telles que les ensembles et les dictionnaires.

Ces structures de données sont des collections non ordonnées. Bien que vous ne soyez pas intéressé par l’ordre des éléments, il est toujours utile d’obtenir le nombre total d’éléments dans la collection.

>>> nums_set = set(nums)
>>> len(nums_set)
5

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

Cas d’utilisation courants de la fonction Python len()

Jusqu’à présent, nous avons vu des exemples simples d’utilisation de la fonction len() pour obtenir le nombre d’éléments d’une table itérative. Voyons maintenant où nous pouvons utiliser cette fonction en pratique.

#1. Itération à l’aide des boucles For

La boucle for de Python fournit une construction pour boucler à travers les itérables dans la syntaxe for an item in iterable (pour un élément dans l’itérable). Mais si vous voulez accéder à l’index de chaque élément au lieu de l’élément lui-même ou à la fois à l’index et aux éléments, vous pouvez utiliser la fonction range() comme indiqué :

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

Comme range(N) donne la séquence d’entiers 0,1,2,…,N – 1, l’utilisation de range(len(nums)) nous donne l’ensemble des indices valides à parcourir en boucle.

# Sortie
Indice 0 : 9
Indice 1 : 2
Indice 2 : 4
Indice 3 : 7
Index 4 : 8

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

>>> nums = [9,2,4,7,8]
>>> pour idx,num dans enumerate(nums) :
... print(f "Index {idx} : {num}")
# Sortie
Indice 0 : 9
Indice 1 : 2
Index 2 : 4
Index 3 : 7
Index 4 : 8

#2. Boucle conditionnelle à l’aide des boucles While

Supposons que vous ayez une liste de nombres nums. La méthode de liste pop() supprime le dernier élément de la liste et le renvoie.

Tant que la longueur de la liste nums len(nums) est supérieure à zéro, il y a au moins un élément qui peut être supprimé.

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

L’exemple ci-dessus est une façon plus explicite d’écrire ce qui suit :

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

while nums : est équivalent à la condition “while the nums list is not empty”.

#3. Vérification et validation de la longueur des itérables

Une autre utilisation courante de la fonction len est la vérification et la validation de la longueur de certains itérables.

Ici, nous vérifions si nom d'utilisateur est une chaîne de caractères valide en fonction de sa longueur (calculée à l’aide de la fonction len() ) :

>>> nom_d'utilisateur = "another-random-user" (un autre utilisateur aléatoire)
>>> if len(nom_d'utilisateur) > 10 :
... print("Nom d'utilisateur trop long ; doit comporter 10 caractères au maximum")
... elif len(username) < 5 :
... print("Nom d'utilisateur trop court ; doit comporter au moins 5 caractères.")
... else :
... print("Nom d'utilisateur valide !")
Le nom d'utilisateur est trop long ; il doit comporter au maximum 10 caractères.

#4. Compréhensions de listes et de dictionnaires

Les compréhensions en Python fournissent une syntaxe concise pour construire de nouveaux itérables à partir de ceux existants. Nous pouvons utiliser des fonctions intégrées dans une expression de compréhension.

Compréhension de liste

Dans cette compréhension de liste, nous utilisons la fonction len() pour obtenir la longueur de chaque chaîne de la liste des langues.

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

Compréhension du dictionnaire

Dans cette compréhension du dictionnaire, nous utilisons la liste des langues et la fonction len() pour construire un dictionnaire :

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

Ici, les clés et les valeurs sont respectivement les chaînes de langue et la longueur des chaînes de langue.

#5. Paramètre clé dans le tri personnalisé

Python dispose de la méthode intégrée sort() pour trier les listes Python en place et de la fonction sorted() pour trier les listes et autres itérables.

Dans les deux cas, vous pouvez utiliser le paramètre clé pour personnaliser le tri.

Ici, nous trions la liste des langues en fonction de la longueur de la chaîne.

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

Dans l’extrait ci-dessous, nous utilisons la fonction sorted() pour obtenir une liste triée.

>>> languages = ['Hindi', 'English', 'German', 'French']
>>> sorted(languages,key=len)
['Hindi', 'German', 'French', 'English']

Dans cet exemple, ‘Allemand’ et ‘Français’ ont chacun 6 caractères. Comme la fonction sorted() effectue un tri stable, l’ordre de la liste originale est préservé.

#6. Longueur des tableaux NumPy

Vous pouvez également utiliser la fonction len() avec d’autres structures de données comme les tableaux NumPy.

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

Dans ce cas, np_array est un vecteur à 4 éléments. Donc len(np_array) renvoie 4, le nombre d’éléments présents dans le tableau.

Une matrice est un tableau à deux dimensions.

Considérez l’exemple suivant. len(np_array) est égal à 2, ce qui correspond au nombre de lignes. 

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

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

>>> help(len)
Aide sur la fonction intégrée len dans le module builtins :

len(obj, /)
    Renvoie le nombre d'éléments dans un conteneur.

Cependant, lorsque vous commencez à travailler avec des tableaux multidimensionnels, il est recommandé d’utiliser l’attribut shape à la place.

>>> np_array.shape
(2, 3)

Pièges courants à éviter lors de l’utilisation de la fonction len() de Python

pitfalls

Pour conclure notre discussion, passons en revue quelques-uns des pièges les plus courants que vous devez éviter lorsque vous utilisez la fonction len en Python.

Utiliser len() avec des types de données non itérables

Nous savons que la fonction len ne prend en argument que des itérables valides. Cela signifie que si vous appelez la fonction len avec un type de données invalide qui n’est pas itérable, vous rencontrerez des erreurs.

Ces types de données non valides comprennent les types de données de base tels que les entiers, les nombres à virgule flottante et les booléens :

>>> len(2)
Traceback (dernier appel le plus récent) :
  Fichier "<stdin>", ligne 1, in <module&gt
TypeError : object of type 'int' has no len()

>>> len(True)
Traceback (dernier appel le plus récent) :
  Fichier "<stdin>", ligne 1, in <module&gt
TypeError : object of type 'bool' has no len()

>>> len(3.14)
Traceback (dernier appel le plus récent) :
  Fichier "<stdin>", ligne 1, dans <module&gt
TypeError : object of type 'float' has no len()

En Python, les générateurs sont des choix efficaces en termes de mémoire pour les cas d’utilisation qui nécessitent la génération de séquences. L’objet générateur renvoie les éléments de la séquence à la demande, un élément à la fois. Mais les objets générateurs n’ont pas de longueur.

Vous rencontrerez donc des erreurs si vous essayez de calculer la longueur d’un objet générateur :

>>> nums_sq = (i*i for i in range(10))
>>> nums_sq
<objet générateur <genexpr> à 0x0157DBC0&gt
>>> len(nums_sq)
Traceback (dernier appel le plus récent) :
  Fichier "<stdin>", ligne 1, in <module&gt
TypeError : object of type 'generator' has no len()

Utilisation de len() avec des tuples de longueur un

Si vous n’insérez qu’un élément dans un tuple, Python l’interprète comme un élément unique et non comme un tuple.

Voici un exemple :

>>> nums = (1)
>>> len(nums)
Traceback (dernier appel le plus récent) :
  Fichier "<stdin>", ligne 1, in <module&gt
TypeError : object of type 'int' has no len()

Ainsi, lorsque vous avez un tuple avec un seul élément, initialisez-le sous cette forme : tuple_name = (elt, ) afin qu’il soit interprété comme un tuple :

>>> nums = (1,)
>>> len(nums)
1

Résumé

Voici un résumé de ce que nous avons couvert dans ce tutoriel :

  • Vous pouvez trouver le nombre d’éléments d’une table itérative en utilisant la fonction len() de Python. La syntaxe pour utiliser la fonction length est : len(any-valid-iterable).
  • Cela inclut les séquences telles que les listes, les tuples et les chaînes de caractères. Et d’autres collections telles que les dictionnaires et les ensembles.
  • La fonction len() est couramment utilisée dans les boucles et les compréhensions.
  • Vous pouvez également utiliser la fonction len() comme paramètre clé lorsque vous devez personnaliser le tri en fonction de la longueur. Par exemple : trier une liste de chaînes de caractères en fonction de leur longueur.

Apprenez ensuite à utiliser la fonction sum() de Python.