Python Academy · Lekcja

Dziedziczenie pojedyncze

Proszę tworzyć klasy potomne dziedziczące atrybuty i metody po klasie nadrzędnej.

Dziedziczenie pojedyncze to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Dziedziczenie pozwala klasie potomnej ponownie wykorzystać i rozszerzyć zachowanie klasy nadrzędnej bez powielania kodu.

Definiowanie klasy potomnej

class Dog(Animal): dziedziczy wszystko po Animal. Klasa potomna może dodawać nowe metody lub przesłaniać istniejące.

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return '...'
class Dog(Animal):
    def speak(self): return 'Woof'
d = Dog('Rex')
print(d.name, d.speak())

Wywoływanie super().init

super().__init__(args) wywołuje __init__ klasy nadrzędnej. Jeśli klasa nadrzędna zawiera logikę konfiguracji, w klasie potomnej należy zawsze ją wywołać.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
d = Dog('Rex', 'Labrador')
print(d.name, d.breed)

Dziedziczenie metod

Klasa potomna dziedziczy wszystkie metody klasy nadrzędnej. Jeśli ich nie przesłonisz, działają bez zmian.

class Vehicle:
    def start(self): return 'starting'
class Car(Vehicle):
    pass
print(Car().start())

Przesłanianie metod

Zdefiniuj w klasie potomnej metodę o tej samej nazwie, aby zastąpić wersję z klasy nadrzędnej. Wywoływana będzie wersja z klasy potomnej.

class Shape:
    def area(self): return 0
class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s**2
print(Square(4).area())

Rozszerzanie zachowania klasy nadrzędnej

Wywołaj super().method() wewnątrz przesłonięcia, aby najpierw uruchomić wersję z klasy nadrzędnej, a następnie dodać własne działanie.

class Animal:
    def describe(self): return 'I am an animal'
class Dog(Animal):
    def describe(self): return super().describe() + ' and a dog'
print(Dog().describe())

isinstance() i issubclass()

isinstance(obj, Parent) zwraca True również dla instancji klas potomnych. issubclass(Child, Parent) sprawdza hierarchię klas.

class Animal: pass
class Dog(Animal): pass
d = Dog()
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))

Nowe metody w klasie potomnej

Klasa potomna może definiować zupełnie nowe metody, których nie ma klasa nadrzędna.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def fetch(self): return f'{self.name} fetches!'
print(Dog('Rex').fetch())

Atrybuty chronione

Konwencja _name sygnalizuje „nie uzyskuj dostępu spoza klasy”. Klasy potomne MOGĄ z nich korzystać.

class Animal:
    def __init__(self, name): self._name = name
    def name(self): return self._name
class Dog(Animal):
    def bark(self): return f'{self._name} barks'
print(Dog('Rex').bark())

Abstrakcyjne klasy bazowe

from abc import ABC, abstractmethod wymusza implementację metod przez klasy potomne.

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self): pass
class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(3).area())

bases i mro

Dog.__bases__ pokazuje bezpośrednie klasy nadrzędne. Dog.__mro__ pokazuje pełną kolejność wyszukiwania metod.

class A: pass
class B(A): pass
class C(B): pass
print(C.__mro__)

Szybkie sprawdzenie

Co robi super().__init__() w klasie potomnej?

Podsumowanie

Dziedziczenie: class Child(Parent). super() zapewnia dostęp do klasy nadrzędnej. Przesłaniaj metody, aby zmieniać zachowanie. isinstance() sprawdza hierarchię. ABC wymusza abstrakcyjne kontrakty.

Kontynuuj

Doskonale sobie radzisz! Proszę kontynuować, aby opanować następne zagadnienie.

Często zadawane pytania

Czy lekcja „Dziedziczenie pojedyncze” jest bezpłatna?

Tak — pełny tekst „Dziedziczenie pojedyncze” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Dziedziczenie pojedyncze”?

Proszę tworzyć klasy potomne dziedziczące atrybuty i metody po klasie nadrzędnej. Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Dziedziczenie pojedyncze”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Python Academy