python面向对象 : 属性, 类方法, 静态方法

一. 属性

属性: 将方法伪装成一个属性,代码上没有什么提升,只是更合理. property应用 : 类似于bmi这种,area,周长.... 需要用到计算的.

# 求BMI体质数:BMI = 体重(kg)/身高(米)^2

class Person:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    def bmi(self):
        bmi = self.weight / self.height ** 2
        return '%s的bmi是%s' % (self.name, bmi)


p = Person('jack', 55, 1.65)
print(p.bmi())  # jack的bmi是20.202020202020204

class Person:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    @property  # 加在需要伪装成属性的方法前面
    def bmi(self):
        bmi = self.weight / self.height ** 2
        return '%s的bmi是%s' % (self.name, bmi)


p = Person('jack', 55, 1.65)
print(p.bmi)  # 调用方法不用带括号了
# jack的bmi是20.202020202020204

　　属性的修改

class Person:
    def __init__(self, name, age):
        self.name = name
        # if type(age) is int:  # 判断年龄是否为整型
        #     self.__age = age
        # else:
        #     print('年龄应该输入数字')
        self.__age = age if type(age) is int else print('年龄应该输入数字')  # 三元表达式

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, a):
        self.__age = a if type(a) is int else print('年龄应该输入数字')  # 判断年龄是否为整型,为整型则把a的值赋值给self.__age


p = Person('jack', '18')  # 输入的年龄不是数字,重新输入
p = Person('jack', 18)
print(p.age)
print(p.__dict__)  # {'name': 'jack', '_Person__age': 18}
p.age = 22  # 自动执行@age.setter下面的方法age,并把22传给a 
print(p.__dict__)  # {'name': 'jack', '_Person__age': 22}

# 属性的删除

    @age.deleter
    def age(self):
        del self.__age

p = Person('jack', 18)
del p.age  # 自动执行@age.deleter下的age函数
print(p.__dict__)  # {'name': 'jack'}

二. 类方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

 　　类方法 :

class A:
    def func(self):  # 普通方法
        print(self)

    @classmethod  # 类方法
    def func1(cls):
        print(cls)

# 普通方法调用
a = A()
a.func()  # <__main__.A object at 0x0000022778238160>
A.func(111)  # 111 必须传值


# 类方法的调用
a1 = A()
a1.func1()  # <class '__main__.A'>  对象调用类方法,传进去的cls是这个对象所属的类空间
A.func1()  # 不用传值
# <class '__main__.A'>

类方法的应用场景:
　　1, 类中有些方法是不需要对象参与.

class A:
    name = 'jack'
    age = 18

    @classmethod
    def func1(cls):  # 此方法不需要对象参与  cls是所调用的类的空间
        print('%s%s岁' % (cls.name, cls.age))


A.func1()  # jack18岁

2, 对类中的静态变量进行改变,要用类方法.

class A:
    name = 'jack'
    age = 18

    @classmethod
    def func1(cls):  # 此方法不需要对象参与
        cls.name = 'tom'  # 修改类中静态字段的值
        print('%s%s岁' % (cls.name, cls.age))


A.func1()  # tom18岁

3,继承中,父类得到子类的类空间.

class A:
    name = 'tom'
    age = 22

    @classmethod
    def func(cls):  # 对传进来的类的所有的内容可以进行修改.
        print('%s%s岁' % (cls.name, cls.age))


class B(A):
    name = 'jack'
    age = 18


B.func()  # 执行父类A中的方法func,并把自己的类空间传给cls
# jack18岁

三. 静态方法

　　静态方法就相当于在类中定义个普通函数,不用传对象,也不用传类名

class A:
    @staticmethod
    def func(name,age):
        print('%s%s岁' % (name, age))
a = A()
a.func('tom', 22)  # tom22岁
A.func('jack', 18)  # jack18岁

为什么不直接在类外面加个函数

1,代码块.清晰:  把功能都放在一个类里,用着方便

2,复用性. 其它类可以通过继承来获取这个方法