2.4.

Opérations
2.4.1. Opérations sur les types numériques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques comme
des additions, soustractions, multiplication, division etc. entre différentes variables contenant
des valeurs numériques.
Python reconnait et accepte les opérateurs arithmétiques suivants :

Opérateur Nom
+ Addition
– Soustraction
* Multiplication
/ Division
% Modulo Reste d’une division entière
** Puissance
// Division entière

Exemple :
>>> x = 45
>>> x + 2
47
>>> y = 2.5
>>> x + y
47.5
>>> (x * 10) / y
180.0
Remarquez toutefois que si vous mélangez les types entiers et réels, le résultat est renvoyé
comme un réel (car ce type est plus général). Par ailleurs, l’utilisation de parenthèses permet de
gérer les priorités.

Certains opérateurs nécessitent certainement qu’on s’attarde dessus :

Le modulo (%) correspond au reste d’une division Euclidienne (division entière) tandis que
L’opérateur (//) permet d’obtenir le résultat entier d’une division (ou la partie entière de ce
résultat pour être tout à fait exact).

Le résultat de 13//3, par exemple, sera 4 tandis que le résultat de 13%3 sera 1 car dans le cas
d’une division entière 13/3 = 4 avec reste = 1.
>>> 13//4
3
>>> 13%4
1

L’opérateur puissance permet d’élever le nombre à gauche de l’opérateur à une certaine

puissance mentionnée à droite de l’opérateur. La “puissance” correspond à la multiplication
d’un nombre par lui-même.
 Par exemple, écrire 2 ** 4 correspond à multiplier 2 par lui-même 4 fois ( = 2 * 2 * 2 * 2
= 16).
>>> 2**4
16

2.4.2. Opérations sur les chaînes de caractères

Les opérateurs de chaines vont nous permettre de manipuler des données de type str (chaines
de caractères) et par extension des variables stockant des données de ce type.

Python met à notre disposition deux opérateurs de chaine :

L’opérateur de concaténation +
L’opérateur de répétition *

L’opérateur de concaténation va nous permettre de mettre bout à bout deux chaines de

caractères afin d’en former une troisième, nouvelle.

L’opérateur de répétition va nous permettre de répéter (dupliquer) une chaine un certain

nombre de fois.

Ces deux symboles remplissent donc un rôle relativement similaire que lorsqu’ils sont utilisés
avec des données de type numériques mais attention tout de même de ne pas confondre le +
utilisé pour additionner deux nombres et le + utilisé pour concaténer deux chaines de
caractères : on distingue ici bien deux opérateurs différents même si le même symbole est
utilisé.

Exemple :
>>> chaine = "Salut"
>>> chaine
'Salut'
>>> chaine + " Python"
'Salut Python'
>>> chaine * 3
'SalutSalutSalut'
Attention : Vous voyez que les opérateurs + et * se comportent différemment selon s’il s’agit
d’entiers ou de chaînes de caractères : 2 + 2 est une addition, '2' + '2' est une concaténation. On
appelle ce comportement surcharge des opérateurs.

2.4.3. Opérations illicites

Attention à ne pas faire d’opération illicite car vous obtiendriez un message d’erreur :
>>> 'toto' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Notez que Python donne le maximum d’information dans son message d’erreur. Dans
l’exemple précédent, il vous indique que vous ne pouvez pas mélanger des objets de type str
(string, donc des chaînes de caractères) avec des objets de type int (donc des entiers), ce qui est
assez logique.

2.4.4. Les opérateurs d’affection simple et composés Python

Nous connaissons déjà bien l’opérateur d’affectation simple Python =. Cet opérateur permet
d’affecter ou d’assigner une valeur à une variable.
Python reconnait également des opérateurs d’affectation qu’on appelle “composés” et qui vont
nous permettre d’effectuer deux opérations à la suite : une première opération de calcul suivie
immédiatement d’une opération d’affectation.
Ces opérateurs vont donc nous permettre de réduire la taille de notre code en nous offrant une
écriture simplifiée. Voici la liste des opérateurs d’affectation supportés par Python et leur
équivalent en “version longue” :

Opérateur Exemple Equivalent à Description

= x=1 x=1 Affecte 1 à la variable x

Ajoute 1 à la dernière valeur connue de x et affecte la nouvelle
+= x += 1 x=x+1
valeur (l’ancienne + 1) à x
Enlève 1 à la dernière valeur connue de x et affecte la nouvelle
-= x -= 1 x=x–1
valeur à x
 Mutliplie par 2 la dernière valeur connue de x et affecte la
*= x *= 2 x=x*2
nouvelle valeur à x
Divise par 2 la dernière valeur connue de x et affecte la
/= x /= 2 x=x/2
nouvelle valeur à x
Calcule le reste de la division entière de x par 2 et affecte ce
%= x %= 2 x=x%2
reste à x
Calcule le résultat entier de la division de x par 2 et affecte ce
//= x //= 2 x = x // 2
résultat à x
**= x **= 4 x = x ** 4 Elève x à la puissance 4 et affecte la nouvelle valeur dans x

2.5. La fonction type()

Si vous ne vous souvenez plus du type d’une variable, utilisez la fonction type() qui vous le
rappellera.
>>> x = 2
>>> type(x)
<class 'int'>
>>> y = 2.0
>>> type(y)
<class 'float'>
<class 'str'>
>>> Z=3+4j
>>> type(Z)
<class 'complex'>
>>> Ch = '2'
>>> type(Ch)

Faites bien attention, car pour Python, la valeur 2 (nombre entier) est différente de 2.0 (nombre
réel), de même que 2 (nombre entier) est différent de '2' (chaîne de caractères).

2.6. Note sur la division

Notez bien qu’en Python, la division de nombres entiers renvoie par défaut un nombre réel
(float) :
>>> x=8/2
>>> x
4.0
>>> type(x)
<class 'float'>
2.7. Conversion de types
Dans tout langage de programmation, on est souvent amené à convertir les types, c’est-à-dire
passer d’un type numérique à une chaîne de caractères ou vice-versa. En Python, rien de plus
simple avec les fonctions int(), float() et str().
Exemples :
>>> i = 3
>>> str(i)
'3'
>>> i = '456'
>>> int(i)
456
>>> float(i)
456.0
>>> i = '3.1416'
>>> float(i)
3.1416

Toute conversion d’une variable d’un type en un autre est appelé casting en anglais, il se peut
que vous croisiez ce terme si vous allez consulter d’autres ressources.

On verra l’une des importances de cette conversion au Chapitre sur les fichiers. En effet,
lorsqu’on lit ou écrit des nombres dans un fichier, ils sont considérés comme du texte.

2.8. Note sur le vocabulaire et la syntaxe

Nous avons vu dans ce Chapitre la notion de Variable qui est commune à tous les langages de
programmation. Toutefois, Python est un langage dit Orienté Objet, il se peut que dans la suite
du cours nous employions ce mot Objet pour désigner une variable.
Par exemple variable de type entier sera équivalent à un objet de type entier.
Nous avons rencontré plusieurs fois des fonctions dans ce chapitre, avec type(x), int(x), float(x)
et str(x). Dans le chapitre 1 nous avons également vu la fonction print(). On reconnait qu’il
s’agit d’une fonction au nom - par exemple type - suivi de parenthèses ().
En Python la syntaxe générale est fonction(). La variable x entre les parenthèses est appelé
argument que l’on passe à la fonction. Dans type (2) c’est l’entier 2 qui est l’argument passé à
la fonction.
Pour l’instant on retiendra qu’une fonction est une sorte de boite à qui on passe un argument et
qui renvoie un résultat ou plus généralement un objet. Par exemple, la fonction type() renvoie
le type de la variable qu’on lui a passé en argument.

2.9. Affichage
2.9.1. La fonction print()

Dans le chapitre 1, nous avons rencontré la fonction print() qui affiche une chaîne de
caractères. En fait, la fonction print()affiche l'argument qu'on lui passe entre
parenthèses et un retour à ligne. Ce retour à ligne supplémentaire est ajouté par défaut. Si
toutefois, on ne veut pas afficher ce retour à la ligne, on peut utiliser l'argument par « mot-
clé » end :
>>> print("Hello world!")
Hello world!
>>> print("Hello world!", end="")
Hello world!>>>

La fonction print() permet d’afficher du texte. L’utilisation la plus simple que l’on puisse en
faire est de passer en argument la variable à afficher : print (variable). Elle permet en plus
d’afficher le contenu d’une ou plusieurs variables.

Exmple :
>>> x = 32
>>> nom = 'John'
>>> print (nom , ' a ' , x , ' ans')
John a 32 ans
>>> print("Nom_"*2)
Nom_Nom
Python a donc écrit la phrase en remplaçant les variables x et nom par leur contenu. Vous pouvez
noter également que pour écrire plusieurs blocs de texte sur une seule ligne, nous avons utilisé
le séparateur virgule (,) avec la fonction print().

En regardant de plus près, vous vous apercevrez que Python a automatiquement ajouté un
espace à chaque fois que l’on utilisait le séparateur virgule (,) . Par conséquent, si vous voulez
mettre un seul espace entre chaque bloc, vous pouvez retirer ceux de vos chaînes de caractères
:
>>> print(nom, 'a' , x , 'ans')
John a 32 ans
Pour imprimer deux chaînes de caractères l’une à côté de l’autre sans espace, vous devrez les
concaténer :
>>> ani1 = 'chat'
>>> ani2 = 'souris'
>>> print(ani1, ani2)
chat souris
>>> print(ani1 + ani2)
chatsouris

2.9.2. Écriture formatée

L'écriture formatée est un mécanisme permettant d'afficher des variables avec un certain format,
par exemple justifiées à gauche ou à droite, ou encore avec un certain nombre de décimales
pour les floats.
 2.9.2.1. f-strings (formatted string literals)
Les f-strings permettent une meilleure organisation de l'affichage des variables.
Reprenons l'exemple ci-dessus à propos de notre ami John :
>>> x = 32
>>> nom = "John"
>>> print(f"{nom} a {x} ans")
John a 32 ans

Il suffit de passer un nom de variable au sein de chaque couple d'accolades et Python les
remplace par leur contenu ! Première remarque, la syntaxe apparait plus lisible que l'équivalent
vu ci-avant print(nom, "a", x, "ans"). Bien sûr, il ne faut pas omettre le f avant le
premier guillemet, sinon Python prendra cela pour une chaîne de caractères normale et ne mettra
pas en place ce mécanisme de remplacement :
>>> print("{nom} a {x} ans")
{nom} a {x} ans

Une variable est utilisable plus d'une fois pour une f-string donnée :
>>> var = "to"
>>> print(f"{var} et {var} font {var}{var}")
to et to font toto
>>>
Enfin, il est possible de mettre entre les accolades des valeurs numériques ou des chaînes de
caractères :

>>> print(f"J'affiche l'entier {10} et le float {3.14}")

J'affiche l'entier 10 et le float 3.14
>>> print(f"J'affiche la chaine {'Python'}")
J'affiche la chaine Python

Cela fonctionne avec n'importe quel type de variable (entiers, chaînes de caractères, floats, etc.).
Attention toutefois pour les chaînes de caractères, utilisez des guillemets simples au sein des
accolades si vous définissez votre f-string avec des guillemets doubles.

2.9.2.2. Écriture scientifique

Pour les nombres très grands ou très petits, l'écriture formatée permet d'afficher un nombre en
notation scientifique (sous forme de puissance de 10) avec la lettre e :
>>> print(f"{1_000_000_000:e}") # ou print(f"{1000000000:e}")
1.000000e+09
>>> print(f"{0.000_000_001:e}") # ou print(f"{0.000000001:e}")
1.000000e-09
Il est également possible de définir le nombre de chiffres après la virgule. Dans l'exemple ci-
dessous, on affiche un nombre avec aucun, 3 et 6 chiffres après la virgule :
>>> number = 6.022_140_76e23
>>> print(f"{number:.0e}")
6e+23
>>> print(f"{number:.3e}")
6.022e+23
>>> print(f"number:.6e}")
6.022141e+23

2.9.2.3. La méthode .format()

La méthode format() permet une meilleure organisation de l’affichage des variables. Si on
reprend l’exemple précédent :
>>> x = 32
>>> nom = 'John'
>>> print('{} a {} ans'.format(nom, x))
John a 32 ans
Dans la chaine de caractères, les accolades vides {} précisent l’endroit où le contenu de
la variable doit être inséré.
Juste après la chaine de caractères, l’instruction .format(nom, x) indique la liste
des variables à insérer, d’abord la variable nom puis la variable x. Ainsi, la méthode
.format() agit sur la chaine de caractères à laquelle elle est attachée par le point (.) .

Remarque : il est possible d’indiquer entre les accolades {} dans quel ordre afficher les
variables, avec 0 pour la variable à afficher en premier, 1 pour la variable à afficher en second,
etc. (attention, Python commence à compter à 0). Cela permet de modifier l’ordre dans lequel
sont affichées les variables.
>>> x = 32
>>> nom = 'John'
>>> print({0} a {1} ans'.format(nom, x))
John a 32 ans
# même résultat avec print("{0} a {1} ans".format(nom, x))
>>> print('{1} a {0} ans'.format(nom, x))
32 a John ans

2.9.2.4. Note sur le vocabulaire et la syntaxe

Revenons quelques instants sur la notion de méthode abordée dans ce chapitre
avec .format().

En Python, on peut considérer chaque variable comme un objet sur lequel on peut appliquer
des méthodes. Une méthode est simplement une fonction qui utilise et/ou agit sur l'objet lui-
même, les deux étant connectés par un point. La syntaxe générale est de la
forme objet.méthode().

Dans l'exemple suivant :

>>> "Joe a {} ans".format(20)

'Joe a 20 ans'
La méthode .format() est liée à "Joe a {} ans" qui est un objet de type chaîne de
caractères. La méthode renvoie une nouvelle chaîne de caractères avec le bon formatage ;
ici, 'Joe a 20 ans').

Nous aurons de nombreuses occasions de revoir cette notation objet.méthode().

2.10. Entrée au clavier : La fonction input()

Dans un programme, il est très pratique de pouvoir demander à l’utilisateur de saisir une chaîne
de caractères. La fonction input() permet de lire (récupère ce qu'a tapé l'utilisateur sur le clavier)
une ligne écrite et de la stocker dans une variable. Cette instruction va renvoyer une chaîne de
caractères. Ainsi, si l’utilisateur tape l’entier 25, le résultat initial est le caractère ‘25’. La saisie
de la ligne est interrompue avec la touche entrée. Elle accepte un argument optionnel qui permet
d’afficher une chaine de caractères (par exemple, pour donner des informations) :

Exemple à interpréter dans un fichier Python sur l’invite de commande

# -*-coding:Utf-8 -*
# Acquisition des données
nom = input("Quel est votre nom ? ")
âge = input("Veuillez donner votre âge : ")
# Restitution des données
print('L\'utilisateur est', nom ,'et il a', âge,'ans')

La ligne # -*-coding:Utf-8 -* Permet de gérer le codage des caractères

spéciaux.
On enregistre les réponses de l’utilisateur dans deux variables nommées nom et âge
puis on affichage la chaîne de caractères.

2.11. Programme Pause en Python

La mise en pause de l’exécution du programme ou de l’application est utilisée dans différents
scénarios, comme lorsqu’un programme doit entrer l’utilisateur. Nous pouvons également avoir
besoin de mettre un programme en pause pendant quelques secondes pour permettre à
l’utilisateur de lire un message ou une instruction importante avant que le programme ne
continue. La mise en pause d’un programme peut également être utile lorsque nous devons nous
assurer que l’utilisateur lit l’instruction avant de choisir les actions qu’il souhaite que le
programme effectue.

Sur Python, nous pouvons mettre le programme en pause pour une durée spécifique ou pour
une entrée en utilisant :

La méthode time.sleep()
La fonction input()
La méthode os.system("pause")
2.11.1. Mettre en pause un programme en Python en utilisant la méthode time.sleep()

La méthode time.sleep (secs) suspend l’exécution du fil donné pendant le nombre de secondes
fourni comme secs. Par conséquent, si nous avons besoin de suspendre l’exécution du
programme, nous pouvons le faire en fournissant la durée en secondes à la
méthode time.sleep(). L’exemple de code ci-dessous montre comment utiliser la
méthode time.sleep() pour mettre en pause un programme Python.
import time
time_duration = 3.5
time.sleep(time_duration)

2.11.2. Mettre en pause un programme en Python en utilisant la fonction input()

Si nous voulons mettre un programme en pause pour obtenir une entrée de l’utilisateur, nous
pouvons le faire en utilisant la fonction input() comme vu précédemment. Nous pouvons
également utiliser cette méthode pour mettre le programme en pause jusqu’à ce que la
touche Enter soit enfoncée. L’exemple de code ci-dessous montrent comment utiliser les
input() pour ce faire.
input("Please press the Enter key to proceed")

2.11.3. Pause d’un programme en Python en utilisant la méthode os.system("pause")

Un double clic sur notre tout premier programme au chapitre 1 ; print("Mon premier
programme" enregistré sous un fichier d’extension .py va ouvrir la console de commande et la
refermer aussi vite, ne nous permettant pas de voir notre message. La
méthode os.system("pause") met en pause l’exécution du programme et nous demande
d’appuyer sur une touche pour continuer.

L’exemple de code ci-dessous montre comment utiliser la méthode os.system("pause") pour

mettre en pause un programme Python.
print("Hello world!")
import os
os.system("pause")

2.12. Exercices :
1) En utilisant l’écriture formatée, affichez en une seule ligne les variables a, b et c dont
les valeurs sont respectivement "salut", 102 et 10.318. Exécuter ce programme en
double cliquant sur le fichier d’extension .py que vous allez créer.
2) Écrivez un programme qui demande le nom et prénom à d’un utilisateur, et qui l’affiche
ensuite à l’écran avec un message commençant par : L'utilisateur est….
Rajouter le code permettant de stocker l’argent contenu (en franc cfa) dans la poche
gauche, puis l’argent contenu dans la poche droite
Rajouter le code pour afficher l’argent total que porte la personne.
3) Écrire un programme qui, à partir de la saisie d'un rayon et d'une hauteur (en m), calcule
le volume d'un cône droit (en m3).