学习Python第三周的第四天

学习Python第三周的第四天

一、面向对象编程

​ 面向对象编程是一种编程范式（程序设计的方法论）。

如果要用一句话来概括面向对象编程，我认为下面的说法是相当精准的。

面向对象编程：把一组数据和处理数据的方法组成对象，把行为相同的对象归纳为类，通过封装隐藏对象的内部细节，通过继承实现类的特化和泛化，通过多态实现基于对象类型的动态分派。

对象：对象是可以接收消息的实体，面向对象编程就行通过给对象发消息达到解决问题的目标。对象 = 数据 + 函数（方法），即对象将数据和操作数据的函数从逻辑上变成了一个整体。

对象有以下四个特征：

• 一切皆为对象
• 对象都有属性和行为
• 每个对象都是独一无二的
• 对象一定属于某个类

类：将有共同特征（静态特征和动态特征）的对象的共同特征抽取出来之后得到的一个抽象概念。简单的说，类是对象的蓝图（模板），有了类才能够创建出这种类型的对象。

二、创建和使用对象

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

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

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

2、创建对象

3、给对象发消息

例如：

# 第一步：定义类
class Student:
    """学生"""

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

    # 行为抽象（方法）
    def eat(self, name):
        """吃饭"""
        print(f'{self.name}正在吃{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}')
        
# 第二步：创建对象--->构造器语法--->类名（..., ...）
Stu1 = Student('黄小宇', 18)
Stu2 = Student('周大大', 21)

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

Stu2.study('Python程序设计')

三、经典例题

# 创建一个时钟对象（可以显示时/分/秒），让它运转起来
import time


class Clock:

    # 数据抽象
    def __init__(self, hour=0, minute=0, second=0):
        self.hour = hour
        self.min = minute
        self.sec = second

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

    # 行为抽象
    def run(self):
        """走字"""
        self.sec += 1
        if self.sec == 60:
            self.sec = 0
            self.min += 1
            if self.min == 60:
                self.min = 0
                self.hour += 1
                if self.hour == 24:
                    self.hour = 0


if __name__ == '__main__':
    clock = Clock()
    while True:
        print(clock.show())
        time.sleep(1)
        clock.run()

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

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

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


class Triangle:

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

    @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__':
    try:
        t = Triangle(3, 4, 5)
        print(t.perimeter())
        print(t.area())
    except ValueError as err:
        print(err)

四、简单的总结

面向对象编程是一种非常流行的编程范式，除此之外还有指令式编程、函数式编程等编程范式。由于现实世界是由对象构成的，而对象是可以接收消息的实体，所以面向对象编程更符合人类正常的思维习惯。类是抽象的，对象是具体的，有了类就能创建对象，有了对象就可以接收消息，这就是面向对象编程的基础。定义类的过程是一个抽象的过程，找到对象公共的属性属于数据抽象，找到对象公共的方法属于行为抽象