2 - Les Variables en Python

PROGRAMMATION EN LANGAGE PYTHON LES VARIABLES ET TYPES DE DONNÉES
Chapitre 2 : Les variables et types de données en Python

Sommaire :
Chapitre 2 : Les variables et types de données en Python................................................................2
1) Les variables......................................................................................................................2
a) Définition.......................................................................................................................2
b) Nommage des variables.................................................................................................2
c) Les mots-clés..................................................................................................................3
2) Types de données en Python..............................................................................................3
a) La fonction type()...........................................................................................................3
b) Le type int (entier)..........................................................................................................3
c) Le type float (flottant)....................................................................................................4
d) Le type complex (complexe)..........................................................................................5
e) Le type str (chaîne de caractères)...................................................................................5
f) Le type bool (booléen).......................................................................................................6
g) Le type list (liste)...........................................................................................................6
3) Les opérateurs Python........................................................................................................6
a) Les opérateurs arithmétiques..........................................................................................7
b) Les opérateurs de comparaisons.....................................................................................8
c) L’opérateur d’affection en Python.................................................................................9
d) Les opérateurs logiques................................................................................................11
e) Opérateurs sur les bits (Bitwise operators)..................................................................11
f) Opérateurs d'appartenance...............................................................................................13
g) Opérateurs d'identité.....................................................................................................13
h) Les opérateurs de chaines de caractères.......................................................................14
i) Priorité des opérateurs.....................................................................................................15
4) Conversion de types.........................................................................................................16
ELBASRI OFPPT Page 1 sur 16

Chapitre 2 : Les variables et types de données en Python

1) Les variables
a) Définition
Une variable est un conteneur pour une valeur. On peut lui attribuer un nom, vous pouvez
l'utiliser pour vous y référer plus tard dans le programme.
Aux yeux du programmeur, cette variable est définie par un nom, alors que pour l’ordinateur, il
s’agit en fait d’une adresse mémoire (c’est-à-dire d’une zone particulière de la mémoire), dans
laquelle une valeur est stockée.
En Python, la déclaration d’une variable et son initialisation (c’est-à-dire la première valeur que
l’on va stocker dedans) se font en même temps. Pour vous en convaincre, testez les instructions
suivantes après avoir lancé l’interpréteur :
>>> x = 2
>>> x
2
Ligne 1. Dans cet exemple, nous avons déclaré, puis initialisé la variable x avec la valeur 2.
Notez bien qu’en réalité, il s’est passé plusieurs choses :
 Python a « deviné » que la variable était un entier. On dit que Python est un langage au
typage dynamique.
 Python a alloué (réservé) l’espace en mémoire pour y accueillir un entier. Chaque type de
variable prend plus ou moins d’espace en mémoire. Python a aussi fait en sorte qu’on
puisse retrouver la variable sous le nom x.
 Enfin, Python a assigné la valeur 2 à la variable x.
Lignes 2 et 3. L’interpréteur nous a permis de connaître le contenu de la variable juste en tapant
son nom.
NB : Python est un langage à typage dynamique, ce qui signifie qu’il n’est pas nécessaire de
déclarer les variables avant de pouvoir leur affecter une valeur. La valeur que l’on affecte
possède un type qui dépend de la nature des données (nombre entier, nombre à virgule, chaîne de
caractères, etc). Le type du contenu d’une variable peut donc changer si on change sa valeur.
b) Nommage des variables
Un identificateur est une suite de caractères servant à désigner les différentes entités manipulées
par un programme : variables, fonctions, classes…
En Python, un identificateur est une suite de caractères alphanumériques qui respecte les
contraintes suivantes :
 Un identificateur peut être constitué de lettres minuscules (a à z), de lettres majuscules (A
à Z), de nombres (0 à 9) ou du caractère souligné (_).

 Un identificateur ne doit pas débuter par un chiffre.

 Un mot clé n’est pas un identificateur.
 Les minuscules et majuscule sont différentiés : Cela signifie que les variables TesT, test
ou TEST sont différentes.
c) Les mots-clés
Python possède un certain nombre de mots clefs réservés. En programmation, un mot clef réservé
est un mot qui est utilisé par le cœur du langage et qui possède une signification spéciale. On ne
peut donc pas utiliser un mot clef réservé comme identifiant (comme nom de variable, nom de
fonction, etc.).
Les mots clefs suivants sont des mots clefs réservés en Python :
and break elif For in not True
as class else From is or try
assert continue except Global lambda pass while
async def False If None raise with
await del finally Import nonlocal return yield
2) Types de données en Python
Bien que nous n'ayons pas à déclarer un type pour les variables Python, une valeur a un type.
Cette information est vitale pour l'interprète. Python prend en charge les types de données Python
suivants.
a) La fonction type()
Pour connaître le type d’une donnée ou le type de la valeur d’une variable, il suffit d’utiliser la
fonction type().
>>> type(15)
<class 'int'>
>>> a = 15
>>> type(a)
<class 'int'>
>>> a = "Monty Python"
>>> type(a)
<class 'str'>
b) Le type int (entier)
Ce type est utilisé pour stocker un entier, en anglais Integer. Pour cette raison, on appelle ce type
int. Le type int regroupe les nombres entiers positifs, nul ou négatifs.

>>> a = -15
>>> type(a)
<class 'int'>
>>> a
-15
>>> print("a vaut :", a)
a vaut : -15
Les entiers en Python 3 sont de taille illimitée.
>>> a = 999999999999999999999999999999999999
>>> type(a)
<class 'int'>
>>> a
999999999999999999999999999999999999
Il est possible de représenter un entier sous forme binaire, octale ou hexadécimale :
>>> nombre = 0b100110 #Binaire
>>> nombre
38
>>> nombre = 0o37 #Octal
>>> nombre
31
>>> nombre = 0xA0F #Hexadécimal
>>> nombre
2575
c) Le type float (flottant)
Ce type est utilisé pour stocker des nombres à virgule flottante, (en anglais floating point
numbers). Pour cette raison, on appelle ce type : float. En français, on parle de flottant.
>>> a = 14.5
>>> type(a)
<class 'float'>
>>> a = 14.
>>> type(a)
<class 'float'>
>>> a
14.0

Les floats peuvent également être en notation scientifique, avec E ou e indiquant la puissance de
10 (3.25e7=3.25 x 107 = 32500000).
>>> a = 3.25e7
>>> type(a)
<class 'float'>
>>> a
32500000.0
>>>
d) Le type complex (complexe)
Python possède par défaut un type pour manipuler les nombres complexes. La partie imaginaire
est indiquée grâce à la lettre « j » ou « J ».
>>> a = 2 + 3j
>>> type(a)
<class 'complex'>
>>> a
(2+3j)
>>> b = 1 + j
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
b = 1 + j
NameError: name 'j' is not defined
>>> b = 1 + 1j
>>> a * b
(-1+5j)
>>> 1j**2
(-1+0j)
e) Le type str (chaîne de caractères)
Sous Python, une donnée de type str est une suite quelconque de caractères délimitée soit par des
apostrophes (simple quotes), soit par des guillemets (double quotes). str est l’abréviation de
string, qui veut dire chaîne en français.
>>> a = 'Bonsoir'
>>> type(a)
<class 'str'>
>>> a
'Bonsoir'

>>> a = "Bonjour"
>>> type(a)
<class 'str'>
>>> a
'Bonjour'
f) Le type bool (booléen)
Le type bool est utilisé pour les booléens. Un booléen peut prendre les valeurs True ou False.
>>> 2 == 1
False
>>> 2 != 1
True
>>> a = 2 != 1
>>> type(a)
<class 'bool'>
>>> a
True
>>> b = not(a)
>>> b
False
Remarque : not est un opérateur logique qui renvoie l’opposé de la valeur booléenne transmise.
Pour True, on obtient False. Réciproquement, il renvoie False quand on lui transmet True.
g) Le type list (liste)
Sous Python, on peut définir une liste comme une collection d’éléments (qui peuvent être de
types différents) séparés par des virgules, l’ensemble étant enfermé dans des crochets.
>>> ma_liste = ["lundi", 18, 20.357, True]
>>> type(ma_liste)
<class 'list'>
>>> ma_liste
['lundi', 18, 20.357, True]
3) Les opérateurs Python

Un opérateur est un signe ou un symbole qui va nous permettre de réaliser une opération. Le
signe = par exemple est en Python l’opérateur d’affectation simple : il permet d’affecter une
valeur à une variable.
Python dispose de nombreux opérateurs qui peuvent être classés selon les catégories suivantes :

 Les opérateurs arithmétiques ;

 Les opérateurs de comparaison ;
 Les opérateurs d’affectation ou d’assignation ;
 Les opérateurs logiques ;
 Les opérateurs d’appartenance ;
 Les opérateurs d’identité ;
 Les opérateurs de chaines ;
a) Les opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques comme
des additions, soustractions, multiplication, 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
** Puissance
// Division entière
>>> x = 45 >>> x * 3
>>> x 135
45 >>> y = 2.5
>>> x + 2 >>> x - y
47 42.5
>>> x - 2 >>>(x*10)+y
43 452.5
Remarque :
1. Si vous mélangez les types entiers et floats, le résultat est renvoyé comme un float (car ce
type est plus général).
2. L’utilisation de parenthèses permet de gérer les priorités.

L’opérateur / effectue une division. Contrairement aux opérateurs +, - et *, celui-ci renvoie

systématiquement un float :
>>> 3/4 >>> 2.5/2
0.75 1.25
L’opérateur puissance utilise les symboles ** :

>>>2**3 >>>2**4
8 16
Pour obtenir le quotient et le reste d’une division entière (voir ici 2 pour un petit rappel sur la
division entière), on utilise respectivement les symboles // et modulo % :
>>>11//4 >>> 8//4
2 2
>>>11%4 >>> 8%4
3 0
b) Les opérateurs de comparaisons
Tout comme les opérateurs logiques, les opérateurs de comparaison renvoient une valeur
booléenne "True" ou "False". Les opérateurs de comparaisons s'appliquent sur tous les types de
base.
Opérateur Description
< strictement inférieur
> strictement supérieur
<= inférieur ou égal
>= supérieur ou égal
== égal
!= différent
En python, il est possible d'enchaîner les opérateurs : X < Y < Z, dans ce cas, c'est Y qui est pris
en compte pour la comparaison avec Z et non pas l'évaluation de (X < Y) comme on pourrait s'y
attendre dans d'autres langages.
>>> a = 2 >>> a == b
>>> b = 10 False
>>> c = 5 >>> a != b

True False
>>> a < b < c
>>> a < b False
True >>> a < c < b
>>> a > b True
c) L’opérateur d’affection en Python
i. Affectation simple :
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.
Syntaxe : Variable = Expression ;
>>> x = 2
>>> x
2
ii. Affectations multiples
Sous Python, on peut assigner une valeur à plusieurs variables simultanément.
Syntaxe : Variable1 = Variable2 = ….= VariableN = Expression;
>>> x = y = 7
>>> x
7
>>> y
7
iii. Affectations simultanées (parallèles)
On peut aussi effectuer des affectations parallèles à l'aide d'un seul opérateur :
Syntaxe : Variable1 , Variable2 , …., VariableN = Expression1 , Expression2 ,…, ExpressionN;
>>> x , y = 2 , 7
>>> x
2
>>> y
7
Dans cet exemple, les variables x et y prennent simultanément les nouvelles valeurs 2 et 7.
Attention : Le nombre de variables à gauche de l’opérateur d’affectation doit être le même que
celui des expressions à sa droite.
Par exemple si vous écrivez :

>>> x , y = 2 , 7 , 8
Vous aurez l’erreur suivant:
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
iv. Affectation composée:
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 selon la syntaxe suivante :
variable op= expression qui est équivalent à variable = variable op expression
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:
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

+= x += 1 x=x+1
nouvelle valeur (l’ancienne + 1) à x
Enlève 1 à la dernière valeur connue de x et affecte la

-= x -= 1 x=x–1
nouvelle valeur à x
Multiplie par 2 la dernière valeur connue de x et affecte la

*= x *= 2 x=x*2
Divise par 2 la dernière valeur connue de x et affecte la

/= x /= 2 x=x/2
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
Exemples :
>>> x = 2
>>> x += 5
>>> x
7

>>> x **= 2
>>> x
49
d) Les opérateurs logiques
Les expressions avec un opérateur logique sont évaluées à True ou False.
 X and Y : ET logique.
Renvoie True si les opérandes (X et Y) sont vraies et False dans le cas contraire.
 X or Y : OU logique.
Renvoie True si l'une des opérandes (X et Y) est vraie et False dans le cas contraire
 not X : NON logique (l’opposée de X).
Renvoie False si X est vrai et True dans le cas contraire.
Tables de vérités :
X Y X and Y X or Y X not X
False False False False False True
False True False True True False
True False False True
True True True True
Exemple :
>>> age = 26 >>> not ( moy > 12 )
>>> moy = 14 False
>>> age < 24 >>> age < 24 and moy > 12
False False
>>> moy > 12 >>> age < 24 or moy > 12
True True
e) Opérateurs sur les bits (Bitwise operators)
Les opérateurs au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit.
Python nous offre 6 opérateurs de base pour agir directement sur les bits:
& Et logique bit par bit

Il copie un bit, vers le résultat, s'il existe dans les deux opérandes.
| Ou logique bit par bit
Il copie un peu, s'il existe dans l'un ou l'autre des opérandes.
^ ou exclusif bit par bit
Il copie le bit s'il est défini dans un opérande mais pas dans les deux.
~ inversion des bits
Il est unaire et a pour effet d’inverser les bits du nombre situé à droite.
» décalage d'un bit à droite (correspond à une division par 2)
La valeur de l'opérande de gauche est déplacée vers la gauche du nombre de bits spécifié par
l'opérande de droite.
« décalage d'un bit à gauche (correspond à une multiplication par 2)
La valeur de l'opérande gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande
droit.
Exemple :
Supposons, par exemple, a = 60; et b = 13
Au format binaire : a = 0011 1100 et b = 0000 1101
Le résultat des différents opérateurs sur les bits est illustré ci-dessous.
a b a&b a|b
Décimal 60 13 12 61
Binaire 0b111100 0b1101 0b1100 0b111101
a^b ~a a << 2 a >> 2
Décimal 49 -61 240 15
Binaire 0b110001 -0b111101 0b11110000 0b1111
La fonction intégrée bin() de Python peut être utilisée pour obtenir une représentation binaire
d'un nombre entier.
Vérification des résultats sur l’interpréteur python:
>>> a = 60 '0b1101'
>>> b = 13 >>> a & b
>>> bin(a) 12
'0b111100'
>>> bin(b) >>> bin(a & b)

'0b1100' >>> bin(~ a )

>>> a | b '-0b111101'
61 >>> a << 2
>>> bin(a | b) 240
'0b111101' >>> bin(a << 2)
>>> a ^ b '0b11110000'
49 >>> a >> 2
>>> bin(a ^ b) 15
'0b110001' >>> bin(a >> 2)
>>> ~ a '0b1111'
-61 >>>
f) Opérateurs d'appartenance
Les opérateurs d'appartenance de Python testent l'appartenance à une séquence, telle que des
chaînes, des listes ou des tuples. Il existe deux opérateurs d'appartenance comme expliqué ci-
dessous.
Évalue à True s'il trouve une variable dans la séquence spécifiée et à False dans
in
le cas contraire.
Évalue à True s'il ne trouve pas de variable dans la séquence spécifiée et à False
not in
dans le cas contraire.
Exemple :
>>> x = 2
>>> liste = [1, 5, 10, 20, 17]
>>> liste
[1, 5, 10, 20, 17]
>>> x in liste
False
>>> x not in liste
True
g) Opérateurs d'identité
Les opérateurs d'identité comparent les emplacements mémoire de deux objets. Il existe deux
opérateurs d'identité comme expliqué ci-dessous

Évalue à True si les variables de chaque côté de l'opérateur

is
pointent vers le même objet et à False dans le cas contraire.
Évalue à False si les variables de chaque côté de l'opérateur

is not
pointent vers le même objet et à True dans le cas contraire.
Exemple :
>>> a = 2 >>> a is not b
>>> b = 10 True
>>> a is b >>> a is a
False True
h) Les opérateurs de chaines 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 + et
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 une chaine un certain nombre de fois.
>>> chaine = "Monty " >>> chaine + "Python"
>>> chaine 'Monty Python'
'Monty ' >>> chaine * 3
'Monty Monty Monty '
A noter que les opérateurs + et * se comportent différemment s’il s’agit d’entiers ou de chaînes
de caractères : 2 + 2 est une addition alors que "2" + "2" est une concaténation.
>>> 2 + 2 >>> "2" + "2"
4 '22'
Attention : à ne pas faire d’opération illicite car vous obtiendriez un message d’erreur :
>>> "toto" * 1.3
TypeError: can't multiply sequence by non-int of type 'float'
>>> "toto" + 2


TypeError: can only concatenate str (not "int") to str
Notez que Python vous donne des informations dans son message d’erreur. Dans le second
exemple, il indique que vous devez utiliser une variable de type str c’est-à-dire une chaîne de
caractères et pas un int, c’est-à-dire un entier.
i) Priorité des opérateurs
Les opérateurs Python ont un ordre de priorité défini, qui détermine quels opérateurs sont
évalués en premier dans une expression potentiellement ambiguë.
Par exemple, dans l'expression 2+2*4, le 3 est multiplié par 4, puis le résultat est ajouté à 2, ce
qui donne 14. L'expression n'est pas évaluée dans l'autre sens, car * a une priorité supérieure à +.
Si vous voulez évaluer 2+3 puis multiplier la somme par 4 vous devriez utiliser les parenthèses.
>>> 2+3*4 >>> (2+3)*4
14 20
Ci-dessous, vous pourrez trouver l’ordre de traitement de chaque opérateur Python (classés du
plus prioritaire au moins prioritaire).
() Opérateur de groupement
** Elévation à la puissance
~ Opérateur d’inversion de bit
Opérateurs arithmétiques multiplication, division et

*, /, % modulo
<<, >> Décalage de bits à gauche ou à droite
& Définit chaque bit à 1 si les deux bits valent 1
Définit chaque bit à 1 si seulement l’un des deux bits

^ vaut 1
Définit chaque bit à 1 si au moins l’un des deux bits vaut

| 1
==, !=, <, <=, >, >=, in, not in, is, is not Opérateurs de comparaison, d’appartenance et d’identité
not Opérateur logique (booléen) inverse ou “non”
and Opérateur logique (booléen) “et”

or Opérateur logique (booléen) “ou”
NB : Si deux opérateurs ont la même priorité, l'évaluation est effectuée de gauche à droite.
>>> 2*3/4 >>> 2/3*4
1.5 2.6666666666666665
Ainsi dans l'expression 2*3/4, la multiplication est effectuée en premier, et la machine doit donc
ensuite effectuer 6/4, ce qui donne 1.5.
4) Conversion de types
En 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(). Pour vous en convaincre, regardez ces exemples :
>>> i = 3 >>> float ( i )
>>> str ( i ) 456.0
'3' >>> i = '3.1416'
>>> i = '456' >>> float ( i )
>>> int ( i ) 3.1416
456
Ces conversions sont essentielles. En effet, lorsqu’on lit ou écrit des nombres dans un fichier, ils
sont considérés comme du texte, donc des chaînes de caractères.
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 consultez d’autres ressources.

2 - Les Variables en Python

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2 - Les Variables en Python

Transféré par

Droits d'auteur :

Formats disponibles

PROGRAMMATION EN LANGAGE PYTHON LES VARIABLES ET TYPES DE DONNÉES

Chapitre 2 : Les variables et types de données en Python

ELBASRI OFPPT Page 1 sur 16

Chapitre 2 : Les variables et types de données en Python

ELBASRI OFPPT Page 2 sur 16

 Un identificateur ne doit pas débuter par un chiffre.

2) Types de données en Python

ELBASRI OFPPT Page 3 sur 16

ELBASRI OFPPT Page 4 sur 16

ELBASRI OFPPT Page 5 sur 16

3) Les opérateurs Python

ELBASRI OFPPT Page 6 sur 16

 Les opérateurs arithmétiques ;

ELBASRI OFPPT Page 7 sur 16

L’opérateur / effectue une division. Contrairement aux opérateurs +, - et *, celui-ci renvoie

L’opérateur puissance utilise les symboles ** :

< strictement inférieur

> strictement supérieur

<= inférieur ou égal

>= supérieur ou égal

ELBASRI OFPPT Page 8 sur 16

ELBASRI OFPPT Page 9 sur 16

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

Enlève 1 à la dernière valeur connue de x et affecte la

Multiplie par 2 la dernière valeur connue de x et affecte la

Divise par 2 la dernière valeur connue de x et affecte la

Calcule le reste de la division entière de x par 2 et affecte ce

Calcule le résultat entier de la division de x par 2 et affecte ce

**= x **= 4 x = x ** 4 Elève x à la puissance 4 et affecte la nouvelle valeur dans x

ELBASRI OFPPT Page 10 sur 16

False False False False False True

False True False True True False

True False False True

True True True True

ELBASRI OFPPT Page 11 sur 16

Binaire 0b111100 0b1101 0b1100 0b111101

a^b ~a a << 2 a >> 2

Décimal 49 -61 240 15

Binaire 0b110001 -0b111101 0b11110000 0b1111

ELBASRI OFPPT Page 12 sur 16

'0b1100' >>> bin(~ a )

ELBASRI OFPPT Page 13 sur 16

Évalue à True si les variables de chaque côté de l'opérateur

Évalue à False si les variables de chaque côté de l'opérateur

ELBASRI OFPPT Page 14 sur 16

File "<stdin>", line 1, in <module>

~ Opérateur d’inversion de bit

Opérateurs arithmétiques multiplication, division et

<<, >> Décalage de bits à gauche ou à droite

& Définit chaque bit à 1 si les deux bits valent 1

Définit chaque bit à 1 si seulement l’un des deux bits

Définit chaque bit à 1 si au moins l’un des deux bits vaut

not Opérateur logique (booléen) inverse ou “non”

and Opérateur logique (booléen) “et”

ELBASRI OFPPT Page 15 sur 16

or Opérateur logique (booléen) “ou”

ELBASRI OFPPT Page 16 sur 16

Vous aimerez peut-être aussi

= x = 4 x = x ** 4 Elève x à la puissance 4 et affecte la nouvelle valeur dans x