Kurs Python · Moduł 3: Programowanie obiektowe
Enkapsulacja - ochrona siedlisk
W tej lekcji11
Witaj ponownie! Tu Darwin, dziś kluczowa lekcja o bezpieczeństwie danych.
Wyobraź sobie, że prowadzisz katalog gatunków zagrożonych. Dane o lokalizacji rzadkich zwierząt są wrażliwe - nie chcesz, aby kłusownicy mieli do nich bezpośredni dostęp! Potrzebujesz kontrolowanego dostępu, walidacji, ochrony.
W OOP ten mechanizm to enkapsulacja (encapsulation) - ukrywanie szczegółów implementacji i ochrona danych przed nieautoryzowanym dostępem!
Czym jest enkapsulacja?
Enkapsulacja to jeden z 4 filarów OOP, który polega na:
- Grupowaniu danych i metod w jednej klasie
- Ukrywaniu szczegółów implementacji
- Kontrolowaniu dostępu do danych przez metody publiczne
Analogia Safari: Wrażliwe dane o lokalizacji gatunków zagrożonych są chronione - dostęp tylko dla autoryzowanego personelu, z logowaniem każdej zmiany!
# BEZ enkapsulacji - niebezpieczne!
class Species:
def __init__(self, name, population):
self.name = name
self.population = population # Publiczne - każdy może zmienić!
lion = Species("Lew", 500)
lion.population = -999999 # Nikt nie zatrzyma tego błędu!
# Z enkapsulacją - bezpieczne!
class ProtectedSpecies:
def __init__(self, name, population):
self.name = name
self.__population = population # Prywatne!
def set_population(self, value):
"""Kontrolowany dostęp z walidacją"""
if value < 0:
raise ValueError("Populacja nie może być ujemna!")
self.__population = value
def get_population(self):
return self.__population
lion = ProtectedSpecies("Lew", 500)
# lion.__population = -999 # Bez błędu, ale tworzy NOWY atrybut; prywatne __population się nie zmienia
lion.set_population(550) # Działa - walidowane!Konwencje dostępu w Pythonie
Python używa konwencji nazewniczych do oznaczania poziomów dostępu:
| Konwencja | Znaczenie | Przykład |
|---|---|---|
name | Publiczny - dostęp z każdego miejsca | self.name |
_name | Chroniony - tylko klasa i podklasy | self._internal_id |
__name | Prywatny - tylko wewnątrz klasy | self.__password |
UWAGA: W Pythonie to są konwencje, nie twarde ograniczenia! Python ufa programiście.
Atrybuty publiczne
Domyślnie wszystkie atrybuty są publiczne - dostępne z każdego miejsca:
class Animal:
def __init__(self, name, age):
self.name = name # Publiczny
self.age = age # Publiczny
lion = Animal("Simba", 3)
# Pełny dostęp
print(lion.name) # "Simba"
lion.age = 4 # Można zmienić
print(lion.age) # 4Użyj publicznych atrybutów gdy:
- Dane są bezpieczne do bezpośredniej modyfikacji
- Nie potrzebujesz walidacji
- To część publicznego API klasy
Atrybuty chronione - _single_underscore
Konwencja: Atrybut z jednym podkreśleniem (_name) oznacza "chroniony" - używaj tylko wewnątrz klasy i w podklasach.
class Species:
def __init__(self, name):
self.name = name # Publiczny
self._internal_id = 12345 # Chroniony - konwencja!
def _calculate_risk(self):
"""Metoda chroniona - konwencja"""
return self._internal_id * 2
lion = Species("Lew")
# Technicznie możliwe, ale narusza konwencję
print(lion._internal_id) # 12345 - działa, ale NIE POWINNO!
# Prawidłowe użycie
class EndangeredSpecies(Species):
def get_risk(self):
# Podklasa może używać _internal_id
return self._calculate_risk()Konwencja _underscore:
- Sygnał: "To wewnętrzna implementacja, nie używaj bezpośrednio"
- Techniczne: Wciąż dostępne, Python nie blokuje
- Dokumentacja: Nie pojawia się w
help()domyślnie
Atrybuty prywatne - __double_underscore
Name Mangling: Atrybut z dwoma podkreśleniami (__name) jest "prywatny" - Python zmienia nazwę, żeby utrudnić dostęp!
class SecretData:
def __init__(self, value):
self.__secret = value # Prywatny!
def get_secret(self):
"""Kontrolowany dostęp"""
return self.__secret
data = SecretData("Top Secret")
# Bezpośredni dostęp nie działa
# print(data.__secret) # AttributeError!
# Działa przez metodę
print(data.get_secret()) # "Top Secret"
# Name mangling - Python zmienił nazwę!
print(data._SecretData__secret) # "Top Secret" - można, ale NIE RÓB TAK!Mechanizm Name Mangling:
- Python zmienia
__namena_ClassName__name - To utrudnia dostęp, ale nie uniemożliwia
- Chroni przed przypadkowym nadpisaniem w podklasach
class Parent:
def __init__(self):
self.__private = "Rodzic"
class Child(Parent):
def __init__(self):
super().__init__()
self.__private = "Dziecko" # Nie koliduje!
child = Child()
print(child._Parent__private) # "Rodzic"
print(child._Child__private) # "Dziecko"Properties - @property
Property to elegancki sposób na tworzenie getterów i setterów, które wyglądają jak atrybuty!
Podstawowe property (tylko odczyt)
Najprostszy przypadek to metoda z dekoratorem @property, którą odczytujesz bez nawiasów, jak zwykły atrybut. Pole i średnica koła liczą się w chwili odczytu:
class Circle:
def __init__(self, radius):
self.radius = radius
@property
def area(self):
"""Oblicz pole - automatycznie!"""
return 3.14159 * self.radius ** 2
@property
def diameter(self):
"""Oblicz średnicę"""
return self.radius * 2
circle = Circle(5)
# Używaj jak atrybutu, ale wywołuje metodę!
print(circle.area) # 78.53975 - wygląda jak atrybut
print(circle.diameter) # 10
circle.radius = 10
print(circle.area) # 314.159 - automatycznie przeliczone!Property z getterem i setterem
Do zapisu służy druga metoda o tej samej nazwie, z dekoratorem @celsius.setter. To w niej sprawdzasz nową wartość, zanim trafi do obiektu:
class Temperature:
def __init__(self, celsius):
self._celsius = celsius # Wewnętrzne przechowywanie
@property
def celsius(self):
"""Getter - odczyt temperatury"""
return self._celsius
@celsius.setter
def celsius(self, value):
"""Setter - zapis z walidacją"""
if value < -273.15:
raise ValueError("Temperatura poniżej zera bezwzględnego!")
self._celsius = value
@property
def fahrenheit(self):
"""Automatyczna konwersja"""
return self._celsius * 9/5 + 32
@fahrenheit.setter
def fahrenheit(self, value):
"""Ustawienie przez Fahrenheita"""
self._celsius = (value - 32) * 5/9
temp = Temperature(25)
# Getter
print(temp.celsius) # 25
# Setter z walidacją
temp.celsius = 30 # OK
print(temp.celsius) # 30
# temp.celsius = -300 # ValueError: Temperatura poniżej zera bezwzględnego!
# Konwersja automatyczna
print(temp.fahrenheit) # 86.0
temp.fahrenheit = 32 # Ustaw przez Fahrenheita
print(temp.celsius) # 0.0 - automatyczna konwersja!Property tylko do odczytu (read-only)
Jeśli nie zdefiniujesz settera, wartość da się tylko odczytać. Tak działa wiek osoby, który zawsze wynika z roku urodzenia i bieżącej daty:
class Person:
def __init__(self, birth_year):
self._birth_year = birth_year
@property
def birth_year(self):
"""Tylko odczyt - brak settera"""
return self._birth_year
@property
def age(self):
"""Obliczane dynamicznie"""
from datetime import datetime
return datetime.now().year - self._birth_year
person = Person(1990)
print(person.age) # zależy od bieżącego roku, np. 36 w 2026
try:
person.age = 40 # brak settera
except AttributeError as e:
print(e) # property 'age' of 'Person' object has no setterPrzykład z safari - System zarządzania gatunkami zagrożonymi
Ta klasa łączy wszystkie poziomy dostępu: nazwy są publiczne, identyfikator i status chronione, a populacja, tajne lokalizacje i log dostępu prywatne. Property i metody publiczne pilnują, kto i jak może je zmieniać.
from datetime import datetime
from typing import List, Dict
class EndangeredSpecies:
"""
Klasa zarządzająca gatunkiem zagrożonym z pełną enkapsulacją
Chroni wrażliwe dane o lokalizacji, populacji, obserwacjach
"""
# Klasa przechowuje wszystkie instancje
_all_species: Dict[str, 'EndangeredSpecies'] = {}
_next_id = 1
def __init__(self, scientific_name, common_name, conservation_status):
# Publiczne dane - bezpieczne do udostępnienia
self.scientific_name = scientific_name
self.common_name = common_name
# Chronione dane - konwencja _underscore
self._id = EndangeredSpecies._next_id
EndangeredSpecies._next_id += 1
self._conservation_status = conservation_status
self._created_at = datetime.now()
# Prywatne dane - wrażliwe informacje
self.__population = 0
self.__secret_locations = [] # Lokalizacje - NIE dla publiki!
self.__access_log = [] # Log dostępu
# Rejestruj w katalogu
EndangeredSpecies._all_species[scientific_name] = self
# === PROPERTY: Population (z walidacją) ===
@property
def population(self):
"""Odczyt populacji - logowany"""
self.__log_access("population", "read")
return self.__population
@population.setter
def population(self, value):
"""Zapis populacji - walidacja + logowanie"""
self.__log_access("population", "write", f"Zmiana z {self.__population} na {value}")
if not isinstance(value, int):
raise TypeError("Populacja musi być liczbą całkowitą")
if value < 0:
raise ValueError("Populacja nie może być ujemna")
self.__population = value
self.__update_conservation_status()
# === PROPERTY: Conservation Status (tylko odczyt) ===
@property
def conservation_status(self):
"""Status ochrony - tylko odczyt"""
return self._conservation_status
# === PROPERTY: Threat Level (obliczane dynamicznie) ===
@property
def threat_level(self):
"""
Poziom zagrożenia (1-10) - obliczane na podstawie populacji
Tylko odczyt - brak settera
"""
if self.__population == 0:
return 10 # Krytycznie zagrożony
elif self.__population < 50:
return 9
elif self.__population < 250:
return 7
elif self.__population < 1000:
return 5
elif self.__population < 5000:
return 3
else:
return 1 # Bezpieczny
# === METODY PRYWATNE ===
def __log_access(self, field, action, details=""):
"""Prywatna metoda - logowanie dostępu"""
log_entry = {
"timestamp": datetime.now(),
"field": field,
"action": action,
"details": details
}
self.__access_log.append(log_entry)
def __update_conservation_status(self):
"""Prywatna metoda - aktualizacja statusu na podstawie populacji"""
if self.__population == 0:
self._conservation_status = "Extinct in the Wild"
elif self.__population < 50:
self._conservation_status = "Critically Endangered"
elif self.__population < 250:
self._conservation_status = "Endangered"
elif self.__population < 1000:
self._conservation_status = "Vulnerable"
else:
self._conservation_status = "Least Concern"
# === METODY PUBLICZNE - Kontrolowany dostęp ===
def add_secret_location(self, latitude, longitude, authorization_code):
"""
Dodaj wrażliwą lokalizację - wymaga autoryzacji!
Args:
latitude: Szerokość geograficzna
longitude: Długość geograficzna
authorization_code: Kod dostępu (w produkcji: hash, token, etc.)
"""
# Walidacja autoryzacji
if authorization_code != "SAFARI_2024_SECURE":
self.__log_access("secret_locations", "denied", "Nieautoryzowany dostęp")
raise PermissionError("Nieautoryzowany dostęp do wrażliwych danych!")
# Walidacja współrzędnych
if not (-90 <= latitude <= 90):
raise ValueError("Nieprawidłowa szerokość geograficzna")
if not (-180 <= longitude <= 180):
raise ValueError("Nieprawidłowa długość geograficzna")
location = {
"lat": latitude,
"lon": longitude,
"added_at": datetime.now()
}
self.__secret_locations.append(location)
self.__log_access("secret_locations", "add", f"Dodano lokalizację: {latitude}, {longitude}")
return f"Lokalizacja dodana (ID: {len(self.__secret_locations)})"
def get_location_count(self):
"""Zwróć liczbę lokalizacji bez ujawniania szczegółów"""
return len(self.__secret_locations)
def get_general_area(self):
"""Zwróć ogólny obszar bez precyzyjnych współrzędnych"""
if not self.__secret_locations:
return "Brak danych o lokalizacji"
# Uśrednij współrzędne dla ogólnego obszaru
avg_lat = sum(loc["lat"] for loc in self.__secret_locations) / len(self.__secret_locations)
avg_lon = sum(loc["lon"] for loc in self.__secret_locations) / len(self.__secret_locations)
# Zwróć zaokrąglone do 1 miejsca (mniej precyzyjne)
return f"Obszar: {avg_lat:.1f}°, {avg_lon:.1f}°"
def get_access_log(self, authorization_code):
"""Zwróć log dostępu - wymaga autoryzacji"""
if authorization_code != "SAFARI_2024_SECURE":
raise PermissionError("Nieautoryzowany dostęp do logów!")
return self.__access_log.copy() # Zwróć kopię, nie oryginał!
def generate_public_report(self):
"""Raport publiczny - bez wrażliwych danych"""
return f"""
╔════════════════════════════════════════════════╗
{self.common_name} ({self.scientific_name})
╠════════════════════════════════════════════════╣
Status ochrony: {self.conservation_status}
Populacja: {self.population} osobników
Poziom zagrożenia: {self.threat_level}/10
Znane lokalizacje: {self.get_location_count()}
Ogólny obszar: {self.get_general_area()}
╚════════════════════════════════════════════════╝
""".strip()
def generate_classified_report(self, authorization_code):
"""Raport szczegółowy - wymaga autoryzacji"""
if authorization_code != "SAFARI_2024_SECURE":
raise PermissionError("Nieautoryzowany dostęp do danych niejawnych!")
locations_str = "\n".join(
f" - Lat: {loc['lat']:.6f}, Lon: {loc['lon']:.6f} (dodano: {loc['added_at'].strftime('%Y-%m-%d %H:%M')})"
for loc in self.__secret_locations
)
return f"""
╔════════════════════════════════════════════════╗
RAPORT NIEJAWNY - {self.common_name}
╠════════════════════════════════════════════════╣
ID: {self._id}
Status: {self.conservation_status}
Populacja: {self.__population}
Zagrożenie: {self.threat_level}/10
LOKALIZACJE (NIEJAWNE):
{locations_str if locations_str else " Brak danych"}
Dostępy do danych: {len(self.__access_log)}
╚════════════════════════════════════════════════╝
""".strip()
# === METODY KLASOWE ===
@classmethod
def get_species_by_threat_level(cls, min_level):
"""Zwróć gatunki o zagrożeniu >= min_level"""
return [
species for species in cls._all_species.values()
if species.threat_level >= min_level
]
# === DEMONSTRACJA UŻYCIA ===
print("=== SYSTEM ZARZĄDZANIA GATUNKAMI ZAGROŻONYMI ===\n")
# Tworzenie gatunków
rhino = EndangeredSpecies(
scientific_name="Diceros bicornis",
common_name="Nosorożec czarny",
conservation_status="Critically Endangered"
)
mountain_gorilla = EndangeredSpecies(
scientific_name="Gorilla beringei beringei",
common_name="Goryl górski",
conservation_status="Endangered"
)
# Ustawienie populacji (z walidacją)
rhino.population = 45 # OK
mountain_gorilla.population = 880 # OK
# Próba nieprawidłowej wartości
try:
rhino.population = -10 # ValueError!
except ValueError as e:
print(f"Błąd walidacji: {e}\n")
# Dodanie lokalizacji (wymaga autoryzacji)
try:
rhino.add_secret_location(
latitude=-1.2345,
longitude=36.7890,
authorization_code="WRONG_CODE"
)
except PermissionError as e:
print(f"Brak autoryzacji: {e}\n")
# Prawidłowa autoryzacja
rhino.add_secret_location(-1.2345, 36.7890, "SAFARI_2024_SECURE")
rhino.add_secret_location(-1.5678, 36.9012, "SAFARI_2024_SECURE")
mountain_gorilla.add_secret_location(-1.4321, 29.6543, "SAFARI_2024_SECURE")
print("Lokalizacje dodane\n")
# Bezpośredni dostęp do prywatnych danych - nie działa!
try:
print(rhino.__population) # AttributeError
except AttributeError:
print("Nie można uzyskać bezpośredniego dostępu do __population\n")
# Dostęp przez property - działa!
print(f"Populacja nosorożca (przez property): {rhino.population}\n")
# Raport publiczny - bezpieczny
print("=== RAPORT PUBLICZNY ===")
print(rhino.generate_public_report())
# Raport niejawny - wymaga autoryzacji
print("\n=== RAPORT NIEJAWNY ===")
print(rhino.generate_classified_report("SAFARI_2024_SECURE"))
# Property tylko do odczytu
print(f"\n=== WŁAŚCIWOŚCI TYLKO DO ODCZYTU ===")
print(f"Status ochrony: {rhino.conservation_status}")
print(f"Poziom zagrożenia: {rhino.threat_level}/10")
# Próba zmiany - nie działa!
try:
rhino.threat_level = 1 # AttributeError - brak settera!
except AttributeError as e:
print(f"Nie można ustawić threat_level: {e}")
# Automatyczna aktualizacja statusu przy zmianie populacji
print(f"\n=== AUTOMATYCZNA AKTUALIZACJA ===")
print(f"Przed: populacja={rhino.population}, status={rhino.conservation_status}")
rhino.population = 280 # Zwiększ populację
print(f"Po: populacja={rhino.population}, status={rhino.conservation_status}")
# Gatunki o wysokim zagrożeniu
print(f"\n=== GATUNKI KRYTYCZNIE ZAGROŻONE ===")
critical = EndangeredSpecies.get_species_by_threat_level(7)
for species in critical:
print(f" {species.common_name}: Zagrożenie {species.threat_level}/10")Zalety enkapsulacji
1. Walidacja danych
Setter może odrzucić wartość, która nie ma sensu. Temperatura poniżej zera bezwzględnego nigdy nie trafi do obiektu:
class Temperature:
def __init__(self):
self.__celsius = 0
@property
def celsius(self):
return self.__celsius
@celsius.setter
def celsius(self, value):
if value < -273.15:
raise ValueError("Poniżej zera bezwzględnego!")
self.__celsius = value
temp = Temperature()
try:
temp.celsius = -300
except ValueError as e:
print(e) # Poniżej zera bezwzględnego!2. Kontrola dostępu
Saldo konta zmienia się tylko przez metodę, która najpierw sprawdza, czy wypłata jest możliwa:
class BankAccount:
def __init__(self, balance):
self.__balance = balance
def withdraw(self, amount):
"""Kontrolowany dostęp"""
if amount > self.__balance:
raise ValueError("Niewystarczające środki")
self.__balance -= amount
account = BankAccount(1000)
# account.__balance = 999999 # Tworzy nowy atrybut, prawdziwego salda nie zmienia
account.withdraw(500) # Tylko przez metodę!3. Elastyczność implementacji
Kod, który odczytuje circle.area, nie wie, czy pole jest zapisane, czy liczone. Dzięki temu możesz później zmienić sposób liczenia bez poprawiania reszty programu:
class Circle:
def __init__(self, radius):
self.__radius = radius
@property
def area(self):
"""Użytkownik nie wie, że to obliczane!"""
return 3.14159 * self.__radius ** 2
# Możesz zmienić implementację bez zmiany interfejsu
circle = Circle(5)
print(circle.area) # Użytkownik używa jak atrybutu4. Ukrywanie złożoności
Prywatna metoda __connect() chowa szczegóły łączenia z bazą. Użytkownik klasy zna tylko prostą metodę query():
class Database:
def __init__(self):
self.__connection = None
self.__cache = {}
def __connect(self):
"""Prywatna - użytkownik nie musi znać szczegółów"""
print("Łączenie z bazą...")
def query(self, sql):
"""Publiczny interfejs - prosty"""
if not self.__connection:
self.__connect()
# ... wykonaj zapytanieDobre praktyki enkapsulacji
1. Użyj property zamiast getterów/setterów
W stylu znanym z Javy pisze się osobne metody get_name() i set_name(). W Pythonie ten sam efekt daje property, a kod, który korzysta z klasy, wygląda jak zwykły dostęp do atrybutu:
# Styl Java - rozwlekły
class Person:
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name
def set_name(self, value):
self.__name = value
# Pythonowy sposób - elegancki
class Person:
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value2. Nie nadużywaj prywatnych atrybutów
Dwa podkreślenia mają sens tam, gdzie naprawdę coś chronisz. Imię, które każdy może bezpiecznie przeczytać i zmienić, może zostać zwykłym atrybutem:
# Zbyt paranoidalne
class Person:
def __init__(self, name):
self.__name = name # Zbędne __
# Zaufaj konwencjom
class Person:
def __init__(self, name):
self.name = name # Prosty atrybut, jeśli nie potrzebujesz ochrony3. Używaj enkapsulacji dla wrażliwych danych
Hasło to dobry kandydat na atrybut prywatny: obiekt trzyma tylko jego skrót i porównuje go w metodzie check_password(), a sam skrót nigdy nie wychodzi na zewnątrz.
# Ochrona wrażliwych danych. Uproszczenie: wbudowane hash() nie nadaje się do haseł,
# bo zmienia wynik przy każdym uruchomieniu; w praktyce używa się hashlib albo bcrypt
class User:
def __init__(self, username, password):
self.username = username # Publiczny
self.__password_hash = hash(password) # Prywatny!
def check_password(self, password):
return hash(password) == self.__password_hashPodsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym jest enkapsulacja i dlaczego jest ważna
- Różnicy między publicznymi, chronionymi i prywatnymi atrybutami
- Mechanizmu name mangling (
__name) - Tworzenia properties z
@property, getterów i setterów - Walidacji danych przy zapisie
- Kontrolowanego dostępu do wrażliwych informacji
- Praktycznych przykładów z systemu zarządzania gatunkami zagrożonymi
Checkpoint
Przed przejściem dalej:
- Rozumiesz różnicę między
name,_namei__name - Potrafisz stworzyć property z getterem i setterem
- Wiesz kiedy używać enkapsulacji
- Rozumiesz mechanizm name mangling
- Potrafisz walidować dane w setterze
Analogia Safari: Enkapsulacja to system ochrony dla wrażliwych danych o gatunkach zagrożonych - nie każdy powinien mieć dostęp do lokalizacji rzadkich zwierząt!
W następnej lekcji Darwin nauczy Cię magicznych metod - ukrytych zachowań, które sprawiają, że Twoje klasy działają jak wbudowane typy Pythona!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jak oznaczyć atrybut jako 'prywatny' w Pythonie?
2. Do czego służy dekorator @property?
Zadania praktyczne w grze
- Edytor kodu
Stwórz klasę Animal(name, age) z property age (getter @property), która zwraca wiek zapisany w self._age. Jeśli w __init__ podano age < 0, zgłoś ValueError
- Edytor kodu
Dodaj do property age setter (@age.setter), który zmienia wiek, ale odrzuca liczby ujemne (zgłasza ValueError)
- Układanie w pionie
Uporządkuj elementy wzorca property:
- Układanie w pionie
Uporządkuj elementy property: