Recherche de site Web

Apprendre la structure de données de liste Python - Partie 1

La structure de données est un ensemble de types de données, la relation entre eux et les fonctions ou opérations qui peuvent être appliquées sur les données. Le type de données peut être une chaîne, un entier, une valeur flottante, etc.

Quelle est la différence entre un objet mutable/immuable ?
Objets mutables
  1. Objets dont l’état peut être modifié une fois créé, comme l’ajout, la mise à jour ou la suppression d’éléments.
  2. Lists, Dictionary, Set, bytearray sont des types d’objets mutables en python.
Objets immuables
  1. L’état de l’objet ne peut pas être modifié. Une fois l’objet créé, nous ne pouvons pas ajouter, supprimer ou mettre à jour des éléments.
  2. String, Integer, Tuples, Frozenset sont quelques-uns des types d’objets immuables en python.
Quelle est la différence entre une structure de données homogène et hétérogène ?
  1. Structure de données homogène – Les éléments de données seront du même type de données (ex : Array).
  2. Structure de données hétérogène – Les éléments de données peuvent ne pas être du même type de données (ex : Liste, Tuples, Ensembles, etc.).
Que sont les types de données primitifs et non primitifs ?

Avant de comprendre la fonctionnalité de la structure de données intégrée, voyons quelques fonctions intégrées qui seront utilisées avec les objets de structure de données.

  • dir(obj) – une fonction intégrée qui renverra l’attribut et les méthodes.
  • len(obj) – Renvoie la longueur (le nombre d’éléments) d’un objet. L’argument peut être une séquence (telle qu’une chaîne, des octets, un tuple, une liste ou une plage) ou une collection (telle qu’un dictionnaire, un ensemble ou un ensemble figé).
  • del – Ce mot-clé intégré est utilisé pour supprimer un objet d’un espace de noms ou supprimer des éléments d’un objet comme une liste, un dictionnaire, etc.
  • type(obj) – La fonction type() renvoie soit le type de l’objet, soit renvoie un nouvel objet de type basé sur les arguments passés.
  • id() – Cette fonction renvoie l’identité d’un objet. Il s’agit d’un entier qui est garanti unique et constant pour cet objet pendant sa durée de vie.

Maintenant que vous avez vu quelques détails importants, passons aux structures de données python.

Python est livré avec des structures de données intégrées ainsi que les utilisateurs peuvent définir leurs propres structures de données. La structure de données intégrée comprend LIST, DICTIONARY, TUPLE et SET. Voici quelques exemples de structures de données définies par l’utilisateur : STACK, QUEUES, TREE, HASHMAP, etc.

Les personnes venant d’autres langages de programmation seront très familières avec un type de tableau. Mais chez python, ils ne sont pas si courants.

Ici, la liste est un peu similaire à un tableau, mais la liste nous permet de stocker des valeurs de n’importe quel type de données (hétérogène) tandis que le tableau ne contiendra que des données de type particulier (int, float etc...). Pour utiliser array, vous devez importer explicitement le tableau du module « array ».

Dans cette série d’articles Python, nous allons voir ce qu’est une structure de données et une structure de données intégrée à Python.

LISTE

List est une structure de données qui est une collection de différents types de données. Que signifie « collecte de différents types de données » ? La liste peut stocker des chaînes, des entiers, des valeurs à virgule flottante, des listes imbriquées, etc.

Les objets de liste sont « Mutables », ce qui signifie que les éléments créés à l’intérieur de la liste peuvent être consultés, modifiés ou supprimés. Répertorier l’indexation. Chaque élément des listes est attribué à une adresse qui peut être utilisée pour accéder à la valeur de l’élément ou la modifier.

  • Créer une liste
  • Liste Insérer/Accéder/Modifier
  • Supprimer la liste

CRÉER UNE LISTE

La liste peut être créée à l’aide de crochets.

>>> name_empty = []			# Empty list
>>> name = ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# list with string data type
>>> name_int = [1,2,3]			# list with Integer data type
>>> name_mixed = [name_int,name,1,2,3.14]	# list with nested list items.
>>> name_mixed
[[1, 2, 3], ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'], 1, 2, 3.14]
>>> name_int
[1, 2, 3]

Nous pouvons utiliser la fonction type() intégrée pour vérifier le type d’objet.

>>> type(name)

Nous pouvons accéder aux méthodes et attributs de l’instance de liste en utilisant la fonction dir().

>>> dir(name)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Nous pouvons connaître le nombre total d’éléments dans la liste en utilisant la méthode len().

>>> len(name)

Nous pouvons créer une nouvelle liste à partir d’une liste existante en utilisant la méthode list.copy().

>>> name_new = name.copy()
>>> name_new
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

INSERTION/ACCÈS/MODIFICATION DE LISTE

Nous pouvons insérer un élément dans une liste à n’importe quelle position en utilisant la méthode list.insert(i, x).

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name
['Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.insert(0,'Tom')	# Insert method takes 2 arguments (Index position, Item)
>>> name
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# Tom is inserted at the 0th position.

Nous pouvons utiliser la méthode list.append(x) pour ajouter un seul élément dans la liste. Cela insérera l’élément à la fin de la liste.

>>> name = []
>>> len(name)
0
>>> name.append('Leo')
>>> name.append('Matt')
>>> name.append('Kane')
>>> print(name)
['Leo', 'Matt', 'Kane']

Nous pouvons utiliser la méthode list.extend() pour ajouter plusieurs éléments à la liste.

>>> new_name = ['Gowtham','Martin','Luis']
>>> name.extend(new_name)
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']

Nous pouvons également utiliser l'opérateur '+' pour combiner deux listes. Les deux listes peuvent être de types de données différents.

>>> a = [1,2,3]
>>> b = [2,3,3]
>>> c = a + b
>>> c
[1, 2, 3, 2, 3, 3]
>>> d = ['karthi','kenny']
>>> e = a + d
>>> e
[1, 2, 3, 'karthi', 'kenny']

Comme nous l’avons déjà dit, les objets de listes sont mutables. Un élément de liste peut être modifié en référençant la position de l’index et en lui attribuant une valeur.

>>> name									# Before modified
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[0] = 'Karthi'
>>> name									# After Modified
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

La liste prend en charge l’indexation positive et négative.

L’indexation commence à partir de 0 et l’indexation négative commence à partir de -1.

Nous pouvons accéder à l’élément de liste en utilisant sa position d’index.

>>> name[0]			# Accessing the List item at index 0
'Leo'
>>> name[1]
'Matt'
>>> name[4]
'Petter'
>>> name[5]
'Will'
>>> name[-1]			# Accessing the list item with negative indexing
'Will'
>>> name[-6]
'Leo'

Nous pouvons également utiliser le découpage pour accéder aux éléments de la liste. Le découpage nous permet d’accéder à une gamme d’éléments en définissant les paramètres de début, de fin, d’étape.

# SYNTAX: list[starting position, ending position, Step]

>>> name[0:3]
['Tom', 'Leo', 'Matt']
>>> name[:]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[:4]
['Tom', 'Leo', 'Matt', 'Kane']
>>> name[:-2]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott']
>>> name[:-1]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter']
>>> name[:-1:2]
['Tom', 'Matt', 'Scott']

Nous pouvons trouver le nombre d’occurrences pour une valeur donnée en utilisant la méthode list.count(x).

>>> name_int = [1,1,2,3,1]
>>> name_int.count(1)
3

Nous pouvons trouver la position de l’index d’un élément donné à l’aide de la méthode list.index(x[, start[, end]]).

>>> name			# Inserted ‘Will’ at the end of the list. Now we have 2 name ‘Will’.
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will']
>>> name.index('Will)	# Returns the index position of first occurence of x.
0
>>> name.index('Will',2)	# Starting index positon’2’ is given.
7
>>> name.index('Will',2,4)	# Starting and Ending Index position is given. Since there is no 					occurence of ‘Will’ within the given search position it will throw 					Value Error.
Traceback (most recent call last):
File "<stdin>", line 1, in 
ValueError: 'Will' is not in list

Nous pouvons utiliser la méthode list.reverse() pour inverser les éléments de la liste.

>>> name
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.reverse()
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi']

SUPPRIMER LA LISTE

Nous pouvons utiliser la méthode list.pop(x) pour supprimer un élément d’une liste à la position x. Cette fonction supprimera l’élément de la liste et affichera l’élément supprimé. Si x n’est pas spécifié, la méthode pop() renverra le dernier élément de la liste.

>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop(0)
'Will'
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop()
'Luis'

Nous pouvons également utiliser la méthode list.remove (x) pour supprimer l’élément de la liste. Ici, x prend la valeur de l’élément et lève une ValueError si x n’est pas dans la liste.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name.remove('Leo')
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.remove('Leo')
Traceback (most recent call last):
  File "", line 1, in 
ValueError: list.remove(x): x not in list

Nous pouvons rendre une liste vide en attribuant le nom de la liste entre crochets ou en utilisant la méthode list.clear().

>>> name1 = name.copy()
>>> name1
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name = []			
>>> name
[]
>>> name1.clear()		
>>> name1
[]

Au lieu d’utiliser des méthodes de liste pour rendre la liste vide ou supprimer un élément de la liste, nous pouvons utiliser le mot-clé intégré del pour effectuer ces actions. Le mot-clé « del » peut supprimer un objet de liste de la mémoire, supprimer un élément d’une liste ou supprimer un élément d’une tranche.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> del name[0]
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> del name[-3:]
>>> name
['Matt', 'Kane']
>>> del name[:]
>>> name
[]

La fonction id() intégrée renvoie l'"identité » d’un objet. Il s’agit d’un entier qui est garanti unique et constant pour cet objet pendant sa durée de vie.

>>> id(name)
139979929658824
>>> del name
>>> id(name)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'name' is not defined

Remarque : nous avons supprimé la variable list de la mémoire à l’aide de del(), donc elle génère une erreur de nom.

help() funtion:

Help() intégré est très utile pour obtenir des détails sur un objet particulier ou les méthodes de cet objet.

help(object)
help(object.method)
Résumé

Jusqu’à présent, dans cet article, nous avons vu comment nous pouvons utiliser une structure de données de liste pour stocker, accéder, modifier, supprimer des objets de liste en utilisant les méthodes de liste. Nous avons également vu quelques fonctions intégrées comme id(), dir(), type(), help() qui sont des fonctions très efficaces. Nous avons également la compréhension de liste en python qui fournit une manière plus concise et lisible de créer une liste.

Articles connexes: