一、 函数高级内容
Python 中的函数是“一等公民”，因此函数本身也是一个对象，函数即可用于赋值，也可用作其函数的参数，还可作为其他函数的返回值。
1、 使用函数变量
Python的函数也是一种值。所有函数都是 function 对象，可以把函数本身赋值给变量，就像把整数、列表、元组等赋值给变量一样。把函数赋值给变量后，就可通过变量来调用函数。示例如下：
1 def pow(base, exponent):
2 """计算乘方"""
3 result = 1
4 for i in range(1, exponent + 1):
5 result *= base
6 return result
7 my_fun = pow # 将 pow 函数赋值给 my_fun 变量
8 print(my_fun(3, 3)) # 计算3的3次方，输出：27
9
10 def area(length, width):
11 """计算面积"""
12 return length * width
13 my_fun = area # 将 area 函数赋值给 my_fun 变量
14 print(my_fun(4, 5)) # 计算面积，输出：20
这里对 my_fun 变量赋值不同的函数，可以让 my_fun 在不同的时间指向不同的函数来让程序更加灵活。使用函数变量的好处是让程序更加灵活。
2、 使用函数作为函数形参
在函数中定义函数形参，这样可在调用该函数时传入不同的函数作为参数，从而动态改变这段代码。示例如下：
1 def map(data, fn):
2 """定义函数类型的形参，其中 fn 是一个函数"""
3 result = []
4 # 遍历 data 列表中的每个元素，并用 fn 函数对每个元素进行计算
5 # 然后将计算结果作为新数组的元素
6 for e in data:
7 result.append(fn(e))
8 return result
9 # 定义一个计算平方的函数
10 def square(n):
11 return n * n
12 # 定义一个计算立方的函数
13 def cube(n):
14 return n * n * n
15 # 定义一个计算阶乘的函数
16 def factorial(n):
17 result = 1
18 for i in range(2, n + 1):
19 result *= i
20 return result
21 data = [2, 4, 6, 8, 10]
22 print("列表原始数据：", data)
23 print("计算列表元素的平方：")
24 print(map(data, square))
25 print("计算元素的立方：")
26 print(map(data, cube))
27 print("计算元素的阶乘：")
28 print(map(data, factorial))
29 print(type(map))
30
31 运行程序输出如下：
32 列表原始数据： [2, 4, 6, 8, 10]
33 计算列表元素的平方：
34 [4, 16, 36, 64, 100]
35 计算元素的立方：
36 [8, 64, 216, 512, 1000]
37 计算元素的阶乘：
38 [2, 24, 720, 40320, 3628800]
39 <class 'function'>
这里定义的 map() 函数的第二个参数是一个函数类型参数，这意味着每次调用函数时可以动态传入一个函数。传入不同的函数，可以动态改变 map() 函数中的部分计算代码。Python3 内置的 map 函数与这里定义的 map 函数功能相似，但是更强大。
3、 使用函数作为返回值
Python支持使用函数作为其他函数的返回值。示例如下：
1 def foo(type):
2 """定义一个函数，该函数包含局部函数"""
3 def square(n):
4 """定义一个计算平方的局部函数"""
5 return n * n
6 def cube(n):
7 """定义一个计算立方的局部函数"""
8 return n * n * n
9 def factorial(n):
10 """定义一个计算阶乘的局部函数"""
11 result = 1
12 for i in range(2, n + 1):
13 result *= i
14 return result
15 # 调用局部函数
16 if type == 'square':
17 # 注意返回的函数不能加括号，只返回函数名称
18 return square
19 elif type == 'cube':
20 return cube
21 else:
22 return factorial
23 # 调用 foo 函数，程序返回一个嵌套函数
24 cube = foo('cube')
25 print(cube(10)) # 计算立方，输出：1000
26 square = foo('square')
27 print(square(5)) # 计算平方：输出：25
28 factorial = foo('factorial')
29 print(factorial(5)) # 计算阶乘：输出：120
这次定义的 foo 函数体定义了3个局部函数，foo 函数由参数来决定返回哪一个函数。
二、 局部函数与 lambda 表达式
lambda 表达式是功能更灵活的代码块，可以在程序中被传递和调用。
从前面的局部函数内容可知，局部函数的作用域仅在其封闭函数体内，离开这个封闭函数体，局部函数的函数名就失去了意义（当然可以用返回函数名的方法进行调用），可考虑用 lambda 表达式简化局部函数的写法。
1、 使用 lambda 表达式代替局部函数
使用 lambda 表达式简化前面的 foo 函数，代码如下：
1 def foo(type):
2 result = 1
3 # 该函数返回的是 lambda 表达式
4 if type == 'square':
5 return lambda n: n * n
6 elif type == 'cube':
7 return lambda n: n * n * n
8 else:
9 return lambda n: (n + 1) * n / 2
10 # 调用 foo 函数，程序返回的是一个嵌套函数
11 square = foo('square')
12 print(square(10)) # 计算平方，输出：100
13 cube = foo('cube')
14 print(cube(10)) # 计算立方，输出：1000
15 other = foo('other')
16 print(other(10)) # 求和，输出：55.0
这次定义的 foo 函数体内，return 后面使用 lambda 关键字定义的是 lambda 表达式。Python 要求 lambda 表达只能是单行表达式，不允许使用复杂的函数形式。
lambda 表达式的语法格式如下：
lambda [参数列表]: 表达式
lambda 表达式的几个要点：
（1）、lambda 表达式必须使用 lambda 关键字定义。
（2）、在 lambda 关键字之后、冒号左边的是参数列表，可以不给参数，也可以给多个参数。多个参数用逗号分隔，冒号右边是 lambda 表达的返回值。
（3）、lambda 表达式也叫做匿名函数，也是单行函数体的函数。
函数比 lambda 表达式的适应性更强，lambda 表达式只能创建简单的函数对象（适合函数体为单行的情形）。lambda表达的两个用途：
（1）、对于单行函数，使用 lambda 表达式更简洁，省去定义函数的过程。
（2）、对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高性能。
下面示例使用内置的 map() 函数，参数是 lambda 表达式：
1 # 计算平方
2 x = map(lambda x: x * x, range(5))
3 print([i for i in x])
4 # 计算偶数的平方
5 y = map(lambda x: x * x if x % 2 ==0 else 0, range(5))
6 print([i for i in y])
这段代码中 map 函数是内置函数，第一个参数是函数，第二个参数通常是列表、元组等。这里传入的 lambda 表达式，是简化的函数，这样程序更加简洁，性能也更好。
三、 小结
函数和lambda 表达式是 Python 编程的两大核心机制之一。Python 支持面向过程编程，也支持面向对象编程。函数和 lambda 表达式是面向过程编程的语法基础，需要重点掌握。
要掌握函数的定义、函数调用语法，函数位置参数与关键字参数的区别和用法、形参默认值等特性。此外，函数也是一个 function 对象，函数可作为其他函数的参数，也可作为其它函数的返回值。把函数当成参数传入其他函数，可以让编程变得更加灵活。
lambda 表达式是单行函数的简化版本，功能比较简单。
练习：
1、 定义一个函数，该函数可接收一个 list 作为参数，该函数使用直接选择排序对 list 排序。
1 def choose_sort(sequence):
2 length = len(sequence)
3 for i in range(length):
4 for j in range(i + 1, length):
5 if sequence[i] > sequence[j]:
6 sequence[i], sequence[j] = sequence[j], sequence[i]
7
8 seq = [100, 31, -50, 1, 3, 28, -11, 85]
9 choose_sort(seq)
10 print(seq) # 输出：[-50, -11, 1, 3, 28, 31, 85, 100]
2、定义一个函数，该函数接收一个 list 作为参数，该函数使用冒泡排序对 list 排序。
默认按升序排序，即从小到大排序。
冒泡排序思路：首先，列表每两个相邻的数，如果前边的数比后边的数大，那么交换这两个数，第一次遍历完后，最大的这个数就在列表的末尾，接着第二次遍历，指针回到列表起始处，继续比较两个相邻的数，如果前边比后边大的，就交换这两个数，以此类推。
1 def bubble_sort(sequence):
2 length = len(sequence)
3 for i in range(length):
4 is_sorted = True # 如果内层循环已经是从小到大的顺序，可通过判断这个变量来结束循环
5 for j in range(length - i - 1): # 减 1 是避免遍历到最后一个元素
6 if sequence[j] > sequence[j + 1]:
7 sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
8 is_sorted = False
9 if is_sorted: return # 如果内层循环已排序完成，就结束外层循环
10
11 seq = [100, 31, -50, 1, 3, 28, -11, 85]
12 bubble_sort(seq)
13 print(seq) # 输出：[-50, -11, 1, 3, 28, 31, 85, 100]
3、定义一个 is_leap(year) 函数，判断 year 是否为闰年。若是闰年则返回 True; 否则返回 False.
闰年分为普通闰年和世纪闰年。普通闰年是指公历年份是4的倍数，例如2016年就是闰年。世纪闰年是指公历年份是整百数，必须是400的倍数才是闰年，例如1900年不是世纪闰年，2000是世纪闰年。
1 def is_year(year):
2 year = int(year)
3 # 过滤整百数年份，判断普通闰年
4 if (year % 4 == 0) and (year % 100 != 0):
5 return True
6 # 判断世纪闰年
7 elif year % 400 == 0:
8 return True
9 else:
10 return False
11
12 while True:
13 year = input("请输入年份：")
14 if year == 'q' or year == 'exit':
15 exit(0)
16 else:
17 print("%s是否是闰年？%s" % (year, is_year(year)))
4、 定义一个 count_str_char(my_str) 函数，该函数返回参数字符串中包含多少个数字、多少个英文字母、多少个空白字符、多少个其它字符。
1 def count_str_char(my_str):
2 char_num, digit_num, space_num, other_num = 0, 0, 0, 0
3 for s in my_str:
4 if s.isdigit(): digit_num += 1
5 elif s.isalpha(): char_num += 1
6 elif s.isspace(): space_num += 1
7 else: other_num += 1
8 return char_num, digit_num, space_num, other_num
9
10 while True:
11 my_str = input("请输入一个字符串：")
12 if my_str == 'q':
13 exit()
14 char_num, digit_num, space_num, other_num = count_str_char(my_str)
15 print("字符个数是：", char_num)
16 print("数字个数是：", digit_num)
17 print("空白个数是：", space_num)
18 print("其它字符个数是：", other_num)
19 print("-" * 30)
5、定义一个函数fn1(n)，该函数返回 1到n 的立方和，即求：1+2*2*2+3*3*3+...+n*n*n
1 def fn1(n):
2 if n < 2:
3 exit()
4 result = 1
5 for i in range(2, n + 1):
6 result += i * i * i
7 return result
8 n = int(input("请输入一个数字："))
9 sum = fn1(n)
10 print("1~%d的立方和是：%s" % (n, sum))
6、定义一个fn2(n) 函数，该函数返回 n 的阶乘。
1 def fn2(n):
2 if n < 2:
3 return 1
4 result = 1
5 for i in range(2, n + 1):
6 result *= i
7 return result
8
9 def fn3(n):
10 """用递归函数来实现阶乘"""
11 if n <= 1:
12 return 1
13 else:
14 return fn3(n - 1) * n
15
16 def fn4(n):
17 """用列表的方式计算阶乘"""
18 if n <= 1:
19 return 1
20 my_list = [1]
21 for _ in range(n):
22 my_list.append(my_list[-1] * len(my_list))
23 return my_list[-1]
24
25 n = int(input("请输入一个整数："))
26 print("%d的阶乘是：%d" % (n, fn4(n)))
7、定义一个函数，接收一个列表作为参数，函数用于去除列表中的重复元素。
1 def no_repeat(sequence):
2 my_list = []
3 for s in sequence:
4 if s not in my_list:
5 my_list.append(s)
6 return my_list
7
8 def no_repeat_2rd(sequence):
9 """利用字典的 fromkeys 方法，将列表的元素转换为字典的键，
10 因字典的键不能重复，通过获取字典的键列表，就是去重后的列表"""
11 my_list = list({}.fromkeys(sequence).keys())
12 return my_list
13
14 seq = ['a', 'java', 'c', 'python', 'c', 'stark', 'michael', 'c', 'a', 'python']
15 print(no_repeat_2rd(seq))
16
17 输出：
18 ['a', 'java', 'c', 'python', 'stark', 'michael']
8、定义一个函数 fn5(n) ,用于返回一个包含 n 个不重复的 0~100 之间整数的元组。
注意：输入的整数大于100时，程序会陷入死循环。
1 import random
2
3 def fn5(n):
4 i, my_list =0, []
5 while True:
6 temp_num = random.randint(0, 100)
7 if temp_num not in my_list:
8 my_list.append(temp_num)
9 i += 1
10 if i == n:
11 break # 结束循环
12 return tuple(my_list)
13
14 n = int(input("请输入一个整数："))
15 my_tuple = fn5(n)
16 print("元组元素个数是：%d" % len(my_tuple))
17 print(my_tuple)
9、定义一个函数 fn6(n)，该函数返回一个包含 n 个不重复的大写字母的元组。
1 import random
2 def fn6(n):
3 i, my_list =0, []
4 while True:
5 num = random.randint(65, 90)
6 s = chr(num)
7 if s not in my_list:
8 my_list.append(s)
9 i += 1
10 if i == n:
11 break
12 return tuple(my_list)
13
14 n = int(input("请输入一个整数："))
15 print(fn6(n))
10、定义一个函数 fn7(n)，参数 n 表示一个 n 行 n 列的矩阵。在输出时，先输出 n 行 n 列的矩阵，再输出该矩阵的转置形式。例如参数是3时，先输出
1 2 3
4 5 6
7 8 9
再输出：
1 4 7
2 5 8
3 6 9
1 def fn7(n):
2 # 输出矩阵
3 for i in range(n):
4 for j in range(n):
5 print(" %2d " % (1 + j + i * n), end="")
6 print()
7 print("-" * (4 * n))
8
9 # 输出转置矩阵
10 for i in range(n):
11 for j in range(n):
12 print(" %2d " % (1 + i + j * n), end="")
13 print()
14 n = int(input("请输入整数："))
15 fn7(n)