20180727 (面向对象的属性 类方法和静态方法)

一.属性:将一个方法,伪装成一个属性,在代码的级别上没有本质的提升,但是可以让其看起来更合理

property:类似于bmi这种,看起来像名词,实际是需要计算的(动词),或者遇到周长或者面积这种词的时候,需要使用property装饰器来对其进行伪装

例如:　

class Person:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height                 
    def bmi(self):                                 此时bmi按常理会认为他是一个名词.然而在这里确实当做动词再用,所以不太合理
        return round(self.weight / self.height ** 2,2)
p1 = Person("刘某某",60,1.7)
print(p1.bmi())

例如:

class Person:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height
    @property                      ====>此时使用这个装饰器的主要作用是将bmi方法伪装成一个属性,就是把它当做一个名词来看
    def bmi(self):
        return round(self.weight / self.height ** 2,2)
p1 = Person("刘某某",60,1.7)
print(p1.bmi)

属性的修改:

例如:

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    @property
    def age(self):
        return self.__age
    @age.setter                   =====>这个装饰器在这里是可以修改年龄这个对象值
    def age(self,a1):
        print(a1)
p1 = Person("刘某某",22)
p1.age = 21    (修改年龄)

属性的删除:

例如:

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    @property
    def age(self):
        return self.__age
    @age.setter
    def age(self,a1):
        print(a1)
    @age.deleter                 =====>这个装饰器在这里是可以删除年龄这个属性
    def age(self):
        del self.__age
p1 = Person("刘某某",22)
p1.age = 21
del p1.age                   (删除年龄这个属性)
print(p1.__dict__)

二.类方法

类方法:通过类名调用的方法,类方法中第一个参数约定俗成cls,python自动将类名(类空间)传给cls

普通方法与类方法的区别:

例如:

class A:
    def func(self):
        print(self)        普通方法  : 由对象调用,至少一个self参数,执行普通方法的时候,自动将调用该方法的对象赋值给self
    @classmethod
    def func(cls):          类方法   :  由类调用,至少一个cls参数,执行类方法的时候,自动将调用该方法的类赋值给cls
        print(cls) 
a1 = A()
a1.func()     对象调用方法,cls最终的到的是该类本身

类方法的应用场景

(1)类中有些方法是不需要对象参与    (只能有类名调用(对象调用)传给cls参数的也是该对象的所属)类)

例如:

class A:
    name = "alex"
    count = 1
    @classmethod            此方法无需对象参与
    def func(cls):
        return cls.name + str(cls.count + 1)
#A.func(111)       =====>(不要用类名去调用类里面的方法,除了类方法和静态方法)
a1 = A()
print(a1.func())

(2)在类中的静态变量进行改变,要用到类方法

class A:
    name ="alex"
    @classmethod
    def func(cls):
        cls.name = "wusir"
        return cls.name
a = A()
print(a.func())              ======>执行func()   将A的类空间传给了func()里的cls     这个函数里将cls.name改为wusir   就相当于A.name = wusir  从而改变了类中的静态变量
print(A.func())
print(A.name)

(3)继承中,父类得到子类的类空间      (子类通过类名去执行父类中的类方法,并将本子类的类名空间传给了父类,并且可以对子类中的所有内容进行修改)
例如: 

class A:
    age = 12
    @classmethod                    =====>类方法在这里接收到的是一个类空间,哪个类调用的,就是哪个类的类空间
    def func(cls):
　　　　 cls.age = 25
        return cls.age
class B(A):
    age = 22
a1 = B()
print(a1.func())     =====>25    

例如:不通过类方法,想让父类的某个方法得到子类的类空间里面的任意值

class A:
    age = 12
    def func(self):
        print(self.age)      =====>self是B类实例化的一个对象,能得到子类空间的任意值,但是只能访问,不能修改
class B(A):
    age = 22
b1 = B()
b1.func()     

三.静态方法

静态方法的好处:(1)代码块是一个整体   分类整理  是代码看起来清晰明了

　　　　　　　 (2)复用性   减少代码量   (比如父类A下面有100个子类,这100个子类都可以调用父类A中的这个方法,还可以调用自己本类中的方法)

例如:

class A:
    @staticmethod
    def func():
        print(666)
A.func()