In [ ]:
    
from __future__ import division, print_function
    
In [ ]:
    
13.14 + 1.2
    
    Out[ ]:
In [ ]:
    
14.34 - 1.2
    
    Out[ ]:
In [ ]:
    
6 * 9
    
    Out[ ]:
In [ ]:
    
54 / 9
    
    Out[ ]:
La division d'un nombre par zéro retourne une erreur:
In [ ]:
    
53 / 0
    
    Out[ ]:
In [ ]:
    
2 ** 8
    
    Out[ ]:
ATTENTION
En Python, l'opérateur ^ ne calcule pas l'exposant, mais fait plutôt une opération sur la représentation binaire des nombres entiers (ou exclusif bit à bit):
In [ ]:
    
5 ^ 3
    
    Out[ ]:
In [ ]:
    
256 ** (1 / 8)
    
    Out[ ]:
In [ ]:
    
94 % 10
    
    Out[ ]:
L'opération a // b lorsque a et b sont des nombres entiers retourne le quotient de la division a par b :
In [ ]:
    
94 // 10
    
    Out[ ]:
In [ ]:
    
acos       atanh      e          factorial  hypot      log10      sin
acosh      ceil       erf        floor      isinf      log1p      sinh
asin       copysign   erfc       fmod       isnan      modf       sqrt
asinh      cos        exp        frexp      ldexp      pi         tan
atan       cosh       expm1      fsum       lgamma     pow        tanh
atan2      degrees    fabs       gamma      log        radians    trunc
    
On trouvera leur documentation sur https://docs.python.org/library/math.html
Pour importer quelquechose de ce module, il faut d'abord l'importer avec la syntaxe from math import quelquechose. Par exemple, pour importer la fonction factorial, on procède de la façon suivante:
In [ ]:
    
from math import factorial
factorial(4)
    
    Out[ ]:
Alternativement, on peut aussi importer le module math et procéder ainsi:
In [ ]:
    
import math
math.factorial(4)
    
    Out[ ]:
De même pour les fonctions trigonométriques, on les importe de la façon suivante:
In [ ]:
    
from math import sin, cos, tan, pi
    
Pour importer toutes les fonctions d'un module, il suffit d'écire from module import *. Par exemple, pour importer toutes les fonctions du module math, on écrit:
In [ ]:
    
from math import *
    
On vérifie que le sinus d'un angle de 90 degrés est bien égal à 1:
In [ ]:
    
sin(90)
    
    Out[ ]:
Oups, l'argument doit être écrit est en radians (90 degrés est égal à $\pi/2$ radians) et on obtient bien 1:
In [ ]:
    
sin(pi/2)
    
    Out[ ]:
La constante $\pi$ du module math retourne une valeur approchée à une quinzaine de décimales:
In [ ]:
    
pi
    
    Out[ ]:
Les fonctions degrees et radians permettent de passer d'une unité d'angle à l'autre:
In [ ]:
    
from math import degrees, radians
degrees(pi)
    
    Out[ ]:
In [ ]:
    
radians(180)
    
    Out[ ]:
Extraction de la racine carrée avec la fonction sqrt :
In [ ]:
    
from math import sqrt
sqrt(100)
    
    Out[ ]:
Calcul des racines du polynôme $3x^2 + 7x + 2$ :
In [ ]:
    
from math import sqrt
(- 7 + sqrt(7**2 - 4 * 3 * 2) ) / (2 * 3)
    
    Out[ ]:
In [ ]:
    
(- 7 - sqrt(7**2 - 4 * 3 * 2) ) / (2 * 3)
    
    Out[ ]:
In [ ]:
    
from math import hypot
help(hypot)
    
    Out[ ]:
En IPython, on peut consulter la documentation d'une fonction en ajoutant un point d'interrogation avant ou après le nom de la fonction. Cela fonctionne aussi dans l'interface Jupiter, ce qui ouvre une fenêtre au bas de la page:
In [ ]:
    
?hypot
    
    Out[ ]:
In [ ]:
    
hypot?
    
    Out[ ]:
In [ ]:
    
3 * (5 + 2)        # l'addition est calculée en premier
    
    Out[ ]:
In [ ]:
    
(3 * 5) + 2        # la multiplication est calculée en premier
    
    Out[ ]:
Sans les parenthèses, l'expression est évaluée selon l'ordre de priorité des opérations. En particulier, le comportement par défaut est que la multiplication est évaluée avant l'addition:
In [ ]:
    
3 * 5 + 2          # la multiplication est calculée en premier
    
    Out[ ]:
En général, les expressions non parenthésées utilisant les opérations de base sont évaluées en tenant compte de l'ordre décrit dans la table ci-bas.
Supposons que l'on veut évaluer le polynôme $3x^4 + 7x^3 - 3x^2 + x - 5$ lorsque $x=1234567$. On peut procéder de la façon suivante:
In [ ]:
    
3 * 1234567**4 + 7 * 1234567**3 - 3 * 123467**2 + 1234567 - 5
    
    Out[ ]:
Cela nous oblige à écrire quatre fois le nombre 1234567 et on peut éviter cela au moyen d'une variable.
Une variable permet de mémoriser un nombre pour le réutiliser plus tard. Par exemple, on peut mémoriser le nombre 1234567 dans la variable x :
In [ ]:
    
x = 1234567
    
Le symbole = ne doit pas être vu comme une équation à résoudre, mais plutôt comme une affectation de la valeur 1234567 dans la variable x. On peut demander la valeur de x :
In [ ]:
    
x
    
    Out[ ]:
Cela nous permet de faire des calculs avec x :
In [ ]:
    
x + 1
    
    Out[ ]:
Finalement, on peut utiliser la variable x pour évaluer le polynôme au point x=1234567 :
In [ ]:
    
3*x**4 + 7*x**3 - 3*x**2 + x - 5
    
    Out[ ]:
C'est curieux. On remarque que le résultat n'est pas le même que celui que l'on avait calculé plus haut. Pourquoi? En effet, on s'était trompé en écrivant 123467 plutôt que 1234567. C'est aussi l'autre avantage d'utiliser une variable: ça permet d'éviter de se tromper lorsqu'on doit utiliser la même valeur plusieurs fois dans un calcul.
Ensuite, on peut changer la valeur de la variable x et évaluer le même polynôme lorsque x prend une autre valeur:
In [ ]:
    
x = 10
3*x**4 + 7*x**3 - 3*x**2 + x - 5
    
    Out[ ]:
In [ ]:
    
5 * 9 == 40 + 5
    
    Out[ ]:
La valeur retournée est un booléen: True pour vrai et False pour faux. Si l'égalité n'est pas vérifiée, alors c'est la valeur False qui est retournée:
In [ ]:
    
5 * 9 == 40 + 6
    
    Out[ ]:
Il existe d'autres opérateurs de comparaison dont la description se trouve dans la table ci-bas.
Par exemple:
In [ ]:
    
5 * 9 < 1000
    
    Out[ ]:
In [ ]:
    
1 + 2 + 3 + 4 + 5 >= 15
    
    Out[ ]:
In [ ]:
    
2016 != 2016
    
    Out[ ]: