Création d'objets nouveaux avec des classes : Maîtrise de la programmation orientée objet

Introduction

Cette section présente l'instruction class et l'idée de création de nouveaux objets.

Programmation Orientée Objet (POO)

Une technique de programmation dans laquelle le code est organisé comme une collection d'objets.

Un objet est composé de :

Données. Attributs
Comportement. Méthodes qui sont des fonctions appliquées à l'objet.

Vous avez déjà utilisé un peu de POO au cours de ce programme.

Par exemple, en manipulant une liste.

>>> nums = [1, 2, 3]
>>> nums.append(4)      ## Méthode
>>> nums.insert(1,10)   ## Méthode
>>> nums
[1, 10, 2, 3, 4]        ## Données
>>>

nums est une instance d'une liste.

Les méthodes (append() et insert()) sont attachées à l'instance (nums).

L'instruction `class`

Utilisez l'instruction class pour définir un nouvel objet.

class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.health = 100

    def move(self, dx, dy):
        self.x += dx
        self.y += dy

    def damage(self, pts):
        self.health -= pts

En résumé, une classe est un ensemble de fonctions qui effectuent diverses opérations sur des soi-disant instances.

Instances

Les instances sont les vrais objets que vous manipulez dans votre programme.

Elles sont créées en appelant la classe comme une fonction.

>>> a = Player(2, 3)
>>> b = Player(10, 20)
>>>

a et b sont des instances de Player.

Insistance : L'instruction class n'est que la définition (elle ne fait rien d'elle-même). Elle est similaire à la définition d'une fonction.

Données d'instance

Chaque instance a ses propres données locales.

>>> a.x
2
>>> b.x
10

Ces données sont initialisées par __init__().

class Player:
    def __init__(self, x, y):
        ## Toute valeur stockée dans `self` est une donnée d'instance
        self.x = x
        self.y = y
        self.health = 100

Il n'y a pas de restrictions quant au nombre total ou au type d'attributs stockés.

Méthodes d'instance

Les méthodes d'instance sont des fonctions appliquées à des instances d'un objet.

class Player:
  ...
    ## `move` est une méthode
    def move(self, dx, dy):
        self.x += dx
        self.y += dy

L'objet lui-même est toujours passé en premier argument.

>>> a.move(1, 2)

## associe `a` à `self`
## associe `1` à `dx`
## associe `2` à `dy`
def move(self, dx, dy):

Par convention, l'instance est appelée self. Cependant, le nom réel utilisé n'est pas important. L'objet est toujours passé en premier argument. Il n'est que du style de programmation Python d'appeler cet argument self.

Portée des classes

Les classes ne définissent pas une portée de noms.

class Player:
 ...
    def move(self, dx, dy):
        self.x += dx
        self.y += dy

    def left(self, amt):
        move(-amt, 0)       ## NON. Appelle une fonction `move` globale
        self.move(-amt, 0)  ## OUI. Appelle la méthode `move` ci-dessus.

Si vous voulez opérer sur une instance, vous la référencez toujours explicitement (par exemple, self).

À partir de cet ensemble d'exercices, nous commençons à apporter une série de modifications au code existant des sections précédentes. Il est crucial d'avoir une version fonctionnelle de l'Exercice 3.18 pour commencer. Si vous n'en avez pas, veuillez travailler à partir du code de solution trouvé dans le répertoire Solutions/3_18. Il est possible de le copier.

Exercice 4.1 : Objets en tant que structures de données

Dans les sections 2 et 3, nous avons travaillé avec des données représentées sous forme de tuples et de dictionnaires. Par exemple, une position d'action pourrait être représentée comme un tuple comme ceci :

s = ('GOOG',100,490.10)

ou comme un dictionnaire comme ceci :

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

Vous pouvez même écrire des fonctions pour manipuler de telles données. Par exemple :

def cost(s):
    return s['shares'] * s['price']

Cependant, à mesure que votre programme grandit, vous pouvez vouloir créer une meilleure organisation. Ainsi, une autre approche pour représenter les données serait de définir une classe. Créez un fichier appelé stock.py et définissez une classe Stock qui représente une seule position d'action. Que les instances de Stock aient des attributs name, shares et price. Par exemple :

>>> import stock
>>> a = stock.Stock('GOOG',100,490.10)
>>> a.name
'GOOG'
>>> a.shares
100
>>> a.price
490.1
>>>

Créez quelques autres objets Stock et manipulez-les. Par exemple :

>>> b = stock.Stock('AAPL', 50, 122.34)
>>> c = stock.Stock('IBM', 75, 91.75)
>>> b.shares * b.price
6117.0
>>> c.shares * c.price
6881.25
>>> stocks = [a, b, c]
>>> stocks
[<stock.Stock object at 0x37d0b0>, <stock.Stock object at 0x37d110>, <stock.Stock object at 0x37d050>]
>>> for s in stocks:
     print(f'{s.name:>10s} {s.shares:>10d} {s.price:>10.2f}')

... regardez la sortie...
>>>

Une chose à souligner ici est que la classe Stock fonctionne comme une usine pour créer des instances d'objets. Fondamentalement, vous l'appelez comme une fonction et elle crée un nouvel objet pour vous. De plus, il est important de souligner que chaque objet est distinct - chacun d'entre eux a ses propres données qui sont séparées des autres objets qui ont été créés.

Un objet défini par une classe est quelque peu similaire à un dictionnaire - juste avec une syntaxe un peu différente. Par exemple, au lieu d'écrire s['name'] ou s['price'], vous écrivez maintenant s.name et s.price.

✨ Vérifier la solution et pratiquer

Exercice 4.2 : Ajout de méthodes

Avec les classes, vous pouvez attacher des fonctions à vos objets. Ce sont appelées des méthodes et sont des fonctions qui opèrent sur les données stockées à l'intérieur d'un objet. Ajoutez une méthode cost() et sell() à votre objet Stock. Elles devraient fonctionner comme ceci :

>>> import stock
>>> s = stock.Stock('GOOG', 100, 490.10)
>>> s.cost()
49010.0
>>> s.shares
100
>>> s.sell(25)
>>> s.shares
75
>>> s.cost()
36757.5
>>>

✨ Vérifier la solution et pratiquer

Exercice 4.3 : Création d'une liste d'instances

Essayez les étapes suivantes pour créer une liste d'instances de Stock à partir d'une liste de dictionnaires. Ensuite, calculez le coût total :

>>> import fileparse
>>> with open('portfolio.csv') as lines:
...     portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str,int,float])
...
>>> portfolio = [ stock.Stock(d['name'], d['shares'], d['price']) for d in portdicts]
>>> portfolio
[<stock.Stock object at 0x10c9e2128>, <stock.Stock object at 0x10c9e2048>, <stock.Stock object at 0x10c9e2080>,
 <stock.Stock object at 0x10c9e25f8>, <stock.Stock object at 0x10c9e2630>, <stock.Stock object at 0x10ca6f748>,
 <stock.Stock object at 0x10ca6f7b8>]
>>> sum([s.cost() for s in portfolio])
44671.15
>>>

Exercice 4.4 : Utilisation de votre classe

Modifiez la fonction read_portfolio() dans le programme report.py de sorte qu'elle lise un portefeuille dans une liste d'instances de Stock comme indiqué dans l'Exercice 4.3. Une fois que vous avez fait cela, corrigez tout le code dans report.py et pcost.py de sorte qu'il fonctionne avec des instances de Stock au lieu de dictionnaires.

Indice : Vous n'avez pas besoin d'apporter de grandes modifications au code. Vous devriez principalement changer l'accès au dictionnaire tel que s['shares'] en s.shares.

Vous devriez être capable d'exécuter vos fonctions comme avant :

>>> import pcost
>>> pcost.portfolio_cost('portfolio.csv')
44671.15
>>> import report
>>> report.portfolio_report('portfolio.csv', 'prices.csv')
      Name     Shares      Price     Change
---------- ---------- ---------- ----------
        AA        100       9.22     -22.98
       IBM         50     106.28      15.18
       CAT        150      35.46     -47.98
      MSFT        200      20.89     -30.34
        GE         95      13.48     -26.89
      MSFT         50      20.89     -44.21
       IBM        100     106.28      35.84
>>>

✨ Vérifier la solution et pratiquer

Sommaire

Félicitations ! Vous avez terminé le laboratoire sur les classes. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.