Python fr:Structures De Données

[edit] Introduction

Les structures de données sont juste cela - ce sont des structures qui peuvent contenir des données . En d'autres termes, elles sont utilisées pour stocker une collection de données en rapport.

Il y a quatre structures de données existantes dans Python - liste, tuple, dictionnaire et set. Nous verrons maintenant comment utiliser chacune et comment nous simplifier la vie.

[edit] Liste

Une liste est une structure de données qui contient une collection ordonnée d'items, c'est-à-dire que vous pouvez stocker une séquence d'items dans une liste. C'est facile à imaginer si vous pensez à une liste de commissions qui est une liste de choses à acheter, sauf que vous avez une chose par ligne, mais Python les présentera séparées par des virgules.

La liste de choses à acheter doit être entourée de crochets afin que Python comprenne que vous créez une liste. Une fois que vous avez créé une liste, vous pouvez ajouter, enlever ou rechercher un élément dans la liste. Comme nous pouvons ajouter ou enlever un élément , nous disons qu'une liste est un type de données mutable c'est-à-dire que ce type peut être modifié.

[edit] Introduction Rapide Aux Objets Et Classes

Bien que j'aie retardé jusqu'à maintenant la discussion sur les objets et les classes, quelques explications vont vous permettre de mieux comprendre les listes. Nous verrons cela en détail plus tard dans le chapitre dédié.

Une liste est un exemple de l'utilisation des objets et des classes. Quand nous utilisons une variable i et lui donnons une valeur, disons un entier 5, nous pouvons voir cela comme créer un objet (c'est-à-dire une instance) i de classe (c'est-à-dire de type) int. En fait, vous pouvez lire help(int) pour mieux comprendre cela.

Une classe peut aussi avoir des méthodes c'est-à-dire des fonctions définies pour être utilisées seulement avec cette classe. Vous pouvez utiliser ces fonctionnalités seulement avec un objet de cette classe. Par exemple, Python fournit une méthode append pour la classe liste ce qui vous permet d'ajouter un item à la fin de la liste. Par exemple, mylist.append('an item') va ajouter cette chaîne de caractères à la liste mylist. Notez l'utilisation de la notation pointée pour accéder aux méthodes des objets.

Une classe peut aussi avoir des champs qui sont juste des variables définies pour être utilisées dans le cadre de cette classe uniquement. Vous pouvez utiliser ces variables/noms seulement quand vous avez un objet de cette classe. Les champs sont aussi accédés avec la notation pointée, par exemple, mylist.field.

Exemple:

#!/usr/bin/python
# Nom de fichier : using_list.py
 
# Voici ma liste de commissions
shoplist = ['pomme', 'mangue', 'carotte', 'banane']
 
print('J\'ai', len(shoplist), 'objets à acheter.')
 
print('Ces objets sont :', end=' ')
for item in shoplist:
    print(item, end=' ')
 
print('\nJe dois acheter du riz.')
shoplist.append('riz')
print('Ma liste de commissions contient maintenant ', shoplist)
 
print('Je vais trier ma liste maintenant')
shoplist.sort()
print('Ma liste triée  est', shoplist)
 
print('Le premier objet que je vais acheter est', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('J\'ai acheté', olditem)
print('Ma liste de commissions est', shoplist)

Résultat :

   $ python using_list.py
   J'ai 4 objets à acheter.
   Ces objets sont : pomme mangue carotte banane 
   Je dois acheter du riz.
   Ma liste de commissions contient maintenant  ['pomme', 'mangue', 'carotte', 'banane', 'riz']
   Je vais trier ma liste maintenant
   Ma liste triée  est ['banane', 'carotte', 'mangue', 'pomme', 'riz']
   Le premier objet que je vais acheter est banane
   J'ai acheté banane
   Ma liste de commissions est ['carotte', 'mangue', 'pomme', 'riz']

Comment cela fonctionne :

La variable shoplist est une liste pour quelqu'un qui va faire ses courses au marché. Dans shoplist, nous stockons seulement les chaînes de caractères des noms des objets à acheter mais vous pouvez ajouter n'importe quel type d'objet à une liste, incluant des nombres et même d'autres listes.

Nous utilisons aussi la boucle for..in pour itérer les items de la liste. Vous réalisez maintenant qu'une liste est aussi une séquence. La spécificité des séquences sera vue plus tard dans la section dédiée.

Notez l'utilisation du mot-clé end de la fonction print pour indiquer que nous voulons finir l'affichage avec un espace au lieu de l'habituel line break.

Ensuite, nous ajoutons un item à la liste en utilisant la méthode append de l'objet list, comme indiqué précédemment. puis, nous vérifiions que l'item a bien été ajouté à la liste en affichant le contenu de la liste avec l'instruction print qui fait cela proprement. Puis, nous trions la liste avec la méthode sort de la liste. Il est important de comprendre que cette méthode modifie la liste elle-même et ne renvoie pas une liste modifiée - c'est différent de la manière dont les chaînes de caractères fonctionnent. C'est pour cela que nous disons que les listes sont mutables et que les chaînes de caractères sont immuables.

Ensuite, quand nous avons fini d'acheter des objets sur le marché, nous voulons les enlever de la liste. Nous faisons cela avec l'instruction del . Ici, nous indiquons quel élément de la liste nous voulons enlever et l'instruction del le fait pour nous. Nous indiquons que nous voulons enlever le premier élément de la liste et donc nous utilisons del shoplist[0] (souvenez-vous que Python compte à partir de 0).

Si vous voulez connaître toutes les méthodes définies par l'objet list voyez help(list) pour plus de détails.

[edit] Tuple

Les tuples sont utilisés pour contenir des objets multiples. Voyez-les comme des listes, mais sans la fonctionnalité supplémentaire que la classe list vous apporte. Une caractéristique majeure des tuples est qu'ils sont immuables comme les chaînes de caractères, vous ne pouvez pas modifier les tuples.

Les tuples sont définis en indiquant des items séparés par des virgules, avec éventuellement une paire de parenthèses.

Les tuples sont en général utilisés dans des cas où une instruction ou une fonction définie par l'utilisateur peut légitimement supposer que la liste de valeurs, c'est-à-dire le tuple de valeurs, ne changera pas.

Exemple:

#!/usr/bin/python
# Nom de fichier : using_tuple.py
 
zoo = ('python', 'éléphant', 'pingouin') 
#  souvenez-vous, les parenthèses sont optionnelles
print('Le nombre d\'animaux est', len(zoo))
 
new_zoo = ('singe', 'chameau', zoo)
print('le nombre de cages dans le nouveau zoo est', len(new_zoo))
print('Les animaux dans le nouveau zoo sont', new_zoo)
print('Les animaux venant de l\'ancien zoo sont', new_zoo[2])
print('Le dernier animal venant de l\ancien zoo sont', new_zoo[2][2])
print('Le nombre d\'animaux dans le nouveau zoo sont', len(new_zoo)-1+len(new_zoo[2]))

Résultat :

   $ python using_tuple.py
   Le nombre d'animaux est 3
   Le nombre de cages dans le nouveau zoo est 3
   Les animaux dans le nouveau zoo sont ('singe', 'chameau', ('python', 'éléphant', 'pingouin'))
   Les animaux venant de l'ancien zoo sont ('python', 'éléphant', 'pingouin')
   Le dernier animal venant de l'ancien zoo est pingouin
   Le nombre d'animaux dans le nouveau zoo est 5

Comment cela fonctionne :

La variable zoo se réfère à un a tuple d'items. Nous voyons que la fonction len peut être utilisée pour obtenir la longueur du tuple. Cela indique aussi qu'un tuple est également une séquence.

Nous décalons ces animaux vers un nouveau zoo, car l'ancien est maintenant fermé. En conséquence, le tuple new_zoo contient quelques animaux qui étaient déjà là, et les animaux de l'ancien zoo. Retour à la réalité, notez qu'un tuple à l'intérieur d'un tuple ne perd pas son identité.

Nous pouvons accéder les items dans le tuple en indiquant la position de l'item à l'intérieur d'une paire de crochets comme pour les listes. On appelle cela l'opérateur indexant . Nous accédons le troisième item dans new_zoo en indiquant new_zoo[2] et nous accédons le troisième item à l'intérieur du troisième item à l'intérieur du tuple new_zoo en indiquant new_zoo[2][2]. C'est très simple une fois que vous avez compris le principe.

Parenthèses

Bien que les parenthèses soient optionnelles, je préfère toujours les mettre pour indiquer clairement que c'est un tuple, en particulier parce que cela évite l'ambiguïté. Par exemple, print(1,2,3) et print( (1,2,3) ) signifient deux choses différentes - le premier affiche trois nombres alors que le second affiche un tuple (qui contient trois nombres).

Tuple avec 0 ou 1 item

Un tuple vide créé par une paire de parenthèses sans rien à l'intérieur comme myempty = (). Cependant, un tuple avec un seul item n'est pas si simple. Il faut le définir avec une virgule suivi du premier e(et seul) item, afin que Python puisse différencier un tuple d'une paire de parenthèses entourant l'objet dans une expression, c'est-à-dire que vous devez déclarer singleton = (2 , ) si vous voulez un tuple contenant l'item 2.

Note pour les programmeurs Perl

Une liste à l'intérieur d'une list ne perd pas son identité, c'est-à-dire que les listes ne sont pas aplaties comme en Perl. Le même principe s'applique à un tuple à l'intérieur d'un tuple, ou un tuple à l'intérieur d'une liste, ou une liste à l'intérieur d'un tuple, etc. En Python, ils sont juste des objets stockés en utilisant un autre objet, c'est tout.

[edit] Dictionnaire

Un dictionnaire est comme un carnet d'adresses dans lequel vous pouvez trouver une adresse et des renseignements sur une personne avec juste son nom, c'est-à-dire que nous associons des clés (nom) avec des valeurs (détails). Notez que la clé doit être unique, de la même manière que vous ne pouvez pas trouver une information correcte si vous avez deux personnes avec exactement le même nom.

Notez que pour les clés d'un dictionnaire, vous pouvez seulement utiliser des objets immuables (comme des chaînes de caractères), mais vous pouvez utiliser soit des objets immuables ou mutables pour les valeurs d'un dictionnaire. Cela revient à dire que pour les clés, vous devez seulement utiliser des simples objets.

Des paires de clés et valeurs sont spécifiées dans un dictionnaire avec la notation d = {key1 : value1, key2 : value2 }. Notez que les paires de valeurs de clés sont séparées par le caractère deux-points et que les paires sont elle-mêmes séparées par une virgule et que tout cela est entouré d'accolades.

Souvenez-vous que les paires de valeurs de clé dans un dictionnaire ne sont pas ordonnées. Si vous voulez qu'elle soient dans l'ordre, il vous faudra les trier vous-mêmes avant de les utiliser.

Les dictionnaires que vous utiliserez sont des instances/objets de la classe dict .

Exemple:

#!/usr/bin/python
# Nom de fichier : using_dict.py
 
# 'ab' est un raccourci pour address'b'ook
 
ab = {  'Swaroop'   : 'swaroop@swaroopch.com',
        'Larry'     : 'larry@wall.org',
        'Matsumoto' : 'matz@ruby-lang.org',
        'Spammer'   : 'spammer@hotmail.com'
    }
 
print("L'adresse de Swaroop est", ab['Swaroop'])
 
# Destruction d'une paire de valeurs 
del ab['Spammer']
 
print('\nIl y a {0} contacts dans le carnet d\'adresse\n'.format(len(ab)))
 
for name, address in ab.items():
    print('Contact {0} at {1}'.format(name, address))
 
# Adding a key-value pair
ab['Guido'] = 'guido@python.org'
 
if 'Guido' in ab:
    print("\nL'adresse de Guido est", ab['Guido'])

Résultat :

   $ python using_dict.py
   L'adresse de Swaroop est swaroop@swaroopch.com

   Il y a 3 contacts dans le carnet d'adresse

   Contact Swaroop at swaroop@swaroopch.com
   Contact Matsumoto at matz@ruby-lang.org
   Contact Larry at larry@wall.org

   L'adresse de Guido est guido@python.org

Comment cela fonctionne :

Nous créons le dictionnaire ab en utilisant la notation déjà vue. Puis nous accédons les paires de valeurs de clés en indiquant la clé avec l'opérateur d'indexation comme vu dans le contexte de listes et tuples. Observez la simplicité de la syntaxe.

Nous pouvons détruire les paires de valeurs de clés en utilisant notre vieil ami, l'instruction del . Nous indiquons simplement le dictionnaire et l'opérateur d'indexation pour la clé à enlever et nous la passons à l'instruction del . Il n'y a pas besoin de connaître la valeur correspondant à la clé pour cette opération.

Ensuite, nous accédons chaque paire de valeur de clé du dictionnaire avec la méthode items du dictionnaire qui retourne une liste de tuples, chaque tuple contient une paire d'items - la clé suivie de la valeur. Nous retrouvons cette paire et nous l'assignons aux variables name et address correspondantes pour chaque paire en utilisant la boucle for..in et nous affichons ces valeurs dans le block for.

Nous pouvons ajouter des nouvelles paires de valeurs de clés en utilisant juste l'opérateur d'indexation pour accéder une clé et lui assigner cette valeur, comme nous l'avons fait pour Guido dans le cas précédent.

Nous pouvons tester si une clé existe avec l'opérateur in .

Pour la liste des méthodes de la classe dict , voyez help(dict).

Keyword Arguments et Dictionnaires

Sur un autre sujet, si vous avez utilisé des keyword arguments dans vos fonctions, vous avez déjà utilisé des dictionnaires ! Voyez-le ainsi - la paire de valeurs est indiquée par vous dans la liste des paramètres de la définition de la fonction et quand vous accédez les variables à l'intérieur de votre fonction, cela revient juste à accéder une clé dans un dictionnaire (qui est appelé la table des symboles dans la terminologie de conception des compilateurs).

[edit] Séquences

Les listes, tuples et chaînes de caractères sont des exemples de séquences, mais que sont les séquences et qu'il y a-t-il de tellement particulier à leur sujet ?

La principale fonctionnalité est qu'elles ont des test d'appartenance (c'est-à-dire les expressions in et not in ) et les opérations d'indexation. L'opération d' indexation nous permet de rechercher directement un item particulier dans la séquence.

Les trois types de séquences mentionnées au-dessus - listes, tuples et chaînes de caractères, ont aussi une opération de slicing qui nous permet de retrouver un slice de la séquence, c'est-à-dire une partie de la séquence.

Exemple:

#!/usr/bin/python
# Nom de fichier : seq.py
 
shoplist = ['pomme', 'mangue', 'carotte', 'banane']
name = 'swaroop'
 
# Indexation ou opération 'Subscription' operation
print('L\'item 0 est', shoplist[0])
print('L\'item 1 est', shoplist[1])
print('L\'item 2 est', shoplist[2])
print('L\'item 3 est', shoplist[3])
print('L\'item -1 est', shoplist[-1])
print('L\'item -2 est', shoplist[-2])
print('Le caractère 0 est', name[0])
 
# Slicing sur une liste
print('L\'item 1 à 3 est', shoplist[1:3])
print('L\'item 2 jusqu\'à la fin est', shoplist[2:])
print('L\'item 1 à -1 est', shoplist[1:-1])
print('Les items du début à la fin sont', shoplist[:])
 
# Slicing sur une chaîne
print('Les caractères 1 to 3 sont', name[1:3])
print('Les caractères 2 à la fin sont', name[2:])
print('Les caractères 1 à -1 sont', name[1:-1])
print('Les caractères du début à la fin sont', name[:])

Résultat :

   L'item 0 est pomme
   L'item 1 est mangue
   L'item 2 est carotte
   L'item 3 est banane
   L'item -1 est banane
   L'item -2 est carotte
   Le caractère 0 est s
   L'item 1 à 3 est ['mangue', 'carotte']
   L'item 2 jusqu'à la fin est ['carotte', 'banane']
   L'item 1 à -1 est ['mangue', 'carotte']
   Les items du début à la fin sont ['pomme', 'mangue', 'carotte', 'banane']
   Les caractères 1 to 3 sont wa
   Les caractères 2 à la fin sont aroop
   Les caractères 1 à -1 sont waroo
   Les caractères du début à la fin sont swaroop

Comment cela fonctionne :

D'abord, nous voyons comment utiliser des index pour récupérer des items d'une séquence. On appelle aussi cela subscription operation. Quand vous indiquez un nombre dans une séquence avec des square brackets comme montré au-dessus, Python va rechercher l'item correspondant à la position dans cette séquence. Souvenez-vous que Python compte à partir de 0. En conséquence, shoplist[0] cherche le premier item et shoplist[3] cherche le quatrième item dans la séquence shoplist .

L'index peut être une valeur négative à partir de la fin de la séquence. Donc, shoplist[-1] fait référence au dernier item de la séquence et shoplist[-2] récupère l'avant-dernier item de la séquence.

L'opération de slicing est utilisée en indiquant le nom de la séquence suivi par une paire optionnelle de nombres séparés par un caractère deux-points à l'intérieur des square brackets. Notez que ceci est très similaire à l'opération d'indexation utilisée jusque-là . Souvenez-vous que les nombres sont optionnels mais pas le caractère deux-points.

Le premier nombre (avant le deux-points) dans l'opération de slicing fait référence à la position où démarre le slice et le deuxième nombre (après le caractère deux-points) indique où s'arrête le slice. Si le premier nombre n'est pas indiqué, Python va commencer au début de la séquence. Si le deuxième nombre est absent, Python va arrêter à ma fin de la séquence. Notez que le slice renvoyé démarre à ma position de début et va se terminer juste avant la position fin c'est-à-dire que la position de début est incluse dans le slice et la position de fin est exclue de la séquence de slice.

Ainsi, shoplist[1:3] renvoie un slice de la séquence en partant de la position 1, inclut la position 2 mais s'arrête à la position 3 et donc un slice de deux items est retourné. De la même manière, shoplist[:] renvoie une copie de la séquence complète.

Vous pouvez aussi faire du slicing avec des positions négatives. Les nombres négatifs sont utilisés pour des positions à partir de la fin de la séquence. Par exemple, shoplist[:-1] va renvoyer un slice de la séquence qui exclut le dernier item de la séquence mais contient tout le reste.

Vous pouvez aussi fournir un troisième argument pour le slice, qui est le pas du slicing (par défaut, le pas est de 1):

>>> shoplist = ['pomme', 'mangue', 'carotte', 'banane']
>>> shoplist[::1]
['pomme', 'mangue', 'carotte', 'banane']
>>> shoplist[::2]
['pomme', 'carotte']
>>> shoplist[::3]
['pomme', 'banane']
>>> shoplist[::-1]
['banane', 'carotte', 'mangue', 'pomme']

Notez que quand le pas est de 2, nous obtenons les items des positions 0, 2, ... Quand le pas est de 3, nous obtenons les items des position 0, 3, etc.

Essayez diverses combinaisons de slice en utilisant l'interpréteur Python de manière interactive, c'est-à-dire le prompt, afin de voir immédiatement les résultats. Ce qui est chouette avec les séquences, c'est que vous pouvez accéder des tuples, listes et chaînes de caractères de la même manière !

[edit] Set

Les sets sont des simples collections de données sans ordre . Ils sont utilisés quand l'existence d'un objet dans une collection est plus importante que l'ordre ou le nombre de fois qu'il y est.

Avec les sets, vous pouvez tester l'appartenance, si c'est un sous-ensemble d'un autre set, trouver l'intersection entre deux sets, et ainsi de suite.

>>> bri = set(['brésil', 'russie', 'inde'])
>>> 'inde' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('chine')
>>> bric.issuperset(bri)
True
>>> bri.remove('russie')
>>> bri & bric # OU bri.intersection(bric)
{'brésil', 'inde'}

Comment cela fonctionne :

Cet exemple est assez parlant, parce qu'il applique des mathématiques de base apprises à l'école.

[edit] Références

Quand vous créez un objet et y assignez une variable, la variable fait référence seulement à l'objet et ne représente pas l'objet lui-même ! Le nom de variable pointe sur la partie de la mémoire de votre ordinateur où l'objet est stocké. Cela est appelé le binding du nom vers l'objet.

En général, vous n'avez pas besoin de vous en soucier, mais il y a une conséquence subtile à cause des références, quer vous devez connaître :

Exemple:

#!/usr/bin/python
# Nom de fichier : reference.py
 
print('Affectation Simple')
shoplist = ['pomme', 'mangue', 'carotte', 'banane']
maliste = shoplist # mylist est juste un autre nom pointant sur le même objet!
 
del shoplist[0] # j'ai acheté le premier élément, donc je l'enlève de la liste
 
print('La liste de commissions contient', shoplist)
print('maliste contient', maliste)
# notez que shoplist et maliste affichent la même liste sans
# la 'pomme', ce qui confirme qu'ils pointent sur le même objet
 
print('Copie en faisant un slice complet')
maliste = shoplist[:] # On copie en faisant un slice complet
del maliste[0] # On enlève le premier élément
 
print('La liste de commissions contient', shoplist)
print('maliste contient', maliste)
# notez que maintenant les deux listes sont différentes

Résultat :

   $ python reference.py
   Affectation Simple
   La liste de commissions contient ['mangue', 'carotte', 'banane']
   maliste contient ['mangue', 'carotte', 'banane']
   Copie en faisant un slice complet
   La liste de commissions contient ['mangue', 'carotte', 'banane']
   maliste contient ['carotte', 'banane']

Comment cela fonctionne :

L'essentiel des explications est disponible dans les commentaires.

Souvenez-vous que si vous voulez faire une copie d'une liste ou d'une sorte de séquence ou d'objets complexes, (pas des simples objets comme des entiers), alors vous devez utiliser l'opération de slicing pour faire une copie. Si vous voulez juste assigner un nom de variable à un autre nom, les deux font faire référence au même objet, et cela peut poser problème si vous ne faites pas attention.

Note pour les programmeurs Perl

Souvenez-vous qu'une opération d'assignation pour les listes ne crée pas une copie. Vous devez utiliser l'opération de slicing pour faire une copie de la séquence.

[edit] Plus Sur Les Chaînes De Caractères

Nous avons déjà étudié les chaînes de caractères en détail plus tôt. Que pouvons-nous apprendre de plus ? Et bien, savez-vous que les chaînes de caractères sont aussi des objets et ont des méthodes qui font tout, depuis la vérification d'une partie d'une chaîne jusqu'à enlever des espaces !

Les chaînes de caractères que vous utilisez dans les programmes sont toutes des objets de la classe str. Quelques méthodes de cette classe sont mises en évidence dans l'exemple suivant. Pour une liste complète de ces méthodes, voyez help(str).

Exemple:

#!/usr/bin/python
# Nom de fichier : str_methods.py
 
nom = 'Swaroop' # Ceci est un objet de type chaîne 
 
if nom.startswith('Swa'):
    print('Oui, la chaîne commence par "Swa"')
 
if 'a' in nom:
    print('Oui, elle contient la chaîne "a"')
 
if nom.find('war') != -1:
    print('Oui, elle contient la chaîne "war"')
 
delimiter = '_*_'
maliste = ['Brésil', 'Russie', 'Inde', 'Chine']
print(delimiter.join(maliste))

Résultat :

   $ python str_methods.py
   Oui, la chaîne commence par "Swa"
   Oui, elle contient la chaîne "a"
   Oui, elle contient la chaîne "war"
   Brésil_*_Russie_*_Inde_*_Chine

Comment cela fonctionne :

Ici, nous voyons en action de nombreuses méthodes des chaînes de caractères. La méthode startswith est utilisée pour trouver si une chaîne de caractères commence avec la chîne indiquée. L'opérateur in est utilisé pour vérifier si une chaîne donnée fait partie de la chaîne de caractères.

La méthode find est utilisée pour trouver la position d'une chaîne donnée dans la chaîne, ou retourne -1 si elle ne trouve pas sous-chaîne. La classe str a aussi une méthode pour join (joindre) les items d'une séquence, avec la chaîne jouant le rôle de délimiteur entre chaque item de la séquence et retournant une chaîne plus longue.

[edit] Récapitulatif

Nous avons étudié les différentes structures de données disponibles dans Python en détail. ces structures de données seront essentielles pour écrire des programmes de taille raisonnable.

Maintenant que nous possédons l'essentiel des bases de Python, nous allons concevoir et écrire un vrai programme Python.