Cet article explique les opérateurs arithmétiques en Python.
Pour les nombres, tels que les entiers ( 𝐢𝐧𝐭 ) et les nombres à virgule flottante ( 𝐟𝐥𝐨𝐚𝐭 ), vous pouvez effectuer des opérations arithmétiques de base telles que l’addition, la soustraction, la multiplication, la division et l’exponentiation. Pour les listes ou les chaînes, vous pouvez effectuer des opérations telles que la concaténation et la répétition.
Les astérisques * et ** sont également utilisés lors de la définition ou de l’appel d’une fonction pour décompresser des arguments.
- *𝐚𝐫𝐠𝐬 et **𝐤𝐰𝐚𝐫𝐠𝐬 en Python (arguments de longueur variable)
- Décompresser et transmettre des arguments de liste, de tuple et de dict à une fonction en Python
Opérations arithmétiques
Ajout : l’opérateur +
L’opérateur + effectue l’addition.
print(10 + 3) # 13 Soustraction : l’opérateur –
L’opérateur – effectuer une soustraction.
print(10 - 3) # 7 Multiplication : l’opérateur *
L’opérateur * effectue la multiplication.
print(10 * 3) # 30 Division : l’opérateur /
L’opérateur / effectuer la division.
print(10 / 3) # 3.3333333333333335 print(0.1 / 0.03) # 3.3333333333333335 Dans Python 2, la division entre entiers renvoyait un entier ( 𝐢𝐧𝐭 ). Depuis Python 3, elle renvoie un nombre à virgule flottante ( 𝐟𝐥𝐨𝐚𝐭 ).
Division entière : l’opérateur //
L’opérateur // effectue une division entière.
print(10 // 3) # 3 print(0.1 // 0.03) # 3.0 Si des nombres à virgule flottante ( 𝐟𝐥𝐨𝐚𝐭 ) sont inclus dans le calcul, le résultat est renvoyé sous la forme d’un 𝐟𝐥𝐨𝐚𝐭 même s’il représente une entière valeur.
Reste de division (mod) : l’opérateur %
L’opérateur % calcule le reste de la division.
print(10 % 3) # 1 print(0.1 % 0.03) # 0.010000000000000009 Comme dans l’exemple ci-dessus, les nombres à virgule flottante ( 𝐟𝐥𝐨𝐚𝐭 ) peuvent introduire des erreurs numériques. Consultez l’article suivant pour plus de détails.
Il existe également la fonction 𝐝𝐢𝐯𝐦𝐨𝐝() qui renvoie le quotient et le reste ensemble.
Exponentiation : l’opérateur **
L’opérateur ** effectue l’exponentiation.
Vous pouvez également calculer la puissance des nombres à virgule flottante et des valeurs négatives. 0 élevé à la puissance 0 est défini comme 1 .
print(10**3) # 1000 print(2**0.5) # 1.4142135623730951 print(10**-2) # 0.01 print(0**0) # 1 Z𝐞𝐫𝐨D𝐢𝐯𝐢𝐬𝐢𝐨𝐧E𝐫𝐫𝐨𝐫
La division par 0 donne un Z𝐞𝐫𝐨D𝐢𝐯𝐢𝐬𝐢𝐨𝐧E𝐫𝐫𝐨𝐫 .
# print(10 / 0) # ZeroDivisionError: division by zero # print(10 // 0) # ZeroDivisionError: integer division or modulo by zero # print(10 % 0) # ZeroDivisionError: integer modulo by zero # print(0**-1) # ZeroDivisionError: 0.0 cannot be raised to a negative power Pour la gestion des exceptions, reportez-vous à l’article suivant.
Opérateurs d’affectation composés
Les opérateurs, tels que + et – , renvoient un nouvel objet. Notez que les chaînes f sont utilisées ici pour générer la valeur des variables.
a = 10 b = 3 c = a + b print(f'{a = }') print(f'{b = }') print(f'{c = }') # a = 10 # b = 3 # c = 13 Les opérateurs combinés avec le signe = , comme += , sont appelés opérateurs d’affectation composés. Le résultat est affecté et mis à jour sur l’objet du côté gauche.
a = 10 b = 3 a += b print(f'{a = }') print(f'{b = }') # a = 13 # b = 3 Outre l’opérateur += , il existe les opérateurs -= , *= , /= , %= et **= .
a = 10 b = 3 a %= b print(f'{a = }') print(f'{b = }') # a = 1 # b = 3 a = 10 b = 3 a **= b print(f'{a = }') print(f'{b = }') # a = 1000 # b = 3 Opérations impliquant 𝐢𝐧𝐭 et 𝐟𝐥𝐨𝐚𝐭
Si un nombre à virgule flottante ( 𝐟𝐥𝐨𝐚𝐭 ) est inclus dans un calcul avec les opérateurs + , – ou * , le résultat est renvoyé sous la forme d’un 𝐟𝐥𝐨𝐚𝐭 , même s’il représente une valeur entière.
print(2 + 3.0) print(type(2 + 3.0)) # 5.0 # <class 'float'> En Python 3, l’opérateur / renvoie un 𝐟𝐥𝐨𝐚𝐭 même si le calcul implique des entiers et que le résultat est une valeur entière.
print(10 / 2) print(type(10 / 2)) # 5.0 # <class 'float'> L’opérateur ** renvoie un 𝐢𝐧𝐭 si le calcul implique des entiers. Cependant, si des nombres à virgule flottante ou des valeurs négatives sont impliqués, le résultat devient un 𝐟𝐥𝐨𝐚𝐭 , même s’il représente une valeur entière.
print(2**3) print(type(2**3)) # 8 # <class 'int'> print(2.0**3) print(type(2.0**3)) # 8.0 # <class 'float'> print(25**0.5) print(type(25**0.5)) # 5.0 # <class 'float'> print(0.01**-2) print(type(0.01**-2)) # 10000.0 # <class 'float'> Priorité des opérateurs
En Python, la priorité des opérateurs suit les mêmes règles qu’en arithmétique standard.
Les deux expressions suivantes sont équivalentes.
print(100 / 10**2 + 2 * 3 - 5) # 2.0 print(100 / (10**2) + (2 * 3) - 5) # 2.0 Si vous mettez une expression entre parenthèses () , cette partie sera exploitée en premier. Cela suit le même principe que dans l’arithmétique standard.
print((100 / 10) ** 2 + 2 * (3 - 5)) # 96.0 Opérations sur les listes, les tuples, les chaînes
Les opérateurs arithmétiques effectuent des opérations spécifiques sur des objets non numériques.
Concaténation : l’opérateur +
L’opérateur + effectue la concaténation sur des listes, des tuples, des chaînes et d’autres types similaires.
l1 = [1, 2, 3] l2 = [10, 20, 30] t1 = (1, 2, 3) t2 = (10, 20, 30) s1 = 'abc' s2 = 'xyz' print(l1 + l2) # [1, 2, 3, 10, 20, 30] print(t1 + t2) # (1, 2, 3, 10, 20, 30) print(s1 + s2) # abcxyz L’ajout de types incompatibles génère un T𝐲𝐩𝐞E𝐫𝐫𝐨𝐫 . Par exemple, si vous souhaitez ajouter une valeur à une liste, vous devez la concaténer sous forme de liste avec un seul élément.
# print(l1 + 4) # TypeError: can only concatenate list (not "int") to list print(l1 + [4]) # [1, 2, 3, 4] Notez qu’un tuple à élément unique nécessite une virgule à la fin.
# print(t1 + 4) # TypeError: can only concatenate tuple (not "int") to tuple print(t1 + (4,)) # (1, 2, 3, 4) L’opérateur d’affectation composé += peut également être utilisé.
l1 += l2 print(l1) # [1, 2, 3, 10, 20, 30] t1 += t2 print(t1) # (1, 2, 3, 10, 20, 30) s1 += s2 print(s1) # abcxyz Il existe d’autres moyens de concaténer des listes, des tuples et des chaînes que l’opérateur + . Consultez les articles suivants pour plus de détails.
- Ajouter un élément à une liste en Python (append, extend, insert)
- Concaténer des chaînes en Python (opérateur +, join, etc.)
Répétition : l’ opérateur *
L’opérateur * effectue une répétition sur des listes, des tuples, des chaînes, etc.
l = [1, 10, 100] t = (1, 10, 100) s = 'Abc' print(l * 3) # [1, 10, 100, 1, 10, 100, 1, 10, 100] print(t * 3) # (1, 10, 100, 1, 10, 100, 1, 10, 100) print(s * 3) # AbcAbcAbc L’opérateur * renvoie le même résultat, qu’un entier soit utilisé comme opérande de gauche (comme dans 𝐢𝐧𝐭 * 𝐥𝐢𝐬𝐭 ) ou comme opérande de droite (comme dans 𝐥𝐢𝐬𝐭 *𝐢𝐧𝐭 ).
print(3 * l) # [1, 10, 100, 1, 10, 100, 1, 10, 100] Pour les objets autres que les entiers ( 𝐢𝐧𝐭 ), une expression T𝐲𝐩𝐞E𝐫𝐫𝐨𝐫 se produit. Lorsque des entiers négatifs sont utilisés avec l’opérateur * , il renvoie une liste, un tuple ou une chaîne vide.
# print(l * 0.5) # TypeError: can't multiply sequence by non-int of type 'float' print(l * -1) # [] L’opérateur d’affectation composé *= peut également être utilisé.
l *= 3 print(l) # [1, 10, 100, 1, 10, 100, 1, 10, 100] t *= 3 print(t) # (1, 10, 100, 1, 10, 100, 1, 10, 100) s *= 3 print(s) # AbcAbcAbc L’opérateur * a une priorité plus élevée que l’opérateur + , donc l’opération * est traitée en premier. Bien entendu, vous pouvez également contrôler l’ordre de traitement avec des parenthèses () .
l1 = [1, 2, 3] l2 = [10, 20, 30] print(l1 + l2 * 2) # [1, 2, 3, 10, 20, 30, 10, 20, 30] print((l1 + l2) * 2) # [1, 2, 3, 10, 20, 30, 1, 2, 3, 10, 20, 30]