From data to large model application, on November 25th, Hangzhou Yuanchuang Conference was held to share development tips.

Welcome to our blog series "Python Panorama Series"! In this series, we will lead you from the basics of Python to advanced topics step by step to help you master this powerful and flexible programming syntax. Whether you are new to programming or an experienced developer, this series will provide you with the knowledge and skills you need.

The sixth article in the Python Panorama Series, this article will delve into the core concepts in the Python language: Class and Object. We'll introduce these basic concepts and then use example code to show in detail how classes and objects in Python work, including definition, instantiation, and modification. This article will help you gain a deeper understanding of object-oriented programming (OOP) in Python and provide some uncommon but useful technical insights.

1. Abstract concepts of classes and objects

The concepts of classes and objects are the basis of object-oriented programming (OOP). In Python, object-oriented design methods provide an efficient way to encapsulate data and functionality. It allows us to map real-world things and behaviors into code. This mapping is more in line with our human cognitive style, allowing us to understand and design complex software systems in a more natural way.

class abstraction

A class is an abstract template used to describe a collection of objects with common properties and methods. A class defines the common structure and behavior of these objects, but it does not occupy any storage space itself. Class is a mechanism for creating new objects and provides a rule and standard for the creation and management of objects.

object materialization

In contrast, an object is an instance of a class, which exists concretely and takes up storage space. Each object has its own properties and behaviors, which are defined by its class. Each property of an object has a value associated with it, which can change during the lifetime of the object, and its behavior is defined by methods.

object uniqueness

Although a class may be instantiated as multiple objects, each object is unique. Even if two objects are from the same class and have the same property values, they are different objects. Each object has a unique identifier (which can be id()obtained through built-in functions in Python), which is used to distinguish different objects.

The relationship between classes and objects

The relationship between classes and objects can be compared to a blueprint and a house, or a recipe and a dish. Classes are like blueprints or recipes, providing detailed instructions for creating an object (a house or a dish). You can use the same blueprint or recipe to create multiple houses or dishes, just like you can use the same class to create multiple objects.

unique insights

Understanding the abstract ideas of classes and objects not only helps us write and read object-oriented code, but also helps us better understand the real world. In the real world, we often need to deal with collections of things with similar properties and behaviors, just like we deal with objects in programming.

In object-oriented programming, we encapsulate data and methods of operating data together to form "objects". This encapsulation of data and operations allows us to organize and manage complex software systems more efficiently. In fact, the concepts of classes and objects lead us to see that many complex problems in the real world can be simplified through abstraction and encapsulation, making it easier to

be understood and addressed. It’s a way of finding order out of chaos, simplicity out of complexity. This is also an important reason why object-oriented programming is unique among many programming paradigms.

2. Class: the way to define data types

In Python, a class is a way of defining a new data type, which encapsulates data (properties) and functions (methods) that operate on the data within a logical framework. This concept helps us build more complex data models to simulate various objects in the real world and how they interact.

The core features of the class are as follows:

Data encapsulation : The attributes in the class save the state of the object. These properties are typically __init__initialized within methods and can be accessed and modified through the object's life cycle. Encapsulation ensures data integrity and consistency.
Behavioral abstraction : The methods defined in a class describe the operations that an object can perform. These methods can access and modify the object's state, or interact with other objects.
Inheritance : A class can inherit the properties and methods of another class, allowing code reuse and behavior customization. This is an important mechanism for achieving polymorphism and code reuse.
Polymorphism : Due to inheritance, instances of a class may belong to more than one class. Python allows us to use subclass objects instead of parent class objects, improving the flexibility and reusability of the code.

Next, let's look at an example of a more complex class definition, using different types of workers as examples.

class Employee:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def work(self):
        return f"{self.name} is working."

class Manager(Employee):
    def work(self):
        return f"{self.name} is managing the team."

class Developer(Employee):
    def __init__(self, name, age, programming_language):
        super().__init__(name, age)
        self.programming_language = programming_language

    def work(self):
        return f"{self.name} is writing {self.programming_language} code."

In this example, we define a base class called Employee, and two subclasses Manager and Developer that inherit from Employee. Every class has a workmethod, but the behavior of this method is different in different subclasses. This is an example of polymorphism. At the same time, the Developer class adds a new attribute programming_language, showing how to add new attributes in subclasses.

Classes provide a high-level abstraction mechanism that enables us to design and implement complex software systems in a way that is more in line with human thinking habits. Mastering the concepts of classes and objects is crucial to understanding and using Python programming.

3. Object: instantiation of a class

In Python, once we define a class, we can create an object by instantiating the class. An object is an instance of a class that inherits the properties and methods defined by the class.

Let's continue using the "Dog" class to understand this process in depth:

fido = Dog("Fido", 3)
buddy = Dog("Buddy", 5)

Here, Dog("Fido", 3)and Dog("Buddy", 5)are expressions that create new Dog objects. They are two different instances of the Dog class, each with its own name and age properties. Although fido and buddy are both instances of the Dog class, they are two completely different objects.

You can imagine the process being like making candy. A class is like a candy mold, and each instance (object) is like a candy made from the mold. Although all candies are made from the same mold and have the same shape and size, they are still individual candies, each with their own color and flavor.

This leads to an important feature of Python objects: each object has its own namespace and stores its own attributes. These properties are independent of other objects. For example, we can modify fido's age property like this without affecting buddy's age property:

fido.age = 4
print(fido.age)  # 4
print(buddy.age)  # 5

Additionally, objects can have methods. Methods are functions defined in a class that can access and modify the properties of an object. For example, we can define a celebrate_birthdaymethod that increases the age property of the Dog object:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        return f"{self.name} says Woof!"

    def celebrate_birthday(self):
        self.age += 1
        return f"Happy Birthday {self.name}! You are now {self.age} years old."

fido = Dog("Fido", 3)
print(fido.celebrate_birthday())  # "Happy Birthday Fido! You are now 4 years old."

In general, objects are instances of classes and they inherit the properties and methods of the class. Each object has its own state (properties) and behavior (methods). In Python, we can create an object by instantiating a class, and then use dot notation .to access and modify the object's properties, or call the object's methods.

4. Class inheritance: code reuse and extension

In Python, a class can inherit from another class, which means it automatically gets all the properties and methods of the parent class. This is a core concept of object-oriented programming and can help us achieve code reuse and extension.

Suppose we have an "Animal" base class, which has some shared properties and methods, such as the "name" and "age" properties, and a "sound" method. Now we want to create two new classes: "Dog" and "Cat". They should both have "name" and "age" properties, and both should have their own "sound" method.

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sound(self):
        pass


class Dog(Animal):
    def sound(self):
        return f"{self.name} says Woof!"


class Cat(Animal):
    def sound(self):
        return f"{self.name} says Meow!"

In this example, the Dog and Cat classes both inherit from the Animal class, so they automatically get all the properties and methods of the Animal class. We then overridden the "sound" method in the Dog and Cat classes to provide respective implementations.

Inheritance can make our code more modular, easier to maintain and extend. We can put some common properties and methods in the base class, and then add or override specific behaviors in the derived class. This way, we can reuse code from the base class without having to repeat the same code in each derived class.

You can think of this process like making a Lego model. The base class is like the base of a Lego model, and the derived classes are like the various Lego bricks added to the base. We can use the same base to make a variety of different LEGO models, just by changing the bricks added to it. This is how code reuse works.

In addition, Python supports multiple inheritance, that is, a class can inherit multiple parent classes. This further enhances code reusability and extensibility, but also introduces some complexity. When using multiple inheritance, we need to be careful about possible conflicts between properties and methods of different parent classes.

In general, class inheritance is a powerful tool that can help us reuse and extend code to achieve more complex functions. When designing a class structure, we should make full use of the advantages of inheritance, and at the same time be careful to avoid problems caused by overuse of inheritance.

5. Magic methods: control the behavior of a class

Python classes can define special methods that are automatically called under certain circumstances. Because their method names begin and end with a double underscore, they are often called "magic methods" or "special methods." By defining magic methods, we can control the behavior of a class, such as the instantiation process, property access, operator overloading, etc.

For example, when we instantiate a class, __init__the magic method is automatically called:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

In this example, __init__the method is run every time a new instance of the Dog class is created to initialize the state of the new instance.

We can also define other magic methods to achieve more custom behaviors. For example, we can define __str__methods to control how an object is displayed when we print it:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"A dog named {self.name}, age {self.age}"

fido = Dog("Fido", 3)
print(fido)  # "A dog named Fido, age 3"

In this example, when we print the fido object, Python will automatically call its __str__method and use its return value as the printed content.

Magic methods are like a control panel for Python classes. By adjusting the various switches and knobs on this panel, we can finely control the behavior of the class. You can imagine this process being like driving a car. The driver can accurately control the car's driving direction, speed and position by operating the steering wheel, brakes, accelerator and other controls. Likewise, by defining and using magic methods, we can precisely control the behavior of a Python class.

However, there are caveats when using magic methods. On the one hand, excessive use of magic methods can make code difficult to understand and maintain. On the other hand, if we override the magic method of the parent class in the subclass, it may lead to unpredictable results. Therefore, we need to be careful and follow best practices when using magic methods.

In general, magic methods are a powerful tool for Python object-oriented programming, which can help us customize the behavior of classes and achieve more functions. When designing classes, we should take full advantage of the advantages of magic methods while taking care to avoid potential problems.

6. Polymorphism in Python: The power of dynamic typing

In object-oriented programming, polymorphism is a feature that allows us to deal with different types of objects in a uniform way. It makes our code more flexible and extensible. In Python, polymorphism is mainly reflected in its dynamic type system.

Python is a dynamically typed language, which means that the types of variables are determined at runtime, not at compile time. This allows us to write code without caring about the specific type of the object, as long as the object implements the expected method or property.

Consider the following example:

class Dog:
    def sound(self):
        return "Woof!"

class Cat:
    def sound(self):
        return "Meow!"

def make_sound(animal):
    return animal.sound()

fido = Dog()
whiskers = Cat()

print(make_sound(fido))  # "Woof!"
print(make_sound(whiskers))  # "Meow!"

In this example, make_soundthe function can accept any object that implements soundthe method, whether it is an instance of the Dog class, an instance of the Cat class, or an instance of any other class. This is the embodiment of polymorphism. Our code doesn't care about the specific type of the object passed in, only its behavior.

You can think of this process like sockets and various electronic devices. Sockets don't care whether you plug in a TV, a computer, or a hair dryer, as long as their plugs meet standards. Likewise, our make_soundfunctions don't care about the specific type of the objects passed in, as long as they implement the expected soundmethods. This is how Python polymorphism works.

When designing classes and functions, we should take advantage of Python's polymorphism as much as possible. We should focus on the behavior of objects, not their specific types. This makes our code more flexible and scalable, making it easier to adapt to changing needs.

However, there are some issues to be aware of when using polymorphism. If we rely too heavily on the specific behavior of an object, it can make the code difficult to understand and maintain. Additionally, runtime errors may result if the object passed in does not implement the expected behavior. Therefore, we need to be careful and follow best practices when using polymorphism.

Overall, polymorphism is a powerful tool for Python object-oriented programming, which can help us write more flexible and scalable code. When designing classes, we should make full use of Python's polymorphism while taking care to avoid potential problems.

7. Summary

Python classes and objects are the cornerstone of understanding object-oriented programming. Classes provide a way to encapsulate data and functions into a self-contained blueprint, thereby generating multiple independent instances - objects. These objects have all the properties and methods defined in the class, bundling data and behavior. Class inheritance provides code reuse and extension, while magic methods allow us to customize the special behavior of the class. Python's dynamic typing and polymorphism provide great flexibility for programming, realize a unified processing method for various objects, and improve the readability and scalability of the code.

If it helps, please pay more attention to TeahLead KrisChang, 10+ years of experience in the Internet and artificial intelligence industry, 10+ years of experience in technical and business team management, bachelor's degree in software engineering from Tongji, master's degree in engineering management from Fudan, Alibaba Cloud certified senior architect of cloud services, Head of AI product business with revenue of over 100 million.

<Python Panorama Series-6> Master the key to object-oriented programming in Python: in-depth exploration of classes and objects