Metodi privati in Python

1. il modificatore di accesso privato in Python
2. Dichiarare un metodo privato 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__():

class 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.

from personClass import Person

sys.path.append(".")


person = Person("John Doe", 25)

print(person.name, person.age)

Produzione:

John Doe   25

Il metodo __init__() può essere chiamato esplicitamente dopo aver istanziato la classe Person in una variabile per istanziare nuovamente l’oggetto.

Per esempio:

person = Person("John Doe", 25)
person.__init__("Jane Doe", 29)

print(person.name, person.age)

Produzione:

Jane 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.

person = Person("John Doe", 25)
Person.__init__(person, "Jack Sparrow", 46)  # person is the 'self' argument

print(person.name, person.age)

Produzione:

Jack 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.

class 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:

class 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")

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:

employee_1 = Employee("John Doe", 25, "Software Engineer", 40000)

employee_1.work()
employee_1.takeCall()

Produzione:

Employee 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.