python面向对象组合-day22

class A:
    Country = 'China'
    def talk(self):
        print('%s is talking'%self.name)
alex = A()          #相当于A(self)
alex.name = 'alex'  #相当于A(self,name)
alex.talk()
一个类可以没有__init__
在没有__init__的情况下,实例化经历了哪些步骤???
    1.创建一个空间给对象
    2.将这个空间的地址返回

class A:
    Country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s is talking'%self.name)
#新增静态属性
A.静态属性名 = 'abc'
print(A.静态属性名)
#修改静态属性
A.Country = '印度'
print(A.Country)
#删除静态属性
del A.Country
print(A.Country)   # 报错
#查看类中的方法,只能看,不能改也不能删
print(A.__dict__)

类的命名空间中有什么:
    静态属性(共享给所有对象的)
    动态属性(绑定到所有对象的)

对象的命名空间和类的命名空间之间的关系:
    对象和类之间有一个单向的联系,类对象指针
    创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
    对象在使用某个名字的时候,如果在自己的空间中没有找到,就找父类,如果父类找不到,就要到类的空间中去找,最后到找不到抛异常
    对象可以查看类的静态属性,但是不能修改
    并且一旦修改,就不能取到类当中的内容了(除非手动删除这个修改的属性)
    所有的静态属性的修改,都应该由类名来完成,而不应该使用对象名来完成
class A:
    Country = 'China'
    def __init__(self,name):
        self.name = name
    def talk(self):
     print('%s is talking'%self.name)
alex = A('alex')
baoyuan = A('baoyuan')
print(alex.Country)
alex.Country = '泰国'
print(alex.Country)
del alex.Country
print(alex.Country)
print(A.Country)
print(baoyuan.Country)

静态属性就是用来描述所有的对象都共享的某一个值
class People:
    money = 1000
    def salary(self):
        People.money += 1000
mother = People()
father = People()
mother.salary()
father.salary()
print(People.money,mother.money,father.money)

写一个类,能够记录这个类有多少个对象了(每一次实例化都能够被记录下来)
    class A:
        count = 0
        def __init__(self):
            A.count += 1
    print(A.count)
    a = A()
    print(A.count)
方法二
    class A:
        count = 0
        def __init__(self):
            self.counter()
        def counter(self):
            A.count+=1
    a = A()

class People:
    money = 1000
    def salary(self):
        People.money += 1000
mother = People()
father = People()
mother.salary()
father.salary()
print(People.money,mother.money,father.money)

class B:
    l = []
    def __init__(self,name):
        self.l.append(name)
alex = B('alex')
baoyuan = B('宝元')
print(B.l)
print(alex.l)
print(baoyuan.l)

如果静态变量是一个不可变数据类型,那么只要对象修改这个数据,就相当于在对象的空间中新建
如果静态变量是一个可变数据类型,那么对象修改这个容器中的元素,相当于修改类的空间中的元素
如果静态变量是一个可变数据类型,那么对象直接对这个变量重新赋值,相当于修改对象自己空间中的元素

大结论
只要是静态变量,就用类名去修改,永远修改成功,并且所有的对象都共享这个改变

总结
对象的命名空间:类指针\对象的所有属性
类的命名空间:方法和(静态属性\字段)
对象在寻找名字的时候 : 先找对象自己内存空间中的,找不到就去类的命名空间中寻找
类中的名字是什么时候写入内存的 : 代码从上到下执行的时候就已经写入的.一定是在实例化之前
静态变量 : 尽量用类名去操作

组合 : 一个类对象的属性是另外一个类的对象
class Person:
    def __init__(self,name,sex,hp,mp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.mp = mp
        self.ad =ad
    def attack(self,dog):
        print('%s攻击了%s'%(self.nme,dog.name))
        dog.hp -= self.ad
class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬了%s'%(self.name,person.name))
        person.hp -= self.ad
alex = Person('alex','man',10,10,0.1)
hei = Dog('小黑','中华田园犬',999,1.1)
hei.bite(alex)
class Weapon:
    def __init__(self,name,price,ad):
        self.name = name
        self.price = price
        self.ad = ad
    def skill(self,dog):
        print('%s被%s攻击了'%(dog.name,self.name))
        dog.hp -= self.ad
        print(dog.hp)
sh = Weapon('棍子',9.99,66)
sh.skill(hei)
alex.武器 = sh
alex.武器.skill(hei)
# sh.ad -= 10
alex.武器.skill(hei)
#解耦 (降低耦合)

class Birthday:
    def __init__(self,y,m,d):
        self.y = y
        self.m = m
        self.d = d
class Student:
    def __init__(self,name,sex,birth_day):
        self.name = name
        self.sex = sex
        self.birth_day = birth_day
birth = Birthday(1990,11,22)
bobo = Student('bobo','male',birth)
#bobo.birthday == birth
print(birth.year)
print(bobo.birthday.year)


class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return 3.14*self.r**2
    def perimter(self):
        return 3.14*2*self.r
c1 = Circle(10)
print(c1.area())
print(c1.perimter())

class Ring:
    def __init__(self,outer_r,inner_r):
        self.out_r = outer_r
        self.in_r = inner_r
    def area(self):
        return self.out_r**2*3.14 - self.in_r**2*3.14
    def perimeter(self):
        return self.out_r*2*3.14 - self.in_r*2*3.14
r1 = Ring(10,5)
print(r1.area())
print(r1.perimeter())

圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
from math import pi
class Circle:
    def __init__(self,r):   #r为圆半径
        self.r = r
    def area(self):
        return pi*self.r**2
    def perimeter(self):
        return pi*self.r*2
c1 = Circle(10)         #实例化一个圆半径为10
print(c1.area())        #计算圆的面积
print(c1.perimeter())   #计算圆的周长
class Ring:
    def __init__(self,outer_r,inner_r):
        self.out_c1 = Circle(outer_r)
        self.in_c2 = Circle(inner_r)
        # c1 = Circle(outer_r)
        # c2 = Circle(inner_r)
        # self.out_c = c1
        # self.in_c = c2
    def area(self):
        return self.out_c1.area() - self.in_c2.area()
    def perimeter(self):
        return self.out_c1.perimeter() + self.in_c2.perimeter()
r1 = Ring(10,5)         #实例化一个环形
print(r1.area())        #计算环形的周长
print(r1.perimeter())   #计算环形的面积

事例二
class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name
        self.gender=gender
        self.birth=birth
        self.course=course
    def teach(self):
        print('teaching')

p1=Teacher('egon','male',BirthDate('1995','1','27'),
           Couse('python','28000','4 months')
           )
print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
结果
1995 1 27
python 28000 4 months
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好