z.real # Un complexe est un couple de flottants >>> z.conjugate

ISN
TP N O 3 : L ISTES , T UPLES , S TRING
I. Rappel sur les types scalaires
On a déjà vu plusieurs types simples de variables :
• Les entiers (int : désignent un entier relatif, en précision illimitée.
• Les booléens (bool) : ne peuvent prendre que deux valeurs : True et False.
• Les flottants (float) : désignent un nombre décimal. La précision dépend du système utilisé (voir cours sur la représentation des flottants en mémoire). Ils peuvent être la source d’erreurs d’arrondi ou de dépassements.
• Les complexes (complex) : se notent a + bj où a est la partie réelle et b la partie imaginaire. Par exemple :
>>> z = 3 + 5j
>>> z.real # Un complexe est un couple de flottants
3.0
>>> z.imag
5.0
>>> z.conjugate() # Attention de ne pas oublier les parenthèses.
(3-5j)
>>> z2= -2 + 1j # Ne pas oublier le 1 : Python ne comprend pas j tout court.
>>> z * z2
(-11-7j)
II. Les types séquentiels
La notion de variable numérique (ou scalaire) est rapidement insuffisante dès que l’on veut manipuler un grand nombre
de données. Par exemple, si on veut stocker la vitesse d’un mobile à 50 instants différents. On peut imaginer créer 50
variables v 1 , v 2 , . . . , v 50 , mais on voit bien que ça va vite être pénible. On va plutôt créer une variable dans laquelle on
mettra la séquence des mesures.
On dispose pour cela de plusieurs types. Le contenus de certains peut être modifié (on dit qu’ils sont « mutables »), alors
que les autres sont fixés à la construction.
1) Les n-uplets
a) Création et accès
Un n-uplet (ou tuple en anglais) est une généralisation des notions de couple, triplet, quadruplet, . . . Pour construire
un tuple, il suffit de séparer les expressions par des virgules, et de mettre des parenthèses autour.
Pour avoir la longueur d’un tuple (c’est à dire son nombre d’élément), on utilise la fonction len.
Pour accéder aux éléments d’un tuple t, on utilise la syntaxe t[i] où i désigne l’indice de l’élément. Attention : l’indice
du premier élément est 0. On peut utiliser des indices négatifs pour accéder aux éléments en partant de la fin.
Exercice 1 : Prévoir l’affichage des commandes suivantes, puis vérifier en les tapant dans une console :
t = ('Arthur', 42, 1.85)
type(t)
len(t)
t[0]
t[2]
t[3]
t[-1]
t[-3]
On peut aussi accéder à une sous séquence en utilisant la syntaxe t[i:j] où i et j désignent les indices de début et
de fin (on parle de « slicing » en anglais, ou de « saucissonnage »en français). Dans ce cas, il faut voir i et j comme des
indices de séparateurs plutôt que comme des indices de valeurs :
0
3
1
2
t[0:2] = (’Arthur’, 42) t[1:3] = (42, 1.85) t[-3:-1] = (’Arthur’, 42)
Si l’on omet i (resp. j ), on part du début (resp. de la fin) :
t[:2] = (’Arthur’, 42)
t[-2:] = (42, 1.85) t[:] = (’Arthur’, 42, 1.85)
1/4
−3
1.85
42
Arthur
−2
−1
DELAY – DESFORÊTS – 2015 - 2016
ISN
TP N O 3 : L ISTES , T UPLES , S TRING
Exercice 2 : Prévoir l’affichage des commandes suivantes, puis vérifier en les tapant dans une console :
notes = (12, 11, 18, 7, 15, 3)
notes[2]
notes[7]
notes[-2]
notes[-4]
notes[2:]
notes[:2]
notes[:]
notes[2:5]
notes[2:7]
notes[-2:-4]
notes[-4:-2]
Un tuple est un objet non mutable : on ne peut pas changer la valeur d’un élément :
>>> notes = (13, 8 ,15) ; notes[0] = 14
On peut aussi créer un tuple ne contenant aucun élément avec t=() ou contenant un seul élément avec t=(3,). La
virgule est importante ici, sinon t serait égal à l’entier 3, et pas au tuple (3,).
Une autre façon d’accéder aux éléments d’un tuple est de d’affecter simultanément ses éléments a plusieurs variables.
Par exemple, on peut taper nom, age, taille = t qui donnera nom = ’Arthur’, age = 42 et taille = 1.85.
On peut aussi se passer de mettre les parenthèses autour d’un tuple, ce qu’on a fait plusieurs fois sans le dire, quand on
affiche plusieurs valeurs simultanément, ou qu’on réalise une affectation multiple. Par exemple a, b = b, a revient en
fait à (a, b) = (b, a).
b) Concaténation
On peut « coller » plusieurs tuple ensemble. Cette opération s’appelle la concaténation, et l’opérateur Python correspondant est le +. Par exemple, (1, 3, 10) + (2, 5) donne (1, 3, 10, 2, 5).
Exercice 3 : Taper en mode console l’instruction (1, 2) + 3. Expliquer l’erreur, et corriger pour que le résultat soit le
triplet (1, 2, 3).
Exercice 4 : Que va faire la commande (1, 2) * 3 ? Vérifier.
c) Autres opérations
Si t est un tuple, on peut utiliser les fonctions min(t), max(t), sum(t) et sorted(t) qui sont assez explicites (les essayer). On peut aussi tester la présence d’un élément val dans un tuple t avec l’opérateur val in t, trouver sa position
avec la méthode t.index(val) et le nombre d’occurrences avec t.count(val).
Exercice 5 : Écrire une fonction que prend en argument un tuple de notes, qui affiche la moyenne, l’écart type, les notes
minimales et maximales (et le nombre d’élèves ayant eu ces notes), le nombre d’élèves ayant eu au moins dix, la médiane,
les quartiles.
Remarque : Pour pouvoir calculer une racine carrée, on utilisera la fonction sqrt en commençant le programme par la
ligne from math import sqrt que l’on détaillera plus tard.
2) Les listes
a) Création et accès
À peu de chose près, une liste (ou list en anglais) est un tuple mutable, c’est à dire qu’on peut modifier les éléments
d’une liste sans avoir à créer une nouvelle liste. Pour créer une liste, on remplace les parenthèses par des crochets. Toutes
les opérations vues sur les tuples sont aussi valables sur les listes.
Exercice 6 : Reprendre rapidement les exercices 1 à 4 en remplaçant les tuples par des listes.
2/4
DELAY – DESFORÊTS – 2015 - 2016
ISN
TP N O 3 : L ISTES , T UPLES , S TRING
On peut aussi créer des listes « en compréhension » :
>>> [x ** 2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [x for x in range(10) if x % 2 == 0]
[0, 2, 4, 6, 8]
>>> [x if x % 2 == 1 else '.' for x in range(10) ]
['.', 1, '.', 3, '.', 5, '.', 7, '.', 9]
On peut aussi simuler des tableaux à deux dimensions (voir plus) avec des listes de listes, mais il faut être prudent sur
l’initialisation. Taper les lignes ci-dessous dans une console, et expliquer les résultats (on pourra aussi utiliser le site
http://www.pythontutor.com/) :
liste1 = [1, 2, 3] ; liste2 = [liste1]*3 ; print(liste2)
print(liste2[0]) ; print(liste2[1][2])
liste2[0][1] = 5 ; print(liste2) ; print(liste1)
liste1 = [1, 2, 3] ; liste3 = [liste1 for ligne in range(3)] ; print(liste3)
liste3[0][1] = 5 ; print(liste3) ; print(liste1)
liste4 = [[1, 2, 3]]*3 ; print(liste4)
liste4[0][1] = 5 ; print(liste4)
liste5 = [[1, 2, 3] for ligne in range(3)] ; print(liste5)
liste5[0][1] = 5 ; print(liste5)
b) Modification
Contrairement aux tuples on peut modifier la valeur d’un élément d’une liste. On peut aussi combiner le slicing et les
affectations.
Exercice 7 : Prévoir et vérifier la valeur de liste après chaque instruction :
liste = [12, 11, 18, 7, 15, 3]
liste[0] = 2
liste[5] = 13
liste[6] = 8
liste[2:5] = ['a', 'b', 'c']
liste[2:5] = [100, 200]
liste[2:4] = 3
liste[2:4] = 3,5
liste[1] = [10, 20, 30]
liste[1][2] = 15
liste[2:4] = [1, 2, 3, 4, 7, 11]
c) Autres opérations
En plus des opérations vues sur les tuples, on peut aussi ajouter des éléments à la fin d’une liste lst avec les méthode
lst.append(element) ou lst.extend(sequence), en insérer à un indice i avec lst.insert(i, element), en supprimer un avec lst.pop(i) ou lst.remove(element).
Il est aussi possible de trier une liste en place (c’est à dire de remplacer la liste par la liste triée) avec lst.sort() et
d’inverser l’ordre des éléments avec lst.reverse() (faire des essais).
3) Les chaînes de caractères
Une chaîne de caractères (str, pour string) peut être vu comme un n-uplet de caractères. Toutes les opérations vues sur
les n-uplets sont aussi valables sur les chaînes de caractères. La comparaison de deux chaînes de caractères se fait dans
l’ordre alphabétique (’A’ < ’B’ < . . .< ’Z’ < ’a’ < ’b’ < . . .< ’z’). En fait, Python compare les codes associés à ces caractères (c’est
à dire le nombre stocké en mémoire correspondant au caractère). On peut avoir le code correspondant à un caractère
avec la fonction ord et, réciproquement, avoir le caractère correspondant à un entier avec la fonction chr. Par exemple,
ord('A') renvoie 65 et chr(101) renvoie ’e’.
3/4
DELAY – DESFORÊTS – 2015 - 2016
ISN
TP N O 3 : L ISTES , T UPLES , S TRING
Pour définir une chaîne de caractères, on utilise soit les apostrophes ('Il a dit : "bonjour"'), soit les guillemets
("L'informatique, c'est génial"), soit des triples guillemets qui permettent de mettre tout ce qu’on veut dans la
chaîne de caractères (y compris des retours à la ligne) ("""L'info, c'est un truc de 'geek' (ou "guik").""" ).
En plus des opérations identiques à celles sur les n-uplets, les chaînes de caractères ont beaucoup de méthodes spécifiques. Par exemple, pour obtenir un chaîne de caractères ch en majuscules ou en minuscules, on utilise les méthodes
ch.upper() ou ch.lower(). Il y en a beaucoup d’autres : se référer à l’aide en ligne.
III. Compléments sur la boucle for
En fait, la boucle for en Python permet de décrire n’importe quelle séquence (on parle d’itérables).
Par exemple, for car in "Bonjour" : permet de parcourir tous les caractères de la chaîne "Bonjour". D’ailleurs, en
Python2.x, range(5) renvoie tout simplement la liste [0, 1, 2, 3, 4] (en Python3.x, il faut transformer le résultat avec
list(range(5)), mais l’idée est la même).
Exercice 8 : Écrire des fonctions qui prennent en paramètre une chaîne de caractères et qui, respectivement :
1. renvoie le nombre d’espaces,
2. renvoie le nombre de voyelles,
3. renvoie le score marqué au Scrabble avec cette chaîne, en comptant 0 point pour les espaces et les signes de ponctuation,
4. renvoie la lettre la plus fréquente.
Exercice 9 : Chercher sur le Web ce qu’est la méthode de chiffrement ROT13 et écrire un programme qui demande une
chaîne de caractères au clavier et la chiffre ou la déchiffre selon cette méthode.
Exercice 10 : Écrire des fonctions qui déterminent respectivement le minimum, le maximum et la somme d’une liste
sans utiliser les fonctions min, max ou sum. Simuler de même l’opérateur in et les méthodes index et count.
IV. Applications
Exercice 11 :
1. Écrire une fonction qui prend en argument une chaîne de caractères représentant l’écriture binaire d’un nombre et
qui renvoie ce nombre.
2. Écrire une fonction qui renvoie la chaîne de caractères correspondant à l’écriture binaire d’un entier naturel.
3. Généraliser à une base quelconque (entre 2 et 36).
4. Écrire un programme qui réalise une de ces conversions au choix de l’utilisateur.
Exercice 12 : Écrire une fonction qui prend en argument deux entiers positifs n et p et qui renvoie un tableau de n lignes
et p colonnes dont l’élément situé sur la ligne i et la colonne j est égal à i × j . On représentera un tableau par une liste
de listes. Par exemple, pour n = 4 et p = 5, la fonction doit renvoyer [[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12]]
4/4
DELAY – DESFORÊTS – 2015 - 2016