类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

 属性：静态属性（直接和类名关联或者直接定义在class下的变量）
    #对象属性 （在类内和self关联，在类外和对象名关联的变量）
    #动态属性（函数）
# class Foo:
#     country = 'China'
#     country_lst  = ['China']
#     def __init__(self,name):
#         self.name = name
# alex = Foo('alexander')
# xiao = Foo('jiangxiao')
# xiao.age = 20
# alex.country_lst =[]
# print(Foo.country_lst) #['China']
# Foo.role = 'Person'
# print(Foo.country)  #China
# print(alex.name)
# print(xiao.name)
# alex.country = '印度'
# print(alex.country) #印度
# print(xiao.country) #China
# print(Foo.country)#China
# del alex.country
# print(alex.country)#China
# print(alex.country_lst)#[]
# alex.country_lst.append('印度')
# print(alex.country_lst) #['印度']
# print(xiao.country_lst)#['China']
# print(Foo.country_lst)#['China']

#类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量

# 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性

# class Foo:
#     count = 0
#     def __init__(self):
#         Foo.count += 1
#
# f = Foo()
# f1 = Foo()
# f2 = Foo()
# print(f.count)#Foo.count
# print(f1.count)#Foo.count
# print(f2.count)#Foo.count
# 3
# 3
# 3


# 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,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('哈尼',23,'男',1994,3,28)
# print('%s %d岁 %s %d年 %d月 %d日'%(boss_gold.name,
#                                boss_gold.age,
#                                boss_gold.sex,
#                                boss_gold.birth.year,
#                                boss_gold.birth.month,
#                                boss_gold.birth.day))
#圆形类
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.randius = r
#     def perimeter(self):
#         return 2*pi*self.randius
#     def area(self):
#         return pi*(self.randius**2)
# #环形类
# class Ring:
#     def __init__(self,outer_r,inner_r):
#         self.outer_circle = Circle(outer_r)#大圆的周长
#         self.inner_circle = Circle(inner_r)#小圆的周长2
#     def perimeter(self):
#         return self.outer_circle.perimeter()+self.inner_circle.perimeter()
#     def area(self):
#         return self.outer_circle.area() - self.inner_circle.area()
# ring1 = Ring(20,10)
# print(ring1.area())

#人狗大战
# 面向对象的三大特性之一 —— 继承
# 继承 ：至少两个类 ： 什么 是 什么 的关系,为了避免几个类之间有相同的代码
# 父类 ： 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 Animal:
    def __init__(self,name,aggressivity,life_value,money):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value
        self.money = money
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#金老板攻击增加了

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)
huang.bite(boss_gold)
print(boss_gold.life_value)
boss_gold.attack(huang)
print(huang.life_value)

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