函数进阶

函数返回值

1.函数的返回值

1)什么是返回值：

返回值就是从函数内部传递到函数外部的数据(python中的每个函数都可以传递一个数据到函数的外部)

# return后面放需要返回的数据
def func1(a, b):
    result = a + b   # 30
    return result   # return 30


func1(10, 20)
1
2
3
4
5
6
7

一个函数只有一个返回值(一个函数最多只有一个return有效)，如果想要吧多个数据作为函数的返回值返回，可以在一个return后面写多个数据，用逗号隔开。
return除了可以返回数据，还会提前结束函数(执行函数体的时候如果遇到return，函数直接结束)

def func3():
    print('++++++')
    print('------')
    return    # 相当于return None;函数结束，下面的程序不会执行
    print('======')


func3()
1
2
3
4
5
6
7
8

2)怎么确定一个函数的返回值(怎么在函数的内部将数据传递到函数的外部)：
return后面的值就是函数的返回值(执行函数体的时候如果遇到return，return后面的值就是函数的返回值)
获取函数的返回值:函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数调用表达式都可以做。

func1(10, 20)   # 结果就是返回值；return 30，返回值就是30，结果就是30
num1 = 30
num2 = func1(10, 20)
print(num1, num2)   # 30 30
print(30 * 2, func1(10, 20) * 2)   # 60 60
1
2
3
4
5

3)怎么在函数外部获取函数返回值： 获取函数调用表达式的值就是获取这个函数的返回值。
函数调用表达式 - 调用函数的语句；每个函数调用表达式都有结果，结果就是这个函数的返回值。
4)什么时候使用返回值：
如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回

变量作用域

1.变量作用域 - 变量在定义完成后可以使用的范围

根据变量作用域的不同，可以将变量分为全局变量和局部变量两种

2.全局变量和局部变量

1)全局变量
没有定义在函数里面或者类里面的变量都是全局变量
作用域：从定义开始，到程序结束。(程序结束前的任何位置都可以使用)。

# x和b是全局变量
for x in range(5):
    b = 20

print(f'外面x和b:{x}, {b}')


def func2():
    print(f'函数里面x和b:{x}, {b}')


func2()
1
2
3
4
5
6
7
8
9
10
11
12

2)局部变量
定义在函数中的变量就是局部变量(定义在类中的变量是属性)
作用域：从定义开始到函数结束。

# c和d是局部变量
def func3(c):
    d = 30
    print(f'函数里面c和d:{c}, {d}')


func3(40)
# print(f'函数里面c和d:{c}, {d}')    # 报错！函数外面不能使用函数中定义的局部变量
1
2
3
4
5
6
7
8

3.不同变量的存储方式

全局变量默认保存在全局栈区间(程序结束的时候才会被释放);局部变量默认是保存在函数对应的临时栈区间中(函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放)。
在函数中定义变量的时候，可以在定义变量前加global关键字，让函数中定义变量可以保存在全局栈区间中。

x = 100   # 保存在全局栈区间


def func4():
    y = 200    # 保存在func4对应的临时栈区间

    global z
    z = 300    # 保存在全局栈区间中


func4()
print(f'外面z:{z}')    # 外面z:300
1
2
3
4
5
6
7
8
9
10
11
12

如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明。

name = '小明'    # name是全局变量，保存在全局栈区间中


def change_name():
    # name = '小花'    # 重新创建一个局部变量name，保存在change_name对应的临时栈区间中
    # print(f'函数里面name:{name}')
    global name
    name = '小花'
    print(f'函数里面name:{name}')   # 函数里面name:小花


change_name()

print(f'外面name:{name}')   # 外面name:小花
1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数参数的确定

1.调用函数的时候，实参到底应该给什么样的数据，由什么东西决定？

由参数在函数体中的使用方式决定

2.实参高阶函数 - 函数的参数是函数

如果一个参数是函数，传参的时候有两种方法：1)用普通函数的函数名 2)使用匿名函数。

def func1(x):
    print(x)


func1(10)    # 10
func1('abc')    # abc
func1([10, 20])    # [10, 20]


def func2(x):
    print(x + 10)


func2(10)   # 20
func2(2.34)   # 12.34

def func4(x):
    print(x[-1])


func4('abc')   # c
func4([10, 20, 30])   # 30
func4({'a': 10, -1: 20})   # 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# func6这个函数的参数要求是函数，这个func6就是一个实参高阶函数
def func6(x):
    x()      # temp()


def temp():
    print('临时函数')


func6(temp)    # 临时函数

# x必须是函数，有一个参数，返回值必须是数字
def func7(x):
    print(x(10) + 20)   # print(19 + 20)


def temp2(m):
    return 19


func7(temp2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

匿名函数

1.匿名函数

匿名函数的本质还是函数，只能实现简单的功能(一行语句就能实现它的功能)
语法：
函数名 = lambda 形参列表:返回值
相当于：
def 函数名(形参列表):
(缩进)return 返回值
示例1：定义一个函数求两个数的和

sum2 = lambda num1, num2: num1 + num2

print(sum2(30, 23))    # 53
print(sum2(num1=200, num2=300))    # 500
1
2
3
4

2.匿名函数的应用

在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)

def func1(x):
    print(x(10, 20) + 10)

# x是一个函数；有两个参数；有一个数字对应的返回值
def temp1(m, n):
    return 12.3


func1(temp1)
func1(lambda m, n: 12)
1
2
3
4
5
6
7
8
9
10

常用的实参高阶函数

1.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)   # 90
1
2
3

示例2：求nums中个位数最大的元素

nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item % 10)
print(result)   # 49
1
2
3

示例3：求students中年龄最大的学生

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小罗', 'age': 25, 'score': 59, 'gender': '男'},
    {'name': '小潘', 'age': 17, 'score': 100, 'gender': '女'},
    {'name': '小黄', 'age': 23, 'score': 84, 'gender': '女'}
]
result = max(students, key=lambda item: item['age'])
print(result)    # {'name': '小罗', 'age': 25, 'score': 59, 'gender': '男'}
1
2
3
4
5
6
7
8
9

2.map - 基于原序列中的元素创建一个新的序列

1)map(函数,序列) - 根据函数制定的规则，将指定序列中的元素转换成新序列中的元素。
函数的要求：a.有且只有一个参数(代表后面序列中的元素)；b.有返回值(返回对应的就是新序列中的元素)
2)map(函数,序列1,序列2)
函数的要求：a.有且只有二个参数(分别代表后面两个序列中的元素)；b.有返回值(返回对应的就是新序列中的元素)
3)map(函数,序列1,序列2,…) - 同上
示例1：创建一个列表，列表中的元素是nums中所有元素的个位数

nums = [82, 67, 89, 6617, 90, 23, 71]
result = map(lambda item: item % 10, nums)
print(list(result))
1
2
3

示例2：将A和B中的元素对应求和，产生一个新的列表

A = [3000, 5600, 9800, 4200, 10000]
B = [1500, 1000, 2200, 1300, 3200]
result = map(lambda a, b: a + b, A, B)
print(list(result))
1
2
3
4

3.reduce - 将序列中所有的元素通过指定的规则合并成一个序列

reduce(函数,序列,默认值)
函数的要求：a.有且只有两个参数(第一个参数指向默认值，第二个参数指向序列中的每个元素);b.需要一个返回值(描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么样的操作得到的)
注意：reduce使用之前要先导入

from functools import reduce
1

示例1: 求nums中所有元素的和(求和的默认值和初始值一般为0)

nums = [10, 20, 30, 40]
# 0 + 10 + 20 + 30 + 40
result = reduce(lambda i, item: i + item, nums, 0)
print(result)
1
2
3
4

示例2：求nums中所有元素的乘积(求乘积的默认值和初始值一般为1)

nums = [10, 20, 30, 40]
# 1 * 10 * 20 * 30 * 40
result = reduce(lambda i, item: i * item, nums, 1)
print(result)
1
2
3
4

示例3：求所有元素个位数的和(求和的默认值和初始值一般为0)

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)
1
2
3
4

示例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)
1
2
3

示例5：求所有学生的总分(求和的默认值和初始值一般为0)

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)
print(result)
1
2
3
4
5
6
7
8
9
10