Python en mathématiques - Niveau 1

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.

Opérateur d'addition

Le but de cet exercice est de déterminer le comportement de l'opérateur + dans chacun des cas suivants :

  1. Entre deux entiers int.
  2. Entre deux flottants float.
  3. Entre deux chaînes de caractères str.
  4. Entre un entier int et un flottant float.
  5. Entre un entier 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'
	
  • Deux entiers
  • Deux flottants
  • Deux chaînes de caractères
  • Un entier et un flottant
  • Un entier et une chaîne de caractères

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

Attention !

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 :

  • Une machine ne représente qu'une toute petite partie des réels puisque le nombre de chiffres en mémoire est toujours fini. Ainsi une opération sur des flottants sera rarement exacte au sens mathématique.
  • Les nombres en machine sont en fait codés avec uniquement des 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.

Opérateur de multiplication

Le but de cet exercice est de déterminer le comportement de l'opérateur * dans chacun des cas suivants :

  1. Entre deux entiers int.
  2. Entre deux flottants float.
  3. Entre deux chaînes de caractères str.
  4. Exponentiation.
  5. Entre un entier 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
	
  • Multiplication de nombres
  • Multiplication de chaînes de caractères
  • Opérateur d'exponentiation **
  • Multiplication d'une chaîne de caractères par un entier
>>> 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.

  • Entre deux int, Python est capable de calculer de façon exacte sur de très grands entiers.
  • Entre deux 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.

Opérateur de division

Le but de cet exercice est de déterminer le comportement de l'opérateur /, dans chacun des cas suivants :

  1. Entre deux entiers int.
  2. Entre deux flottants float.

Pour cela, testez les instructions suivantes en mode console :

>>> 2/3

>>> 2.0/3.0

>>> 2.0/3

>>> 2/0

	
  • Réponse
>>> 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).

Division euclidienne

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

	
  • Opérateur //
  • Opérateur %
>>> 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 (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.