在这篇文章中，边肖整理了Python中self的用法和例子的内容，供大家参考。
Python类中规定函数的第一个参数是实例对象本身，习惯上将其名称写成self。它的功能相当于java中的这个，代表当前类的对象，可以调用当前类中的属性和方法。
类是一种面向对象的设计思想，实例(即对象)是按照类来创建的。
一个类应该包含数据和操作数据的方法。一般来说就是属性和函数(即调用方法)。
为什么上课要用self？
在类的代码(函数)中，需要访问当前实例中的变量和函数，即访问：
对应的变量(属性):实例。读取以前的值并写入新值。
调用相应的函数):Instance.function()，即执行相应的动作。
-需要访问实例的变量，调用实例的函数，当然需要对应的实例实例对象本身。
Python中规定函数的第一个参数必须是实例对象本身，按照惯例建议将其名称写成self。
-所以，我们需要自我。
首先，Python中类的定义：
在python中，类是由关键字class定义的：
Class后面是类名，即Person。类名通常以大写字母开头，后跟(object)，表示该类是从哪个类继承的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都要继承的类。
类别人员(对象):
及格
实例化Person类，实例化是通过类名()实现的。
类别人员(对象):
及格
Student=Person() #创建类的实例化
打印(学生)
打印(人)
可以看到，变量student指向一个人的对象，后面的0x0000026EE434D8D0就是内存地址。每个对象的地址不一样，人本身就是一个类。
您还可以将属性绑定到实例变量，例如student的name和score属性。
类别人员(对象):
及格
学生=人()
#打印(学生)
#打印(人)
Student.name='Gavin' #是一个实例变量。
学生绑定名称属性类似于赋值操作。
Student.score=100 #是为它绑定的
分数属性
打印(学生姓名)p
rint(学生分数)
虽然上面的方法可以为类的实例变量绑定属性，但是它不方便也不优雅。因为类可以起到模板的作用，所以在创建实例的时候，我们可以强制填充我们认为必须绑定的属性。在python中，是通过类中常用的一种方法，即def __init__(self)方法。在创建实例变量时，name和score等属性被捆绑在一起。
类别人员(对象):
def __init__(自己，名字，分数):
self.name=name
self.score=分数
Student=Person('Gavin '，100) #在__init__方法中传递必需的参数
打印(学生姓名)
打印(student.score)
如果传入一个空参数，将会报告一个错误：
类别人员(对象):
def __init__(自己，名字，分数):
self.name=name
self.score=分数
Student=Person() #这里应该传入一个参数，但是没有。
打印(学生姓名)
打印(student.score)
注意：
1.__init__方法的第一个参数始终是self，表示创建的实例本身。因此，在__init__方法中，可以将各种属性绑定到self，因为self指向创建的实例本身。
2.使用__init__方法，在创建实例时不能传入空参数。必须传入与__init__方法匹配的参数，但是self不需要传入。python解释器会自己传入实例变量。
在类中定义多个函数相互调用。
类别人员(对象):
def __init__(self，x，y):
self.x=x
self.y=y
定义添加(自身):
sum=self.x self.y
返回总和
定义正方形(自身):
squr=pow(self.x，2) pow(self.y，2)
返回squr
def add_square(自身):
c=self.add() self.square()
返回c
学生=Person(3，4)print(student.add())
print(student.square())
打印('-')
print(student.add_square())
从上面的例子可以看出，与普通函数相比，类中定义的函数之间只有两个区别：
1.第一个参数始终是self，调用时不需要传递这个参数。
2.在类中，函数相互调用时要添加self，如上例：c=self.add() self.square()。如果没有添加self，将会报错：函数未定义。见下图：
此外，类的方法与普通函数没有什么不同。当然，也可以使用默认参数、变量参数和关键字参数。例子如下：
类别人员(对象):
def __init__(self，x，y):
self.x=x
self.y=y
DEF (self，z=16): #设置默认变量z=16，这只是一个普通的局部变量，不是实例变量，实例变量需要
Self.z=z，如此定义。
sum=self.x self.y z
返回总和
定义正方形(自身):
squr=pow(self.x，2) pow(self.y，2)
返回squr
Add _ square (self，z): #调用时传入一个变量，也是普通的局部变量，不是实例变量。
c=self.add() self.square() z
返回c
学生=人(3，4)
print(student.add())
print(student.square())
打印('-')
print(student.add_square(16))
看了上面的例子，我可能还是不明白什么是地狱自我。为什么要用self？没关系，往下看：
其实这个家伙，self，简单来说就是把类中定义的变量和函数变成实例变量和实例函数。作为类的成员，成员之间可以相互调用，而不需要从外部调用数据(变量)和方法(函数)，实现数据封装。以上面的Person类为例：
创建实例时需要给实例变量x，y，调用函数时需要给Z。调用起来很容易，但是你不知道内部实现的细节。
总之，类是创建实例的模板，而实例是具体的对象，每个实例拥有的数据是独立的，互不影响；方法是绑定到实例的函数。与普通函数不同，方法可以直接访问实例的数据。
其实self存储的是实例变量和实例函数的属性，可以理解为字典，比如：{'name':'zhang '，' age':'18'}仅此而已。
注意只有数据属性，没有办法创建新的类。类——实例化生成——对象——(对象只是一串类似于字典的数据，类中的方法并没有复制给你。python没有新方法！)
类别人员(对象):
def __init__(self，x，y):
self.x=x
self.y=y
DEF (self，z=16): #将z设置为实例变量，即
Self.z=z，z是类的成员，不是普通的局部变量。
self.z=z
Sum=self.x self.y z # z已经实例化，但是R仍然可以作为常用变量。
总和
定义正方形(自身):
squr=pow(self.x，2) pow(self.y，2)
返回squr
def add_square(自身):
c=self . add()self . square()self . z #调用实例变量z。
返回c
学生=人(3，4)
print(student.add())
print(student.square())
打印('-')
print(student.add_square())
print(student.z) #函数add中的z实例化后，可以通过实例化来访问。
从这个例子可以看出，Z是add()函数的默认参数。通过实例化它，可以在其他函数体中调用实例变量Z。
实例化后，可以通过实例化来访问它。
那么自我到底是什么？
类别框(对象):
def __init__(self，boxname，size，color):
self.boxname=boxname
self.size=size
Self.color=color # Self是一个存储对象属性的集合，即使没有属性self，也是必须的。
def open(自己，我自己):
打印('-使用您自己的打开%s'%(我自己. color，我自己. size，我自己. boxname)的那个% s，% s)
Print(' - Open% s'% (self.color，self.size，self . box name)of the % s，%s with the class's own self)
定义关闭(自己):
打印('-关闭%s，谢谢' % self.boxname ')
B=盒子('魔法盒子'，' 14m '，'红色')
关闭()
B.open(b) #会自动传递一个自我。现在，如果B被传入，open将获得一个实例对象本身。打印出来看看是什么。
Print(b.__dict__) #这里返回的是self本身。自我储存属性，没有行动。
表示self类的实例，而不是类。自身是对象/实例属性的集合。
Box是一个类自我实例化b对象/实例。
类抽象body-instantiation-object/instance，其中包含属性：{'boxname':' magic box '，' size':' 14m '，' color':' red'}，即self。
Self看似是整个对象，其实是明确描述了类是生成对象的过程，self就是对象，所以self中的key值可以直接使用。
作为自然界中的有效物体，它必须包括：
1.描述对象的属性；2.对象的方法
所以自我是必要的，是物体的一个重要特征。
看看下面这段代码，感觉更神奇了：
类别框(对象):
def myInit(我自己，boxname，size，color):
我自己. boxname=boxname
我自己。size=size
自己写一个初始化函数，效果也一样。你甚至不用给它起名叫self。其他函数使用标准自我。
return my #返回一个对象到实例化过程！太神奇了！并且包含对象属性/字典。
# def __init__(self，boxname，size，color):
# self.boxname=boxname
# self.size=size
# self.color=color #注释掉原标准的初始化。
def open(自己，我自己):
打印(自我)
打印('-使用您自己的打开%s'%(我自己. color，我自己. size，我自己. boxname)的那个% s，% s)
Print(' - Open% s'% (myself.color，myself.size，my self . box name)of the % s，% s with the class 's own self)
定义关闭(自己):
打印('-关闭%s，谢谢' % self.boxname ')
#修改后运行结果和标准初始化没有区别。
B=方框()。myInit('魔盒'，' 14m '，'红色')
# b=Box('魔盒'，' 14m '，' red') #注释掉原来的标准初始化方法。
关闭()
B.open(b) #会自动传递一个自我。现在，如果B被传入，open将获得一个实例对象本身。打印出来看看是什么。
Print(b.__dict__) #这里返回的是self本身。自我储存属性，没有行动。
换句话说，对该类的操作是：
1.定义属性；2.调用方法
对课程的反馈是：
1.获取属性；2.实现方法
在阶级阶级的功能中，自我为什么是必要的？因为自我是对象的载体，所以可以理解为字典。请看下面的代码：
类别框(对象):
def myInit(我自己，boxname，size，color):
打印(神秘。_ _ dict _ _) #显示为{}空词典
我自己. boxname=boxname
我自己。__dict__['aa']='w'#甚至可以像字典一样操作
我自己。size=size
自己写一个初始化函数，效果也一样。你甚至不用给它起名叫self。其他函数使用标准自我。
return my #返回一个对象到实例化过程！太神奇了！并且包含对象属性/字典。
# def __init__(self，boxname，size，color):
# self.boxname=boxname
# self.size=size
# self.color=color #注释掉原标准的初始化。
def open(自己，我自己):
打印(自我)
打印('-使用您自己的打开%s'%(我自己. color，我自己. size，我自己. boxname)的那个% s，% s)
Print(' - Open% s'% (myself.color，myself.size，my self . box name)of the % s，% s with the class 's own self)
定义关闭(自己):
打印('-关闭%s，谢谢' % self.boxname ')
#修改后运行结果和标准初始化没有区别。
B=方框()。myInit('魔盒'，' 14m '，'红色')
# b=Box('魔盒'，' 14m '，' red') #注释掉原来的标准初始化方法。
关闭()
B.open(b) #会自动传递一个自我。现在，如果B被传入，open将获得一个实例对象本身。打印出来看看是什么。
Print(b.__dict__) #这里返回的是self本身。自我储存属性，没有行动。
这里注意：我自己。__dict__['aa']='w' #甚至可以像字典一样操作；在b.__dict__的结果中，显示为：' aa':'w '
所以self可以理解为存储实例化对象属性的字典，self存储属性而不执行动作。
Self在被调用时总是引用该类的实例。
python中的一些特殊实例变量：
1.私有变量，只能在内部访问，不能在外部访问。私有变量在其名称前以两个下划线开头，如：__name。事实上，private变量并非完全无法从外部访问。不能直接访问，因为python解释器在外部把__name变量改成了_ class name __name，所以仍然可以通过_ class name __name访问__name。
2.在Python中，变量名类似于__xxx__，即以双下划线开头，以双下划线结尾。它是一个特殊的变量，可以直接访问，不是私有变量。因此，不能使用__name__和__score__等变量名。
3.以下划线开头的实例变量名，如_name，可以从外部访问。但按照既定规则，看到这样的变量，就意味着“虽然我可以被访问，但请把我当成私有变量，不要随意访问”。
以上是Python中阅读自我的详细内容。更多请关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。