Understanding Python Classes: Definitions, Attributes, Methods, Inheritance, and Advanced Features

Object‑Oriented Programming (OOP) is a core paradigm in modern software development, and the class is its heart. Python’s class system is powerful and flexible, allowing developers to define custom data types, encapsulate data and behavior, and promote code reuse and modularity.

Table of Contents

1. Basic Class Definition and Instantiation 2. Attributes and Methods 3. Constructor (__init__) and Initialization 4. Special Method __str__ 5. Inheritance and Polymorphism 6. Advanced Features (class methods, static methods, private members, @property)

Basic Class Definition and Instantiation

Scenario 1 demonstrates how to define a simple class and create an instance.

class Person:
    """A simple Person class"""
    pass

person = Person()
print("Created an instance of Person:", person)

Use a class when you need a custom data type.

Attributes and Methods

Scenario 2 adds class attributes that are shared by all instances.

class Person:
    """Person class with attributes"""
    name = "张三"  # class attribute
    age = 18      # class attribute

print("Person name:", Person.name)
print("Person age:", Person.age)

Scenario 3 adds an instance method to define object behavior.

class Person:
    """Person class with a method"""
    name = "张三"
    age = 18
    def greet(self):
        print(f"Hello, I am {self.name}, {self.age} years old.")

person = Person()
person.greet()

Methods are functions bound to an instance via the self parameter.

Constructor (__init__) and Initialization

Scenario 4 shows how to use __init__ to initialize instance attributes.

class Person:
    """Person class with an initializer"""
    def __init__(self, name, age):
        self.name = name  # instance attribute
        self.age = age
    def greet(self):
        print(f"Hello, I am {self.name}, {self.age} years old.")

person = Person("张三", 20)
person.greet()

Special Method __str__

Scenario 5 defines __str__ to provide a friendly string representation.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"

person = Person("张三", 20)
print(person)

Inheritance and Polymorphism

Scenario 6 creates a subclass that inherits from a parent class.

class Animal:
    """Animal base class"""
    def __init__(self, name):
        self.name = name
    def speak(self):
        print(f"{self.name} says: animal sound")

class Dog(Animal):
    """Dog subclass"""
    def speak(self):
        print(f"{self.name} says: Woof!")

dog = Dog("旺财")
dog.speak()

Scenario 7 demonstrates polymorphism by calling the same method on different subclasses.

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def animal_sound(animal):
    animal.speak()

animal_sound(Dog())
animal_sound(Cat())

Polymorphism allows a uniform interface to invoke different implementations.

Advanced Features

Scenario 8 introduces class methods and static methods.

class Dog:
    def __init__(self, name):
        self.name = name
    @classmethod
    def from_name(cls, name):
        return cls(name)  # creates an instance
    @staticmethod
    def bark():
        print("Woof!")

dog = Dog.from_name("旺财")
print(dog.name)
Dog.bark()

Scenario 9 shows private attributes and methods using double underscores.

class Dog:
    def __init__(self, name):
        self.__name = name  # private attribute
    def get_name(self):
        return self.__name
    def __bark(self):
        print("Woof!")

dog = Dog("旺财")
print(dog.get_name())  # prints 旺财
# dog.__bark()  # cannot be accessed directly

Scenario 10 uses the @property decorator to expose a method as an attribute with validation.

class Dog:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value

dog = Dog("旺财")
print(dog.name)
dog.name = "大黄"
print(dog.name)

Summary and Recommendations

Through these ten code examples we explored Python's class mechanism from basic definitions to advanced features. Classes serve as templates for objects, enabling custom data types, encapsulation of data and behavior, and supporting inheritance, polymorphism, and various special methods. Mastering these concepts leads to more modular, maintainable, and expressive Python code.