Liste Python - Créer, accéder, découper, ajouter ou supprimer des éléments

python list create

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Dans ce didacticiel sur les listes Python, nous explorerons les moyens de créer, d'accéder, de découper et d'ajouter / supprimer des éléments aux listes Python qui sont sans doute l'un des types de données les plus utiles:

Python comprend 4 types de données de collection comme mentionné ci-dessous:

liste
Ensemble
dictionnaire
Tuple

Dans ce tutoriel, nous discuterons en détail de List et de ses différentes opérations. En Python, la liste est une structure de données ou c'est comme un tableau utilisé pour stocker plusieurs données à la fois.

=> Explorez la série de formations Python ici

Si vous avez de l'expérience dans d'autres langages de programmation tels que Java, C, C ++, etc., vous serez familiarisé avec le concept de tableaux. La liste est presque la même que les tableaux.

Ce que vous apprendrez:

Que sont les listes Python
En savoir plus sur les listes en Python
Conclusion
- lecture recommandée

Que sont les listes Python

En Python, une liste est un Type de données , qui stocke une collection d'objets différents (éléments) entre crochets (()). Chaque élément d'une liste est séparé par une virgule (,) avec le premier élément à l'index 0.

Remarque :À l'avenir, tous les exemples de ce didacticiel s'exécuteront directement à partir d'un shell Python, sauf indication contraire.

Voici un exemple de liste de 5 éléments.

>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')

Dans l'exemple ci-dessus, nous pouvons voir que la liste a Objets de chaîne comme éléments, et chaque élément est séparé par une virgule.

Caractéristiques de la liste Python

Avant de regarder comment nous pouvons manipuler les éléments d'une liste, examinons certaines des caractéristiques qui font que les listes Python sont préférées.

Les listes Python sont des séquences de conteneurs

Contrairement aux séquences plates ( chaîne de caractères , array.array , mémoire visuelle , etc.) qui ne peuvent contenir que des éléments d'un seul type, une liste est un séquence de conteneurs pouvant contenir des éléments d'un type ainsi que de types différents.

Exemple avec des éléments d'un type

Ouvrons notre shell python et définissons une liste de nombres.

>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')

L'exemple ci-dessus montre une liste d'éléments du même type, dans ce cas de type chaîne (str) .

Exemple avec des éléments de différents types

Ouvrons notre shell Python et définissons une autre version d'une liste de nombres.

>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)

L'exemple ci-dessus montre une liste d'éléments de différents types. Les types sont chaîne de caractères , entier, et flotter .

// a sketch showing the list of items and their types as annotation

La liste Python peut également contenir tous les objets tels que les fonctions , Des classes , modules , listes , tuples, et beaucoup plus.

Ouvrez un éditeur et collez le code ci-dessous:

def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list)

Production

Les listes Python sont des séquences de conteneurs

Les listes Python sont des séquences ordonnées

Une liste Python est une collection ordonnée d'objets. La position de chaque élément dans une liste est très importante. En fait, deux listes avec les mêmes éléments ne sont pas les mêmes si l'ordre dans lequel les éléments sont positionnés n'est pas le même.

>>> ('a','b','c','d') == ('a','c','b','d') False

Cette caractéristique de la liste Python permet d'accéder à ses éléments par index et découpage (plus à ce sujet plus tard).

Les listes Python sont des séquences mutables

Les listes Python sont modifiables. Mais qu'est-ce qu'un objet mutable? C’est simplement un objet qui peut être modifié après sa création. Exemples d'autres séquences mutables sont dictionnaire , array.array , collections.deque .

Pourquoi mutable? Des séquences telles que des listes sont utilisées pour des opérations complexes, il est donc logique qu'elles puissent changement , grandir , rétrécir , mise à jour, etc. . Ceci n'est possible qu'avec la mutabilité. La mutabilité nous permet également de modifier les listes en place (plus à ce sujet).

Vérifions la mutabilité d'une liste avec l'exemple ci-dessous.

Ouvrez simplement un éditeur et collez le code:

def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()

Production

Les listes Python sont des séquences mutables

À partir de la sortie ci-dessus, nous remarquons que la liste avant et après modification est différente. Cependant, le Identifiant la valeur est la même. Le Identifiant valeur ici représente l'adresse de l'objet en mémoire - obtenue avec Python identifiant() .

Cela nous indique que, bien que le contenu de la liste ait changé, il s'agit toujours du même objet. Par conséquent, cela répond à notre définition: ' C'est simplement un objet qui peut être modifié après sa création '

Remarque :Dans l'exemple ci-dessus, nous avons utilisé l'indexation (plus à ce sujet) pour modifier la liste.

Manipulation des listes Python

Avec les listes Python, le ciel est notre limite. Il y a d'innombrables choses que nous pouvons faire avec des listes comme ajouter , suppression , indexage , trancher , vérification de l'adhésion , et beaucoup plus. En outre, Python a des fonctions intégrées qui aident à rendre la manipulation des listes plus excitante.

Dans cette section, nous examinerons certaines opérations de liste couramment utilisées.

Créer une liste

Pour créer une liste, il vous suffit de mettre un certain nombre d'éléments ou d'expressions entre crochets séparés par des virgules.

(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)

En outre, Python a un objet intégré appelé liste () qui peut être utilisé pour créer des listes.

list( sequence ) >>> l = list() # create an empty list >>> l ()

Python liste () peut prendre des types de séquence et les convertir en listes. C'est la manière typique de convertir un tuple en liste.

>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)

Dans l'exemple ci-dessus, nous avons utilisé le type de données Tuple . Il est similaire à une liste mais contrairement aux listes, il est immuable et ses éléments sont entre parenthèses.

Un autre moyen par lequel nous pouvons créer une liste consiste à utiliser compréhension de liste qui a la syntaxe suivante.

(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9)

Il est à noter que les listes Python sont passées par référence. Cela signifie que l'attribution d'une liste fournira son identité d'emplacement de mémoire. L'erreur que font de nombreux débutants est de créer des listes de cette façon.

>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)

Ici, nous pourrions penser que nous avons créé deux listes différentes, mais vraiment nous venons d'en créer une. Voyons cela en modifiant l’une des variables.

>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)

Nous remarquons que la modification d'une variable change l'autre. Cela est dû au fait que les variables l1 et l2 détiennent la même identité d'emplacement mémoire, de sorte qu'elles pointent toutes deux vers le même objet.

Ajouter des éléments à une liste

Python a de nombreuses façons d'ajouter des éléments à sa liste. Le moyen le plus courant consiste à utiliser le ajouter() méthode. Les autres moyens sont d'utiliser le étendre() méthode. Indexage et trancher (nous en parlerons plus tard) sont plus susceptibles de remplacer des éléments dans une liste.

# 1) Utilisation de la méthode append ()

Cette méthode prend un seul élément et l'ajoute à la fin de la liste. Il ne renvoie pas de nouvelle liste mais modifie simplement la liste en place (grâce à sa mutabilité).

>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, )

Peu de choses à noter dans l'exemple ci-dessus:

Les éléments ici peuvent être des expressions, des types de données, des séquences et bien d'autres.
Le ajouter() La méthode a une complexité temporelle de (0) 1. Cela signifie que c'est constant.

# 2) Utilisation de la méthode extend ()

Cette méthode prend un itérable comme argument et ajoute tous les éléments de celui-ci à la fin de la liste. Cette méthode est principalement utilisée lorsque nous voulons ajouter des éléments individuels d'une séquence dans une liste

Fondamentalement, le étendre() La méthode itère sur son argument et ajoute chaque élément à la liste. Tout comme la méthode append (), elle ne renvoie pas de nouvelle liste mais modifie la liste en place.

>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o')

Peu de choses à noter dans l'exemple ci-dessus:

Une chaîne est itérable, donc notre étendre() La méthode itérera sur ses caractères.
Le étendre() la méthode a une complexité temporelle de (0) K où K est la longueur de son argument.

Accéder aux éléments d'une liste

Indexage et trancher sont les moyens les plus couramment utilisés pour accéder aux listes. Nous pouvons également accéder aux éléments d'une liste avec des boucles comme le pour boucle .

# 1) Indexation

Une liste Python utilise le numérotation à base zéro système. Cela signifie que tous ses éléments sont identifiés de manière unique par un numéro d'index allant de 0 à n-1 où n est la longueur de la liste.

Considérez la liste ci-dessous:

>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5

Le tableau ci-dessous montre leurs indices respectifs dans le numérotation à base zéro d'une liste.

Article	rapporter	bleu	vert	jaune	noir
pop ()	Pour supprimer / supprimer l'élément du dernier d'une liste.
Indice	0	1	deux	3	4

D'après le tableau ci-dessus, nous voyons que le premier élément ('rouge') est à la position d'index 0 et le dernier élément ('noir') est à la position d'index 4 (n-1) où n = 5 (longueur de l'objet couleurs).

Comme nous l'avons vu dans la section caractéristique ci-dessus, les listes Python sont des séquences ordonnées. Cela nous permet d'utiliser l'indexation pour accéder et manipuler facilement son élément.

Utilisons l'indexation pour accéder aux éléments à des index particuliers de l'objet couleurs créé ci-dessus.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range

Remarque :La dernière instruction ci-dessus tente d'accéder à un élément à la position d'index 9 à partir d'un objet de liste de longueur 5. Dans la liste Python, l'accès à un élément à un index qui n'existe pas augmentera le IndexError exception.

Un concept important de l'indexation est que nous pouvons utiliser l'indexation négative, c'est-à-dire que nous pouvons accéder aux éléments d'une liste de manière inversée en commençant à -1 pour le dernier élément et se terminant à -n pour le dernier élément où n est la longueur de l'objet de la liste.

Dans le tableau ci-dessus, si nous utilisons une indexation négative, cela ressemblera à celui ci-dessous:

Article	rapporter	bleu	vert	jaune	noir
Indice	-5	-4	-3	-2	-1

Utilisons l'indexation négative pour accéder à certains éléments de l'objet couleur créé ci-dessus.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red'

# 2) Trancher

Contrairement à l'indexation qui ne renvoie qu'un seul élément, trancher d'autre part, peut renvoyer une gamme d'articles.

Il a la syntaxe suivante:

L(n:m)

Lorsque n est le numéro d'index où la tranche commence (par défaut à 0), et m est le numéro d'index exclusif où la tranche se termine (par défaut à length-1). Ils sont séparés par un deux-points (:)

Prenons l'exemple ci-dessous qui utilise le découpage pour accéder aux éléments à des indices particuliers de l'objet couleurs créé ci-dessus.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>>

Dans la syntaxe L (n: m), n vaut 0 par défaut et m prend par défaut la longueur de la liste. Donc, dans exemples 1 et 3 ci-dessus, nous pourrions omettre n et m comme couleurs (: 2) et couleurs (2:) respectivement. Ou (:) qui, dans ce cas, renvoie une copie superficielle de tout l'objet de la liste.

Nous pouvons également utiliser des nombres d'index négatifs lors du découpage des listes. Ceci est généralement utilisé lorsque nous voulons accéder à la liste de manière inversée.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')

En outre, il existe un troisième paramètre que le découpage prend en charge appelé étape (s). Il définit le nombre d'éléments à avancer une fois le premier élément extrait de la liste. La valeur par défaut est 1.

L(n:m:s)

En utilisant la même liste de couleurs définie ci-dessus, utilisons le troisième paramètre de la tranche pour déplacer 2 étapes.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')

# 3) Utilisation de boucles

Les boucles sont principalement utilisées pour accéder aux éléments d'une liste afin de manipuler les éléments. Ainsi, au cas où nous voudrions opérer sur les éléments d'une liste, nous pouvons utiliser le pour boucle pour accéder aux articles et les faire passer pour être opérés.

Disons que nous voulons compter le nombre de lettres pour chaque élément. Nous pouvons utiliser le pour boucle pour accomplir cela.

Ouvrez un éditeur et collez le code ci-dessous:

def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors))

Production

Utilisation de boucles

Pour terminer cette section, examinons deux choses intéressantes qui peuvent être faites avec le tranchage.

Faire une copie superficielle d'une liste

C'est la manière de base d'utiliser le copie() méthode de l'objet liste ou de la fonction intégrée copy.copy . Cependant, cela peut être réalisé par tranchage.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>>

Inverser une liste

La méthode de base consiste à utiliser le sens inverse méthode de l'objet liste ou de la fonction intégrée renversé() . Cependant, cela peut être réalisé par tranchage.

>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>>

Suppression d'éléments d'une liste

Comme nous pouvons ajouter autant d'éléments à une liste, ils peuvent également être supprimés d'une liste. Les trois façons dont les éléments peuvent être supprimés sont:

# 1) Utilisation de l'instruction del

Il a la syntaxe suivante:

del target_list

La liste cible ( target_list ) peut être la liste entière (au cas où vous voudriez supprimer la liste) ou un ou plusieurs éléments dans une liste (dans ce cas, vous utilisez l'indexation ou le découpage).

Prenons l'exemple ci-dessous .

Disons que nous voulons supprimer certains éléments de la liste des couleurs créée ci-dessus.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>

Remarque :L'instruction del supprime en place c.-à-d. , cela modifiera l'objet de liste d'origine plutôt que de renvoyer un nouvel objet de liste.

# 2) Utilisation de list.remove (x)

Il supprime le premier élément de la liste dont la valeur est égale à X . Il lève une ValueError s'il n'y a pas un tel élément.

Cette méthode est principalement utilisée pour supprimer des éléments d'une liste par nom, contrairement à l'instruction del qui utilise l'indexation et le découpage.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>

Remarque :L'objet liste supprimer() suppression de méthode en place c.-à-d. , cela modifiera l'objet de liste d'origine plutôt que de renvoyer un nouvel objet de liste.

# 3) Utilisation de list.pop ((i))

Il supprime et renvoie l'élément à la position donnée dans un objet de liste. Si aucun i (index) n'est fourni, il supprime et renvoie le dernier élément de la liste.

Remarque :Le crochet carré autour de i ci-dessus ne signifie pas une liste de i, mais plutôt i est facultatif.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>>

Noter: La liste. pop ((i)) suppression de méthode en place c.-à-d. , cela modifiera l'objet de liste d'origine plutôt que de renvoyer un nouvel objet de liste. En outre, il renvoie l'élément supprimé de la liste

Remplacement des éléments d'une liste

Le remplacement des articles est assez simple. Dans l'une des sections ci-dessus, nous avons vu l'indexation et le découpage. Ceux-ci peuvent être utilisés pour accéder et supprimer des éléments d'une liste.

# 1) Remplacer en utilisant l'indexation

L(index) = value

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>>

# 2) Remplacement en utilisant le tranchage

L(n:m) = value

Remarque : Valeur devrait être un itérable , ou bien le Erreur-type l'exception sera soulevée.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>>

Questions fréquemment posées

Q # 1) Qu'est-ce qu'une liste de listes en Python?

Répondre: Une liste de listes en Python est une liste qui contient des listes comme élément.

Par exemple

(('a','b'),('c','d'))

Il peut également être appelé un liste imbriquée .

Q # 2) Comment déclarez-vous une liste en Python?

Répondre: En Python, une liste peut être déclarée de deux manières. Soit en utilisant la fonction intégrée liste() ou en utilisant la notation entre crochets (). liste() prend un itérable et () prend des éléments de tout type séparés par une virgule.

(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)

Q # 3) Pouvez-vous mettre une liste dans une liste Python?

Répondre: Oui, nous pouvons mettre une liste dans une liste. En fait, une liste est une séquence de conteneurs qui contient des éléments de tout type de données.

Q # 4) Que fait list () en Python?

Réponse: liste ( ) est une fonction intégrée en Python qui crée un objet liste. Il prend un itérable comme argument.

>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>

Q # 5) Une liste Python peut-elle contenir différents types?

Répondre: Une liste est une séquence de conteneurs qui accepte des éléments de tous types de données ( liste , tuple , entier , flotter , cordes , etc)

En savoir plus sur les listes en Python

Qu'est-ce que la structure des données?

Les ordinateurs sont utilisés pour stocker un grand nombre de données ou pour traiter un grand nombre de données avec une vitesse et une précision élevées. Par conséquent, il est préférable de stocker les données en permanence pour un accès rapide.

Pendant que le traitement des données a lieu, il doit avoir lieu dans les plus brefs délais sans perdre en précision. Nous utilisons la structure de données pour traiter les données de manière organisée et stocker les données dans la mémoire pour traitement.

Comme Python est un langage de programmation interprété de haut niveau, il est très important d'utiliser la structure de données en Python.

Qu'est-ce que List?

Une liste est une structure de données utilisée pour stocker plusieurs données à la fois.

Les données stockées dans une liste sont homogènes et cela en fait la fonctionnalité la plus puissante de la liste en Python. Nous pouvons stocker plusieurs données de différents types de données comme des chaînes, des entiers et des objets dans une seule liste.

Les listes sont modifiables en Python, les données peuvent donc être modifiées à tout moment, même après la création. Les listes sont très puissantes pour implémenter des piles et des files d'attente en Python.

Comme indiqué précédemment, la liste stocke les données dans une séquence ordonnée et les données stockées dans une liste sont accessibles à l'aide de leur index, et pour la liste, l'index commencera toujours à partir de zéro. Chaque élément a une place spécifique dans la liste et toutes ces données sont accessibles à l'aide d'un index.

Dans la liste, nous pouvons stocker la même valeur plusieurs fois et chaque donnée sera considérée comme un élément distinct et unique. Il est préférable que les listes stockent des données et les parcourent ultérieurement.

Créer une liste

Les données d'une liste sont stockées séparées par des virgules et placées entre crochets (()). Les éléments de la liste ne doivent pas nécessairement être du même type.

Syntax: List = (item1, item2, item3)

Exemple 1:

List = ( )

Exemple 2:

List = (2, 5, 6.7)

Exemple 3:

List = (2, 5, 6.7, ‘Hi’)

Exemple 4:

List = (‘Hi’, ‘Python’, ‘Hello’)

Dans les exemples ci-dessus, nous pouvons observer que nous avons stocké des éléments de différents types de données séparés par des virgules, 2 et 5 sont de type Integer, 6.7 de type float et 'Hi' est de type String, tous ces éléments sont inclus dans un liste et cela en fait une liste.

Nous pouvons également déclarer une liste vide. Nous pouvons également déclarer une liste dans une autre liste, et nous l'appelons comme une liste imbriquée.

Exemple 5:

List = (‘Hi’, (2, 4, 5), (‘Hello’))

Dans l'exemple ci-dessus, vous pouvez observer qu'une liste a été déclarée dans une autre liste.

Accéder aux valeurs dans la liste

Il existe différentes manières d'accéder aux éléments présents dans la liste en Python.

À l'aide de l'index, nous pouvons accéder aux éléments de la liste. L'index commence à 0 et l'index doit toujours être un entier. Si nous utilisons un index autre qu'un entier comme float, cela entraînera TypeError.

Exemple 1:

List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)

Production:

La liste est: (2, 5, 6.7, 'Salut')

Accessing_values_in_list_example_1

Production:

meilleur programme pour cloner un disque dur

Accessing_values_in_list_example_1_output

Dans l'exemple ci-dessus, nous imprimons directement la liste à l'aide de la fonction d'impression, nous n'accédons pas à l'élément individuel de la liste.

Accédons à chaque élément de la liste.

Exemple: 2

List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))

Production:

Le deuxième élément de la liste est: 5

Accessing_values_in_list_example_2

Production:

Accessing_values_in_list_example_2_output

Dans l'exemple ci-dessus, vous pouvez observer que nous imprimons le deuxième élément de la liste qui est 5, mais vous pouvez avoir une question pour savoir pourquoi dans l'instruction d'impression nous imprimons List (1)? C'est parce que l'index commence à zéro, donc List (1) fait référence au deuxième élément de la liste.

Exemple: 3

List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))

Production:

Le premier élément de la liste est: 2
Le dernier élément de la liste est: Salut

Accessing_values_in_list_example_3

Production:

Accessing_values_in_list_example_3_output

Exemple: 4

List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))

Production:

Le premier élément de la liste est: i
Les éléments présents dans une autre liste sont: 5

Accessing_values_in_list_example_4

Production:

Accessing_values_in_list_example_4_output

Dans le programme ci-dessus, si vous observez attentivement, vous pouvez voir que nous accédons aux éléments de la liste imbriquée.

En interne, les données seront stockées dans un format matriciel comme indiqué ci-dessous:

salut

2 4 5

Par conséquent, lorsque nous essayons d'accéder à List (0) (1), il pointera vers 1^strangée et 2^ndcolonne, les données seront donc «i».

De même, lorsque nous essayons d'accéder à List (1) (2), il pointera vers 2^ndrangée et 3^rdcolonne, ainsi, les données seront 5.

Indexation négative

Nous pouvons également accéder aux données en utilisant un indice négatif. Un index négatif commencera toujours à -1 et -1 se réfère au dernier élément et -2 se réfère au dernier élément de seconde et ainsi de suite.

Exemple 1

List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))

Production:

Le dernier élément de la liste est: 3

Negative_indexing_example_1.1

Production:

Negative_indexing_example_1_output1

Exemple: 2

List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))

Production:

Le deuxième élément de la liste est: 5

Exemple_indexation_négative_2.1

Production:

Negative_indexing_example_2_output1

Trancher la liste

En utilisant l'opérateur de tranche (:), nous pouvons accéder à une gamme d'éléments de la liste

Exemple 1

List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))

Production:

Les éléments du 2ème au 5ème sont: (2, 3, 4, 5)
Les éléments commençant au 2e sont: (1, 2, 3, 4)
Les éléments du quatrième à la fin sont: (4, 5, 6, 7)
Les éléments du début à la fin sont: (1, 2, 3, 4, 5, 6, 7)

Slicing_list_example_1.1

Production:

Slicing_list_example_1_output1

On peut également accéder aux éléments présents dans la liste en utilisant la boucle for.

Exemple: 2

List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)

Production:

1
deux
3
4
5
6
sept

Slicing_list_example_2

Production:

Slicing_list_example_2_output1

Souvenez-vous du format d'indexation ci-dessous:

H	EST	L	L	OU	5	sept	9	4
0	1	deux	3	4	5	6	sept	8
-9	-8	-7	-6	-5	-4	-3	-2	-1

Comme indiqué précédemment, List en python est mutable, ce qui signifie que les éléments peuvent être modifiés même s'il s'agit d'un entier ou d'une chaîne ou de tout type de données.

Nous pouvons mettre à jour la liste à l'aide de l'opérateur d'affectation.

Exemple: 3

List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)

Production:

La liste mise à jour est: (7, 4, 6, 9)

Slicing_list_example_3.1

Production:

Slicing_list_example_3_output1

Dans l'exemple ci-dessus, nous mettons à jour le premier élément de la liste «2» avec un nouvel élément «7».

Exemple: 4

List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)

Production:

La liste mise à jour est: (2, 5, 2, 4, 9, 0, 7)

Dans l'exemple ci-dessus, nous mettons à jour la liste des données dans la liste.

Slicing_list_example_4.1

Production:

Slicing_list_example_4_output1

Ajout d'éléments à la liste

Il existe plusieurs façons d'ajouter des éléments à la liste, et python a une fonction intégrée appelée append ().

En utilisant append (), nous ne pouvons ajouter qu'un seul élément à la liste, si vous souhaitez ajouter plusieurs éléments à la liste, nous devons utiliser pour boucle . La fonction append () ajoute toujours l'élément à la fin de la liste, la fonction append () ne prend qu'un seul argument.

Si vous souhaitez ajouter des éléments à une position spécifique, il vous suffit d'utiliser la méthode insert (). insert () prend deux arguments, c'est-à-dire la position et la valeur, la position fait référence à l'index, où les éléments doivent être ajoutés et la valeur fait référence à l'élément à ajouter à la liste.

Il existe une autre méthode appelée extend (), à l'aide de laquelle nous pouvons ajouter des éléments à la liste. La méthode extend () est utilisée pour ajouter une liste d'éléments à la liste. Semblable à la méthode append () et à la méthode extend (), elle ajoutera également des éléments à la fin de la liste.

Exemple 1

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)

Production:

La liste avant l'ajout de valeurs est la suivante: ('Bonjour', 'Bonjour')
La liste après l'ajout des valeurs est la suivante: ('Bonjour', 'Bonjour', 'Python', 'Salut')

Dans l'exemple ci-dessus, nous ajoutons les valeurs 'Python' et 'Hi' à la fin de la liste.

append () en python

Production:

append () dans la sortie Python

Exemple: 2

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))

Production:

La liste avant l'ajout de valeurs est la suivante: ('Bonjour', 'Bonjour')
La longueur de la liste avant l'ajout est: 2
La liste après l'ajout des valeurs est la suivante: ('Bonjour', 'Bonjour', 'Python', 'Salut')
La longueur de la liste après l'ajout est: 4

Nous pouvons trouver la longueur de la liste en utilisant la fonction len (), comme indiqué dans l'exemple ci-dessus.

Ajout_élément_à_la_liste_exemple_2

Production:

Adding_element_to_the_list_example_2_output

Nous pouvons également ajouter plusieurs valeurs à la liste en utilisant la boucle for.

Exemple: 3

List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))

Production:

La liste avant d'ajouter des éléments est: (7, 9, 8)
La longueur de la liste avant l'ajout d'éléments est: 3
La liste après l'ajout d'éléments est: (7, 9, 8, 2, 3, 4, 5)
La longueur de la liste après l'ajout d'éléments est: 7

Ajout_élément_à_la_liste_exemple_3

Production:

Adding_element_to_the_list_example_3_output1

Que se passe-t-il si nous ajoutons une liste de liste à une liste? Voyons cela dans l'exemple ci-dessous.

Exemple: 4

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)

Production:

List1 après l'ajout de List2 est: ('Salut', 'Python', (1, 5, 7, 2))

Si vous remarquez dans l'exemple ci-dessus, lorsque nous ajoutons List2 à List1, List1 deviendra une liste imbriquée.

Ajout_élément_à_la_liste_exemple_4

Production:

Adding_element_to_the_list_example_4_output

Si vous ne souhaitez pas créer la liste sous forme de liste imbriquée après avoir ajouté la liste, il est préférable d'utiliser la méthode extend ().

Exemple: 5

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)

Production:

List1 après l'ajout de List2 est: ('Salut', 'Python', 1, 5, 7, 2)

Lorsque nous utilisons la méthode extend (), les éléments de List1 seront étendus avec les éléments de List2. N'oubliez pas qu'il n'ajoutera pas la liste lorsque nous utiliserons la méthode extend ().

Ajout_élément_à_la_liste_exemple_5

Production:

Adding_element_to_the_list_example_5_output

Lorsque vous étendez une liste avec une chaîne, elle ajoute chaque caractère de la chaîne à la liste, car une chaîne peut être itérée.

Exemple: 6

List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)

Production:

La liste après extension de la chaîne est: (1, 5, 7, 2, «P», «y», «t», «h», «o», «n»)

Ajout_élément_à_la_liste_exemple_6

Production:

Adding_element_to_the_list_example_6_output

Liste append () vs extend ()

Jetons un œil à quelques exemples pour extend () et append ().

Exemple 1

def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()

Production:

Les éléments de la liste sont: («Salut», 1, «Bonjour», 2, 5)
La liste après avoir ajouté la chaîne est: ('Salut', 1, 'Bonjour', 2, 5, 'Python')
La liste après avoir ajouté la liste est: ('Salut', 1, 'Bonjour', 2, 5, 'Python', ('un', 'deux', 3))
List1 après avoir étendu la List2 est: («Salut», 1, «Bonjour», 2, 5, «Python», («un», «deux», 3), «Apple», «Orange», 2, 8)

List_append_vs_extend_example_1.1

Production:

List_append_vs_extend_example_3_output1

Exemple: 2

List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)

Production:

La liste avant l'insertion est: («Apple», «Orange», «Mango», «Strawberry»)
La liste après insertion est la suivante: («Pomme», «Orange», «Pastèque», «Mangue», «Fraise»)

List_append_vs_extend_example_2.1

Production

List_append_vs_extend_example_2_output1

Comme nous l'avons vu précédemment, la méthode insert () est utilisée pour insérer des valeurs à un index spécifique de la liste.

Exemple: 3

List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)

Production:

La liste après avoir ajouté les éléments est: (2, 4, 6, 8, 1, 3, 5, 7)
Après avoir ajouté les mêmes éléments à plusieurs reprises est: ('Salut', 'Salut', 'Salut', 'Salut', 'Salut')

List_append_vs_extend_example_3.1

Production:

List_append_vs_extend_example_3_output1

Suppression ou suppression d'éléments d'une liste

Nous pouvons également supprimer ou supprimer des éléments de la liste en utilisant les instructions del et remove ().

quel est le but des tests de régression

Voyons dans l'exemple ci-dessous.

Exemple 1

List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)

Production:

La liste avant la suppression du troisième élément est: (1, 2, 3, 4, 5, 6, 7, 8, 9)
La liste après la suppression du troisième élément est: (1, 2, 3, 5, 6, 7, 8, 9)
La liste après la suppression de plusieurs éléments est: (1, 5, 6, 7, 8, 9)

Dans l'exemple ci-dessus, vous pouvez observer que nous avons utilisé l'instruction del pour supprimer un élément ou plusieurs instructions de la liste.

Deleting_or_removing_element_from_the_list_example_11

Production:

Deleting_or_removing_element_from_the_list_example_1_output1

Nous allons maintenant voir la méthode remove ().

Exemple: 2

List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)

Production:

La liste avant de supprimer un élément est: (1, 2, 3, 4, 5, 6, 7)
La liste après avoir supprimé un élément est: (1, 2, 4, 5, 6, 7)
La liste après avoir fait apparaître l'élément est: (1, 2, 4, 5, 6)

Dans l'exemple ci-dessus, vous pouvez observer que nous supprimons un élément de la liste à l'aide de la méthode remove (). La méthode pop () est utilisée pour supprimer / supprimer le dernier élément de la liste.

Deleting_or_removing_element_from_the_list_example_2.1

Production:

Deleting_or_removing_element_from_the_list_example_2_output1

Méthodes de liste

Méthodes	Description
dégager()	Pour supprimer tous les éléments de la liste.
ajouter()	Pour ajouter un élément à la fin de la liste.
insérer()	Pour insérer un élément à un index spécifique de la liste.
étendre()	Pour ajouter une liste d'éléments à la fin de la liste.
compter()	Pour renvoyer le nombre d'éléments avec une valeur spécifique.
indice()	Pour renvoyer l'index du premier élément.
sens inverse()	Pour inverser une liste existante.
supprimer()	Pour supprimer les éléments de la liste.

Conclusion

Dans ce tutoriel, nous avons examiné quelques caractéristiques des listes Python ainsi que les différentes manières de manipuler une liste comme créer une liste , accès aux éléments d'une liste , et remplacer des éléments d'une liste.

Ce tutoriel sur la liste Python peut être conclu avec les pointeurs suivants:

La liste est l'un des types de données en Python, également appelé structure de données.
La liste est utilisée pour stocker un grand nombre de valeurs de n'importe quel type de données dans une seule variable, ce qui à son tour facilite l'accès.
L'index pour la liste commence toujours à zéro comme les autres langages de programmation.
Si vous travaillez sur une liste, vous devez vous souvenir de toutes les fonctions intégrées courantes de celle-ci.

=> Visitez ici pour apprendre Python à partir de zéro

Liste Python - Créer, accéder, découper, ajouter ou supprimer des éléments

Que sont les listes Python

Caractéristiques de la liste Python

Les listes Python sont des séquences de conteneurs

Les listes Python sont des séquences ordonnées

Les listes Python sont des séquences mutables

Manipulation des listes Python

Créer une liste

Ajouter des éléments à une liste

Accéder aux éléments d'une liste

Faire une copie superficielle d'une liste

Inverser une liste

Suppression d'éléments d'une liste

Remplacement des éléments d'une liste

Questions fréquemment posées

En savoir plus sur les listes en Python

Qu'est-ce que la structure des données?

Qu'est-ce que List?

Créer une liste

Accéder aux valeurs dans la liste

Indexation négative

Trancher la liste

Ajout d'éléments à la liste

Liste append () vs extend ()

Suppression ou suppression d'éléments d'une liste

Méthodes de liste

Conclusion

lecture recommandée