Loading lesson path
Overview
Encapsulation is about protecting data inside a class. It means keeping data (properties) and methods together in a class, while controlling how the data can be accessed from outside the class. This prevents accidental changes to your data and hides the internal details of how your class works.
In Python, you can make properties private by using a double underscore __ prefix:
__age
class Person:
def __init__(self, name, age):Formula
self.name = name self.__age = age # Private property p1 = Person("Emil", 25)print(p1.name)
print(p1.__age) # This will cause an errorPrivate properties cannot be accessed directly from outside the class.
To access a private property, you can create a getter method:
Use a getter method to access a private property: class Person:
def __init__(self, name, age):
self.name = name self.__age = age def get_age(self):
return self.__age p1 = Person("Tobias", 25)
print(p1.get_age())To modify a private property, you can create a setter method.The setter method can also validate the value before setting it:
Use a setter method to change a private property: class Person:
def __init__(self, name, age):
self.name = name self.__age = age def get_age(self):
return self.__age def set_age(self, age):if age > 0:
self.__age = age else:
print("Age must be positive")Formula
p1 = Person("Tobias", 25)print(p1.get_age())
p1.set_age(26)
print(p1.get_age())Internal implementation can change without affecting external code
You have full control over how data is accessed and modified
Use encapsulation to protect and validate data: class Student:
def __init__(self, name):
self.name = name self.__grade = 0 def set_grade(self, grade):
if 0 <= grade <= 100:
self.__grade = grade else:
print("Grade must be between 0 and 100")
def get_grade(self):
return self.__grade def get_status(self):
if self.__grade >= 60:
return "Passed"
else:
return "Failed"Formula
student = Student("Emil")student.set_grade(85)
print(student.get_grade())
print(student.get_status())Python also has a convention for protected properties using a single underscore _ prefix:
class Person:
def __init__(self, name, salary):Formula
self.name = name self._salary = salary # Protected property p1 = Person("Linus", 50000)print(p1.name)
print(p1._salary) # Can access, but shouldn't_ is just a convention. It tells other programmers that the property is intended for internal use, but Python doesn't enforce this restriction.
You can also make methods private using the double underscore prefix: