Python 类的定义与实例化详解

舞夢輝影

发布时间：2025-09-18 13:17:01

1102人浏览过

来源于php中文网

原创

类是对象的模板，定义属性和方法；实例化创建具体对象。__init__ 初始化实例，self 指向当前对象。类属性共享，实例属性独有。实例方法操作对象状态，类方法用 @classmethod 装饰，操作类本身；静态方法用 @staticmethod 装饰，不依赖类或实例状态，作为工具函数使用。

python 类的定义与实例化详解

Python的类定义，在我看来，就是我们对现实世界或抽象概念进行建模的一种方式，它提供了一个蓝图，而实例化则是根据这个蓝图“生产”出具体的、拥有自己状态和行为的个体——对象。简单来说，类是模板，对象是根据模板制造出来的具体物品。

解决方案

要搞懂Python的类定义与实例化，我们得从最基础的语法结构说起。定义一个类，我们用

class

关键字，后面跟着类的名称，通常遵循驼峰命名法（如

MyClass

）。类内部可以包含属性（变量）和方法（函数）。而实例化，就是通过调用这个类名，像调用函数一样，来创建一个对象。

# 类的定义
class Car:
    # 类属性：所有Car对象共享的属性
    wheels = 4

    # __init__ 方法：当对象被创建时自动调用，用于初始化实例属性
    def __init__(self, make, model, year):
        # 实例属性：每个Car对象独有的属性
        self.make = make
        self.model = model
        self.year = year
        self.engine_on = False # 默认引擎关闭

    # 实例方法：操作实例属性的行为
    def start_engine(self):
        if not self.engine_on:
            self.engine_on = True
            print(f"The {self.year} {self.make} {self.model}'s engine is now on.")
        else:
            print("The engine is already running.")

    def stop_engine(self):
        if self.engine_on:
            self.engine_on = False
            print(f"The {self.year} {self.make} {self.model}'s engine is now off.")
        else:
            print("The engine is already off.")

    def display_info(self):
        print(f"Car Info: {self.year} {self.make} {self.model}, Wheels: {Car.wheels}")

# 类的实例化
my_car = Car("Toyota", "Camry", 2020)
your_car = Car("Honda", "Civic", 2022)

# 访问实例属性
print(my_car.make) # 输出: Toyota
print(your_car.model) # 输出: Civic

# 调用实例方法
my_car.start_engine() # 输出: The 2020 Toyota Camry's engine is now on.
my_car.display_info() # 输出: Car Info: 2020 Toyota Camry, Wheels: 4
your_car.start_engine()
your_car.stop_engine()

# 访问类属性
print(Car.wheels) # 输出: 4
print(my_car.wheels) # 也可以通过实例访问，但通常建议通过类名访问类属性

这里面有几个关键点：

__init__

方法是每个类定义中非常核心的一部分，它负责在对象创建时进行初始化。

self

参数是Python约定俗成的，它代表了当前正在操作的那个实例对象本身。理解了这些，基本上就掌握了Python面向对象编程的门槛。

__init__

方法：它是构造函数吗？为什么它如此重要？

很多人刚接触Python类的时候，会习惯性地把

__init__

方法当成其他语言（比如Java或C++）里的构造函数。但严格来说，它并不是。在Python里，当你说

my_object = MyClass(...)

的时候，实际上会发生两个步骤：首先，Python会调用

__new__

方法来创建一个新的实例对象；然后，才会调用这个新创建的实例的

__init__

方法来对它进行初始化。所以，

__init__

更准确的称呼是“初始化方法”或“初始化器”。

立即学习“Python免费学习笔记（深入）”；

它的重要性不言而喻。想象一下，你生产了一批汽车，但每辆车出厂时，你总得给它贴上品牌、型号、年份这些标签，对吧？

__init__

就是干这个活儿的。它确保了每个新创建的

Car

对象在被使用之前，都拥有了它最基本、最核心的状态。如果没有它，或者它初始化不当，你的对象可能就处于一个“未定义”或“不完整”的状态，后续的操作就容易出错了。在我日常开发中，我总是会花时间仔细考虑

__init__

里需要哪些参数，以及这些参数如何正确地设置实例的初始状态，这往往决定了一个类是否好用、是否健壮。

类属性与实例属性：什么时候该用谁？

这是另一个初学者常犯迷糊的地方。简单来说，类属性是属于类本身的，所有该类的实例都共享同一个类属性。而实例属性则是每个实例独有的，它们的值可以互不影响。

类属性 (Class Attributes)：定义在类内部、方法外部的变量。它们通常用来存储那些与类的所有实例都相关、且值通常不变的数据，或者作为所有实例的默认值。比如上面
```
Car
```
例子中的
```
wheels = 4
```
，所有的汽车都有四个轮子，这是汽车这个“物种”的共性，所以它适合作为类属性。如果某个实例修改了类属性，那可能会影响到所有其他实例（除非你先给实例创建了一个同名的实例属性）。
```
class MyClass:
    class_var = "I am a class variable"

obj1 = MyClass()
obj2 = MyClass()

print(obj1.class_var) # I am a class variable
print(obj2.class_var) # I am a class variable

MyClass.class_var = "Modified by class" # 通过类修改
print(obj1.class_var) # Modified by class
print(obj2.class_var) # Modified by class

obj1.class_var = "Modified by obj1" # 这创建了一个新的实例属性，不再是类属性
print(obj1.class_var) # Modified by obj1
print(obj2.class_var) # Modified by class (obj2仍然访问的是类属性)
```
我个人觉得，类属性很适合用来做一些常量定义或者作为工厂模式中的共享配置。

成新网络商城购物系统
使用模板与程序分离的方式构建，依靠专门设计的数据库操作类实现数据库存取，具有专有错误处理模块，通过 Email 实时报告数据库错误，除具有满足购物需要的全部功能外，成新商城购物系统还对购物系统体系做了丰富的扩展，全新设计的搜索功能，自定义成新商城购物系统代码功能代码已经全面优化，杜绝SQL注入漏洞前台测试用户名：admin密码：admin888后台管理员名：admin密码：admin888

下载
实例属性 (Instance Attributes)：定义在
```
__init__
```
方法内部，并且通过
```
self.attribute_name
```
来赋值的变量。它们是每个对象独有的状态。比如
```
Car
```
的
```
make
```
、
```
model
```
、
```
year
```
，每辆车的品牌型号年份都不一样，所以它们是实例属性。
```
class AnotherClass:
    def __init__(self, value):
        self.instance_var = value

obj_a = AnotherClass("Value A")
obj_b = AnotherClass("Value B")

print(obj_a.instance_var) # Value A
print(obj_b.instance_var) # Value B
```
选择哪种属性，关键在于你这个数据是“共享的”还是“独有的”。如果所有对象都应该有相同的值，或者这个值代表了类本身的特性，那就用类属性；如果每个对象都有自己独立的状态，那就用实例属性。这是一个非常重要的设计决策，直接影响你代码的内存使用和逻辑清晰度。

方法的种类：普通方法、类方法与静态方法，它们有什么区别？

Python的类不仅仅是数据（属性）的容器，它还定义了操作这些数据（或与类相关）的行为（方法）。在Python中，方法主要分为三种：实例方法、类方法和静态方法。

实例方法 (Instance Methods)：这是我们最常见的方法类型，比如
```
Car
```
类中的
```
start_engine
```
、
```
stop_engine
```
。它们必须接收
```
self
```
作为第一个参数，这个
```
self
```
就是调用该方法的实例对象本身。实例方法可以访问和修改实例属性，也可以访问类属性。它们是对象行为的核心。
```
class Example:
    def instance_method(self):
        print(f"This is an instance method, called by {self}")
```
当我需要一个方法去改变某个特定对象的状态时，或者这个方法的操作依赖于该对象的具体数据时，我肯定会用实例方法。
类方法 (Class Methods)：使用
```
@classmethod
```
装饰器来定义。它接收
```
cls
```
作为第一个参数，这个
```
cls
```
代表的是类本身，而不是实例。类方法可以访问和修改类属性，但不能直接访问实例属性（除非通过
```
cls
```
创建新实例）。它们常用于工厂方法，或者操作类属性，或者与类本身相关的操作。
```
class MyClassWithMethods:
    class_level_data = "Shared Data"

    @classmethod
    def class_method_example(cls, new_data):
        print(f"This is a class method, called by class {cls.__name__}")
        print(f"Current class data: {cls.class_level_data}")
        cls.class_level_data = new_data # 可以修改类属性
        print(f"New class data: {cls.class_level_data}")
```
在我看来，类方法非常适合那些不需要特定实例数据，但又需要操作类本身或者创建类实例的场景。比如，你可能有一个类方法，根据不同的输入参数来创建不同类型的对象。
静态方法 (Static Methods)：使用
```
@staticmethod
```
装饰器来定义。它不接收
```
self
```
也不接收
```
cls
```
作为第一个参数。静态方法与类或实例都没有直接关系，它就像一个普通的函数，只是恰好被放在了类的命名空间下。它不能访问类属性，也不能访问实例属性。通常用于那些逻辑上与类相关，但又不需要访问类或实例特定数据的工具函数。
```
class UtilityClass:
    @staticmethod
    def static_method_example(x, y):
        print("This is a static method.")
        return x + y
```
我一般会在什么时候用静态方法呢？当一个函数与类有逻辑上的关联，但它完全不需要访问任何类或实例的状态时。比如，一个数据校验函数，它接收一些参数并返回布尔值，这个函数可能属于某个类，但它本身并不依赖于类的任何内部状态。如果我发现一个方法没有使用
```
self
```
或
```
cls
```
，我就会考虑把它变成一个静态方法，这能让代码更清晰，也暗示了它的独立性。