Python006

学习总结六

面向对象编程

含义：把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）和泛化（generalization），通过多态（polymorphism）实现基于对象类型的动态分派。
1. 类是对象的蓝图和模板，有了类就可以创建对象
2. 定义类需要做两件事情：数据抽象和行为抽象
3. 数据抽象——抽取对象的静态特征（找名词）— 属性
4. 行为抽象——抽取对象的动态特征（找动词）—方法
5. 定义类的关键字——class — 类名（每个单词首字母大写）

---

定义类

class Student(object):       # 定义类。(自己定义的类)首字母要大写

    # 构造方法，构造器 / 构造子 - constructor
    # 调用该方法的时候不是直接使用方法的名字而是直接使用类的名字
    def __init__(self, name, age):   # init表示初始化  给对象绑定属性
        self.name = name   
        # self.__name = name   加一个下划线代表隐藏，后面更改无效
        # self.__age = age

    # 定义方法：代表对象可以接收这个消息
    # 对象的方法的第一个参数都是统一写成self
    # 它代表了接收消息的对象 - 对象.消息（参数）
    def study(self, course):      # study表示学习（学生的行为）
        print('%s正在学习%s' % (self.name, course)) # self接受消息的对象

    def watch_av(self):
        if self.age >= 18:
            print('%s正在观看岛国动作片' % self.name)
        else:
            print('%s,我们推荐你观看《熊出没》。' % self.name)

def main():
    # Step2 调用构造方法创建学生对象
    stu1 = Student('瞿凯', 24)
    # stu1.name = '元芳'   # 可以在外面改名字或者年龄

    # Step3 给对象发出消息
    # 通过给对象发消息让对象完成某些工作
    # 解决任何的问题都是通过让对象取做事情
    stu1.study('python课程设计')

    stu2 = Student('王大锤', 16)
    # stu2.age = 18
    stu2.study('HTML网页设计')
    stu2.watch_av()


if __name__ == '__main__':
    main()

练习1

定义数字时钟

class Clock(object):
    def __init__(self, hour=0, minutes=0, second=0):
        self._hour = hour
        self._minutes = minutes
        self._second = second

    def run(self):
        """
        走字
        :return:
        """
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minutes += 1
            if self._minutes == 60:
                self._minutes = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
    #def __str__(self) 这种可以获得对象的字符串表示形式，当我们用print打印对象时会自动调该方法。
        """
        显示时间
        :return:
        """
        return '%02d:%02d:%02d' % (self._hour, self._minutes, self._second)


from time import sleep

def main():
    clock = Clock(23,59,58) # 创建对象
    while True:
        clock.run()
        sleep(1)
        print(clock.show())

if __name__ == '__main__':
    main()

练习2

倒计时时钟

class Clock(object):
    def __init__(self, hour=23, minutes=59, second=59):
        self._hour = hour
        self._minutes = minutes
        self._second = second

    def run(self):
        self._second -= 1
        if self._second == -1:
            self._second = 59
            self._minutes -= 1
            if self._minutes == -1:
                self._minutes = 59
                self._hour -= 1
                if self._hour == 0:
                    self._hour == 0

    def show(self):
        return '%02d:%02d:%02d' % (self._hour, self._minutes, self._second)

from time import sleep

def main():
    clock = Clock(0,0,3)
    while True:
        clock.run()
        sleep(1)
        print(clock.show())
        if clock._hour == 0 and clock._minutes == 0 and clock._second == 0:
            print( '倒计时结束！')
            break

if __name__ == '__main__':
    main()

练习3

定义点的移动等动作

from math import sqrt


class Point(object):

    def __init__(self, x=0, y=0):
        self._x = x
        self._y = y

    def move_to(self, x, y):   # 移动到某一点
        self._x = x
        self._y = y

    def move_by(self, dx, dy):   # 移动去某一点
        self._x += dx
        self._y += dy

    def distangce_to(self, other):
        dx = self._x - other._x
        dy = self._y - other._y
        return sqrt(dx ** 2 + dy ** 2)

    def __str__(self):
        return '(%s, %s)' % (str(self._x), str(self._y))


class Line(object):

    def __init__(self, start, end):
        self._start = start
        self._end = end

    @property
    def length(self):
        return self._start.distance_to (self._end)


# 线段上有两个点 - has - a - 关联关系（对象与对象之间的关系）
# 人和房子的关系 - use - a - 依赖关系
# 学生是人类 - is - a - 继承关系
def main():
    p1 = Point(3, 5)
    p2 = Point()
    print(p1)
    print(p2)
    print(p1.distangce_to(p2))
    p1.move_by(1,2)
    print(p1)
    p1.move_to(8,8)
    print(p1)

if __name__ == '__main__':
    main()

练习4

计算矩形周长面积

class Rectangel(object):  # step1 定义类

    def __init__(self, height, width):  # 构造方法
        self._width = width   # 定义属性
        self._height = height

    @property  # 属性访问器
    def height(self):
        return self._height

    @height.setter  # 属性修改器
    def height(self, height):
        if height >= 0:
            self._height = height
        else:
            self._height = 0

    def area(self):  # 定义行为
        return self._height * self._width

    def perimeter(self):
        return (self._height + self._width) * 2


def main():
    rect1 = Rectangel(12, 55)  # step2  自动调用构造方法。创建对象（实例）访问类的属性和方法
    print(rect1.area())      # step3 给对象发消息
    print(rect1.perimeter())


if __name__ == '__main__':
    main()

练习5

泳池走廊围墙造价

class Cricle(object):   # step1 定义类

    def __init__(self,radius):   # 构造方法
        self._radius = radius    # 定义属性

    def area(self):    # 定义行为
        return pi * self._radius ** 2

    def perimeter(self):  # 周长
        return 2 * pi * self._radius


def main():
    r = float(input('请输入游泳池的半径：'))
    big = Cricle(r + 3)     # step2自动调用构造方法  创建对象（实例） 访问类的属性和方法
    small = Cricle(r)
    print('围墙的造价：%.2f' % (big.perimeter() * 35.5))   # step3 给对象发消息，执行方法
    print('走廊的造价：%.2f' % (((big.area() - small.area()) * 25)))

if __name__ == '__main__':
    main()

练习6

工资计算表

class Person(object):
    def __init__(self, name, post):
        self._name = name
        self._post = post

    @property
    def name(self):
        return self._name

    @property
    def post(self):
        return self._post

    @post.setter
    def post(self, post):
        self._post = post

    def count(self):
        return '姓名：%s, 岗位：%s' % (self._name, self._post)


class Manager(Person):
    def __init__(self, name, post, month=0):
        super().__init__(name, post)
        self._month = month

    @property
    def month(self):
        return self._month

    @month.setter
    def month(self, month):
        self._month = month

    def count_salary(self):
        return '%s%s当月工资为：%d' % (self._name, self._post, 15000 * self._month)


class Programmer(Person):
    def __init__(self, name, post,  hour=0):
        super().__init__(name , post)
        self._hour = hour

    @property
    def hour(self):
        return self._hour

    @hour.setter
    def hour(self, hour):
        self._hour = hour

    def count_salary(self):
        return '%s当月工资为: %d' % (self._name, 150 * self._hour)


class Salesperson(Person):
    def __init__(self, name, post, sales=0):
        super().__init__(name, post)
        self._sales = sales

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, sales):
        self._sales = sales

    def count_salary(self):
        return '%s当月工资为：%d' % (self._name, 1200 + 0.05 * self._sales)


def main():
    manager1 = Manager('张三', 'manager',1)
    print(manager1.count_salary())
    programmer1 = Programmer('李四', 'programmer', 120)
    print(programmer1.count_salary())
    salesperson1 = Salesperson('王麻子', 'salesperson', 100000)
    print(salesperson1.count_salary())


if __name__ == '__main__':
    main()

练习7

奥特曼打小怪兽

from random import randint


class Ultraman(object):

    __slots__ = ('_name', '_hp', '_mp')  # 表示只能有这三个属性

    def __init__(self, name, hp, mp):
        self._name = name
        self._hp = hp   # 血量
        self._mp = mp   # 蓝量

    @property   # 属性访问器
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    def attack(self, monster):   # 普通攻击小怪兽
        injury = randint(15, 25)
        monster.hp -= injury

    def huge_attack(self, monster):   # 大招攻击小怪兽
        if self._mp >= 50:
            self._mp -= 50
            injury = monster.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            monster.hp -= injury
        else:
            self.attack(monster)   # 直接调用上面的

    def magic_attack(self,monsters):    # 魔法攻击
        if self._mp >= 20:
            self._mp -= 20
            for monster in monsters:
                monster.hp -= randint(10, 15)

    def __str__(self):
        return '%s奥特曼\n' % self._name + \
               '生命值：%d\n' % self._hp + \
               '魔法值：%d\n' % self._mp


class Monster(object):

    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        self._name = name
        self._hp = hp

    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    def attack(self, ultraman):
        ultraman.hp -= randint(10, 20)

    def __str__(self):
        return '%s小怪兽\n' % self._name + \
               '生命值：%d' % self._hp


def main():
    u = Ultraman('王大锤', 1000, 100)
    print(u)
    m = Monster('舒小锤', 250)
    print(m)
    attack_round = 1
    while u.hp > 0 and m.hp >0:
        print('====第%d回合====' % attack_round)
        u.attack(m)
        if m.hp > 0:
            m.attack(u)
        print(u)
        print(m)
        attack_round += 1
    if u.hp > 0:
        print('%s奥特曼胜利' % u.name)
    else:
        print('%s小怪兽胜利' % m.name)


if __name__ == '__main__':
    main()