Python基础19 实例方法 类方法 静态方法 私有变量 私有方法 属性

#实例方法
#方法，就是在类中定义的函数
#和实例化变量一样
#实例化方法的时候，在()内的第一个变量也一定要是self

class fangfa(object):
    def __init__(self ,weight):
        self.weight=weight

    def eat(self):
        self.weight+=0.5
        print("您又胖了呢")
        print("您现在的体重是{0}".format(self.weight))
        
    def rush(self):
        self.weight-=0.1
        print("您终于瘦了一丢丢呢")
        print("您现在的体重是{0}".format(self.weight))

#这样我们就建立了在类中间的函数
#也就是方法
#那我们来尝试调用它一下

I=fangfa(145)
I.eat()
I.rush()
#这样我们就可以像一般的变量一样，来调用对应的方法了

print("//////////////////////////////")

#类方法
#存在实例方法就会存在类方法
#类方法不一样的地方在于，要在函数的前面加上
#@classmethod
#而且()中不用加上self

class leifangfa(object):
    def __init__(self,weight):
        self.weight=weight

    def eat(self):
        self.weight+=0.5

    def run(self):
        self.run-=0.1

    @classmethod
    #def pangduoshao(eats,runs):
    #TypeError: pangduoshao() takes 2 positional arguments but 3 were given
    #这里就会出现这样的报错
    #这是因为我们没有添加cls作为函数的第一个参数
    #而当我们添加了cls以后
    #他就会说eat()没有没定义

    #def pangduoshao(cls,eats,runs):
    def pangduoshao(cls,weight,eats,runs):
        for i in range(eats):
            #eat()
            #我们发现，在类方法中不能调用上面定义的实例函数
            #也不能调用构造函数导入的数据
            #所以只能手动导入weight数据
            weight+=0.5
        for i in range(runs):
            #run()
            weight-=0.1
        print("您的体重将会变成{0}".format(weight))

II=leifangfa(145)
II.pangduoshao(145,3,1)
#最后，我们得到了这样的结果
#成功得到了类方法运算的值

#而类方法虽然不能调用构造函数的数据
#但是却可以调用类变量的数据

class lei_2(object):
    lei=2020
    @classmethod
    def suan(cls,daoru):
        return daoru*cls.lei
print(lei_2.suan(10))
#这里需要注意的是
#在调用类变量的时候
#需要在变量的前面添加cls.来声明

print("////////////////////////////")

#静态方法
#如果定义的方法既不想与实例绑定也不想和类绑定
#只是想把类作为它的命名空间，就可以使用静态方法

class static_method(object):
    
    @staticmethod
    #静态方法通过@staticmethod装饰符表示
    #在()内定义参数的时候不需要输入cls或者self
    def jing():
        print("静态方法！")

J=static_method()
J.jing()
#这样我们就调用了静态方法了

class static_method_2(object):
    def shili(self):
        print("调用实例方法")

    @classmethod
    def lei(cls):
        print("调用了类方法")

    @staticmethod
    def jing():
        #lei()
        #表示lei没有被定义
        #shili()
        #表示实例也没被定义
        #这说明类实例和实例函数都不能被静态函数调用
        print("静态")

JJ=static_method_2()
JJ.jing()

print("///////////////////////////////")

#封装性
#私有变量
#默认情况下，Python中的变量是共有的
#我们可以在类的外部访问他们
#我们也可以通过在变量前面加上__来建立私有变量

class siyou(object):
    def __init__(self,weight,weight_2):
        self.weight=weight
        #公有
        self.__weight_2=weight_2
        #私有

siyou_0=siyou(10,20)
print(siyou_0.weight)
#print(siyou_0.weight_2)
#如果就用原来的访问方法
#是不能访问到私有变量的
print(siyou_0._siyou__weight_2)
#但是通过  _类名__变量 
#也是可以访问得到的

print("////////////////////////")

#私有方法
#和私有变量一样，我们只需要在定义方法的时候
#在函数名前面加上 __ 即可

class siyou_2(object):
    def __fangfa(self):
        print("私有方法")

    def fangfa(self):
        print("公共方法")
siyou1=siyou_2()
siyou1.fangfa()
siyou1._siyou_2__fangfa()
#同样的道理，我们也可以用 _类名__方法名 的方法调用
#但是这样都会严重破坏封装性
#不符合规范

#定义属性
#严格来说，类中间不应该存在共有的变量
#类中间只存在私有的变量
#然后通过公有的setter和getter访问器访问

class set(object):
    def __init__(self,eats,runs,weight=0.0):
        self.eats=eats
        self.runs=runs
        self.__weight=weight
        #注意，虽然是通过访问器来进行赋值和读取
        #我们任然需要在__init__构造出实例变量weight
        #不然后面会显示找不到私有变量weight
        

    def set_weight(self,weight):
        self.__weight=weight
        #这里就是我们定义的setter访问器
        
    def get_weight(self):
        return self.__weight
        #而这里定义的是getter访问器

set_1=set(10,5)     #实例化变量
set_1.set_weight(145)       #调用setter访问器来为私有变量__weight录入数据
print("你的体重是{0}".format(set_1.get_weight()))
        #调用getter访问器来返还私有变量__weight的值
#封装操作需要setter和getter
#如果是只读变量就不需要setter了

#Python中提供了修饰符@property来表示属性
#定义
#getter访问器可以使用@property来表示
#   也可以使用@属性名.setter 来就是setter访问器

class set_2(object):
    def __init__(self,weight=0.0):
        #self.__weight
        #我们先写的这样子的形式
        #他说我们没有定义一个_set_2.__weight的变量
        #self.__weight=0.0
        #TypeError: 'float' object is not callable
        #self.__weight=0
        #TypeError: 'int' object is not callable
        self.__weight=weight
    @property                   #书写习惯，先写getter后写setter
    def weight(self):           #原因是有时候我们只用到getter访问器
        return self.__weight

    @weight.setter
    def weight(self,weight):
        self.__weight=weight

sss=set_2()
#sss.weight()
#为什么上面会一直报错说不是callable
#是因为下面这里
#sss.weight是作为一个访问器使用
#这里sss.weight=C
#就相当于sss.weight(C)是一样的
sss.weight=145
print(sss.weight)
#而这时候，两个def出来的函数在@property和@weight.setter的修饰下
#不冲突
#原因是@属性名.setter就是声明了这个下面的函数就是之前那个setter访问器
#注意：这就类似我们之前C#所说过的
#调用方法时候要加上()，调用属性时不用时一个道理
#这里我们只是在学习建立方法和建立属性，所以其实时一样的

class set_3(object):
    def __init__(self):
        self.__weight=0.0
        #这里我们直接在__init__中对私有变量赋值
        #也是可以的
    @property                   
    def weight(self):           
        return self.__weight

    @weight.setter
    def weight(self,weight):
        self.__weight=weight

ssss=set_3()
ssss.weight=10
print(ssss.weight)