Python orienté objet - Structures de données

Les structures de données Python sont très intuitives d'un point de vue syntaxique et offrent un large choix d'opérations. Vous devez choisir la structure de données Python en fonction de ce que les données impliquent, si elles doivent être modifiées, ou s'il s'agit d'une donnée fixe et du type d'accès requis, comme au début / à la fin / aléatoire, etc.

Listes

Une liste représente le type de structure de données le plus polyvalent en Python. Une liste est un conteneur qui contient des valeurs séparées par des virgules (éléments ou éléments) entre crochets. Les listes sont utiles lorsque nous voulons travailler avec plusieurs valeurs associées. Comme les listes conservent les données ensemble, nous pouvons effectuer les mêmes méthodes et opérations sur plusieurs valeurs à la fois. Les index des listes commencent à zéro et contrairement aux chaînes, les listes sont modifiables.

Structure des données - Liste

>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']

Accéder aux éléments de la liste Python

Chaque élément d'une liste se voit attribuer un numéro - c'est-à-dire l'index ou la position de ce nombre. L'indexation commence toujours à zéro, le deuxième index est un et ainsi de suite. Pour accéder aux éléments d'une liste, nous pouvons utiliser ces numéros d'index entre crochets. Observez le code suivant par exemple -

>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'

Objets vides

Les objets vides sont les types intégrés Python les plus simples et les plus élémentaires. Nous les avons utilisés plusieurs fois sans nous en rendre compte et l'avons étendu à toutes les classes que nous avons créées. Le but principal d'écrire une classe vide est de bloquer quelque chose pour le moment, puis de l'étendre et d'y ajouter un comportement.

Ajouter un comportement à une classe signifie remplacer une structure de données par un objet et modifier toutes les références à celui-ci. Il est donc important de vérifier les données, s'il s'agit d'un objet déguisé, avant de créer quoi que ce soit. Observez le code suivant pour une meilleure compréhension:

>>> #Empty objects
>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'

Donc, d'en haut, nous pouvons voir qu'il n'est pas possible de définir des attributs sur un objet qui a été instancié directement. Lorsque Python permet à un objet d'avoir des attributs arbitraires, il faut une certaine quantité de mémoire système pour garder une trace des attributs de chaque objet, pour stocker à la fois le nom de l'attribut et sa valeur. Même si aucun attribut n'est stocké, une certaine quantité de mémoire est allouée pour de nouveaux attributs potentiels.

Ainsi, Python désactive les propriétés arbitraires sur l'objet et plusieurs autres éléments intégrés, par défaut.

>>> # Empty Objects
>>>
>>> class EmpObject:
    pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'

Par conséquent, si nous voulons regrouper les propriétés, nous pourrions les stocker dans un objet vide comme indiqué dans le code ci-dessus. Cependant, cette méthode n'est pas toujours suggérée. N'oubliez pas que les classes et les objets ne doivent être utilisés que lorsque vous souhaitez spécifier à la fois des données et des comportements.

Tuples

Les tuples sont similaires aux listes et peuvent stocker des éléments. Cependant, ils sont immuables, nous ne pouvons donc pas ajouter, supprimer ou remplacer des objets. Le principal avantage que le tuple offre en raison de son immuabilité est que nous pouvons les utiliser comme clés dans des dictionnaires, ou dans d'autres emplacements où un objet nécessite une valeur de hachage.

Les tuples sont utilisés pour stocker des données et non des comportements. Si vous avez besoin d'un comportement pour manipuler un tuple, vous devez le transmettre à une fonction (ou une méthode sur un autre objet) qui exécute l'action.

Comme le tuple peut agir comme une clé de dictionnaire, les valeurs stockées sont différentes les unes des autres. Nous pouvons créer un tuple en séparant les valeurs par une virgule. Les tuples sont placés entre parenthèses mais pas obligatoires. Le code suivant montre deux affectations identiques.

>>> stock1 = 'MSFT', 95.00, 97.45, 92.45
>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
>>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>

Définition d'un tuple

Les tuples sont très similaires à list sauf que l'ensemble des éléments est placé entre parenthèses au lieu de crochets.

Tout comme lorsque vous découpez une liste, vous obtenez une nouvelle liste et lorsque vous découpez un tuple, vous obtenez un nouveau tuple.

>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')

Méthodes de tuple Python

Le code suivant montre les méthodes dans les tuples Python -

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
   File "<pyshell#148>", line 1, in <module>
      tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
   File "<pyshell#149>", line 1, in <module>
      tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
   File "<pyshell#151>", line 1, in <module>
      tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1

À partir du code ci-dessus, nous pouvons comprendre que les tuples sont immuables et donc -

• Toi cannot ajouter des éléments à un tuple.

• Toi cannot ajouter ou étendre une méthode.

• Toi cannot supprime les éléments d'un tuple.

• Les tuples ont no supprimer ou pop méthode.

• Count et index sont les méthodes disponibles dans un tuple.

dictionnaire

Dictionary est l'un des types de données intégrés de Python et définit des relations un-à-un entre les clés et les valeurs.

Définition de dictionnaires

Observez le code suivant pour comprendre la définition d'un dictionnaire -

>>> # empty dictionary
>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
   File "<pyshell#177>", line 1, in <module>
   my_dict['IT']
KeyError: 'IT'
>>>

À partir du code ci-dessus, nous pouvons observer que:

• Nous créons d'abord un dictionnaire avec deux éléments et l'affectons à la variable my_dict. Chaque élément est une paire clé-valeur, et l'ensemble des éléments est entouré d'accolades.

• Le nombre 1 est la clé et msftest sa valeur. De même,2 est la clé et IT est sa valeur.

• Vous pouvez obtenir des valeurs par clé, mais pas l'inverse. Ainsi quand on essaiemy_dict[‘IT’] , cela soulève une exception, car IT n'est pas une clé.

Modifier les dictionnaires

Observez le code suivant pour comprendre la modification d'un dictionnaire -

>>> # Modifying a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}

À partir du code ci-dessus, nous pouvons observer que -

• Vous ne pouvez pas avoir de clés en double dans un dictionnaire. La modification de la valeur d'une clé existante supprimera l'ancienne valeur.

• Vous pouvez ajouter de nouvelles paires clé-valeur à tout moment.

• Les dictionnaires n'ont aucune notion d'ordre parmi les éléments. Ce sont de simples collections non ordonnées.

Mélanger les types de données dans un dictionnaire

Observez le code suivant pour comprendre le mélange de types de données dans un dictionnaire -

>>> # Mixing Data Types in a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}

À partir du code ci-dessus, nous pouvons observer que -

• Non seulement les chaînes mais la valeur du dictionnaire peuvent être de n'importe quel type de données, y compris des chaînes, des entiers, y compris le dictionnaire lui-même.

• Contrairement aux valeurs de dictionnaire, les clés de dictionnaire sont plus restreintes, mais peuvent être de n'importe quel type comme des chaînes, des entiers ou tout autre.

Suppression d'éléments des dictionnaires

Observez le code suivant pour comprendre comment supprimer des éléments d'un dictionnaire -

>>> # Deleting Items from a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}

À partir du code ci-dessus, nous pouvons observer que -

• del - vous permet de supprimer des éléments individuels d'un dictionnaire par clé.

• clear - supprime tous les éléments d'un dictionnaire.

Ensembles

Set () est une collection non ordonnée sans éléments en double. Bien que les éléments individuels soient immuables, l'ensemble lui-même est modifiable, c'est-à-dire que nous pouvons ajouter ou supprimer des éléments / éléments de l'ensemble. Nous pouvons effectuer des opérations mathématiques comme l'union, l'intersection, etc. avec un ensemble.

Bien que les ensembles en général puissent être implémentés à l'aide d'arbres, les ensembles en Python peuvent être implémentés à l'aide d'une table de hachage. Cela lui permet une méthode hautement optimisée pour vérifier si un élément spécifique est contenu dans l'ensemble

Créer un ensemble

Un ensemble est créé en plaçant tous les éléments (éléments) à l'intérieur d'accolades {}, séparés par des virgules ou en utilisant la fonction intégrée set(). Observez les lignes de code suivantes -

>>> #set of integers
>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>

Méthodes pour les ensembles

Observez le code suivant pour comprendre les méthodes pour les ensembles -

>>> >>> #METHODS FOR SETS
>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>

Opérateurs pour ensembles

Observez le code suivant pour comprendre les opérateurs pour les ensembles -

>>> # PYTHON SET OPERATIONS
>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
   set1.add(i)
>>> for j in range(4,9):
   set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
>>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
   print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
   print('Set3 is subset of set4')
else: #set3 == set4
   print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
   print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()