|
Édition du: 12/08/2025 |
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 |
|
|
|
|
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} |
|
|
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 |
