学习python第十五天，面对对象

学习python第十五天，面对对象

面对对象又叫劝退对象，要么劝退你的对象，要么python劝退你，hhhh

开玩笑，但是这块知识点确实比较难

面向对象编

面向对象编程
指令式编程---->面向过程（函数）编程----->程序比较简单的时候没有任何毛病

编程范式（程序设计的方法论）：面向对象编程/函数式编程

对象： 对象是可以接收消息的实体，面向对象编程就是通过给对象发消息达到解决问题的目标

对象 = 数据 + 函数（方法）----->对象将数据和操作数据的函数从逻辑上变成一个整体。

类（类型）： 将一大类对象共同的特正抽取出来之后得到的一个抽象概念

简单地说，类是对象的蓝图（模板），有了类才能创建出这种类的对象

面向对象编程：
1、定义类---->使用驼峰命名法，每个单词首字母大写
~数据抽象： 找到对象相关的静态特征（属性）---->找名词
~行为抽象： 找到和对象相关的动态特征（方法）----->找动词
2、造对象
3、发消息
一切皆为对象
对象都有属性和行为
每个对象都是独一无二的
对象一定属于某个类

面对对象编程一般分为三个步骤

# 第一步，定义类
class Student:
    # 数据抽象
    """
    学生
    """

    def __init__(self, name, age):
        self.name = name
        self.age = age
        pass

    # 行为抽象
    def eat(self):
        """
        吃饭
        :return:
        """
        print(f'{self.name}正在吃饭')
        pass

    def study(self, course_name):
        """
        学习
        :param course_name:
        :return:
        """
        print(f'{self.name}正在学习{course_name}')

    def play(self, game_name):
        """
        玩耍
        :param game_name:
        :return:
        """
        print(f'{self.name}正在玩{game_name}')
        pass

    def watch_av(self):
        """
        看片
        :return:
        """
        if self.age < 18:
            print(f'{self.name}小于18岁，只能看熊出没')
        else:
            print(f'{self.name}正在看岛国片')

# 第二步： 创建对象 ---->构造器语法--->类名(...., .....)
stu1 = Student(name='龚凡', age=17)
stu2 = Student('爱因斯坦', 67)

if __name__ == '__main__':
    # 第二步： 创建对象 ---->构造器语法--->类名(...., .....)
    stu1 = Student(name='龚凡', age=17)
    stu2 = Student('爱因斯坦', 67)
    # 第三步，给对象发送消息（调用对象的方法）
    stu1.study('python程序设计的方法论')
    # Student.study(stu1, 'python程序设计的方法论')
    stu2.study('光子原理')
    
    stu1.eat()
    
    stu1.play('王者荣耀')
    stu2.play('斗地主')
    
    stu1.watch_av()
    stu2.watch_av()

简单来说，

1、就是创建类，对象，然后阐述对象属性、 行为，

2、找到这个类里面一个确切的对象，比如爱因斯坦，龚凡

3，给这两个确切的对象发送消息、指令，然他们执行他们的行为

练习

有一个圆形游泳池，泳池外围有一条三米宽的石板路将泳池围起，小路外围又是一道围墙将小路围起来

石板路的造价为58.5一平米，然后围墙造价为38.5一米

现在要求用面向对象的方法求石板路和围墙的造价

class Circle:

    def __init__(self, radius):
        self.radius = radius

    def perimeter(self):
        return 2 * math.pi * self.radius
   # 圆的周长公式

    def area(self):
        return math.pi * self.radius ** 2
 # 圆的面积公式

if __name__ == '__main__':
    r = float(input('请输入游泳池的半径： '))
    c1, c2 = Circle(r), Circle(r + 3)
    # 求出大圆、小圆点面积
    fence_price = c2.perimeter() * 38.5
    aisle_price = (c2.area() - c1.area()) * 58.5
    print(fence_price + aisle_price)

练习

显示出一个时钟

首先要显示时钟的字样，其次我们要控制它的走字问题

import time
import os


class Clock:
    """时钟"""
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def show(self):
        """
        显示时间
        输入起始时间
        :return:
        """
        return f'{self.hour:>2d}:{self.minute:>2d}:{self.second:>2d}'

    def run(self):
        """
        走字
        根据时钟走字规则加减时、 分、 秒
        :return:
        """
        self.second += 1
        if self.second == 60:
            self.second = 0
            self.minute += 1
            if self.minute == 60:
                self.minute = 0
                self.hour += 1
                if self.hour == 24:
                    self.hour = 0


if __name__ == '__main__':
    clock = Clock(23, 59, 58)
    while True:
        clock.run()
        print(clock.show())
        time.sleep(1)
        # 循环一次休眠一秒
        os.system('cls')
        # 清屏函数

静态方法、类方法

只知道三条边，用面向对象计算三角形面积

定义描述三角形的类，提供计算周长和面积的方法

我们在类里面写的函数，通常称之为方法，它们基本上都是发给对象的消息。
但是有的时候，我们的消息并不想发给对象，而是希望发给这个类（类本身也是一个对象），
这个时候，我们可以使用静态方法或类方法。

class Triangle:
    """三角形"""

    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

    # @classmethod
     # 使用类方法判断，这三条边是否能够构成三角形，这两个@单词是使用这两个方法的钥匙，有钥匙才能使用
    # def is_valid(cls, a, b, c):
    #     return a + b > c and b + c > a and a + c > b

    @staticmethod
    # 使用静态方法判断，这三条边是否能够构成三角形
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self.a + self.b + self.c

    def area(self):
        half = self.perimeter() / 2
        return (half * (half - self.a) * (half - self.b) * (half - self.c)) ** 0.5


if __name__ == '__main__':
    # 调用静态方法，判断三条边能否构成三角形
    if Triangle.is_valid(3, 4, 5):
        t = Triangle(3, 4, 5)
        print(t.perimeter())
        print(t.area())
    else:
        print('无效的边长，无法构造三角形对象')

静态方法 - 发给类的消息 ---> @staticmethod ---> 装饰器
类方法 - 发给类的消息 ---> @classmethod ---> 装饰器 ---> 第一个参数（cls）是接收消息的类

作业

使用面对对象制作倒计时器

import time
import os


class Clock:
    """时钟"""

    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def show(self):
        """
        显示时间
        :return:
        """
        return f'{self.hour:>2d}:{self.minute:>2d}:{self.second:>2d}'

    def run(self):
        """
        走字
        :return:
        """

        if self.second > 0:
            self.second -= 1
        if self.second == 0:
            if self.minute > 0:
                self.second = 60
                self.minute -= 1
                self.second -= 1
            if self.minute == 0 and self.second == 0:
                if self.hour > 0:
                    self.hour -= 1
                    self.minute = 60
                    self.minute -= 1
        if self.hour == 0 and self.minute == 0 and self.second == 0:
            return '时间到'


if __name__ == '__main__':
    clock = Clock(1, 1, 0)
    while True:

        if clock.run() == '时间到':
            print(clock.run())
            break
        else:
            print(clock.show())
        time.sleep(1)
        os.system('cls')

王者荣耀，小兵和铠爹的战争

import random


class Hero:

    def __init__(self, name, blood,):
        """

        :param name: 人物名字
        :param blood: 人物血量
        """
        self.name = name
        self.blood = blood

    def kill_one(self, enemy):
        enemy.blood -= 5
        return f'{self.name}一技能命中对方，{enemy.name}减少5滴血'

    def kill_two(self, enemy):
        enemy.blood -= 10
        return f'{self.name}二技能命中对方，{enemy.name}减少10滴血'

    def kill_big(self, enemy):
        enemy.blood -= 20
        return f'{self.name}大招命中对方，{enemy.name}减少20滴血'

    def kill_A(self, enemy):
        enemy.blood -= 5
        return f'{self.name}A了一下对方，{enemy.name}减少2滴血'
    pass


fatherK = Hero('铠爹', 50)
batman = Hero('小兵', 30)
print('######开始游戏######')
while True:
    if fatherK.blood <= 0 or batman.blood <= 0:
        break
    h = random.randrange(1, 10)
    print(h)
    if h == 1:
        print(fatherK.kill_one(batman))
    elif h == 2:
        print(fatherK.kill_two(batman))
    elif h == 3:
        print(fatherK.kill_big(batman))
    elif h == 10:
        print(fatherK.kill_A(batman))
    else:
        print(batman.kill_A(fatherK))
    print(f'{fatherK.name}还剩{fatherK.blood}')
    print(f'{batman.name}还剩{batman.blood}')
if fatherK.blood <= 0:
    print(f'{batman.name}获胜')
else:
    print(f'{fatherK.name}获胜')

我尽力了