067、Python 高阶函数的编写：优质冒泡排序-优快云博客

以下写了个简单的冒泡排序函数：

def bubble_sort(items: list) -> list:
    for i in range(1, len(items)):
        swapped = False
        for j in range(0, len(items) - 1):
            if items[j] > items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break


if __name__ == '__main__':
    nums = [55, 66, 9, 22, 86, 35, 44, 97, 56]
    bubble_sort(nums)
    print(nums)  # 输出结果：[9, 22, 35, 44, 55, 56, 66, 86, 97]

上面写法虽然正确排好序了，但初始化变量nums的结果改变了，如果实际应用不需要把初始变量改变，该如何？

优化后：

def bubble_sort(items: list) -> list:
    items = items[:]  # 把列表数据赋给一个新变量并作为返回值
    for i in range(1, len(items)):
        swapped = False
        for j in range(0, len(items) - 1):
            if items[j] > items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    return items


if __name__ == '__main__':
    nums = [55, 66, 9, 22, 86, 35, 44, 97, 56]
    print(bubble_sort(nums))  # 输出结果：[9, 22, 35, 44, 55, 56, 66, 86, 97]
    print(nums)  # 输出结果：[55, 66, 9, 22, 86, 35, 44, 97, 56]  原来值并没有改变

如此修改后初始化变量就可以保留，又可以输出排好序的数据了。

这点是基于以下编程思想：

在我们设计函数的时候，一定要注意函数的无副作用（调用函数不影响调用者）。优化后函数质量提升了。

但是该函数的功能还不够全面，假如我对于排序输出结果既要按升序输出，也要按降调输出，又该如何？

方法就是增加一个布尔值变量：

def bubble_sort(items: list, ascending=True) -> list:  # 增加一个bool变量
    items = items[:]  # 把列表数据赋给一个新变量并作为返回值
    for i in range(1, len(items)):
        swapped = False
        for j in range(0, len(items) - 1):
            if items[j] > items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    if not ascending:
        items = items[::-1]
    return items


if __name__ == '__main__':
    nums = [55, 66, 9, 22, 86, 35, 44, 97, 56]
    print(bubble_sort(nums))  # 输出结果：[9, 22, 35, 44, 55, 56, 66, 86, 97]
    print(bubble_sort(nums, ascending=False))  # 输出结果：[97, 86, 66, 56, 55, 44, 35, 22, 9]

如此，我们就可以通过变量ascending的值来判断按升序还是降序输出结果。

但是优化后的函数还不够好，因为在if items[j] > items[j + 1]:语句存在一定的耦合性。那么又该如何解耦呢？

方法就通过引入函数变量：

def bubble_sort(items: list, ascending: bool = True, gt=lambda x, y: x > y) -> list:  # 增加一个bool变量，并引入一个Lambda函数
    items = items[:]  # 把列表数据赋给一个新变量并作为返回值
    for i in range(1, len(items)):
        swapped = False
        for j in range(0, len(items) - 1):
            if gt(items[j], items[j + 1]):  # 通过调用函数做大小比较
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    if not ascending:
        items = items[::-1]
    return items


if __name__ == '__main__':
    nums = [55, 66, 9, 22, 86, 35, 44, 97, 56]
    print(bubble_sort(nums))  # 输出结果：[9, 22, 35, 44, 55, 56, 66, 86, 97]
    print(bubble_sort(nums, ascending=False))  # 输出结果：[97, 86, 66, 56, 55, 44, 35, 22, 9]

如此优化后，该函数质量就很高了，功能更全面，灵活性更高。

为什么这么说，看以下应用：


def bubble_sort(items: list, ascending: bool = True, gt=lambda x, y: x > y) -> list:  # 增加一个bool变量，并引入一个Lambda函数
    """冒泡排序

    ：param items: 待排序的列表
    ：param ascending：是否使用升序
    ：param gt: 比较两个元素大小的函数
    ：return: 返回排序后列表
    """
    items = items[:]  # 把列表数据赋给一个新变量并作为返回值
    for i in range(1, len(items)):
        swapped = False
        for j in range(0, len(items) - 1):
            if gt(items[j], items[j + 1]):  # 通过调用函数做大小比较
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    if not ascending:
        items = items[::-1]
    return items


if __name__ == '__main__':
    nums = [55, 66, 9, 22, 86, 35, 44, 97, 56]
    print(bubble_sort(nums))  # 输出结果：[9, 22, 35, 44, 55, 56, 66, 86, 97]
    print(bubble_sort(nums, ascending=False))  # 输出结果：[97, 86, 66, 56, 55, 44, 35, 22, 9]
    words = ['Apple', 'Banana', 'Orange', 'Strawberry', 'Grape', 'Watermelon']
    print(bubble_sort(words, gt=lambda x, y: len(x) > len(y), ascending=False))
    # 输出结果 ['Watermelon', 'Strawberry', 'Orange', 'Banana', 'Grape', 'Apple']

如上，当一个列表数字是字符串，我需要把输出结果按字符串长度进行排序输出，那么只需要在调用函数的时候，修改函数变量的函数就可以实现了。

这就是高阶函数！