函数的返回值
1）什么是返回值 - 返回就是从函数内容传递到函数外部的数据(Python中的每个函数都可以传递一个数据到函数的外部)
2）怎么确定一个函数的返回值(怎么在函数的内容将数据传递到函数的外部)
return后面的值就是函数的返回值(执行函数体的是如果遇到return，return后面的值就是函数的返回值)
3）怎么在函数外部获取函数返回值
获取函数调用表达式的值就是获取这个函数的返回值
函数调用表达式 - 调用函数的语句
4）什么时候使用返回值：
如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回
1）return确定返回值
return后面放需要返回的数据
def func1(a, b):
# a = 10, b = 20
result = a + b # 30
return result # return 30
一个函数只有一个返回值(一个函数最多只能有一个return有效)；如果想要把多个数据作为函数的返回值返回，可以在一个return后面写多个数据
def func2(a, b):
result1 = a + b
result2 = a * b
return result1, result2
return除了可以返回数据，还会提前结束函数(执行函数体的时候如果遇到return，函数直接结束)
def func3():
print('++++++')
print('------')
return # 相当于 return None
print('======')
def func4(str1: str):
# str1 = 'hsMNsh啥时间A看N'
new_str = ''
for x in str1:
if x.isupper():
new_str += x
return new_str # 'MNAN'
2） 获取函数的返回值
函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数调用表达式都可以做
print(30)
print(func1(10, 20))
num1 = 30
num2 = func1(10, 20)
print(num1, num2)
print(30 * 2, func1(10, 20) * 2)
print(func4('hsMNsh啥时间A看N'))
#
for x in func4('hsMNsh啥时间A看N'):
print(f'x:{x}')
print(func4('hsMNsh啥时间A看N').lower())
result = func4('hsMNsh啥时间A看N')
print(result)
result = func2(10, 20)
print(result)
#变量1, 变量2, ... = 元组
s1, s2 = func2(10, 20)
print(s1, s2)
-
变量作用域 - 变量在定义完成后可以使用的范围
根据变量作用域的不同，可以将变量分为全局变量和局部变量两种 -
全局变量和局部变量
1)全局变量
没有定义在函数里面或者类里面的变量都是全局变量。
作用域：从定义开始，到程序结束。（程序结束前的任何位置都可以使用）
1. print('------------------------------------案例1：-----------------------------------')
#a是全局变量
a = 10
print(f'外面的a:{a}')
for x in range(5):
print(f'循环里面a:{a}')
def func1():
print(f'函数中a：{a}')
func1()
print('------------------------------------案例2：-----------------------------------')
#x和b是全局变量
for x in range(5):
b = 20
print(f'外面x和b:{x}, {b}')
def func2():
print(f'函数里面x和b:{x}, {b}')
func2()
局部变量
定义在函数中的变量就是局部变量（形参也是局部变量；定义在类中的变量是属性）
作用域：从定义开始到函数结束
#c和d是局部变量
def func3(c):
d = 30
print(f'函数里面c和d:{c}, {d}')
func3(40)
print(f'函数外面:{c},{d}') # 报错！函数外面不能使用函数中定义的局部变量
- 不同变量的存储方式
全局变量默认保存在全局栈区间(程序结束的时候才会被释放)，
局部变量默认是保存在函数对应的临时栈区间中(函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放)。
在函数中定义变量的时候，可以在定义变量前加global关键字，让函数中定义变量可以保存在全局栈区间中。
x = 100 # 保存全局栈区间
def func4():
y = 200 # 保存在func4对应的临时栈区间
global z
z = 300 # 保存在全局栈区间中
func4()
print(f'外面z:{z}')
print('------------------------------------华丽的分割线-----------------------------------')
如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明
name = '小明' # name是全局变量，保存在全局栈区间
def change_name():
# name = '小花' # 重新创建一个局部变量name，保存在change_name对应的临时栈区间中
# print(f'函数里面name：{name}')
global name
name = '小花'
print(f'函数里面name：{name}')
change_name()
print(f'外面name：{name}')
-
调用函数的时候，实参到底应该给什么样的数据，由什么东西决定？
由参数在函数体中的使用方式决定 -
实参高阶函数 - 函数的参数是函数
如果一个参数是函数，传参的时候有两种方法：1）用普通函数的函数名 2）使用匿名函数
def func1(x):
print(x)
func1(10)
func1('abc')
func1([10, 20])
def func2(x):
print(x + 10)
func2(10)
func2(2.34)
def func3(x):
print(x * 2)
func3(10)
func3('abc')
func3([10, 20])
func3((10, 23))
def func4(x):
print(x[-1])
func4('abc')
func4([10, 20, 30])
func4({'a': 10, -1: 20})
def func5(x):
x.append(100)
print(x)
func5([10, 23])
func6这个函数的参数要求是函数， 这个func6就是一个实参高阶函数
def func6(x):
x = temp
x() # temp()
def temp():
print('临时函数')
func6(temp)
x必须是函数，有一个参数，返回值必须是数字
def func7(x):
# x = temp2
print(x(10) + 20) # print(temp2(10) + 20) -> print(19 + 20)
def temp2(m):
# m = 10
return 19
func7(temp2)
匿名函数
匿名函数的本质还是函数，但是它只能实现简单的功能(一行语句就能实现它的功能)
语法：
函数名 = lambda 形参列表:返回值
相当于：
def 函数名(形参列表):
return 返回值
#示例1：定义一个函数求两个数的和
sum2 = lambda num1, num2: num1+num2
print(sum2(10, 20)) # 30
print(sum2(num1=100, num2=200)) # 300
2.匿名函数的应用：
在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)
max、min、sorted
1）max(序列) - 直接比较序列中元素本身的大小，求出最大值
2）max(序列,key=函数) - 按照函数制定的比较规则比较元素的大小，求出最大值
函数的要求：a.有且只有一个参数（这个参数代表序列中的每个元素）
b.需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）
#示例1：求nums中值最大的元素
nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item)
print(result)
#示例2：求nums中个位数最大的元素
nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item % 10)
print(result)
#示例3：求students中年龄最大的学生
students = [
{'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
{'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
{'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
{'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
{'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
result = max(students, key=lambda item: item['age'])
print(result)
练习1：求nums中十位数最大的元素: 90
nums = [9108, 23, 167, 90, 556, 149]
result = max(nums, key=lambda item: item // 10 % 10)
print(result)
#练习2：求nums中绝对值最小的元素
abs(数据) - 返回指定数据的绝对值
nums = [-992, 12, 78, -34, 99]
#方法一：
result = min(nums, key=lambda item: abs(item))
print(result)
#方法二：
result = min(nums, key=lambda item: item ** 2)
print(result)
#练习3：nums中各个位数之和最大的元素
nums = [102, 19, 48, 221, 52]
3,10,12,5,7 -> 48
102 -> '102' -> '1'、'0'、'2'
#方法一：
result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(result)
#方法二：
def temp(item):
sum1 = 0
for x in str(item):
sum1 += int(x)
return sum1
result = max(nums, key=temp)
print(result)
#练习4：将students中的元素按照分数从高到低排序
#方法一
result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)
#方法二
students.sort(key=lambda item: item['score'], reverse=True)
print(students)
map - 基于原序列中的元素创建一个新的序列
1)map(函数, 序列) - 根据函数制定规则，将指定序列中的元素转换成新序列中的元素
函数的要求:a.有且只有1个参数（代表后面序列中的元素）
b.有返回值（返回对应的就是新序列中的元素）
2)map(函数, 序列1, 序列2)
函数的要求:a.有且只有个2参数(分别代码后面两个序列中的元素)
b.有返回值（返回对应的就是新序列中的元素）
3)map(函数, 序列1, 序列2, 序列3,…)
#示例1：创建一个列表，列表中的元素是nums中所有元素的个位数
nums = [82, 67, 89, 6617, 90, 23, 71]
[2, 7, 9, 7, 0, 3, 1]
result = map(lambda item: item % 10, nums)
print(list(result))
#示例2：将A和B中的元素对应求和产生一个新的列表
A = [3000, 5600, 9800, 4200, 10000]
B = [1500, 1000, 2200, 1300, 3200]
[4500, 6600, 12000, 5500, 13200]
result = map(lambda i1, i2: i1 + i2, A, B)
print(list(result))
#练习1：将nums中所有的元素乘以10
nums = [82, 67, 89, 6617, 90, 23, 71]
result = map(lambda item: item * 10, nums)
print(list(result))
#练习2：基于scores创建一个列表，列表中元素根据nums中元素确定为'及格'或者'不及格'
scores = [82, 67, 89, 66, 90, 23, 71]
['及格', '及格', '及格', '及格', '不及格', '及格']
result = map(lambda item: '不及格' if item < 60 else '及格', scores)
print(list(result))
#练习3：基于names、ages和scores，创建学生列表：
names = ['stu1', 'stu2', 'stu3', 'stu4']
ages = [23, 34, 19, 22]
scores = [82, 67, 89, 66]
[{'name': 'stu1', 'age': 23, 'score': 82}, .....]
result = map(lambda i1, i2, i3: {'name': i1, 'age': i2, 'score': i3}, names, ages, scores)
print(list(result))
reduce - 将序列中所有的元素通过指定的规则合并成一个数据
reduce(函数, 序列, 默认值)
函数的要求：a.有且只有两个参数(第一个参数指向默认值，第二个参数指向序列中的每个元素)
b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么样的操作得到的）
注意：reduce使用之前要先导入
from functools import reduce
#示例1: 求nums中所有元素的和
nums = [10, 20, 30, 40]
0 + 10 + 20 + 30 + 40
result = reduce(lambda i, item: i + item, nums, 0)
print(result)
#示例2：求nums中所有元素的乘积
nums = [10, 20, 30, 40]
1 * 10 * 20 * 30 * 40
result = reduce(lambda i, item: i * item, nums, 1)
print(result)
#示例3：求所有元素个位数的和
nums = [23, 78, 92, 78, 12]
0 + 3 + 8 + 2 + 8 + 2 -> 0 + 23%10 + 78 % 10 + 92 % 10 + 78 % 10 + 12 % 10
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)
#示例4：将所有元素合并成一个字符串：'2378927812'
nums = [23, 78, 92, 78, 12]
'' + '23' + '78' + '92' + '78' + '12' -> '' + str(23) + ...
result = reduce(lambda i, item: i + str(item), nums, '')
print(result)
#示例5：求所有学生的总分
students = [
{'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
{'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
{'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
{'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
{'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]# 0 + 89 + 99 + 75 +... -> 0 + {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'}['score'] + ...
result = reduce(lambda i, item: i + item['score'], students, 0)
371
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
