20 属性, 类方法, 静态方法. python2与python3的区别.

主要内容:

1.  属性:将方法伪装成属性,代码上没有什么变化,只是更加符合逻辑.

　　@property

　　@属性名.setter

　　@属性名.deleter

　　a : 属性的初始 

class Person:
    def __init__(self,name,height,hight):
        self.name = name
        self.height = height
        self.hight = hight
    @property
    def bmi(self):
        return '%s的bmi值是%s' % (self.name,self.height/self.hight**2)
p1 = Person('小明',45,1.6)
print(p1.bmi)
这样有点不符合逻辑方法都是动词,而bmi值是名词.所以引入属性这个概念.@property

　b : 属性的增删改查

class Person:
    def __init__(self,name,age):
        self.name = name
        if type(age) is int:               #判断age是不是数字.然后再封装属性.
            self.__age = age
        else:
            print('输入有误,请重新输入')
    @property   #把age伪装成一个属性名
    def age(self):
        return self.__age
    @age.setter
    def age(self,a1):
        if type(a1) is int:                 #判断传过来的a1是不是数字.
            self.__age = a1
        else:
            print('输入有误,重新输入')
    @age.deleter
    def age(self):
        del self.__age

p1 = Person('xiao',12)
p1.age = 21                                 #执行修改方法def age(self,a1)
print(p1.age)                               #执行age方法,返回已经修改的值.
print(p1.__dict__)
del p1.age
print(p1.age)                     #会报错,因为age已经删除,找不到了.
print(p1.__dict__)                #此时查询age已经不再对象所在的空间里.

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

　　@classmethod

class A:
    def func(self):         #普通方法
        print(self)
    @classmethod            #类方法
    def func1(cls):
        print(cls)
a = A()
# a.func()           #对象调用func方法,自动将对象空间传给self
# A.func(a)          #类名调用func方法,需要传值.<__main__.A object at 0x0000022EE7CD8A58>
a.func1()            #<class '__main__.A'>  对象调用类方法,cls得到的是类本身
A.func1()            #<class '__main__.A'> 类方法: 通过类名调用的方法,类方法中第一个参数约定俗称cls,python自动将类名(类空间)传给cls.

　　类方法的应用场景:

　　    a: 类中,有些方法不需要对象参与.

# 1.类中  有些方法不需要对象参与
class A:
    name = 'alex'
    id = 1
    @classmethod
    def func(cls):
        return cls.name + str(cls.id)          #这个时候不能用A,因为方法执行的时候,自动将类名传给cls,应该用cls,
print(A.func())                                 #alex1

　　b:  对类中的静态变量进行改变,需要用到类方法.

　　c : 通过继承,父类得到子类的类空间.

class A:
    age = 12
    @classmethod
    def func(cls):
        #得到b中的所有内容,可以对b中的所有内容进行更改.
        print(cls.age)
class B(A):
    age = 22
B.func()

　　d : 不通过类方法,父类也可以得到子类空间的任意值

# 不通过类方法,想让我的父类的某个方法得到子类的类空间里面的任意值.
class A:
    age = 12
    def func(self):               # self 子类的对象,能得到子类空间的任意值
        print(self)

class B(A):
    age = 22
a1 = A()
a1.func()

3.  静态方法:

　　@staticmethod

class A:
    @staticmethod
    def login(username,password):
        if username == 'alex' and password == 123:
            print('登录成功')
        else:
            print('失败')
A.login('alex',123)

　　该login方法不使用静态方法,也可以实现该功能,但是需要给该方法传递self参数,而这个参数在方法中根本不会用到;

　　可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。

　　优点:  1,代码块清晰

　　　　　2,复用性