Compréhension de liste Python, ajout, tri, longueur [EXEMPLES]

Qu'est-ce qu'une liste Python ?

Une liste est exactement ce à quoi elle ressemble, un conteneur qui contient différents objets Python, qui peuvent être des entiers, des mots, des valeurs, etc. C'est l'équivalent d'un tableau dans d'autres langages de programmation. Il est représenté par un carré brackets (et c'est l'un des attributs qui le différencie des tuples, qui sont séparés par des parenthèses). Il est également mutable, c'est-à-dire qu'il peut être modifié ou mis à jour ; contrairement aux tuples, qui sont immuables.

Exemples de listes Python :

Les listes Python peuvent être homogènesneous, c'est-à-dire qu'ils peuvent contenir le même type d'objets ; ou hétérogèneneonous, y compris différents types d’objets.

Exemples de homogeneoLes listes américaines incluent :

list of integers =  [1, 2, 3, 8, 33]
list of animals = ['dog', 'cat', 'goat']
list of names = ['John', 'Travis', 'Sheila']
list of floating numbers = [2.2, 4.5, 9.8, 10.4]

Exemples d'hétérogénéiténeoLes listes américaines incluent :

[2, 'cat', 34.33, 'Travis']
[2.22, 33, 'pen']

Accéder aux valeurs dans les listes

Pour accéder aux valeurs dans les listes, l'index des objets à l'intérieur des listes peut être utilisé. Un index dans les listes Python fait référence à la position d'un élément dans une liste ordonnée. Par exemple:

list = [3, 22, 30, 5.3, 20]
  • La première valeur de la liste ci-dessus, 3, a un indice de 0
  • La deuxième valeur, 22, a un indice de 1
  • La troisième valeur, 30, a un indice de 2

et ainsi de suite. Pour accéder à chacune des valeurs de la liste, vous utiliseriez :

list[0] to access 3
list[1] to access 22
list[2] to access 30
list[3] to access 5.3
list[4] to access 20

Le dernier membre d'une liste est également accessible en utilisant l'index -1. Par exemple,

list[-1] = 20

Découpage de liste Python

Le découpage de liste est la méthode de fractionnement d'un sous-ensemble d'une liste, et les indices des objets de la liste sont également utilisés à cet effet. Par exemple, en utilisant le même exemple de liste ci-dessus ;

list[:] = [3, 22, 30, 5.3, 20] (all the members of the list];
list[1:3] = [22, 30] (members of the list from index 1 to index 3, without the member at index 3);
list[:4] = [3, 22, 30, 5.3] (members of the list from index 0 to index 4, without the member at index 4)
list[2:-1] = [30, 5.3] (members of the list from index 2, which is the third element, to the second to the last element in the list, which is 5.3).

Les listes Python sont exclusives à la limite supérieure, ce qui signifie que le dernier index lors du découpage de liste est généralement ignoré. C'est pourquoi

list[2:-1] = [30, 5.3]

, et non [30, 5.3, 20]. Il en va de même pour tous les autres exemples de découpage de liste donnés ci-dessus.

Mise à jour des listes

Disons que vous avez une liste = [physique, chimie, mathématiques] et que vous souhaitez modifier la liste en [biologie, chimie, mathématiques], modifiant ainsi le membre à l'index 0. Cela peut facilement être fait en attribuant cet index au nouveau membre que vous voulez.

Autrement dit,

list = [physics, chemistry, mathematics]
    list[0] = biology
    print(list)

Résultat : [biologie, chimie, mathématiques]

Cela remplace le membre à l'index 0 (physique) par la nouvelle valeur souhaitée (chimie). Cela peut être fait pour n’importe quel membre ou sous-ensemble de la liste que vous souhaitez modifier.

Pour donner un autre exemple : disons que vous avez une liste appelée nombres entiers et contenant les nombres [2, 5, 9, 20, 27]. Pour remplacer 5 dans cette liste par 10, vous pouvez le faire avec :

integers = [2, 5, 9, 20, 27]
           integers[1] = 10
           print(integers)

>>> [2, 10, 9, 20, 27]

Pour remplacer le dernier membre de la liste d'entiers, qui est 27, par un nombre libre comme 30.5, vous utiliseriez :

integers = [2, 5, 9, 20, 27]
           integers[-1] = 30.5
           print(integers)

>>> [2, 5, 9, 20, 30.5]

Suppression d'éléments de liste

Il existe 3 méthodes Python pour supprimer des éléments de liste : list.remove(), list.pop() et l'opérateur del. La méthode Remove prend l'élément particulier à supprimer comme argument tandis que pop et del prennent l'index de l'élément à supprimer comme argument. Par exemple:

liste = [3, 5, 7, 8, 9, 20]

Pour supprimer 3 (le 1er élément) de la liste, vous pouvez utiliser :

  • list.remove(3) ou
  • list.pop[0], ou
  • supprimer la liste[0]

Pour supprimer 8, l'élément à l'index 3, de la liste, vous pouvez utiliser :

  • list.remove(8), ou
  • liste.pop[3]

Ajout d'éléments de liste

Pour ajouter des éléments à une liste, la méthode append est utilisée, ce qui ajoute l'élément à la fin de la liste.

Par exemple :

list_1 = [3, 5, 7, 8, 9, 20]
    list_1.append(3.33)
    print(list_1)

    >>> list_1 = [3, 5, 7, 8, 9, 20, 3.33]

    list_1.append("cats")
    print(list_1)
    >>> list_1 = [3, 5, 7, 8, 9, 20, 3.33, "cats"]

Liste des fonctions intégrées (méthodes)

Le following est une liste de fonctions et de méthodes intégrées avec leurs descriptions :

  • len(liste): cela donne la longueur de la liste en sortie. Par exemple:
numbers = [2, 5, 7, 9]
print(len(numbers))
>>> 4
  • max(liste): renvoie l'élément de la liste avec la valeur maximale. Par exemple:
numbers = [2, 5, 7, 9]
print(max(numbers))
>>> 9
  • min(liste) : renvoie l'élément de la liste avec la valeur minimale. Par exemple:
numbers = [2, 5, 7, 9]
print(min(numbers))
>>> 2
  • liste(tuple): convertit un objet tuple en liste. Par exemple;
animals = (cat, dog, fish, cow)
print(list(animals))
>>> [cat, dog, fish, cow]
  • liste.append(élément) : ajoute l'élément à la liste. Par exemple;
numbers = [2, 5, 7, 9]
numbers.append(15)
print(numbers)
>>> [2, 5, 7, 9, 15]
  • liste.pop(index) : supprime l'élément à l'index spécifié de la liste. Par exemple;
numbers = [2, 5, 7, 9, 15]
numbers.pop(2)
print(numbers)
>>> [2, 5, 9, 15]
  • liste.remove(élément) : supprime l'élément de la liste. Par exemple;
values = [2, 5, 7, 9]
values.remove(2)
print(values)
>>> [5, 7, 9]
  • liste.reverse() : inverse les objets de la liste. Par exemple;
values = [2, 5, 7, 10]
values.reverse()
print(values)
>>> [10, 7, 5, 2]
  • liste.index(élément) : pour obtenir la valeur d'index d'un élément dans la liste. Par exemple;
animals = ['cat', 'dog', 'fish', 'cow', 'goat']
fish_index = animals.index('fish')
print(fish_index)
>>> 2
  • somme(liste) : pour obtenir la somme de toutes les valeurs de la liste, si les valeurs sont toutes des nombres (entiers ou décimaux). Par exemple;
values = [2, 5, 10]
sum_of_values = sum(values)
print(sum_of_values)

>>> 17

Si la liste contient un élément autre qu'un nombre, comme une chaîne, la méthode sum ne fonctionnera pas. Vous obtiendrez une erreur disant : « Erreur-type: type(s) d'opérande(s) non pris en charge pour + : 'int' et 'str'"

  • list.sort() : pour organiser une liste d'entiers, de nombres à virgule flottante ou de chaînes, par ordre croissant ou décroissant. Par exemple:
values = [1, 7, 9, 3, 5]
# To sort the values in ascending order:
values.sort()
print(values)

>>> [1, 3, 5, 7, 9]

Un autre exemple:

values = [2, 10, 7, 14, 50]
# To sort the values in descending order:
values.sort(reverse = True)
print(values)

>>> [50, 14, 10, 7, 2]

Une liste de chaînes peut également être triée, soit par ordre alphabétique, soit par longueur des chaînes. Par exemple;

# to sort the list by length of the elements
strings = ['cat', 'mammal', 'goat', 'is']
sort_by_alphabet = strings.sort()
sort_by_length = strings.sort(key = len)
print(sort_by_alphabet)
print(sort_by_length)

>>> ['cat', 'goat', 'is', 'mammal']
        ['is', 'cat', 'goat', 'mammal']

Nous pouvons trier la même liste par ordre alphabétique en utilisant des « chaînes ».

Parcourir les listes

Le bouclage dans les listes peut être effectué de la même manière que n’importe quelle autre fonction de bouclage en Python. De cette façon, une méthode peut être exécutée sur plusieurs éléments d’une liste en même temps. Par exemple:

liste = [10, 20, 30, 40, 50, 60, 70].

Pour parcourir tous les éléments de cette liste, et disons, ajoutez 10 à chaque élément :

for elem in list:
        elem = elem + 5
        print(elem)
    
    >>>>15
        25
        35
        45
        55
        65
        75

Pour parcourir les trois premiers éléments de la liste et les supprimer tous ;

for elem in list[:3]:
    list.remove(elem)

    >>>list = [40, 50, 60, 70]

Pour parcourir les 3rd (index 2) au dernier élément de la liste et ajoutez-les à une nouvelle liste appelée new_list :

new_list = []	
    for elem in list[2:]:
        new_list.append(elem)
        print(“New List: {}”.format(new_list))
    
   Output:
	New List: [30, 40, 50, 60, 70]

De cette manière, n’importe quelle méthode ou fonction peut être appliquée aux membres d’une liste pour effectuer une opération particulière. Vous pouvez soit parcourir tous les membres de la liste, soit parcourir un sous-ensemble de la liste en utilisant le découpage de liste.

Compréhensions de listes Python

Les compréhensions de liste sont des fonctions Python utilisées pour créer de nouvelles séquences (telles que des listes, des dictionnaires, etc.) à l'aide de séquences déjà créées. Ils aident à réduire les boucles plus longues et rendent votre code plus facile à lire et à maintenir.

Par exemple; disons que vous vouliez créer une liste contenant le squares de tous les nombres de 1 à 9 :

list_of squares = []
    for int in range(1, 10):
        square = int ** 2
        list_of_squares.append(square)

    print(list_of_squares)

List_of_squares using for loop:

    [1, 4, 9, 16, 25, 36, 49, 64, 81]

Pour faire la même chose avec les compréhensions de listes :

list_of_squares_2 = [int**2 for int in range(1, 10)]

    print('List of squares using list comprehension: {}'.format(list_of_squares_2))

Output using list comprehension:

    [1, 4, 9, 16, 25, 36, 49, 64, 81]

Comme vu ci-dessus, l'écriture du code à l'aide de compréhensions de liste est beaucoup plus courte que l'utilisation de boucles for traditionnelles, et est également plus rapide. Ceci n'est qu'un exemple d'utilisation de compréhensions de liste à la place des boucles for, mais cela peut être reproduit et utilisé dans de nombreux endroits où les boucles for peuvent également être utilisées. Parfois, utiliser une boucle for est la meilleure option, surtout si le code est complex, mais dans de nombreux cas, la compréhension des listes rendra votre codage plus facile et plus rapide.

Vous trouverez ci-dessous un tableau contenant quelques fonctions et méthodes de liste, ainsi que leurs descriptions.

Fonctions intégrées

FONCTION DESCRIPTION
Rond () Arrondit le nombre passé en argument à un nombre spécifié de chiffres et renvoie la valeur à virgule flottante
Mini() renvoyer l'élément minimum d'une liste donnée
Max () renvoyer l'élément maximum d'une liste donnée
len () Renvoie la longueur de la liste
Énumérer() Cette fonction intégrée génère à la fois les valeurs et les index des éléments dans un itérable, nous n'avons donc pas besoin de compter manuellement
Filtre() teste si chaque élément d'une liste est vrai ou non
Lambda Une expression qui peut apparaître là où un def (pour créer des fonctions) n'est pas syntaxique, à l'intérieur d'un littéral de liste ou des arguments d'appel d'une fonction.
Carte() renvoie une liste des résultats après avoir appliqué la fonction donnée à chaque élément d'un itérable donné
Accumuler() appliquer une fonction particulière passée dans son argument à tous les éléments de la liste renvoie une liste contenant les résultats intermédiaires
Somme () Renvoie la somme de tous les nombres de la liste
Cmp() Ceci est utilisé pour comparer deux listes et renvoie 1 si la première liste est supérieure à la deuxième liste.
insérer Insérer un élément à lister à une position particulière

Méthodes de liste

FONCTION DESCRIPTION
Ajouter () Ajoute un nouvel élément à la fin de la liste
Dégager() Supprime tous les éléments de la liste
Copier () Renvoie une copie de la liste originale
Se déployer() Ajouter de nombreux éléments à la fin de la liste
Compter () Renvoie le nombre d'occurrences d'un élément particulier dans une liste
Indice() Renvoie l'index d'un élément spécifique d'une liste
Populaire() Supprime l'élément de la liste à un index particulier (suppression par position)
Supprimer() Supprime l'élément spécifié de la liste (supprimer par valeur)
Inverser() Méthode d'inversion sur place qui inverse l'ordre des éléments de la liste

Résumé

  • Une liste est exactement ce à quoi elle ressemble, un conteneur qui contient différents objets Python, qui peuvent être des entiers, des mots, des valeurs, etc.
  • Python les listes peuvent être homogènesneonous, signifie qu'ils peuvent contenir le même type d'objets ; ou hétérogèneneonous, contenant différents types d’objets.
  • Pour accéder aux valeurs dans les listes, l'index des objets à l'intérieur des listes peut être utilisé.
  • Le découpage de liste est la méthode de fractionnement d'un sous-ensemble d'une liste, et les indices des objets de la liste sont également utilisés à cet effet.
  • Trois méthodes pour supprimer des éléments de liste sont : 1)list.remove(), 2)list.pop() et 3)del opérateur
  • La méthode Append est utilisée pour ajouter des éléments. Cela ajoute l'élément à la fin de la liste.
  • La méthode de bouclage du programme Python peut être exécutée sur plusieurs éléments d'une liste de données en même temps.
  • Les compréhensions de liste sont des fonctions Python utilisées pour créer de nouvelles séquences (telles que des listes, des dictionnaires, etc.) à l'aide de séquences déjà créées.