Flash cards
Review the key moves
What is the main idea behind Python Encapsulation?
Lesson checks
Practice each idea before moving on
Short Mimo-style checks built from this lesson's code, terms, and sequence.
Which statement best captures the main point of this lesson?
Put the learning moves in the order that makes the concept easiest to apply.
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.
Private Properties
In Python, you can make properties private by using a double underscore __ prefix:
__ageNote
Private properties cannot be accessed directly from outside the class.
Get Private Property Value
To access a private property, you can create a getter method:
Example
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())Set Private Property Value
To modify a private property, you can create a setter method.
The setter method can also validate the value before setting it:
Example
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")
p1 = Person("Tobias", 25)
print(p1.get_age())
p1.set_age(26)
print(p1.get_age())Why Use Encapsulation?
Encapsulation provides several benefits
- Data Protection: Prevents accidental modification of data
- Validation: You can validate data before setting it
- Flexibility: Internal implementation can change without affecting external code
- Control: You have full control over how data is accessed and modified
Example
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"
student = Student("Emil")
student.set_grade(85)
print(student.get_grade())
print(student.get_status())Protected Properties
Python also has a convention for protected properties using a single underscore _ prefix:
Example
class Person:
def __init__(self, name, salary):
self.name = name
self._salary = salary # Protected property
p1 = Person("Linus", 50000)
print(p1.name)
print(p1._salary) # Can access, but shouldn'tNote
A single underscore _ is just a convention. It tells other programmers that the property is intended for internal use, but Python doesn't enforce this restriction.
Private Methods
You can also make methods private using the double underscore prefix:
Example
class Calculator:
def __init__(self):
self.result = 0
def __validate(self, num):
if not isinstance(num, (int, float)):
return False
return True
def add(self, num):
if self.__validate(num):
self.result += num
else:
print("Invalid number")
calc = Calculator()
calc.add(10)
calc.add(5)
print(calc.result)
# calc.__validate(5) # This would cause an errorNote
Just like private properties with double underscores, private methods cannot be called directly from outside the class. The __validate method can only be used by other methods inside the class.
Name Mangling
Name mangling is how Python implements private properties and methods.
When you use double underscores __ , Python automatically renames it internally by adding _ClassName in front.
For example, age becomes _Personage .
Example
class Person:
def __init__(self, name, age):
self.name = name
self.__age = age
p1 = Person("Emil", 30)
# This is how Python mangles the name:
print(p1._Person__age) # Not recommended!Note
While you can access private properties using the mangled name, it's not recommended. It defeats the purpose of encapsulation.