Public, private, and protected attributes and methods are used to control the accessibility and visibility of class members. These access modifiers help in encapsulating and organizing the code within a class. **Public Attributes/Methods:** Public attributes and methods are accessible from anywhere, both within the class and outside the class. By default, all attributes and methods in Python are public unless specified otherwise. Let's take an example of a `Person` class with a public attribute and method:
class Person:
def __init__(self, name):
self.name = name
def greet(self):
return f"Hello, my name is {self.name}!"In this code, the `name` attribute and the `greet` method are public. They can be accessed and used from anywhere, both within and outside the `Person` class.
person = Person("John")
print(person.name) # Output: John
print(person.greet()) # Output: Hello, my name is John!John Hello, my name is John!
In this code, we create an object of the `Person` class called `person`. We can access the public attribute `name` and call the public method `greet()` using the `person` object. **Private Attributes/Methods:** Private attributes and methods are intended to be used only within the class where they are defined. They are not intended to be accessed or modified directly from outside the class. Let's modify the `Person` class to include private attributes and methods:
class Person:
def __init__(self, name):
self.__name = name
def __greet(self):
return f"Hello, my name is {self.__name}!"In this code, the `__name` attribute and the `__greet` method are private. They are intended to be used only within the `Person` class.
person = Person("John")
print(person.__name) # Error: AttributeError: 'Person' object has no attribute '__name'
print(person.__greet()) # Error: AttributeError: 'Person' object has no attribute '__greet'---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
Cell In[4], line 2
1 person = Person("John")
----> 2 print(person.__name) # Error: AttributeError: 'Person' object has no attribute '__name'
3 print(person.__greet()) # Error: AttributeError: 'Person' object has no attribute '__greet'
AttributeError: 'Person' object has no attribute '__name'In this code, attempting to access the private attribute `__name` or call the private method `__greet()` from outside the class will result in an `AttributeError`. Private attributes and methods are not intended to be accessed directly. **Protected Attributes/Methods:** Protected attributes and methods are intended to be used within the class where they are defined and within its subclasses. Although they can be accessed from outside the class, it is conventionally recommended to treat them as non-public and accessed only within the class hierarchy. Let's modify the `Person` class to include protected attributes and methods:
class Person:
def __init__(self, name):
self._name = name
def _greet(self):
return f"Hello, my name is {self._name}!"
class Student(Person):
def study(self):
return f"{self._name} is studying!"In this code, the `_name` attribute and the `_greet` method are protected. They can be accessed within the Person class and its subclasses, such as the Student class.
student = Student("Alice")
print(student._name) # Output: Alice
print(student._greet()) # Output: Hello, my name is Alice!
print(student.study()) # Output: Alice is studying!Alice Hello, my name is Alice! Alice is studying!
In this code, we can access the protected attribute `_name` and call the protected method `_greet()` from outside the class. However, it is conventionally recommended to treat protected attributes and methods as non-public and accessed only within the class hierarchy. It's important to note that the use of access modifiers in Python is primarily a convention, and the interpreter does not enforce strict access control. The leading underscore `_` is a signal to indicate the intended visibility of an attribute or method.