|
Édition du: 08/03/2026 |
Faites un double-clic pour un retour en haut de page
|
PYTHON: Trucs et astuces Listes et ensembles Quelles sont
les principales choses à savoir ou à avoir sous la main lorsqu'on s'intéresse
aux listes et aux ensembles. Rappel: les listes et ensembles
peuvent être modifiées, un tuple non. |
||
|
|
Sommaire de cette page >>>
Listes >>>
Ensembles >>>
Listes et Ensembles >>>
Manipulations >>>
Tests >>>
Zip >>>
LISTE – Exemples |
Débutants Glossaire |
|
List L = [1, 5, 2, 5] |
Éléments non-ordonnés, accepte les doublons. Les
éléments sont placés dans l'ordre d'apparition par les traitements. Ajouter
un élément avec L.append(n). Possibilité
d'appel d'un élément par indexation : L[i]. |
|
|
Set S = {1, 5, 2} |
Éléments non-ordonnés, sans doublons. Les
éléments sont placés dans l'ordre d'apparition par les traitements. Ajouter
un élément avec S.add(n). Pas de
possibilité d'indexation. Il faut convertir en liste. En
revanche, test d'appartenance possible avec x in S |
|
|
sorted(L) => [1, 2, 5,
5] sorted(S) => [1, 2, 5] |
Tri, que la source soit une liste ou un ensemble. |
|
|
sorted(set(L)) [1, 2, 5] |
Tri et éléments par ordre croissant. |
|
Voir Exemples
en Divisibilité par 3 et somme 18
|
Liste Ajouter un élément |
Surtout pas L = A.append() |
|
|
|
Liste + Liste [ ] = liste { } = ensemble | avec Alt 6 |
|
|
|
|
Liste retournée |
|
|
|
|
Ensemble Ensemble: élément dans l'ordre et sans redondance. |
S = {1, 2, 3, 4} T = {1, 2, 2, 5, 4, 2} print(S) print(T) |
{1, 2, 3, 4} {1, 2, 4, 5} |
||||
|
Identification de nombres à chiffres tous différents |
def ND(n): L = [int(c) for c in str(n)] S = set(L) if len(L) == len(S): print(f"les chiffres de {n} sont distincts") else: print(f"les chiffres de {n} ne sont pas
distincts") n = 1234; ND(n) m = 122352 ; ND (m) |
|||||
|
les
chiffres de 1234 sont distincts les
chiffres de 122352 ne sont pas distincts |
||||||
|
Ensemble en liste |
S = {1, 2, 3, 4, 5} L = list(S) print(L) |
[1, 2, 3, 4, 5] |
||
|
Liste en ensemble |
L = [1, 2, 2, 3, 4, 4, 5] S = set(L) print(S) |
{1, 2, 3, 4, 5} |
||
|
Ordonné (ordre de la liste
initiale) ou trié (croissant) |
A = [10, 3, 2, 2, 6, 3] B = set(A) C = list(dict.fromkeys(A)) D = sorted(set(A)) print(A,B,C,D) |
A = [10, 3, 2, 2, 6, 3] B = {2, 10, 3, 6} supprime les
doublons C = [10, 3, 2, 6] idem en
conservant l'ordre D = [2, 3, 6, 10] ensemble
(unique et trié) |
||
|
Liste triée |
L = [1, 2, 2, 3, 4, 4, 5] S = sorted(L) print(S) |
[1, 2, 2, 3, 4, 4, 5] |
||
|
Aussi |
L = [5, 2, 9, 1, 7] L.sort() print(L) |
[1, 2, 5, 7, 9] |
||
|
Tri décroissant |
L = [5, 2, 9, 1, 7] L.sort(reverse=True) print(L) |
[9, 7, 5, 2, 1] |
||
|
Tri par clé |
L = ['Kevin', 'Bob', 'Jo', 'Louise'] LT = sorted(L, key=len) print(LT) |
['Jo', 'Bob', 'Kevin', 'Louise'] |
||
|
Ajouter des éléments à une liste |
M = [1, 2, 3] N = [4, 5] M.extend(N) print(M) |
[1, 2, 3, 4, 5] |
|
|
Plus simple |
M = [1, 2, 3] M += [4, 5] print(M) |
[1, 2, 3, 4, 5] |
|
|
Ajouter une sous-liste |
M = [[1, 2, 3], [2,3]] N = [4, 5] M.append(N) print(M) |
[[1, 2, 3], [2, 3], [4, 5]] |
|
|
Regrouper deux listes |
M = [1, 2, 3] N = [4, 5] P = M + N print(P) |
[1, 2, 3, 4, 5] |
|
|
Créer une liste avec une boucle de calcul |
L = [] for i in range(3): M = [i, i + 1, i + 2] L.append(M) print(L) |
[[0, 1, 2], [1, 2, 3], [2, 3, 4]] |
|
|
Accéder à un élément Note: commence par
0 |
A = [[1,2,3],[234],45] print(A[0]) print(A[2]) |
[1, 2, 3] 45 |
|
|
Test si une liste est présente dans une liste:
même valeur dans l'ordre |
L = [[1, 2], [3, 4], [5, 6]] T = [3, 4] if T in L: print("oui") else: print("non") |
oui |
|
|
Test d'appartenance d'une sous liste dans une liste dans l'ordre Note \ pour aller à la ligne (surtout
, rien derrière) |
def EstSL(M, N): m = len(M) n = len(N) return any(M[i:i+n] == N \ for i in range(m-n+1)) A = [5, 1, 2, 3, 4, 9] B = [2, 3, 4] C = [3, 2, 4] print(A) print(B, EstSL(A, B)) print(C, EstSL(A, C)) |
[5, 1, 2, 3, 4, 9] [2, 3, 4] True [3, 2, 4] False |
|
|
Test d'appartenance d'une sous liste dans une liste sans ordre |
L = [ [1, 2], [4, 3], [5, 6], [7, 8, 9] ] C = [3, 4] CE = set(C) present = any(set(sous_liste)\ == CE for sous_liste in L) if present: print("Oui") else: print("Non") |
Oui |
|
|
Associer deux listes Si les séquences n’ont
pas la même longueur, zip() s’arrête à la plus
courte. |
prenoms = ["Alice", "Bob", "Charlie"] ages = [25, 30, 22] for nom, age in zip(prenoms, ages): print(f"{nom} a {age} ans.") |
Alice a
25 ans. Bob a
30 ans. Charlie
a 22 ans |
|||
|
Création d'un dictionnaire à partir de deux listes |
clefs = ["nom", "âge", "ville"] valeurs = ["Nathan", 12, "Antibes"] d = dict(zip(clefs, valeurs)) print(d) |
{'nom': 'Nathan', 'âge': 12, 'ville': 'Antibes'} |
|||
|
Zipper une chaine de
caractères |
a = "abc" b = "123" print(list(zip(a, b))) |
[('a',
'1'), ('b', '2'), ('c', '3')] |
|||
|
Dezipper |
paires = [("x", 1), ("y", 2), ("z", 3)] lettres, chiffres = zip(*paires) print(lettres) # ('x', 'y', 'z') print(chiffres) # (1, 2, 3) |
('x',
'y', 'z') (1, 2,
3) |
|||
|
Zipper et lister |
noms = ["Marie", "Jean", "Luc"] notes = [18, 15, 19] for i, (nom, note) in enumerate(zip(noms, notes)): print(f"#{i+1} : {nom} → {note}/20") |
#1 :
Marie → 18/20 #2 :
Jean → 15/20 #3 :
Luc → 19/20 |
|||
|
# Liste L = ["A", "B", "C", "D"] print(L, "Longueur
:", len(L)) print("Qté de C :", L.count("C")) print("Index
de 'D' :", L.index("D")) print("'B'
est-il présent ?", "B" in L) |
['A',
'B', 'C', 'D'] Longueur : 4 Qté de
C : 1 Index
de 'D' : 3 'B'
est-il présent ? True |
|||||
|
L = ["A", "B", "C", "D"] # voir slicing et Tableau de possibilités print(L[:2])
# Prend tous les éléments
du début jusqu’à l’indice 2 exclus. print(L[2:]) # Prend tous les éléments
à partir de l’indice 2 jusqu’à la fin. print(L[::2] # Prend les éléments un
sur deux, en commençant par l’indice 0 |
['A',
'B'] ['C',
'D'] ['A',
'C'] |
|||||
|
# Indexation par position print("Premier
:", L[0])
print("Dernier
:", L[-1])
print("Sous-liste
:", L[1:3])
|
Premier
: A Dernier
: D Sous-liste
: ['B', 'C'] |
|||||
|
# Ajouter des éléments print(L + ["XYZ"]) L.append("X") L.insert(2, "Y") print("Ajouté", L) |
['A',
'B', 'C', 'D', 'XYZ'] Ajouté
['A', 'B', 'Y', 'C', 'D', 'X'] |
|||||
|
# Étendre avec une autre
liste Lbis = ["P", "Q"] L.extend(Lbis) print("Etendue :", L) |
Etendue :
['A', 'B', 'Y', 'C', 'D', 'X', 'P', 'Q'] |
|||||
|
# Concaténation avec + LM = L + ["Oui", "Non"] print("Concaténée
:", LM) |
Concaténée
: ['A', 'B', 'Y', 'C', 'D', 'X', 'P', 'Q', 'Oui', 'Non'] |
|||||
|
# Nettoyage L.remove("A") #un seul
élément print("Retrait
:", L) del L[2] print("Effacer
:",L) L.clear() print("Vidée
:",L) |
Retrait
: ['B', 'Y', 'C', 'D', 'X', 'P', 'Q'] Effacer
: ['B', 'Y', 'D', 'X', 'P', 'Q'] Vidée :
[] |
|||||
|
# Duplication L = [1, 5, 3] print("Nouvelle
liste",L) print("Répétée
:", L * 2) |
Nouvelle
liste [1, 5, 3] Répétée
: [1, 5, 3, 1, 5, 3] |
|||||
|
# Trier et inverser L.sort() print("Triée
:", L) L.reverse() print("Inversée
:", L) |
Triée :
[1, 3, 5] Inversée
: [5, 3, 1] |
|||||
|
# Création d'une chaîne mots = ["Bonjour", "Nathan", "comment", "ça", "va"] phrase = " ".join(mots) print(phrase) |
Bonjour
Nathan comment ça va |
|||||
|
# Statistiques (avec liste
de nombres) nombres = [4, 10, 15, 2, 7] print("Min
:", min(nombres)) print("Max
:", max(nombres)) print("Somme
:", sum(nombres)) |
Min : 2 Max :
15 Somme :
38 |
|||||
|
# Conversion chaine = "Python" print("Lettres
Python :", list(chaine)) |
Lettres Python:
['P', 'y', 't', 'h', 'o', 'n'] |
|||||
Diverses possibilités d'accéder aux éléments
d'une liste
Haut de page (ou double-clic)
|
Retour |
|
|
Suite |
|
|
Voir |
|
|
Sites |
|
|
Cette page |
