Recherche de site Web

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

La Structure des données est un ensemble de types de données, les relations entre eux et les fonctions ou opérations qui peuvent être appliquées aux 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. Les listes, dictionnaire, ensemble, 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/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 : Tableau).
  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 le type de l'objet ou renvoie un nouvel objet de type en fonction des arguments passés.
  • id() – Cette fonction renvoie « l'identité » d'un objet. Il s’agit d’un nombre entier garanti unique et constant pour cet objet tout au long de 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 et 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. Certains exemples de structures de données définies par l'utilisateur sont STACK, QUEUES, TREE, HASHMAP, etc…

Les personnes venant d’autres langages de programmation seront très familiarisées avec un type tableau. Mais en 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 contiendra uniquement des données d'un type particulier (int, float etc…). Pour utiliser un tableau, vous devez importer explicitement le tableau depuis le module « array ».

Dans cette série d'articles Python, nous examinerons 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, une liste imbriquée, etc.

Les objets Liste sont « Mutables », ce qui signifie que les éléments créés dans la liste peuvent être consultés, modifiés ou supprimés. Indexation de prise en charge de la liste. Chaque élément des listes est attribué à une adresse et cette adresse peut être utilisée pour accéder ou modifier la valeur de l'élément particulier.

  • Créer une liste
  • Insérer/Accéder/Modifier la liste
  • 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 aux attributs de l'instance list 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 LA 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. La liste peut être de différents types de données.

>>> 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 déjà indiqué, les objets des 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 à 0 et l'indexation négative commence à -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 et 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 d'index d'un élément donné en utilisant 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é, alors 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 renvoie 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 aux 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 ou 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 nombre entier garanti unique et constant pour cet objet tout au long de sa 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 de liste de la mémoire en utilisant del(), elle génère donc une erreur de nom.

help() funtion:

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

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

Jusqu'à présent, dans cet article, nous avons vu comment utiliser une structure de données de liste pour stocker, accéder, modifier et supprimer des objets de liste à l'aide des 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 un moyen plus concis et lisible de créer une liste.