Programmazione orientata agli oggetti in Python: guida completa

Istanziare oggetti

Per istanziare un oggetto, digita il nome della classe, seguito da due parentesi tonde. Puoi assegnarlo a una variabile per tenere traccia dell’oggetto.

ozzy = Dog()

E stampalo:

print(ozzy)

<__main__.Dog object at 0x111f47278>

Aggiungere attributi a una classe

Dopo aver stampato ozzy, è chiaro che questo oggetto è un cane. Ma non hai ancora aggiunto alcun attributo. Diamo alla classe Dog un nome e un’età riscrivendola:

class Dog:

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

Ora vedi che la funzione accetta due argomenti dopo self: name e age. Questi vengono poi assegnati rispettivamente a self.name e self.age. Ora puoi creare un nuovo oggetto ozzy con un nome e un’età:

ozzy = Dog("Ozzy", 2)

Per accedere agli attributi di un oggetto in Python, puoi usare la dot notation. Si fa digitando il nome dell’oggetto, seguito da un punto e dal nome dell’attributo

print(ozzy.name)

print(ozzy.age)

Ozzy
2

Questo può anche essere combinato in una frase più articolata:

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

Ozzy is 2 year(s) old.

La funzione str() viene usata qui per convertire l’attributo age, che è un intero, in una stringa, così puoi usarlo nella funzione print().

Definire metodi in una classe

Ora che hai una classe Dog, ha un nome e un’età di cui puoi tenere traccia, ma in realtà non fa nulla. Qui entrano in gioco i metodi di istanza. Puoi riscrivere la classe per includere ora un metodo bark(). Nota come si usa di nuovo la keyword def, così come l’argomento self.

class Dog:

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

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

Il metodo bark ora può essere chiamato usando la dot notation, dopo aver istanziato un nuovo oggetto ozzy. Il metodo dovrebbe stampare "bark bark!" a schermo. Nota le parentesi in .bark(). Si usano sempre quando si chiama un metodo. In questo caso sono vuote, perché il metodo bark() non accetta argomenti.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Ricordi come hai stampato ozzy prima? Il codice sotto ora implementa questa funzionalità nella classe Dog, con il metodo doginfo(). Poi istanzi alcuni oggetti con proprietà diverse e chiami il metodo su di essi.

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.

Come vedi, puoi chiamare il metodo doginfo() sugli oggetti con la dot notation. La risposta ora dipende su quale oggetto Dog stai chiamando il metodo.

Poiché i cani invecchiano, sarebbe utile poter aggiornare di conseguenza la loro età. Ozzy ha appena compiuto 3 anni, quindi cambiamo la sua età.

ozzy.age = 3

print(ozzy.age)

3

È semplice come assegnare un nuovo valore all’attributo. Potresti anche implementarlo come metodo birthday() nella 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

Ora non devi più cambiare manualmente l’età del cane. Ogni volta che è il suo compleanno, puoi semplicemente chiamare il metodo birthday(). 

Passare argomenti ai metodi

Vorresti che i nostri cani avessero un amico. Questo dovrebbe essere opzionale, dato che non tutti i cani sono così socievoli.

Dai un’occhiata al metodo setBuddy() qui sotto. Accetta come argomenti self, come al solito, e buddy. In questo caso, buddy sarà un altro oggetto Dog. Imposta l’attributo self.buddy su buddy, e l’attributo buddy.buddy su self.

Questo significa che la relazione è reciproca; tu sei l’amico del tuo amico. In questo caso, Filou sarà l’amico di Ozzy, il che significa che Ozzy diventa automaticamente l’amico di Filou.

Potresti anche impostare questi attributi manualmente invece di definire un metodo, ma richiederebbe più lavoro (scrivere due righe di codice invece di una) ogni volta che vuoi impostare un amico.

Nota che in Python non devi specificare di che tipo è l’argomento. Se fosse Java, sarebbe richiesto.

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

Ora puoi chiamare il metodo con la dot notation e passargli un altro oggetto Dog. In questo caso, l’amico di Ozzy sarà Filou:

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

ozzy.setBuddy(filou)

Se ora vuoi ottenere qualche informazione sull’amico di Ozzy, puoi usare la dot notation due volte: la prima per riferirti all’amico di Ozzy, e la seconda per riferirti al suo attributo.

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

Filou
8

Nota come questo si possa fare anche per Filou.

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

Ozzy
2

Si possono anche chiamare i metodi dell’amico. L’argomento self che viene passato a doginfo() ora è ozzy.buddy, cioè filou.

ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Esempio di OOP in Python

Un esempio in cui la programmazione orientata agli oggetti in Python può tornare utile è il nostro tutorial Python per la finanza: trading algoritmico. In esso spieghiamo come impostare una strategia di trading per un portafoglio azionario.

La strategia di trading si basa sulla media mobile del prezzo di un’azione. Se signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] è soddisfatta, viene creato un segnale. Questo segnale è una previsione per la variazione futura del prezzo del titolo.

Nel codice qui sotto, vedrai che c’è prima un’inizializzazione, seguita dal calcolo della media mobile e dalla generazione del segnale. Poiché non è codice orientato agli oggetti, è solo un unico blocco grande che viene eseguito in una volta.

Nota che usiamo aapl nell’esempio, che è il ticker azionario di Apple. Se volessi farlo per un’azione diversa, dovresti riscrivere il codice.

# 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)

Con un approccio orientato agli oggetti, devi scrivere il codice di inizializzazione e generazione dei segnali solo una volta.

Puoi poi creare un nuovo oggetto per ogni titolo su cui vuoi calcolare una strategia e chiamare su di esso il metodo generate_signals(). Nota che il codice OOP è molto simile al codice sopra, con l’aggiunta di 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'] = self.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

Ora puoi semplicemente istanziare un oggetto con i parametri che vuoi e generare i segnali per esso.

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

Fare lo stesso per un altro titolo diventa molto semplice. È solo questione di istanziare un nuovo oggetto con un simbolo diverso.

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

Considerazioni finali

Abbiamo coperto alcuni dei principali concetti OOP in Python. Ora sai come dichiarare classi e metodi, istanziare oggetti, impostarne gli attributi e chiamare metodi di istanza. Queste competenze torneranno utili nella tua futura carriera da data scientist.

Per un approccio più moderno alla definizione delle classi, dai un’occhiata alle data class di Python, che riducono il boilerplate. Se vuoi approfondire i concetti chiave necessari per lavorare ulteriormente con Python, non perderti il nostro corso Python intermedio.

Con l’OOP, il tuo codice crescerà in complessità man mano che il programma diventa più grande. Avrai classi diverse, sottoclassi, oggetti, ereditarietà, metodi di istanza e altro. Per scenari di ereditarietà complessi, scopri l’ereditarietà multipla e super().