Python---第14天---面向对象

Python—第14天—面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容

易的。

面向对象

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

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

对象：

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

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

• 一切皆为对象

• 对象都有属性和行为

• 每个对象都是独一无二的

• 对象一定属于某个类

类：

将有共同特征（静态特征和动态特征）的对象的共同特征抽取出来之后得到的一个抽象概念。

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

面向对象编程：

1. 定义类 —> 类的命名使用驼峰命名法（每个单词首字母大写）

   数据抽象：找到和对象相关的静态特征（属性） —> 找名词

   行为抽象：找到和对象相关的动态特征（方法） —> 找动词

2. 造对象

3. 发消息

创建对象

class Student:
    """学生类"""

    # 数据抽象(属性)
    def __init__(self, name, age):
        self.name = name
        self.age = age

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

    def study(self, course_name):
        """学习

        :param course_name: 课程名字
        """
        print(f'{self.name}正在学习{course_name}.')

    def play(self, game_name):
        """玩

        :param game_name: 游戏名字
        """
        print(f'{self.name}正在玩{game_name}.')

给对象发消息

from e01 import Student

# 第二步：创建对象 ---> 构造器语法 ---> 类名（...，...）
stu1 = Student('王大锤', 15)
stu2 = Student('张三', 30)

# Student.study(stu1, 'Python程序设计') 
# 第三步： 给对象发消息（调用对象的方法）
stu1.study('Python程序设计')
stu1.eat()

stu2.play('斗地主')

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

练习1：

import math


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)
    aisle_price = (c2.area() - c1.area()) * 58.5
    fence_price = c2.perimeter() * 38.5
    print(f'围墙的造价：{aisle_price:0.2f}元')
    print(f'过道的造价：{fence_price:0.2f}元')
    print(f'总计：{aisle_price + fence_price:0.2f}元')

练习2：

创建一个时钟对象（可以显示时/分/秒）

import time
import os


class Clock:
    """时钟"""

    def __init__(self, hour=0, minute=0, seconds=0):
        """"""
        self.hour = hour
        self.minute = minute
        self.seconds = seconds

    def run(self):
        """走动"""
        self.seconds += 1
        if self.seconds == 60:
            self.minute += 1
            self.seconds = 0
            if self.minute == 60:
                self.hour += 1
                self.minute = 0
                if self.hour == 24:
                    self.hour = 0

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


if __name__ == '__main__':
    c1 = Clock(23, 59, 56)
    while True:
        # os.system('cls')
        print(c1.show())
        c1.run()
        time.sleep(1)

可以调用os函数，在终端运行该程序

静态方法或类方法

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

静态方法 — 发给类的消息 —> @staticmethod —> 装饰器

类方法 —发给类的消息 —> @classmethod —> 装饰器 —> 第一个参数（cls）是接受消息的类

练习：

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

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

    def __init__(self, side1, side2, side3):
        if not Triangle.is_valid(side1, side2, side3):
            raise ValueError('无效的边长，无法构成三角形！')
        self.side1 = side1
        self.side2 = side2
        self.side3 = side3

    # @classmethod
    # def is_valid(cls, side1, side2, side3):
    # return side1 + side2 > side3 and side1 + side3 > side2 and side3 + side2 > side1

    @staticmethod
    def is_valid(side1, side2, side3):
        return side1 + side2 > side3 and side1 + side3 > side2 and side3 + side2 > side1

    def perimeter(self):
        """周长"""
        return self.side1 + self.side2 + self.side3

    def area(self):
        """面积"""
        p = self.perimeter() / 2
        return (p * (p - self.side1) * (p - self.side2) * (p - self.side3)) ** 0.5


if __name__ == '__main__':
    try:
        t1 = Triangle(3, 4, 5)
        print(t1.perimeter())
        print(t1.area())
    except ValueError as err:
        print(err)

Python允许我们在程序中手动设置异常，使用 raise 语句即可。

该语句引发当前上下文中捕获的异常（比如在 except 块中），或默认引发 RuntimeError 异常。

三角形必须满足两边之和大于第三边，当输入的变成不符合条件时

练习3：

创建一个倒计时对象（可以显示时/分/秒）

import time
import os


class Clock:
    """时钟"""

    def __init__(self, hour=0, minute=0, seconds=0):
        self.hour = hour
        self.minute = minute
        self.seconds = seconds

    def run(self):
        """走动"""
        self.seconds -= 1
        if self.seconds == -1:
            self.minute -= 1
            self.seconds = 59
            if self.minute == -1 and self.hour > 0 and self.seconds > 0:
                self.hour -= 1
                self.minute = 59

    def show(self):
        """显示"""
        # 当时钟到00：00：00时设置报错
        if self.hour == 0 and self.minute == 0 and self.seconds == 0:
            raise ValueError('倒计时结束')
        return f'{self.hour:0>2d}:{self.minute:0>2d}:{self.seconds:0>2d}'


if __name__ == '__main__':
    c1 = Clock(0, 1, 3)
    try:
        while True:
            # os.system('cls')
            print(c1.show())
            c1.run()
            # 睡眠1秒
            time.sleep(1)
    # 捕获报错
    except ValueError as err:
    	# 输出 倒计时结束
        print(err)

同样可以调用os函数，在终端运行该程序