La fonction len() est l'une des fonctions les plus utilisées en Python. Elle permet de mesurer la taille ou la longueur d'un objet, qu'il s'agisse d'une chaîne de caractères, d'une list, d'un tuple, d'un dict ou de tout autre objet itérable. Maîtriser cette fonction est essentiel pour tout développeur Python, et vous la retrouverez dans pratiquement tous les programmes que vous écrirez. Si vous souhaitez approfondir vos connaissances en Python, nous vous recommandons de suivre notre formation complète sur Python qui couvre en détail cette fonction et bien d'autres concepts fondamentaux.
Définition de la fonction len()
La fonction len() est une fonction native (built-in) de Python qui retourne le nombre d'éléments contenus dans un objet. Le terme "len" est l'abréviation du mot anglais "length", qui signifie "longueur" en français.
La syntaxe de cette fonction est particulièrement simple :
len(objet)Cette fonction accepte un seul argument : l'objet dont vous souhaitez connaître la taille. Elle retourne un entier représentant le nombre d'éléments de cet objet.
La fonction len() fonctionne avec tous les types de séquences et collections en Python, ce qui en fait un outil polyvalent et indispensable dans votre boîte à outils de développeur.
Les types d'objets compatibles avec len()
La fonction len() peut être utilisée avec de nombreux types d'objets en Python. Voici un tableau récapitulatif des principaux types compatibles :
| Type d'objet | Ce que len() retourne |
|---|---|
| str (chaîne) | Nombre de caractères |
| list | Nombre d'éléments dans la liste |
| tuple | Nombre d'éléments dans le tuple |
| dict | Nombre de paires clé-valeur |
| sets | Nombre d'éléments uniques |
| frozenset | Nombre d'éléments uniques |
| range | Nombre d'éléments dans la séquence |
| bytes | Nombre d'octets |
| bytearray | Nombre d'octets |
Exemples pratiques avec len()
Mesurer la longueur d'une chaîne de caractères
L'utilisation la plus courante de len() est sans doute la mesure de la longueur d'une chaîne de caractères. Chaque caractère compte, y compris les espaces et les caractères spéciaux.
# Mesurer la longueur d'une chaîne simple
message = "Bonjour Python"
longueur = len(message)
print(longueur) # Affiche : 14
# Les espaces comptent comme des caractères
phrase = "Hello World"
print(len(phrase)) # Affiche : 11
# Les caractères spéciaux et accentués comptent aussi
texte_accent = "été"
print(len(texte_accent)) # Affiche : 3
# Une chaîne vide a une longueur de 0
chaine_vide = ""
print(len(chaine_vide)) # Affiche : 0
Compter les éléments d'une liste
Avec les list, la fonction len() retourne le nombre d'éléments contenus dans la liste, peu importe leur type.
# Liste de nombres
nombres = [1, 2, 3, 4, 5]
print(len(nombres)) # Affiche : 5
# Liste mixte avec différents types
mixte = [1, "texte", 3.14, True, None]
print(len(mixte)) # Affiche : 5
# Liste contenant d'autres listes (listes imbriquées)
imbriquee = [[1, 2], [3, 4, 5], [6]]
print(len(imbriquee)) # Affiche : 3 (nombre de sous-listes)
# Liste vide
liste_vide = []
print(len(liste_vide)) # Affiche : 0Attention : pour une liste imbriquée, len() compte uniquement les éléments du premier niveau. Pour compter tous les éléments y compris ceux des sous-listes, vous devrez implémenter une logique récursive.
Utiliser len() avec les tuples
Le comportement de len() avec les tuple est identique à celui avec les listes.
# Tuple simple
coordonnees = (10, 20, 30)
print(len(coordonnees)) # Affiche : 3
# Tuple avec un seul élément
singleton = (42,)
print(len(singleton)) # Affiche : 1
# Tuple vide
tuple_vide = ()
print(len(tuple_vide)) # Affiche : 0
Compter les entrées d'un dictionnaire
Pour les dict, la fonction len() retourne le nombre de paires clé-valeur.
# Dictionnaire simple
utilisateur = {
"nom": "Dupont",
"prenom": "Jean",
"age": 30,
"ville": "Paris"
}
print(len(utilisateur)) # Affiche : 4
# Dictionnaire vide
dict_vide = {}
print(len(dict_vide)) # Affiche : 0
# Compter séparément les clés ou les valeurs
print(len(utilisateur.keys())) # Affiche : 4
print(len(utilisateur.values())) # Affiche : 4
Mesurer la taille des ensembles (sets)
Les sets ne contiennent que des éléments uniques. La fonction len() retourne donc le nombre d'éléments distincts.
# Set avec des éléments uniques
fruits = {"pomme", "banane", "orange", "kiwi"}
print(len(fruits)) # Affiche : 4
# Les doublons sont automatiquement éliminés
nombres = {1, 2, 2, 3, 3, 3}
print(len(nombres)) # Affiche : 3 (seulement les valeurs uniques)
# Frozenset fonctionne de la même manière
immutable_set = frozenset([1, 2, 3, 4, 5])
print(len(immutable_set)) # Affiche : 5
Utiliser len() avec range
La fonction len() fonctionne également avec les objets range, ce qui peut être très utile pour connaître le nombre d'itérations d'une boucle.
# Range simple
sequence = range(10)
print(len(sequence)) # Affiche : 10 (de 0 à 9)
# Range avec début et fin
sequence2 = range(5, 15)
print(len(sequence2)) # Affiche : 10 (de 5 à 14)
# Range avec pas
sequence3 = range(0, 20, 2)
print(len(sequence3)) # Affiche : 10 (0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
Cas d'utilisation avancés
Valider la longueur des entrées utilisateur
La fonction len() est très utile pour valider les données saisies par les utilisateurs.
def valider_mot_de_passe(mot_de_passe):
"""Vérifie que le mot de passe respecte les critères de longueur."""
if len(mot_de_passe) < 8:
return "Le mot de passe doit contenir au moins 8 caractères."
elif len(mot_de_passe) > 128:
return "Le mot de passe ne doit pas dépasser 128 caractères."
else:
return "Longueur du mot de passe valide."
# Test de la fonction
print(valider_mot_de_passe("abc")) # Trop court
print(valider_mot_de_passe("monMotDePasse123")) # Valide
Vérifier si une collection est vide
Comparer la longueur à zéro est une façon courante de vérifier si une collection est vide, bien que Python offre des alternatives plus idiomatiques.
ma_liste = []
# Méthode avec len()
if len(ma_liste) == 0:
print("La liste est vide")
# Méthode pythonique (recommandée)
if not ma_liste:
print("La liste est vide")
# Vérifier qu'une liste contient des éléments
if len(ma_liste) > 0:
print("La liste contient des éléments")
# Méthode pythonique équivalente
if ma_liste:
print("La liste contient des éléments")En Python, une collection vide est évaluée comme False dans un contexte booléen, tandis qu'une collection non vide est évaluée comme True. Cette propriété permet d'écrire du code plus concis et idiomatique.
Parcourir une séquence avec son index
La fonction len() est souvent utilisée en combinaison avec range() pour parcourir une séquence tout en ayant accès aux indices.
prenoms = ["Alice", "Bob", "Charlie", "Diana"]
# Parcours avec len() et range()
for i in range(len(prenoms)):
print(f"Index {i}: {prenoms[i]}")
# Résultat :
# Index 0: Alice
# Index 1: Bob
# Index 2: Charlie
# Index 3: Diana
# Alternative plus pythonique avec enumerate()
for i, prenom in enumerate(prenoms):
print(f"Index {i}: {prenom}")
Implémenter len() dans vos propres classes
Vous pouvez rendre vos propres class compatibles avec la fonction len() en implémentant la méthode spéciale __len__.
class Panier:
"""Classe représentant un panier d'achat."""
def __init__(self):
self.articles = []
def ajouter(self, article):
"""Ajoute un article au panier."""
self.articles.append(article)
def __len__(self):
"""Retourne le nombre d'articles dans le panier."""
return len(self.articles)
# Utilisation
panier = Panier()
print(len(panier)) # Affiche : 0
panier.ajouter("Pommes")
panier.ajouter("Pain")
panier.ajouter("Lait")
print(len(panier)) # Affiche : 3
Bonnes pratiques avec len()
Éviter les appels répétés à len()
Si vous devez utiliser la longueur d'un objet plusieurs fois, stockez-la dans une variable pour éviter des appels répétés.
# Mauvaise pratique : appels multiples à len()
for i in range(len(ma_liste)):
if i < len(ma_liste) - 1: # Appel inutile
print(ma_liste[i])
# Bonne pratique : stocker la longueur
longueur = len(ma_liste)
for i in range(longueur):
if i < longueur - 1:
print(ma_liste[i])
Préférer les méthodes pythoniques
Python offre souvent des alternatives plus élégantes que l'utilisation directe de len().
# Au lieu de :
if len(liste) == 0:
pass
# Préférez :
if not liste:
pass
# Au lieu de :
for i in range(len(liste)):
element = liste[i]
# Préférez :
for element in liste:
pass
# Ou si vous avez besoin de l'index :
for i, element in enumerate(liste):
pass
Gérer les erreurs TypeError
La fonction len() lève une exception TypeError si vous l'appelez sur un objet qui ne supporte pas la notion de longueur.
# Types qui ne supportent pas len()
try:
print(len(42)) # int
except TypeError as e:
print(f"Erreur : {e}")
try:
print(len(3.14)) # float
except TypeError as e:
print(f"Erreur : {e}")
try:
print(len(None)) # NoneType
except TypeError as e:
print(f"Erreur : {e}")
# Vérifier si un objet supporte len()
def supporte_len(objet):
"""Vérifie si un objet supporte la fonction len()."""
try:
len(objet)
return True
except TypeError:
return False
print(supporte_len([1, 2, 3])) # True
print(supporte_len(42)) # False
Complexité algorithmique de len()
La fonction len() a une complexité temporelle de O(1) (temps constant) pour les types natifs de Python. Cela signifie que le temps d'exécution ne dépend pas de la taille de l'objet.
Cette efficacité est possible car Python stocke la longueur des objets comme attribut interne, plutôt que de la calculer à chaque appel.
import time
# La longueur est calculée en temps constant
petite_liste = list(range(10))
grande_liste = list(range(10_000_000))
# Les deux opérations prennent sensiblement le même temps
debut = time.time()
len(petite_liste)
print(f"Petite liste : {time.time() - debut:.10f} secondes")
debut = time.time()
len(grande_liste)
print(f"Grande liste : {time.time() - debut:.10f} secondes")
Questions fréquentes
Quelle est la différence entre len() et la méthode count() ?
La fonction len() retourne le nombre total d'éléments dans une séquence, tandis que la méthode count() retourne le nombre d'occurrences d'un élément spécifique. Par exemple, len([1, 2, 2, 3]) retourne 4, alors que [1, 2, 2, 3].count(2) retourne 2 (car le nombre 2 apparaît deux fois).
Peut-on utiliser len() sur un générateur ou un itérateur ?
Non, la fonction len() ne fonctionne pas directement avec les générateurs et les itérateurs, car leur longueur n'est pas connue à l'avance. Pour compter les éléments d'un générateur, vous devez soit le convertir en liste avec len(list(generateur)), soit utiliser une boucle avec un compteur. Attention cependant, convertir un générateur en liste le consomme entièrement et utilise de la mémoire.
Comment compter les éléments d'une liste imbriquée ?
Pour compter tous les éléments d'une liste imbriquée (y compris ceux des sous-listes), vous devez utiliser une fonction récursive :
def compter_elements(liste):
total = 0
for element in liste:
if isinstance(element, list):
total += compter_elements(element)
else:
total += 1
return total
liste_imbriquee = [[1, 2], [3, [4, 5]], 6]
print(compter_elements(liste_imbriquee)) # Affiche : 6
Comment apprendre à maîtriser Python et ses fonctions natives ?
Pour maîtriser Python et toutes ses fonctions natives comme len(), il est essentiel de pratiquer régulièrement et de suivre une formation structurée. Nous vous recommandons notre formation Python sur Believemy qui vous guidera pas à pas dans l'apprentissage du langage, des bases jusqu'aux concepts avancés, avec de nombreux exercices pratiques pour consolider vos acquis.