类命名空间与对象、实例的命名空间
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：静态属性和动态属性
- 静态属性就是直接在类中定义的变量
- 动态属性就是定义在类中的方法
对于类的静态属性和方法不同操作发生的效果
#·类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效
#如果对可变数据类型，断开并指向新的数据类型，那只是对象自己的静态属性发生变化
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量
# 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性
class Foo:
country='中国'
country_list=['china']
def __init__(self,name):
self.name=name
f1=Foo('alex')
f2=Foo('jinxing')
f1.country='印度' #当我在对象中操不可变类型的作静态变量时，只是类自己中的静态变量发生变化
print(f1.country) #印度
print(f2.country) #中国
print(Foo.country) #中国
Foo.country='美国' #当在类中操作不可变类型的静态变量时，对象的静态变量都会发生变化，
print(Foo.country) # 美国
print(f1.country) #印度 #除了这个在上边已经单独对对象的静态属性进行改变的
print(f2.country)# 美国
f1.country_list.append('韩国') #在对象中操作可变类型的静态属性时,当对其增删改时
# ，整体都会发生变化
print(f1.country_list)#['china', '韩国']
print(Foo.country_list) #['china', '韩国']
f2.country_list=[] #这个是将f2.country_list断开可原来的指向，指向了另外一个新的列表
print(f2.country_list)#[] #得到的结果是
print(Foo.country_list) #['china', '韩国']创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
面向对象的组合用法
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
class Squear: #先定义一个类
def __init__(self,radius):
self.radius=radius
def squear(self): # 在类中有关于他面积的动态属性，
return 3.14*(self.radius**2)
def perimeter(self):
return self.radius*2*3.14
class Ring:
def __init__(self,r1,r2): #在这里是将其他类中的对象当作此类中的数据来引用
self.a1=Squear(r1)
self.a2=Squear(r2)
def squear_ring(self):
return self.a1.squear()-self.a2.squear() #在这里可以直接调用调用过来的
# 对像的属性来进行相印的计算和操作的
def perimeter_ring(self):
return self.a1.perimeter()+self.a2.perimeter()
w3=Ring(30,10)
print(w3.squear_ring()) #2512.0 计算出圆环的面积
print(w3.perimeter_ring()) #计算出圆环的周长计算圆环的面积和周长
#类的组合，
class Preson:
def __init__(self,name,life_vale,aggressivity,money):
self.name=name
self.life_value=life_vale
self.aggressivity=aggressivity
self.money=money
def attac(self,animal): #定义了人的攻击属性，人攻击狗
print('%s攻击了%s'%(self.name,animal.name))
animal.life_value-=self.aggressivity
def get_weapen(self,weapen_name):#人设置了一个方法，装备武器
if self.money>weapen_name.price:
self.aggressivity += weapen_name.argg#装备武器是对人的
# 一些特点进行加成，这里需要引用武器这个对象属性
self.money -=weapen_name.price
class Dog:
def __init__(self,name,life_vale,aggressivity,breed):
self.name=name
self.life_value=life_vale
self.aggressivity=aggressivity
self.bred=breed
def attac(self,pieple):
print('%s咬击了%s'%(self.name,pieple.name))
pieple.life_value-=self.aggressivity
class Weapon: #在这里定义了一个武器的类
def __init__(self,name,price,argg):#武器带有的一些属性
self.name=name
self.price=price
self.argg=argg
gold_jin=Preson('金星',1000,10,200)
gou=Dog('黑子',500,100,'哈士奇')
dgg=Weapon('打狗棍',100,50)#设置了一个武器对象
gold_jin.get_weapen(dgg) #人执行了get_weapon的方法，将武器打狗棍的属性加上去
print(gold_jin.money) #钱由200变成100 #当加成完成之后再看人的钱和，攻击力会发生变化
print(gold_jin.aggressivity)#攻击力由10增长到60
gold_jin.attac(gou) #此时执行方法 攻击 gou #金星攻击了黑子
print(gou.life_value) #440 狗的血量由500降到440人狗大战之带武器
class Teacher:
def __init__(self,name,age,sex,brith):
self.name=name
self.age=age
self.sex=sex
self.brith=brith
class Birthda:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
a=Teacher('alex',18,'man',Birthda(1997,10,10)) #这里可以直接将里一个Brithda中的一个对象传入
# ，当他的一个数据属性之一。 然后就可以在调用的时候使用（调用）这个对象中的一些属性
print(a.name,a.brith.year,a.brith.day)
#alex 1997 10 这是打印的结果老师和生日
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
继承
什么是继承
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
两个类中有相同的代码，
# 继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的
# 单继承和多继承
# 父类 超类 基类
# 子类 派生类
# 抽象和继承
class Animal:#定义一个父类，
def __init__(self,name,hurt,life_value):
self.name=name
self.hurt=hurt
self.life_value=life_value
class Dog(Animal): #注意子类的使用父类方法 #子类，其中有一些特种是和父类中一样的
# 所以不用再一一去设定（写ef __init__(self,name,hurt,life_value):重复写这些内容，
# 直接调用即可
def eat(self,people):
people.life_value-=self.life_value
class People(Animal):
def eat(self,dog):
dog.life_value-=self.life_value
huang=Dog('大黄',100,1000)
alex=People('alex',50,500)
huang.eat(alex)
print(alex.life_value)从Animal开始认识继承
python中类的继承分为：单继承和多继承
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass查看继承
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)继承与抽象（先抽象再继承）
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
