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[ ]: