Certains opérateurs arithmétiques peuvent être utilisés sur plusieurs types. Mais les algorithmes en jeu ne sont pas les mêmes. Il est donc important de savoir distinguer ces types pour prévoir l'effet d'un opérateur.
Opérations sur les types int
, float
, str
Certains opérateurs arithmétiques peuvent être utilisés sur plusieurs types. Mais les algorithmes en jeu ne sont pas les mêmes. Il est donc important de savoir distinguer ces types pour prévoir l'effet d'un opérateur.
Le but de cet exercice est de déterminer le comportement de l'opérateur +
dans chacun des cas suivants :
int
.float
.str
.int
et un flottant float
.int
et une chaîne de caractère str
.Pour cela, testez les instructions suivantes en mode console :
>>> 2 + 3 >>> 2.5 + 3.0 >>> '2' + '3' >>> 2 + 3.0 >>> 2 + '3'
On obtient :
>>> 2 + 3 5
L'opérateur +
entre deux int
est l'addition usuelle. Le résultat est de type int
.
On obtient :
>>> 2.5 + 3.0 5.5
Le résultat est de type float
.
On pourrait croire que l'opérateur +
entre
deux float
est aussi l'addition usuelle.
C'est vrai dans la grande majorité des cas. Toutefois,
il apparaît même sur des nombres simples des « distorsions »
sur le résultat qu'il importe de comprendre.
Testez par exemple l'addition suivante dans la console :
>>> 3.0+3.001 6.0009999999999994
Les int
et les float
ne sont pas codés
de la même façon en machine et les algorithmes d'addition ne sont
pas les mêmes.
Pourquoi Python fait-il une erreur
sur une addition aussi simple que 3.0 + 3.001
?
Deux principes en cause :
0
et des 1
. Or un nombre ayant un nombre
fini de décimales en base 10 peut se représenter avec un nombre
très grand, voire non fini de décimales en base 2 et sera donc
tronqué en machine.
On retrouve bien sûr le même problème avec d'autres opérations sur
les float
:
>>> 0.3 - 0.1 0.19999999999999998
Nous vous proposons des compléments sur ce sujet dans la page Représentation des nombres en machine, à consulter à l'issue de cette formation.
On obtient :
>>> '2' + '3' '23'
L'opérateur +
entre deux str
réalise
ce que l'on nomme la concaténation de chaînes
(mise bout à bout des deux chaînes pour n'en former qu'une).
On obtient :
>>> 2 + 3.0 5.0
A priori, on ne peut pas additionner un int
et un
float
puisque le codage en machine de ces deux types
de nombres n'est pas le même et l'algorithme d'addition n'est pas
le même (cf. question 2°/).
En fait, dans une telle opération entre int
et
float
, Python convertit
la valeur de type int
en une valeur de type float
puis effectue l'opération. Le résultat est donc de type float
.
On obtient :
>>> 2 + '3' TypeError: unsupported operand type(s) for +: 'int' and 'str'
On ne peut donc pas additionner un nombre et une chaîne de caractères.
Le but de cet exercice est de déterminer le comportement de l'opérateur *
dans chacun des cas suivants :
int
.float
.str
.int
et une chaîne de caractère str
.Pour cela, testez les instructions suivantes en mode console :
>>> 2 * 3 >>> 3.0 * 3.001 >>> '2' * '3' >>> 2 ** 3 >>> 2**100 * 2**100 >>> 2.0**100 * 2.0**100 >>> '2' * 3 >>> 'cou' * 2
**
>>> 2 * 3 6 >>> 2.2*4.2 9.240000000000002
Entre deux nombres, l'opérateur *
représente la multiplication (on s'en doutait...).
La multiplication de deux int
donne un int
.
La multiplication de deux float
donne un float
.
La multiplication d'un int
par un float
donne un float
.
On retrouve les problèmes de représentation (approximation)
avec les float
, comme pour l'addition.
>>> '2' * '3' TypeError: can't multiply sequence by non-int of type 'str'
Il n'est pas possible de multiplier deux chaînes de caractères entre elles.
>>> 2 ** 3 8 >>> 2**100 * 2**100 1606938044258990275541962092341162602522202993782792835301376 >>> 2.0**100 * 2.0**100 1.6069380442589903e+60
Entre deux nombres, l'opérateur **
représente
l'exponentiation.
int
, Python
est capable de calculer de façon exacte sur de très grands entiers.
float
, les limites de la représentation
en machine apparaissent à nouveau.
On peut même ajouter l'exemple suivant :
>>> 2.0*10**300 * 10**100 inf
>>> '2' * 3 '222' >>> 'cou' * 2 'coucou'
La multiplication d'une chaîne de caractères par un entier revient à une concaténation multiple de la chaîne de caractères.
Le but de cet exercice est de déterminer le comportement de l'opérateur /
,
dans chacun des cas suivants :
int
.float
.Pour cela, testez les instructions suivantes en mode console :
>>> 2/3 >>> 2.0/3.0 >>> 2.0/3 >>> 2/0
>>> 2/3 0.6666666666666666 >>> 2.0/3.0 0.6666666666666666 >>> 2.0/3 0.6666666666666666 >>> 2/0 ZeroDivisionError: division by zero
L'opérateur /
entre deux int
ou deux
float
donne une approximation du quotient de la division
correspondante.
Une division par 0 entraîne évidemment une erreur. Les élèves feront tous un certain nombre d'erreurs "prévisibles": il paraît important qu'ils sachent rapidement reconnaître quelques-unes des erreurs usuelles via les messages Python obtenus (comme celle ci-dessus).
Le but de cet exercice est de déterminer le comportement des opérateurs
//
et %
entre deux entiers int
.
Pour cela, testez les instructions suivantes en mode console :
>>> 2//3 >>> (-2)//3 >>> 2%3 >>> 5%2 >>> 13%3
//
%
>>> 2//3 0 >>> (-2)//3 -1
L'opérateur //
entre deux int
calcule
le quotient de la division euclidienne correspondante.
En d'autres termes a//b
(où a
et
b
sont de type int
) est la partie
entière de $ \frac{a}{b} $.
>>> 2%3 2 >>> 5%2 1 >>> 13%3 1
a%b
est le reste de la division euclidienne de
a
par b
.