Découvrez tout ce qu’il faut savoir sur la fonction `sum()` en Python, de sa syntaxe à son utilisation avec divers itérables, le tout illustré par des exemples de code pratiques.
Lorsqu’on manipule des itérables en Python, comme par exemple une liste de nombres, une opération fréquente consiste à calculer la somme de tous les éléments de cette liste. Cette opération est aussi courante avec d’autres types d’itérables, tels que les tuples et les ensembles.
Plusieurs méthodes permettent d’obtenir ce résultat, mais la méthode recommandée par la communauté Python consiste à utiliser la fonction intégrée `sum()`.
Nous allons commencer par explorer d’autres approches, comme l’utilisation d’une boucle et la définition d’une fonction. Ensuite, nous étudierons la syntaxe de la fonction `sum()` en Python et l’illustrerons par des exemples de code pour une meilleure compréhension.
Calcul de la somme des valeurs dans un itérable Python
Vous pouvez tester le code dans un interpréteur Python (REPL). Ou vous pouvez utiliser un éditeur Python en ligne.
Prenons comme exemple la liste de nombres suivante :
>>> nums = [2,8,5,3,11,7,9]
Notre objectif est d’obtenir la somme de tous les nombres de cette liste. Nous aborderons bientôt la fonction `sum()` de Python, mais commençons par d’autres méthodes possibles, telles que:
- L’utilisation d’une simple boucle `for`
- L’utilisation de la fonction `reduce()` du module `functools`
- La définition d’une fonction personnalisée
Utilisation de boucles
Pour additionner tous les éléments d’une liste, nous pouvons utiliser une boucle `for` de la manière suivante :
- Initialiser une variable `total` à zéro.
- Parcourir chaque nombre de la liste.
- Ajouter chaque nombre à la variable `total`.
>>> nums = [2,8,5,3,11,7,9] >>> total = 0 >>> for num in nums: ... total += num ... >>> total 45
Utilisation de la fonction `reduce()`
Une autre approche pour additionner les éléments d’un itérable est d’utiliser la fonction `reduce()`. Cette fonction, intégrée au module `functools` de Python, prend en arguments une fonction et un itérable. Elle applique la fonction successivement aux éléments de l’itérable, réduisant ainsi l’ensemble à une seule valeur.
Ici, nous utilisons une fonction lambda pour définir l’addition de deux nombres, et nous fournissons la liste de nombres comme itérable.
>>> nums = [2,8,5,3,11,7,9] >>> from functools import reduce >>> total = reduce(lambda n1, n2: n1 + n2, nums) >>> total 45
La fonction `reduce()` opère en additionnant successivement deux nombres, de gauche à droite, jusqu’à obtenir une seule valeur résultant de l’addition de tous les nombres.
Utilisation d’une fonction personnalisée
Nous pouvons également définir notre propre fonction pour réaliser cette tâche. Ici, nous définissons une fonction `sum_list` qui :
- Prend une liste de nombres en argument et
- Retourne la somme des éléments de cette liste.
Le corps de la fonction utilise la boucle que nous avons vue précédemment. La définition d’une fonction nous offre la possibilité de réutiliser le code.
>>> def sum_list(some_list): ... total = 0 ... for num in some_list: ... total += num ... return total ...
L’appel de la fonction `sum_list()` avec `nums` comme argument renvoie la somme 45 :
>>> nums = [2,8,5,3,11,7,9] >>> total = sum_list(nums) >>> total 45
Maintenant, découvrons la fonction intégrée `sum()`. Elle est non seulement concise, mais aussi robuste, car elle fonctionne avec différents types d’itérables et de données.
Syntaxe de la fonction `sum()` en Python
La syntaxe d’utilisation de la fonction `sum()` est la suivante :
sum(iterable, start)
Où :
- `iterable` est un argument obligatoire. Il peut s’agir de n’importe quel itérable pour lequel l’opération d’addition est valide, comme une liste ou un tuple de nombres. L’appel de la fonction `sum()` avec des chaînes de caractères en Python génère une exception `TypeError` (nous y reviendrons).
- `start` est un argument optionnel. Il s’agit généralement d’une valeur numérique qui est ajoutée à la somme calculée. Cela peut être utile pour ajouter une valeur constante au résultat.
Maintenant que nous avons compris la syntaxe de la fonction `sum()` de Python, utilisons-la pour additionner des itérables.
Addition d’itérables avec la fonction `sum()`
#1. Liste
Calculons la somme des nombres de la liste `nums` à l’aide de la fonction `sum()` :
>>> nums = [2,8,5,3,11,7,9] >>> sum_1 = sum(nums) >>> sum_1 45
Utilisation de la valeur de départ facultative
Pour ajouter une valeur constante à la somme, nous pouvons utiliser la fonction `sum()` avec la valeur de départ optionnelle. Ici, nous passons une valeur de départ de 100 en tant qu’argument positionnel :
>>> sum_start = sum(nums,100) >>> sum_start 145
La valeur de départ peut également être spécifiée en tant qu’argument nommé :
>>> sum_start = sum(nums,start=10) >>> sum_start 55
#2. Tuple
La fonction `sum()` fonctionne aussi avec les tuples. Nous créons un tuple `nums_tuple` en convertissant la liste `nums` en tuple :
>>> nums_tuple = tuple(nums) >>> nums_tuple (2, 8, 5, 3, 11, 7, 9)
>>> sum_2 = sum(nums_tuple) >>> sum_2 45
#3. Ensemble
Nous pouvons également utiliser la fonction `sum()` avec un ensemble de nombres :
>>> nums_set = set(nums)
>>> nums_set
{2, 3, 5, 7, 8, 9, 11}Ici, nous transformons la liste `nums` en un ensemble Python et nous calculons la somme des éléments de `nums_set`.
>>> sum_3 = sum(nums_set) >>> sum_3 45
#4. Dictionnaire
Considérons le dictionnaire `student_dict` suivant, avec des clés numériques. Observez ce qui se passe lorsque nous appelons la fonction `sum()` avec ce dictionnaire en argument.
>>> students_dict = {1:106,2:112,3:127}
>>> sum_4 = sum(students_dict)
>>> sum_4
6Par défaut, la fonction `sum()` renvoie la somme des clés.
Somme des clés
Nous savons que le comportement par défaut est d’additionner les clés du dictionnaire.
Cependant, vous pouvez rendre cela plus explicite en utilisant la méthode `keys()` du dictionnaire pour accéder aux clés. Passez ensuite la liste des clés à la fonction `sum()` :
>>> sum_keys = sum(students_dict.keys()) >>> sum_keys 6
Somme des valeurs
Si vous souhaitez plutôt additionner les valeurs du dictionnaire, accédez aux valeurs en appelant la méthode `values()` sur l’objet dictionnaire :
>>> sum_vals = sum(students_dict.values()) >>> sum_vals 345
Utilisation de la fonction `sum()` de Python avec d’autres types de données numériques
Jusqu’à présent, nous avons vu comment utiliser la fonction `sum()` avec des itérables d’entiers. Explorons maintenant quelques exemples avec d’autres types de données numériques.
Nombres complexes
La fonction `sum()` peut également être utilisée pour additionner des nombres complexes. Dans cet exemple, `nums_c` est une liste de nombres complexes :
>>> nums_c = [3 + 4j, 1 + 2j] >>> sum_c = sum(nums_c) >>> sum_c (4+6j)
Nombres à virgule flottante
Ici, nous utilisons la fonction `sum()` pour additionner la liste des nombres à virgule flottante `nums_f` :
>>> nums_f = [1.8,2.5,3.6,7.2] >>> sum_f = sum(nums_f) >>> sum_f 15.100000000000001
Pour une meilleure précision dans le résultat de l’addition de nombres à virgule flottante, vous pouvez utiliser la fonction `fsum()` du module `math` pour additionner des itérables contenant des valeurs à virgule flottante.
Aplatir avec la fonction `sum()`
Voyons maintenant comment la fonction `sum()` peut être utilisée pour aplatir et concaténer des itérables.
Aplatir une liste
Supposons que nous ayons une liste imbriquée :
>>> lists = [[2,4,6],[3,5,7]]
Lorsque nous appelons la fonction `sum()` en fournissant cette liste imbriquée comme argument avec une liste vide comme valeur de départ :
>>> sum(lists,[]) [2, 4, 6, 3, 5, 7]
Nous constatons que la liste imbriquée a été aplatie en une seule liste de nombres.
De la même manière, si nous considérons que la liste est de la forme `l3 = [l1,l2]`, la fonction `sum()` concatène les deux listes `l1` et `l2` imbriquées dans la liste `l3`.
En guise d’exercice rapide, essayez d’utiliser la fonction `sum()` sur d’autres itérables imbriqués.
Piège courant : n’utilisez pas la fonction `sum()` de Python avec des chaînes
Puisque nous avons vu que la fonction `sum()` peut être utilisée pour aplatir et concaténer des listes (et d’autres itérables comme les tuples), il est tentant de penser que nous pouvons aussi l’utiliser pour concaténer des chaînes de caractères.
Cependant, si vous essayez de le faire, vous rencontrerez une `TypeError` :
>>> sum(['a','b','c'],'') Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: sum() can't sum strings [use ''.join(seq) instead]
La fonction `sum()` ne peut donc pas être utilisée pour additionner (ou concaténer) des chaînes de caractères.
Cependant, comme l’indique le message d’erreur ci-dessus, vous pouvez utiliser la méthode `join()` pour concaténer une liste de chaînes en une seule chaîne.
>>> ''.join(['a','b','c']) 'abc'
Conclusion
Dans ce tutoriel, nous avons appris à utiliser la fonction intégrée `sum()` pour calculer la somme de tous les éléments d’un itérable. La syntaxe générale pour utiliser la fonction `sum()` est : `sum(iterable, start)`, où `iterable` est un argument obligatoire et `start` est un argument facultatif.
Nous avons ensuite étudié plusieurs exemples pour comprendre comment utiliser la fonction `sum()` avec des itérables comme les listes, les tuples, les ensembles et les dictionnaires. Enfin, nous avons examiné comment la fonction `sum()` peut être utilisée pour aplatir et concaténer des itérables, à l’exception des chaînes de caractères en Python.
J’espère que vous avez trouvé ce tutoriel utile. Vous pouvez maintenant consulter ce tutoriel sur la fonction `map` de Python.