(1ADS-04) Structures Séquentielles de Données

Structures séquentielles de données.
1ADS Algorithm in Python
© SUPINFO Interna/onal University – h8p://www.supinfo.com

Structures séquen/elles de données.
Objec&fs de ce module
• Introduire des structures de données dites

« complexes ».
• Au sein d’une même en/té on va ainsi pouvoir

stocker plusieurs données, et les traiter de
façon op/male.

Plan de ce module
1. Généralités sur les séquences en Python.

2. Les listes.
3. Les t-‐uples.

1. GÉNÉRALITÉS SUR LES

SÉQUENCES EN PYTHON.

Plan de ce chapitre
a. No/on de séquence.

b. Les trois principaux types de séquences.
c. Opéra/ons communes aux séquences.
d. Parcours d’une séquence avec « for ».
e. Exercice.

a. No&on de séquence.

Mo&va&on :

• Réunir au sein d’une même variable plusieurs valeurs
différentes.
• L’objec/f étant d’op/miser certaines opéra/ons comme la

recherche d’un élément, le tri de ces valeurs, le calcul de
leur maximum, etc.


Défini&on :

•Suite d’éléments accessibles par leur posi&on.
•Chaque élément, à part le premier, a un prédécesseur et, à

part le dernier, a un successeur.


Une séquence de n éléments :

Indexation des éléments à
partir du début
0 1 2 n-2 n-1
-n -(n – 1) -(n – 2) -2 -1
Indexation des éléments à

partir de la fin


Accès a un élément :

• L’accès à un élément d’une séquence se fait en u/lisant la
posi/on de cet élément et des crochets [ ].
maSéquence[maPositionVoulue]

b. Les 3 principaux types de séquences.

Les trois principaux types de séquences :

1. Les listes dont les éléments sont quelconques et
modifiables.
2. Les t-‐uples dont les éléments sont quelconques et non

modifiables.
3. Les chaînes de caractères dont les éléments sont des

caractères et ne sont pas modifiables.


Syntaxes de la déclara&on d’une liste :
maListeVide = []
maListeAvecUnSeulElement = [élément]
maListe = [élément1,élément2,...,élémentN]


Exemple de créa&on/manipula&on de listes :
>>> maListe = [2, -3, ['xox', 69], 11]

>>> print(maListe)
[2, -3, ['xox', 69], 11]
>>> print(maListe[-1])
11
>>> maListe[1] = 666
>>> print(maListe[1])
666
>>> print(maListe[2][0][1])
o


Un pe&t dessin de la liste précédente pour fixer les idées :
0 1 2 3
2 -‐3 [‘xox’, 69] 11
-4 -3 -2 -1
0 1
‘xox’ 69
-2 0 1 2
-1
x o x
-3 -2 -1

Syntaxes de la déclara&on de t-‐uples :
monTupleVide = ()
monTupleAvecUnSeulElement = (élément,)
monTuple = (élément1,élément2,...,élémentN)


Exemple de créa&on/manipula&on de t-‐uples :
>>> monTuple = (2.718, 3.14, 1.414)

>>> print(monTuple)
(2.718, 3.14, 1.414)
>>> print(monTuple[2])
1.414
>>> monTuple[2] = 1.732
Traceback (most recent call last):
File "<console>", line 1, in <module>
TypeError: 'tuple' object does not support
item assignment

c. Opéra&ons communes aux séquences

Accès aux éléments (“slicing”) :
Opéra&on Résultat
s[i] i-‐ème élément de s
s[i:j] Sous-‐séquence de s cons/tuée des éléments entre
le i-‐ème (inclus) et le j-‐ème (exclus)
s[i:j:k] Sous-‐séquence de s cons/tuée des éléments entre
le i-‐ème (inclus) et le j-‐ème (exclus)
pris avec un pas de k


Exemple :
>>> t = (7, -3, 2, 11, 666, -1975)

>>> t[3:]
(11, 666, -1975)
>>> t[1:4]
(-3, 2, 11)
>>> t[1::2]
(-3, 11, -1975)
>>> t[23]
Traceback (most recent call last):
File "<console>", line 1, in <module>
IndexError: tuple index out of range

Opéra&ons de traitement :
Opéra&on Résultat
x in s Teste si x appar/ent à s
x not in s Teste si x n’appar/ent pas à s
s + t Concaténa/on de s et t
s * n ou n * s Concaténa/on de n copies de s
len(s) Nombre d’éléments de s
min(s) Plus pe/t élément de s
max(s) Plus grand élément de s
s.count(x) Nombre d’occurences de x dans s
s.index(x) Indice de x dans s.

Exemples :
>>> t = (7, -3, 2)

>>> 11 not in t
True
>>> max(t)
7
>>> tt = 2*t
>>> print(tt)
(7, -3, 2, 7, -3, 2)
>>> tt.count(-3)
2

d. Parcours d’une séquence avec “for”.

Itéra&on sur les éléments :
for x in maSéquence:
traitement de l’élemént x


Exemple :
l = [-2, 3, 11]
for x in l:
print(x**2)


Itéra&on sur les couples (indice, élément) :
for i,x in enumerate(maSéquence):

traitement de l’élemént x et/ou de
l’indice i


Exemple :
l = (-2, 3, 11)
for i, x in enumerate(l):
print("élément n°",i+1,":",x**2)


Itéra&on sur les indices :
for i in range(len(maSéquence)):
traitement de l’élément maSéquence[i]
et/ou de l’indice i


Exemple :
l = (-2, 3, 11)
for i in range(len(l)):
print("élément n°",i+1,":",l[i]**2)


Itéra&on sur deux séquences :
for x,y in zip(maSéquence1,maSéquence2):

traitement des éléments x et y


Exemple :
l = (-2, 3, 11)
m = 'Keith'
for x,y in zip(l,m):
print(x,y)

e. Exercice.
Exercice : écrire une fonc/on prenant une séquence de
nombre en/ers en paramètre, et qui retourne le nombre
d’en/ers pairs de ce8e séquence.

e. Exercice.
Solu&on :
def nbPairs(s):
n = 0
for x in s:
if x%2 == 0:
n += 1
return n
monTuple = (-4, 5, 2, 4, 1)
print(nbPairs(monTuple))

Fin de ce chapitre
Avez – vous des ques/ons ?

2. LES LISTES.

2. Les listes.
Plan de ce chapitre
a. Les listes sont muables.

b. Opéra/ons propres aux listes.
c. Le délicat problème des copies
d. Listes définies « en compréhension ».
e. Listes mul/dimensionnelles.
f. Exercice.

2. Les listes.

Deux conséquences de la muabilité des listes :

1. On peut modifier les éléments d’une liste, en supprimer,
en ajouter d’autres.
2. Une liste transmise en paramètre à une fonc/on peut

être modifiée par ce8e dernière.

2. Les listes.

Exemple de modifica&on d’une liste par une fonc&on :
def swap(l,i,j):
l[i], l[j] = l[j], l[i]
maListe = [1, 2, 3, 4]
print("avant échange :",maListe)
swap(maListe,0,3)
print("après échange :",maListe)

2. Les listes.
b. Opéra&ons propres aux listes.

Opéra&ons de “slicing” pour modifier une liste :
Opéra&on Résultat
s[i] = x Remplacement de l’élément s[i] par x
s[i:j] = t Remplacement des éléments de s[i:j] par ceux de
la séquence t
del(s[i:j]) Suppression des éléments de s[i:j]
s[i:j:k] = t Remplacement des éléments de s[i:j:k] par ceux
de la séquence t
del(s[i:j:k]) Suppression des éléments de s[i:j:k]

2. Les listes.

Exemple de modifica&on d’une liste par “slicing” :
>>> maListe = [1, 2, 3, 4, 5]

>>> maListe[2:4] = (6,'x',7)
>>> print(maListe)
[1, 2, 6, 'x', 7, 5]
>>> maListe[1:6:2] = 'sup'
>>> print(maListe)
[1, 's', 6, 'u', 7, 'p']

2. Les listes.

Opéra&ons de traitement :
Opéra&on Résultat
Iist(s) Transforme une séquence s en une liste
s.append(x) Ajoute l’élément x à la fin de s
s.extend(t) Étend s avec la séquence t
s.insert(i,x) Insère l’élément x à la posi/on i
s.clear() Supprime tous les éléments de s
s.remove(x) Re/re l’élement x de s
s.pop(i) Renvoie l’élément d’indice i et le supprime
s.reverse() Inverse l’ordre des éléments de s
s.sort() Trie les éléments de s par ordre croissant
2. Les listes.

Exemples :
>>> maListe = [1, 3, 5]

>>> maListe.append(7)
>>> print(maListe)
[1, 3, 5, 7]
>>> maListe.extend((8, 11))
>>> print(maListe)
[1, 3, 5, 7, 8, 11]
>>> maListe.remove(8)
>>> maListe.insert(4,9)
>>> print(maListe)
[1, 3, 5, 7, 9, 11]

2. Les listes.

Exemples :
>>> maListe = list(range(1,10,2))

>>> maListe
[1, 3, 5, 7, 9]
>>> taListe = list('The Strypes')
>>> taListe
['T', 'h', 'e', ' ', 'S', 't', 'r', 'y',
'p', 'e', 's']

2. Les listes.
c. Le délicat problèmes des copies

Phénomène d’alias :

• La tenta/ve de copie d’une liste avec la syntaxe naturelle
maListe2 = maListe1
ne crée qu’un alias.

• Les deux noms pointeront vers le même emplacement
mémoire. Il n’y aura donc en réalité qu’une seule liste
existante.
2. Les listes.

Exemple du problème soulevé :
>>> maListe1 = [1, 2, 3, 4]

>>> maListe2 = maListe1
>>> maListe2[3] = 666
>>> print(maListe1)
[1, 2, 3, 666]
>>> maListe1[0] = 'Python'
>>> print(maListe2)
['Python', 2, 3, 666]

2. Les listes.

Plusieurs solu&ons pour réaliser une copie superficielle :
maListe2 = maListe1.copy()
import copy
maListe2 = copy.copy(maListe1)
maListe2 = list(maListe1)
maListe2 = []
maListe2.extend(maListe1)
maListe2 = maListe1[:]

2. Les listes.

Exemple d’une copie “qui marche” :
>>> maListe1 = [1, 2, 3, 4]

>>> maListe2 = maListe1[:]
>>> maListe2[3] = 666
>>> print(maListe1)
[1, 2, 3, 4]
>>> maListe1[0] = 'Python'
>>> print(maListe2)
[1, 2, 3, 666]

2. Les listes.

Solu&on pour réaliser une copie profonde :
import copy
maListe2 = copy.deepcopy(maListe1)

2. Les listes.

Exemple d’une copie profonde :
>>> maListe1 = [1, [11, 22]]

>>> maListe2 = list(maListe1)
>>> maListe2[1][0] = 33
>>> print(maListe1)
[1, [33, 22]]
>>> import copy
>>> maListe3 = copy.deepcopy(maListe1)
>>> maListe3[1][0] = 44
>>> print(maListe1)
[1, [33, 22]]

2. Les listes.
d. Listes définies “en compréhension”.

Principe :

• Le but est de construire une liste à par/r d’une séquence
déjà existante.
• Plus précisément, on va effectuer une opéra/on sur

chacun des éléments d’une séquence pour obtenir une
liste cons/tuée des différents résultats.

2. Les listes.

Syntaxe générale :
[expression for x in sequence if conditionnelle]

2. Les listes.

Exemple 1 : élever au carré les éléments d’une séquence
pour construire une liste
t = (11, 22, 33, 44)
l = [x**2 for x in t]
print(l)

2. Les listes.

Exemple 1 (suite) : la même chose sans u/liser une défini/on
par compréhension.
t = (11, 22, 33, 44)
l=[]
for x in t:
l.append(x**2)
print(l)

2. Les listes.

Exemple 2 : avec deux boucles “for” et une condi/onnelle.
l = [(i,j) for i in range(1,4) for j in

range(1,4) if i != j]
print(l)

2. Les listes.
e. Listes mul&dimensionnelles.
• Comme constaté sur un exemple les éléments d’une liste
peuvent eux-‐mêmes être une liste.
• On peut ainsi créer des listes mul&dimensionnelles.
• L’accès aux élément se fait alors avec une syntaxe de la

forme :

maListe[i1][i2]...[iN]

2. Les listes.
Remarque importante et exemple : a8en/on à l’ini/alisa/on
des listes mul/mensionnelles.
plateau = [[0]*3]*4
print(plateau)
plateau[3][2] = 666
print(plateau)

2. Les listes.
Remarque importante et exemple (suite) : a8en/on à
l’ini/alisa/on des listes mul/mensionnelles.
plateau = [[0]*3 for i in range(4)]

print(plateau)
plateau[3][2] = 666
print(plateau)

2. Les listes.
Remarque : le parcours de listes mul/dimensionnelles se
fera en imbriquant des boucles for.
plateau = [[0]*3 for i in range(4)]

plateau[3][2] = 666
for ligne in plateau:
for x in ligne:
print(x,' ',end='')
print('\n')

2. Les listes.
f. Exercice.
Exercice : écrire une fonc/on prenant une séquence de
nombre en/ers en paramètre, et qui retourne une liste de
booléens de la même taille. Le i-‐ème élément de ce8e liste
retournée vaudra “true” si le i-‐ème élément du paramètre
est pair, et “false” sinon.

2. Les listes.
f. Exercice.
Solu&on :
def parite(s):
return [(n%2 == 0) for n in s]
monTuple = (-4, 5, 2, 4, 1)
print(parite(monTuple))

2. Les listes.
Fin de ce chapitre

3. LES T-‐UPLES.

3. Les t-‐uples.
Plan de ce chapitre
a. Les t-‐uples sont immuables.

b. Opéra/ons propres aux t-‐uples.
c. Intérêts des t-‐uples.
d. Fonc/ons avec nombre variable de
paramètres.
e. Exercices.

3. Les t-‐uples.

Deux conséquences de l’immuabilité des t-‐uples :

1. On ne peut pas modifier les éléments d’un t-‐uple, en
supprimer, en ajouter d’autres.
2. Un t-‐uple transmis en paramètre à une fonc/on ne peut

être modifiée par ce8e dernière.

3. Les t-‐uples.

Exemple de non modifica&on d’un t-‐uple par une fonc&on :
def swap(l,i,j):
l[i], l[j] = l[j], l[i]
monTuple = (1, 2, 3, 4)
print("avant échange :",monTuple)
swap(monTuple,0,3)
print("après échange :",monTuple)

3. Les t-‐uples.
b. Opéra&ons propres aux t-‐uples.

Opéra&on de créa&on d’un t-‐uple :

Permet de transformer une séquence en un t-‐uple

monTuple = tuple(maSéquence)

3. Les t-‐uples.
b. Opéra&ons propres aux t-‐uples.

Exemples :
>>> monTuple = tuple(range(0,9,2))

>>> monTuple
(0, 2, 4, 6, 8)
>>> monTuple = tuple("The Decemberist")
>>> monTuple
('T', 'h', 'e', ' ', 'D', 'e', 'c', 'e',
'm', 'b', 'e', 'r', 'i', 's', 't')

3. Les t-‐uples.
c. Intérêts des t-‐uples.

• Si on veut définir une séquence de données que l’on ne
veut pas modifier, u/liser un t-‐uple sécurise ce fait.
• Itérer sur les éléments d’un t-‐uple est plus rapide que sur
ceux d’une liste.
• Une fonc/on qui retourne “plusieurs valeurs”, retourne en

fait un t-‐uple.
• Les t-‐uples peuvent être u/lisés comme des clés de

dic/onnaire (voir module 7).
3. Les t-‐uples.
d. Fonc&ons avec nb. variable de para.

Principe :

• En Python, une fonc/on peut adme8re un nombre
variable de paramètres.
• Ceux-‐ci ne possèdent pas de noms individuels, et la

fonc/on les traite alors comme étant regroupés dans un
t-‐uple.

3. Les t-‐uples.

Syntaxe :
def maFonction(para1,para2,...,*args):
bloc d’instructions de la fonction
traitant les paramètres 1,2 etc.
ainsi que les paramètres en nombre
variable regroupés dans le t-uple
nommé ici « args ».
return valeur

3. Les t-‐uples.

Exemple :
def relations(ami,*args):
for i,name in enumerate(args):
print("mon",ami,"n°",i+1,":",name)
relations("ami","mick","keith","ron")
relations("ennemi","john","paul")

3. Les t-‐uples.
e. Exercices.
Exercice : écrire une fonc/on calculant le produit d’un
nombre variable de paramètres.

3. Les t-‐uples.
e. Exercices.
Solu&on :
def produit(*nombres):
p = 1
for x in nombres:
p *= x
return p
print(produit(2,-4,5,3))

3. Les t-‐uples.
e. Exercices.
Exercice : en u/lisant le t-‐uplet ('a', 'e', 'i', 'o', 'u'), écrire une
fonc/on calculant le nombre de voyelles d’un texte.

3. Les t-‐uples.
e. Exercices.
Solu&on :
def voyelles(mot):
t = ('a','e','i','o','u')
s = 0
mot = mot.lower()
for x in t:
s += mot.count(x)
return s
print(voyelles('Alamo'))

3. Les t-‐uples.
Fin de ce chapitre

Structures séquentielles de données.
Récursivité. Paradigme « diviser pour régner ».

(1ADS-04) Structures Séquentielles de Données

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

(1ADS-04) Structures Séquentielles de Données

Transféré par

Droits d'auteur :

Formats disponibles

Structures séquentielles de données.

1ADS Algorithm in Python

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Objec&fs de ce module

• Introduire des structures de données dites

• Au sein d’une même en/té on va ainsi pouvoir

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Plan de ce module

1. Généralités sur les séquences en Python.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

1. GÉNÉRALITÉS SUR LES

© SUPINFO Interna/onal University – h8p://www.supinfo.com

Plan de ce chapitre

a. No/on de séquence.

a. No&on de séquence.

• L’objec/f étant d’op/miser certaines opéra/ons comme la

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. No&on de séquence.

•Chaque élément, à part le premier, a un prédécesseur et, à

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. No&on de séquence.

Indexation des éléments à

© SUPINFO Interna/onal University – h8p://www.supinfo.com

a. No&on de séquence.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

b. Les 3 principaux types de séquences.

2. Les t-­‐uples dont les éléments sont quelconques et non

3. Les chaînes de caractères dont les éléments sont des

© SUPINFO Interna/onal University – h8p://www.supinfo.com

b. Les 3 principaux types de séquences.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

b. Les 3 principaux types de séquences.

>>> maListe = [2, -3, ['xox', 69], 11]

© SUPINFO Interna/onal University – h8p://www.supinfo.com

b. Les 3 principaux types de séquences.

2 -­‐3 [‘xox’, 69] 11

b. Les 3 principaux types de séquences.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

b. Les 3 principaux types de séquences.

>>> monTuple = (2.718, 3.14, 1.414)

© SUPINFO Interna/onal University – h8p://www.supinfo.com

c. Opéra&ons communes aux séquences

© SUPINFO Interna/onal University – h8p://www.supinfo.com

c. Opéra&ons communes aux séquences

>>> t = (7, -3, 2, 11, 666, -1975)

c. Opéra&ons communes aux séquences

c. Opéra&ons communes aux séquences

>>> t = (7, -3, 2)

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

for i,x in enumerate(maSéquence):

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

© SUPINFO Interna/onal University – h8p://www.supinfo.com

d. Parcours d’une séquence avec “for”.

2. Les t-‐uples dont les éléments sont quelconques et non

2 -‐3 [‘xox’, 69] 11