1. 匿名函数
1.1 匿名函数
没有名字的函数。
'''
语法：
函数名 = lambda 形参列表：返回值
相当于
def 函数名(形参列表)：
return 返回值
'''
1.2 注意
1）匿名函数的本质还是函数；
2）普通函数中的绝大部分内容匿名函数都支持
1.3 练习
练习1：求任意两个数据的和。
# 普通函数
def sum1(num1: int, num2= 2):
return num1 + num2
# 匿名函数
x = lambda num1,num2= 2: num1 + num2
print(x(10,30)) # 40
print(x(num1=12,num2=33))
print(x(100))
练习2：一个匿名函数判断指定的年是否是闰年。
is_leap_year = lambda year: (year % 4 ==0 and year % 100 != 0) or year % 400 ==0
print(is_leap_year(2022)) # False
练习3：求个位数最大的元素。
# 求最大的元素
nums = [12,39,18,80,34]
print(max(nums))
# 求个位数最大的元素
nums = [12,39,18,80,34]
def func1(x):
return x % 10
print(max(nums, key=func1))
print(max(nums, key=lambda x: x % 10))
练习4：求绝对值最大的元素。
nums = [12,39,-18,-80,34]
print(max(nums, key=lambda x: x**2))
print(max(nums, key=lambda x: -x if x < 0 else x))
2. 变量作用域
2.1 变量作用域
变量作用域即变量使用范围；
根据变量作用域不同，可以将变量分为两种：全局变量、局部变量。
2.2 全局变量
1）定义在函数或者类外面的变量就是全局变量（没有定义在函数里面和类里面的变量就是全局变量）；
2）全局变量的作用域：从定义开始到程序结束。
# a是全局变量
a = 10
print('外面a:',a)
# b是全局变量
for b in range(3):
# c是全局变量
c = 20
print('循环里面a：',a)
print('循环里面b：',b)
print('外面b：',b)
print('外面c：',c)
def func1():
print('函数里面a：',a)
print('函数里面b：',b)
func1()
2.3 局部变量
1）定义在函数里面的变量就是局部变量。（形参也是局部变量）；
2）局部变量的作用域：从定义开始到函数结束。
# d、e、f都是局部变量
def func1(d,e):
f = 100
print('函数里面：',d,e,f)
func1(2,5)
# print('函数外面：',d,e,f) # 报错！
2.4 global关键字
1）变量能不能使用，看的是使用的时候内存中有没有。
2）定义全局变量的时候，全局变量保存在全局栈区间中，程序结束之后才会被自动释放；
局部变量是保存在函数对应的临时栈区间中，函数调用结束就会被自动释放。
3）global是函数体中的关键字，可以在函数体中修饰变量，让变量在使用和保存的时候都在全局栈中进行。
aa = 100
bb = 100
def func2():
# 不会修改全局变量aa的值，而是创建一个局部变量aa
aa = 200
print('里面aa：',aa) # 在函数里面使用的是局部变量aa的值
# print(bb) # 报错！global修饰变量必须放在这个变量使用之前
global bb
bb = 200
print('里面bb：',bb)
global cc
cc = 300
func2()
print('外面aa：',aa) # 在函数外面使用的是全局变量aa的值
print('外面bb：',bb)
print('外面cc：',cc)
3. 高阶函数
3.1 函数就是变量
1）python中定义函数其实就是在定义一个类型是function的变量，函数名就是变量。
2）变量能做的事情函数都可以做。
def sum2(num1,num2):
return num1 + num2
# sum2 = lambda num1,num2: num1 + num2
b = [10,20]
print(type(b),type(sum2))
print(b[0],sum2(1,3))
c = b
d = sum2
print(c[0],d(1,3))
list1 = [10,b,sum2]
print(list1[1]) # [10, 20]
print(list1[1][-1]) # 20
print(list1[-1](10,20)) # 30
3.2 高阶函数
3.2.1 实参高阶函数
实参阶函数：函数的参数是函数。
# 应该怎么来确定函数的参数是什么？
def func1(x):
print(x(10,20)[-1])
def temp(a,b):
return 'abc'
func1(temp) # c
3.2.2 返回值高阶函数
返回值高阶函数：函数的返回值是函数。
def func2():
def temp(x):
return 23
return temp
4. 常用的实参高阶函数
4.1 max
max、min、sorted、sort - 参数key要求是一个函数。
'''
max(序列,key=函数) - 按照函数制定的比较规则来获取序列中最大的元素
函数的要求：1）参数 - 有且只有一个参数；这个参数代表前面序列中的每个元素
2）返回值 - 有一个返回值；返回值就是比较对象
注意：如果一个函数的参数是函数，这个参数有两种传值方式：a.普通函数的命名 b.匿名函数
'''
4.1.1 练习
练习1：求元素最大值。
nums = [10,88,39,-748,44,23]
print(max(nums)) # 88
练习2：求元素最大值。
nums = [10,88,39,-748,44,23]
result = max(nums,key=lambda item: item)
print(result) # 88
练习3：求个位数元素最大值。
nums = [10,88,39,-748,44,23]
result = max(nums,key=lambda item: item % 10)
print(result) # 39
练习4：求绝对值最小的元素。
result = min(nums,key=lambda item: item ** 2)
print(result) # 10
练习5：求nums中数值最大的元素:‘1998’。
nums = ['235','-290','71','1998','80']
result = max(nums,key=lambda item: eval(item) ** 2)
print(result)
练习6：将nums中的元素按照十位数的大小从小到大排序。
# nums = [913, 281, 1765, 92, 802]
# [802, 913, 1765, 281, 92]
nums = [913, 281, 1765, 92, 802]
result = sorted(nums,key=lambda item: item //10 % 10)
print(result)
练习7：获取nums中各个位数之和最小的元素。
nums = [1002, 908, 99, 76, 502]
# [3, 17, 18, 13, 7] -> 1002
# 方法1：
def sums(num:int):
s = 0
for x in str(num):
s += int(x)
return s
result = min(nums,key=sums)
print(result)
# 方法2：
# 1002 -> '1+0+0+2' -> '+'.join('1002') -> '1+0+0+2'
result = min(nums,key=lambda item: eval('+'.join(str(item))))
print(result)
4.2 map
'''
1）map(函数,序列) - 按照函数制定的规则将原序列转换成新的序列,返回值是map对象
函数要求：a.参数：有且只有1个参数；参数代表后面的这个序列中的元素
b.返回值：有一个返回值；新序列中的元素
2）map(函数,序列1,序列2)
函数要求：a.参数：有且只有2个参数；参数代表后面两个序列中的元素
b.返回值：有一个返回值；新序列中的元素
map(函数,序列1,序列2,序列3)
函数要求：a.参数：有且只有3个参数；参数代表后面三个序列中的元素
b.返回值：有一个返回值；新序列中的元素
map(函数,序列1,序列2,序列3,...)
'''
练习：获取nums中所有元素的个位数。
# [8,9,7,6,2,1]
nums = [128,239,87,96,102,91]
result = list(map(lambda item: item % 10,nums))
print(result) # [8, 9, 7, 6, 2, 1]
str1 = 'abcde'
nums = [10,20,30,40,50]
# ->['a10','b20','c30','d40','e50']
result = list(map(lambda i1,i2: i1 + str(i2),str1,nums))
print(result)
4.3 reduce
# 注意：reduce在使用之前必须先导入
from functools import reduce
'''
reduce(函数，序列,初始值) - 按照函数制定的规则将序列中所有的元素合并成一个数据
函数的要求：1）参数：有且只有2个参数，第一个参数指向初始值，第二个参数代表序列中的每个元素
2）返回值：有一个返回值；描述初始值和元素之间的合并方式
'''
nums = [10,30,20] # 所有元素的和：60
# 0 + 10 + 30 + 20 -> i + item
result = reduce(lambda i,item: i + item,nums,0)
print(result) # 60
nums = [12,34,91] # 所有元素个位数的和：7
# 0 + 2 + 4 + 1 -> 0 + 12%10 + 34%10 + 91%10 -> i + item%10
result = reduce(lambda i,item: i + item % 10,nums,0)
print(result) # 7
nums = [10,40,20] # 所有元素的乘积：8000
# 1 * 10 * 40 * 20 -> i * item
result = reduce(lambda i,item: i * item,nums,1)
print(result) # 8000
nums = [10,40,20] # '104020'
# '' + '10' + '40' + '20' -> '' + str(10) + str(40) + str(20) -> '' + str(item)
result = reduce(lambda i,item: i + str(item),nums,'')
print(result) # '104020'
4.3.1 练习
练习1：求所有数字的和。
list1 = [10,'abc','2.4','hans',5.5,3] # 18.5
# 方法1：
# [10,5.5,3]
result = reduce(lambda i,item: i + item,[x for x in list1 if type(x) in (int,float)],0)
print(result)
# 方法2：
# 0 + 10 + 5.5 + 3 -> 0 + 10 + 0 + 0 + 0 + 5.5 + 3 -> i + item / i + 0
list1 = [10,'abc','2.4','hans',5.5,3] # 18.5
result = reduce(lambda i,item: i + item if type(item) in (int,float) else i + 0,list1,0)
print(result
练习2：将所有偶数的十位数和奇数的个位数求和。
nums = [23, 54, 801, 132, 92] # 3+5+1+3+9
# i + item%10、i + item // 10 % 10
result = reduce(lambda i,item: i + item % 10 if item % 2 else i + item // 10 % 10,nums,0)
print(result)
def temp(i,item):
if item % 2:
return i +item % 10
return i + item // 10 % 10
result = reduce(temp,nums,0)
print(result)
5. 作业
-
写一个匿名函数，判断指定的年是否是闰年
is_leap_year = lambda year: (year % 4 ==0 and year % 100 != 0) or year % 400 ==0 print(is_leap_year(2022)) # False -
写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)
def reverse(list1): new_list1 = [] for x in list1: new_list1.insert(0,x) return new_list1 print(reverse([1,2,3])) -
编写一个函数，计算一个整数的各位数的平方和
例如: sum1(12) -> 5（1的平方加上2的平方） sum1(123) -> 14
def sum1(num1):
s = 0
for x in str(num1):
s += int(x) ** 2
return s
print(sum1(123))
- 求列表 nums 中绝对值最小的元素
例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-23
nums = [-23, 100, 89, -56, -234, 123]
result = min(nums,key=lambda item: item ** 2)
print(result)
- 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
新字典: {'name': '张三', 'age': 18, 'sex': '女'}
key = ['name', 'age', 'sex']
value = ['张三', 18, '女']
result = dict(map(lambda key,value: {key,value},key,value))
print(result)
- 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
name = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
result = dict(map(lambda name,subjects,nums: {name,subjects+nums},name,subjects,nums))
print(result)
- 已经一个列表message, 使用reduce计算列表中所有数字的和
message = ['你好', 20, '30', 5, 6.89, 'hello']
结果：31.89
from functools import reduce
message = ['你好', 20, '30', 5, 6.89, 'hello']
result = reduce(lambda i,item: i + item if type(item) in (int,float) else i + 0 ,message,0)
print(result)
- 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）
points = [
(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]
1）获取列表中y坐标最大的点
result = max(points,key=lambda item: list(item)[-1])
print(result)
2）获取列表中x坐标最小的点
result = min(points,key=lambda item: list(item)[0])
print(result)
3）获取列表中距离原点最远的点
result = max(points,key=lambda item: list(item)[0] ** 2 + list(item)[1] ** 2)
print(result) # (30, -100)
4）将点按照点到x轴的距离大小从大到小排序
result = sorted(points,key=lambda item: list(item)[0] ** 2 ,reverse=True)
print(result) # (30, -100)
