一文读懂Python中的self-Python教程

神秘的self：

正在Python类中规则，函数的第一个参数是实例工具自身，而且商定俗成，把其名字写为self。其作用相称于java中的this，示意以后类的工具，能够挪用以后类中的属性以及办法。

class是面向工具的设计思维，instance（也便是 object，工具）是依据 class 创立的。

一个类（class）应该蕴含数据以及操作数据的办法，浅显来说就是属性以及函数（即挪用办法）。

类 class 中为啥用应用 self ？

正在类的代码（函数）中，需求拜访以后的实例中的变量以及函数，即拜访Instance中的：

对应的变量（property)：Instance.ProperyNam，去读取以前的值以及写入新的值。

挪用对应函数（function）：Instance.function()，即执行对应的举措。

-> 而需求拜访实例的变量以及挪用实例的函数，当然需求对应的实例Instance工具自身。

-> 而Python中就规则好了，函数的第一个参数，就必需是实例工具自身，而且倡议，商定俗成，把其名字写为self。

-> 以是，咱们需求self（需求用到self）。

起首，正在Python中类的界说：

正在python中，类是经过要害字 class 界说的：

class 前面紧跟类名，即 Person，类名通常年夜写字母扫尾，紧接着是(object),示意该类是从哪一个类承继上去的，通常，假如不合适的 承继类，就应用 object 类，这是一切类终极城市承继的类。

class Person（object）:
    pass

将 Person类实例化，创立实例化是经过 类名+() 完成的。

class Person(object):
    pass
student = Person()    # 创立类的实例化
print(student)
print(Person)

能够看到，变量 student 指向的就是一个 Person的 object，前面的 0x0000026EE434D8D0 是内存地点，每一个 object 的地点都纷歧样，而 Person 自身则是一个类。

也能够给实例变量绑定属性，比方：为 student 绑定 name 以及 score 属性

class Person(object):
    pass
student = Person()
# print(student)
# print(Person)
student.name = "Gavin"     # 为实例变量 student 绑定 name 属性   相似于 赋值 操作
student.score = 100        # 为 其绑定  score 属性
print(student.name)
print(student.score)

上述的办法尽管能够为类的实例变量绑定属性，然而不敷不便以及elegant , 因为类 能够起到模板的作用，故正在创立实例的时分，能够将咱们以为必需绑定 属性 强迫填写出来，正在python中，是经过 类中通常城市应用的一个办法，即def __init__(self) 办法，正在创立实例变量的时分，就把 name 以及 score 等属性绑下来。

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person('Gavin',100)    #  传入 __init__ 办法中需求的参数
print(student.name)
print(student.score)

传入空参数的状况，会报错：

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person()      # 此处应该有参数传入，却不传
print(student.name)
print(student.score)

留意：

一、__init__ 办法的第一个参数永远是 self ，示意创立的实例自身，因而，正在 __init__ 办法的外部，就能够把各类属性绑定到 self，由于 self 就指向创立的实例自身。

二、应用了 __init__ 办法，正在创立实例的时分就不克不及传入 空的参数了，必需传入与 __init__ 办法婚配的参数，然而 self 没有需求传，python诠释器会本人把实例变量传出来。

相干保举：《Python视频教程》

正在类中界说多个函数互相挪用

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    def add(self):
        sum = self.x + self.y
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):
        c = self.add()+self.square()
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可恶的宰割线-----------')
print(student.add_square())

经过上述的例子能够看出，与一般的函数相比，正在类中界说的函数只有两点没有同：

一、第一个参数永远是 self ，而且挪用时不必通报该参数

二、正在类中函数互相挪用要加 self ，如上例中： c = self.add()+self.square(), 没有加 self ，会报错： 函数不决义，看下图：

除了此以外，类的办法以及一般函数没甚区分，当然也能够应用 默许参数、可变参数以及要害字参数，例子以下：

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):         # 设置 默许变量 z =16,这只是个一般的部分变量，非实例变量，实例变量需求 
    self.z = z,这样界说
        sum = self.x + self.y + z
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self,z):        #  挪用时传入变量，这也是个一般的部分变量，非实例变量 
        c = self.add()+self.square() + z
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可恶的宰割线-----------')
print(student.add_square(16))

看了上述的例子可能仍是没有明确 self 究竟是个甚么鬼，为啥要应用 self 这鬼货色？不妨事，往下看：

其实 self 这家伙简略的说就是把 class 中 界说的 变量以及函数 变为 实例变量以及实例函数，作为类 class 的成员，使患上成员间能相互挪用，而没有需求从内部挪用 数据（变量）以及 办法（函数），以完成数据的封装，以下面的 Person 类为例：

创立实例的时分需求给出实例变量 x,y, 挪用函数时给出 z ，挪用很容易，殊不知道外部完成的细节。

总之，类是创立实例的模板，而实例则是一个一个详细的工具，各个实例领有的数据都互相自力、互没有影响；办法是与实例绑定的函数，以及一般的函数没有同，办法能够间接拜访实例的数据。

其实 self 中存储的是实例变量以及实例函数的属性，能够了解为一个字典（ dict ），如：{'name':'zhang','age':'18'}就是这些。

留意只无数据属性，并无创立新的类的办法。 类----->经过实例化天生----工具---->（工具只是一串相似于字典的数据，不把类的里的办法复制给你，python不new这个办法！）

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):     # 设置 z 为实例变量，即 self.z = z, z 是 class 的一个成员了，而非一般部分变量
        self.z = z
        sum = self.x + self.y + z  # z尽管已被实例化，然而仍然能够当做 一般变量来用
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):        
        c = self.add()+self.square() + self.z  # 挪用实例变量 z 
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可恶的宰割线-----------')
print(student.add_square())
print(student.z)          # 函数add 中的 z 被实例化当前，就能够行使实例化的办法拜访它

经过这个例子能够看出， z 原本是 add() 函数的默许形参，经过将其实例化，就能够正在其余函数体内挪用实例变量z

被实例化当前，就能够行使实例化的办法拜访它。

那末 self 究竟是甚么？

class Box(object):
    def __init__(self, boxname, size, color):
        self.boxname = boxname
        self.size = size
        self.color = color  # self就是用于存储工具属性的荟萃，就算不属性self也是必备的
 
    def open(self, myself):
        print('-->用本人的myself，关上阿谁%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类本人的self，关上阿谁%s,%s的%s' % (self.color, self.size, self.boxname))
 
    def close(self):
        print('-->封闭%s，谢谢' % self.boxname)
 
 
b = Box('魔盒', '14m', '白色')
b.close()
b.open(b)  # 原本就会主动传一个self，如今传入b，就会让open多失去一个实例工具自身，print看看是甚么。
print(b.__dict__)  # 这里前往的就是self自身，self存储属性，不举措。

self代表类的实例，而非类；self 就是 工具/实例 属性荟萃

Box 是个类-----》self 实例化------》 b工具/ 实例

class 形象体------》实例化------》工具/实例，含有属性：{'boxname':'魔盒', ‘size’：‘14m’, 'color':'red'}，即 self

self 看似是整个工具，实际上分明地形容了类就是孕育发生工具的进程，形容了 self 就是失去了 工具，以是 self 内的键值能够间接应用

正如天然界中一个无效的工具，必需包罗：

一、形容工具的属性；二、工具的办法

以是 self是必需的，也是工具中首要的特点。

看上面的代码，觉得就更神秘了：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        mySelf.boxname = boxname
        mySelf.size = size
        mySelf.color = color  # 本人写一个初始化函数，同样见效,乃至不必self定名。其它函数傍边用规范self
        return mySelf  # 前往给实例化进程一个工具！神秘！而且含有工具属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #正文掉原来规范的初始化
 
    def open(self, myself):
        print(self)
        print('-->用本人的myself，关上阿谁%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类本人的self，关上阿谁%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->封闭%s，谢谢' % self.boxname)
 
 
# 通过革新，运转后果以及规范初始化没区分
 
b = Box().myInit('魔盒', '14m', '白色')
# b = Box('魔盒', '14m', '白色')#正文掉原来规范的初始化办法
b.close()
b.open(b)  # 原本就会主动传一个self，如今传入b，就会让open多失去一个实例工具自身，print看看是甚么。
print(b.__dict__)  # 这里前往的就是self自身，self存储属性，不举措。

换个角度来说，对类的操作有：

一、界说属性 ； 二、挪用办法

对类的反馈有：

一、失去属性 ； 二、执行办法

正在 class 类的函数中，为何 self是须要的，由于 self 是工具的载体，能够了解成一个字典，看上面代码：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        print(mySelf.__dict__)#显示为{}空字典
        mySelf.boxname = boxname
        mySelf.__dict__['aa'] = 'w'#乃至能够像字典同样操作
        mySelf.size = size
        mySelf.color = color  # 本人写一个初始化函数，同样见效,乃至不必self定名。其它函数傍边用规范self
        return mySelf  # 前往给实例化进程一个工具！神秘！而且含有工具属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #正文掉原来规范的初始化
 
    def open(self, myself):
        print(self)
        print('-->用本人的myself，关上阿谁%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类本人的self，关上阿谁%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->封闭%s，谢谢' % self.boxname)
 
 
# 通过革新，运转后果以及规范初始化没区分
 
b = Box().myInit('魔盒', '14m', '白色')
# b = Box('魔盒', '14m', '白色')#正文掉原来规范的初始化办法
b.close()
b.open(b)  # 原本就会主动传一个self，如今传入b，就会让open多失去一个实例工具自身，print看看是甚么。
print(b.__dict__)  # 这里前往的就是self自身，self存储属性，不举措。

留意此处的： mySelf.__dict__['aa'] = 'w' #乃至能够像字典同样操作； 正在 b.__dict__ 的后果中显示为：'aa':'w'

故能够把 self 了解成存储 实例化工具属性的字典(dict), self 存储属性，而不举措执行。

self老是指挪用时的类的实例。

python 中一些非凡的实例变量：

一、公有变量(private),只有外部能够拜访，内部不克不及拜访，公有变量是正在称号前以两个下划线扫尾，如：__name，其实公有变量也没有是齐全不克不及被内部拜访，不克不及间接拜访是由于python诠释器对外把 __name 变量改为了 _类名__name,所依然能够经过 _类名__name 来拜访 __name。

二、正在Python中，变量名相似__xxx__的，也就是以双下划线扫尾，而且以双下划线末端的，是非凡变量，非凡变量是能够间接拜访的，没有是private变量，以是，不克不及用__name__、__score__这样的变量名。

三、以一个下划线扫尾的实例变量名，比方_name，这样的实例变量内部是能够拜访的，然而，依照商定俗成的规则，当你看到这样的变量时，意义就是，“尽管我能够被拜访，然而，请把我视为公有变量，没有要随便拜访”。

以上就是一文读懂Python中的self的具体内容，更多请存眷资源魔其它相干文章！