PYTHON继承学习

谁借莪１个温暖的怀抱￠ 2022-02-14 06:11 125阅读 0赞

# class
    # 函数 ：方法 动态属性 #在类中定义方法。方法都有一个必须传的参数self
    # 变量：类属性 静态属性
    # #__init__方法 初始化方法
    # python帮我们创建了一个对象self
    # 每当我们调用类的时候就会自动的触发这个方法,默认传self
    # 在Init方法里面可以对self进行赋值
    # #self在类的内部，self就是一个对象
    # #实例化
    # 对象=类（参数Init方法的）
    # 对象查看属性
    # 对象.属性
    # 对象调用方法
    #  对象.方法名（参数）  #类名.方法名（对象名，参数）
    #类的命名空间
    #类：静态属性 动态属性
    class Course:
        language='Chinese'
        def __init__(self,teacher,course_name,period,price):
           self.teacher=teacher
           self.name=course_name
           self.period=period
           self.price=price
    
    Course.language='English'
    Course.__dict__['language']='Chinese'#不可以修改
    python=Course('egon','python','6 months',2000)
    linux=Course('egon','python','6 months',2000)
    '''类中的静态变量 可以被对象和类调用'''
    '''对于不可变的数据类型来说，类变量最好用类操作'''
    '''对于可变的数据类型来说，对象名的修改是共享的，重新赋值是独立的'''
    class Person:
        money =0
        def work(self):
            Person.money+=10000
    
    class Foo:
        def func(self):
            print('func')
    
    f1=Foo()
    print(Foo.func)
    print(f1.func)
    #面向对象的三大特性：继承 多态。封装
    #组合
    class Dog:
        def __init__(self,name,aggr,hp,kind):
            self.name=name
            self.aggr=aggr
            self.hp=hp
            self.kind=kind
        def bite(self,person):
            person.hp -=self.aggr
    class Person:
        def __init__(self,name,aggr,hp,sex):
            self.name=name
            self.aggr=aggr
            self.hp=hp
            self.sex=sex
            self.money=0
        def attack(self,dog):
            dog.hp -= self.aggr
        def get_weapon(self,weapon):
            if self.momey>=weapon.price:
                self.momey -= weapon.price
                self.weapon=weapon
                self.aggr+=weapon.aggr
            else:
                print("余额不足，请先充值")
    class Weapon:
        def __init__(self,name,aggr,njd,price):
            self.name=name
            self.aggr=aggr
            self.njd=njd
            self.price=price
        def hand28(self,person):
            if self.njd>0:
                person.hp-=self.aggr*2
                self.njd-=1
    
    
    w=Weapon('打狗棒',100,3,999)
    alex=Person('alex',0.5,100,'不详')
    jin=Dog('jin',100,500,'不详')
    #alex装备打狗棒
    alex.money+=1000
    alex.get_weapon(w)
    print(alex.aggr)
    print(alex.weapon)
    alex.attack(jin)
    print(jin.hp)
    alex.weapon. hand28(jin)
    print(in.hp)
    # 组合：一个对象的属性值是另外一个类的对象
    # alex.weapon是Weapon类的对象
    from math import pi
    class Circle:
        def __init__(self,r):
            self.r=r
        def area(self):
            return self.r**2*pi
        def perimeter(self):
            return 2*pi*self.r
    
    class Ring:
        def __init__(self,outside_r,inside_r):
            self.outside_c=Circle(outside_r)#一个类的对象作为另外一个类的属性
            self.inside_c=Circle(inside_r)
        def area(self):
            return  self.outside_c.area()-self.inside_c.area()
        def perimeter(self):
            return self.outside_c.perimeter()+self.inside_c.perimeter()
    ring=Ring(10,20)
    print(ring.area())
    print(ring.perimeter())
    #创建老师类
    #生日也可以是一个类
    #组合
    class Birthday:
        def __init__(self,year,month,day):
            self.year=year
            self.month=month
            self.day=day
    
    class Course:
        language='Chinese'
        def __init__(self,teacher,course_name,period,price):
           self.teacher=teacher
           self.name=course_name
           self.period=period
           self.price=price
    class Teacher:
        def __init__(self,name,sex,age,birthday):
            self.name=name
            self.sex=sex
            self.age=age
            self.birthday=birthday
            self.course = Course(self,'python','6 month',20000)
    
    b=Birthday(2018,1,16)
    egg=Teacher('egon',0,'女',b)
    print(egg.name)
    print(egg.birthday.day)
    print(egg.birthday.month)
    print(egg.birthday.year)
    print(egg.course.price)
    
    #面向对象编程
    #思想：角色的抽象，创建类，创建角色（实例化）操作这些实例
    class 类名：
       静态属性='aaa'
       def __init__(self):
            pass
    
    类名.静态属性  #----存储在类的命名空间里
    对象=类名()#实例化：创造了一个self对象，执行Init方法，返回self对象给外部
    类名.方法(对象)#等价于  对象.方法
    对象.属性
    #对象可以使用静态变量
    #一个类对象是另外一个类对象的属性
    
    #继承
    class A:pass#父类 基类 超类
    class B:pass
    class A_son(A,B):pass#继承A A为父类 A_son子类派生类
    #一个类可以被多个类继承
    #一个类可以继承多个类 ----python中特有的 其他语言没有
    print(A_son.__bases__)
    class A(object):pass#父类 基类 超类
    print(A.__bases__)#没有继承的父类 默认继承object类
    """
    class Dog:
        def __init__(self,name,aggr,hp,kind):
            self.name=name
            self.aggr=aggr
            self.hp=hp
            self.kind=kind
        def bite(self,person):
            person.hp -=self.aggr
    class Person:
        def __init__(self,name,aggr,hp,sex):
            self.name=name
            self.aggr=aggr
            self.hp=hp
            self.sex=sex
            self.money=0
        def attack(self,dog):
            dog.hp -= self.aggr
        def get_weapon(self,weapon):
            if self.momey>=weapon.price:
                self.momey -= weapon.price
                self.weapon=weapon
                self.aggr+=weapon.aggr
            else:
                print("余额不足，请先充值") 
    """
    class Animal:
        def __init__(self, name, aggr, hp):
            self.name = name
            self.aggr = aggr
            self.hp = hp
    class Dog(Animal):
        def bite(self, person):
            person.hp -= self.aggr
    class Person(Animal):
        pass
    Dog('jin',200,500)
    #狗类 吃 喝 跑 看门
    #鸟类 吃 喝 跑 下蛋
    #父类中没有的属性 在子类中出现 叫做派生属性
    #父类中没有的方法，在子类中出现 就叫派生方法
    #只要是子类的对象调用，子类中有的名字一定用子类的，子类中没有的才找父类的。如果父类没有报错
    #如果都有 还想用父类 单独调用父类（既想实现新的功能也想使用父类原本的功能，还需要在子类中调用父类）
       #1父类名.方法名     需要自己传self参数
       #2super().方法名   不需要自己传self参数
    class Animal:
        def __init__(self, name, aggr, hp):
            self.name = name
            self.aggr = aggr
            self.hp = hp
    class Dog(Animal):
        def __init__(self,name,aggr,hp,kind):
            super().__init__(name,aggr,hp)#找父类调用Initsuper(Dog,self).__init__(name,aggr,hp)只在新式类中有 Python类都是新式类
            self.kind=kind
        def bite(self, person):
            person.hp -= self.aggr
    class Person(Animal):
        pass
    Dog('jin',200,500)
    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