全网最适合入门的面向对象编程教程：46 Python 函数方法与接口-函数与事件驱动框架

本文档主要介绍如何使用 Python 进行面向对象编程，需要读者对 Python 语法和单片机开发具有基本了解。相比其他讲解 Python 面向对象编程的博客或书籍而言，本文档更加详细、侧重于嵌入式上位机应用，以上位机和下位机的常见串口数据收发、数据处理、动态图绘制等为应用实例，同时使用 Sourcetrail 代码软件对代码进行可视化阅读便于读者理解。

相关示例代码获取链接如下：https://github.com/leezisheng/Python-OOP-Demo

正文

函数

函数是一个命名的代码块，需要 0 个或多个输入参数，运行以后会返回输出值。在 Python 中，函数不仅是对象，也是第一类对象（First-Class Object），这是 Python 函数的一大特性。函数作为对象可以赋值给一个变量、可以作为元素添加到集合对象中、可作为参数值传递给其它函数，还可以当做函数的返回值，这些特性就是第一类对象所特有的。

简单来说，就是在 Python 中可以把函数像普通变量一样任意地使用,。包括赋值，以及作为其它函数的参数和返回值。这样就能很容易地写出高阶函数与闭包的代码。而在其他应用面向对象设计的语言中（如 C++）实现类似操作，需要借助函数指针进行实现。

在许多情况下，我们需要将函数作为参数传递到另一个函数中。最典型的例子就是事件驱动编程模式，所谓事件驱动编程模式不同于原先依次执行每个函数的编程模式，其基本的处理思路是预先设计一个事件循环所形成的程序，这个事件循环程序不断地检查目前要处理的信息，根据要处理的信息执行一个触发函数进行必要的处理。其中这个外部信息可能来自一个目录夹中的文件，可能来自键盘或鼠标的动作，或者是一个时间事件。

从事件角度说，事件驱动程序的基本结构是由一个事件收集器、一个事件发送器和一个事件处理器组成。事件收集器专门负责收集所有事件，包括来自用户的（如鼠标、键盘事件等）、来自硬件的（如时钟事件等）和来自软件的（如操作系统、应用程序本身等）。事件发送器负责将收集器收集到的事件分发到目标对象中。事件处理器做具体的事件响应工作，它往往要到实现阶段才完全确定。在事件处理器中一般都需要提前传入一个注册好的回调函数，回调函数被注册之后，程序将继续执行后面的语句，而回调函数则会在对应事件产生后被异步调用。

函数身为一个对象，拥有对象模型的三个通用属性：id、类型、和值。在下面的代码中，我们创建了一个平均值滤波函数，实现三个周期的传感器采样值计算平均值，在代码中，DataList 为全局变量，它用来记录 FileterLength 个周期的采样值，AverageFilter(value)为滤波函数，它的输入为新采集到的数据，函数中，首先将 DataList[]中的数据进行移位，并将新采集到的数据保存到 DataList[]最后的元素中，同时计算 DataList[]中 10 个数据的和，最后返回 FileterLength 个数据和的平均值。示例代码如下：

_# 全局变量，记录三个周期的采样值_

FileterLength   = 3

DataList        = [0] * FileterLength

def AverageFilter(value):

    '''

    平均值滤波函数，实现三个周期的传感器采样值计算平均值

    :param value: 当前采样值

    :return: 滤波后的传感器数值

    '''

    global DataList

    _# 临时变量，存储列表中数据之和_

    sum = 0

    for i in range(FileterLength-1):

        _# 实现列表的移位操作_

        DataList[i] = DataList[i+1]

        _# 实现列表求和_

        sum += DataList[i]

    DataList[FileterLength-1] = value

    sum += DataList[FileterLength-1]

    average = sum / len(DataList)

    return average

我们首先访问一下这个函数的基本属性：

print(id(AverageFilter))

print(type(AverageFilter))

print(AverageFilter)

运行结果如下：

我们可以给函数添加自定义属性并且访问自定义属性：

AverageFilter.description = ("The average value filter function realizes the calculation of the average value "

                             "of the sensor sample value for three periods")

print(AverageFilter.description)

运行结果如下：

事件驱动框架计时器

接下来我们用一个事件驱动框架计时器的示例更好的说明函数作为参数可以传递到另一个函数中的相关应用。示例代码如下：

import datetime

import time

_# 定义定时器事件类_

class TimedEvent:

    def __init__(self, endtime, callback):

        '''

        初始化方法，存储endtime和callback

        :param endtime:  callback执行前需要等待的时间

        :param callback: 回调函数，即到达执行时间后调用的函数

        '''

        self.endtime = endtime

        self.callback = callback

    def ready(self):

        '''

        判断是否事件已经到达了该执行的适合

        :return:

        '''

        return self.endtime <= datetime.datetime.now()

_# 定义定时器类，轮询检测实现任务调度_

class Timer:

    def __init__(self):

        '''

        初始化方法，定义一个events列表存储事件

        '''

        self.events = []

    def call_after(self, delay, callback):

        '''

        添加新的事件

        :param delay: 执行回调方法之前要等待的秒数

        :param callback: 回调方法

                         callback函数应该接收一个参数：执行调用的计时器

        :return:

        '''

        end_time = (datetime.datetime.now() +

                    datetime.timedelta(seconds=delay))

        self.events.append(TimedEvent(end_time, callback))

    def run(self):

        '''

        轮询检测，执行到达执行时间的回调函数

        :return:

        '''

        _# 轮询检测，执行到达执行时间的回调函数_

        while True:

            _# 使用一个生成器表达式，将将时间已到的事件过滤出来_

            ready_events = (e for e in self.events if e.ready())

            _# 按照顺序执行_

            for event in ready_events:

                event.callback(self)

                _# 执行完成后，移除已执行完毕的任务_

                self.events.remove(event)

            _# 在每次迭代过程中休眠 0.5 秒以防止系统死机_

            time.sleep(0.5)

下面，我们编写几个回调函数测试一下：

def format_time(message, *args):

    '''

    用字符串的 format 方法将当前时间添加到信息中，并说明变量参数

    :param message: 接收任意数量的定位参数

    :param args:    用于在函数中处理传递的位置参数序列

    :return: None

    '''

    _# 当前的时间，格式为：时-分-秒_

    now = datetime.datetime.now().strftime("%I:%M:%S")

    _# 格式化打印参数_

    print(message.format(*args, now=now))

_# 回调函数：任务一_

def Task_One(timer):

    format_time("{now}: Called Task One")

_# 回调函数：任务二_

def Task_Two(timer):

    format_time("{now}: Called Task Two")

_# 回调函数：任务三_

def Task_Three(timer):

    format_time("{now}: Called Task Three")

_# 创建定时器对象_

timer = Timer()

_# 添加回调函数_

timer.call_after(1, Task_One)

timer.call_after(2, Task_One)

timer.call_after(2, Task_Two)

timer.call_after(4, Task_Two)

timer.call_after(3, Task_Three)

timer.call_after(6, Task_Three)

_# 开始运行定时器_

format_time("{now}: Starting")

timer.run()

运行结果如下，可以看到到达各自的执行时间后，每个事件都简单地输出当前时间和一段简短的消息，告诉我们调用的是哪个回调方法。

实际上类的方法也可以用作回调函数，示例代码如下

_# 定义类_

class Repeater:

    def __init__(self):

        self.count = 0

    def repeater(self, timer):

        '''

        在函数中在创建一个定时任务

        :param timer: 定时器

        :return: None

        '''

        format_time("{now}: repeat {0}", self.count)

        self.count += 1

        _# 类的方法也可以用作回调函数_

        timer.call_after(5, self.repeater)

_# 创建定时器对象_

timer = Timer()

repeater = Repeater()

_# 添加回调函数，类的方法_

timer.call_after(5, repeater.repeater)

_# 开始运行定时器_

format_time("{now}: Starting")

timer.run()

运行结果如下：

从运行结果中我们不能看出，我们可以从当前正在运行的回调函数中给计时器添加新的事件。然后创建一个计时器并添加几个事件，在不同时间之后调用。

Format 函数

在 Python 中，format()是一个内置函数，用于格式化字符串。format()函数提供了灵活的方式来将变量插入到字符串中，并控制它们的显示格式。

它的语法如下：

format(value, format_spec)

其中，参数说明如下：

value: 要格式化的值;format_spec: 格式化规范，用于指定值的显示方式。
format()函数返回一个格式化后的字符串。

它是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。示例代码如下：

_# 不设置指定位置，按默认顺序_

print("{} {}".format("hello", "world"))

_# 设置指定位置_

print("{0} {1}".format("hello", "world"))

_# 设置指定位置_

print("{1} {0} {1}".format("hello", "world"))

输出如下：