day24 面向对象，交互，组合，命名空间，初始继承

面向对象的命名空间：

#属性：静态属性 （直接和类名关联或者直接定义在class下的变量）
    # 对象属性 （在类内和self关联，在类外和对象名关联的变量）
    #  动态属性（函数）

class Foo:
    country = 'China'
    country_lst = ['China']
    def __init__(self,name):
        self.name = name

alex = Foo('alexander')
egg = Foo('egon')
alex.age = 90
alex.country_lst = []
alex.country_lst.append('印度')
# print(Foo.country_lst)
# Foo.role = 'Person'
# print(Foo.country)
# print(alex.name)
# print(egg.name)
# Foo.country
# alex.country = '印度'
# print(alex.country)
# print(egg.country)
# print(Foo.country)
# del alex.country
# print(alex.country)
# print(alex.country_lst)
# alex.country_lst.append('印度')
# print(alex.country_lst)
# print(egg.country_lst)
# print(Foo.country_lst)
#类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量

# 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性
# class Foo:
#     count = 0
#     def __init__(self):
#         Foo.count += 1
#
# f = Foo()
# f2 = Foo()
# f3 = Foo()
# print(f.count) #Foo.count
# print(f2.count) #Foo.count
# print(f3.count) #Foo.count

class Person:
    def __init__(self):pass
        #给一个什么属性都没有的对象赋一些初识的属性
    def eat(self):
        print('吃猪食')

alex = Person()  #裸着
print(alex.__dict__)
alex.name = 'alexander'
# alex.eat = '泔水'  #对象使用名字的顺序：先用自己的，再用类的
# alex.eat()
#对象可以使用类的
#而类无法使用对象的
# print(Person.eat)
# print(alex.eat)  #类对象指针的东西  alex = {'eat':eat}

组合：

#函数
#定义 调用 返回值 参数、命名空间和作用域

#面向对象
#定义 、命名空间
#三大特性：封装继承和多态（组合）

#组合 ： 什么 有 什么 的关系
#一个对象的属性是另外一个类的对象
#老师有生日
# class Teacher:
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#         # self.birth_year = year
# class Birthday:
#     def __init__(self,year,month,day):
#         self.year = year
#         self.month = month
#         self.day = day
# birthay1 = Birthday(1968,12,31)
# boss_gold = Teacher('太亮',40,'不详')
# boss_gold.birth = birthay1
# boss_gold.birth.year  #boss_gold.bith.year
#老师有生日 ： 年月日
#将一个类的对象拥有的属性 再将其定义成一个类以提高代码的复用
# class Teacher:
#     def __init__(self,name,age,sex,year,month,day):
#         self.name = name
#         self.age = age
#         self.sex = sex
#         self.birth = Birthday(year,month,day)
# class Birthday:
#     def __init__(self,year,month,day):
#         self.year = year
#         self.month = month
#         self.day = day
# boss_gold = Teacher('太亮',40,'不详',1968,12,31)
# print(boss_gold.birth)

#圆形类
from math import pi
class Circle:
    def __init__(self,r):
        self.radius = r
    def perimeter(self):
        return 2*pi*self.radius
    def area(self):
        return pi*(self.radius**2)
#环形类
class Ring:
    def __init__(self,outer_r,inner_r):
        self.outer_circle = Circle(outer_r)
        self.inner_circle = Circle(inner_r)
    def perimeter(self):
        return self.outer_circle.perimeter()+self.inner_circle.perimeter()
    def area(self):
        return self.outer_circle.area() - self.inner_circle.area()
r1 = Circle(5)
print(r1.perimeter())
print(r1.area())
r = Ring(10,8)
print(r.perimeter())
print(r.area())
# 既能hold住圆形的问题
# 又能解决环形的问题
#10,20
# def func(arg1,arg2):
#     outer_circle = Circle(20)
#     inner_circle = Circle(10)
#     print(outer_circle.area() - inner_circle.area())
#
# def func2(arg1,arg2):
#     outer_circle = Circle(20)
#     inner_circle = Circle(10)
#     print(outer_circle.perimeter() + inner_circle.perimeter())
# # 500个环
# ring1 = Ring(20,10)
# ring1.area()
#思想 —— 技术

#面向对象 命名空间
#组合 ： 老师有生日，环中有圆
#游戏 ：组合

组合例题：

#狗
class Dog:  # 定义一个狗类
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        people.life_value -= self.aggressivity
#人
class Person:  # 定义一个人类
    def __init__(self, name, aggressivity, life_value, money):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;
        self.money = money

    def attack(self,dog):
        dog.life_value -= self.aggressivity

    def get_weapon(self,weapon_obj):
        if self.money > weapon_obj.price:
            self.money -= weapon_obj.price  # 金老板花钱买武器
            self.weapon = weapon_obj  # 金老板装备打狗棒
            self.aggressivity += weapon_obj.aggr  # 金老板的攻击力增加了

# boss_gold = Person('金老板',5,250,100)
# huang = Dog('大黄','藏獒',100,3000)
# huang.bite(boss_gold)
# print(boss_gold.life_value)
# boss_gold.attack(huang)
# print(huang.life_value)
#不公平
#武器装备
#人 有 武器 —— 组合
#武器：攻击力，名字，价格
class Weapon:
    def __init__(self,name,price,aggr):
        self.name = name
        self.price = price
        self.aggr = aggr
dgb = Weapon('打狗棒',99.8,100)
boss_gold = Person('金老板',5,250,100)
huang = Dog('大黄','藏獒',100,3000)
boss_gold.get_weapon(dgb)
boss_gold.attack(huang)
print(huang.life_value)

#游戏的组合
#人可以有装备 ——
#狗 ——

#组合和命名空间
#继承的一点知识

初识继承：

# 面向对象的三大特性之一 —— 继承
# 继承 ：至少两个类 ： 什么 是 什么 的关系,为了避免几个类之间有相同的代码
# 父类 ： Animal
# 子类 ： Dog、Person
#动物
class Animal:
    def __init__(self,name,aggressivity,life_value):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value
#狗
class Dog(Animal):  # 定义一个狗类
    def bite(self,people):
        people.life_value -= self.aggressivity
#人
class Person(Animal):  # 定义一个人类
    def attack(self,dog):
        dog.life_value -= self.aggressivity

    def get_weapon(self,weapon_obj):
        if self.money > weapon_obj.price:
            self.money -= weapon_obj.price  # 金老板花钱买武器
            self.weapon = weapon_obj  # 金老板装备打狗棒
            self.aggressivity += weapon_obj.aggr  # 金老板的攻击力增加了
huang = Dog('大黄',100,3000)   #__init__ 找父类
print(huang.life_value)
boss_gold = Person('金老板',5,250)  #__init__ 自己没有 找父类
print(boss_gold.life_value)
# Dog.bite(Person)
print(Dog.__bases__)
print(Animal.__bases__)

#python 两种类：经典类 新式类
#python3 新式类 —— 都默认继承object class Animal(object): == class Animal:
#python2 经典类和新式类 并存
        #class Animal:  经典类 —— 继承顺序 个别使用方法
        #class Animal(object):  新式类
#两个类中有相同的代码，
# 继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的
# 单继承和多继承
# 父类 超类 基类
# 子类 派生类
# 抽象和继承