类别:Python / 日期:2019-12-02 / 浏览:97 / 评论:0

奇异的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)

注重:

1、__init__ 要领的第一个参数永远是 self ,示意建立的实例自身,因而,在 __init__ 要领的内部,就能够把种种属性绑定到 self,由于 self 就指向建立的实例自身。

2、运用了 __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())

经由历程上述的例子能够看出,与一般的函数比拟,在类中定义的函数只要两点差别:

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

2、在类中函数相互挪用要加 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 内的键值能够直接运用

正如自然界中一个有用的对象,必需包含:

1、形貌对象的属性;2、对象的要领

所以 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存储属性,没有行动。

换个角度来说,对类的操纵有:

1、定义属性 ; 2、挪用要领

对类的反应有:

1、获得属性 ; 2、实行要领

在 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 中一些特别的实例变量:

1、私有变量(private),只要内部能够接见,外部不能接见,私有变量是在称号前以两个下划线开首,如:__name,实在私有变量也不是完整不能被外部接见,不能直接接见是由于python诠释器对外把 __name 变量改成了 _类名__name,所依然能够经由历程 _类名__name 来接见 __name。

2、在Python中,变量名相似__xxx__的,也就是以双下划线开首,而且以双下划线末端的,是特别变量,特别变量是能够直接接见的,不是private变量,所以,不能用__name__、__score__如许的变量名。

3、以一个下划线开首的实例变量名,比方_name,如许的实例变量外部是能够接见的,然则,根据约定俗成的划定,当你看到如许的变量时,意义就是,“虽然我能够被接见,然则,请把我视为私有变量,不要随便接见”。

以上就是一文读懂Python中的self的细致内容,更多请关注ki4网别的相干文章!

打赏

感谢您的赞助~

打开支付宝扫一扫,即可进行扫码打赏哦~

版权声明 : 本文未使用任何知识共享协议授权,您可以任何形式自由转载或使用。

 可能感兴趣的文章

评论区

发表评论 / 取消回复

必填

选填

选填

◎欢迎讨论,请在这里发表您的看法及观点。