Python(class_inherit)

"""
类中的继承: 子类继承自父类

class Grandpa(爷爷):
    数据和功能

class Father(爸爸):
    继承自爷爷Grandpa
class son(儿子):
    继承自父亲(father)

类中定义了哪些东西？
    类中可以定义类变量，对象变量，方法
问题：继承的话，子类可以从父类中继承哪些东西？
    继承了父类中的类变量，对象变量，以及方法

继承语法：
在Python中，类的继承是多继承：一个子类可以继承多个父类
class ClassName(ParentClass1, ParentClass2, ParentClass3...):
    statement

"""

class Delivery:
    pass

"""
== class Delivery(object):
    pass
上边省略了它的继承，为什么省略？
因为object是我们所有类的基类， 无论哪个类它其实都是继承自object
"""


class Parent:

    count = 0

    def __init__(self, name, age):
        self.age = age
        self.name = name

    def print_info(self):
        print(f"{self.name}-{self.age}")

class Son(Parent):
    pass

son = Son("son", 10) #son对象有对象变量: name, age
print(son.name)
print(son.age)
son.print_info()
print(son.count)
# 实例化Son类的时候： __new__ -> __init__
#    一个是创建并返回一个新的对象 __new__(不参与)
#    初始化返回的这个对象 (可以参与的) __init__
#    Son继承自Parent，所以它在实例化的时候：
#    先去调用__new__(Son未定义) -> Parent找(也没有定义)->object中找，找到了
#    去调用__init__(Son为定义) -> Parent找(定义了)，找到了

class A(object):
    def print_info(self):
        print("This is A")

class B:
    def print_info(self):
        print("This is B")
    def say_something(self):
        print("My name is B")
class D:
    def say_something(self):
        print("My Name is D")

class C(A, B, D):
    pass

class E(A):  # C和E有一个相同Parent A, A 是有两个孩子 C和E, C和E是兄弟类
    pass

c = C()
# 为什么在执行c.print_info()，调用的是A中print_info方法，而不是B中的？
c.print_info()
c.say_something()

#Python是可以支持多继承
#继承顺序是什么？Python继承的顺序是依靠一个叫做C3线性算法
print(C.__mro__) #mro: method resolution order: 查找顺序
#如果我们要改变它的继承顺序，如何去改变？
#super关键字:
"""
super: super([type[, object-or-type]])
[type[, object-or-type]]
中括号：代表的是这些参数可以传，也可以不传
       可以什么都不传
       可以只传递一个type
       可以传递: type和object-or-type
super的作用：返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。
type: 类
object-or-type: 可以是一个对象也可以是一个类
    object-or-type 确定用于搜索的 method resolution order,
    搜索会从 type 之后的类开始。
如果 object-or-type 的 __mro__ 为 D -> B -> C -> A -> object 
并且 type 的值为 B，
则 super() 将会搜索 C -> A -> object。
限定条件：如果省略第二个参数，则返回的超类对象是未绑定的。 
        如果第二个参数为一个对象，则 isinstance(obj, type) 必须为真值。 
        如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值。
"""

class F(A, B, D):
    def print_info(self):
        # super(A, F).print_info()
        # super().print_info() #省略了什么
        super(F, self).print_info()
        # pass
    def say_something(self):
        super(B, F).say_something(self)
        pass
    # pass

f = F()
f.print_info()
f.say_something()
print(F.__mro__)

"""
继承：
1.Python支持单继承和多继承
  class ClassName(Parent1...):
  
2.object是所有类的父类(基类)
  class ClassName:
  == class ClassName(object):
3.super：
  就可以将我们方法的调用委托给父类或者兄弟类
  因为它可以改变我们继承的顺序
4.__mro__: 继承的搜索顺序:利用了C3线性算法
"""

"""
_和__：下划线和双下划线:
在类中想要实现私有和不被继承的东西：_和__
python中没有私有这个概念: 约定的东西，是希望你遵守

_命名的方法或变量， 是在python中约定为私有变量或私有方法的
因为只是一个约定，实际上在继承时候是可以继承到的

__命名的方法或变量，在python解释器会对名称做一个转换:
转换的格式:_ClassName+methodName
__test_func() -> _Person__test_func()
__test_func() -> _Man__test_func()
作用是什么？
他的作用: 避免我们子类和父类中名称的冲突




"""

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self._gender = gender
    def print_info(self):
        print(f"{self.name}-{self.age}-{self._gender}")

    def __test_func(self):
        print("This is testing double_underline")

class Man(Person):
    def __test_func(self):
        print("This is Man Testing double_underline")
    pass

man = Man("zhangsan", 18, "男")
print(man.name)
print(man.age)
print(man._gender) # access to a protected member _gender
# Python约定的一个私有变量: 使用_xxx来命名
# 这个意义在于：如果外部的人去使用这个对象的时候:
            # 使用对象.可以访问name和age，但是他是不知道_gender的
            # _gender是受保护
# 访问一个受保护的成员_gender
man.print_info()

# man.__test_func() # 'Man' object has no attribute '__test_func'
# print(dir(man))
#_Person__test_func
man._Person__test_func()
man._Man__test_func()

"""
类中定义的方法是必须携带self参数
问题是：可不可以定义不携带self参数的方法

# 装饰器来解答

"""

# class Test:
#
#     def test_func(value):
#         pass
#
# test = Test()
# test.test_func(1)

"""
什么是类，什么是对象，类和对象的关系？
类中可以包含哪些东西？
如何定义一个类?
   如何定义类变量
   如何定义方法
   如何定义对象变量
实例化一个对象的时候，python解释器帮我们做了什么？
如何去访问类变量和对象变量,以及如何去定义一个临时对象变量
特殊方法: +, len(), bool(), print(obj)
        __name__, __doc__, __modules__
继承: python支持的是多继承
     object是我们所有类的基类
     继承的语法
     继承的顺序怎么看: __mro__
     如何修改/干预继承的顺序： super(type, object-or-type)
     私有变量：_
     名称转换:__
"""