If you are just learning Python, are you still writing a bunch of messy functions? When you encounter repeated functionalities, do you copy and paste, and when you modify the code, does it affect everything? In fact, there is a more efficient programming method in Python—Object-Oriented Programming (OOP). It is like “bringing” real-world objects into code, making the code more organized and maintainable, allowing beginners to easily get started!
1. First, understand: What is “Object-Oriented”? (A relatable analogy)
In simple terms, Object-Oriented means abstracting real-world objects into “objects” in code. Each object has two core components:
- • Attributes: Characteristics of the object (e.g., a person’s name, age; a phone’s brand, price)
- • Methods: Actions the object can perform (e.g., a person can eat, speak; a phone can make calls, take photos)
For example:
- • A real-world “kitten”: Attributes (name=Kitty, age=2 years, color=orange), Methods (meow, catch mice)
- • A “kitten object” in code: Using Python syntax to encapsulate these characteristics and actions, allowing direct use without rewriting code.
Compared to traditional “procedural programming” (writing functions step by step), Object-Oriented programming is more like “building with blocks”: breaking down complex functionalities into independent “object modules” that can be assembled as needed, providing strong reusability!
2. The 3 Core Characteristics of Object-Oriented Programming (A Must-Know for Beginners)
This is the essence of Object-Oriented programming. Using the example of “pets” to help you grasp each concept, with minimal code that you can copy and run directly!
1. Encapsulation: Packaging Attributes and Methods
Encapsulation is about “drawing a boundary” around the object: Attributes (like age) and methods (like meowing) are hidden within the object, and external modifications are not allowed; they must be operated through specified methods (like dedicated modification functions).
Benefits: Prevents accidental data modification, making the code safer and cleaner.
🌰 Code Example: Creating a kitten (encapsulating attributes and methods)
# Define a "Cat" template (class: class, is a blueprint for creating objects)
class Cat:
# Initialization method: Automatically executed when creating an object, assigning initial attributes to the object
def __init__(self, name, age, color):
self.name = name # Cat's name (attribute)
self.age = age # Cat's age (attribute)
self.color = color# Cat's color (attribute)
# Cat's methods (actions it can perform)
def meow(self):
print(f"{self.name}（{self.color}）meows～")
def catch_mouse(self):
print(f"{self.name} catches mice!")
# Create a specific "cat object" using the template (instantiation)
my_cat = Cat(name="Kitty", age=2, color="orange")
# Access the object's attributes and methods
print(my_cat.name) # Output: Kitty (accessing attribute)
my_cat.meow() # Output: Kitty (orange) meows～ (calling method)
my_cat.catch_mouse()# Output: Kitty catches mice!👉 Note for Beginners:
- •
<span>class</span>is a keyword used to define a “class” (template for objects) - •
<span>__init__</span>is the initialization method, and the first parameter is always<span>self</span>(representing the object itself) - •
<span>self.attribute_name</span>is used to define the object’s attributes, and can only be used within the object
2. Inheritance: Writing Code on the “Shoulders of Giants”
Inheritance means that a “child object” inherits the attributes and methods of a “parent object”, and can also add new functionalities without rewriting the parent object’s code.
For example: “Dogs” and “Cats” are both “Animals”, sharing names, ages, and the ability to speak and eat. You can first define a “Animal” parent class, then let the “Dog” and “Cat” child classes inherit, only writing their unique methods (like dogs wagging their tails).
🌰 Code Example: Usage of Inheritance
# Parent class: Animal (contains common attributes and methods for all animals)
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print(f"{self.name} is eating～")
def speak(self):
print(f"{self.name} is speaking～")
# Child class: Cat (inherits Animal, automatically has name, age attributes and eat method)
class Cat(Animal):
# Add unique attributes for the child class
def __init__(self, name, age, color):
# Call the parent's initialization method, inheriting name and age
super().__init__(name, age)
self.color = color # Cat's unique attribute: color
# Override the parent's speak method (customize the cat's sound)
def speak(self):
print(f"{self.name}（{self.color}）meows～")
# Add unique methods for the cat
def catch_mouse(self):
print(f"{self.name} catches mice!")
# Child class: Dog (inherits Animal)
class Dog(Animal):
def __init__(self, name, age, breed):
super().__init__(name, age)
self.breed = breed # Dog's unique attribute: breed
# Override the parent's speak method
def speak(self):
print(f"{self.name}（{self.breed}）barks～")
# Dog's unique method
def shake_tail(self):
print(f"{self.name} shakes its tail cutely～")
# Create child class objects and use them
my_cat = Cat("Kitty", 2, "orange")
my_dog = Dog("Lucky", 3, "Golden Retriever")
my_cat.eat() # Inherited method from parent: Kitty is eating～
my_cat.speak()# Overridden method: Kitty (orange) meows～
my_dog.shake_tail()# Child's unique method: Lucky shakes its tail cutely～👉 Key Points for Beginners:
- • When defining a child class, write the parent class name in parentheses (
<span>class ChildClass(ParentClass)</span>) - •
<span>super().__init__()</span>is used to call the parent’s initialization method, inheriting attributes - • Child classes can override parent methods (same name method overrides the parent) and can also add new methods
3. Polymorphism: The Same Operation, Different Behaviors
Polymorphism means “the same method behaves differently when called by different objects”, allowing code to adapt to different objects without writing multiple checks.
For example, in the previous example: calling the <span>speak()</span> method will make the cat meow and the dog bark—this is polymorphism, where you don’t need to check “is this a cat or a dog”; you can just call it directly.
🌰 Code Example: Practical Use of Polymorphism
# Define a generic function that accepts any Animal subclass object
def make_animal_speak(animal):
animal.speak() # Same operation, different objects behave differently
# Create different objects
cat = Cat("Kitty", 2, "orange")
dog = Dog("Lucky", 3, "Golden Retriever")
# Call the same function, automatically adapting to different objects
make_animal_speak(cat) # Output: Kitty (orange) meows～
make_animal_speak(dog) # Output: Lucky (Golden Retriever) barks～👉 Understanding for Beginners: Polymorphism makes the code more flexible. In the future, if you add subclasses like “Rabbit” or “Bird”, you won’t need to modify the <span>make_animal_speak</span> function; just call it directly!
3. Practical Exercise for Beginners: Write a “Pet Management System” Using Object-Oriented Programming
Integrate the three major characteristics to write a simple management system that can add cats and dogs and let them “speak”. Beginners can copy and run it directly!
# Parent class: Animal
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
pass # Empty method for subclasses to override
# Child class: Cat
class Cat(Animal):
def __init__(self, name, age, color):
super().__init__(name, age)
self.color = color
def speak(self):
return f"{self.name}（{self.color}，{self.age} years old）meows～"
# Child class: Dog
class Dog(Animal):
def __init__(self, name, age, breed):
super().__init__(name, age)
self.breed = breed
def speak(self):
return f"{self.name}（{self.breed}，{self.age} years old）barks～"
# Pet Management System (Main class)
class PetSystem:
def __init__(self):
self.pets = [] # Store all pet objects
# Add pet
def add_pet(self, pet):
self.pets.append(pet)
print(f"Successfully added pet: {pet.name}")
# Let all pets speak
def all_pets_speak(self):
print("\nAll pets' sounds:")
for pet in self.pets:
print(pet.speak())
# Run the system
if __name__ == "__main__":
# Create system object
pet_system = PetSystem()
# Add pets
pet_system.add_pet(Cat("Kitty", 2, "orange"))
pet_system.add_pet(Dog("Lucky", 3, "Golden Retriever"))
pet_system.add_pet(Cat("Fluffy", 1, "white"))
# Let all pets speak
pet_system.all_pets_speak()Output:
Successfully added pet: Kitty
Successfully added pet: Lucky
Successfully added pet: Fluffy
All pets' sounds:
Kitty（orange，2 years old）meows～
Lucky（Golden Retriever，3 years old）barks～
Fluffy（white，1 year old）meows～4. Common Pitfalls for Beginners: Avoid These 3 Mistakes
- 1. Misusing Inheritance: Not all related classes need to inherit; only use it for “is-a” relationships (e.g., “a cat is an animal”, not “a cat has a collar”—the latter is better suited for “composition”)
- 2. Ignoring Encapsulation: Exposing all attributes to external modification can lead to data chaos (you can use private attributes
<span>__attribute_name</span>to restrict external access) - 3. Overcomplicating: For small projects (like a single-file web scraper), don’t force Object-Oriented programming; simple functions can be more efficient
5. Summary: 3 Steps for Beginners to Learn Object-Oriented Programming
- 1. First, understand “classes” and “objects”: a class is a template, and an object is a specific instance created from that template
- 2. Master the three major characteristics: Encapsulation (packaging attributes and methods) → Inheritance (code reuse) → Polymorphism (flexible adaptation)
- 3. Write more practical cases: from simple “cats/dogs” to “student management systems” and “library management systems”, gradually become proficient
Object-Oriented programming is not “mystical”; it is a mindset that makes code closer to reality and easier to maintain. Beginners should not rush; start by trying to encapsulate functionalities in classes in small projects, and you will gradually appreciate its advantages!
👉 Interactive Question: What small project do you want to write using Object-Oriented programming? For example, “game characters” or “employee management systems”? Let’s discuss in the comments!