Introduction
Cette section présente l'instruction class
et l'idée de création de nouveaux objets.
This tutorial is from open-source community. Access the source code
💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Cette section présente l'instruction class
et l'idée de création de nouveaux objets.
Une technique de programmation dans laquelle le code est organisé comme une collection d'objets.
Un objet est composé de :
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
).
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.
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.
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.
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
.
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.
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
.
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
>>>
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
>>>
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
>>>
Félicitations ! Vous avez terminé le laboratoire sur les classes. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.