Python9-继承1-day24（大年初一）

#面向对象编程：
'''
思想：角色的抽象，创建类，创建角色，
面对对象的关键字
class 类名：
    静态属性 = ‘aaa'
    def __init__(self):pass

类名.静态属性   ———存储在类的命名空间里
对象 = 类名（）   实例化：创造了一个self对象，执行init方法，返回self对象给外部
类名.方法(对象)
对象.属性
对象.方法
对象可以使用静态变量
类不可用可以使用对象的属性
组合
一个类的对象是另外一个类对象的属性

什么是继承

# 继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

class ParentClass1: #定义父类

    pass

class ParentClass2: #定义父类

    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass

    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类

    pass

class A:pass

class B:pass

class A_son(A,B):pass

print(A_son.__bases__)

print(A.__bases__)

(<class '__main__.A'>, <class '__main__.B'>)

(<class 'object'>,)

class Animal:

    def __init__(self,name,aggr,hp):

        self.name =name

        self.aggr = aggr

        self.hp =hp

class Dog(Animal):

    def bite(self,persion):

        persion.hp -= self.aggr

class Person(Animal):

    pass

jin = Dog('金老板',200,500)

print(jin.name)

class Animal:

    def __init__(self,name,aggr,hp):

        self.name =name

        self.aggr = aggr

        self.hp =hp

    def eat(self):

        print('吃药回血')

        self.hp+=100

class Dog(Animal):

    def __init__(self,name,aggr,hp,kind):

        Animal.__init__(self,name,aggr,hp)

        self.kind =kind                     #派生属性

    def bite(self,persion):               #派生方法

        persion.hp -= self.aggr

class Person(Animal):

    def __init__(self,name,aggr,hp,sex):

        Animal.__init__(self,name,aggr,hp)

        self.sex =sex               #派生属性

        self.money = 0               #派生属性

    def attack(self,dog):

        dog.hp -= self.aggr

    def get_weapon(self,weapon):

        if self.money >= weapon.price:

            self.money -= weapon.price

            self.weapon = weapon

            self.aggr += weapon.aggr

        else:

            print('余额不足，请先充值')

alex = Person('alex',0.5,100,'不详')

jin = Dog('金老板',100,500,'不详')

print(jin.name)

jin.eat()

print(jin.hp)

print(alex.name)

alex = Person('alex',1,2,None)

alex.eat()

print(alex.hp)

jin.bite(alex)

print(alex.hp)

#父类中没有的属性，在子类中出现，叫做派生属性
# 父类中没有的方法，在子类中出现，叫做派生方法
# 只要是子类的对象调用，子类中有的名字，一定有子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都没有，用子类的
# 如果还想用父类的，单独调用父类的，需要自己穿self参数

class Animal:

    def __init__(self,name,aggr,hp):

        self.name =name

        self.aggr = aggr

        self.hp =hp

    def eat(self):

        print('吃药回血')

        self.hp+=100

class Dog(Animal):

    def __init__(self,name,aggr,hp,kind):

        super().__init__(name,aggr,hp)

        self.kind =kind                     #派生属性

jin = Dog('金老板',100,500,'teddy')

print(jin.name)

super(Dog,jin).eat()

金老板
吃药回血

# 如果还想用父类的，单独调用父类的，需要自己穿self参数

    父类名.方法名 需要自己穿self参数
    super（）.方法名  不需要自己穿参数

class F:

    def func(self):print('F')

class A(F):

    pass

    # def func(self):print('A')

class B(A):

    pass

    # def func(self):print('B')

class E(F):

    pass

    # def func(self):print('E')

class C(E):

    pass

    # def func(self):print('C')

class D(B,C):

    pass

     # def func(self):print('D')

d = D()

# d.func()

print(D.mro()

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>]

# 新式类中的继承顺序：广度优先
# 经典类  如果你直接创建一个类在2.7中就是经典类，深度优先
# 多集成中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是：
# 经典类中  深度优先
# 新式类中，广度优先
# python2.7 新式类和经典类共存，新式类要继承object
# python3  只有新式类，默认继承object
# 经典类和新式类还有个区别 super mro方法只在新式类中存在

# super的本质：不是直接找父类，而是根据调用者的节点位置的广度优先位置顺序来的

class A(object):

     def func(self):print('A')

class B(A):

    def func(self):

        super().func()

        print('B')

class C(A):

    def func(self):

        super().func()

        print('C')

class D(B,C):

    def func(self):

        super().func()

        print('D')

d = D()

d.func()

A

C

B

D

巴特西

Python9-继承1-day24（大年初一）

最新文章

热门文章