Kurs Python · Moduł 3: Programowanie obiektowe

Enkapsulacja - ochrona siedlisk

13 min czytania ·
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:

  1. Grupowaniu danych i metod w jednej klasie
  2. Ukrywaniu szczegółów implementacji
  3. 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:

KonwencjaZnaczeniePrzykład
namePubliczny - dostęp z każdego miejscaself.name
_nameChroniony - tylko klasa i podklasyself._internal_id
__namePrywatny - tylko wewnątrz klasyself.__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)   # 4

Uż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 __name na _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 setter

Przykł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 atrybutu

4. 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 zapytanie

Dobre 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 = value

2. 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 ochrony

3. 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_hash

Podsumowanie

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, _name i __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. 1. Jak oznaczyć atrybut jako 'prywatny' w Pythonie?

  2. 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:

  1. PytanieAtrybuty prywatne
  2. PytanieDekorator @property
  3. Zadanie z kodemGetter z @property
  4. Zadanie z kodemSetter z @property
  5. Ułóż w kolejnościEnkapsulacja - getter/setter
  6. Ułóż w kolejnościWzorzec property

Przydatne artykuły