Modificadores de acceso en Python: público, privado y protegido

Requisitos previos: guión bajo (_) en Python , variables privadas en Python

Varios lenguajes orientados a objetos como C++, Java, Python controlan las modificaciones de acceso que se utilizan para restringir el acceso a las variables y métodos de la clase. La mayoría de los lenguajes de programación tienen tres formas de modificadores de acceso, que son Público , Protegido y Privado en una clase.
Python usa el símbolo ‘_’ para determinar el control de acceso para un miembro de datos específico o una función miembro de una clase. Los especificadores de acceso en Python tienen un papel importante que desempeñar en la protección de los datos contra el acceso no autorizado y en la prevención de su explotación.
Una clase en Python tiene tres tipos de modificadores de acceso:

• Modificador de acceso público
• Modificador de acceso protegido
• Modificador de acceso privado

Modificador de acceso público:

Los miembros de una clase que se declaran públicos son fácilmente accesibles desde cualquier parte del programa. Todos los miembros de datos y funciones miembro de una clase son públicos de forma predeterminada. 

# program to illustrate public access modifier in a class
 
class Geek:
      
     # constructor
     def __init__(self, name, age):
           
           # public data members
           self.geekName = name
           self.geekAge = age
 
     # public member function     
     def displayAge(self):
           
           # accessing public data member
           print("Age: ", self.geekAge)
 
# creating object of the class
obj = Geek("R2J", 20)
 
# accessing public data member
print("Name: ", obj.geekName)
 
# calling public member function of the class
obj.displayAge()

Name:  R2J
Age:  20

En el programa anterior, geekName y geekAge son miembros de datos públicos y el método displayAge() es una función de miembro público de la clase Geek. Se puede acceder a estos miembros de datos de la clase Geek desde cualquier parte del programa.

Modificador de acceso protegido:

Los miembros de una clase que se declaran protegidos solo son accesibles para una clase derivada de ella. Los miembros de datos de una clase se declaran protegidos agregando un único símbolo de guión bajo ‘_’ antes del miembro de datos de esa clase. 

# program to illustrate protected access modifier in a class
 
# super class
class Student:
    
     # protected data members
     _name = None
     _roll = None
     _branch = None
    
     # constructor
     def __init__(self, name, roll, branch): 
          self._name = name
          self._roll = roll
          self._branch = branch
    
     # protected member function  
     def _displayRollAndBranch(self):
 
          # accessing protected data members
          print("Roll: ", self._roll)
          print("Branch: ", self._branch)
 
 
# derived class
class Geek(Student):
 
       # constructor
       def __init__(self, name, roll, branch):
                Student.__init__(self, name, roll, branch)
         
       # public member function
       def displayDetails(self):
                   
                 # accessing protected data members of super class
                print("Name: ", self._name)
                   
                 # accessing protected member functions of super class
                self._displayRollAndBranch()
 
# creating objects of the derived class       
obj = Geek("R2J", 1706256, "Information Technology")
 
# calling public member functions of the class
obj.displayDetails()

Name:  R2J
Roll:  1706256
Branch:  Information Technology

En el programa anterior, _name, _roll y _branch son miembros de datos protegidos y el método _displayRollAndBranch() es un método protegido de la superclase Student. El método displayDetails() es una función de miembro público de la clase Geek que se deriva de la clase Student, el método displayDetails() en la clase Geek accede a los miembros de datos protegidos de la clase Student. 

Modificador de acceso privado:

Los miembros de una clase que se declaran privados son accesibles solo dentro de la clase, el modificador de acceso privado es el modificador de acceso más seguro. Los miembros de datos de una clase se declaran privados agregando un símbolo de guión bajo doble ‘__’ antes del miembro de datos de esa clase. 

# program to illustrate private access modifier in a class
 
class Geek:
    
     # private members
     __name = None
     __roll = None
     __branch = None
 
     # constructor
     def __init__(self, name, roll, branch): 
          self.__name = name
          self.__roll = roll
          self.__branch = branch
 
     # private member function 
     def __displayDetails(self):
           
           # accessing private data members
           print("Name: ", self.__name)
           print("Roll: ", self.__roll)
           print("Branch: ", self.__branch)
    
     # public member function
     def accessPrivateFunction(self):
            
           # accessing private member function
           self.__displayDetails() 
 
# creating object   
obj = Geek("R2J", 1706256, "Information Technology")
 
# calling public member function of the class
obj.accessPrivateFunction()

Name:  R2J
Roll:  1706256
Branch:  Information Technology

En el programa anterior, __name, __roll y __branch son miembros privados, el método __displayDetails() es una función miembro privada (solo se puede acceder a ellas dentro de la clase) y el método accessPrivateFunction() es una función miembro pública de la clase Geek que puede ser se accede desde cualquier lugar dentro del programa. El método accessPrivateFunction() accede a los miembros privados de la clase Geek.
 

A continuación se muestra un programa para ilustrar el uso de los tres modificadores de acceso anteriores (público, protegido y privado) de una clase en Python: 

# program to illustrate access modifiers of a class
 
# super class
class Super:
     
     # public data member
     var1 = None
 
     # protected data member
     _var2 = None
      
     # private data member
     __var3 = None
     
     # constructor
     def __init__(self, var1, var2, var3): 
          self.var1 = var1
          self._var2 = var2
          self.__var3 = var3
     
    # public member function  
     def displayPublicMembers(self):
  
          # accessing public data members
          print("Public Data Member: ", self.var1)
        
     # protected member function  
     def _displayProtectedMembers(self):
  
          # accessing protected data members
          print("Protected Data Member: ", self._var2)
      
     # private member function  
     def __displayPrivateMembers(self):
  
          # accessing private data members
          print("Private Data Member: ", self.__var3)
 
     # public member function
     def accessPrivateMembers(self):    
           
          # accessing private member function
          self.__displayPrivateMembers()
  
# derived class
class Sub(Super):
  
      # constructor
       def __init__(self, var1, var2, var3):
                Super.__init__(self, var1, var2, var3)
           
      # public member function
       def accessProtectedMembers(self):
                 
                # accessing protected member functions of super class
                self._displayProtectedMembers()
  
# creating objects of the derived class    
obj = Sub("Geeks", 4, "Geeks !")
 
# calling public member functions of the class
obj.displayPublicMembers()
obj.accessProtectedMembers()
obj.accessPrivateMembers()
 
# Object can access protected member
print("Object is accessing protected member:", obj._var2)
 
# object can not access private member, so it will generate Attribute error
#print(obj.__var3)

Public Data Member:  Geeks
Protected Data Member:  4
Private Data Member:  Geeks !

En el programa anterior, el método accessProtectedMembers() es una función miembro pública de la clase Sub accede al método _displayProtectedMembers() que es una función miembro protegida de la clase Super y el método accessPrivateMembers() es una función miembro pública de la clase Super que accede al método __displayPrivateMembers() que es una función miembro privada de la clase Super.