3、面向对象基础二

def editage(age):
    def wrapper(cls):
        cls.age = age
        return cls
    return wrapper

@editage(20)
class Person:pass

p1 = Person()
print(p1.age)  # 20

class Person:
    def method(self):
        return 'method'

print(Person().method()) # method
# 等同于 print(Person.method(Person()))

class Person:
    id = 1
    @classmethod
    def clsmtd(cls):  # 类方法，第一个参数为类
        return cls, cls.id

p1 = Person()
print(p1.clsmtd())  # (<class '__main__.Person'>, 1)

class Person:
    @staticmethod
    def stmtd(): # 无需传递任何参数
        return 'stmtd'

p1 = Person()
print(p1.stmtd())  # stmtd

class Person:
    def __init__(self):
        self.__num = True  # 私有数据属性
    def __private_attrs(self):  # 私有方法属性
        return self.__num

p1 = Person()
p1.__private_attrs()  # 'Person' object has no attribute '__private_attrs' # 私有属性，不可见
print(dir(p1))  # ['_Person__private_attrs',...]  # 实际上是修改了方法名称
print(p1._Person__private_attrs())  # 1  # 依旧可以调用

class Person:
    def __init__(self):
        self.__name = 'cce'
    def get_info(self):
        return self.__name

p1 = Person()
print(p1.get_info()) # cce

class Person:
    def __init__(self):
        self.__name = 'cce'
    @property
    def get_info(self):
        return self.__name
p1 = Person()
print(p1.get_info)  # cce # 无需使用括号调用
p1.get_info = 2 # AttributeError: can't set attribute

class Person:
    def __init__(self):
        self.__name = 'cce'
    @property
    def get_info(self):
        return self.__name
    @get_info.setter # 装饰器直接使用property装饰的方法名.的方式
    def get_info(self, name):   # 所有方法名，和property装饰的方法名一致
        self.__name = name
    @get_info.deleter
    def get_info(self):
        del self.__name

p1 = Person()
print(p1.get_info)  # cce
p1.get_info = 2  # AttributeError: can't set attribute
print(p1.get_info)  # 2
del p1.get_info
print(p1.get_info)  # AttributeError: 'Person' object has no attribute '_Person__name'

class Person:
    def __del__(self):
        print('del')
p = Person() # Person()实例对象 引用计数为 1
p1 = p # Person()实例对象 引用计数为 2
print('-----end-----')
del p # Person()实例对象 引用计数为 1
print('----start-----')
del p1 # del # Person()实例对象 引用计数为 0
print('---------')

### 执行结果
# -----end-----
# ----start-----
# del
# ---------

class Animal:
    def shout(self):
        print("%s shouts" % type(self).__name__)
class Cat(Animal):
    pass

a = Animal()
a.shout() # Animal shouts
c = Cat()
c.shout() # Cat shouts

class 子类名( 基类一 [ ，基类二 ，基类三 , ... ] )
        语句块

__name__：类、函数、方法等的名字；
__module__：类定义所在的模块名；
__class__：对象或类所属的类；
__doc__：类、函数的文档字符串，如果没有定义则为None；
__dict__：类或实例的属性字典；
__base__：类的基类；
__bases__：类的基类元组；
__mro__：显示方法查找顺序，基类的元祖；
mro：派生类新增的方法，同上，返回列表；
__subclasses__：返回一个父类的子类列表；

class Animal:
    def __shout(self):
        print("%s shouts" % type(self).__name__)
class Cat(Animal):
    pass

c = Cat()
c._Animal__shout() # Cat shouts
# 可以访问

class Animal:
    __COUNT = 100
    def __init__(self, age, weight, height):
        self.__COUNT += 1
        self.age = age
        self.__weight = weight
        self.height = height
    def eat(self):
        print('{} eat'.format(self.__class__.__name__))
    def __getweight(self):
        print(self.__weight)
    @classmethod
    def showcount1(cls):
        print(cls)
        print(cls.__dict__)
        print(cls.__COUNT)
    @classmethod
    def __showcount2(cls):
        print(cls.__COUNT)
    def showcount3(self):
        print(self.__COUNT)

class Cat(Animal):
    __COUNT = 200

c = Cat(3,40,20)
print(c._Cat__COUNT)
c._Animal__getweight()
c.showcount1()
c._Animal__showcount2()
c.showcount3()
print(c._Cat__COUNT)
print(c._Animal__COUNT)

# 1、c = Cat() # 是否可以初始化
# 2、print(c.__COUNT) # 是否可以访问，如果不能如何改进
# 3、c.__getweight() # 是否可以访问，如果不能如何改进
# 4、c.showcount1() # 求输出结果
# 5、c.__showcount2() # 是否可以访问，如果不能如何改进
# 6、c.showcount3() # 求输出结果
# 7、print(c._Cat__COUNT) # 是否可以访问，如果不能如何改进
# 8、print(c._Animal__COUNT) # 是否可以访问，如果不能如何改进

# 解析
# 重点：私有属性，属于定义私有属性的类，原则上无法继承，实际可以继承，私有属性实现私有的方式就下改名

# 第一题：答案为，无法初始化
# 解析：因为Cat没有__init__方法，所以会继承自父类，所以需要提供age、height、weight三个参数

# 第二题：答案为无法访问
# 解析：私有属性是无法通过这种方式改名的，如果要访问Cat内部的__COUNT，那么正确的访问方式应该是c._Cat__COUNT

# 第三题：答案为无法访问
# 解析：和第二题差不多，无论是私有属性还是私有方法，实现私有的方式都是改名，如果需要访问Animal中的__getweight，那么应该是c._Animal__getweight()

# 第四题：答案。Cat {'_Cat__COUNT':200} 100
# 解析：之所以cls.__COUNT的值为100是因为，私有属性是改名了，此时我们不应该将它看成cls.__COUNT，应该看成cls._Animal__COUNT，c实例属于Cat类，那么c在寻找_Animal__COUNT的时候，Cat里面没有，则会去Animal中去找，之所以结果为100而不是101的原因是，我们访问的是cls的_Animal__COUNT而不是实例的_Animal__COUNT，如果我们访问self._Animal__COUNT那么结果就是101

# 第五题：答案。无法访问，应修改为。c._Animal__showcount2()
# 解析：不论是在子类中还是在父类中，我们都不应该将它们的方法属性标识符看成__showcount2()，而是_Animal__showcount2()，所以不管怎么调用，都应该使用_Animal__showcount2()这个标识符来调用

# 第六题：答案。101
# 解析：showcount3方法使用的是self，self就是实例，上面也说过，self.__COUNT我们就不应该看成self.__COUNT，而是self._Aniaml__COUNT，所以结果应该是实例的_Aniaml__COUNT，实例经过初始化+1，即为101

# 第七题：答案，可以访问，200
# 第八题：答案，可以访问，101

class Animal:
    pass
class Cat(Animal):
    pass
print(Cat.mro()) # [<class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>]

class Animal:
    name = "cce"
class Cat(Animal):
    name = "cfj"  # 实现了覆盖overwirte的效果
c1 = Cat()
print(c1.name)  # cfj
# 覆盖了父类的name属性

class Animal:
    def shout(self):
        print("Animal")
class Cat(Animal):
    def shout(self):
        print("Cat")
    def call(self):
        __class__.__base__.shout(self) # 不推荐
        super(__class__, self).shout() # 指定具体调用哪一个父类的方法
        super().shout() # 让super自己按照mro查找顺序去寻找调用的方法
c1 = Cat()
c1.call()
# Animal
# Animal
# Animal

class A():
    def __init__(self,name):
        self.name=name
    def showname(self):
        return self.name
class B(A):
    def __init__(self,age):
        self.age=age
b=B(18)
print(b.__dict__) # {'age': 18}        此时b实例只有一个age属性
print(b.showname()) # AttributeError: 'B' object has no attribute 'name'

class A():
    def __init__(self,name):
        self.name=name
    def showname(self):
        return self.name
class B(A):
    def __init__(self,age):
        super().__init__('cce')
        self.age=age
b=B(18)
print(b.__dict__) # {'age': 18, 'name': 'cce'}  # 将父类的name也加入到了子类实例中
print(b.showname()) # cce