《Python 从入门到精通》075|self 到底是谁:新手最常见疑惑彻底讲清

如果说面向对象这一阶段，哪一个词最容易把新手卡住，那大概率就是 self。

很多人第一次看到它时，心里都会冒出一串问题：

self 到底是谁 为什么方法里一定要写它 为什么我调用方法时没传它，代码却还能跑 为什么 self.name = name 左边右边都像名字self 是关键字吗 能不能换成别的名字

这些问题太正常了。几乎所有初学面向对象的人，都会在这里绕一圈。

这一章，我们就不着急堆概念，而是专门把 self 这件事讲透。你只要把这一章吃明白，前面几章关于类、对象、__init__ 的内容会一下子变顺很多。

一、先给结论：self 可以先理解成“对象自己”

先给你一个最实用、最够用的结论：

self 可以先粗略理解成“当前这个对象自己”。

比如看这段代码：

classStudent:defintroduce(self):        print('大家好')

这里的 self，你先不要把它想得太神秘。你只要先理解成：

这个方法在执行时，需要知道“当前到底是哪一个对象在调用它”。

所以 self 的作用，就是把“当前对象自己”传进来。

这一句话你先抓住，后面一层层展开，就不会乱。

二、为什么一定要有 self

先看一个没有 self 的想象场景。

假设你定义一个学生类，里面有方法要输出对象自己的姓名：

classStudent:defintroduce():        print(self.name)

这段代码的问题在哪？

问题在于，方法根本不知道它现在面对的是谁。 到底是张三这个对象在自我介绍，还是李四这个对象在自我介绍，它没有入口知道。

所以方法内部必须有一种方式，能拿到“当前对象自己”。

这个入口，就是 self。

也就是说，`self`` 不是为了显得高级，而是因为方法必须知道它现在正在操作哪个对象。

三、先看一个最经典的例子

classStudent:def__init__(self, name, age):        self.name = name        self.age = agedefintroduce(self):        print(f'我叫{self.name}，今年{self.age}岁')

创建对象：

stu1 = Student('张三', 18)stu2 = Student('李四', 19)stu1.introduce()stu2.introduce()

输出结果：

我叫张三，今年18岁我叫李四，今年19岁

这段代码为什么能对两个对象输出不同结果？

因为：

stu1.introduce() 执行时，self 指的是 stu1stu2.introduce() 执行时，self 指的是 stu2

所以方法里虽然写的是同一套代码：

print(f'我叫{self.name}，今年{self.age}岁')

但它取到的数据，会跟着当前对象走。

这就是 self 最本质的价值。

四、谁调用方法，self 就是谁

这一句你一定要牢牢记住：

谁调用方法，self 就是谁。

比如：

stu1.introduce()

这里是 stu1 调用了 introduce()，所以 self 就是 stu1。

再比如：

stu2.introduce()

这里是 stu2 调用了 introduce()，所以 self 就是 stu2。

这句话几乎能解决你现阶段关于 self 的大部分困惑。

很多人一开始觉得 self 很抽象，其实不是它抽象，而是因为脑子里没把“调用者”和“当前对象”这层关系建立起来。

只要这层关系一通，self 立刻就顺了。

五、那为什么调用方法时，我明明没写 self

这是新手最常问的一个问题。

比如你调用方法时写的是：

stu1.introduce()

你明明只写了一个空括号，根本没写 self，那它是怎么进去的？

答案是：

Python 会在对象调用方法时，自动把当前对象传给第一个参数。

也就是说：

stu1.introduce()

背后你可以先粗略理解成：

Student.introduce(stu1)

再比如：

stu2.introduce()

背后你可以先粗略理解成：

Student.introduce(stu2)

所以不是 self 不存在，而是 Python 帮你自动传了。

这也是为什么方法定义时必须留出第一个位置。

六、为什么方法定义时必须写 self

看下面这个方法：

classStudent:defintroduce(self):        print('你好')

这里为什么不能写成：

classStudent:defintroduce():        print('你好')

因为你是通过对象调用它的：

stu1.introduce()

既然对象调用时，Python 会自动把对象本身传进来，那方法定义时就必须有一个位置来接住它。

这个位置，通常我们就写成 self。

所以不要把 self 理解成一种“奇怪规定”，它其实就是方法定义里的第一个参数位置，只不过这个参数专门用来接当前对象。

七、self 不是关键字，它只是一个约定俗成的名字

这点特别重要，很多人会误会。

self 不是 Python 关键字。 它不是像 if、for、class 那样不能改的保留字。

理论上，你完全可以写成这样：

classStudent:defintroduce(this):        print('你好')

甚至这样：

classStudent:defintroduce(abc):        print('你好')

语法上都可能成立。

但为什么大家都写 self

因为这是 Python 社区长期形成的标准习惯。 别人一看到 self，马上就知道这里代表“当前对象自己”。

所以虽然它 technically 可以改名，但你几乎不要这么做。 因为这样会让代码变得很别扭，也不符合大家的阅读习惯。

你可以把它理解成：

不是法律规定必须叫 self，但行业里默认都这么叫。

八、self.name = name 这句到底怎么读

这一句是让无数新手发懵的名场面。

self.name = name

左边也是 name，右边也是 name，看起来特别容易混。

其实你可以把它拆开读。

左边的：

self.name

表示“这个对象自己的 name 属性”。

右边的：

name

表示“创建对象时外面传进来的参数”。

所以整句话翻译成人话就是：

把外面传进来的 name，保存到对象自己的 name 属性里。

再看完整一点：

classStudent:def__init__(self, name, age):        self.name = name        self.age = age

你可以这样理解：

创建对象时，外面给了一个姓名和年龄__init__ 收到它们 然后把它们存到对象自己身上

这样一翻译，是不是一下就清楚多了。

九、左边加 self，右边不加 self，到底为什么

这个点必须单独说透。

还是看这句：

self.name = name

为什么左边加 self，右边不加？

因为左边是在说对象自己的属性。 右边是在说当前方法收到的局部参数。

它们不是同一个层面的东西。

右边的 name，只是方法执行时收到的一个普通参数。 左边的 self.name，则是这个对象以后长期保存的数据。

你可以把它理解成：

右边是临时拿到的值 左边是正式存进对象档案里的值

所以这句代码，本质上是在做“从临时参数，到对象属性”的转存。

十、如果方法里不用对象自己的属性，还要写 self 吗

只要它是实例方法，通常还是要写。

比如：

classDog:defbark(self):        print('汪汪汪')

虽然这里方法体里没有用到 self.name、self.age 这些属性，但它依然是一个由对象调用的实例方法，所以第一个参数位置还是要留给当前对象。

因为 Python 调用时会自动把对象传进来。 你不留这个位置，参数数量就对不上。

所以现阶段你可以这样理解：

只要是实例方法，第一个参数就先老老实实写 self。

后面讲类方法和静态方法时，你会看到别的情况。

十一、init 里的 self 和普通方法里的 self，是同一个思路

很多人会把 __init__ 里的 self 和普通方法里的 self 分开理解，其实没必要。

看 __init__：

classStudent:def__init__(self, name):        self.name = name

再看普通方法：

classStudent:defintroduce(self):        print(self.name)

这两个 self 本质上是同一个意思：

都表示当前对象自己。

在 __init__ 里，self 负责“给对象自己装数据”。 在普通方法里，self 负责“读取或修改对象自己的数据”。

所以你不要把 self 想成只在 __init__ 里才特殊。 它在实例方法体系里，逻辑是完全统一的。

十二、再看一个完整过程：对象创建到方法调用

下面这段代码，建议你认真顺一遍：

classStudent:def__init__(self, name, score):        self.name = name        self.score = scoredefshow_score(self):        print(f'{self.name} 的成绩是 {self.score}')

创建对象：

stu1 = Student('张三', 95)stu2 = Student('李四', 88)

调用方法：

stu1.show_score()stu2.show_score()

现在把整个过程翻译成人话。

第一步，执行：

stu1 = Student('张三', 95)

Python 创建一个新对象，把它交给 self，然后把 '张三' 和 95 传进去。 于是这个对象身上有了：

name = 张三score = 95

第二步，执行：

stu1.show_score()

此时 self 代表 stu1，所以读取到的是：

self.name -> 张三self.score -> 95

于是输出张三的成绩。

同理，stu2 也是一样的逻辑。

你会发现，一旦从“当前对象”这个角度去想，整个流程特别自然。

十三、self 最大的作用，不是记语法，而是让方法知道自己在服务谁

这句话你可以反复看。

实例方法不是空气里的函数。 它们是属于对象的行为。

既然是对象的行为，那方法就必须知道自己此刻正在服务哪个对象。

这个“知道自己在服务谁”的能力，就是 self 提供的。

没有 self，方法就失去了对象归属感。 有了 self，方法才能真正围绕对象自己的属性工作。

所以从本质上讲，self 是对象和方法之间的一座桥。

十四、方法里如何修改对象自己的属性

self 不只是能读属性，也能改属性。

比如：

classPhone:def__init__(self, brand, battery):        self.brand = brand        self.battery = batterydefcharge(self):        self.battery = self.battery + 10        print(f'{self.brand} 当前电量是 {self.battery}%')

创建对象：

phone1 = Phone('华为', 50)phone1.charge()phone1.charge()

输出结果：

华为 当前电量是 60%华为 当前电量是 70%

这里为什么电量会变化？

因为方法里写了：

self.battery = self.battery + 10

这表示不是改某个外部变量，而是在改这个对象自己身上的 battery 属性。

这也是 self 非常关键的地方。 它让方法不仅能访问对象状态，还能改变对象状态。

十五、如果一个类有多个对象，self 会不会串掉

不会，这正是 self 的价值之一。

比如：

classPhone:def__init__(self, brand, battery):        self.brand = brand        self.battery = batterydefcharge(self):        self.battery += 10        print(f'{self.brand} 当前电量是 {self.battery}%')

创建两个对象：

p1 = Phone('华为', 50)p2 = Phone('小米', 30)p1.charge()p2.charge()p1.charge()

输出结果：

华为 当前电量是 60%小米 当前电量是 40%华为 当前电量是 70%

你会发现，两个对象各改各的，不会互相影响。

因为：

p1.charge() 时，self 是 p1p2.charge() 时，self 是 p2

所以 self 天然就把不同对象隔开了。

十六、一个很常见的错误：忘了写 self

这是初学者高频踩坑点。

比如你写：

classStudent:defintroduce():        print('你好')

然后调用：

stu1 = Student()stu1.introduce()

这里就容易报参数相关的错误。

因为对象调用方法时，Python 自动把对象传进来了，但你的方法定义里根本没有位置接住它。

所以这个坑你一定要提前避开：

实例方法的第一个参数，先默认写 self。

别省，别猜，先养成习惯。

十七、另一个常见错误：方法里忘了写 self.属性

比如：

classStudent:def__init__(self, name):        self.name = namedefintroduce(self):        print(name)

这段代码看起来像是在输出姓名，实际上会报错。 因为方法里写的是 name，它会去找当前局部作用域里有没有这个变量。可这里根本没有。

正确写法应该是：

classStudent:def__init__(self, name):        self.name = namedefintroduce(self):        print(self.name)

因为你要取的是对象自己的属性，而不是某个凭空存在的局部变量。

所以从这一章开始，你要慢慢形成一个反射：

方法里想访问对象自己的数据，优先想 self.xxx。

十八、self 和普通参数可以同时出现

当然可以。

比如：

classBankAccount:def__init__(self, owner, balance):        self.owner = owner        self.balance = balancedefdeposit(self, amount):        self.balance += amount        print(f'{self.owner} 存入了 {amount} 元，当前余额是 {self.balance} 元')

这里的 deposit 方法里，既有 self，也有 amount。

什么意思？

self 表示当前账户对象自己。amount 表示这次方法调用时额外传进来的金额。

调用时：

acc1 = BankAccount('张三', 1000)acc1.deposit(200)

这时：

self -> acc1amount -> 200

这就非常典型地展示了，self 是对象自己，其他参数则是这次行为额外需要的信息。

十九、现阶段怎么判断什么时候该写 self

你先记一个够用的判断法。

如果你在类里定义的是实例方法，那么第一个参数先写 self。 如果你在方法里要访问或修改对象自己的属性，就写成 self.xxx。

这两个判断，足够你应付当前阶段 90% 的使用场景。

后面讲类方法和静态方法时，你会看到例外情况。 但现阶段，先把这套主线练熟最重要。

二十、把 self 彻底翻译成人话

到这里，你其实已经可以把 self 总结成一句很朴素的话了：

self 就是方法内部用来表示“当前对象自己”的那个名字。

它的作用主要有两个：

第一，让方法知道现在是谁在调用它。 第二，让方法可以访问和修改这个对象自己的属性。

只要这两点你牢牢抓住，后面很多语法细节都只是展开而已。

二十一、本章小练习

你可以自己做两个很适合巩固的练习。

第一个练习，定义一个 Book 类。

要求：

通过 __init__ 接收 title 和 price写一个 show_info() 方法，输出书名和价格

参考代码：

classBook:def__init__(self, title, price):        self.title = title        self.price = pricedefshow_info(self):        print(f'书名：{self.title}，价格：{self.price}元')book1 = Book('Python 入门', 59)book2 = Book('数据分析实战', 88)book1.show_info()book2.show_info()

第二个练习，定义一个 Lamp 类。

要求：

通过 __init__ 接收 name 和 is_on写两个方法 turn_on() 和 turn_off()分别修改对象自己的状态并输出结果

参考代码：

classLamp:def__init__(self, name, is_on):        self.name = name        self.is_on = is_ondefturn_on(self):        self.is_on = True        print(f'{self.name} 已打开')defturn_off(self):        self.is_on = False        print(f'{self.name} 已关闭')lamp1 = Lamp('台灯', False)lamp1.turn_on()lamp1.turn_off()

一个练的是读取属性，一个练的是修改属性。你把这两个练熟，self 的感觉就会很稳。

二十二、本章总结

这一章，我们把面向对象里最容易卡人的 self 讲透了。

self 可以先理解成当前对象自己。 谁调用方法，self 就是谁。 对象调用实例方法时，Python 会自动把当前对象传给第一个参数。 所以实例方法定义时，第一个参数通常都要写 self。self.name = name 的意思，是把传进来的值保存到对象自己的属性里。 方法里如果要访问或修改对象自己的数据，通常写成 self.xxx。self 不是关键字，但它是最标准、最通用的写法。 你不用把它神秘化，它本质上就是对象和方法之间的连接入口。

到这里，类、对象、实例属性、实例方法、__init__、self 这一整套基础骨架已经基本搭起来了。 下一章我们继续往前走，进入很多人容易混淆的新内容：076｜类属性、类方法、静态方法的区别。