day24 python学习 类 画元，命名空间作用域，组合，人狗大战升级

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

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

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

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

对于类的静态属性和方法不同操作发生的效果

#·类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效

#如果对可变数据类型，断开并指向新的数据类型，那只是对象自己的静态属性发生变化
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量

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

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)

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.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

继承与重用性