1

Tableau statique en lecture seule d’objets hétérogènes

LES TUPLES

2
Création des tuples et accès aux données
#définition d'un tuple Les ( ) sont importantes pour indiquer qu’il
t1 = (2,6,8,10,15,26) s’agit d’un tuple, « , » sépare les éléments.
print(t1)
#taille du tuple (2,6,8,10,15,26)
print(len(t1)) 6 éléments
#accès indicé
a = t1[0] 1er élément, les indices vont de 0 à len(t1)-1
print(a) Remarque : a n’est pas un tuple
#modification ?
t1[2] = 3 ERREUR
#plage d'indices
b = t1[2:5] Attention : on récupère à partir du n°2 (inclus) au n°5
print(b) (non-inclus) c.-à-d. les indices 2, 3, 4
#autre plage Résultat : b est un tuple avec (8,10,15)
c = t1[:4]
print(c) Les 4 premiers éléments c.-à-d. les indices 0, 1, 2, 3 : nous
#indiçage négatif obtenons le tuple (2, 6, 8, 10).
d = t1[-1]
print(d) Le 1er élément à partir de la fin : 26
#indiçage négatif
e = t1[-3:]
Les 3 derniers éléments : (10,15,26)
print(e)

3
Plus loin avec les tuples
#concaténation
t2 = (7, 9,31) (2,6,8,10,15,26,7,9,31)
t3 = t1 + t2
print(t3)
(7,9,31,7,9,31)
#réplication
t4 = 2 * t2
print(t4) Ca ne pose absolument aucun
problème.
#tuples d'objets hétérogènes
v1 = (3,6,"toto",True,34.1)
print(v1)
Sorte de tableau à 2 dimensions
#tuple de tuples
x = ((2,3,5),(6,7,9),(1,8))
print(x) 
x[0] → (2,3,5) Organisation de
#accès indicé x[1] → (6,7,9) la structure
print(x[2][1]) → 8 x[2] → (1,8)
#accès aux tailles
print(len(x)) → 3 3 éléments sur la 1ère dimension
print(len(x[2])) → 2 2 éléments dans le tuple référencé par x[2]

4
Bilan sur les tuples

• Type ‘tuple’ cf. appel de la fonction type()

• Collection d’objets de types hétérogènes
• Taille et contenu fixé lors de l’écriture du programme
• Impossible de modifier : objet non mutable
• La variable de type tuple est en réalité une référence (pointeur de pointeur)
• Bénéficie du mécanisme de ramasse miettes
• Accès indicé, plage d’indices possible, indices négatifs possibles aussi
• Structures complexes avec tuple de tuples, et même plus – à voir plus tard

5
Tableau dynamique en lecture-écriture d’objets hétérogènes

LES LISTES

6
Liste – Le type list

Liste ≈ tuple de taille dynamique et modifiable

#définition d'une liste Les [ ] sont importantes pour indiquer qu’il

L1 = [2,6,8,10,15,26] s’agit d’une liste, « , » sépare les éléments.
print(L1)
[2,6,8,10,15,26]
#taille de la tuple = 6
print(len(L1))
[2,6,3,10,15,26]
#accès indicé = 2
a = L1[0]
print(a)
Les autres mécanismes associés aux
tuples sont transposables aux listes :
#modification ! Possible !
L1[2] = 3 • plages d’indices
print(L1) • indiçages négatifs
• objets hétérogènes
• liste de listes (tableaux 2D ou +)
• concaténation, réplication

7
Plus loin avec les listes : modification de taille et de contenu
#autre liste Une liste est un objet (instance de classe) auquel est
L2 = [32,69,28,69] associé des méthodes permettant de le manipuler.
#ajout
[Link](21) [32,69,28,69,21]
print(L2)
#insertion à l'indice 1
[32,53,69,28,69,21]
[Link](1,53)
print(L2)
#suppression elt n°3
[32,53,69,69,21] 28 a disparu de L2
del L2[3]
print(L2)
#accès + suppression elt n°1
a = [Link](1) [32,69,69,21] 53 a disparu de L2
print(a) → renvoie 53
#inversion
[Link]()
[21,69,69,32]
print(L2)
#étendre Remarque :
[Link]([34,55]) [21,69,69,32,34,55] [Link]()
print(L2) Permet de vider la liste
8
Les « List Comprehensions » (traduite en « listes en intension »)

Objectif : un mécanisme simple (et concis) pour générer une liste à partir d’une autre liste.

Exemple 1 : Monter tous les chiffres au carré

source = [1,5,8,12,7]
resultat = [] resultat = [v**2 for v in source]
for v in source: print(resultat)
[Link](v**2)
print(resultat) La convention d’écriture nous facilite la tâche !!!

Exemple 2 : Actions conditionnelles

source = [1,5,8,12,7]
resultat = []
for v in source: resultat = [v**2 for v in source if (v % 2 == 0)]
if (v % 2 == 0): print(resultat)
[Link](v**2)
print(resultat)

9
Plus loin avec les listes : traitement par le contenu
L2 = [21,69,69,32,34,55]
#recherche d'élément
trouve = 32 in L2 Renvoie True puisque la valeur
print(trouve) 32 se trouve dans la liste

#index
Renvoie 4 puisque la valeur 34 apparaît
id = [Link](34)
à l’indice n°4 (indice du 1er trouvé)
print(id)

#comptage Renvoie 2 puisque la valeur 69 apparaît

nb = [Link](69) 2 fois dans la liste
print(nb)

#retrait par valeur Retire la valeur 69 de la liste, la

première que la méthode trouvera
[Link](69)
print(L2) [21,69,32,34,55]

Ce mécanisme fonctionne avec tout type d’objet pourvu

qu’une comparaison soit possible (ex. chaîne, etc.)
10
Une variable de type liste est une référence
#L3
L3 = [61,92,17]
print(L3)
#affectation ? En ré alité, c’est la référence qui est copiée.
L4 = L3
print(L4) L3 et L4 « pointent » au même endroit.
#modification d'une valeur
L4[1] = 55
#répercussions
print(L4) → [61,55,17]
#mais aussi sur L3
print(L3) → [61,55,17] ???

#L3
L3 = [61,92,17]

#copie des valeurs

L4 référe nce une nouvelle zone mémoire,
L4 = [Link]()
print(L4) et les do nnées de L3 y sont recopiées.

L4[1] = 55
print(L4) → [61,55,17]

print(L3) → [61,92,17] !!! L3 n’est pas impacté.

11
Un e xe m p l e : s o m m e d e v a l e u r s s a i s i e s p a r l’utilisateur

12
Un exemple(bis) : boucle directe sur les éléments de la liste

Permet de définir une

liste initialement vide.

Une liste est directement

« itérable », il n’est pas
nécessaire de passer par un
indice (un peu comme le
foreach de certains langages
de prog.).

13
Un cas particulier de liste

CHAÎNE DE CARACTÈRES

14
Une chaîne de caractères est une liste particulière avec des méthodes associées
#définir une chaîne
s1 = "bonjour le monde"
Guillemets pour délimiter une chaîne
print(s1)
#longueur
long = len(s1) Mécanisme identique aux
print(long) tuples et listes
#accès indicé
s2 = s1[:7]
print(s2) ERREUR. Une chaîne n’est pas modifiable. Il faut mettre
#non modifiable
le résultat d’une manipulation dans une autre chaîne.
#s1[0] = "B"
#méthodes associées
S = [Link]()
print(S)
#recherche d'une sous-chaîne
id = [Link]("JO") Des méthodes spécifiques permettent
print(id)→ 3 (1 occurrence si plusieurs)
ère de manipuler les chaînes. Cf.
#nb d'occurences [Link]
nb = [Link]("ON")
[Link]#text-sequence-type-str
print(nb)→ 2
#remplacement de « O » par « A »
SA = [Link]("O","A")
print(SA)
R.R. – Université Lyon 2 15
Transformation explicite en liste (pour traitements)

Une chaîne peut être transformée en liste pour réaliser des

traitements sophistiqués. L’outil est très souple.

[‘B’,’O’,’N’,’J’,’O’,’U’,’R’,’ ‘,’L’,’E’,’ ‘,’M’,’O’,’N’,’D’,’E’]

#transf. en liste Toutes les opérations sur les listes sont possibles par la suite.
liste = list(S)
print(liste)
[‘BONJOUR’,’LE,’MONDE’]
Espace est utilisé comme séparateur ici, mais
#découpage par séparateur
ça peut être tout autre carac., y compris un
decoupe = [Link](" ")
caractère spécial (ex. \t pour tabulation)
print(decoupe)

#former une chaîne à

#partir d’une liste
SB = "-".join(decoupe) "BONJOUR-LE-MONDE"
print(SB) Les mots de la liste ont été fusionnés avec le
séparateur "-". Tout séparateur est possible, y
compris la chaîne vide.

16
Un exemple

17
Liste avec accès par clé

LES DICTIONNAIRES

18
Dictionnaire - Le type dict
#définition d'un dictionnaire
d1 = {'Pierre':17, 'Paul':15,'Jacques':16}
print(d1)
#ou
Noter le rôle de { }, de « : »
print([Link]())
et « , »
#nombre d'élements
print(len(d1)) → 3 éléments

#liste des clés

[‘Paul’, ‘Jacques’, ‘Pierre’]
print([Link]())

#liste des valeurs [15, 16, 17]

print([Link]())

#accès à une valeur par clé Remarques :

print(d1['Paul']) → 15 1) [Link]() vide
#ou
le dictionnaire
print([Link]('Paul')) → 15
(2) d1 est une référence,
#si clé n'existe pas [Link]() permet de
print(d1['Pipa']) → ERREUR copier le contenu.
19
Dictionnaire – Modifications, ajouts et suppressions
#modification
{'Pierre':17, 'Paul':15,'Jacques':16} → {'Pierre':17, 'Paul':15,'Jacques':18}
d1['Jacques'] = 18
print(d1) Ajout par définition d’une nouvelle paire « clé –
valeur ». N.B. : Si ‘Henri’ existe déjà, son ancienne
#ajouter un élément valeur sera écrasée.
d1['Henri'] = 22
{'Pierre':17, 'Paul':15,'Jacques':18, ‘Henri’:22}
print(d1)

#ajout d'un bloc d’éléments

[Link]({'Monica':36,'Bill':49})
print(d1)
{'Pierre':17, 'Paul':15,'Jacques':18, ‘Henri’:22, ‘Monica’:36, ‘Bill’ : 49}

#détecter présence clé

test = 'Pierre' in d1
print(test) → True

#suppression par clé

del d1['Monica']
print(d1) {'Pierre':17, 'Paul':15,'Jacques':18, ‘Henri’:22, ‘Bill’ : 49}

20
Plus loin avec les clés

Les clés ne sont pas forcément des chaînes de caractères.

L’outil est très souple mais, attention, autant de liberté
peut être aussi préjudiciable. Il faut être très rigoureux.

#autre type de clé

d2 = {('Pierre',56):['Directeur',1253,True],('Paul',55):['Employé',100,False]}
print([Link]())
print([Link]())

Dans cet exemple :

• clé est un tuple ;
• valeur est une liste.
D’autres types sont possibles (ex. instances de classes – à voir plus loin).

21
Exemple

Accès indicé malaisé

(très), on a intérêt à
passer par un itérateur
pour passer en revue le
dictionnaire.

Exemple :
Kate 15.0
Pipa 23.5
William 10.7

49.2

22