Métodos privados en Python
![Métodos privados en Python](/img/Python/feature-image---python-private-method.webp)
Este tutorial demuestra cómo declarar, manipular y utilizar métodos privados en Python.
private
es una palabra clave para un tipo de modificador de acceso utilizado en lenguajes de programación orientados a objetos. Los modificadores de acceso limitan la visibilidad de una función o variable hasta cierto punto. Declarar su función / variable como privada limita el acceso solo a la clase que la encapsula.
Una comparación de la vida real con un método privado sería un sistema de iluminación para el hogar. El interruptor de luz y la bombilla son como métodos públicos porque la persona tiene acceso directo y visibilidad a ellos. Al mismo tiempo, los cables eléctricos dentro de la goma protectora son los métodos privados, ya que generalmente no son visibles a menos que se manipulen, pero aún hacen su trabajo sin ser atendidos en su mayor parte.
El Modificador de acceso privado en Python
En Python, los métodos privados son métodos a los que no se puede acceder fuera de la clase en la que están declarados ni de ninguna otra clase base.
Para declarar un método privado en Python, inserte guiones bajos dobles al principio del nombre del método.
El método __init__()
Un método privado notable en Python es el método __init__()
, que se usa como un constructor de clase para un objeto de clase. Este método se llama cuando se crea una instancia de un objeto de una clase, según los argumentos del método.
Por ejemplo, declare una clase Person
con dos campos y un método __init__()
:
class Person:
name = ""
age = 0
def __init__(self, n, a):
self.name = n
self.age = a
Ahora, para acceder al método privado __init__()
fuera de la clase, lo necesitaríamos para acceder a él desde el objeto de la propia clase después de instanciarlo.
Por ejemplo, en otro archivo en el mismo directorio, cree una instancia de la clase Person
y llame al constructor usando el nombre de la clase.
from personClass import Person
sys.path.append(".")
person = Person("John Doe", 25)
print(person.name, person.age)
Producción :
John Doe 25
sys.path.append()
con el directorio de la ruta de la cadena de la clase que desea importar como argumento. En este caso, ambos archivos residen en la misma carpeta, por lo que un punto .
es suficiente. Luego, importe la clase (Person
) del archivo .py
(personClass.py
).El método __init__()
se puede llamar explícitamente después de instanciar la clase Person
en una variable para volver a instanciar el objeto.
Por ejemplo:
person = Person("John Doe", 25)
person.__init__("Jane Doe", 29)
print(person.name, person.age)
Producción :
Jane Doe 29
Además, el método __init()__
se puede llamar explícitamente llamándolo desde la propia clase. Aunque para este enfoque, necesitaría poner explícitamente el primer parámetro self
en los argumentos.
person = Person("John Doe", 25)
Person.__init__(person, "Jack Sparrow", 46) # person is the 'self' argument
print(person.name, person.age)
Producción :
Jack Sparrow 46
Todos estos enfoques retienen la propiedad privada del método __init__()
.
Ahora que este método incorporado ha sido analizado. Pasemos a implementar nuestros propios métodos privados en una clase y diferenciar su acceso de un método público.
Declarar un método privado en Python
Para declarar un método privado, anteponga el método en cuestión con dos guiones bajos __
. De lo contrario, se tratará como un método público predeterminado.
Extendamos la clase Person
del ejemplo anterior y creemos una subclase Employee
que base su constructor en la clase Person
.
Además, cree dos nuevos métodos dentro de la clase person, un método público y otro privado.
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")
Ahora, cree la clase o subclase derivada Employee
que extiende 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")
Person
.En esta clase, los métodos work()
y takeCall()
llaman externamente a las clases walk()
y __call()
de la clase padre Person
, respectivamente.
El otro método llama externamente a un método público y el otro llama a un método privado desde su clase principal. Veamos cómo funciona este comportamiento cuando lo ejecutamos.
Por ejemplo, dadas las declaraciones de clase anteriores:
employee_1 = Employee("John Doe", 25, "Software Engineer", 40000)
employee_1.work()
employee_1.takeCall()
Producción :
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 llamada al método work()
se ejecuta con éxito, imprimiendo las declaraciones del método work()
y walk()
. Sin embargo, la llamada a takeCall()
desencadena un AttributeError
porque no reconoce el método __call()
de la clase Person
como un método de la clase Employee
. La extensión de una clase a otra clase no incluye sus propios métodos privados en la extensión.
En resumen, los métodos privados en Python se declaran prefijando un método con dos guiones bajos, __
. La declaración de métodos privados permite que un método se reserve exclusivamente para la clase de encapsulación. Una clase que extiende otra clase con un método privado no heredará esos métodos y provocará un error si intenta acceder a ellos.
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