首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >Python的实例方法把我坑惨了,原来self和cls的区别这么大

Python的实例方法把我坑惨了,原来self和cls的区别这么大

原创
作者头像
风一样的男子
发布于 2026-11-19 14:52:43
发布于 2026-11-19 14:52:43
220
举报
文章被收录于专栏:编程教程编程教程

小唐那天在写一个用户管理系统,需要给用户类加一个“从字典创建用户”的功能。

他的思路很简单:写一个方法,接收一个字典,把里面的字段取出来,创建用户实例。他觉得这个方法不需要访问某个具体用户的属性,于是写成了这样:

代码语言:javascript
复制
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def from_dict(self, data):
        return User(data["name"], data["age"])

调用时他写:

代码语言:javascript
复制
user = User.from_dict({"name": "Alice", "age": 30})

直接报错:

代码语言:javascript
复制
TypeError: from_dict() missing 1 required positional argument: 'data'

小唐愣了:“我传了data啊,为什么说少了一个参数?”

他试着通过实例调用:

代码语言:javascript
复制
u = User("Bob", 25)
new_user = u.from_dict({"name": "Alice", "age": 30})

这次不报错了,但from_dict内部用的是self,而他传进去的u和data完全没关系。方法能跑,但语义很怪:他用一个已有的用户实例,去创建一个新用户。这个已有实例除了“提供一个方法入口”之外,没有任何作用。

同事看了一眼说:“你这里应该用@classmethod,第一个参数写cls,不要写self。self是实例,cls是类。你写的是实例方法,却想当类方法用。”

小唐把代码改成:

代码语言:javascript
复制
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["age"])

User.from_dict(...)直接就能调,不需要先创建实例。而且子类调用时,cls是子类,返回的也是子类实例。

“原来self和cls不是‘两种写法’,而是‘两种方法的第一个参数’。方法的类型决定了第一个参数是谁。”

这个认知,就是很多人对实例方法、类方法、静态方法感到混乱的根源:**self和cls不是可以随便替换的名字,它们分别属于不同的方法类型,代表不同的东西。**

先看一个最直观的对比

代码语言:javascript
复制
class Demo:
    def instance_method(self):
        print(f"self 是: {self}")

    @classmethod
    def class_method(cls):
        print(f"cls 是: {cls}")

    @staticmethod
    def static_method():
        print("没有 self 也没有 cls")

调用结果:

代码语言:javascript
复制
d = Demo()

d.instance_method()    # self 是: <Demo object at 0x...>,实例
Demo.class_method()    # cls 是: <class 'Demo'>,类
d.class_method()       # cls 是: <class 'Demo'>,还是类,不是实例
Demo.static_method()   # 没有 self 也没有 cls

关键差异:

  • self指向实例,是对象本身。
  • cls指向类,是类本身。
  • 实例方法必须通过实例调用,self自动绑定到那个实例。
  • 类方法通过类或实例调用都可以,cls始终绑定到类。
  • 静态方法没有隐式参数。

用一个生活场景来理解。

你有一个公司,公司里有员工。

self是员工本人。员工说“我要请假”,这个“我”指的是具体的某个员工。他知道自己的工号、自己的部门、自己的工资。

cls是公司这个组织。公司说“我们要招人”,这个“我们”指的是公司整体,不是某个具体员工。它知道公司的名称、公司的规章制度,但不知道某个员工的私人信息。

区别一目了然:self代表“某一个具体的个体”,cls代表“这一类事物的整体”。

self:实例的引用

self是实例方法的第一个参数,指向调用该方法的实例。

代码语言:javascript
复制
class User:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hello, {self.name}"

u = User("Alice")创建实例,u.greet()调用时,Python自动把u作为self传入。self.name就是u.name。

self不是关键字,只是一个约定俗成的名字。你完全可以写成this或者obj:

代码语言:javascript
复制
class User:
    def greet(this):
        return f"Hello, {this.name}"

但永远不要这么做。self是Python社区的强约定,所有读代码的人都默认第一个参数叫self。改成别的名字,代码能跑,但可读性会大打折扣,而且会被linter警告。

self的核心能力是访问实例属性:

代码语言:javascript
复制
class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1  # 修改的是这个实例的 count

每个实例有自己的count,互不干扰。self让方法知道“我操作的是哪个实例的数据”。

cls:类的引用

cls是类方法的第一个参数,指向调用该方法的类。

代码语言:javascript
复制
class User:
    species = "human"

    @classmethod
    def get_species(cls):
        return cls.species

User.get_species()调用时,cls是User。cls.species就是User.species。

cls的核心能力是访问类属性、创建实例、感知调用类:

代码语言:javascript
复制
class User:
    def __init__(self, name):
        self.name = name

    @classmethod
    def create(cls, name):
        return cls(name)  # 用 cls 创建实例

create用cls(name)而不是User(name),这样在子类调用时,创建的是子类实例。

cls同样是约定名,不是关键字,但同样不要改。

坑一:在实例方法里用 cls

代码语言:javascript
复制
class User:
    def greet(cls):  # 参数名叫 cls,但这是实例方法
        return f"Hello"

这个方法的第一个参数虽然叫cls,但它仍然是实例方法。通过实例调用时,cls收到的是实例,不是类。

代码语言:javascript
复制
u = User()
u.greet()  # 能跑,但 cls 是 u,不是 User
User.greet()  # TypeError: missing 1 required positional argument

参数名不会改变方法的类型。方法的类型由装饰器决定,不是由第一个参数的名字决定。把self写成cls不会让实例方法变成类方法,只会让读代码的人困惑。

坑二:在类方法里用 self

代码语言:javascript
复制
class User:
    @classmethod
    def greet(self):  # 参数名叫 self,但这是类方法
        return f"Hello, {self.name}"  # AttributeError

@classmethod的第一个参数收到的是类,不是实例。参数名叫self不会改变这个事实。self.name会去找User.name这个类属性,找不到就报AttributeError。

@classmethod里访问实例属性是根本性的错误:类方法不知道“具体是哪个实例”,因为调用时可能根本没有实例。

坑三:用实例方法实现工厂

这就是小唐踩的坑。

代码语言:javascript
复制
class User:
    def from_dict(self, data):
        return User(data["name"], data["age"])

from_dict被定义成实例方法,第一个参数是self。但这个方法根本不需要访问实例状态,它只是“接收一个字典,创建一个新用户”。用实例方法实现,导致调用时必须先有一个实例,语义上很别扭。

正确的做法是用@classmethod:

代码语言:javascript
复制
@classmethod
def from_dict(cls, data):
    return cls(data["name"], data["age"])

@classmethod不要求有实例,User.from_dict(...)直接调用,cls自动绑定到User。

判断标准:方法需要访问实例属性吗? 需要,用实例方法(self)。不需要,但需要创建实例或访问类属性,用类方法(cls)。

坑四:在类方法里写死类名

代码语言:javascript
复制
class User:
    @classmethod
    def from_dict(cls, data):
        return User(data["name"], data["age"])  # 写死了 User

cls参数摆在那儿没用,创建实例时写死了User。子类调用SubUser.from_dict(...),返回的还是User,不是SubUser。

代码语言:javascript
复制
@classmethod
def from_dict(cls, data):
    return cls(data["name"], data["age"])  # 用 cls

cls(...)让子类调用时返回子类实例。这是@classmethod存在的核心价值之一。

坑五:混淆 self 和 cls 的绑定时机

实例方法的self在调用时绑定到实例。类方法的cls在调用时绑定到类。

代码语言:javascript
复制
class User:
    def instance_method(self):
        return self

    @classmethod
    def class_method(cls):
        return cls
代码语言:javascript
复制
u = User()

print(u.instance_method() is u)      # True,self 是 u
print(User.class_method() is User)   # True,cls 是 User
print(u.class_method() is User)      # True,通过实例调用,cls 仍然是 User
print(u.class_method() is u)         # False,cls 不是实例

通过实例调用类方法时,cls仍然是类,不是实例。这个行为容易让人误以为“通过实例调用就会传实例”,实际上类方法永远不接收实例。

坑六:staticmethod 里想用 self 或 cls

代码语言:javascript
复制
class User:
    @staticmethod
    def greet():
        return f"Hello, {self.name}"  # NameError: self 不存在

@staticmethod没有隐式参数,既没有self也没有cls。方法体里引用self或cls都会报NameError。

静态方法如果需要访问实例或类,就不应该用@staticmethod。它适合的是“完全独立于实例和类的工具函数”。

那 self 和 cls 能互换吗?

不能。

self和cls不是“同一个东西的两个名字”。它们代表不同的对象,属于不同的方法类型。

代码语言:javascript
复制
# 实例方法:self 是实例
def method(self): ...

# 类方法:cls 是类
@classmethod
def method(cls): ...

# 静态方法:没有隐式参数
@staticmethod
def method(): ...

把self写成cls,方法仍然是实例方法,cls收到的是实例。把cls写成self,方法仍然是类方法,self收到的是类。参数名不改变方法类型,只改变可读性。

方法类型由装饰器决定,第一个参数的名字只是约定。 但约定极其重要,因为它们向读代码的人传递了“这个方法操作的是什么”的信号。

什么时候用 self,什么时候用 cls?

判断标准:

方法需要访问或修改实例属性:用实例方法,第一个参数self。

方法需要创建实例、访问类属性、或者需要感知调用类(支持继承):用类方法,第一个参数cls。

方法既不需要实例也不需要类,只是逻辑上属于这个类的工具函数:用静态方法,没有隐式参数。

方法需要访问实例属性,但也需要类级别的信息:实例方法里可以用self.__class__或type(self)拿到类,但更清晰的做法是拆成两个方法,或者用@classmethod配合实例参数。

不确定:先写实例方法。如果发现方法体里根本没用到self,再考虑改成@classmethod或@staticmethod。

一个容易忽略的细节:self 在继承中的多态

self在继承中有一个强大的特性:它指向的是实际实例的类型,不是定义方法的类的类型。

代码语言:javascript
复制
class Animal:
    def speak(self):
        return f"{self.__class__.__name__} makes a sound"

class Dog(Animal):
    pass

d = Dog()
print(d.speak())  # "Dog makes a sound",self 是 Dog 实例

speak定义在Animal里,但self是Dog实例,self.__class__是Dog。这就是多态的基础:父类的方法可以操作子类的实例。

cls在继承中也有类似的特性:cls是实际调用类的类型。

代码语言:javascript
复制
class Animal:
    @classmethod
    def create(cls):
        return cls()

class Dog(Animal):
    pass

print(type(Dog.create()))  # <class 'Dog'>,cls 是 Dog

两者的区别在于:self绑定到实例,cls绑定到类。在继承链中,它们都指向“最具体的那个类型”,但一个是实例层面,一个是类层面。

回到小唐的故事

小唐最终的代码是这样的:

代码语言:javascript
复制
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Hello, {self.name}"  # 需要实例属性,用 self

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["age"])  # 需要创建实例,用 cls

    @staticmethod
    def is_valid_name(name):
        return bool(name and name.strip())  # 不需要实例也不需要类

greet用self,因为它需要访问self.name。from_dict用cls,因为它要创建实例,并且要支持子类。is_valid_name用@staticmethod,因为它只是一个名字校验工具,和实例、类都无关。

他后来在团队文档里写了一条:“self是实例,cls是类。实例方法用self,类方法用cls。方法类型由装饰器决定,参数名不改变类型。需要创建实例的工厂方法用@classmethod,用cls(...)不要写死类名。既不需要实例也不需要类的工具函数用@staticmethod。不确定就先写实例方法,发现没用self再改。”

self和cls的区别,本质上是“操作对象”和“操作类”的区别。self让你访问某个具体实例的数据,cls让你访问类本身、创建实例、支持继承。用错了不会立即报错,但会在调用方式、继承行为、代码语义上悄悄出问题。

记住那个公司和员工的比喻:self是员工本人,知道自己工号、部门、工资;cls是公司,知道公司名称、规章制度,能招新员工,但不知道某个员工的私人信息。你要操作“某个人”,用self;你要操作“公司这个整体”,用cls。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • 先看一个最直观的对比
  • self:实例的引用
  • cls:类的引用
  • 坑一:在实例方法里用 cls
  • 坑二:在类方法里用 self
  • 坑三:用实例方法实现工厂
  • 坑四:在类方法里写死类名
  • 坑五:混淆 self 和 cls 的绑定时机
  • 坑六:staticmethod 里想用 self 或 cls
  • 那 self 和 cls 能互换吗?
  • 什么时候用 self,什么时候用 cls?
  • 一个容易忽略的细节:self 在继承中的多态
  • 回到小唐的故事
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档