# 面向对象的命名空间
# 属性：静态属性（直接和类名关联或者直接定义在class名下的变量）它是属于累的
# 对象属性（在类内和self关联，在类外和对象名关联的变量）它是属于对象的
# 动态属性（函数）
# class Foo:
# country ='China'
# country_lst = ['China']
# def __init__(self,name):
# self.name = name
#
# alex = Foo('alexander')
# egg = Foo('egg')
# alex.age = 90
# Foo.role = 'Person'
# print(Foo.country)
# print(alex.name)
# print(egg.name)
# print(alex.country)#此刻结果是china,因为类对象指针指向country
# alex.country = '印度'
# print(alex.country)#他自己变了此刻自己的空间里有了country属性，断开了与父类指针指向
# print(egg.country)#他的还是不变
# 此刻alex要想恢复中国国籍需要做操作 #del alex.country
# alex.country_lst.append('印度')#此刻这项操作改变了class中country_lst，他所属的对象对应的都会变如下
# print(alex.country_lst)#['China', '印度']
# print(egg.country_lst) #['China', '印度']# 此刻egg 也会跟着改变因为class里面的country_lst发生改变了
# 此刻再在alex.age = 90 下面加一个
# alex.country_lst =[]# 这个时候在自己空间内新建了一个country_lst
# print(Foo.country_lst)# 所以这时候对类的 coun影响try_lst不会造成任何
# 类名 操作 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间查找，找不到就到类的空间找
#修改变量：
# 如果是对可变数据类型中元素进行修改，那么全局就会生效
#如果是对变量进行重新赋值，那么知识在对象自己的命名空间里增加了一个新的属性
#总结 用类名去操作 静态变量
# 小练习 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性
#这是一道面试题
# class Foo:
# count = 0
# def __init__(self):
# Foo.count+=1
# f = Foo()
# print(f.count)
# f2 = Foo()
# print(f2.count)
# f3 = Foo()
# print(f3.count) # 上述的答案为 1 3 3
# 下面这种情况不同于上面
# f = Foo()
# f2 = Foo()
# f3 = Foo()
# print(f.count)
# print(f2.count)
# print(f3.count) # 这里的结果是 3,3,3
# class Person:
# def __init__(self):pass
# #给一个什么属性都没有的对象赋一些初始的属性（__init__做的事情）
# def eat(self):
# print('吃猪食')
#
# alex = Person()#裸着的人
# print(alex.__dict__)
# alex.eat() #此刻可以调用 alex.eat() ==Person.eat(alex）找到了eat方法近而调用
# 由上面的进一步发展到以下的情况
# class Person:
# def __init__(self):pass
# def eat(self):
# print('吃猪食')
#
# alex = Person()
# print(alex.__dict__)
# alex.eat= '泔水' #此处加一个（对象使用名字的顺序，先用自己的，再用类的）
# alex.eat() #执行结果是TypeError: 'str' object is not callable
# alex.name = 'alexander'
# print(Person.name) #他找不到 name 类里不能找到对象中的属性
#对象可以使用类的属性
#类无法使用对象的属性
# print(Person.eat)
# print(alex.eat) ##因为类对象指针eat的存在（eat指针指向类中eat方法）
# 面向对象的三大特性：封装多态继承
# 组合 表达的是 什么 有 什么 的关系
#组合的定义 ： 一个对象的属性是另外一个类的对象
# 比如老师有生日
# class Teacher:
# def __init__(self,name,age,sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# #老师有生日 所以再给生日定义一个类
# class Bithday:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
#
# bithday1=Bithday(1968,12,31)
# boss_gold =Teacher('太亮',40,'不详')
# boss_gold.birth = bithday1
# boss_gold.birth.year #就可以查看金老师的生日中的年了 这就是组合了
#老师有生日：年月日
#讲一个类的对象拥有的属性，再将其定义成一个类以提高代码的复用
# 下面是在定义的时候就用到组合：
#老师有生日 所以再给生日定义一个类
# class Bithday:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
#
# class Teacher:
# def __init__(self, name, age, sex,year,month,day):
# self.name = name
# self.age = age
# self.sex = sex
# self.birth = Bithday(year,month,day)
# boss_gold = Teacher('太亮',40,'不详',1968,12,31)
# 练习
# 圆形类
# 环形类 计算环形类的周长，以及面积
# import math
# class Shape:
# def __init__(self,radius):
# self.radius = radius
# def cir_long(self):
# return 2*math.pi*self.radius
# def area(self):
# return math.pi*(self.radius**2)
#
# class yuanhuan:
# def __init__(self,outer_r,inner_r):
# self.outer_cirle = Shape(outer_r)
# self.inner_cirle = Shape(inner_r)
# def zhouchang(self):
# return self.outer_circle.cir_long() + self.inner_cirle.cir_long()
# def mianji(self):
# return self.outer_cirle.area() - self.inner_cirle.area()
#
# #既能hold住环形类，又能解决圆形类的问题
# # 假设不用组合的话 有两个圆形一个半径 20 一个10
# outer_circle = Shape(20)
# inner_circle = Shape(10)
# print(outer_circle.area()- inner_circle.area()) #这是不用组合的解法
# # 但是有500个环的话，得这样500次
#
# # 但是如果有组合可以这样：
# yh = yuanhuan(20,10)
# yh.mianji()
# 用组合完成人狗大战的游戏
# 狗
# 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)
# if boss_gold.money >dgb.price:
# boss_gold.money - = dgb.price
# boss_gold.weapon = dgb
# boss_gold.aggressivity + = dgb.aggr #封装成一个方法放在人类中
# boss_gold.attack()
# print(huang.life_value)
# 封装完毕以后就可以如下调用了：
# 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): 新式类
#两个类中有相同的代码，
# 继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的
# 单继承和多继承
# 父类 超类 基类
# 子类 派生类
# 抽象和继承
浙公网安备 33010602011771号