====== Les types ======
**entier ** (type **int**) comme 3 ou 42
**réel ** (type **float**) comme 2.4 ou 3.14159265
**liste ** (type **list**) comme [1, 2, 3, 12]
**chaîne de caractères ** (type **str**) comme "bonjour"
**booléen ** (type **bool**) comme True ou False
a = 10
b = 3
print(a, b)
a, b = b, a
print(a, b)
===== Les entiers =====
**Les opérations utilisables sur les entiers sont:**
+ addition
- soustraction
* multiplication
// quotient de la division euclidienne
% reste de la division euclidienne
** puissance
===== Les flottants =====
**Sur les réels:**
+ addition
- soustraction
* multiplication
/ division
** puissance
Vous pouvez entrer un float en mémoire en utilisant une notation classique (attention, le séparateur est un point pas une virgule)
ex: C = 0.0010
On peut aussi utiliser une notation proche de ce que l'on a sur les calculatrices
ex: G = 6.67e-11
===== Les listes =====
L = [1, 2, 3]
vide = [ ]
x = [1,2,3,4]
print(x)
x.append(5)
print(x)
donne
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
len(x)
donne
5
L = [12, 42, 36, 17]
print( L[2] )
donne
36
x = [12, 42, 36, 17]
print( x )
x[ 2 ] = 15
print( x )
donne
[12, 42, 36, 17]
[12, 42, 15, 17]
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print( c )
donne
[1, 2, 3, 4, 5, 6]
Par extension, l'opérateur * permet de faire plusieurs fois la concaténation. [ 0 ] * 4 représente [ 0 ] + [ 0 ] + [ 0 ] + [ 0 ] et donc la liste [0, 0, 0, 0]
On peut extraire des sous-listes en utilisant des "slices". La syntaxe est x[d : f : p] où d, f et p sont des entiers représentants l'indice du premier élément, l'indice du premier élément qui n'y sera pas, et le pas. Par défaut d et f représentent le début et la fin de la liste et le pas est de 1.
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = a[ 2 : 7 : 2 ] #extraction d'une sous-liste de a comportant les éléments d'indice 2, 4 et 6
print(b)
b = a[ : : 2] #extraction d'une sous-liste de a comportant les éléments d'indice 0, 2, 4, 6 et 8
print(b)
b = a[ 2 : : ] #extraction d'une sous-liste de a comportant les éléments d'indice 2, 3, 4, 5, 6, 7, 8 et 9
print(b)
donne
[3, 5, 7]
[1, 3, 5, 7, 9]
[3, 4, 5, 6, 7, 8, 9, 10]
===== Les chaînes de caractères =====
On délimite une chaîne de caractères avec des guillemets simples 'hello', doubles "bonjour" ou triple guillemets _ckgedit_QUOT__ckgedit_QUOT__ckgedit>Hi_ckgedit_QUOT__ckgedit_QUOT__ckgedit>
On peut faire appel à une lettre d'une chaîne de caractère en utilisant son indice. Comme pour les listes, les indices démarrent à 0.
texte = "Bonjour"
print( texte[ 2 ] )
donne
n
a = "Bonjour "
b = "à tous"
c = a + b
print( c )
donne
Bonjour à tous
a = "Bonjour"
b = a[1 : 6 : 2]
print(b)
donne
oju
**On ne peut pas modifier une lettre par affectation. Une chaîne de caractère est immuable : texte[5] = "i" renvoie un message d'erreur.**
a = "Bonjoir"
b = a[ : 5 : ] + "u" + a[6 : : ]
print(b)
a = "Bonjoir"
b = a.replace("i", "u")
print(b)
donne
Bonjour
Bonjour
chaine = "Hello world"
print(chaine)
gauche = "bleu"
centre = "blanc"
droite = "rouge"
print("Le drapeau est {0} {1} et {2}.".format(gauche, centre, droite))
donne :
>>>
Le drapeau est bleu blanc et rouge.>>>
===== Le type booléen =====
Toutes les expressions évaluables à Vrai ou Faux sont des booléens. On peut par exemple comparer des valeurs en utilisant supérieur >, inférieur <, supérieur ou égal >=, inférieur ou égal <=, égal == et différent !=. Il ne faut pas confondre le simple égal = qui est une affectation et le double égal == qui permet de comparer deux valeurs entre elles.
Les expressions suivantes sont des expressions booléennes:
3 > 4
25 % 2 == 1\\
On peut utiliser and, or et not pour créer une expression plus complexe:
25%2 == 0 and 25%3 == 0 (vérifie si le nombre 25 est divisible par deux et par trois)
25%2 == 0 or 25%3 == 0 or 25%5 == 0 (vérifie si le nombre 25 est divisible par deux, trois ou cinq)