DESCRIPTION.

Créer un objet séquence, ou collection, qui contient une liste de valeurs qui peuvent être de toutes natures d'objets valides. 

SYNTAXE.

LST_Designation = [ valeura , ... , valeurn ]

LST_Designation = ⇨ Nom de la variable [ optionnel ]

[ ] ⇨ création d'une instance de list ( ) [ OBLIGATOIRE ]

valeura , ... , valeurn ⇨ éléments de la liste [ optionnel ]

LST_Designation = list ( iterable )

LST_Designation = ⇨ Nom de la variable [ optionnel ]

list ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

iterable ⇨ objet itérable contenant les valeurs [ optionnel ]

REMARQUES.

valeur peut être n'importe quel objet valide de Python pouvant être comparé. 

iterable doit être un objet collection, ou séquence, tel que : range ( ), list ( ), tuple ( ), bytes ( ) ou bytearray ( ).

Python gère de nombreux types d'objets_variables. Certains sont des collections de valeurs regroupées au sein d'un même objet_variable. L'objet_variable de ce genre le plus souple est la liste (list ( )). On peut définir simplement une liste comme une suite de valeurs, par obligatoirement de types similaires, séparées par des virgules et comprises entre crochets. C'est bien la présence des crochets qui définissent un objet list ( ).

Les instances de list ( ) sont des objets itérables et mutables.

Bien qu'étant un raccourcit, la forme de création d'un objet list ( ) LST_Designation = [ valeur1 , valeurn ] est à privilégier.

Les variables globales de type list ( ) sont identifiées dans le site par : LST_. 

Voir les conventions sur les variables utilisées dans ce site ...

CRÉER UNE NOUVELLE LISTE.

LST_Joueurs = [ "pseudo" , "genre" , 3 , 1099 ].

Crée une list ( ) nommée LST_Joueurs. Elle contient 4 valeurs initialisées lors de la création.

print ( type ( LST_Joueurs ) ) retournera <class 'list'>.

Il est aussi possible de créer une nouvelle liste à partir d'objets itérables.

LST_Joueurs = list ( [ "pseudo" , "genre" , 3 , 1099 ] ) à partir d'une list ( ).

LST_Joueurs = list ( ( "pseudo" , "genre" , 3 , 1099 ) ) à partir d'un tuple ( ).

LST_Joueurs = list ( { "pseudo" , "genre" , 3 , 1099 } ) à partir d'un set ( ).

Ou en convertissant une instance d'un objet itérable en un objet list ( ).

LST_Liste = [ "pseudo" , "genre" , 3 , 1099 ] à partir d'une list ( ).

LST_Joueurs = list ( LST_Liste ) convertir une list ( ) en une autre list ( ).

TPL_Tuple = ( "pseudo" , "genre" , 3 , 1099 ) à partir d'un tuple ( ).

LST_Joueurs = list ( TPL_Tuple ) convertir un tuple ( ) en une list ( ).

ESB_Set = { "pseudo" , "genre" , 3 , 1099 } à partir d'un set ( ).

LST_Joueurs = list ( ESB_Set ) convertir un set ( ) en une list ( ).

Attention cependant avec un objet du type dict ( ) car seuls les clés sont retournées comme éléments.

DCT_Dict = {  "Pseudo" : "Aliénor12" , "Genre" : "Fée" , "Rang" : 3 , "Renommée" : 1099 } à partir d un dict ( ).

LST_Joueurs = list ( DCT_Dict ) convertir un dict ( ) en une list ( ).

print ( LST_Joueurs ) retourne ['Pseudo', 'Genre', 'Rang', 'Renommée'].

LST_NomDeLaVariable = [ ] créé une list ( ) vide.

LST_NomDeLaVariable = [ 'pseudo' , 'genre' , 3 , 1099 , [ "win" , "win" , "loos" , 29 ] ]

créé une list ( ) où l'un des éléments est une list ( ). En effet, comme dit plus haut, les éléments d'une list ( ) peuvent être de toutes natures (variables, constantes, listes, dictionnaires, ou tous autres objets).

LST_NomDeLaVariable = [ element ] * quantite 

crée une list ( ) de quantite éléments ayant tous pour valeur element. Si element peut être de n'importe quel type d'objet, valide dans Python, quantite doit être de type int ( ).

LST_A = [ "Salut" ] * 3 crée une list ( ) de 3 éléments valant tous Salut (alphanumérique).

LST_B = [ 25 ] * 5 crée une list ( ) de 5 éléments valant tous 25 (numérique).

LST_C = [ [ 25 , 'Salut' ] ] * 4 crée une list ( ) de 4 éléments valant tous [ 25, 'Salut' ] (list ( )).

Mais attention à la place des crochets pour créer des list ( ), parenthèses pour des tuple ( ) ou accolades pour dict ( ) comme éléments.

LST_Fruits = [ [ "Prune" , "Rouge" , 12 ] ] * 5

print ( LST_Fruits )

retourne [['Prune', 'Rouge', 12], ['Prune', 'Rouge', 12], ['Prune', 'Rouge', 12], ['Prune', 'Rouge', 12], ['Prune', 'Rouge', 12]]

alors que

LST_Fruits = [ "Prune" , "Rouge" , 12 ] * 5

print ( LST_Fruits )

retourne ['Prune', 'Rouge', 12, 'Prune', 'Rouge', 12, 'Prune', 'Rouge', 12, 'Prune', 'Rouge', 12, 'Prune', 'Rouge', 12]

Pour créer rapidement, une list ( ) dont les éléments forment une suite de nombres entiers on utilise la méthode range ( ).

LST_NomDeLaVariable = list ( range ( debut , fin , pas ) ) 

LST_Chiffres = list ( range ( 0 , 10 ) ) 

print ( LST_Chiffres ) retourne [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

print ( type ( LST_Chiffres ) ) retourne <class 'list'>

LST_Pairs = list ( range ( 10 , 30 , 2 ) ) 

print ( LST_Chiffres ) retourne [10, 12, 14, 16, 18, 20, 22, 24, 26, 2].

Voir la fonction range ( ) pour plus de détails sur la création de suite numériques ...

Il est possible de créer une list ( ) à partir des mots contenus dans une chaine de caractères, en utilisant la méthode .split ( ).

LST_NomDeLaVariable = "chaine de caractères".split ( )

LST_Mots = "Création d'une nouvelle liste".split ( )

print ( LST_Mots )

retourne ['Création', "d'une", 'nouvelle', 'liste']

Voir la fonction str ( ) pour plus de détails sur les chaines de caractères ...

Vous avez aussi la possibilité de créer directement un objet list ( ) en récupérant tous les enregistrements (lignes) réalisés dans un fichier texte (.txt)en utilisant list ( fichier ), où fichier est un nom de fichier (avec un chemin relatif ou absolu) valide. 

Voir la fonction open ( ) pour plus de détails sur la gestion des fichiers textes ...

COMPRÉHENSION DE LISTE.

On peut aussi utiliser la technique dite "compréhension des listes" pour initialiser des list ( ) avec certaines spécificités.

Une list ( ) simple de nombres qui se suivent.

LST_Chiffres = [ chiffre for chiffre in range ( 10 ) ]

print ( LST_Chiffres ) retourne [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

équivaut à LST_Chiffres = list ( range ( 10 )

Une list ( ) simple de nombres se suivent avec un écart.

LST_Chiffres = [ chiffre for chiffre in range ( 17 , 48 , 6 ) ]

print ( LST_Chiffres ) retourne [17, 23, 29, 35, 41, 47]

équivaut à LST_Chiffres = list ( range ( 17 , 48 , 6 )

Une list ( ) simple d'éléments après une opérations quelconque.

LST_Cubes = [ ( element ** 3 ) for element in range ( 10 ) ]

print ( LST_Cubes ) retourne [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

Une list ( ) complexes, avec des tuples ( ), de 2 nombres.

LST_Coordonnees = [ ( x , y ) for x in range ( 5 ) for y in range ( 3 ) ]

print ( LST_Coordonnees )

retourne [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2)]

Pour l'exemple des possibilités, une list ( ) complexes, avec des tuples ( ), et des opérations quelconques.

LST_Suites = [ ( ( x*x ) , ( x*y ) , ( x*u ) , ( u+v ) ) for x in range ( 5 ) for y in range ( 3 ) for u in range ( 4 ) for v in range ( 2 ) ]

print ( LST_Suites )

retourne 

[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 0, 3), (0, 0, 0, 4), (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 0, 3), (0, 0, 0, 4), (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 0, 3), (0, 0, 0, 4), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 1), (1, 0, 1, 2), (1, 0, 2, 2), (1, 0, 2, 3), (1, 0, 3, 3), (1, 0, 3, 4), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 1), (1, 1, 1, 2), (1, 1, 2, 2), (1, 1, 2, 3), (1, 1, 3, 3), (1, 1, 3, 4), (1, 2, 0, 0), (1, 2, 0, 1), (1, 2, 1, 1), (1, 2, 1, 2), (1, 2, 2, 2), (1, 2, 2, 3), (1, 2, 3, 3), (1, 2, 3, 4), (4, 0, 0, 0), (4, 0, 0, 1), (4, 0, 2, 1), (4, 0, 2, 2), (4, 0, 4, 2), (4, 0, 4, 3), (4, 0, 6, 3), (4, 0, 6, 4), (4, 2, 0, 0), (4, 2, 0, 1), (4, 2, 2, 1), (4, 2, 2, 2), (4, 2, 4, 2), (4, 2, 4, 3), (4, 2, 6, 3), (4, 2, 6, 4), (4, 4, 0, 0), (4, 4, 0, 1), (4, 4, 2, 1), (4, 4, 2, 2), (4, 4, 4, 2), (4, 4, 4, 3), (4, 4, 6, 3), (4, 4, 6, 4), (9, 0, 0, 0), (9, 0, 0, 1), (9, 0, 3, 1), (9, 0, 3, 2), (9, 0, 6, 2), (9, 0, 6, 3), (9, 0, 9, 3), (9, 0, 9, 4), (9, 3, 0, 0), (9, 3, 0, 1), (9, 3, 3, 1), (9, 3, 3, 2), (9, 3, 6, 2), (9, 3, 6, 3), (9, 3, 9, 3), (9, 3, 9, 4), (9, 6, 0, 0), (9, 6, 0, 1), (9, 6, 3, 1), (9, 6, 3, 2), (9, 6, 6, 2), (9, 6, 6, 3), (9, 6, 9, 3), (9, 6, 9, 4), (16, 0, 0, 0), (16, 0, 0, 1), (16, 0, 4, 1), (16, 0, 4, 2), (16, 0, 8, 2), (16, 0, 8, 3), (16, 0, 12, 3), (16, 0, 12, 4), (16, 4, 0, 0), (16, 4, 0, 1), (16, 4, 4, 1), (16, 4, 4, 2), (16, 4, 8, 2), (16, 4, 8, 3), (16, 4, 12, 3), (16, 4, 12, 4), (16, 8, 0, 0), (16, 8, 0, 1), (16, 8, 4, 1), (16, 8, 4, 2), (16, 8, 8, 2), (16, 8, 8, 3), (16, 8, 12, 3), (16, 8, 12, 4)]

Attention cependant à garder une certaine lisibilité, pour une future évolution de votre script.

La création de list ( ) par compréhension permet aussi de tester si des valeurs sont acceptables ou non.

LST_Test = [ candidat for candidat in range ( 0 , 100 ) if candidat % 6 == 0 ]

print ( LST_Test ) retourne [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

On a créé une liste contenant tous les nombres de 0 et 99 ( candidat for candidat in range ( 0 , 100 ) ) et divisible par 6 ( if candidat % 6 == 0 ).

LST_Dizaine = [ k for k in LST_Test if k > 0 and k % 10 == 0 ]

print ( LST_Dizaine ) retourne [30, 60, 90]

Crée une list ( ) contenant tous les éléments de la liste LST_Test qui sont supérieurs à 0 et divisibles par 10.

Filtrer un objet collection.

LST_Mots = [ "Bon" , "jour" , "et" , "bien" , "venue" , "dent" , "mont" , "pie" , "thon" , "HA" , "mois" ]

LST_SansE = [ mot for mot in LST_Mots if not ( "e" in mot ) ]

print ( LST_SansE ) retourne ['Bon', 'jour', 'mont', 'thon', 'HA', 'mois']

Convertir un autre objet - collection en une list ( ).

Introduction = "BONJOUR et BIENVENUE dans mon PYTHON !"

LST_Lettres = [ lettre.lower ( ) for lettre in Introduction ]

print ( LST_Lettres ) retourne ['b', 'o', 'n', 'j', 'o', 'u', 'r', ' ', 'e', 't', ' ', 'b', 'i', 'e', 'n', 'v', 'e', 'n', 'u', 'e', ' ', 'd', 'a', 'n', 's', ' ', 'm', 'o', 'n', ' ', 'p', 'y', 't', 'h', 'o', 'n', ' ', '!']

Convertir et travailler avec des autres objets-collections

DCT_Jours = { "Lundi" : 21 , "Mardi" : 22 , "Mercredi" : 23 , "Jeudi" : 24 , "Vendredi" : 25 , "Samedi" : 26 , "Dimanch" : 27  } 

LST_Semaine = [ ( cle , valeur ) for cle , valeur in DCT_Jours.items ( ) ]

print ( LST_Semaine ) retourne [('Lundi', 21), ('Mardi', 22), ('Mercredi', 23), ('Jeudi', 24), ('Vendredi', 25), ('Samedi', 26), ('Dimanch', 27)] 

LST_Semaine_Prec = [ ( cle , ( valeur - 7 ) ) for cle , valeur in DCT_Jours.items ( ) ]

print ( LST_Semaine ) retourne [('Lundi', 14), ('Mardi', 15), ('Mercredi', 16), ('Jeudi', 17), ('Vendredi', 18), ('Samedi', 19), ('Dimanch', 20)]

Une compréhension de liste, peut être passée comme argument, à une fonction qui attends une liste.

Cryptage = "1524bon4j5ou85r7et5521bi542en2114ve3n21ue35"

Decrytage = "".join ( [ lettre for lettre in Cryptage if not ( lettre.isdigit ( ) ) ] )

print ( Decrytage ) retourne bonjouretbienvenue

Créer une list ( ) grâce à une compréhension de liste et une saisie de l'utilisateur.

LST_Mots = [ ( mot , len ( mot ) ) for mot in input ( "votre texte à coder ?" ).split ( ) ]

print ( LST_Mots )

retourne 

votre texte à coder ? Nombre de lettre des mots dans cette phrase

[('Nombre', 6), ('de', 2), ('lettre', 6), ('des', 3), ('mots', 4), ('dans', 4), ('cette', 5), ('phrase', 6)]

LST_Lettres = [ ord ( lettre ) for lettre in list ( input ( "votre texte à coder ?" ) ) ]

print ( LST_Lettres )

retourne 

votre texte à coder ? Code des lettres de cette phrase

[32, 67, 111, 100, 101, 32, 100, 101, 115, 32, 108, 101, 116, 116, 114, 101, 115, 32, 100, 101, 32, 99, 101, 116, 116, 101, 32, 112, 104, 114, 97, 115, 101]

LST_Carres = [ i * i for i in range ( int ( input ( "Tous les carrés jusque ?" ) ) + 1 ) ]

print ( LST_Carres )

retourne 

Tous les carrés jusque ?7

[0, 1, 4, 9, 16, 25, 36, 49]

LECTURE D'UNE LISTE.

On appel un élément d'une list ( ) un item, ou élément. Pour afficher la valeur d'un item il suffit d'indiquer son index (sa place / son indice) dans la list ( ). Rappel : le premier item a pour index 0 (zéro).

Pour la list ( ) LST_Joueurs = [ "pseudo" , "genre" , 3 , 1099 ], 

print ( LST_Joueurs [ 0 ] ) retourne pseudo

la valeur de premier élément de la list ( ) LST_Joueurs est pseudo. De même :

print ( LST_Joueurs [ 1 ] ) retourne genre ; et

print ( LST_Joueurs [ 2 ] ) retourne 3 ; enfin

print ( LST_Joueurs [ 3 ] ) retourne 1099 ; mais

print  (LST_Joueurs [ 4 ] ) retourne IndexError: list index out of range (indice en dehors des limites).

Connaitre le type d'un item particulier. Par exemple : 

print ( type ( LST_Joueurs [ 0 ] ) ) retournera  <class 'str'> et 

print ( type ( LST_Joueurs [ 2 ] ) ) retournera <class 'int'>

Demander une plage (plusieurs) d'index.

print ( LST_Joueurs [ 1 : 3 ] ) retourne ['genre', 3]

de l'index 1 jusqu'à l'index 2 (index 3 exclu).

print ( LST_Joueurs [ 2 : ] ) retourne [3, 1099]

de l'index 2 jusqu'à la fin.

print ( LST_Joueurs [ : 3 ] ) retourne ['pseudo', 'genre', 3]

de l'index 0 jusqu'à l'index 2 (index 3 exclu).

print ( LST_Joueurs [ : ] ) retourne ['pseudo', 'genre', 3, 1099]

tous les index (liste complète).

print ( LST_Joueurs [ -2 ] ) retourne 3

l'index 2 en partant de la fin de la liste.

print ( LST_Joueurs [ -2 : ] ) retourne [3, 1099]

les 2 derniers items de la liste.

print ( LST_Joueurs [ : -2 ] ) retourne ['pseudo', 'genre']

tous les items sans les 2 derniers de la liste.

Si l'un des éléments de la list ( ) est une list ( ), on accédera à la valeur d'un item en indiquant son index dans une seconde paire de crochets.

LST_Joueurs = [ 'pseudo' , 'genre' , 3 , 1099 , [ "win" , "win" , "loos" , 29 ] ]

LST_Joueurs [ 4 ] [ 2 ] retourne 'loss'

le troisième éléments de la liste interne, qui est le cinquième élément de LST_Joueurs.

On peut aussi demander les éléments sur plage (plusieurs) d'index mais avec un pas entre les index.

LST_Lettres = [ "a" , "b" , "c" , "d" ,"e" , "f" , "g" , "h" , "i" , "j" , "k" , "l" ,"m" , "n" , "o" , "p" , "q" , "r" , "s" , "t" , "u" , "v" , "w" , "x" , "y" , "z" ]

print ( LST_Lettres [ 4 : 19 : 3 ] ) retourne ['e', 'h', 'k', 'n', 'q']

de l'index 4 jusqu'à l'index 18, tous les 3 index.

print ( LST_Lettres [ : 10 : 2 ] ) retourne ['a', 'c', 'e', 'g', 'i']

du début jusqu'à l'index 10, un index sur deux.

print ( LST_Lettres [ 14 : : 2 ] ) retourne ['o', 'q', 's', 'u', 'w', 'y']

de l'index 14 jusqu'à la fin, un index sur deux.

print ( LST_Lettres [ : : 2 ] ) retourne ['a', 'e', 'i', 'm', 'q', 'u', 'y']

du début à la fin, tous les 4 index.

retourner la list ( ) inversé en précisant un pas négatif.

print ( LST_Lettres [ : : -1 ] ) retourne ['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a'] 

Mais il faut que les premiers arguments soit inversés.

print ( LST_Lettres [ 4 : 19 : -3 ] ) retourne []

une liste vide, mais

print ( LST_Lettres [ 19 : 4 : -3 ] ) retourne ['t', 'q', 'n', 'k', 'h']

de l'index 19 jusqu'à l'index 5, tous les 3 index, et 

print ( LST_Lettres [ -7 : -21 : -3 ] ) retourne ['t', 'q', 'n', 'k', 'h']

donne le même résultat, alors que

print ( LST_Lettres [ -7 : -21 : 3 ] ) retourne []

une liste vide.

Pour connaitre le nombre d'item(s) d'une list ( ), on utilisera la méthode len ( ).

LST_Couleurs = [ "noir" , "vert" , "bleu" , "blanc" , "rouge" ]

print ( len ( LST_Couleurs ) ) retourne 5

Pour connaitre l'index d'un item particulier d'une list ( ), on utilisera la méthode index ( ).

print ( LST_Couleurs.index ( "bleu" ) ) retourne 2

Si la list ( ) contient plusieurs éléments avec la valeur demandée, c'est l'index du premier élément qui sera retourné.

Si aucun élément de la list ( ) n'a la valeur demandée, une erreur est levée.

print ( LST_Couleurs.index ( "orange" ) ) retourne ValueError: 'orange' is not in list

Pour trier les éléments d'une list ( ) on utilise la méthode .sort ( ).

print ( LST_Couleurs.sort ( ) ) retourne [ 'blanc', 'bleu', 'noir', 'rouge', 'vert' ]

Avec la méthode .sort ( ) c'est la list ( ) elle-même qui est modifiée.

Par défaut, la méthode .sort ( ) tri les éléments par ordre croissant. pour obtenir un tri par ordre décroissant, on utilise l'attribut reverse = True.

LST_Couleurs = [ "noir" , "vert" , "bleu" , "blanc" , "rouge" ]

LST_Couleurs.sort ( reverse = True ) 

print ( LST_Couleurs ) retourne [ 'vert', 'rouge', 'noir', 'bleu', 'blanc' ]

Pour avoir une nouvelle list ( ), avec les éléments, d'une autre triés, triés on utilise la méthode sorted ( ).

LST_Couleurs = [ "noir" , "vert" , "bleu" , "blanc" , "rouge" ]

print ( LST_Couleurs ) retourne [ 'noir', 'vert', 'bleu', 'blanc', 'rouge' ]

LST_Teintes = sorted ( LST_Couleurs )

print ( LST_Couleurs ) retourne [ 'noir', 'vert', 'bleu', 'blanc', 'rouge'  ]

La liste LST_Couleurs est inchangée.

print ( LST_Teintes ) retourne [ 'blanc', 'bleu', 'noir', 'rouge', 'vert' ]

La liste LST_Teintes contient tous les éléments triés de la list ( ) LST_Couleurs. 

LST_Couleurs.sort ( )

print ( LST_Couleurs ) retourne [ 'blanc', 'bleu', 'noir', 'rouge', 'vert' ]

L'ordre des éléments de la list ( ) LST_Couleurs est modifié.

Pour savoir si une certaine valeur est présent dans la list ( ) on utilise le mot clé in.

LST_Couleurs = [ "noir" , "vert" , "bleu" , "blanc" , "rouge"  ]

print ( "bleu" in LST_Couleurs ) retourne True

car bleu est l'une des valeurs de la list ( ) LST_Couleur .

print ( "orange" in LST_Couleurs ) retourne False

car Orange n'est pas une valeur de la list ( ) LST_Couleur .

Pour savoir combien d'items ont une valeur recherchée, on utilise la fonction .count ( ).

LST_Fleuve = [ "m" , "i" , "s" , "s" , "i" , "s" , "s" , "i" , "p" , "p" , "i" ]

print ( LST_Fleuve.count ( 'i' ) ) retourne 4

print ( LST_Fleuve.count ( 's' ) ) retourne 4

print ( LST_Fleuve.count ( 'p' ) ) retourne 2

print ( LST_Fleuve.count ( 'm' ) ) retourne 1

Un objet list ( ) est itérable, il peut donc être utilisé avec l'instruction for. Par exemple pour obtenir tous les éléments d'une list ( ), vous pouvez utiliser une boucle for.

LST_Jours = [ ?lundi" , "mardi" , "mercredi" , "jeudi" , "vendredi" , "samedi" , "dimanche" ]

for kjour in LST_Jours :

print ( kjour ) 

retourne.

lundi

mardi

mercredi

jeudi

vendredi

samedi

dimanche

La méthode enumerate ( ) permet d'associer, dans une boucle for, l'index et la valeur de chaque items dans des tuple ( ).

for kjour in enumerate ( LST_Jours ) :

print ( kjour ) 

retourne

(0, 'lundi')

(1, 'mardi')

(2, 'mercredi')

(3, 'jeudi')

(4, 'vendredi')

(5, 'samedi')

(6, 'dimanche')

Il possible de référencer chaque index avec un nom de variable pour un traitement plus lisible.

LST_Geographie = [ "USA" , "Amérique du Nord" , "Washington" , 9_853_517 , 327_170_000 ]

print ( LST_Geographie  ) retourne ['USA', 'Amérique du Nord', 'Washington', 9853517, 327170000]

[ Pays , Continent , Capitale , Superficie , Population ] = LST_Geographie

print ( Pays ) retourne 'USA'

print ( f"{ Superficie } Km²" ) retourne 9853517 Km².

Attention cependant, car la réaffectation de la valeur d'une des variable ne modifie pas la list ( ) initiale.

Pays = "Suisse"

print ( Pays ) retourne 'Suisse'.

print ( LST_Geographie  ) retourne ['USA', 'Amérique du Nord', 'Washington', 9853517, 327170000]

MODIFIER UNE LISTE.

Pour modifier la valeur d'un item, on indique l'index de l'élément à réaffecter suivi de sa nouvelle valeur.

LST_Joueurs = [ "pseudo" , "genre" , 3 , 1099 ]

print ( LST_Joueurs [ 3 ] ) retourne 1099

LST_Joueurs [ 3 ] = 1450

print ( LST_Joueurs [ 3 ] ) retourne1450

Il est aussi possible de modifier plusieurs item en indiquant une plage d'index. Dans ce cas, le nombre d'éléments de la list ( ) peut changer lui aussi.

LST_Points = [ 4 , 1 , 3 , 2 , 0 , 6 , 5 ]

print ( LST_Points ) retourne [ 4, 1, 3, 2, 0, 6, 5 ]

LST_Points [ 3 : 5 ] = [ 7 , 9 ]

print ( LST_Points ) retourne [ 4, 1, 3, 7, 9, 6, 5 ]

les items 3 et 4 ont changés.

LST_Points [ 3 : 5 ] = [ ]

print ( LST_Points ) retourne [ 4, 1, 3, 6, 5 ]

les valeurs 7 et 9, ont disparut et la list ( ) n'a plus que 5 éléments.

LST_Points [ : ] = [ 2 , 0 , 4 , 7 , 8 , 1 , 4 , 6 , 9 ]

print ( LST_Points ) retourne [ 2 , 0 , 4 , 7 , 8 , 1 , 4 , 6 , 9 ]

toutes toutes les valeurs ont été supprimé, puis les nouvelles valeurs ont été ajouté.

LST_Points [ : ] = [ ]

print ( LST_Points ) retourne [ ]

toutes les valeurs ont disparu et la list ( ) n'a plus d'élément. Cette syntaxe permet de vider une liste.

Pour effacer tous les  éléments d'une list ( ), on utilise la méthode .clear ( ).

LST_Villes = [ "Paris" , "Bruxelles" , "Bern" , "Londres" , "Rome"  ]

print ( LST_Villes ) retourne [ 'Paris', 'Bruxelles', 'Bern', 'Londres', 'Rome ]

LST_Villes.clear ( ) 

print ( LST_Villes ) retourne [  ]

toutes les valeurs ont disparut et la list ( ) n'a plus d'élément.

On peut aussi utiliser LST_Villes [ : ] = [ ] comme vu plus haut.

Pour ajouter un élément dans une list ( ), on utilise la méthode .insert ( index , valeur ).

LST_Villes = [ "Paris" , "Bruxelles" , "Bern" , "Londres" , "Rome"  ]

print ( LST_Villes ) retourne [ 'Paris', 'Bruxelles', 'Bern', 'Londres', 'Rome ]

LST_Villes.insert ( 3 , "Lisbonne" ) 

print ( LST_Villes ) retourne [ 'Paris', 'Bruxelles', 'Bern', 'Lisbonne', 'Londres', 'Rome' ]

'Lisbonne' à été inséré (ajouté) à l'index 3.

Cependant, on remarque que LST_Villes.insert ( 3 , "Lisbonne" )

équivaut à LST_Villes [ 3 : 3 ] = [ "Lisbonne" ].

Pour ajouter un élément à la fin d'une list ( ), on utilise la méthode .append ( valeur ).

LST_Carres = [ 1 , 4 , 9 , 16 , 25 ]

print ( LST_Carres ) retourne [ 1, 4, 9, 16, 25 ]

LST_Carres.append ( 36 )

LST_Carres.append ( 49 )

print ( LST_Carres ) retourne [ 1, 4, 9, 16, 25, 36, 49 ]

la list ( ) comprends 2 items de plus, les valeurs sont ajoutées dans l'ordre des ajouts.

Pour ajouter plusieurs éléments à la fin d'une list ( ), on utilise la méthode .extend ( liste ).

LST_Cubes = [ 1 , 8 , 27 , 64 ]

print ( LST_Cubes ) retourne [ 1, 8, 27, 64 ]

LST_Cubes.extend ( [ 125 , 216 , 343 ] )

print ( LST_Cubes ) retourne [ 1, 8, 27, 64, 125, 216, 343 ]

la list ( ) comprends 3 items de plus, les valeurs sont ajoutées dans l'ordre des ajouts.

Attention de bien passer une list ( ) ([ ]) en argument avec la méthode .extend ( ). 

Ont aussi utiliser, plus simplement, l'opérateur + (addition) pour ajouter des éléments à la fin, ou au début d'une list ( ).

LST_Carres = [ 1 , 4 , 9 , 16 , 25 , 36 , 49 ]

LST_Carres = LST_Carres + [ 64 , 81 , 100 ]

print ( LST_Carres ) retourne [ 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 ]

a ajouté des éléments à la fin.

LST_Carres = [ 0 ] + LST_Carres

print ( LST_Carres ) retourne [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 ]

a ajouté un élément au début.

De même l'opérateur + (addition) peu concaténer (fusionner) plusieurs list ( ) entre elles, dans l'une d'elles ou dans une nouvelle list ( ).

LST_Fruits = [ "pomme" , "banane" , "fraise" ]

LST_Premiers = [ 1 , 2 , 3 , 5 , 7 , 9 ]

LST_PremiersSuite = [ 11 , 13 , 17 , 19 ]

LST_Légumes = [ "salade" , "carotte" ]

LST_Végétaux = LST_Légumes  +  LST_Fruits

LST_Premiers = LST_Premiers  +  LST_PremierSuite  + [ 23 , 29 ]

print ( LST_Végétaux ) retourne [ 'salade', 'carotte', 'pomme', 'banane', 'fraise' ]

print ( LST_Premiers ) retourne [ 1, 2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 29 ]

La réaffectation d'une valeur par son index et les méthodes .append ( ) et .extend ( ) modifient la list ( ) elle-même, alors que l'opérateur + créé une nouvel liste, avec le même nom où un nom différent.

Pour inverser l'ordre des éléments d'une list ( ), on utilise la méthode .reverse ( ).

LST_Carres = [ 1 , 4 , 9 , 16 , 25 , 36 , 49 ]

LST_Carres.reverse ( )

print ( LST_Carres ) retourne [ 49, 36, 25, 16, 9, 4, 1 ].

Pour supprimer un item ayant une certaine valeur, on utilise la méthode .remove ( ).

LST_Carres = [ 1 , 4 , 9 , 16 , 25 , 36 , 49 ]

LST_Carres.remove ( 16 )

print ( LST_Carres ) retourne [ 49, 36, 25, 9, 4, 1 ]

la valeur 16 a été effacée, la list ( ) comprend un élément de moins.

Si plusieurs éléments de la list ( ) ont la valeur recherchée, seule l'item ayant le plus petit index est supprimé.

Pour supprimer un item précis, ont utilise la méthode del.

LST_Suite = [ 1 , 2 , 3 , 4 , 5 ]

print ( LST_Suite ) retourne [ 1, 2, 3, 4, 5 ]

del LST_Suite [ 2 ] suppression de l'item ayant l'index 2 (élément 3 de la list ( )).

print ( LST_Suite ) retourne [ 1, 2, 4, 5 ]

la valeur 3 a disparut de la list ( ).

del LST_Suite [ 1 : 3 ] suppression des l'items ayant l'index 1 et 2.

print ( LST_Suite ) retourne [ 1, 5 ]

les valeurs 2 et 4 ont disparut.

Pour supprimer un seul item précis, et connaitre la valeur de cette item ont utilise la méthode .pop ( ).

LST_Prenoms = [ "Jean" , "Marie" , "Yann" , "François" , "Michelle" , "José" , "Emmanuelle" ]

print ( LST_Prenoms ) retourne [ 'Jean', 'Marie', 'Yann', 'François', 'Michelle', 'José', 'Emmanuelle' ]

Absent = LST_Prenoms.pop ( 4 )

print ( LST_Prenoms ) retourne [ 'Jean', 'Marie', 'Yann', 'François',  'José', 'Emmanuelle' ]

Michelle n'est plus dans la list ( )

print ( Absent ) retourne Michelle

c'est à dire la valeur de l'élément supprimé de la list ( ).

Si la méthode .pop ( ) est utilisée sans attribut, c'est le dernier élément de la list ( ) qui est supprimé et sa valeur retourné. 

Absent = LST_Prenoms.pop ( )

print ( LST_Prenoms ) retourne [ 'Jean', 'Marie', 'Yann', 'François',  'José' ]

Emmanuelle n'est plus dans la list ( ).

print ( Absent ) retourne Emmanuelle

c'est à dire la valeur de l'élément (le dernier de la list ( )) supprimé de la list ( ).

MODIFICATIONS AVANCÉES D'UNE LISTE.

Il existe d'autres techniques, plus avancées mais à l'utilisation plus délicates, pour modifier une list ( ). C'est le slicing (tranches). La syntaxe de cette technique à la forme générale suivante : Liste [ début : fin ] = [ valeur1 , ... , valeurn ].

Cette technique permet d'ajouter et de supprimer des valeurs par tranches dans des list ( ) à des emplacements bien précis.

LST_Lettres = [ "a" , "b" , "d" , "g" , "h" ]

LST_Lettres [ 2 : 2 ] = [ "c" ]

print ( LST_Lettres ) retourne ['a', 'b', 'c', 'd', 'g', 'h']

la valeur c a été ajoutée à l'index 2.

LST_Lettres [ 4 : 4 ] = [ 'e' , 'f' ] 

print ( LST_Lettres ) retourne ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

les valeurs e et f ont été ajouté et inséré à partir de l'index 4. Notez que l'ont indique le même index de début et de fin pour insérer une ou plusieurs valeurs.

LST_Lettres [ 2 : 5 ] = [ ] 

print ( LST_Lettres ) retourne ['a', 'b', 'f', 'g', 'h']

les valeurs c, d, e ont été supprimées car ont a rentrer une chaîne vide ([ ]) à leur index.

LST_Lettres [ 1 : 4 ] = [ 'x' ] 

print ( LST_Lettres ) retourne ['a', 'x','h']

les valeurs b, f, g ont été supprimées et la valeur x a été ajoute à l'index 1.

Notez qu'entre les crochets à gauche du symbole =, il faut toujours indiquer une plage d'index [ début : fin ], alors qu'à sa droite il faut toujours entrer une list ( ) de valeurs [ valeur1 , ... , valeurn ] ou [ ].

REMARQUES.

Si un item est créé en utilisant une variable, c'est la valeur affectée à cette variable à l'instant de la création qui est "mémorisée", l'item pointe vers la valeur et pas sur la variable elle-même. Si la valeur de la variable est modifiée, la valeur de l'item ne change pas.

Nombre = 123

Mot = "abc"

LST_Union = [ Nombre , Mot , [ Nombre , Mot ] , ( Nombre , Mot ) ]

print ( Nombre , Mot , LST_Union ) retourne 123 abc [123, 'abc', [123, 'abc'], (123, 'abc')]

Nombre = 987

Mot = "zyx"

print ( Nombre , Mot , LST_Union ) retourne 987 zyx [123, 'abc', [123, 'abc'], (123, 'abc')]

Les valeurs des variables Nombre et Mot ont bien été modifiées, mais les valeurs des items de LST_Union sont restées inchangées.

Pour copier une list ( ), on doit utiliser la syntaxe suivante : LST_New = LST_Old [ : ] pour que les 2 list ( ) soient indépendantes l'une de l'autre. En effet, la syntaxe LST_New = LST_Old est erronée car elle ne fait que créer une nouvelle instance (référence) pour l'ancienne list ( ).

LST_Lettres = [ "a" , "b" , "d" , "g" , "h" ]

LST_Consonnes = LST_Lettres

LST_Voyelles = LST_Lettres [ : ]

LST_Consonnes [ 0 ] = 'j'

print ( LST_Lettres ) retourne ['j', 'b', 'd', 'g', 'h', 'k']

Les modifications apportées à LST_Consonnes concernent aussi LST_Lettres.

LST_Lettres.append ( "k" )

print ( LST_Consonnes ) retourne ['j', 'b', 'd', 'g', 'h', 'k']

Les modifications apportées à LST_Lettres concernent aussi LST_Consonnes.

LST_Voyelles [ 1 : 4 ] = [ "e" , "i" , "o" , "u' ]

print ( LST_Voyelles ) retourne ['a', 'e', 'i', 'o', 'u', 'h']

print ( LST_Consonnes ) retourne ['j', 'b', 'd', 'g', 'h', 'k']

Seules les valeurs des index des items précisés sont modifié dans LST_Voyelles.

Conclusion : LST_Lettres et LST_Consonnes sont deux noms d'une même list ( ) alors que LST_Voyelles est une list ( ) différente. Lors de sa création LST_Voyelles a reçu les items de LST_Lettres, mais il s'agit bien d'une création.

Convertir une list ( ) de mots en un str ( ) avec la fonction intégrée .join ( ).

LST_Mots  = [ "La" , "douceur" , "du" , "miel" , "ne" , "console" , "pas" , "de" , "la" , "piqûre'" , "de" , "l'abeille." ]

Dicton = " ".join ( LST_Mots )

print ( Dicton ) retourne La douceur du miel ne console pas de la piqûre de l'abeille.

print ( type ( Dicton ) ) retourne <class 'str'>

On peut définir un séparateur différent de "espace", en précisant le caractère souhaité devant .join ( ).

Dicton = "-".join ( LST_Mots )

print ( Dicton ) retourne La-douceur-du-miel-ne-console-pas-de-la-piqûre-de-l'abeille.

Dicton = "*".join ( LST_Mots )

print ( Dicton ) retourne La*douceur*du*miel*ne*console*pas*de*la*piqûre*de*l'abeille.

De même on pourra splitter une chaîne en list ( ), en précisant le séparateur de termes dans la méthode .split ( ).

Dicton = "La*douceur*du*miel*ne*console*pas*de*la*piqûre*de*l'abeille."

LST_Termes = Dicton.split ( "*" )

print ( LST_Termes ) retourne ['La', 'douceur', 'du', 'miel', 'ne', 'console', 'pas', 'de', 'la', 'piqûre', 'de', 'l'abeille.']

L'utilisation, en association, de ces 2 méthodes sera particulièrement utile lors de l'écriture / relecture de fichiers textes, sur un disque durs.

Il est possible d'isoler certains des élément d'une list ( ) grâce à la technique "extended unpacking". Notez la position du symbole * pour déterminer quels éléments ne seront pas isolés.

LST_Jours = [ "Lundi" , "Mardi" , "Mercredi" , "Jeudi" , "Vendredi" , "Samedi" , "Dimanche" ]

*Ouvert , Ferme = LST_Jours

print ( Ouvert ) retourne ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi']

print ( Ferme ) retourne 'Dimanche'

print ( type ( Ouvert ) ) retourne <class 'list'>

print ( type ( Ferme ) ) retourne <class 'str'>

De même :

Premier , *Autres = LST_Jours

print ( Premier ) retourne 'Lundi'

print ( Autres ) retourne ['Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']

Et aussi :

Premier , *Autres , Dernier = LST_Jours

print ( Premier ) retourne 'Lundi'

print ( Autres ) retourne  ['Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi']

print ( Dernier ) retourne 'Dimanche'

Enfin :

Premier , *Autres , Avant , Dernier = LST_Jours

print ( Premier ) retourne 'Lundi'

print ( Autres ) retourne  ['Mardi', 'Mercredi', 'Jeudi', 'Vendredi']

print ( Avant ) retourne 'Samedi'

print ( Dernier ) retourne 'Dimanche'

Cette technique est utile pour extraire et traiter les éléments en début ou en fin de list ( ), le nombre d'éléments étant variable. Par exemple :

LST_Cliant_A = [ "DUPONT" , "Jean" , "01.23.64.654" , "04.27.42.297" , "04.27.12.817" , "Paris" ]

LST_Cliant_B = [ "MARTIN" , "Paul" , "03.12.76.005" , "06.19.89.140" , "Lihvuo" ]

Nom_A , Prenom_A , *Tel , Ville_A = LST_Client_A 

Nom_B , Prenom_B , *Tel , Ville_B = LST_Client_B 

MÉTHODES SPÉCIFIQUES AUX OBJETS LIST ( ). 

append ( ) : ajoute un élément à la fin de la liste.

clear ( ) : supprime tous les éléments de la liste.

copy ( ) : créer une copie superficielle de la liste.

count ( ) : retourne le nombre d'éléments ayant la même valeur.

extend ( ) : ajoute des éléments à la fin de la liste.

index ( ) : retourne l'index de l'élément ayant une certaine valeur.

insert ( ) : insert un nouvel élément devant un élément existant.

pop ( ) : supprime un élément et retourne sa valeur.

remove ( ) : supprime l'élément ayant une certaine valeur.

reverse ( ) : inverse l'ordre des éléments de la liste. 

sort ( ) : tri et réordonne les éléments de la liste.