Dictionnaires
Dictionnaires
Les listes nous permettent d’accéder aux éléments de la liste par indices.
>>> animaux = ['girafe', 'hippopotame', 'singe', 'dahu']
>>> animaux[2]
'singe'
Mais parfois, on aimerais que les indices soient autre chose que des numéros. Des chaînes de caractères, par exemple.
>>> nombre["giraffe"]
3
>>> nombre["singe"]
5
>>> emplacement["giraffe"]
"Cage nord-ouest"
Une telle représentation de l’information est possible avec le dictionnaire.
>>> nombre = {"giraffe":3, "singe":5}
>>> emplacement = {"giraffe":"Cage nord-ouest"}
Dictionnaire
La liste associe à chaque indice une valeur.
Le dictionnaire associe à chaque clé une valeur. Une clé de dictionnaire peut être un chiffre, une chaîne de caractères, un n-tuplet, etc. Mais pas une liste ou un autre dictionnaire. Un dictionnaire est créé en utilisant les accolades {} avec la syntaxe
{cle1: valeur1, cle2: valeur2, …}
Remarque: Les dictionnaires sont un type de base en Python mais est inhabituelle pour d’autre langages de programmation.
Dans ce sens, ils ne sont pas strictement nécessaires. De plus il est possible de simuler un dictionnaire avec des listes (c’est-à-dire écrire un ensemble de fonctions qui remplissent les mêmes fonctions que celle d’un dictionnaire).
Opération sur les dictionnaires
Visualiser tous les exemples sur les dictionnaires. Télécharger l'exemple.
Ajout ou mise à jour de valeur.
>>> nombre['dahu'] = 1
>>> nombre["singe"] = 6
>>> nombre
{'giraffe': 3, 'dahu': 1, 'singe': 6}
Déterminer si une clé existe dans un dictionnaire.
>>> 'singe' in nombre
True
>>> 'ornithorynque' in nombre
False
Obtenir les clés, valeurs ou paires clé valeur comme liste.
>>> nombre.keys()
['giraffe', 'dahu', 'singe']
>>> nombre.values()
[3, 1, 6]
>>> nombre.items()
[('giraffe', 3), ('dahu', 1), ('singe', 6)]
Opération sur les dictionnaires
Compréhension de dictionnaire (très avancé)
Comme pour les listes, une notation « mathématique » compacte existe pour la création de dictionnaires.
# Pour les listes
carres_impairs = [i*i for i in range(10) if i%2 == 1]
# Pour les dictionnaires
ordre = {cara: ord(cara) for cara in 'abcde' if cara != 'd'}
>>> print ordre
{'a': 97, 'c': 99, 'b': 98, 'e': 101}
Classes
Définition de nouveaux types avec classes
Que faire si vos données sont mieux représentées par autre chose que les types en Python?
Dans un sens, vous aurez jamais besoin de d'autre types. Il suffit de suivre quelques convention (par exemple, toujours mettre une certaine variable comme premier paramètre) avec une interprétation implicite de l'emboîtement et indices des données (« ce dictionnaire représente toujours... »).
Pour avoir une déclaration explicite, nous pouvons créer de nouveaux types appelés classes.
class MaClasse:
pass
instance = MaClasse()
Comme l'instruction def pour déclarer des fonctions, class fait simplement définir une nouvelle classe et n'a aucun effet d'exécution immédiate.
Comme les types int, str, list, etc, vous pouvez en avoir plusieurs copies d'une même classe à valeurs différentes, chacune appelée une instance de la classe.
Voir help("class") à l'intérieur de l'interpréteur pour de l'aide.
Attributs et méthodes
Une classe est constituée de
- attributs: un dictionnaire
- méthodes: un regroupement de fonction qui seront notamment utiliser pour modifier ou obtenir de l'information sur des instances de la classe.
Exemple d'attributs avec les nombres complexes qui ont deux attributs: real et imag.
>>> x = complex(1, 2)
>>> x.real
1.0
>>> x.imag
2.0
>>> x = x + 3
>>> x.real
4.0
Les attributs sont accédés et assignés avec la syntaxe nom_de_variable.nom_de_l_attribut.
Remarque: Les fonctions de conversion de types du premier cours étaient des initialisations de variables.
Exemple de méthode:
Nous avons déjà vu beaucoup d'exemples de méthodes avec str, list, dict comme list.append et dict.keys.
Rappel: La deuxième formes d'appel d'une fonction variable.nom_de_fonction(parametre1, parametre2, ...) est un appel à une méthode.
La définition de méthode nous permet de créer de nouvelle fonctions qui sont appelé de cette façon.
La notion de classes fait partie de la "programmation orienté objet". L'intuition est que les instances sont des objets que nous manipulons. Soit en les examinant (attributs), soit en les modifiants (méthodes).
Déclaration d'une classe
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def distance(self, autre_point):
distance_carre = (self.x - autre_point.x)**2 + (self.y - autre_point.y)**2
return distance_carre**0.5
point = Point(10, 20)
print point.x, point.y
point.x += 3
print point.x, point.y
origine = Point(0, 0)
print point.distance(origine)
La forme générale que prends la déclaration d'une classe est la suivante.
class MaClasse:
def __init__(self, parametre1, parametre2, ...):
# Blocs d'instructions
# Inclut typiquement l'initialisation des attributs de l'instance.
def methode1(self, parametre1, ...):
# Bloc d'instructions
def methode2(self, parametre1, ...):
# Bloc d'instructions
instance = MaClasse()
print instance.attribut1
La méthode __init__ est spéciale. Elle est appelée à la création d'une instance. Il y a d'autre méthodes « magiques » semblables, tous de la forme __nom__ (comme __add__, __sub__, __str__, __getitem__) que nous n'allons pas décrire en détail ici (voir p.94-95 des transparents ici pour quelques exemples).
Similarités entre méthodes et fonctions
Le premier paramètre d'une fonction est toujours l'instance de la classe. Par convention, on utilise (presque) toujours self pour le nom de cette variable (mais self a sinon aucune signification spéciale).
Comparer cette fonction avec la méthode distance définie plus haut.
def distance(premier_point, autre_point):
distance_carre = (premier_point.x - autre_point.x)**2 + (premier_point.y - autre_point.y)**2
return distance_carre**0.5
point = Point(10, 20)
origine = Point(0, 0)
print point.distance(origine)
print distance(point, origine)
Ces deux fonctions donnent le même résultat.
Attributs de classes
Vous pouvez aussi avoir des attributs de classes (plutôt que des attributs d'instances) mais c'est plus rarement utilisé.
class MaClasse:
x = 10
chaine = "abc"
print MaClasse.x # 10
MaClasse.x = 20
print MaClasse.x # 20
instance = MaClasse()
print instance.x # 20
instance.x = 30
print MaClasse.x # 20
print instance.x # 30
Les attributs de classes sont
Héritage et polymorphisme (avancé)
Si on veut créer une nouvelle classe qui presque toutes les mêmes méthodes qu'une autre classe, nous pouvons utiliser la syntaxe suivante pour faire hériter la nouvelle classe.
Exemple:
class Rectangle:
def __init__(self, longueur, largeur):
self.longueur = longueur
self.largeur = largeur
def volume(self):
return self.longueur * self.largeur
class TriangleRectangle(Rectangle):
def volume(self):
return self.longueur * self.largeur / 2
rectangle = Rectangle(10, 20)
print rectangle.volume() # 200
triangle = TriangleRectangle(10, 20)
print triangle.volume() # 100
Notez que __init__ n'avait pas besoin d'être redéfinie pour TriangleRectangle.
La syntaxe est
class NouvelleClasse(AncienneClasse):
# Definition des methodes de la nouvelle classe
Il est possible d'appeler les méthode de l'ancienne classe (que nous avons possiblement remplacé) avec AncienneClasse.nom_de_la_methde(parametre1, ...)
|