COURS INFO ESEO 1
COURS INFO ESEO 2
Notation d’une liste
[1,2,3,4] # énumération des objets entre []
[[1,2],[1],1] # liste dont les deux premiers termes sont des listes
[] # liste vide
Accès aux éléments d’une liste par indexation positive:
>>> li = [1,2,3]
>>> li[0]
1
>>> li[2]
3
>>> li[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
COURS INFO ESEO 3
IndexError: list index out of range
>>> li[-1]
3
>>> li[-3]
1
>>> li[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Opérations et méthodes applicables à une liste:
len(L) # longueur (nombre d’éléments) de L
L1 + L2 # concaténation des listes
n * L # pour n entier: concaténation répétée de L avec elle-même.
L.append(a) # ajout de l’objet a en fin de liste (m)
L.insert(i,a) # insertion de l’objet a en position i (m)
L.remove(a) # retrait de la première occurrence de a (m)
L.pop(i) # retrait et renvoi de l’élément d’indice i (m)
# par défaut, si i non précisé: dernier élément
L.index(a) # position de la première occurrence de a
# ValueError si a n’est par dans la liste
L.count(a) # nombre d’occurrences de a dans la liste
a in L # teste l’appartenance de a à L
L.copy() # copie simple de L
# attention aux problèmes de dépendance des attributs
L.reverse() # retourne la liste (inversion des indexations) (m)
L.sort() # trie la liste dans l’ordre croissant (m)
# (si composée d’objets comparables)
# voir ci-dessous pour des paramètres
Paramètres de tri:
li.sort() # tri simple
li.sort(reverse=True) # tri inversé
COURS INFO ESEO 4
li.sort(key = f) # tri suivant la clé donnée par la fonction f
≥ L[i:j] L[i],
L[i+1],..., L[j-1]
Technique de slicing:
L[i:j] # Extraction de la tranche [L[i], ... , L[j-1]]
L[i:j:p] # De même de p en p à partir de L[i], tant que i+k*p < j
>>> M = [0,1,2,3,4,5,6,7,8,9,10]
>>> M[3:6]
[3, 4, 5]
>>> M[2:8:2]
[2, 4, 6]
>>> M[:3]
[0, 1, 2]
>>> M[3::3]
[3, 6, 9]
>>> M[::5]
[0, 5, 10]
>>> M[:2:4]
[0]
>>> M[:5:4]
[0, 4]
>>> M[-3:-1]
[8, 9]
>>> M[2:6:-3]
[]
COURS INFO ESEO 5
>>> M[6:2:-3]
[6, 3]
COURS INFO ESEO 6
COURS INFO ESEO 7
COURS INFO ESEO 8
COURS INFO ESEO 9
depiler(P)
empiler(P,42)
sommet(P)
depiler(P) pile_vide(P)
depiler(P) taille(P)
depiler(P)
L.append(x)
x = L.pop()
L == [] len(L)==0
def pile_vide () :
return []
def est_vide ( L ) :
return ( len ( L ) ==0)
def empiler (L , x ) :
L . append ( x )
def depiler ( L ) :
return L . pop ()
COURS INFO ESEO 10
On prend souvent l'analogie de la file d'attente devant un magasin pour décrire une file de données.
COURS INFO ESEO 11
def file_vide () :
return []
def est_vide ( F ) :
return ( len ( F ) ==0)
def enfiler (F , x ) :
F . append ( x )
def defiler ( F ) :
return F . pop ( O ) # ça c’est terrible !!!
def creer_file():
return [],[] #couple de listes
def file_vide(F):
return F[0]==[] and F[1]==[]
def enfiler(F,x):
F[0].append(x)
def defiler(F):
assert not file_vide(F), "file vide"
if F[1]==[]:
F[1][:]=F[0][::-1] # contenu de la deuxième liste remplacé par celui
de la première, à l'envers.
F[0][:]=[] # première liste vidée.
COURS INFO ESEO 12
return F[1].pop()
def recherche_sequentielle(liste, valeur):
for i in range(len(liste)):
if liste[i] == valeur:
return i # Retourne l'indice de l'élément trouvé
return -1 # Si l'élément n'est pas trouvé
COURS INFO ESEO 13
liste = [3, 5, 8, 10]
valeur = 3
# Comparaison unique : liste[0] == 3
# Complexité : O(1)
liste = [3, 5, 8, 10]
valeur = 10
# Comparaison pour chaque élément : liste[0], liste[1], liste[2], puis
liste[3] == 10
# Complexité : O(n)
COURS INFO ESEO 14
liste = [3, 5, 8, 10]
valeur = 6
# Comparaison pour chaque élément : liste[0], liste[1], liste[2], liste[3]
# Élément absent, après n comparaisons.
# Complexité : O(n)
En résumé :
COURS INFO ESEO 15
VARIABLE
t : tableau d'entiers
i : nombre entier
min : nombre entier
j : nombre entier
DEBUT
i←1
tant que i<longueur(t): //boucle 1
j←i+1
min←i
tant que j<=longueur(t): //boucle 2
si t[j]<t[min]:
min←j
fin si
j←j+1
fin tant que
si min≠i :
échanger t[i] et t[min]
fin si
i←i+1
fin tant que
FIN
COURS INFO ESEO 16
COURS INFO ESEO 17
def tri_selection(liste):
n = len(liste)
for i in range(n):
# Trouver l'indice du plus petit élément dans la sous-liste [i:n]
indice_min = i
for j in range(i+1, n):
if liste[j] < liste[indice_min]:
indice_min = j
# Échanger l'élément à l'indice i avec l'élément à l'indice
indice_min
liste[i], liste[indice_min] = liste[indice_min], liste[i]
return liste
COURS INFO ESEO 18
(sorted()).
COURS INFO ESEO 19
COURS INFO ESEO 20
