Python 面对对象：继承

目录

1.1定义字类

 1.1.1子类的使用

 1.1.3 super()关键字

小总结： 

---

         在Python程序中，类的继承是指新类从已有类中取出已有的特性，例如：属性、方法等。类的派生是指从已有的类产生新类的过程，这个已有的类被称为基类或者父类。而新类则被称为派生类或者子类。字类不但可以继承使用父类中的数据成员（类变量、对象变量）和成员函数（方法），而且可以增加新的成员。

         在Python中类的继承是多继承

1.1定义字类

        继承语法：    

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

        

class Delivery:
    pass

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

 1.1.1子类的使用

        上代码（单继承）：

#定义父类
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:                        #定义父类A,父类A继承（object）(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")

#子类C继承父类A,父类B和父类C
class C(A, B, D):
    pass

# C和E有一个相同Parent A, A 是有两个孩子 C和E, C和E是兄弟类
class E(A):  
    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()关键字

        执行结果：

 1.1.3 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 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 F(A, B, D):
    def print_info(self):
        super(A, F).print_info(self)

    def say_something(self):
        super(B, F).say_something(self)
        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线性算法

1.2 _和__的使用        

1. 在类中想要实现私有和不被继承的东西：_和__（python中没有私有这个概念）
2. _命名的方法或变量， 是在python中约定为私有变量或私有方法的

      因为只是一个约定，实际上在继承时候是可以继承到的

1. __命名的方法或变量，在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()

执行结果：

 

方法的重写：

        也叫方法的覆盖，如果从父类继承的方法不能满足子类的需求，可以对其进行重写，这个叫做，方法的覆盖，也叫做方法的冲写。