Python 中 self 的用法

西门吹雪在编程

于 2024-08-27 17:31:44 发布

阅读量609

点赞数 8

分类专栏： Python 文章标签： python 开发语言 linux

本文链接：https://blog.csdn.net/m0_55213370/article/details/141608482

版权

Python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

在 Python 编程语言中，self 是一个在类定义中的方法中特殊使用的变量。它并不是 Python 语言中的一个关键字，而是一个强约定的名称，用于表示类的实例。尽管你可以将其更换为其他名称，但为了保持代码的可读性和 Python 编程的惯例，开发者通常都使用 self。

什么是 `self`？

self 通常用于类的方法定义中。简单来说，它代表了类的实例本身，并且用于访问属于类的变量和方法。在 Python 中，当我们定义一个类时，我们会定义其中的属性和方法。当创建一个类的实例时，这个实例可以调用类中的方法和访问属性。而 self 的主要作用就是在这些方法中，指代当前的实例。

当你在类的方法中使用 self 时，Python 会自动将当前对象传递给该方法。这使得我们可以在类的方法中通过 self 访问对象的属性、调用其他方法，甚至是进行对象之间的比较。

`self` 的使用场合

self 主要用于以下几个场合：

实例变量的访问：在类的构造方法（通常是 __init__ 方法）中，self 用于初始化实例变量。这些实例变量是与具体实例相关联的，而不是与类本身相关联。使用 self 可以确保实例变量在类的各个方法中都可以被正确访问。
实例方法的调用：当你在一个类的方法中调用同一个类的其他方法时，需要通过 self 来进行调用。这确保了你调用的是该实例的方法，而不是其他实例或类的全局方法。
方法的定义：每个实例方法的第一个参数必须是 self。这也是 Python 的约定，它使得方法可以访问和修改对象的状态。如果没有 self，方法将无法区分实例之间的属性和方法，从而导致错误的结果。
区别局部变量和实例变量：在类的方法中，你可能会定义一些局部变量。为了区分这些局部变量和实例变量，self 用于指代实例变量，从而避免变量名冲突。

实例分析

为了更好地理解 self 的作用，我们来看一个具体的例子：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def sit(self):
        print(f"{self.name} is now sitting.")
    
    def roll_over(self):
        print(f"{self.name} rolled over!")

在这个例子中，Dog 是一个类。__init__ 方法是类的构造函数，当创建 Dog 的实例时，__init__ 方法会自动调用。self.name = name 和 self.age = age 这两行代码将传递给 __init__ 的 name 和 age 参数的值存储在实例的 name 和 age 属性中。

self 在这里的作用是确保每个 Dog 实例有自己独立的 name 和 age 属性，而不是所有 Dog 实例共享同样的属性。如果你没有使用 self，这些属性将成为局部变量，无法在其他方法中访问。

下面我们创建一个 Dog 的实例，并调用它的方法：

my_dog = Dog('Willie', 6)
print(my_dog.name)  # 输出：Willie
print(my_dog.age)   # 输出：6

my_dog.sit()        # 输出：Willie is now sitting.
my_dog.roll_over()  # 输出：Willie rolled over!

在这个例子中，my_dog 是一个 Dog 类的实例。通过调用 my_dog.sit()，我们可以看到 Willie is now sitting. 被打印出来了。这里的 sit 方法通过 self.name 访问了实例的 name 属性，并使用它来打印消息。

为什么 `self` 必须作为第一个参数？

当调用一个实例方法时，Python 会自动将该实例传递给方法的第一个参数。为了让方法能够访问实例的属性和方法，必须要有一个变量来接收这个实例。这个变量通常被命名为 self，并且作为方法的第一个参数。正因为如此，即使你不显式地传递 self，Python 也会自动地将当前对象作为第一个参数传递给方法。

你可能会想，既然 self 是自动传递的，为什么还要显式声明它？原因在于 Python 的设计哲学——“显式优于隐式”。通过显式声明 self，代码的意图更加明确，并且程序员可以清晰地看到方法与实例之间的关系。

`self` 与类变量的关系

在 Python 中，类变量是与类本身相关联的变量，而实例变量则是与具体的实例相关联的变量。类变量在所有实例之间共享，而实例变量则是独立的。

来看一个例子：

class Dog:
    species = "Canis familiaris"

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

在这个例子中，species 是一个类变量，它对于所有的 Dog 实例来说都是相同的。而 name 和 age 则是实例变量，每个实例都可以有自己的 name 和 age。

你可以通过类名或实例名来访问类变量，但访问实例变量时必须使用 self：

print(Dog.species)  # 输出：Canis familiaris

my_dog = Dog('Willie', 6)
print(my_dog.species)  # 输出：Canis familiaris

在这个例子中，无论是通过 Dog 还是 my_dog，访问 species 都会返回相同的值。但如果你尝试这样做：

print(Dog.name)  # 报错

你会发现这会报错，因为 name 是实例变量，不能通过类名直接访问，必须通过 self 来访问。

`self` 在继承中的应用

在面向对象编程中，继承是一个非常重要的概念。继承允许你基于已有的类创建新类，新类可以继承旧类的属性和方法，同时可以定义自己的属性和方法。

在继承中，self 仍然扮演着重要的角色，帮助子类访问父类的方法和属性。

来看一个继承的例子：

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

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

在这个例子中，Animal 是一个父类，它定义了一个初始化方法和一个 speak 方法。Dog 和 Cat 继承了 Animal，并且重写了 speak 方法。这里的 self.name 用于访问继承自 Animal 的 name 属性。

我们可以创建 Dog 和 Cat 的实例，并调用它们的 speak 方法：

my_dog = Dog('Willie')
print(my_dog.speak())  # 输出：Willie says Woof!

my_cat = Cat('Kitty')
print(my_cat.speak())  # 输出：Kitty says Meow!

在这里，无论是 Dog 还是 Cat，它们的 speak 方法都使用了 self.name 来访问实例的 name 属性，并且返回一个包含实例名称的字符串。

`self` 的一些常见误解

可以更改 self 的名称：虽然你可以将 self 替换为其他名字，比如 this 或 obj，但这会让代码难以阅读和理解，因为 self 是 Python 社区约定俗成的名称，所有的 Python 程序员都期望在类方法中看到 self。
self 是关键字：self 不是 Python 的关键字。它仅仅是一个约定用语，用于指代类的实例。你可以使用其他名称，但这不推荐。
self 必须显式传递：在调用方法时，你不需要显式传递 self。Python 会自动将实例传递给方法的第一个参数。只在定义方法时，你需要显式地声明 self 参数。

`self` 与静态方法和类方法的区别

在 Python 中，除了实例方法外，还有两种特殊的方法：静态方法（@staticmethod）和类方法（@classmethod）。

静态方法：静态方法不需要访问实例属性，也不需要 self 参数。它们通常用于一些工具函数，这些函数与类的实例无关。

类方法：类方法的第一个参数是 cls，它指代类本身，而不是类的实例。cls 在类方法中的作用类似于 self 在实例方法中的作用，但 cls 用于访问类变量和类方法。

来看一个例子：

class MyClass:
    class_variable = "I am a class variable"

    def __init__(self, value):
        self.value = value
    
    @classmethod
    def class_method(cls):
        return cls.class_variable
    
    @staticmethod
    def static_method():
        return "I don't need cls or self"

在这个例子中，class_method 是一个类方法，它使用 cls 来访问类变量。而 static_method 是一个静态方法，它既不需要 self 也不需要 cls。

print(MyClass.class_method())  # 输出：I am a class variable
print(MyClass.static_method())  # 输出：I don't need cls or self

你可以看到，class_method 访问了 class_variable 类变量，而 static_method 则是一个独立的方法，不依赖于任何实例或类。

`self` 在对象之间的比较中的应用

在类中，self 还可以用于比较不同的实例。例如，你可以使用 self 来编写 __eq__ 方法，以定义实例之间的相等性：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

在这个例子中，我们定义了一个 Person 类，并且通过 __eq__ 方法定义了两个 Person 对象是否相等。这里的 self 用于访问当前对象的属性，而 other 则是另一个需要比较的对象。

person1 = Person('Alice', 30)
person2 = Person('Alice', 30)
person3 = Person('Bob', 25)

print(person1 == person2)  # 输出：True
print(person1 == person3)  # 输出：False