Metodi privati in Python
Questo tutorial mostra come dichiarare, manipolare e utilizzare metodi privati in Python.
private
è una parola chiave per un tipo di modificatore di accesso utilizzato nei linguaggi di programmazione orientati agli oggetti. I modificatori di accesso limitano in una certa misura la visibilità di una funzione o di una variabile. Dichiarare la propria funzione/variabile come privata limita l’accesso solo alla classe che la incapsula.
Un confronto nella vita reale con un metodo privato sarebbe un sistema di illuminazione domestica. L’interruttore della luce e la lampadina sono come metodi pubblici perché la persona ha accesso diretto e visibilità ad essi. Allo stesso tempo, i fili elettrici all’interno della gomma protettiva sono i metodi privati poiché generalmente non sono visibili se non manomessi, ma continuano a svolgere il loro lavoro senza essere per la maggior parte curati.
il modificatore di accesso privato in Python
In Python, i metodi privati sono metodi a cui non è possibile accedere al di fuori della classe in cui è dichiarato né a nessun’altra classe base.
Per dichiarare un metodo privato in Python, inserisci i doppi caratteri di sottolineatura all’inizio del nome del metodo.
il metodo __init__()
Un notevole metodo privato in Python è il metodo __init__()
, che viene utilizzato come costruttore di classi per un oggetto di classe. Questo metodo viene chiamato quando viene istanziato un oggetto di una classe, a seconda degli argomenti del metodo.
Ad esempio, dichiara una classe Person
con due campi e un metodo __init__()
:
pythonCopyclass Person:
name = ""
age = 0
def __init__(self, n, a):
self.name = n
self.age = a
Ora, per accedere al metodo privato __init__()
al di fuori della classe, avremmo bisogno di accedervi dall’oggetto della classe stessa dopo averlo istanziato.
Ad esempio, in un altro file nella stessa directory, creare un’istanza della classe Person
e chiamare il costruttore utilizzando il nome della classe.
pythonCopyfrom personClass import Person
sys.path.append(".")
person = Person("John Doe", 25)
print(person.name, person.age)
Produzione:
textCopyJohn Doe 25
sys.path.append()
con la directory del percorso della stringa della classe che si desidera importare come argomento. In questo caso, entrambi i file risiedono nella stessa cartella, quindi un punto .
è sufficiente. Successivamente, importa la classe (Person
) dal file .py
(personClass.py
).Il metodo __init__()
può essere chiamato esplicitamente dopo aver istanziato la classe Person
in una variabile per istanziare nuovamente l’oggetto.
Per esempio:
pythonCopyperson = Person("John Doe", 25)
person.__init__("Jane Doe", 29)
print(person.name, person.age)
Produzione:
textCopyJane Doe 29
Inoltre, il metodo __init()__
può essere chiamato esplicitamente chiamandolo dalla classe stessa. Sebbene per questo approccio, dovresti inserire esplicitamente il primo parametro self
negli argomenti.
pythonCopyperson = Person("John Doe", 25)
Person.__init__(person, "Jack Sparrow", 46) # person is the 'self' argument
print(person.name, person.age)
Produzione:
textCopyJack Sparrow 46
Tutti questi approcci mantengono la proprietà privata del metodo __init__()
.
Ora che questo metodo integrato è stato sezionato. Passiamo all’implementazione concreta dei nostri metodi privati in una classe e alla differenziazione del suo accesso da un metodo pubblico.
Dichiarare un metodo privato in Python
Per dichiarare un metodo privato, premettere al metodo in questione il doppio carattere di sottolineatura __
. In caso contrario, verrà trattato come un metodo pubblico predefinito.
Estendiamo la classe Person
dell’esempio precedente e creiamo una sottoclasse Employee
che basa il suo costruttore sulla classe Person
.
Inoltre, crea due nuovi metodi all’interno della classe person, un metodo pubblico e uno privato.
pythonCopyclass Person:
name = ""
age = 0
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print("Walking")
def __call(self):
print("Taking a call")
Ora, crea la classe o sottoclasse derivata Employee
che estende Person
:
pythonCopyclass Employee(Person):
occupation = "Unemployed"
salary = 0
def __init__(self, name, age, occupation, salary):
Person.__init__(self, name, age)
self.occupation = occupation
self.salary = salary
def work(self):
print("Employee is working")
self.walk()
def takeCall(self):
self.__call()
print("Employee is taking a call")
Person
.In questa classe, i metodi work()
e takeCall()
chiamano esternamente le classi walk()
e __call()
dalla classe genitore Person
, rispettivamente.
L’altro metodo chiama esternamente un metodo pubblico e l’altro chiama un metodo privato dalla classe padre. Vediamo come funziona questo comportamento quando lo eseguiamo.
Ad esempio, date le dichiarazioni di classe sopra:
pythonCopyemployee_1 = Employee("John Doe", 25, "Software Engineer", 40000)
employee_1.work()
employee_1.takeCall()
Produzione:
textCopyEmployee is working
Walking
Traceback (most recent call last):
File "python/demo.py", line 35, in <module>
employee_1.takeCall()
File "python/demo.py", line 29, in takeCall
self.__call()
AttributeError: 'Employee' object has no attribute '_Employee__call'
La chiamata al metodo work()
viene eseguita con successo, stampando le istruzioni del metodo work()
e walk()
. Tuttavia, la chiamata a takeCall()
attiva un AttributeError
perché non riconosce il metodo __call()
della classe Person
come metodo della classe Employee
. L’estensione di una classe a un’altra classe non include i propri metodi privati nell’estensione.
In sintesi, i metodi privati in Python sono dichiarati anteponendo un metodo con due caratteri di sottolineatura, __
. La dichiarazione di metodi privati consente di riservare un metodo esclusivamente alla classe incapsulante. Una classe che estende un’altra classe con un metodo privato non erediterà quei metodi e attiverà un errore se tenta di accedervi.
Skilled in Python, Java, Spring Boot, AngularJS, and Agile Methodologies. Strong engineering professional with a passion for development and always seeking opportunities for personal and career growth. A Technical Writer writing about comprehensive how-to articles, environment set-ups, and technical walkthroughs. Specializes in writing Python, Java, Spring, and SQL articles.
LinkedIn