Opérateurs arithmétiques, de comparaison et logiques

Opérateurs arithmétiques : effectuer des calculs

Les opérateurs arithmétiques permettent d'effectuer des opérations mathématiques sur des nombres (entiers ou à virgule flottante).

Voici les opérateurs arithmétiques de base en Python :

• `+` (addition)
• `-` (soustraction)
• `*` (multiplication)
• `/` (division)
• `//` (division entière) : retourne le quotient de la division entière
• `%` (modulo) : retourne le reste de la division entière
• `**` (exponentiation)

Exemples :

a = 10
b = 3

print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.3333333333333335
print(a // b)  # 3
print(a % b)   # 1
print(a ** b)  # 1000

L'ordre de priorité des opérateurs est le même qu'en mathématiques (exponentiation avant multiplication/division, avant addition/soustraction). Vous pouvez utiliser des parenthèses pour modifier l'ordre des opérations.

Opérateurs de comparaison : évaluer des relations

Les opérateurs de comparaison permettent de comparer deux valeurs et retournent une valeur booléenne (`True` ou `False`).

Voici les opérateurs de comparaison en Python :

• `==` (égal à)
• `!=` (différent de)
• `>` (strictement supérieur à)
• `>=` (supérieur ou égal à)
• `<` (strictement inférieur à)
• `<=` (inférieur ou égal à)

Exemples :

a = 10
b = 5
c = 10

print(a == b)  # False
print(a != b)  # True
print(a > b)   # True
print(a < b)   # False
print(a >= c)  # True
print(a <= c)  # True

Vous pouvez comparer des nombres, des chaînes de caractères, et d'autres types de données. Pour les chaînes de caractères, la comparaison se fait selon l'ordre lexicographique (ordre alphabétique).

Opérateurs logiques : combiner des expressions booléennes

Les opérateurs logiques permettent de combiner des expressions booléennes et retournent une valeur booléenne.

Voici les opérateurs logiques en Python :

• `and` (ET logique) : retourne `True` si les deux opérandes sont vrais, `False` sinon.
• `or` (OU logique) : retourne `True` si au moins un des opérandes est vrai, `False` sinon.
• `not` (NON logique) : inverse la valeur booléenne de l'opérande (retourne `True` si l'opérande est faux, `False` si l'opérande est vrai).

Exemples :

x = True
y = False
z = True

print(x and y)     # False
print(x or y)      # True
print(not x)       # False
print(x and z)     # True
print(x and y or z) # True (le `and` est prioritaire sur le `or`)

L'évaluation des opérateurs logiques est dite "court-circuitée". Cela signifie que Python n'évalue le deuxième opérande que si c'est nécessaire pour déterminer le résultat final. Par exemple, dans l'expression `x and y`, si `x` est faux, Python n'évalue pas `y` car le résultat sera forcément faux. De même, si on avait eu `x or y`, `y` n'aurait pas été évalué car le résultat aurait forcément été `True`.

Il faut bien faire attention à l'ordre de priorité des opérateurs logiques : `not` est prioritaire sur `and`, qui est lui-même prioritaire sur `or`. Vous pouvez encore une fois utiliser des parenthèses pour modifier l'ordre d'évaluation.

Combiner les opérateurs : créer des expressions complexes

Vous pouvez combiner les opérateurs arithmétiques, de comparaison et logiques pour créer des expressions complexes. Par exemple :

age = 25
taille = 1.75

est_adulte = age >= 18
est_grand = taille > 1.80

print(est_adulte)  # True
print(est_grand)   # False

# Vérifier si la personne est un adulte ET n'est pas grand
print(est_adulte and not est_grand)  # True

Il est important d'utiliser des parenthèses pour clarifier l'ordre des opérations dans les expressions complexes, et ainsi, améliorer la lisibilité et éviter les erreurs.

Voici un exemple complet :

x = 15
y = 7
z = 10

# Vérifier si x est supérieur à y ET que la somme de y et z est supérieure à x
resultat = (x > y) and ((y + z) > x)
print(resultat)  # True

# Vérifier si x est pair OU que y est impair ET que z est un multiple de 5
resultat = (x % 2 == 0) or ((y % 2 != 0) and (z % 5 == 0))
print(resultat)  # True

Opérateurs d'affectation composés : simplifier l'écriture

Les opérateurs d'affectation composés permettent de combiner une opération arithmétique et une affectation en une seule instruction. Ils permettent de simplifier l'écriture et de rendre le code plus concis.

Par exemple, au lieu d'écrire :

x = x + 5

Vous pouvez écrire :

x += 5

Voici les opérateurs d'affectation composés en Python :

• `+=` (addition et affectation)
• `-=` (soustraction et affectation)
• `*=` (multiplication et affectation)
• `/=` (division et affectation)
• `//=` (division entière et affectation)
• `%=` (modulo et affectation)
• `**=` (exponentiation et affectation)

Exemples :

x = 10
y = 3

x += 2    # Equivalent à x = x + 2
print(x)  # 12

y *= 4    # Equivalent à y = y * 4
print(y)  # 12