TYPES SIMPLES EN PYTHON : NOMBRES et BOOLEENS

TYPES SIMPLES EN PYTHON : NOMBRES et BOOLEENS
I TYPES NUMÉRIQUES
A) Type integer : entiers
Il n'y a pas de limitation due à Python pour la valeur d’un entier. Les limites sont liées aux capacités de
stockage de la machine.
Nombres négatifs : signe –
Opérateurs :
Addition, soustraction, produit : +, - , *
Division entière : // et « modulo » : %
Pour a, b entiers relatifs avec b non nul, a//b et a %b renvoient respectivement les entiers q et r tels que
a=bq+r et
01
r
b
(donc r du signe de b)
On a donc :
ar
q
bb
donc
a
qb
Lorsque a est un entier relatif et b un entier naturel non nul, a//b et a %b renvoient les entiers q et r
représentant respectivement le quotient et le reste de la division euclidienne de a par b, c'est-à-dire définis
par : a=bq+r et 0 ≤ r < b.
In: 13//4
Out: 3
In: 13%4
Out: 1
In: 13//-4
Out: -4
In : 13%-4
Out: -3
In : (-13)//4
Out: -4
In: (-13)%4
Out: 3
In: (-13)//(-4)
Out: 3
In: (-13)%(-4)
Out: -1
Exponentiation : pour a, b entiers relatifs, ab s’obtient par : a**b
In: 2**5
Out: 32 (entier)
In: (-2)**5
Out: -32 (entier)
In: 2**-1
Out: 0.5 (flottant)
In: 0**0
Out: 1
Règles de précédence :
1. Exponentiation : **
2. *, //, %
3. +,-
Utiliser des parenthèses pour éviter les ambigüités et faciliter la lecture
B) Type « float » : flottants, ou nombres à virgule flottante
Le séparateur décimal est le point.
2. donne 2.0, .36 donne 0.36
Notation scientifique : réels écrits sous la forme m.10n avec m réel, n entier relatif :
In: 2e4
Out: 20000.0
In: 2e-4
Out: 0.0002
In: 21e-5
Out: 0.00021
In: 1.6e-2
Out: 0.016
In: 2.8e4
Out: 28000.0
In: 5e2.5
Message d’erreur
Un nombre défini ainsi en Python est toujours un flottant, même si sa valeur est un entier.

Opérateurs : +, -, *,: mêmes règles que pour les entiers.
Division des flottants : /
si a et b sont des flottants, avec b non nul, a/b est toujours un flottant.
Si a ou b est un entier, il est automatiquement converti en flottant pour le calcul de a/b.
Donc si a et b sont flottants ou entiers, avec b ≠ 0, a/b est toujours un flottant.
Exponentiation des flottants : **
Attention quand b n’est pas entier, ab est défini uniquement si a > 0 en math, et par définition :
lnb b a
ae
In: 4**0.5
Out: 2.0
In: 2.5**6.3
Out: 321.38237410503837
In: (-8)**(1/3)
Out: (1.0000000000000002+1.7320508075688772j)
(complexe
13i
, et non
38
qui vaut -2; comparer avec le
résultat donné par une calculette pour
13
( 8)
)
Cas où a = 0 : si b> 0, Python donne 0b = 0 (non défini en math si b n'est pas un entier naturel)
Attention aux erreurs d’arrondis sur les flottants : la capacité de stockage allouée par Python aux
flottants est limitée, et les règles opératoires sur les flottants sont sources d'erreurs d'arrondi.
Il peut y avoir des problèmes notamment avec des nombres très petits ou très grands, (mais pas
seulement, cf II, tests d'égalité).
In: 1-1+2**-54
Out: 5.551115123125783e-17
In: 1+2**-54-1
Out: 0.0
Eviter de manipuler des flottants trop petits ou trop grands en valeur absolue.
(Limites inférieure et supérieure dues à la capacité de stockage : de l'ordre de 10-308 et 10308)
C) Conversions entier flottant:
1) Conversion d’un entier en flottant
Si on utilise un entier dans une opération qui requiert normalement un flottant, Python le convertit
automatiquement en flottant.
Mais si on veut préciser qu’on effectue une conversion d’un entier en flottant, on utilise la fonction
float :
In: float(15)
Out: 15.0
In: float(7//2)
Out: 3.0
2) "Conversion" d’un flottant en entier :
On peut utiliser int :
Si x est de type numérique, int(x) renvoie la partie entière de
x
affectée du signe de x,
et le résultat est de type entier quel que soit le type de x.
 Si la valeur de x est un entier, int(x) renvoie toujours x,
 si la valeur de x n’est pas entier et x > 0, int(x) renvoie la partie entière de x :
x
 si la valeur de x n’est pas entier et x < 0, int(x) renvoie
x
+1
In: int(-4.0)
Out: -4
In: int(-4.35)
Out: -4

II BOOLEENS
Une variable ou une expression de type booléen (boolean) ne peut prendre que deux valeurs : True et
False (attention aux majuscules !)
A) Constructions d'expressions booléennes à l'aide d'opérateurs de comparaison et d'expressions
numériques
1) Egalité et non-égalité : == et !=
L'opérateur == correspond au symbole "=" c'est-à-dire "est égal à",
Ne pas le confondre avec l'opérateur d'affectation =.
L'opérateur != correspond au symbole "≠ "
Exemples :
L'expression booléenne 1==2 correspond à la proposition logique "1 = 2"; elle vaut False.
L'expression booléenne 1!=0 vaut True.
L'expression booléenne 5-4==1 a pour valeur True
Si a et b sont deux variables, ou deux expressions de type quelconques,
- l'expression booléenne a==b correspond à la proposition logique "a = b"; elle vaut True si les
valeurs de a et b sont reconnues comme égales, et False sinon.
- L'expression booléenne a!=b correspond à la proposition logique "a ≠ b"
Attention les tests d'égalité et de non-égalité fonctionnent correctement sur les entiers mais pas
toujours sur les flottants :
Exemples de tests d’égalités sur des flottants :
In: 0.1+0.1==0.2
Out: True
In: 0.1+0.1+0.1==0.3
Out: False
Il faut donc éviter au maximum les tests d'égalité sur des flottants
2) Utilisation de <, >, <=, > =
Les opérateurs <= et >= correspondent aux symboles mathématiques "≤" et "≥"
On les utilise principalement avec des variables ou des expressions de type numérique
Exemples : 1<3 vaut True, 1<=1 vaut True
Atttention, avec des flottants les résultats sont parfois inattendus !
In: 0.1+0.1+0.1>0.3
Out: True
B) Opérateurs not,and,or sur les booléens
Ils servent à construire de nouvelles expressions booléennes à partir de variables ou d'expressions
booléennes.
Négation: l'opérateur not correspond au "non" logique
Conjonction : l'opérateur and correspond au "et" logique
Disjonction : l'opérateur or correspond au "ou" logique
Les règles sont les mêmes qu'en logique classique.
Exemples :
Si a et b sont des expressions, l'expression booléenne not(a==b) a même valeur que a!=b
Si x désigne une variable ou une expression de type numérique, la proposition "x > 0 et x ≤ 6" se traduit
par l'expression booléenne : x>0 and x<=6; Python admet aussi : 0 < x <= 6

Règles de précédence :
 not a précédence sur or et and :
Exemple : si x et y sont des variables de type entier, not(0≤x+y<3) or (x==1) équivaut à
(not(0≤x+y<3)) or (x==1)
(L'expression not(0≤x+y<3) est évaluée en premier)
 and a précédence sur or:
Exemple : si x,y,z sont trois variables de type entier,
(x==1) or (y<=3) and (z!=10) équivaut à (x==1) or ((y<=3) and (z!=10)
Remarque : les opérateurs and et or sont dits "paresseux" :
In: 1/0==3 and 1!=1
ZeroDivisionError: division by zero
In: 1!=1 and 1/0==3
Out: False
L'interpréteur lit les expressions de gauche à droite.
Pour l'expression P and Q: si P est fausse, P and Q l'est aussi, donc l'interpréteur ne tient pas compte
de Q.
Pour l'expression P or Q: si P est vraie, alors P or Q est vraie, là encore il ne tient pas compte de Q.
On peut donc parfois modifier l'ordre des expressions P, Q reliées par and ou or afin d'éviter des
messages d'erreur.