Programmation orientée objet en Python (OOP) : Tutoriel

Instancier des objets

Pour instancier un objet, tapez le nom de la classe, suivi de deux parenthèses. Vous pouvez l'assigner à une variable pour garder une trace de l'objet.

ozzy = Dog()

Et imprimez-la :

print(ozzy)

<__main__.Dog object at 0x111f47278>

Ajouter des attributs à une classe

Après avoir imprimé ozzy, il est clair que cet objet est un chien. Mais vous n'avez pas encore ajouté d'attributs. Donnons un nom et un âge à la classe Dog en la réécrivant :

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

Vous pouvez constater que la fonction prend maintenant deux arguments après self: name et age. Ceux-ci sont ensuite assignés respectivement à self.name et self.age. Vous pouvez maintenant créer un nouvel objet ozzy avec un nom et un âge :

ozzy = Dog("Ozzy", 2)

Pour accéder aux attributs d'un objet en Python, vous pouvez utiliser la notation point. Pour ce faire, saisissez le nom de l'objet, suivi d'un point et du nom de l'attribut.

print(ozzy.name)

print(ozzy.age)

Ozzy
2

Ces éléments peuvent également être combinés dans une phrase plus élaborée :

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")

Ozzy is 2 year(s) old.

La fonction str() est utilisée ici pour convertir l'attribut age, qui est un entier, en une chaîne de caractères, afin que vous puissiez l'utiliser dans la fonction print().

Définir des méthodes dans une classe

Maintenant que vous avez une classe Dog, elle a un nom et un âge, que vous pouvez suivre, mais elle ne fait rien en réalité. C'est là que les méthodes d'instance entrent en jeu. Vous pouvez réécrire la classe pour y inclure une méthode bark(). Remarquez que le mot-clé def est à nouveau utilisé, ainsi que l'argument self.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

La méthode bark peut maintenant être appelée en utilisant la notation point, après avoir instancié un nouvel objet ozzy. La méthode doit imprimer "bark bark !" à l'écran. Remarquez les parenthèses (curly brackets) dans .bark(). Ils sont toujours utilisés lors de l'appel d'une méthode. Ils sont vides dans ce cas, puisque la méthode bark() ne prend aucun argument.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Vous vous souvenez de la façon dont vous avez imprimé ozzy plus tôt ? Le code ci-dessous implémente maintenant cette fonctionnalité dans la classe Dog, avec la méthode doginfo(). Vous instanciez ensuite des objets avec différentes propriétés et vous appelez la méthode sur ces objets.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

Comme vous pouvez le constater, vous pouvez appeler la méthode doginfo() sur des objets avec la notation point. La réponse dépend maintenant de l'objet Dog sur lequel vous appelez la méthode.

Comme les chiens vieillissent, il serait bon que vous puissiez adapter leur âge en conséquence. Ozzy vient d'avoir 3 ans, changeons son âge.

ozzy.age = 3

print(ozzy.age)

3

Il suffit d'attribuer une nouvelle valeur à l'attribut. Vous pouvez également implémenter cette méthode sous la forme d'une méthode birthday() dans la classe Dog :

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

Maintenant, vous n'avez plus besoin de modifier manuellement l'âge du chien. Chaque fois que c'est son anniversaire, il vous suffit d'appeler la méthode birthday(). 

Passer des arguments aux méthodes

Vous souhaitez que nos chiens aient un compagnon. Cela devrait être facultatif, car tous les chiens ne sont pas aussi sociables. Jetez un coup d'œil à la méthode setBuddy() ci-dessous. Il prend self, comme d'habitude, et buddy comme arguments. Dans ce cas, buddy sera un autre objet Dog. Définissez l'attribut self.buddy sur buddy, et l'attribut buddy.buddy sur self. Cela signifie que la relation est réciproque ; vous êtes le copain de votre copain. Dans ce cas, Filou sera le copain d'Ozzy, ce qui signifie qu'Ozzy devient automatiquement le copain de Filou. Vous pourriez également définir ces attributs manuellement au lieu de définir une méthode, mais cela nécessiterait plus de travail (écrire deux lignes de code au lieu d'une) chaque fois que vous voulez définir un copain. Remarquez qu'en Python, vous n'avez pas besoin de préciser le type de l'argument. S'il s'agissait de Java, ce serait obligatoire.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

Vous pouvez maintenant appeler la méthode avec la notation point et lui transmettre un autre objet Dog. Dans ce cas, le copain d'Ozzy sera Filou :

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)

Si vous voulez maintenant obtenir des informations sur le copain d'Ozzy, vous pouvez utiliser deux fois la notation par points : Une première fois pour faire référence au copain d'Ozzy, et une seconde fois pour faire référence à son attribut.

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

Remarquez que cela peut également être fait pour Filou.

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

Les méthodes de l'ami peuvent également être appelées. L'argument self qui est transmis à doginfo() est maintenant ozzy.buddy, qui est filou.

 ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Exemple de POO en Python

Un exemple de cas où la programmation orientée objet en Python peut s'avérer utile est notre site Python For Finance : Algorithmic Trading tutoriel. Nous y expliquons comment mettre en place une stratégie de trading pour un portefeuille d'actions. La stratégie de trading est basée sur la moyenne mobile du prix d'une action. Si signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] est rempli, un signal est créé. Ce signal est une prédiction de l'évolution future du cours de l'action. Dans le code ci-dessous, vous verrez qu'il y a d'abord une initialisation, suivie du calcul de la moyenne mobile et de la génération du signal. Comme il ne s'agit pas d'un code orienté objet, c'est un gros morceau qui est exécuté en une seule fois. Notez que nous utilisons aapl dans l'exemple, qui est le symbole boursier d'Apple. Si vous vouliez faire cela pour une autre action, vous devriez réécrire le code.

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

Dans une approche orientée objet, vous ne devez écrire qu'une seule fois le code d'initialisation et de génération des signaux. Vous pouvez ensuite créer un nouvel objet pour chaque action sur laquelle vous souhaitez calculer une stratégie et appeler la méthode generate_signals(). Remarquez que le code OOP est très similaire au code ci-dessus, avec l'ajout de self.

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

Vous pouvez désormais simplement instancier un objet, avec les paramètres que vous souhaitez, et générer des signaux pour lui.

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

Faire de même pour une autre action devient très facile. Il s'agit simplement d'instancier un nouvel objet avec un symbole boursier différent.

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

Programmation orientée objet en Python : Synthèse

Nous avons abordé quelques-uns des principaux concepts de la POO en Python. Vous savez maintenant comment déclarer des classes et des méthodes, instancier des objets, définir leurs attributs et appeler des méthodes d'instance. Ces compétences vous seront utiles au cours de votre future carrière en tant que data scientist. Si vous souhaitez développer les concepts clés dont vous avez besoin pour travailler davantage avec Python, ne manquez pas de consulter notre cours Python intermédiaire pour la science des données.

Avec la POO, votre code deviendra de plus en plus complexe au fur et à mesure que votre programme s'étoffera. Vous aurez différentes classes, sous-classes, objets, héritage, méthodes d'instance, etc. Vous devez veiller à ce que votre code soit correctement structuré et lisible. Pour ce faire, il est conseillé de suivre des modèles de conception. Il s'agit de principes de conception qui représentent un ensemble de lignes directrices permettant d'éviter une mauvaise conception. Ils représentent chacun un problème spécifique qui revient souvent dans la POO de Python et décrivent la solution à ce problème, qui peut ensuite être utilisée de manière répétée. Ces schémas de conception OOP peuvent être classés en plusieurs catégories : les schémas de création, les schémas structurels et les schémas comportementaux. Un exemple de modèle de création est le singleton, qui doit être utilisé lorsque vous voulez vous assurer qu'une seule instance d'une classe peut être créée. Un itérateur Python, qui est utilisé pour parcourir en boucle tous les objets d'une collection, est un exemple de modèle comportemental.