day24 面向对象 命名空间组合 以及继承

一、上节回顾：

类：

对象

实例化：类（）调用__init__方法产生一个对象的过程

类属性：静态属性，数据属性

方法：动态属性，函数属性

初始化方法：__init__

self:在一个类里表示对象本身

对象调用对象属性、方法

类调用静态属性

作业讲解：

1、小明和老李的故事

class Person:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def cutfirewood(self):
        print("%s,%s岁，%s,上山去砍柴"%(self.name,self.age,self.sex))
    def drivertodb(self):
        print("%s,%s岁，%s,开车去东北"%(self.name,self.age,self.sex))
    def lovedbj(self):
        print("%s,%s岁，%s,最爱大保健"%(self.name,self.age,self.sex))
ming=Person("小明",10,"boy")
ming.cutfirewood()
ming.drivertodb()
ming.lovedbj()
alex=Person("老李",90,"男")
alex.cutfirewood()
alex.drivertodb()
alex.lovedbj()

2、圆的周长与圆的面积

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

二、新内容（属性，组合，继承）

1、属性的介绍：

属性：静态属性（直接和类名关联或者直接定义在class下的变量）

　　　对象属性（在类内和self关联，在类外和对象名关联的变量）

　　　动态属性（函数）

说明：

（1）

（2）只有自己的发生了变化

（3）都发生了变化

class Foo:
    country="china"
    country_lst=["china"]
    def __init__(self,name):
        self.name=name
alex=Foo("alesander")
egg=Foo("egon")
print(Foo.country)  #china
print(alex.country) #china
print(egg.country)     #china
alex.country='印度'
print(alex.country)   #印度
print(egg.country)     #china
print(Foo.country)  #china
del alex.country  #恢复指针指向
print(alex.country) #china
print(alex.country_lst)   #['china']
alex.country_lst.append("印度")   #都发生了变化
print(alex.country_lst)   #['china', '印度']
print(egg.country_lst)      #['china', '印度']
print(Foo.country_lst)      #['china', '印度']

2、总结：

　　类名操作变量 不管操作可变还是不可变数据类型，都是类中对应的变量发生变化

　　对象名操作静态变量

　　引用变量：现在自己的命名空间中查找，找不到就去类的命名空间去找

　　修改变量：

　　如果是对可变数据类型中的元素进行修改，那么全局生效

　　如果是对变量进行重新赋值，那么只是在对象自己的命名空间增加了一个新的属性

　面试题：

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

class Foo:
    count=0
    def __init__(self):
        Foo.count+=1
f=Foo()
f2=Foo()
f3=Foo()
print(f.count)  #3
print(f2.count) #3
print(f3.count) #3
# 总结:执行一次count才能在自己的命名空间增加

3、新问题

对象可以使用类的

 4、组合

（1）什么叫做组合

class Teacher:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Birthday:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
birthday1=Birthday(1968,12,31)
boss_gold=Teacher("太亮",40,"不详")
boss_gold.birth=birthday1
print(boss_gold.birth.year)   #1968
#将一个类的对象拥有的属性，再将其定义成一个类似提高代码的复用

class Teacher:
    def __init__(self, name, age, sex, year, month, day):
        self.name = name
        self.age = age
        self.sex = sex
        self.birth = Birthday(year, month, day)
class Birthday:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
# birthday1=Birthday(1968,12,31)
boss_gold=Teacher("太亮",40,"不详",1968,12,31)
# boss_gold.birth
print(boss_gold.birth.year)   #1968

（2）小练习

from math import pi
class Circle:
    def __init__(self,r):
        self.radius=r
    def perimeter(self):
        return 2*pi*self.radius
    def area(self):
        return pi*(self.radius**2)
class Ring:
    def __init__(self,outer_r,inner_r):
        self.outer_circle=Circle(outer_r)
        self.inner_circle=Circle(inner_r)
    def perimeter(self):
        return self.outer_circle.perimeter()+self.inner_circle.perimeter()
    def area(self):
        return self.outer_circle.area()-self.inner_circle.area()
ring1=Ring(20,10)
print(ring1.perimeter())

人狗大战的拓展：

class Dog:
    def __init__(self,name,breed,aggressiving,life_value):
        self.name=name
        self.breed=breed
        self.aggressiving=aggressiving
        self.life_value=life_value
    def bite(self,people):
        people.life_value-=self.aggressiving
class Person:
    def __init__(self,name,aggressiving,life_value,money):
        self.name=name
        self.aggressiving=aggressiving
        self.life_value=life_value
        self.money=money
    def attack(self,dog):
        dog.life_value-=self.aggressiving
    def get_weapon(self,weapon_obj):
        if self.money>weapon_obj.price:
            self.money-=weapon_obj.price
            self.weapon=weapon_obj
            self.aggressiving+=weapon_obj.aggr
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)
boss_gold.get_weapon(dgb)
boss_gold.attack(huang)
print(huang.life_value)

5、继承：多继承和单继承

（1）继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类

　　 父类又可称为基类或超类，新建的类称为派生类或子类

（2）查看继承的类

print(Dog.__bases__)
# (<class 'object'>,)

单继承：
class Person:
    pass
class Dog(Person):
    pass
print(Dog.__bases__)
# (<class '__main__.Person'>,)

多继承
class Person:
    pass
class Weapon:
    pass
class Dog(Person,Weapon):
    pass
print(Dog.__bases__)
# (<class '__main__.Person'>, <class '__main__.Weapon'>)

（3）总结

两个类中有相同的代码：

　　　　继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的

单继承和多继承

父类 超类  基类

子类 派生类

抽象和继承