Encapsulation kwenye pyton
1. Encapsulation ni nini?
Encapsulation ni dhana ya kuficha data ya ndani ya object ili isiweze kufikiwa moja kwa moja kutoka nje ya class.
-
Hii inamaanisha kuwa property au method iliyo ndani ya class haiwezi kufikiwa au kubadilishwa moja kwa moja kutoka nje.
-
Kwa kutumia encapsulation, tunaweza kudhibiti jinsi data inavyopatikana au kubadilishwa kupitia mbinu (methods) maalum.
-
Lengo kuu ni:
-
Kulinda data dhidi ya mabadiliko yasiyotarajiwa.
-
Kuweka mipaka ya ufikiaji ili kuboresha usalama wa programu.
2. Kwanini Tunahitaji Encapsulation?
-
Ulinzi wa Data: Inawezesha kudhibiti jinsi property na method za object zinavyofikiwa au kubadilishwa.
-
Kupunguza Makosa: Inazuia mabadiliko yasiyoidhinishwa kwenye data.
-
Rahisi Kudhibiti: Programu inakuwa rahisi kuelewa, kudumisha, na kufanya marekebisho bila kuvunja sehemu nyingine.
-
Usalama: Huzuia ufikiaji wa moja kwa moja wa data muhimu kutoka nje ya class.
3. Viwango vya Ufikiaji (Access Levels)
Ili kufanikisha encapsulation, tunatumia viwango vya ufikiaji vya property na method kwenye class. Python hutoa viwango vitatu vya msingi:
a) Public
-
Property na method zinazoonekana na kufikiwa moja kwa moja kutoka nje ya class.
-
Kwa kawaida attribute zinakuwa ni public by default.
Mfano:
class Example:
def __init__(self):
self.data = "Public Data" # Public
obj = Example()
print(obj.data) # Inaweza kufikiwa moja kwa moja
b) Protected
-
Property na method zinazofikiwa ndani ya class husika na class zilizorithi (subclasses). Kuhusu class zinazorithi tutajifunza mbeleni.
-
Hutangulizwa na alama ya underscore moja _.
class Example:
def __init__(self):
self.data = "Protected Data" # Private attribute
# Kufikia private attribute moja kwa moja nje ya class
obj = Example()
print(obj.data)
Katika mfano huo tumeweza kuprint attribute data bila ya tatizo nje ya class. Huu ni mfano wa public. Lakini sasa hebu tufanye attribute data kuwa protected.
Mfano
class Example:
def __init__(self):
self._data = "Protected Data" # Private attribute
# Kufikia private attribute moja kwa moja nje ya class
obj = Example()
print(obj._data)
Pia kuna namna ambavyo protected inaweza kutumika lakini sio njia inayoshauriwa kutumia yaani haipendezi.
Mfano:class Example:
def __init__(self):
self._data = "Protected Data" # Protected
obj = Example()
print(obj._data) # Inaweza kufikiwa lakini haipendekezwi
Mfano wa kurithi protected
class Parent:
def __init__(self):
self._data = "Protected Data" # Protected attribute
def display_data(self):
print(f"Data from Parent: {self._data}")
class Child(Parent):
def modify_data(self, new_data):
self._data = new_data # Accessing and modifying protected attribute
print(f"Data modified in Child: {self._data}")
# Kutengeneza object ya Child class
child_obj = Child()
# Kufikia na kuonyesha protected attribute kupitia parent method
child_obj.display_data() # Output: Data from Parent: Protected Data
# Kufikia na kubadilisha protected attribute kupitia child method
child_obj.modify_data("New Protected Data") # Output: Data modified in Child: New Protected Data
# Kuhakikisha mabadiliko yanadumu
child_obj.display_data() # Output: Data from Parent: New Protected Data
c) Private
-
Property na method ambazo haziwezi kufikiwa moja kwa moja kutoka nje ya class.
-
Hutangulizwa na alama ya underscore mbili __.
Mfano:
class Example:
def __init__(self):
self.__data = "Private Data" # Private
obj = Example()
# print(obj.__data) # Hii itatoa error
Hata hivyo, Python inaruhusu "name mangling" ili kufikia property private kwa njia isiyo rasmi:
print(obj._Example__data) # Inaweza kufikiwa, lakini haipendekezwi
4. Getter na Setter
Getter na setter hutumika kudhibiti jinsi data ya private property inavyopatikana na kubadilishwa.
-
Getter: Method inayotumika kupata thamani ya private attribute.
-
Setter: Method inayotumika kubadilisha thamani ya private property kwa udhibiti maalum. Ufupi wa maneno ni kuwa setter inatumika ku set value kwenye attribute
Mfano wa Getter na Setter:
class BankAccount:
def __init__(self, balance):
self.__balance = balance # Private
def get_balance(self): # Getter
return self.__balance
def set_balance(self, amount): # Setter
if amount > 0:
self.__balance = amount
else:
print("Amount must be positive.")
# Matumizi
account = BankAccount(1000)
print(account.get_balance()) # 1000
account.set_balance(1500)
print(account.get_balance()) # 1500
Wacha tuone mfano mwingine, jinsi ambavyo tutatumia setter na getter kwenye class ya student
class Student:
def __init__(self, name, age):
self.__name = name
self.__age = age
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def set_age(self, age):
if age > 0:
self.__age = age
else:
print("Age must be positive.")
student = Student("Amina", 20)
print(student.get_name()) # Amina
print(student.get_age()) # 20
student.set_age(25)
print(student.get_age()) # 25
5. Faida za Encapsulation
-
Ulinzi wa Data: Huzuia data kubadilishwa moja kwa moja kutoka nje ya class.
-
Kuboresha Usalama: Inazuia ufikiaji wa moja kwa moja wa data nyeti.
-
Rahisi Kudumisha: Mabadiliko katika muundo wa data yanaweza kufanywa bila kuathiri sehemu nyingine za programu.
-
Udhibiti Bora: Inawezesha kuweka sheria kuhusu jinsi data inavyobadilishwa.
7. Muhimu Kumbuka
-
Encapsulation ni msingi wa OOP unaosaidia kulinda data na kurahisisha usimamizi wa programu.
-
Tumia getter na setter unapohitaji udhibiti maalum wa ufikiaji wa property.
-
Epuka kubadili private property moja kwa moja hata kama inawezekana kwa kutumia "name mangling."
8. Maswali ya Kujitathmini
-
Kwa nini ni muhimu kutumia getter na setter badala ya kufikia property moja kwa moja?
-
Je, ni wakati gani tunahitaji encapsulation kwenye programu?
-
Ni tofauti gani kati ya viwango vya public, protected, na private?
Kwa mazoezi zaidi, jaribu kubuni programu inayohusisha udhibiti wa data nyeti kama nambari za akaunti au nywila za watumiaji.
