<jupyter_start><jupyter_text>Les opérations mathématiques  Les types numériques- `int` : nombres entiers, naturels (0, 1, 2…) ou relatifs (-2, -1, 0, +1, +2…)- `float` : nombres décimaux- `complex` : nombres complexes (constante complexe, en python, se note `j`)<jupyter_code>a, b = 2, 2.0
c = (3 / 4j) + 1.5j
print(f'{a} is instance of {type(a)}')
print(f'{b} is instance of {type(b)}')
print(f'{c} is instance of {type(c)}')<jupyter_output><empty_output><jupyter_text>Les opérateurs mathématiques<jupyter_code># addition
print(a + b)
# subtraction
print(a - b)
# multiplication
print(a * a)
# divison
print(b / a)
# exponentiation
print(a ** b)
# modulo
print((a + b) % b)<jupyter_output><empty_output><jupyter_text>Priorité des opérations (PEMDAS) :- Parenthèses- Exposants- Multiplication et Division- Addition et SoustractionÀ niveau égal, l’exécution s’effectue de gauche à droite  Les opérateurs de comparaisonSigne `=` pour l’affectation : signifie qu’une valeur a pour référence un nom.    Le test d’égalité s’effectue avec l’opérateur `==`. Il renvoie un booléen (vrai ou faux).<jupyter_code>print(a == b)<jupyter_output><empty_output><jupyter_text>Autres opérateurs :- `<` : strictement inférieur à- `>` : strictement supérieur à- `<=` : inférieur ou égal à- `>=` : supérieur ou égal à- `!=` : différent de- `is` : strictement identique à- `is not` : non identique à<jupyter_code>print(a is b)<jupyter_output><empty_output><jupyter_text>Techniques courantes Arrondir un nombreDès que l’on manipule autre chose que des entiers, il est fréquent d’obtenir un nombre avec quantité de décimales. La fonction `round()` permet d’arrondir le résultat à `n` décimales près :<jupyter_code>div = 1 / 3
round(div, 2)<jupyter_output><empty_output><jupyter_text>Le module `math` propose des fonctions similaires pour arrondir à l’entier supérieur ou inférieur :<jupyter_code>from math import ceil, floor

print(ceil(div))
print(floor(div))<jupyter_output><empty_output><jupyter_text>Il est tentant de croire que le résultat de l’appel à la fonction `floor()` est identique à celui d’un `round()` à zéro décimale près. C’est faux pour deux raisons :- `round()` renvoie un objet de type `float` ;- `round()` effectue à un arrondi à l’entier le plus proche.<jupyter_code>zero = round(0.3333, 0)
un = round(0.6666, 0)
print(un, '!=', zero, '!=', floor(div))<jupyter_output><empty_output><jupyter_text>Contrainte de typeLorsque l’on définit des fonctions qui manipulent des nombres, il est primordial de bien contrôler le type de données en entrée. Parmi les différentes solutions, citons la fonction `insinstance()` qui vérifie la conformité d’un objet à un type donné :<jupyter_code># d is not of string type
d = "12"
# Condition is not satisfied
if isinstance(d, int):
    print(d / 3)<jupyter_output><empty_output><jupyter_text>Obtenir un nombre aléatoireEn parlant de nombre aléatoire, on effectue un raccourci pour désigner en vérité des nombres pseudo-aléatoires. En effet, si l’on génère une grande quantité de ces nombres, on remarque que certains ressortent plus souvent que d’autres. C’est la règle : ne jamais se fier à un algorithme pour obtenir des nombres aléatoires. Malgré tout, les générateurs de nombres pseudo-aléatoires se rapprochent le plus possible de la loi uniforme discrète afin de garantir à chaque nombre la même chance de sortir. C’est le cas du module `random` et de sa méthode `randint()` :<jupyter_code>from random import randint

# An integer between 1 and 100, included
randint(1, 100)<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup