Séquences : listes et tuples

Définition d’une liste. Opérations sur les listes. Fonctions permettant de manipuler les listes. Instruction for. Tuples. Exemples d’application. Copies superficielles et en profondeur.

2

Les listes

Les listes permettent de stocker séquentiellement des données quelconques etd’utiliser des indices pour accéder à des éléments isolés ou consécutifs.

Contrairement aux chaînes, les listes peuvent être modifiées.

Les listes peuvent renfermer des données de différents types. Elles peuvent êtreremplies, vidées, triées et inversées. On peut les allonger et les réduire, lesdécomposer et les assembler à d’autres listes. Elles permettent d’insérer,de modifier ou de supprimer à volonté un ou plusieurs de leurs éléments.

Les tuples

Les tuples partagent plusieurs des caractéristiques des listes.

La principale différence réside dans le fait qu’ils sont accessibles en lectureseulement, c’est-à-dire les opérateurs et les fonctions permettant de mettreà jour les listes ne seront pas valides pour les tuples.

3

Création et affectation d’une liste

Une collection d’éléments séparés par des virgules, l’ensemble étant enfermédans des crochets.

Ex.: >>> jour = ['lundi', 'mardi', 3, 4, 'vendredi', 'samedi', 7]>>> print jour['lundi', 'mardi', 3, 4, 'vendredi', 'samedi', 7]

Les éléments qui constituent une liste peuvent être de types variés, voire mêmedes listes.

>>> voyelles = ['a', 'e', 'i', 'o', 'u', 'y']>>> consonnes = []>>> print voyelles['a', 'e', 'i', 'o', 'u', 'y']>>> print consonnes[]>>> saisons = [1, "printemps", 2, "ete", 3, "automne", 4, "hiver"]>>> print saisons[1, "printemps", 2, "ete", 3, "automne", 4, "hiver"]>>> saisons = [[1, 2, 3, 4], ["printemps", "ete", "automne", "hiver"]]>>> print saisons[[1, 2, 3, 4], ['printemps', 'ete', 'automne', 'hiver']]

Ex. :Liste vide

4

Accès à un élément d’une listeLes listes sont des collections ordonnées de données et l’on peut accéder àchacune d’entre elles individuellement si l’on connaît leur position dans la liste(la position des données commence à zéro).

Ex. : >>> jour = ['lundi', 'mardi', 3, 4, 'vendredi', 'samedi', 7]>>> print jour[2], jour[4]3 vendredi

Le découpage fonctionne comme pour les chaînes : on utilise l’opérateur [ ] avecl’indice approprié.

>>> saisons = [1, "printemps", 2, "ete", 3, "automne", 4, "hiver"]>>> print saisons[1, 'printemps', 2, 'ete', 3, 'automne', 4, 'hiver']>>> saisons = [[1, 2, 3, 4], ["printemps", "ete", "automne", "hiver"]]>>> print saisons[1]['printemps', 'ete', 'automne', 'hiver']>>> print saisons[1][1]ete

Ex. :

Modification d’un élément d’une liste

Il est possible de changer un élément individuel d’une liste contrairement auxchaînes de caractères.

5

Suppression d’un élément d’une liste

La fonction del() supprime un élément d’une liste à partir de sa position tandis quela méthode remove() recherche la 1ière occurrence d’une valeur à enlever pour lasupprimer.

Ex.: >>> del(jour[6])>>> print jour['lundi', 'mardi', 2, 'jeudi', 'vendredi', 'samedi']>>> jour.remove(2)>>> print jour['lundi', 'mardi', 'jeudi', 'vendredi', 'samedi']

>>> Voyelles = ['a', 'e', 'i', 'o', 'u', 'y', ['A', 'E', 'I', 'O', 'U', 'Y']]>>> Voyelles[-1][0], Voyelles[-7] = 'a', 'A'>>> print Voyelles['A', 'e', 'i', 'o', 'u', 'y', ['a', 'E', 'I', 'O', 'U', 'Y']]

Une listedansune liste

Ex. :

Ex.: >>> jour = ['lundi', 'mardi', 3, 4, 'vendredi', 'samedi', 7]>>> jour[2] -= 1>>> jour[3] = 'jeudi'>>> print jour['lundi', 'mardi', 2, 'jeudi', 'vendredi', 'samedi', 7]

6

Vérifier l’appartenance d’un élément à une liste grâce à in et not in

>>> liste = [3.25, 12, "montant"]>>> if (12 in liste):

print "Cette liste renferme la valeur 12"

Cette liste renferme la valeur 12

>>> L = [["rouge", "vert", "bleu"], "noir", "blanc"]>>> ["rouge", "vert", "bleu"] in LTrue

Longueur d’une liste

La fonction len() renvoie le nombre d’éléments présents dans la liste.

Ex.: >>> len(jour)7

Suppression d’une liste

On peut supprimer une liste entière mais cela n’est pas nécessaire.

del jour

On préfère plutôt la laisser quitter sa portée.

7

Comparaison entre listes

On compare les listes jusqu’à détermination d’une gagnante.

>>> liste1 = ["uvw", 13, 3.14159]>>> liste2 = ["ua", 9, "abc"]>>> liste3 = ["uvw", 15, "chaîne"]>>> liste4 = liste1>>> print (liste1 < liste2, liste1 < liste3, liste2 < liste3, liste1 == liste4)(False, True, True, True)

Concaténation de listes (opérateur +)

>>> voyelles_minuscules = ['a', 'e', 'i', 'o', 'u', 'y']>>> voyelles_majuscules = ['A', 'E', 'I', 'O', 'U', 'Y']>>> voyelles = voyelles_minuscules + voyelles_majuscules>>> print voyelles['a', 'e', 'i', 'o', 'u', 'y', 'A', 'E', 'I', 'O', 'U', 'Y']

>>> Forme = ["losange", "triangle", "cube"]>>> Dimension = [2, 3]>>> print Forme + Dimension['losange', 'triangle', 'cube', 2, 3]

8

>>> Forme = Forme + "rectangle"

Traceback (most recent call last): File "<pyshell#3>", line 1, in <module> Forme = Forme + "rectangle"TypeError: can only concatenate list (not "str") to list>>> Forme = Forme + ["rectangle"]>>> print Forme['losange', 'triangle', 'cube', 'rectangle']>>> Forme += "polygone">>> print Forme['losange', 'triangle', 'cube', 'rectangle', 'p', 'o', 'l', 'y', 'g', 'o', 'n', 'e']>>> Forme += ["Polygone"]>>> print Forme['losange', 'triangle', 'cube', 'rectangle', 'p', 'o', 'l', 'y', 'g', 'o', 'n', 'e', 'Polygone']

+ n’est pas défini pour destypes différents de par etd’autre de l’opérateur.

On y arrive en créant uneliste renfermant la donnéeà insérer.

+= est défini pour des listes de par et d’autre de l’opérateur.

+= est aussi défini pour une liste à gauche et une chaîne de caractères à droitede l’opérateur; la chaîne de caractères est décomposée en une liste formée descaractères de la chaîne.

9

Opérateur de répétition à l’aide de *

Création d’une nouvelle liste renfermant n copies des éléments d’une liste.

>>> position = [0, 1, 2, 3, 4, 5]>>> position = position * 2>>> print position[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]>>> vecteur_nul = [0] * 3>>> print vecteur_nul[0, 0, 0]

>>> S = ["plume", 3.9, True] * 3>>> print S['plume', 3.8999999999999999, True, 'plume', 3.8999999999999999,True, 'plume', 3.8999999999999999, True]

L’opérateur *= existe aussi.

>>> print ["_ "] * 5['_ ', '_ ', '_ ', '_ ', '_ ']

10

Méthodes intégréescmp() permet de comparer 2 listes.

1er cas : les éléments correspondants sont de même type dans les 2 listes.

>>> A = ["saison", 3.13, 2+7j]>>> B = ["saison", 2.1, 3+9j]>>> C = ["saison", 2.1, 5+4j]>>> A < BFalse>>> B < CTraceback (most recent call last): File "<pyshell#6>", line 1, in <module> B < CTypeError: no ordering relation is defined for complex numbers

>>> L = [2, 5, 7]>>> M = [2, 5, 7, 9]>>> L < MTrue>>> L = ["ABC", 7]>>> M = ["ABCD"]>>> L < MTrue

Lorsque la fin d’une liste est atteinte,la plus longue est la plus grande.

11

2ième cas : les éléments correspondants sont de types différents dans les 2 listes.

>>> L = [2, 6.3]>>> M = [1.7, 6]>>> L < MFalse>>> L = ["ABC"]>>> M = [8888888888888888]>>> L < MFalse>>> L = [[3,4], 2]>>> M = [[7, 8], 5]>>> L < MTrue>>> M = [[2, 8], 5]>>> L < MFalse

Si ce sont des nombres, effectuer une conversion et comparer.Si l’un des éléments est un nombre, le nombre est le plus petit.Sinon, effectuer un tri alphabétique.

Note : Python fait de son mieux pour effectuer la comparaison mais il se peut qu’iln’y ait aucune relation entre les données ou que cela soit difficile à prévoir.

12

La fonction membre append() permet d’ajouter un élément à la fin d’une liste.

Ex.: >>> jour.append('dimanche')>>> print jour['lundi', 'mardi', 2, 'jeudi', 'vendredi', 'samedi', 'dimanche']

On aurait pu écrire : jour = jour + ['dimanche'] mais cela est moinsavantageux car cela entraîne la création d’une nouvelle liste ce qui n’est pasle cas de la fonction append.

max() et min()

>>> L = ["OH", "LA", "la", "hourra"]>>> min(L), max(L)('LA', 'la')>>> "OH" < "oh"True>>> M = ["Attention", 81, "Aventure"]>>> min(M), max(M)(81, 'Aventure')

Très utiles lorsque les listes sont formées de nombres et de chaînes decaractères.

13

Tri des éléments d’une liste à l’aide de la méthode sort().

>>> nombres_entiers = [32, 13, 64, 0, -25, 9]>>> nombres_entiers.sort()>>> print nombres_entiers[-25, 0, 9, 13, 32, 64]>>> nombres_entiers = [32, 13, 64, 'zero', -25, 9]>>> sorted(nombres_entiers)[-25, 9, 13, 32, 64, 'zero']>>> nombres_entiers[32, 13, 64, 'zero', -25, 9]>>> nombres_entiers.sort()>>> print nombres_entiers[-25, 9, 13, 32, 64, 'zero']

Inverser l’ordre des éléments d’une liste à l’aide de la méthode reverse().

>>> Voyelles = ['a', 'e', 'i', 'o', 'u', 'y']>>> Voyelles.reverse()>>> print Voyelles['y', 'u', 'o', 'i', 'e', 'a']

La méthode sort modifiela liste courante; sinon,on peut utiliser la fonctionsorted qui retourne la listetriée.

14

Liste.index(élément, i = 0, j = len(liste)) Retrouver le plus petit indice k d’unélément d’une liste tel que :

Liste[k] == élémentet i <= k < j.

>>> Voyelles = ['a', 'e', 'i', 'o', 'u', 'y']>>> Voyelles.index('i')2

Retourner le nombre d’occurrences d’un élément d’une liste à l’aide de laméthode count().

>>> Expression = ['e', 't', ' ', 'p', 'a', 't', 'a', 't', 'i', ' ', 'e', 't', ' ', 'p', 'a', 't', 'a', 't', 'a']

>>> Expression.count('a')5>>> Expression.count('t')6

Liste.extend(L) Ajoute les éléments de la liste L à la fin de Liste.

>>> Liste = ["Pierre", "Paul"]>>> L = ["Dubuc", "Rioux", "Bernier"]>>> Liste.extend(L)>>> print Liste['Pierre', 'Paul', 'Dubuc', 'Rioux', 'Bernier']

15

Liste.insert(indice, élément) : Insère élément dans Liste en position indice.

>>> Jours = ["Lundi", "Jeudi", "Vendredi", "Samedi"]>>> Jours.insert(0, "Dimanche")>>> print Jours['Dimanche', 'Lundi', 'Jeudi', 'Vendredi', 'Samedi']>>> Jours.insert(2, "Mardi")>>> print Jours['Dimanche', 'Lundi', 'Mardi', 'Jeudi', 'Vendredi', 'Samedi']>>> Jours.insert(3, "Mercredi")>>> print Jours['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi']

Liste.pop(indice= -1) : Supprime de la liste et retourne l’élément en position indice.En l’absence d’indice, le dernier élément est considéré.

>>> Jours = ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi']>>> Jours.pop()'Samedi'>>> print Jours['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi']>>> Jours.pop(0)'Dimanche'>>> print Jours['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi']

16

Création d’une liste de nombres à l’aide de la fonction range().

>>> range(12)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]>>> range(0)[]>>> range(3,7)[3, 4, 5, 6]>>> range(6, 12, 2)[6, 8, 10]>>> U = range(4) + range(4, 8)>>> print U[0, 1, 2, 3, 4, 5, 6, 7]>>> range(6, 2)[]>>> range(6, 2, -1)[6, 5, 4, 3]

range(n) : génère une liste renfermant les nombres 0, 1, 2, …, n-1;si n 0, cela génère une liste vide [].

range(m, n) : génère une liste renfermant les nombres m, m+1, m+2, …, n-1;si m n, cela génère une liste vide [].

range(m, n, p) : génère une liste renfermant les nombres m, m+p, m+2p, …, m+kp,où k est le plus grand entier tel que m+kp < n si p > 0,

m+kp > n si p < 0.

17

Parcours d’une liste à l’aide de l’instruction for

>>> liste = [3.25, 12, "montant"]>>> indice = 0>>> while (indice < len(liste)):

print type(liste[indice]), liste[indice]indice = indice + 1

<type 'float'> 3.25<type 'int'> 12<type 'str'> montant

>>> liste = [3.25, 12, "montant"]>>> for element in liste :

print type(element), element

<type 'float'> 3.25<type 'int'> 12<type 'str'> montant

ou encore

La séquencequ’il faut traiter.

Variable destinée à contenir succes-sivement tous les éléments de laséquence. Son type est automatique-ment adapté à celui de l’élément quiest en cours de traitement.

18

Parcours d’une liste à l’aide des instructions for, range() et len()

>>> chiffres = ['zero', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf']

>>> for indice in range(len(chiffres)):print indice, chiffres[indice]

0 zero1 un2 deux3 trois4 quatre5 cinq6 six7 sept8 huit9 neuf

On peut étendre la défn

de la liste sur plusieurslignes.

19

Extraction d’une sous-liste dans une liste à l’aide d’une tranche

[m:n] désigne les éléments en position m, m+1, m+2, …, n-1.

>>> Voyelles = ['a', 'e', 'i', 'o', 'u', 'y']>>> print Voyelles[1:3]['e', 'i']>>> print Voyelles[3]o>>> print Voyelles[3:4]['o']>>> print Voyelles[3:]['o', 'u', 'y']

>>> print Voyelles[:3]['a', 'e', 'i']>>> print Voyelles[-1]y>>> print Voyelles[-1:-3][]>>> print Voyelles[-3:-1]['o', 'u']

un élément Une tranche dans une liste est toujours une liste.

20

Extraction d’une sous-liste dans une liste à l’aide d’une tranche

>>> jour = ['lundi', 'mardi', 3, 4, 'vendredi', 'samedi', 7]>>> saisons = [1, "printemps", 2, "ete", 3, "automne", 4, "hiver"]>>> print saisons[::2][1, 2, 3, 4]>>> print saisons[1::2]['printemps', 'ete', 'automne', 'hiver']>>> print saisons[4:6][3, 'automne']>>> saisons = [[1, 2, 3, 4], ["printemps", "ete", "automne", "hiver"]]>>> print saisons[1]['printemps', 'ete', 'automne', 'hiver']>>> print saisons[1][1]ete

21

Insertion d’une sous-liste dans une liste à l’aide d’une tranche

>>> couleur = ['bleu', 'blanc', 'rouge']>>> couleur[2:2] = ['noir']>>> print couleur['bleu', 'blanc', 'noir', 'rouge']>>> couleur[1:] = ['gris']>>> print couleur['bleu', 'gris']>>> couleur[:0] = ['blanc', 'noir', 'rouge']>>> print couleur['blanc', 'noir', 'rouge', 'bleu', 'gris']>>> couleur[6:6] = ['magenta']>>> print couleur['blanc', 'noir', 'rouge', 'bleu', 'gris', 'magenta']>>> couleur[6:6] = ['blanc']>>> print couleur['blanc', 'noir', 'rouge', 'bleu', 'gris', 'magenta', 'blanc']

Une tranche doit être présenteà droite du signe d’affectations’il en existe une à gauche.

22

Suppression ou remplacement d’une sous-liste dans une liste à l’aide d’une tranche

>>> nombres = [1, 3, 6, 8, 10, 18]>>> nombres[3:5] = [9, 12, 15]>>> print nombres[1, 3, 6, 9, 12, 15, 18]>>> nombres[7:7] = [21, 24, 27, 30]>>> print nombres[1, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]>>> nombres[3:5] = []>>> print nombres[1, 3, 6, 15, 18, 21, 24, 27, 30]>>> nombres[3:] = nombres[0:3]>>> print nombres[1, 3, 6, 1, 3, 6]

>>> liste = ["uvw", 13, 3.14159, [], ""]>>> liste[2:4] = ["OUI", 9+5j]>>> print liste['uvw', 13, 'OUI', (9+5j), '']

23

L’affectation d’une liste dans une autre crée un alias à la liste et non une véritablecopie à la liste.

>>> couleurs = ['bleu', 'blanc', 'rouge']>>> teintes = couleurs>>> teintes[1] = 'noir'>>> print couleurs['bleu', 'noir', 'rouge']>>> palette = couleurs +[]>>> palette[2] = 'orange'>>> print palette['bleu', 'noir', 'orange']>>> print couleurs['bleu', 'noir', 'rouge']

Ceci est une expression.

24

Les tuples

Vous savez qu’il n’est pas possible de changer les caractères au sein d’une chaîneexistante, alors que vous pouvez modifier les éléments d’une liste.

Un tuple est une collection d’éléments à l’intérieur de parenthèses séparés par desvirgules semblable à une liste mais qui n’est pas modifiable.

Les tuples sont préférables aux listes partout où l’on veut être certain que lesdonnées transmises ne soient pas modifiées par erreur.

>>> saisons = ("printemps", "été", "automne", "hiver")>>> print saisons('printemps', 'été', 'automne', 'hiver')>>> print saisons[2:3]('automne',)>>> print ("printemps",) + saisons[1:4]('printemps', 'été', 'automne', 'hiver')>>> saisons[2] = "Automne"

Traceback (most recent call last): File "<pyshell#4>", line 1, in <module> saisons[2] = "Automne"TypeError: 'tuple' object does not support item assignment

Il faut toujours au moinsune virgule pour définirun tuple.

Un tuple peut représenter une clé de dictionnaire ce qu’une liste ne peut faire.

25

>>> un_tuple = ()>>> print un_tuple()>>> une_chaine = ("abc")>>> print type(une_chaine), une_chaine<type 'str'> abc>>> un_autre_tuple = ("abc",)>>> print type(un_autre_tuple), un_autre_tuple<type 'tuple'> ('abc',)>>> tuple("abc")('a', 'b', 'c')

tuple vide

Pour accéder aux valeurs d’un tuple, on utilise les crochets de la même façonqu’avec les listes.

>>> Couleur = ("blanc", "bleu", "rouge", "mauve", "noir")>>> print Couleur[1:3]('bleu', 'rouge')>>> print Couleur[:3]('blanc', 'bleu', 'rouge')>>> print Couleur[3:]('mauve', 'noir')

Création et affectation d’un tuple (suite)

26

Modification d’un tuple

Cela ne peut se faire directement. Il faut créer un nouveau tuple à l’aided’anciens grâce à l’opérateur de concaténation ou de répétition.

>>> Teinte = Couleur[1], Couleur[2], Couleur[4]>>> print Teinte('bleu', 'rouge', 'noir')>>> Teinte = Teinte[0:2] + ("vert",)>>> print Teinte * 2('bleu', 'rouge', 'vert', 'bleu', 'rouge', 'vert')

On peut modifier certains éléments d’un tuple si ces éléments sont modifiables.

>>> T = (5, [0, 1, 2])>>> print T(5, [0, 1, 2])>>> T[0] = 6Traceback (most recent call last): File "<pyshell#3>", line 1, in <module> T[0] = 6TypeError: 'tuple' object does not support item assignment>>> T[1][0] = -1>>> print T(5, [-1, 1, 2])

27

Suppression d’un tuple ou des éléments d’un tuple

Il est impossible de supprimer individuellement les éléments d’un tuple.On peut assembler un nouveau tuple en omettant les éléments indésirables.Pour supprimer explicitement un tuple entier, on utilise del :

del Teinte

Les opérateurs *, +, in, [], <, >, ==, <=, >= et les fonctions intégrées len, max, min,cmp et list se comportent exactement de la même façon avec les tuples qu’avecles listes.

Les méthodes de manipulation de listes - tri, remplacement, insertion, etc. – nesont pas implémentées.

Un ensemble d’éléments séparés par des virgules et écrits sans symbolesd’identification de type crochets pour les listes, parenthèses pour les tuples, etc.est par défaut un tuple.

>>> "Abc", 99('Abc', 99)>>> x = 23, 45, "q">>> x(23, 45, 'q')

>>> u, v = 0, 1>>> u, v(0, 1)>>> print u, v0 1

Les fonctions intégrées list() et tuple() permettentde convertir une liste en tuple ou vice versa.

>>> T = (2, 3)>>> T = list(T)>>> print T[2, 3]

28

# Déterminer tous les nombres premiers entre 2 et n.#n = input("Entrez la valeur de n : ")

Liste = range(2, n+1)Nombres_premiers = []

while (Liste != []):V = Liste[0]Nombres_premiers.append(V)W = Vwhile (W <= n):

if (W in Liste): Liste.remove(W)W = W + V

print Nombres_premiers

Recherche des nombres premiers entre 2 et n.

29

Recherche de la note maximale, de la moyenne des notes d’une classe etimpression des résultats tels que saisis ou triés en ordre croissant de note

# Saisir pour chaque étudiant son matricule (7 chiffres) et sa note sur 100# (une valeur entière). Pour terminer la saisie, entrez comme matricule la# valeur 0 et n'importe quelle note.# On doit s'assurer que la note d'un étudiant est saisie une seule fois.Liste = []

while True:matricule, note = input("Entrez le matricule et la note d'un étudiant : ")if (matricule == 0): breakif (matricule in Liste[::2]): continueListe.append(matricule)Liste.append(note)

# Recherche de la note maximale.

Note_maximale = max(Liste[1::2])

# Recherche du matricule de l'étudiant ayant une note maximale# en déterminant sa position.

Mat_maximale = Liste[::2][Liste[1::2].index(Note_maximale)]

30

Recherche de la note maximale, de la moyenne des notes d’une classe etimpression des résultats tels que saisis ou triés en ordre croissant de note

# Calcul de la moyenne obtenue.

somme = 0.0for note in Liste[1::2]: somme += notemoyenne = somme / len(Liste[1::2])

# Impression des résultats.

print ("Le meilleur étudiant est : %7d. Il a obtenu comme note : %3d." % (Mat_maximale, Note_maximale))print "La moyenne de la classe est : ", moyenne

print "\nImpression des résultats de la classe\n"print "\tMatricule\tNote"

for i in range(len(Liste[::2])): print "\t", Liste[2*i], "\t", Liste[2*i + 1]

31

Recherche de la note maximale, de la moyenne des notes d’une classe etimpression des résultats tels que saisis ou triés en ordre croissant de note

print "\nImpression des résultats de la classe triés en ordre croissant de note\n"print "\tMatricule\tNote"

Liste_de_tri = []

for i in range(len(Liste[::2])): Liste_de_tri.append(Liste[2*i + 1]* 10000000 + Liste[2*i])

Liste_de_tri.sort()

for i in range(len(Liste_de_tri)): print "\t", int(Liste_de_tri[i] % 10000000), "\t", Liste_de_tri[i] / 10000000

32

Recherche de la note maximale, de la moyenne des notes d’une classe etimpression des résultats tels que saisis ou triés en ordre croissant de note

Entrez le matricule et la note d'un étudiant : 9876345, 35Entrez le matricule et la note d'un étudiant : 9912432, 54Entrez le matricule et la note d'un étudiant : 9087456, 87Entrez le matricule et la note d'un étudiant : 9123123, 75Entrez le matricule et la note d'un étudiant : 0, 0Le meilleur étudiant est : 9087456. Il a obtenu comme note : 87.La moyenne de la classe est : 62.75

Impression des résultats de la classe

Matricule Note9876345 359912432 549087456 879123123 75

Impression des résultats de la classe triés en ordre croissant de note

Matricule Note9876345 359912432 549123123 759087456 87

33

Algorithme de calcul du kième plus petit élément d’une suite

Étape 0. Créer une liste vide Suite.

Étape 1. Tant que l’élément saisi n’est pas le caractère ‘#’ajouter à la liste l’élément saisi.

Étape 2. Saisir la valeur entière k entre 1 et la longueur de la suite.

Étape 3. Conserver la valeur de k dans Valeur_de_k.

Étape 4. Tant et aussi longtemps que le k ième plus petit élément n’est pas trouvé

Étape 4.1 Créer 2 listes vides Gauche et Droite.Placer dans pivot la valeur de Suite[0].Initialiser à 0 la variable Nb_occurrences_du_pivot désignantle nombre d’occurrences du pivot choisi.

Étape 4.2 Pour chaque i ième élément de la suite Suitesi pivot > i ième élément, ajouter le i ième élément

à la liste Gauchesinon si pivot < i ième élément, ajouter le i ième élément

à la liste Droitesinon ajouter 1 à Nb_occurrences_du_pivot.

34

Étape 4.3 Si la longueur de la suite Gauche Valeur_de_kSuite = Gauche

sinonsi la longueur de la suite Gauche + Nb_occurrences_du_pivot >=

Valeur_de_k): pivot est l’élément cherché, c’est terminé.

sinonValeur_de_k -= ( longueur de la suite Gauche +

Nb_occurrences_du_pivot)Suite = Droite

Étape 5. Afficher la valeur du pivot qui correspond bien au k ième plus petit élémentde la suite.

35

Calcul du kième plus petit élément d’une suite

# Saisir les éléments d'une suite. Pour terminer, entrez le caractère #.

Suite = []while True:

element = input("Entrez un élément de la suite : ")if (element == "#"): breakSuite.append(element)

# Saisir la valeur entière k.

k = input("Entrez l'indice k : ")

# Déterminer le k ième plus petit élément de la suite et ranger sa valeur# dans une variable pivot.

# À compléter ……

# Affichage du k ième plus petit élément de la suite.

print "Le %5d ième plus petit élément de la suite est : %5d" % (k, pivot)

36

Calcul du kième plus petit élément d’une suite

# Déterminer le k ième plus petit élément de la suite et ranger sa valeur# dans la variable pivot.

Valeur_de_k = kFin = Truewhile (Fin):

Gauche = []Droite = []Nb_occurrences_du_pivot = 1pivot = Suite[0]

for i in range(1, len(Suite)):if (pivot > Suite[i]): Gauche.append(Suite[i])elif (pivot < Suite[i]): Droite.append(Suite[i])else: Nb_occurrences_du_pivot += 1

if (len(Gauche) >= Valeur_de_k): Suite = Gaucheelif (len(Gauche) + Nb_occurrences_du_pivot >= Valeur_de_k): Fin = Falseelse :

Valeur_de_k -= (len(Gauche) + Nb_occurrences_du_pivot)Suite = Droite

37

Fusion de 2 suites triées

# Saisir les éléments de la première suite.# Pour terminer la saisie, entrez le caractère #.

Suite1 = []

while True:element = input("Entrez un élément de la première suite : ")if (element == "#"): breakSuite1.append(element)

# Saisir les éléments de la deuxième suite.# Pour terminer la saisie, entrez le caractère #.

Suite2 = []

while True:element = input("Entrez un élément de la deuxième suite : ")if (element == "#"): breakSuite2.append(element)

38

Fusion de 2 suites triées

# Trier les 2 suites en ordre croissant.

Suite1.sort()Suite2.sort()

# Fusionner ces 2 suites en une seule.

i = 0j = 0Suite = []

while (i < len(Suite1) and j < len(Suite2)):if (Suite1[i] <= Suite2[j]):

Suite.append(Suite1[i])i = i + 1

else :Suite.append(Suite2[j])j = j + 1

39

Fusion de 2 suites triées

while (i < len(Suite1)):Suite.append(Suite1[i])i = i + 1

while (j < len(Suite2)):Suite.append(Suite2[j])j = j + 1

# Affichage des 2 suites triées.

print "\nPremière suite triée : ",for i in range(len(Suite1)): print Suite1[i],

print "\nDeuxième suite triée : ",for i in range(len(Suite2)): print Suite2[i],

# Affichage des 2 suites fusionnées.

print "\nFusion des 2 suites : ",for i in range(len(Suite)): print Suite[i],

40

Fusion de 2 suites triées

Entrez un élément de la première suite : 54Entrez un élément de la première suite : 76Entrez un élément de la première suite : 1Entrez un élément de la première suite : 9Entrez un élément de la première suite : 5Entrez un élément de la première suite : 34Entrez un élément de la première suite : 67Entrez un élément de la première suite : 2Entrez un élément de la première suite : "#"Entrez un élément de la deuxième suite : 24Entrez un élément de la deuxième suite : 7Entrez un élément de la deuxième suite : 2Entrez un élément de la deuxième suite : 9Entrez un élément de la deuxième suite : 6Entrez un élément de la deuxième suite : "#"

Première suite triée : 1 2 5 9 34 54 67 76 Deuxième suite triée : 2 6 7 9 24 Fusion des 2 suites : 1 2 2 5 6 7 9 9 24 34 54 67 76

41

Réduction d’une suite de sorte que chaque élément ait une seule occurrence.

# Saisir les éléments de la suite initiale. Terminez la saisie avec le caractère #.

Suite, Suite_reduite = [], []

while True:element = input("Entrez un élément de la suite : ")if (element == "#"): breakSuite.append(element)

for i in range(len(Suite)):if (Suite[i+1:].count(Suite[i]) == 0): Suite_reduite.append(Suite[i])

# Affichage de la suite originale.

print "\nImpression de la suite originale : ",for i in range(len(Suite)): print Suite[i],

# Affichage de la suite réduite.

print "\nImpression de la suite réduite : ",for i in range(len(Suite_reduite)): print Suite_reduite[i],

42

Réduction d’une suite de sorte que chaque élément ait une seule occurrence.

Entrez un élément de la suite : 5Entrez un élément de la suite : 3Entrez un élément de la suite : 4Entrez un élément de la suite : 2Entrez un élément de la suite : 5Entrez un élément de la suite : 4Entrez un élément de la suite : 3Entrez un élément de la suite : 5Entrez un élément de la suite : 7Entrez un élément de la suite : 8Entrez un élément de la suite : 9Entrez un élément de la suite : 45Entrez un élément de la suite : 2Entrez un élément de la suite : "#"

Impression de la suite originale : 5 3 4 2 5 4 3 5 7 8 9 45 2 Impression de la suite réduite : 4 3 5 7 8 9 45 2

43

Somme de deux masques binaires.

MasqueA, MasqueB = input("Saisir les 2 masques binaires : ")

# Placer dans Premier_terme la liste des chiffres du# masque le plus long et dans Deuxieme_terme la liste# des chiffres du masque le moins long précédée d'une# liste de zéro de telle sorte que les 2 termes soient# de même longueur.

if (len(MasqueA) > len(MasqueB)): Premier_terme = ['0'] + list(MasqueA) m = len(MasqueA) - len(MasqueB) + 1 Deuxieme_terme = ['0'] * m + list(MasqueB)else: Premier_terme = ['0'] + list(MasqueB) m = len(MasqueB) - len(MasqueA) + 1 Deuxieme_terme = ['0'] * m + list(MasqueA)

# Inverser chaque masque.

Premier_terme.reverse()Deuxieme_terme.reverse()

44

Somme de deux masques binaires..

Saisir les 2 masques binaires : "1100101011010", "1110011"1100101011010 + 1110011 = 1100111001101

# Placer dans Premier_terme la somme des 2 masques.

retenue = 0for i in range(len(Premier_terme)): chiffre = retenue + int(Premier_terme[i]) + int(Deuxieme_terme[i]) if (chiffre % 2 == 0): Premier_terme[i] = '0' else: Premier_terme[i] = '1' retenue = chiffre / 2

Premier_terme.reverse()

# Afficher le résultat de la somme.

if (Premier_terme[0] == '0'):print MasqueA, " + ", MasqueB, " = ", "".join(Premier_terme[1:])

else: print MasqueA, " + ", MasqueB, " = ", "".join(Premier_terme)

45

Copies superficielles et copies en profondeur

Lors d’une affectation, nous effectuons une copie superficielle ou une copie enprofondeur.

1er cas : Copie superficielle. >>> couleur = ["rouge", 1, ("blanc", "noir"), ["gris"]]>>> teinte = couleur>>> teinte[0] = "ROUGE">>> teinte[1] = 2>>> teinte[2] = "BLANC">>> teinte[3] = 3>>> print couleur['ROUGE', 2, 'BLANC', 3]

2ième cas : Copie en profondeur.

>>> couleur = ["rouge", 1, ("blanc", "noir"), ["gris"]]>>> teinte = couleur[:]>>> teinte[0] = "ROUGE">>> teinte[1] = 2>>> teinte[2] = "BLANC">>> teinte[3] = 3>>> print couleur['rouge', 1, ('blanc', 'noir'), ['gris']]

couleur et teinte désignentla même variable.

couleur et teinte désignentdeux variables différentes.

46

Copies superficielles et copies en profondeur

>>> couleur = ["rouge", 1, ("blanc", "noir"), ["gris"]]>>> import copy>>> teinte = copy.deepcopy(couleur)>>> teinte[0] = "ROUGE">>> print teinte['ROUGE', 1, ('blanc', 'noir'), ['gris']]>>> print couleur['rouge', 1, ('blanc', 'noir'), ['gris']]

On peut aussi forcer une copie en profondeur.