PYTHON继承学习

# 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