Programmazione orientata agli oggetti di Python

In questo articolo, imparerai a conoscere la programmazione orientata agli oggetti (OOP) in Python e i suoi concetti di base attraverso esempi.

Introduzione a Python OOP

Python è un linguaggio di programmazione multiparadigma. Questo significa che supporta diversi metodi di programmazione.

Un metodo popolare per risolvere problemi di programmazione è creare oggetti. Questo è noto come programmazione orientata agli oggetti (OOP).

Un oggetto ha due caratteristiche:

• Proprietà

• Comportamento

Facciamo un esempio:

Un pappagallo è un oggetto,

• Nome, età, colore sono proprietà

• Cantare, ballare sono comportamenti

Il concetto di OOP in Python si concentra sulla creazione di codice riutilizzabile. Questo concetto è anche noto come DRY (Don't Repeat Yourself) - Non ripetere te stesso.

In Python, il concetto di OOP segue alcune regole fondamentali:

Classe (class)

La classe è il piano dell'oggetto.

Possiamo considerare la classe come uno schizzo di un pappagallo con etichetta. Contiene tutte le informazioni su nome, colore, dimensioni, ecc. Sulla base di queste descrizioni, possiamo studiare il pappagallo. In questo caso, il pappagallo è un oggetto.

Un esempio della classe di pappagallo può essere:

class　Parrot:
　　　　pass

In questo caso, usiamo la parola chiave class per definire una classe vuota Parrot. Costruiamo l'esempio dalla classe. Un esempio è un oggetto specifico creato da una classe specifica.

Oggetto (Object)

Un oggetto (esempio) è un esempio della classe. Durante la definizione della classe, si definisce solo la descrizione dell'oggetto. Pertanto, non viene assegnata memoria o archiviazione.

Un esempio di oggetto della classe di pappagallo può essere:

obj = Parrot()

In questo caso, obj è un oggetto della classe Parrot.

Supponiamo di avere dettagli su un pappagallo. Di seguito, mostreremo come costruire la classe e l'oggetto del pappagallo.

Esempio 1: Creazione di classi e oggetti in Python

class　Parrot:
　　　　Commento: Proprietà della classe
　　　　species = "uccello"
　　　　# Proprietà di esempio
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
Esempio di istanziazione della classe Parrot
blu = Parrot("Passero", 10)
woo = Parrot("Pappagallo", 15)
# Accesso alle proprietà di classe
print("Il passero è {}".format(blu.__class__.species))
print("Il pappagallo è anche {}".format(woo.__class__.species))
# Accesso alle proprietà degli esempi
print("{} ha {} anni".format(blu.name, blu.age))
print("{} ha {} anni".format(woo.name, woo.age))

Quando eseguiamo il programma, l'output sarà:

Il passero è un uccello
Il pappagallo è anche un uccello
Il passero ha 10 anni
Il pappagallo ha 15 anni

Nel programma sopra, creiamo un oggetto chiamatoParrotla nostra classe. Poi, definiamo le proprietà. Le proprietà sono le caratteristiche degli oggetti.

Poi, creiamoParrotEsempi di classe. Ecco,blu和wooè il riferimento (valore) al nostro nuovo oggetto.

Poi, usiamo class .species per accedere alle proprietà di classe. Le proprietà di classe di tutti gli esempi della classe sono le stesse. Allo stesso modo, usiamo blu.name e blu.age per accedere alle proprietà degli esempi. Ma per ogni esempio della classe, le proprietà degli esempi sono diverse.

Per ulteriori informazioni su classi e oggetti, vai aClassi e oggetti Python.

Metodi

I metodi sono funzioni definite nel corpo della classe. Servono per definire il comportamento degli oggetti.

Esempio 2: Creare metodi in Python

class　Parrot:
　　　　
　　　　# Proprietà di esempio
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　
　　　　# Metodi di esempio
　　　　def sing(self, song):
　　　　　　　　return "{} canta {}".format(self.name, song)
　　　　def dance(self):
　　　　　　　　return "{} sta ballando".format(self.name)
# Oggetto di esempio
blu = Parrot("Blu", 10)
# Chiamata ai nostri metodi di esempio
print(blu.sing("'Happy'"))
print(blu.dance())

Quando eseguiamo il programma, l'output sarà:

Blu canta 'Happy'
Blu sta ballando

Nel programma sopra, abbiamo definito due metodi, ovvero sing() e dance(). Il motivo per cui si chiamano metodi di esempio è che vengono chiamati sull'oggetto di esempio (cioè blu).

Ereditarietà

L'ereditarietà è un metodo per creare una nuova classe utilizzando l'esistente senza modificare i dettagli dell'attuale. La nuova classe formata è una classe derivata (o sotto-classe). Allo stesso modo, la classe esistente è una classe base (o padre).

Esempio 3: Ereditarietà in Python

# Clase base
class Uccello:
　　　　
　　　　def __init__(self):
　　　　　　　　print("L'uccello è pronto")
　　　　def whoisThis(self):
　　　　　　　　print("Uccello")
　　　　def　swim(self):
　　　　　　　　print("Nuota più veloce")
# Sotto-classe
class Penguin(Uccello):
　　　　def __init__(self):
　　　　　　　　# Chiamare la funzione super()
　　　　　　　　super().__init__()
　　　　　　　　print("Il pinguino è pronto")
　　　　def whoisThis(self):
　　　　　　　　print("Pinguino")
　　　　def run(self):
　　　　　　　　print("Corre più veloce")
peggy　=　Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Quando eseguiamo questo programma, l'output sarà:

L'uccello è pronto
Il pinguino è pronto
Pinguino
Nuota più veloce
Corre più veloce

Nel programma sopra, abbiamo creato due classi, ovveroUccello(Classe padre) ePenguin(Classe figlia). La classe figlia eredita le funzionalità della classe padre. Possiamo vedere questo nel metodo swim(). La classe figlia ha nuovamente modificato il comportamento della classe padre. Possiamo vedere questo nel metodo whoisThis(). Inoltre, abbiamo creato un nuovo metodo run() per estendere le funzionalità della classe padre.

Inoltre, utilizziamo la funzione super() prima del metodo init(). Questo perché vogliamo portare il contenuto del metodo init() dalla classe padre alla classe figlia.

Encapsulazione

Utilizzando l'OOP in Python, possiamo limitare l'accesso ai metodi e alle variabili. Questo aiuta a prevenire la modifica diretta dei dati (chiamata encapsulation). In Python, usiamo l'underscore come prefisso per rappresentare attributi privati, ovvero singolo "_" o doppio "__".

Esempio 4: Encapsulation dei dati in Python

class Computer:
　　　　def __init__(self):
　　　　　　　　self.__maxprice = 900
　　　　def sell(self):
　　　　　　　　print("Prezzo: 1000")
　　　　def setMaxPrice(self, price):
　　　　　　　　self.__maxprice = price
c = Computer()
c.sell()
# Modificare il prezzo
c.__maxprice = 1000
c.sell()
# Utilizzare la funzione setter
c.setMaxPrice(1000)
c.sell()

Quando eseguiamo questo programma, l'output sarà:

Prezzo: 900
Prezzo: 900
Prezzo: 1000

在上面的程序中，我们定义了Computer类。我们使用__init__()方法存储计算机的最高售价。我们试图修改价格。但是，我们无法更改它，因为Python将__maxprice视为私有属性。要更改该值，我们使用了setter函数，即setMaxPrice()，它以price为参数。

多态性

多态性是一种功能（在OOP中），可以将公共接口用于多种形式（数据类型）。

假设我们需要给一个形状上色，有多个形状选项（矩形，正方形，圆形）。但是，我们可以使用相同的方法为任何形状着色。这个概念称为多态。

示例5：在Python中使用多态

class　Parrot:
　　　　def　fly(self):
　　　　　　　　print("鹦鹉会飞")
　　　　
　　　　def　swim(self):
　　　　　　　　print("鹦鹉不会游泳")
class　Penguin:
　　　　def　fly(self):
　　　　　　　　print("企鹅不会飞")
　　　　
　　　　def　swim(self):
　　　　　　　　print("企鹅会游泳")
#　通用接口
def　flying_test(bird):
　　　　bird.fly()
#示例化对象
blu　=　Parrot()
peggy　=　Penguin()
#　传递对象
flying_test(blu)
flying_test(peggy)

当我们运行上面的程序时，输出将是：

鹦鹉会飞
企鹅不会飞

在上面的程序中，我们定义了两个类Parrot和Penguin。它们每个都有通用的fly()方法。但是，它们的功能不同。为了允许多态，我们创建了通用接口，即flying_test()可以接受任何对象的函数。然后，我们在flying_test()函数中传递了blu和peggy对象，它有效地运行了。

面向对象编程的要点：

• 让编程变得简单而有效。

• 类是可共享的，因此可以重复使用代码。

• 让编程人员的生产力提高

• 通过数据抽象，数据是安全的。