Listes ou tableaux en python

Listes ou tableaux en python

Introduction

Les listes sont comme les tableaux, déclarés dans d'autres langages de programmation. Les listes ne doivent pas toujours être homogènes, ce qui en fait un outil extrêmement puissant en Python.
Une seule liste peut contenir des types différents tels que des entiers, des chaînes, ainsi que des objets.
Les listes sont également très utiles pour l'implémentation de piles et de files d'attente.
Les listes sont modifiables et peuvent donc être modifiées même après leur création.

En Python, list est un type conteneur, utilisé pour stocker plusieurs données en même temps.
Les éléments d’une liste sont indexés selon une séquence définie et l’indexation d’une liste est faite avec 0 comme premier index.
Chaque élément de la liste a sa place définie dans la liste, chaque élément ayant son propre emplacement et sa crédibilité.

Création d'une liste

Les listes en Python peuvent être créées en plaçant simplement la séquence entre crochets[].
Une liste peut contenir des valeurs en double avec leurs positions distinctes. Par conséquent, plusieurs valeurs distinctes ou en double peuvent être transmises sous forme de séquence au moment de la création de la liste.

    # Liste vide
    list = [] 

    # liste avec éléments
    list=['lundi','mardi']

    # liste avec éléments de types différents
    list=['mostafa','essaddouki', 31, 2019]

    # liste entiers
    list=[1, 2, 3]

    # liste avec 10 éléments
    list=[0] * 10


    # afficher les éléments d'une liste

    # tous les éléments
    print(list)

    # premier élément
    print(list[0])

    # 2ème élément
    print(list[1])

    # dernier élément
    print(list[-1])

Ajouter des éléments

Des éléments peuvent être ajoutés à la liste à l'aide de la fonction append(). Un seul élément à la fois peut être ajouté à la liste à l'aide de la méthode append().
Pour ajouter plusieurs éléments à l'aide de la méthode append(), des boucles sont utilisées. Vous pouvez également ajouter des tuples à la liste à l’aide de la méthode append(à) car les tuples sont immuables.
Contrairement aux ensembles, les listes peuvent également être ajoutées à la liste existante à l'aide de la méthode append().
La méthode append() fonctionne uniquement pour l'ajout d'éléments à la fin de la liste.
Pour l'ajout d'élément à la position souhaitée, la méthode insert() est utilisée.
Contrairement à append () qui prend un seul argument, la méthode insert() nécessite deux arguments (position, valeur).
Outre les méthodes append() et insert(), il existe une méthode supplémentaire pour l’ajout d’éléments, extend(). Cette méthode permet d’ajouter plusieurs éléments simultanément à la fin de la liste.

    # creation de la liste
    list = []
    # ajouter des éléments à la liste 
    list.append(1) 
    list.append(2) 
    list.append(4) 

    print("\n Liste après ajout de trois éléments ") 
    print(list) 
    
    # ajouter plusieurs éléments (1, 2, 3)
    # avec une boucle
    for i in range(1, 4): 
        list.append(i)
    
    # Adding Tuples to the List 
    list.append((5, 6)) 
    print("\nListe après l'ajout d'un Tuple: ") 
    # [1, 2, 4, (5,6)] 4 éléments dans la liste

    # Adding Tuples to the List 
    list.append([3, 2]) 
    print("\nListe après l'ajout d'une liste: ") 
    # [1, 2, 4, [3,2]]  4 éléments dans la liste

    # ajouter un élément dans une position spécifique
    list.insert(0, 12) 
    # [12, 1, 2, 4]

    # ajouter un élément dans une position spécifique
    list.insert(2, 12) 
    # [1, 2, 12, 4]

    # ajouter plusieurs éléments à la fin de la liste
    List.extend([13 , 7, 9]) 
    
    # [1, 2, 4, 13, 7, 9] 6 éléments dans la liste

Accéder aux éléments de la liste

Afin d'accéder aux éléments de la liste, nous utilisons le numéro d'index. Utilisez l'opérateur d'index [] pour accéder à un élément d'une liste. L'index doit être un entier.
On accède à une liste imbriquée à l'aide de l'indexation imbriquée.

    # creation de la liste
    List = [9, 5, 13]

    # afficher les éléments d'une liste

    # premier élément
    print(list[0])
    # -> 9

    # 2ème élément
    print(list[1])
    # -> 5

    # dernier élément
    print(list[-1]) 
    # -> 13

    # dernier élément
    print(list[-2])
    # -> 5
    
    # liste imbriquée (matrice) ou tableau 2D
    # 3 lignes et 4 colonnes
    # 1 , 2, 5, 7
    # 3, 7, 9, 8
    # 10, 0, 4, 19

    list=[[1, 2, 5, 7],[3, 7, 9, 8],[10, 0, 4, 19]]

    # afficher l'élément de la ligne 2, 3ème colonne
    print(list[1][2])
    # -> 9

    # afficher l'élément de la ligne 3, 2ème colonne
    print(list[2][1])
    # -> 0

Supprimer des éléments de la liste

Les éléments peuvent être supprimés de la liste à l'aide de la fonction remove(), mais une erreur se produit si l'élément n'existe pas dans la liste.
La méthode Remove() ne supprime qu'un élément à la fois, pour supprimer une plage d'éléments, une boucle est utilisée.
La fonction Pop() peut également être utilisée pour supprimer et renvoyer un élément de la liste, mais par défaut, elle supprime uniquement le dernier élément de la liste, pour supprimer un élément d'une position spécifique de la liste, l'index de l'élément est passé en argument à la méthode pop(index).

la méthode remove() ne supprimera que la première occurrence de l'élément recherché.
    list = [5, 7, 8, 12]
    # Supprimer des éléments de la liste
    list.remove(5) 
    list.remove(8) 
    print("\nListe après la suppression: ") 
    print(list)
    # -> [7, 12]


    # Supprimer plusieurs éléments
    for i in range(3): 
        list.remove(list[i]) 
    print("\nListe après la suppression: ") 
    print(list) 
    # -> [12]

    # supprimer le dernier élément
    list.pop() 
    print(List) 
    # [5, 7, 8, 12]

    # supprimer l'élément de la position 1
    list.pop(1) 
    print(List) 
    # [5, 8, 12]

Accéder à une plage d'éléments (découpage ou slice)

Pour accéder aux éléments d'une plage spécifique de la liste, nous utilisons l’opération découpage.
L'opération de découpage est effectuée sur les listes à l'aide de deux points (:).
 

  • Pour accéder aux éléments du début à la plage, utilisez [:Index], 


  • pour accéder aux éléments de la fin ([: -Index]),
  • pour accéder aux éléments d'un index spécifique jusqu'à la fin [Index:],
  • pour accéder aux éléments d'une plage, utilisez [ Index de début: index de fin] et
  • pour accéder à la liste entière à l’aide d’une opération de découpage, utilisez [:]
  • De plus, pour accéder à la liste entière dans l’ordre inverse, utilisez [:: - 1].



    list = [5, 7, 8, 12, 25, 18, 30]

    # afficher les 3 premiers éléments
    print(list[:3])
    # -> [5, 7, 8]

    # afficher les éléments de la liste sans les 3 éléments derniers
    print(list[:-3])
    # -> [5, 7, 8, 12]

    # afficher les éléments de la position 3 jusqu'à la fin
    print(list[2:])
    # -> [8, 12, 25, 18, 30]

    # afficher les éléments avec un pas de 2
    print(list[::2])
    # -> [5, 8, 25, 30]

    # afficher les éléments dans l'ordre inverse
    list[::-1]
    # -> [30, 18, 25, 12, 8, 7, 5]

Méthodes

sum()

Calcule la somme de tous les éléments de la liste.

            # syntaxe : sum(List)
            List = [1, 6, 3, 9] 
            print(sum(List)) 
        
count()

Calcule le nombre d'occurrence d'un élément donné de la liste.

            # syntaxe : List.count(valeur)
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2] 
            print(List.count(3)) 
            # -> 2
        
length()

Calcule la taille de la liste

            # syntaxe : len(liste)
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2] 
            print(len(List)) 
            # -> 9
        
index()

Retourne l'index de première occurrence. Les index de début et de fin ne sont pas des paramètres nécessaires.

            #syntaxe : List.index(valeur[,debut[,fin]])
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            print(List.index(2))
            # -> 1

            print(List.index(2,2)) 
            # -> 4

            # rechercher dans la plage 2 - 6
            print(List.index(2,2,7)) 
            # -> 4
        
min()

Calcule le minimum de tous les éléments de la liste.

            # syntaxe min(List)
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            print(min(List))
            # -> 1
        
max()

Calcule le maximum de tous les éléments de la liste.

            # syntaxe max(List)
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            print(max(List))
            # -> 10
        
reverse()

Inverser l'ordre des éléments dans la liste

            # syntaxe List.reverse()
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            List.reverse()
            print(List)
            # [2, 3, 2, 1, 2, 9, 3, 2, 10]
        
sort()

Triez (tuple et liste) par ordre croissant.
Key et reverse_flag ne sont pas des paramètres nécessaires et reverse_flag est défini sur False, si rien n'est passé par sort().

            # Syntaxe de sorted : sorted([list[,key[,Reverse_Flag]]])
            # syntaxe de sort : list.sort([key,[Reverse_flag]])

            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            List.sort(reverse=True)
            # -> [10, 9, 3, 3, 2, 2, 2, 2, 1]


            sorted(List)
            # -> [1, 2, 2, 2, 2, 3, 3, 9, 10]
        
del()

supprimer un élément mentionné à l'aide du nom de la liste et son indice

            # syntaxe del list[indice]
            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            del List[2]
            # -> List = [10, 2, 9, 2, 1, 2, 3, 2]

            # supprimer une plage
            del List[1:3]
            # -> [10, 9, 2, 1, 2, 3, 2]

        
Opérateur "in"

Cet opérateur est utilisé pour vérifier si un élément est présent ou non dans la liste. Renvoie true si l'élément est présent dans la liste, sinon renvoie false.

            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            if 9 in List:
                print("élément est présent dans la liste")
            else:
                print("l'élément n'est pas présent dans la liste")
        
Opérateur "not in"

Cet opérateur est utilisé pour vérifier si un élément n'est pas présent dans la liste. Renvoie true si l'élément n'est pas présent dans la liste, sinon renvoie false.

                List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
                if 9 not in List:
                    print("l'élément n'est pas présent dans la liste")
                else:
                    print("l'élément est présent dans la liste")
            
Opérateurs "+" et "*"

"+" : Cet opérateur est utilisé pour concaténer deux listes en une seule liste.

"*" : Cet opérateur est utilisé pour multiplier la liste «n» fois et renvoyer une seule liste.

            L1 = [1, 2, 3]
            L2 = [4, 5, 6]

            List1=L1+L2
            # -> [1,2, 3, 4, 5, 6]

            List2=L1 * 3
            # [1, 2, 3, 1, 2, 3, 1, 2, 3]
        
clear()

Cette fonction permet d'effacer tous les éléments de la liste. Après cette opération, la liste devient vide.

            List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
            List.clear()
            print(List)
            # []
        

Rédigé par M. ESSADDOUKI

Many people realize their hearts desires late in life. Continue learning, never stop striving and keep your curiosity sharp, and you will never become too old to appreciate life.