python 20 days

python 20 days

组合、继承、抽象类、接口类

昨天内容，升级版：人狗大战

练习题：

花钱购买武器，攻击力上升：

class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        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):
        person.hp -= self.ad
#
# # 装备
# # 花钱 -> 装备 -> 攻击力上升
# # 价格
# # 加一些生命值、为任务添加攻击力
# # 秘技
#
class Weapon:
    def __init__(self,name,price,ad=0,hp=0):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
        self.ad_total = self.ad    # 人和武器的攻击力的总和
    def kill(self,dog):
        dog.hp -= self.ad_total

alex = Person('alex',None,50,1)
taibai = Dog('哮天犬','teddy',200,30)
alex.attack(taibai)
print(taibai.hp)
板儿砖 = Weapon('打狗砖',998,190)
# print(板儿砖.__dict__)
alex.weapon = 板儿砖
alex.weapon.kill(taibai)   # ---> 组合
print(taibai.hp)

199
9

 

人和武器的攻击力：

lass Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        dog.hp -= self.ad

    def recharge(self,money):
        self.money += money

    def buy_weapon(self,wp):   # self ->alex  wp -> 板儿砖
        if self.money >= wp.price:
            self.money -= wp.price
            self.weap = wp
            # self.ad += wp.ad
            self.weap.ad_total += self.ad
            print('武器装备成功，当前余额%s'%self.money)
        else:
            print('余额不足，请充值再来')

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):
        person.hp -= self.ad

class Weapon:
    def __init__(self,name,price,ad=0,hp=0):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
        self.ad_total = self.ad    # 人和武器的攻击力的总和
    def kill(self,dog):
        dog.hp -= self.ad_total

alex = Person('alex',None,50,1)
taibai = Dog('哮天犬','teddy',200,30)
板儿砖 = Weapon('打狗砖',998,190)
alex.buy_weapon(板儿砖)
alex.recharge(1000)
alex.buy_weapon(板儿砖)
alex.weap.kill(taibai)
print(taibai.hp)

余额不足，请充值再来
武器装备成功，当前余额2

9

 

组合 ：两个类的事儿
    关系： 一个类有另一个类 比如 人有武器
一个类的对象作为另一个类对象的属性
武器类的对象作为人类对象的一个属性
课程类的对象作为学生对象的一个属性
圆形类的对象作为圆环对象的一个属性

练习题：

1，学生类 课程类 —— 学生和课程组合在一起
    学生类 ： 学生姓名 性别 年龄 手机号 课程
    课程类 ： 名称 周期 价格

lass Student:
    def __init__(self,name,sex,age,number,course):
        self.name = name
        self.sex = sex
        self.age = age
        self.number = number
        self.course = course

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

python = Course('python','6 months',20000)
python.period = '5 months'
xiaoming = Student('小明','male',18,1234567891,python)
xiaoming2 = Student('小明2','male',18,1234567891,python)
xiaoming3 = Student('小明3','male',18,1234567891,python)
print(xiaoming.course.name)
print(xiaoming2.course.period)
print(xiaoming3.course.period)
print(xiaoming.course.period)

python
5 months
5 months
5 months

 

2，圆形类 圆环类 —— 圆环和圆形组合在一起

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def perimeter(self): #计算周长
        return pi*2*self.r
    def area(self):  # 计算面积
        return pi*self.r**2

class Ring:
    def __init__(self,out_r,in_r):
        self.out_circle = Circle(out_r)
        self.in_circle = Circle(in_r)
    def peri(self):
        return self.out_circle.perimeter() + self.in_circle.perimeter()
    def are(self):
        return self.out_circle.area() - self.in_circle.area()

r = Ring(10,5)
print(r.peri())
print(r.are())

94.24777960769379
235.61944901923448

 

三大特性 ： 继承 封装 多态
继承：

 

单继承 —— 所有面向对象语言都支持
class 另外一个类名():pass
class 类名(另外一个类名):pass
print(类名.__bases__)  # 可以去查看父类

多继承 —— python
class 另类1():pass
class 另类2():pass
class 类名(另类1,另类2):pass
print(类名.__bases__) # 可以去查看父类
print(另类1.__bases__) # 可以去查看父类
object类是所有类的基类

 

 

继承的作用：

lass Role:
    def __init__(self,name,hp,ad):
        print('in Role init')
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s回了10点血'%self.name)
        self.hp += 10
class Person(Role):
    def __init__(self,name,sex,hp,ad):
        self.sex = sex                     # 派生属性
        self.money = 100
        Role.__init__(self,name,hp,ad)     # 指名道姓
        # super().__init__(name,hp,ad)                   # super()代表父类
        # super(Person,self).__init__(name,hp,ad)                   # super()代表父类
    def attack(self,dog):                  # 派生方法
        dog.hp -= self.ad
    def eat(self):
        if self.money >= 10:
            self.money -= 10
            # super().eat()
            Role.eat(self)
class Dog(Role):
    def __init__(self,name,kind,hp,ad):
        super().__init__(name,hp,ad)
        self.kind = kind                 # 派生属性
    def bite(self,person):
        person.hp -= self.ad

# 继承 —— 代码的重用性
alex = Person('alex',None,100,1)
# print(alex.__dict__)
taibai = Person('taibai','teddy',100,1)
# print(taibai.__dict__)
print(alex.name)
alex.attack(taibai)
print(taibai.hp)
alex.eat()
taibai.eat()

in Role init
in Role init
alex
99
alex回了10点血
taibai回了10点血

 

继承的语法，在子类定义的时候括号里父类的名字
对象在寻找名字的时候 ： 先找自己对象空间里的 -> 再找自己的类的空间里的 -> 父类的空间里的
在自己的类中调用父类中的同名方法，指名道姓（需要自己传self参数），super方法（不需要自己传self参数）

class Foo:
    def __init__(self):
        self.func()
    def func(self):print('in foo')

class Son(Foo):
    def func(self):print('in son')

Son()

in son

 

抽象类和接口类：

组合 什么有什么的关系
    一个类的对象作为另外一个类对象的属性
继承 什么是什么的关系  —— 写代码用的 ****
    节省两个类之间共有的方法或者代码
    如果子类和父类的一样，那么可以省略子类的，用父类的
    如果是子类特有的，用子类的 —— 派生
    如果两个方法，子类也有父类也有，用子类的
    如果两个方法，子类也有父类也有，想用父类的 ： 指名道姓 super

抽象类和接口类  —— 了解 *
在python代码中 抽象类和接口类没有明显的区别
主要就是维持了一种规范

 

一切皆对象

dic = {'k':'v'}
lst = [1,2,3]

len(lst)
print(dic.__len__(),len(dic))

1    1

 

抽象类 ：

    在类的位置指定metaclass 是ABCMeta
    在指定的方法上面添加@abstractmethod装饰器
目的：规范所有继承这个类的子类 必须实现被@abstractmethod装饰器装饰的这个方法
特点：抽象类和接口类不能被实例化

m abc import ABCMeta,abstractmethod

class Pay(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):pass    # 规范



s WechatPay(Pay):
    def pay(self,money):
        print('微信支付了%s元'%money)

class AliPay(Pay):
    def pay(self, money):
        print('支付宝支付了%s元' % money)

class ApplePay(Pay):
    def pay(self,money):
        print('apple支付了%s元' % money)

def payment(obj,money):obj.pay(money)
wp = WechatPay()
payment(wp,100)     # 编程的习惯 —— 归一化设计
wp.pay(100)
ap = AliPay()
payment(ap,100)
ap.pay(100)

app = ApplePay()
payment(app,100)

微信支付了100元
微信支付了100元
支付宝支付了100元
支付宝支付了100元
apple支付了100元

 

                                                                                                                                                                                     接口类：规范
python天生支持多继承
java语言是不支持多继承的

from abc import ABCMeta,abstractmethod
class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass

class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        print('walk')
    def swim(self):
        print('swim')

class Parrot:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')

class Swan:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')
    def swim(self):
        print('swim')

钻石继承 —— 新式类 和 经典类 —— python程序员需要了解的 ***