Variables et types 
Affectation¶
Une variable en informatique possède 3 caractéristiques :
- un nom (par exemple
a) - une valeur (par exemple 42)
- un type (par exemple
int, entier)
Par exemple, l'instruction suivante permet de définir une variable nommée a, de valeur 42 et de type entier :
a = 42 # définition d'une variable a
Lorsque l'on définit une variable de cette façon, la valeur 42 est stockée dans la mémoire RAM et peut être récupérée en écrivant le nom de la variable :
a
Python remplace a par sa valeur et donne le résultat.
On peut aussi modifier la valeur de a :
a = -4 # modification de a
a
De manière générale, une affectation s'écrit sous la forme suivante :
a = expression
Cette affectation a pour effet de calculer la valeur de l'expression et de mettre cette valeur dans a.
Considérons par exemple les lignes suivantes :
x = 2 # x est défini en prenant la valeur 2
y = 3 # y est défini en prenant la valeur 3
x = x + y*4 # x + y*4 est calculé et sa valeur (14) est mise dans x
print(x)
Exercice
Que valent $a$ et $b$ après avoir exécuté les lignes suivantes? Quel est l'intérêt de ce bout de code?
a = 7
b = 42
a = a + b
b = a - b
a = a - b
Solution
a, b # a vaut 42 et b vaut 7 : le code ci-dessus échange les valeurs de a et b (mais il y a une technique plus efficace pour faire ça que nous allons voir ensuite)
Types de base¶
Voici les principaux types qui vont nous intéresser en Python :
| Type | Description | Exemple |
|---|---|---|
int |
entier | 0, 42, -7 |
float |
nombre à virgule | 3.14, -2.718 |
bool |
booléen (vrai ou faux) | True, False |
tuple |
$n$-uplet | (1, 2, 3), (3.14, "chaine", [1, 0]) |
list |
liste | [1, 2, 3], [3.14, "chaine", [1, 0]] |
str |
chaîne de caractères | "blabla", "", "info" |
Types numériques : int, float¶
intest utilisé pour les entiers (naturels : positif ou négatif).floatest utilisé pour les nombres à virgule.
Python utilise en fait des points pour les nombres à virgules. Les virgules sont utilisées pour séparer des éléments, par exemple dans des tuple ou list :
e = 2,718
print(e) # on a défini un couple et non pas un float !
e = 2.718
print(e) # cette fois, on a bien un float
Voici les opérations que l'on peut effectuer sur les int et float :
| Opérateur | Signification | Exemple |
|---|---|---|
+ |
addition | 2 + 3 vaut 5 |
- |
soustraction | 2 - 3 vaut -1 |
* |
multiplication | 2*3 vaut 6 |
** |
puissance | 2**3 vaut 8 |
/ |
division (dans $\mathbb{Q}$) | 5/2 vaut 2.5 |
// |
division entière (quotient de la division euclidienne) | 5//2 vaut 2 |
% |
modulo (reste de la division euclidienne) | 5%2 vaut 1 |
Une racine peut être calculée avec **. Par exemple, $\sqrt{2} = 2^{\frac{1}{2}}$ :
2**0.5
Exercice
stocker dans une variable nombre_or la valeur (approximative) du nombre d'or $\phi = \frac{1 + \sqrt{5}}{2}$
Solution
nombre_or = (1 + 5**0.5)/2
nombre_or
On rappelle que la division euclidienne de $a$ par $b$ consiste à décomposer $a = bq + r$ avec $q$ le quotient (obtenu par a // b en Python) et $r$ le reste (obtenu par a % b).
Exercice
Calculer le quotient $q$ et le reste $r$ de la division euclidienne de 573 par 18. Vérifier que $573 = 18\times q + r$.
Solution
q = 573 // 18
r = 573 % 18
print(q, r)
573 == 18*q + r
31 15
True
% permet aussi de tester la divisibilité :
$$b \text{ divise } a$$
$$\Longleftrightarrow \exists d, a = b\times d$$
$$\Longleftrightarrow \exists d, a = b\times d + 0$$
$$\Longleftrightarrow \text{le reste de la division de } a \text{ par } b \text{ est } 0$$
$$\Longleftrightarrow a \% b == 0$$
Exercice
Est-ce que $86082823925$ est divisible par $179723$?
Solution
86082823925 % 179723 # le reste est 0 donc la réponse est oui
0
On peut comparer des int/float avec les opérateurs suivants :
| Symbole | Signification | Exemple |
|---|---|---|
== |
égal | 0 == 0 vaut True, 0 == 1 vaut False |
< |
inférieur strictement | 1 < 2 vaut True, 3.14 < 3.14 vaut False |
> |
supérieur strictement | 1 > 2 vaut False, 3.14 > 3.14 vaut False |
<= |
inférieur ou égal | 1 <= 2 vaut True, 3.14 <= 3.14 vaut True |
>= |
supérieur ou égal | 1 >= 2 vaut False, 3.14 >= 3.14 vaut True |
!= |
différent | 1 != 2 vaut True, 0 != 1 vaut True |
Attention : ne pas confondre a = b, qui permet de mettre la valeur de b dans a, et a == b qui permet de tester si a et b ont la même valeur.
Il est possible d'utiliser plusieurs < à la suite :
1 < 2 < 3
Exercice
Vérifier que le nombre d'or est compris entre 1 et 2.
Solution
1 < (1 + 5**0.5)/2 < 2
Calcul approché des flottants¶
À cause de la représentation binaire des données sur un ordinateur, les flottants sont stockés de façon approchée et non pas exact. Par exemple 0.1 + 0.2 ne donne pas exactement 0.3 :
0.1 + 0.2 # ne vaut pas 0.3
0.1 + 0.2 == 0.3 # donne False !
On retiendra qu'il faut éviter de comparer deux flottants avec == (regarder si la différence est inférieure à 0.01 par exemple) et que les calculs sur les flottants se font avec des erreurs.
Par contre les calculs sur les entiers se font de façon exacte.
Booléens¶
Un booléen est soit vrai (True) soit faux (False). On peut utiliser les opérations booléennes suivantes :
| Opérateur | Signification | Exemple |
|---|---|---|
or |
ou | 0 == 0 or 3.14 == 3 vaut True |
and |
et | 0 == 0 and 3.14 == 3 vaut False |
not |
négation | not 0 < 1 vaut False |
Exercice
calculer de tête la valeur de l'expression suivante et vérifier avec Python.
not (1 <= 1 and (1 == 2 or 0 != 1))
Solution
not (1 <= 1 and (1 == 2 or 0 != 1))
Listes¶
Une liste sert à stocker plusieurs éléments. Par exemple, pour définir une liste contenant l'entier 1, le booléen True et le flottant 3.14 :
L = [1, True, 3.14] # L est une liste contenant 1, True et 3.14
L
| Python | Signification | Exemple |
|---|---|---|
[..., ..., ...] |
Création d'une liste | [1, True, 3.14] [] (liste vide) |
len(L) |
Taille d'une liste L |
len([1, True, 3.14]) vaut 3 |
L[i] |
Élement d'indice i d'une liste L |
Si L vaut [1, True, 3.14], L[2] vaut 3.14 |
L.append(e) |
Ajoute un élément e à une liste L |
L.append(42) |
Attention : les indices commencent toujours à 0 en informatique. Le dernier indice d'une liste L est len(L) - 1.
L[-1] est un raccourci permettant d'accéder au dernier élément d'une liste. De même, L[-2] accède à l'avant dernier élément...
Essayer d'accéder à un élément qui n'existe pas produit une erreur :
L = [3, 2, 4]
print(L[1]) # donne 2
print(L[3]) # ERREUR
L'opération de slicing L[i:j] permet d'extraire une sous liste de L contenant les éléments de l'indice i inclu à j exclu :
L = [-3, 0, 42, 7, 5]
L[1:3] # extrait une nouvelle liste contenant L[1] et L[2]
Dans un slicing, il est possible d'ommettre l'indice de début (auquel cas la liste ext extraite à partir du début) ou l'indice de fin (auquel cas la liste ext extraite jusqu'à la fin).
print(L[:3]) # sous-liste du 1er au 3ème élément
print(L[-2:]) # sous-liste de l'avant-dernier au dernier élément
Chaînes de caractères¶
Les chaînes de caractères (string en anglais) servent à stocker du texte, sous forme d'une suite de caractères (symboles). Contrairement aux listes, il n'est pas possible de modifier une chaîne de caractères (on dit que c'est un type immutable)). Par exemple, il n'y a pas de append sur les chaîne de caractères.
s = "l'informatique c'est fun" # définition d'une chaîne de caractères
print(len(s)) # taille de s
print(s[2]) # caractère d'indice 2 (c'est à dire en 3ème position)
s[0] = "L" # ERREUR : on ne peut pas modifier un str
s.append("!") # ERREUR : on ne peut pas modifier un str
Tuples¶
Les tuples (ou $n$-uplets) sont la généralisation des couples, triplets... Ils ressemblent beaucoup aux chaînes de caractères (en particulier, ils sont immutables) mais servent à stocker autre chose que du texte.
t = (2, 3, 4, 5)
print(t[1]) # donne 3
print(len(t)) # donne 4
t[1] = 6 # ERREUR : on ne peut pas modifier un tuple
t.append(6) # ERREUR : on ne peut pas modifier un tuple