Types de données et structures de données

Introduction

Cette section présente les structures de données sous forme de tuples et de dictionnaires.

Types de données primitifs

Python dispose de quelques types de données primitifs :

• Entiers
• Nombres à virgule flottante
• Chaînes de caractères (texte)

Nous avons appris cela dans l'introduction.

Type None

email_address = None

None est souvent utilisé comme valeur de remplacement pour une valeur optionnelle ou manquante. Il évalue à False dans les conditionnels.

if email_address:
    send_email(email_address, msg)

Structures de données

Les programmes réels ont des données plus complexes. Par exemple, des informations sur une position boursière :

100 actions de GOOG à 490,10 $

Ceci est un "objet" avec trois parties :

• Nom ou symbole de l'action ("GOOG", une chaîne de caractères)
• Nombre d'actions (100, un entier)
• Prix (490,10, un nombre à virgule flottante)

Tuples

Un tuple est une collection de valeurs regroupées ensemble.

Exemple :

s = ('GOOG', 100, 490.1)

Parfois, les () sont omis dans la syntaxe.

s = 'GOOG', 100, 490.1

Cas spéciaux (0-tuple, 1-tuple).

t = ()            ## Un tuple vide
w = ('GOOG', )    ## Un tuple à un élément

Les tuples sont souvent utilisés pour représenter des enregistrements ou des structures simples. En général, c'est un seul objet composé de plusieurs parties. Une bonne analogie : Un tuple est comme une seule ligne dans un tableau de base de données.

Le contenu d'un tuple est ordonné (comme un tableau).

s = ('GOOG', 100, 490.1)
name = s[0]                 ## 'GOOG'
shares = s[1]               ## 100
price = s[2]                ## 490.1

Cependant, le contenu ne peut pas être modifié.

>>> s[1] = 75
TypeError: object does not support item assignment

Cependant, vous pouvez créer un nouveau tuple à partir d'un tuple existant.

s = (s[0], 75, s[2])

Emballage de tuples

Les tuples sont davantage destinés à regrouper des éléments liés ensemble dans une seule entité.

s = ('GOOG', 100, 490.1)

Le tuple est ensuite facilement transmis à d'autres parties d'un programme en tant qu'un seul objet.

Dépacage de tuples

Pour utiliser le tuple ailleurs, vous pouvez extraire ses parties dans des variables.

name, shares, price = s
print('Coût', shares * price)

Le nombre de variables à gauche doit correspondre à la structure du tuple.

name, shares = s     ## ERREUR
Traceback (most recent call last):
...
ValueError: too many values to unpack

Tuples vs. Listes

Les tuples ressemblent à des listes en lecture seule. Cependant, les tuples sont le plus souvent utilisés pour un élément unique composé de plusieurs parties. Les listes sont généralement une collection d'éléments distincts, généralement tous du même type.

record = ('GOOG', 100, 490.1)       ## Un tuple représentant un enregistrement dans un portefeuille

symbols = [ 'GOOG', 'AAPL', 'IBM' ]  ## Une liste représentant trois symboles d'action

Dictionnaires

Un dictionnaire est une association de clés à des valeurs. On l'appelle parfois également une table de hachage ou un tableau associatif. Les clés servent d'indices pour accéder aux valeurs.

s = {
    'name': 'GOOG',
  'shares': 100,
    'price': 490.1
}

Opérations courantes

Pour obtenir des valeurs à partir d'un dictionnaire, utilisez les noms de clés.

>>> print(s['name'], s['shares'])
GOOG 100
>>> s['price']
490.10
>>>

Pour ajouter ou modifier des valeurs, utilisez l'affectation avec les noms de clés.

>>> s['shares'] = 75
>>> s['date'] = '6/6/2007'
>>>

Pour supprimer une valeur, utilisez l'instruction del.

>>> del s['date']
>>>

Pourquoi utiliser des dictionnaires?

Les dictionnaires sont utiles lorsqu'il y a beaucoup de valeurs différentes et que ces valeurs peuvent être modifiées ou manipulées. Les dictionnaires rendent votre code plus lisible.

s['price']
## vs
s[2]

Dans les derniers exercices, vous avez écrit un programme qui lisait un fichier de données portfolio.csv. En utilisant le module csv, il est facile de lire le fichier ligne par ligne.

>>> import csv
>>> f = open('portfolio.csv')
>>> rows = csv.reader(f)
>>> next(rows)
['name','shares', 'price']
>>> row = next(rows)
>>> row
['AA', '100', '32.20']
>>>

Bien que la lecture du fichier soit facile, vous voulez souvent faire plus avec les données que simplement les lire. Par exemple, peut-être que vous voulez les stocker et commencer à effectuer des calculs sur elles. Malheureusement, une simple "ligne" de données brutes ne vous donne pas assez pour travailler. Par exemple, même un calcul mathématique simple ne fonctionne pas :

>>> row = ['AA', '100', '32.20']
>>> cost = row[1] * row[2]
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type'str'
>>>

Pour faire plus, vous devez généralement interpréter les données brutes d'une certaine manière et les transformer en un type d'objet plus utile afin que vous puissiez travailler avec plus tard. Deux options simples sont les tuples ou les dictionnaires.

Exercice 2.1 : Les tuples

Au prompt interactif, créez le tuple suivant qui représente la ligne ci-dessus, mais avec les colonnes numériques converties en nombres appropriés :

>>> t = (row[0], int(row[1]), float(row[2]))
>>> t
('AA', 100, 32.2)
>>>

En utilisant cela, vous pouvez maintenant calculer le coût total en multipliant les actions et le prix :

>>> cost = t[1] * t[2]
>>> cost
3220.0000000000005
>>>

Le calcul mathématique est-il cassé en Python? Qu'est-ce que le problème avec la réponse 3220.0000000000005?

C'est un artefact de la carte mémoire à virgule flottante de votre ordinateur qui n'est capable de représenter avec précision que les décimales en base-2, pas en base-10. Pour des calculs même simples impliquant des décimales en base-10, de petites erreurs sont introduites. C'est normal, bien que cela puisse paraître un peu surprenant si vous ne l'avez pas vu auparavant.

Cela se produit dans tous les langages de programmation qui utilisent les décimales à virgule flottante, mais cela est souvent caché lors de l'affichage. Par exemple :

>>> print(f'{cost:0.2f}')
3220.00
>>>

Les tuples sont en lecture seule. Vérifiez-le en essayant de changer le nombre d'actions en 75.

>>> t[1] = 75
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

Bien que vous ne puissiez pas modifier le contenu d'un tuple, vous pouvez toujours créer un nouveau tuple entièrement qui remplace l'ancien.

>>> t = (t[0], 75, t[2])
>>> t
('AA', 75, 32.2)
>>>

Chaque fois que vous réaffectez un nom de variable existant de cette manière, l'ancienne valeur est supprimée. Bien que l'affectation ci-dessus semble que vous modifiez le tuple, vous créez en réalité un nouveau tuple et vous jetez l'ancien.

Les tuples sont souvent utilisés pour empaqueter et extraire des valeurs dans des variables. Essayez ceci :

>>> name, shares, price = t
>>> name
'AA'
>>> shares
75
>>> price
32.2
>>>

Prenez les variables ci-dessus et les repaquetez dans un tuple

>>> t = (name, 2*shares, price)
>>> t
('AA', 150, 32.2)
>>>

Exercice 2.2 : Les dictionnaires comme structure de données

Une alternative au tuple est de créer un dictionnaire à la place.

>>> d = {
        'name' : row[0],
      'shares' : int(row[1]),
        'price'  : float(row[2])
    }
>>> d
{'name': 'AA','shares': 100, 'price': 32.2 }
>>>

Calculez le coût total de cette position :

>>> cost = d['shares'] * d['price']
>>> cost
3220.0000000000005
>>>

Comparez cet exemple avec le même calcul impliquant des tuples ci-dessus. Changez le nombre d'actions en 75.

>>> d['shares'] = 75
>>> d
{'name': 'AA','shares': 75, 'price': 32.2 }
>>>

Contrairement aux tuples, les dictionnaires peuvent être modifiés librement. Ajoutez quelques attributs :

>>> d['date'] = (6, 11, 2007)
>>> d['account'] = 12345
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007), 'account': 12345}
>>>

Exercice 2.3 : Quelques autres opérations sur les dictionnaires

Si vous convertissez un dictionnaire en une liste, vous obtiendrez toutes ses clés :

>>> list(d)
['name','shares', 'price', 'date', 'account']
>>>

De manière similaire, si vous utilisez l'instruction for pour itérer sur un dictionnaire, vous obtiendrez les clés :

>>> for k in d:
        print('k =', k)

k = name
k = shares
k = price
k = date
k = account
>>>

Essayez cette variante qui effectue une recherche en même temps :

>>> for k in d:
        print(k, '=', d[k])

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
account = 12345
>>>

Vous pouvez également obtenir toutes les clés en utilisant la méthode keys() :

>>> keys = d.keys()
>>> keys
dict_keys(['name','shares', 'price', 'date', 'account'])
>>>

keys() est un peu particulier car elle renvoie un objet dict_keys spécial.

C'est une couche sur le dictionnaire original qui vous donne toujours les clés actuelles - même si le dictionnaire change. Par exemple, essayez ceci :

>>> del d['account']
>>> keys
dict_keys(['name','shares', 'price', 'date'])
>>>

Remarquez attentivement que 'account' est disparu de keys même si vous n'avez pas appelé d.keys() à nouveau.

Une manière plus élégante de travailler avec les clés et les valeurs en même temps est d'utiliser la méthode items(). Cela vous donne des tuples (clé, valeur) :

>>> items = d.items()
>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> for k, v in d.items():
        print(k, '=', v)

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
>>>

Si vous avez des tuples tels que items, vous pouvez créer un dictionnaire en utilisant la fonction dict(). Essayez :

>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> d = dict(items)
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007)}
>>>

Sommaire

Félicitations! Vous avez terminé le laboratoire sur les types de données et les structures de données. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.