
小唐那天在写一个用户管理系统,需要给用户类加一个“从字典创建用户”的功能。
他的思路很简单:写一个方法,接收一个字典,把里面的字段取出来,创建用户实例。他觉得这个方法不需要访问某个具体用户的属性,于是写成了这样:
class User:
def __init__(self, name, age):
self.name = name
self.age = age
def from_dict(self, data):
return User(data["name"], data["age"])调用时他写:
user = User.from_dict({"name": "Alice", "age": 30})直接报错:
TypeError: from_dict() missing 1 required positional argument: 'data'小唐愣了:“我传了data啊,为什么说少了一个参数?”
他试着通过实例调用:
u = User("Bob", 25)
new_user = u.from_dict({"name": "Alice", "age": 30})这次不报错了,但from_dict内部用的是self,而他传进去的u和data完全没关系。方法能跑,但语义很怪:他用一个已有的用户实例,去创建一个新用户。这个已有实例除了“提供一个方法入口”之外,没有任何作用。
同事看了一眼说:“你这里应该用@classmethod,第一个参数写cls,不要写self。self是实例,cls是类。你写的是实例方法,却想当类方法用。”
小唐把代码改成:
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不是可以随便替换的名字,它们分别属于不同的方法类型,代表不同的东西。**
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")调用结果:
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是实例方法的第一个参数,指向调用该方法的实例。
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:
class User:
def greet(this):
return f"Hello, {this.name}"但永远不要这么做。self是Python社区的强约定,所有读代码的人都默认第一个参数叫self。改成别的名字,代码能跑,但可读性会大打折扣,而且会被linter警告。
self的核心能力是访问实例属性:
class Counter:
def __init__(self):
self.count = 0
def increment(self):
self.count += 1 # 修改的是这个实例的 count每个实例有自己的count,互不干扰。self让方法知道“我操作的是哪个实例的数据”。
cls是类方法的第一个参数,指向调用该方法的类。
class User:
species = "human"
@classmethod
def get_species(cls):
return cls.speciesUser.get_species()调用时,cls是User。cls.species就是User.species。
cls的核心能力是访问类属性、创建实例、感知调用类:
class User:
def __init__(self, name):
self.name = name
@classmethod
def create(cls, name):
return cls(name) # 用 cls 创建实例create用cls(name)而不是User(name),这样在子类调用时,创建的是子类实例。
cls同样是约定名,不是关键字,但同样不要改。
class User:
def greet(cls): # 参数名叫 cls,但这是实例方法
return f"Hello"这个方法的第一个参数虽然叫cls,但它仍然是实例方法。通过实例调用时,cls收到的是实例,不是类。
u = User()
u.greet() # 能跑,但 cls 是 u,不是 User
User.greet() # TypeError: missing 1 required positional argument参数名不会改变方法的类型。方法的类型由装饰器决定,不是由第一个参数的名字决定。把self写成cls不会让实例方法变成类方法,只会让读代码的人困惑。
class User:
@classmethod
def greet(self): # 参数名叫 self,但这是类方法
return f"Hello, {self.name}" # AttributeError@classmethod的第一个参数收到的是类,不是实例。参数名叫self不会改变这个事实。self.name会去找User.name这个类属性,找不到就报AttributeError。
@classmethod里访问实例属性是根本性的错误:类方法不知道“具体是哪个实例”,因为调用时可能根本没有实例。
这就是小唐踩的坑。
class User:
def from_dict(self, data):
return User(data["name"], data["age"])from_dict被定义成实例方法,第一个参数是self。但这个方法根本不需要访问实例状态,它只是“接收一个字典,创建一个新用户”。用实例方法实现,导致调用时必须先有一个实例,语义上很别扭。
正确的做法是用@classmethod:
@classmethod
def from_dict(cls, data):
return cls(data["name"], data["age"])@classmethod不要求有实例,User.from_dict(...)直接调用,cls自动绑定到User。
判断标准:方法需要访问实例属性吗? 需要,用实例方法(self)。不需要,但需要创建实例或访问类属性,用类方法(cls)。
class User:
@classmethod
def from_dict(cls, data):
return User(data["name"], data["age"]) # 写死了 Usercls参数摆在那儿没用,创建实例时写死了User。子类调用SubUser.from_dict(...),返回的还是User,不是SubUser。
@classmethod
def from_dict(cls, data):
return cls(data["name"], data["age"]) # 用 clscls(...)让子类调用时返回子类实例。这是@classmethod存在的核心价值之一。
实例方法的self在调用时绑定到实例。类方法的cls在调用时绑定到类。
class User:
def instance_method(self):
return self
@classmethod
def class_method(cls):
return clsu = 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仍然是类,不是实例。这个行为容易让人误以为“通过实例调用就会传实例”,实际上类方法永远不接收实例。
class User:
@staticmethod
def greet():
return f"Hello, {self.name}" # NameError: self 不存在@staticmethod没有隐式参数,既没有self也没有cls。方法体里引用self或cls都会报NameError。
静态方法如果需要访问实例或类,就不应该用@staticmethod。它适合的是“完全独立于实例和类的工具函数”。
不能。
self和cls不是“同一个东西的两个名字”。它们代表不同的对象,属于不同的方法类型。
# 实例方法:self 是实例
def method(self): ...
# 类方法:cls 是类
@classmethod
def method(cls): ...
# 静态方法:没有隐式参数
@staticmethod
def method(): ...把self写成cls,方法仍然是实例方法,cls收到的是实例。把cls写成self,方法仍然是类方法,self收到的是类。参数名不改变方法类型,只改变可读性。
方法类型由装饰器决定,第一个参数的名字只是约定。 但约定极其重要,因为它们向读代码的人传递了“这个方法操作的是什么”的信号。
判断标准:
方法需要访问或修改实例属性:用实例方法,第一个参数self。
方法需要创建实例、访问类属性、或者需要感知调用类(支持继承):用类方法,第一个参数cls。
方法既不需要实例也不需要类,只是逻辑上属于这个类的工具函数:用静态方法,没有隐式参数。
方法需要访问实例属性,但也需要类级别的信息:实例方法里可以用self.__class__或type(self)拿到类,但更清晰的做法是拆成两个方法,或者用@classmethod配合实例参数。
不确定:先写实例方法。如果发现方法体里根本没用到self,再考虑改成@classmethod或@staticmethod。
self在继承中有一个强大的特性:它指向的是实际实例的类型,不是定义方法的类的类型。
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是实际调用类的类型。
class Animal:
@classmethod
def create(cls):
return cls()
class Dog(Animal):
pass
print(type(Dog.create())) # <class 'Dog'>,cls 是 Dog两者的区别在于:self绑定到实例,cls绑定到类。在继承链中,它们都指向“最具体的那个类型”,但一个是实例层面,一个是类层面。
小唐最终的代码是这样的:
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 删除。