面向对象：类方法(classmethod)，静态方法(staticmethod)

类方法

    @classmethod
　　#使用类名用，默认类名作为第一个参数(对象调用,传给cls参数的也是该对象的所属类).
　　#不用对象命名空间中的内容，而用到了类命名空间中的变量(静态属性)或类方法或静态方法.
    使用场景:

    　　1,无需对象参与.
    　　2,对类中的静态变量进行修改.
    　　3,在父类中类方法得到子类的类空间,为所欲为.

静态方法

　　@staticmethod
　　# 1,代码块.清晰.
　　# 2,复用性.

# 类方法

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

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


a1 = A()

a1.func()
A.func(a1)
# 类方法: 通过类名调用的方法,类方法中第一个参数约定俗称cls,python自动将类名(类空间)传给cls.
A.func1()
a1 = A()
a1.func1()  # 对象调用类方法,cls 得到的是类本身.

<__main__.A object at 0x000001DE71EC2E88>
<__main__.A object at 0x000001DE71EC2E88>
<class '__main__.A'>
<class '__main__.A'>

#类方法的应用场景:

　　1, 类中 有些方法是不需要对象参与.

class A1:
    name = 'alex'
    count = 1

    @classmethod
    def func1(cls):  # 此方法无需对象参与
        return cls.name + str(cls.count + 1)

# A1.func1(111) 不可取
a1 = A1()
a2 = A1()
print(a1.func1())
print(a2.func1())
print(A1.func1())

alex2
alex2
alex2

# 静态方法

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

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

class A:
    age = 12
    @classmethod
    def func1(cls):  # 此方法无需对象参与
        # print(cls)
        # 对B类的所有的内容可以进行修改.
        print(cls.age)
        # return cls.name + str(cls.count + 1)

class B(A):
    age = 22
B.func1()

#执行结果：
22

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

class A:
    age = 12

    def func2(self):
        print(self)  # self 子类的对象,能得到子类 空间的任意值

class B(A):
    age = 22

b1 = B()
b1.func2()
print(B.__dict__)

#执行结果：
<__main__.B object at 0x000001CC98422E48>
{'__module__': '__main__', 'age': 22, '__doc__': None}

# 静态方法:

#函数
def login(username,password):
    if username == 'alex' and password == 123:
        print('登录成功')
    else:
        print('登录失败...')

login('alex',123)

#静态方法
class A:

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


A.login('alex',1234)

#执行结果
登录成功
登录失败...

# 1,代码块.清晰.
# 2,复用性.
待整理：

# classmethod 类方法的装饰器 内置函数
# 使用类名调用,默认传类名作为第一个参数
# 不用对象命名空间中的内容,而用到了类命名空间中的变量(静态属性),或者类方法或静态方法
# class Goods:
#     __discount = 0.8
#     def __init__(self,price):
#         self.__price = price
#     @property
#     def price(self):
#         return self.__price * Goods.__discount
#     @classmethod
#     def change_discount(cls,num):
#         cls.__discount = num
#
# # 商场的程序
# apple = Goods(10)
# banana = Goods(15)
# print(apple.price,banana.price)
# Goods.change_discount(1)
# print(apple.price,banana.price)

# staticmethod 静态方法的装饰器 内置函数
# 如果一个类里面的方法 既不需要用到self中的资源,也不用cls中的资源.
# 相当于一个普通的函数
# 但是你由于某种原因,还要把这个方法放在类中,这个时候,就将这个方法变成一个静态方法
# 某种原因:
    # 你完全想用面向对象编程 ,所有的函数都必须写到类里
    # 某个功能确确实实是这个类的方法,但是确确实实没有用到和这个类有关系的资源