Retour au cours

nombres et opérateurs : arithmétique, affectation, arrondis

dans cette leçon, vous manipulez les nombres, leurs opérateurs, l’ordre d’évaluation et les arrondis. vous verrez aussi des fonctions pratiques comme abs, round, divmod, et un aperçu de math.

objectifs

  • utiliser les opérateurs arithmétiques + - * / // % **
  • comprendre la précédence et l’usage des parenthèses
  • employer les opérateurs d’affectation (+=, -=, *=, etc.)
  • arrondir et formater des nombres correctement
  • connaître abs, pow, sum, min, max, divmod, et math.isclose

types numériques en bref

  • int : entier de précision arbitraire (pas de dépassement, très grands nombres possibles)
  • float : nombre à virgule flottante en double précision (peut introduire de petites erreurs de représentation)
n = 10          # int
x = 3.5         # float
type(n), type(x)

arithmétique de base

a = 7 + 3       # 10
b = 7 - 3       # 4
c = 7 * 3       # 21
d = 7 / 2       # 3.5   division réelle -> float
e = 7 // 2      # 3     division entière (plancher)
f = 7 % 2       # 1     reste (modulo)
g = 2 ** 3      # 8     puissance

relation fondamentale

a, b = 23, 5
q = a // b
r = a % b
a == q * b + r   # True

cas avec nombres négatifs (modulo aligné sur la division par plancher)

-7 // 3   # -3
-7 % 3    # 2   car (-3 * 3) + 2 == -7

utilisez divmod(a, b) pour obtenir (quotient, reste) en une fois :

divmod(23, 5)   # (4, 3)

précédence et parenthèses

ordre simplifié (du plus fort au plus faible) :

  1. **
  2. unaire +x, -x
  3. *, /, //, %
  4. +, -
2 + 3 * 4        # 14
(2 + 3) * 4      # 20
2 ** 3 ** 2      # 512  (car 2 ** (3 ** 2))
-(3 ** 2)        # -9
(-3) ** 2        # 9

toujours préférer des parenthèses explicites pour éviter l’ambiguïté.

opérateurs d’affectation composés

n = 10
n += 5     # 15
n -= 2     # 13
n *= 3     # 39
n /= 4     # 9.75
n //= 2    # 4
n %= 3     # 1
n **= 4    # 1

arrondir et formater

round(x, ndigits) arrondit à ndigits décimales. en cas d’égalité pile (ties), python utilise l’arrondi pair (banker’s rounding).

round(3.14159, 2)    # 3.14
round(2.5)           # 2  (2 est pair)
round(3.5)           # 4  (4 est pair)

formater avec f-strings

prix = 12.9
tva = 0.2
ttc = prix * (1 + tva)
f"ttc: {ttc:.2f} €"   # 'ttc: 15.48 €'

plancher/plafond via math

import math
math.floor(3.9)   # 3
math.ceil(3.1)    # 4

utilitaires numériques utiles

abs(-8)                 # 8
pow(2, 5)               # 32 (identique à 2 ** 5)
pow(2, 5, 7)            # 4  (puissance modulaire efficace)
sum([1, 2, 3])          # 6
min(4, 2, 9)            # 2
max(4, 2, 9)            # 9

comparer des floats de façon sûre

import math
math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-09, abs_tol=0.0)  # True

constantes et racines

import math
math.pi, math.e
math.sqrt(9)            # 3.0
math.hypot(3, 4)        # 5.0

tests de validité

import math
math.isfinite(1.0)      # True
math.isfinite(float("inf"))  # False
math.isnan(float("nan"))     # True

pièges à connaître

  • précision flottante :

    0.1 + 0.2            # 0.30000000000000004

    formatez l’affichage ou utilisez math.isclose pour comparer.

  • division par zéro :

    # 1 / 0 -> zerodivisionerror

  • domaine invalide :

    # math.sqrt(-1) -> valueerror (utiliser cmath pour les complexes)

mini exemples exécutables

# panier ttc avec deux articles
from math import isclose
p1, p2, tva = 9.90, 14.50, 0.2
total_ht = p1 + p2
total_ttc = total_ht * (1 + tva)
print(f"total ttc: {total_ttc:.2f} €")
print("approx 29.28 ?", isclose(total_ttc, 29.28, rel_tol=1e-9))

# diviser une somme en euros/pièces
montant = 987
billets_100, reste = divmod(montant, 100)
billets_20, reste = divmod(reste, 20)
pieces_2, pieces_1 = divmod(reste, 2)
print(billets_100, billets_20, pieces_2, pieces_1)

exercices

  1. intérêts simples écrivez interets_simples(capital, taux, annees) qui renvoie capital × taux × années. affichez le résultat pour 1000, 0.03, 5 avec 2 décimales.
  2. monnaie rendue à partir d’un montant en centimes (ex: 1267), calculez le nombre de billets/pièces de 500, 200, 100, 50, 20, 10, 5, 2, 1 avec divmod. affichez un résumé.
  3. aire d’un cercle lisez un rayon en entrée, calculez l’aire π r² et affichez-la en 3 décimales. utilisez math.pi.
  4. précédence en pratique évaluez mentalement puis en code : 3 + 2 * 2 ** 3, ((3 + 2) * 2) ** 3, -2 ** 2, (-2) ** 2.
  5. comparaison flottante écrivez un test qui vérifie que 0.1 + 0.7 est “égal” à 0.8 avec math.isclose, puis affichez les deux valeurs formatées sur 20 décimales pour observer la différence.
  6. croissance composée calculez le capital final après 12 mois avec un taux mensuel de 1 % à partir de 500. utilisez une boucle et *= (1 + taux).

dépannage

  • zerodivisionerror vérifiez vos dénominateurs avant de diviser. gérez le cas 0 séparément.
  • typeerror: unsupported operand type(s) mélange de types incompatibles (ex: 3 + "2"). convertissez explicitement (int("2")).
  • résultats flottants inattendus utilisez round pour l’affichage, math.isclose pour comparer, ou decimal (plus tard) pour des montants financiers.
  • valueerror sur une fonction math entrée hors domaine (ex: racine d’un négatif). contrôlez vos entrées ou changez de fonction (cmath pour complexes).

Sujets abordés