面向对象（续）

一：不同的类的对象如何实现交互呢？

      因此必须掌握类中方法的传参和调用，例如要实现人狗大战中的交互，可以这么做，程序如下：

class Person:
    role = 'person'   # 静态属性
    def __init__(self,name,sex,hp,ad):
        self.name = name     # 对象属性 属性
        self.sex = sex
        self.hp = hp         
        self.ad = ad         
    def attack(self,d):
        d.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,d.name,d.name,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,p):
        p.hp -= self.ad
        print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad))

alex = Person("张三","男",20,15)
teddy = Dog('dsa','teddy',50,10)
teddy.bite(alex)
alex.attack(teddy)

二：面向对象过程中的命名空间和作用域

     1, 假设在实例化的过程中，创建了一个对象，我们把它用一个变量 a 接收，再为这个对象添加了name , hobby 等属性后，可以通过 a.name来查看对象的属性，在过程中，a 指向这个对象的内存空间，然后在内存空间里找到name

     2, 假设我们为这个对象添加了一个方法 attack ,那么可以通过 a.attack() 进行调用，在这个过程中，a 先找到自己的内存空间，然后通过里面的类对象指针找到这个类，再通过类找到这个方法attack，同理，也可以用  a.静态变量名 找到定义的静态变量。

ps : 对象的内存空间里: 只存储对象的属性，而不存储方法和静态属性, 方法和静态属性都存储在类的内存空间中，这样做是为了节省内存，让多个对象去共享类中的资源。

上述过程的示意图如下：

三：对静态变量进行修改，应该使用类名直接修改，

比如下面这个程序：

class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,'工作,赚了1000块钱')
        self.money += 1000   #此处若要对静态变量进行修改，
                            # 可以改成 Person.money+=1000,这样输出就为2000
father = Person('father')
mother = Person('mother')
mother.work()
father.work()
print(Person.money)   #此处输出为0

class Person:
    money = [1]
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,'工作,赚了1000块钱')
        self.money[0] += 1000

father = Person('father')
mother = Person('mother')
mother.work()
father.work()
print(Person.money)   # 2000 or 0?

class Person:
    money = [0]
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,'工作,赚了1000块钱')
        self.money =  [Person.money[0] + 1000]

father = Person('father')
mother = Person('mother')
mother.work()
father.work()
print(Person.money)

ps：

1，对象属性是独有的，静态属性和方法是共享的

2，对象使用名字：先找自己内存空间中的，再找类的内存空间中的

3，对于静态属性的修改，应该使用类名.静态变量名直接修改

 

【例】写一个类,完成一个功能 :可以统计这个类有几个对象。

class Foo:
    count = 0
    def __init__(self):
        Foo.count += 1
f1 = Foo()
f2 = Foo()
f3 = Foo()
f4 = Foo()
f5 = Foo()
print(Foo.count)

【例】写一个类，计算多个圆的周长和面积。

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def cal_area(self):
        '''
        计算圆面积的方法
        :return:返回值是float数据类型的面积
        '''
        return pi*self.r**2
    def cal_perimeter(self):
        '''
        计算圆周长的方法
        :return:返回值是float数据类型的周长
        '''
        return pi * self.r * 2
for i in range(1,10,2):
    c1 = Circle(i)
    print(c1.cal_area())
    print(c1.cal_perimeter())

【例】用面向对象的思想实现打印：

小明，10岁，男，上山去砍柴 

小明，10岁，男，开车去东北

小明，10岁，男，最爱大保健

老李，90岁，男，上山去砍柴

老李，90岁，男，开车去东北

class Person:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def hobby(self):
        print("%s,%d岁,%s,上山去砍柴" %(self.name,self.age,self.sex))
        print("%s,%d岁,%s,开车去东北" % (self.name, self.age, self.sex))
        print("%s,%d岁,%s,最爱大保健" % (self.name, self.age, self.sex))
alex=Person("小明",10,"男")
wusir=Person("老李",90,"男")
alex.hobby()
wusir.hobby()

 四：组合

1：什么是组合？

    组合就是把一个对象当另一个对象的属性，表示什么有什么的关系。

2：为什么要使用组合？

    因为独立的对象不能发挥作用，必须依赖另一个对象。

【注】组合实例分析

from math import pi
class Circle:
    def __init__(self,r):
        self.r=r
    def area(self):
        return pi*self.r**2
    def perimeter(self):
        return pi * self.r * 2


class ring:
    def __init__(self,R,r):
        self.x=Circle(R)
        self.y=Circle(r)
    def area(self):
        return self.x.area()-self.y.area()
    def perimeter(self):
        return self.x.perimeter()+self.y.perimeter()

r1 = ring(10, 5)
print(r1.area())
print(r1.perimeter())

class Clas:
    def __init__(self,name,num,course,type):
        self.name = name
        self.num = num
        self.course = course
        self.type = type

class Teacher:
    def __init__(self,name,sex,age,py11):
        self.name = name
        self.sex = sex
        self.age = age
        self.cls = py11        #对象py11当做对象boss_jin的属性

py11 = Clas('超级无敌s11',89,'python','脱产全栈')     #在clas里创建对象
boss_jin = Teacher('太白','？',40,py11)
print(py11.course)          # 11期的课程
print(boss_jin.cls.course)  # 金老板所带的班级的课程

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    def fmt(self):
        return '%s-%s-%s'%(self.year,self.month,self.day)
class Teacher:
    def __init__(self,name,birth):
        self.name = name
        self.birthday = birth

birth = Birthday(2018,8,18)
alex = Teacher('alex',birth)
print(alex.birthday.year)   # 调用组合对象中的属性
print(birth.fmt())
print(alex.birthday.fmt())  #调用组合对象中的方法