python 属性,类方法和静态方法

Posted 2020-11-29 S-skill

一. 属性
    属性: 将一个方法, 伪装成一个属性, 在代码的级别上没有本质的提升, 但是让其看起来很合理.
    @property    属性
    @属性名.setter  # 设置(修改)
    @属性名.deleter  # 在内部删除

二. 类方法
    @classmethod  # 类方法
    类方法: 通过类名调用的方法, 类方法中第一个参数约定俗称cls, python自动将类名(类空间)传给cls.
    只能有类名调用(对象调用, 传给cls参数的也是该对象的所属类).
    类方法的应用场景:
        1. 无需对象参与.
        2. 对类中的静态变量进行修改, 用类方法
        3. (1)在父类中类方法得到子类的类空间, 为所欲为,
           (2)继承中, 父类得到子类的类空间子类类名调用父类的类方法, 将我子类的类名传给父类,
              这个方法中能得到子类的任何东西, 还能修改

三. 静态方法
    @staticmethod
    静态方法的优点:
        1. 代码块, 清晰
        2. 复用性



1. 属性

# 属性的初识
class Food:

    def __init__(self,name,apple,banana):
        self.name = name
        self.__apple = apple
        self.__banana = banana

    @property     # 装饰器函数,内置函数,
    def func(self):
        return "喜欢吃 %s 和 %s" % (self.__apple,self.__banana)
    print(111)

f1 = Food("函数",‘苹果‘,‘香蕉‘)

ret = f1.func    # 是装饰器函数,调用函数的时候函数名就不用加括号
print(ret)
f1.name = "名字"    # 在外面,为对象(f1)封装一个属性,覆盖前面的封装的属性
print(f1.name)


# 属性的修改和删除
class Food:

    def __init__(self,num):
        if type(num) is int:
            self.__num = num
        else:
            print(‘输入的数字有误‘)

    @property     # 装饰器函数,内置函数,
    def func(self):
        return self.__num

    @func.setter
    def func(self,num):
        if type(num) is int:
            self.__num = num
        else:
            print(‘输入的数字有误‘)

    @func.deleter
    def func(self):
        del self.__num  # 在内部删除

f1 = Food(90)
ret = f1.func
print(ret)

f1.func = 40        # 修改
print(f1.func)

del f1.func # 删除
# print(f1.func)  # 以删除,会报错

 

2. 类方法

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

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

a1 = A()
a1.func()
A.func(a1)  # 普通的方法

a1.func1()  # 对象调用类方法,cls 得到的是类本身
A.func1()   # 类方法可以不要对象参与
# 类名调用类方法,python自动将类名(类空间)传给cls.


class A:
    name = "名字"

    @classmethod        # 类方法
    def func(cls):     # 此方法无需对象参与
        return cls.name

print(A.func())    # 直接执行,无需对象
ret = A()
print(ret.func())


class A:
    name = "名字"
    num = 2

    @classmethod        # 类方法
    def func1(cls):     # 此方法无需对象参与
        # print(cls)
        # 对B类的所有的内容可以进行修改.
        print(cls.num)  # 到子类找值
        B.num = 23      # 修改子类的值
        print(cls.num)
        return cls.name
    def func2(self):
        print(self)

class B(A):
    num = 20
# B.num = 21      # 修改B类中的num
print(B.func1())       # 区别:子类类名调用父类的类方法,将我子类的类名传给父类,
                            # 这个方法中能得到子类的任何东西,还能修改
# B.func2(2)    # 无需对象
b1 = B()
# b1.func2()

# 不通过类方法,想让我的父类的某个方法得到子类的类空间里面的任意值.

 

3. 静态方法

class A:
    name = ‘函数‘
    num = 12
    @staticmethod           # 静态方法
    def func(): # 不需要self和cls
        print(‘静态方法‘)
        return A.name + str(A.num)


print(A.func())    # 不用创建对象,也就是实例化对象,所以很节省空间