python's ninteenth day for me 类的组合，继承。

组合：

　　表示一个类的对象作为另一个类对象的属性。

实例化的过程：

　　1，创建一个对象。

　　2，__init__ 给对象添加一些属性，对象默认的名字为self。

　　3，将self所指向的内存空间返回给实例化他的地方。

使用这个对象可以找到两个东西：

　　1，对象所在的内存中存储的属性。

　　2，类对象指针所指的类中的所有方法和静态属性。

对象找名字的时候：先找自己内存空间中的，再找类的。

对象没有权利修改类中的静态变量和方法。

用类名操作静态变量（属性）。

类名：实例化对象，调用静态属性，执行方法。

交互：对象可以作为参数传递给类中的方法。

组合：对象可以作为一个对象的属性。

为什么会用组合：独立的对象不能发挥他的作用，必须依赖一个对象。

class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血' % (self.name,dog.name,dog.name,self.ad))
    def pay(self):
        money = int(input('请输入你要充值的金额：'))
        self.money += money
        print('你的余额为：%s' % self.money)
    def wear(self,weapon):  # 装备武器
        if self.money >= weapon.price:
            self.weapon = weapon    # 组合 给人装备了武器   武器类的对象作为了人类对象的一个属性。
            self.money -= weapon.price
            print('购买成功，你已经顺利装备了%s' % weapon.name)
        else:
            print('余额不足，请充值...')
    def attack_with_weapon(self,dog):
        if 'weapon' in self.__dict__:
            self.weapon.skill(dog)
        else:
            print('请先装备武器...')
class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        person.hp -= self.ad
        print('%s咬了%s，%s掉了%s点血' % (self.name,person.name,person.name,self.ad))
class Weapon:
    def __init__(self,name,price,ad,level):
        self.name = name
        self.price = price
        self.ad = ad * level
        self.level = level

    def skill(self,dog):
        dog.hp -= self.ad
        print('%s受到了%s的伤害，%s掉了%s点血' % (dog.name,self.name,dog.name,self.ad))

alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',20,50)
teddy = Dog('笨笨','teddy',150,50)
futou = Weapon('斧头',1000,100,1)

# alex.weapon.skill()
# print(alex.weapon)
# print(futou)
# futou.skill(teddy)
lis = ['攻击','充值','装备武器','使用武器']
while True:
    for index,value in enumerate(lis,1):
        print(index,value)
    choice = int(input('请输入你的选择：'))
    if choice == 1:
        alex.attack(teddy)
    elif choice == 2:
        alex.pay()
    elif choice == 3:
        alex.wear(futou)
    elif choice == 4:
        alex.weapon.skill(teddy)
    else:
        print('无效序号:')

组合的实例：

# 圆形类
# 写一个圆环类 组合 圆形类 去完成 计算圆环的面积和周长
# 一个类的对象作为另一个类对象的属性
# 圆环中有圆

# 圆形类 ： 计算圆形面积 和 周长
# 圆环类 :
    # 圆环的周长 ： 大圆周长加小圆周长
    # 圆环的面积 :  大圆的面积 - 小圆的面积
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def cir_area(self):
        return pi*self.r**2
    def cir_perimeter(self):
        return pi*self.r*2

class Ring:
    def __init__(self,max_r,min_r):
        self.max_r = Circle(max_r)    #  相当于实例化。self.max_r是Circle类中的一个对象。它又是Ring类中的对象的属性。
        self.min_r = Circle(min_r)
    def R_area(self):
        return self.max_r.cir_area() - self.min_r.cir_area()
    def R_perimeter(self):
        return self.max_r.cir_perimeter() + self.min_r.cir_perimeter()

r1 = Ring(3,2)
print(r1.R_area())
print(r1.R_perimeter())

班级和老师的关系（组合）：

# 老师
# 姓名 年龄 性别 班级 ： s11

# 班级
# 班级名 班级人数 科目 性质

class Teacher:
    def __init__(self,name,age,sex,cla):
        self.name = name
        self.age = age
        self.sex = sex
        self.cla = cla

class Cla:
    def __init__(self,name,num,course,type):
        self.name = name
        self.num = num
        self.course = course
        self.type = type
cla = Cla('s11',99,'python','全栈')
teacher = Teacher('Eva',18,'女',cla)

print(teacher.cla.name)
print(teacher.cla.num)
print(teacher.cla.course)
print(teacher.cla.type)

初识继承：

　　　　单继承：

在python3中，所有类都会默认继承object类。

继承了object类的所有类都是新式类。

如果一个类没有继承任何父类，那么__bases__属性就会显示 <class 'object'>

class Parent:
    pass
class Son(Parent):      # 继承关系
    pass
print(Son.__bases__)  # 内置的属性
print(Parent.__bases__)
# (<class '__main__.Parent'>,)
# (<class 'object'>,)

　　　　多继承：

class Parent1:
    pass
class Parent2(Parent1):
    pass
class Parent3:
    pass
class Son(Parent2,Parent3):
    pass

print(Parent1.__bases__)    # (<class 'object'>,)
print(Parent2.__bases__)    # (<class '__main__.Parent1'>,)
print(Parent3.__bases__)    # (<class 'object'>,)
print(Son.__bases__)    # (<class '__main__.Parent2'>, <class '__main__.Parent3'>)

父类：基类，超类。

字类：派生类

class Animal:
    role = 'Animal'
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad

    def eat(self):
        print('%s吃药回血了' % (self.name))

class Person(Animal):
    r = 'Person'
    def attack(self,dog):
        print('%s攻击了%s' % (self.name,dog.name))

class Dog(Animal):
    def bite(self,person):
        print('%s咬了%s' % (self.name,person.name))

alex = Person('a_sb',10,5)  # 继承了父类中的属性。
dog = Dog('teddy',100,20)   # 继承了父类中的属性。

# 继承中的派生方法。
alex.attack(dog)
dog.bite(alex)

# 继承父类的方法，前提自己没有同名方法，否则无法继承。
dog.eat()       # 继承了父类中的 方法。

self.名字   的时候，不要看self当前在哪个位置，要看这个self到底是谁的对象。

class Parent:
    def func(self):
        print('in Parent func')
    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

s = Son()

#  in Son func

面向对象的思想：

　　1，不关心程序执行的过程。

　　2，关心的是一个程序中的角色 以及 角色与角色之间的关系。