以下写了个简单的冒泡排序函数：
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']
如上，当一个列表数字是字符串，我需要把输出结果按字符串长度进行排序输出，那么只需要在调用函数的时候，修改函数变量的函数就可以实现了。
这就是高阶函数！