从零学习Python：函数进阶

一、函数的返回值

（一）什么是返回值

返回就是从函数内容传递到函数外部的数据。

（二）怎么确定一个函数的返回值(怎么在函数的内容将数据传递到函数的外部)

return后面的值就是函数的返回值

执行函数体时如果遇到return，return后面的值就是函数的返回值

（三）怎么在函数外部获取函数返回值

获取函数调用表达式的值就是获取这个函数的返回值。

一个函数只有一个返回值

函数调用表达式 ： 调用函数的语句。

（四）什么时候使用返回值

如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回

1. return确定返回值

return后面放需要返回的数据

一个函数最多只能有一个return有效

如果想把多个数据作为函数的返回值返回，可以在一个return后面写多个数据

案例：

def func1(a, b):
    result = a + b  # 10+20
    result1 = a * b  # 10*20
    return result, result1  # 30,200


func1(10, 20)
print(func1(10, 30))

return除了可以返回数据，还会提前结束函数（执行函数体的时候如果遇到return，函数直接结束）

def fun2():
    print('++++')
    print('----')
    return None
    print('====')


fun2()

2.获取函数的返回值

函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数调用表达式都可以做

二、变量作用域

变量在定义完成后可以使用的范围

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

（一）全局变量

没有定义在函数里面或者类里面的变量都是全局变量。

作用域：从定义开始，到程序结束。（程序结束前的任何位置都可以使用）

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

全局变量默认保存在全局栈区间（程序结束的时候才会被释放）

（二）局部变量

定义在函数中的变量就是局部变量

形参也是局部变量，定义在类中的变量是属性

作用域：从定义开始到函数结束

def func3(c):
    d = 30
    print(f'函数里面c和d:{c},{d}')

# c和d是局部变量
func3(40)

# print(f'函数外面：{c},{d}')   # 报错！函数外面不能使用函数中定义的局部变量

局部变量默认是保存在函数对应的临时栈区间中

函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放

三、函数参数的确定

1）调用函数的时候，实参到底应该给什么样的数据，由参数在函数体中的使用方式决定。

2）实参高阶函数

​ 函数的参数是函数，如果一个参数是函数，传参的时候有两种方法：

1. 用普通函数的函数名
2. 使用匿名函数

普通函数示例1：

def func1(x):
    print(x)


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

普通函数示例2：（func6就是一个实参高阶函数）

def func6(x):
    # x = temp
    x()     # temp()


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


func6(temp)

四、匿名函数

匿名函数的本质还是函数，但是它只能实现简单的功能（一行语句就能实现它的功能）

'''
语法：
函数名 = lambda 形参列表：返回值

相当于：            
def 函数名（形参列表）:  
    return 返回值  
'''

示例：

定义一个函数求两个数的和

sum2 = lambda num1, num2: num1 + num2

print(sum2(10, 20))		# 30
print(sum2(num1=20, num2=30))	# 50

（一）匿名函数的应用

在给实参高阶函数传参的时候，可以使用普通函数名，也可以使用匿名函数

能用匿名函数就使用匿名函数，不行才用普通函数

案例：

def func1(x):
    print(x(10, 20) + 10)
    
#  x是一个函数；有两个参数，有一个数字对应的返回值 
def temp1(m, n):            
    return 12.3             
                            
                            
func1(temp1)            # 22.3    
func1(lambda m, n: 12)      # 12+10=22

五、常见实参高阶函数

（一）max、min、sorted

1) max(序列)

直接比较序列中元素的大小，求出最大值

2) max(序列，key = 函数)

按照函数制定的比较规则比较元素的大小，求出最大值

函数的要求：

​ a.有且只有一个参数（这个参数代表序列中的每个元素）

​ b.需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）

案例1：

求nums中十位数最大的元素:

nums = [9108, 23, 167, 90, 556, 149]
result = max(nums, key=lambda i: i // 10 % 10)
print(result)

案例2：

求nums中绝对值最小的元素

nums = [-992, 12, 78, -34, 99]
result1 = min(nums, key=lambda i: -i if i < 0 else i)
print(result1)

案例3：

nums中各个位数之和最大的元素

nums = [102, 19, 48, 221, 52]
# 3,10,12,5,7  ->  48
result2 = max(nums, key=lambda i: i // 100 + ((i // 10) - i // 100 * 10) + i % 10)
print(result2)


def temp(i):
    sum1 = 0
    for x in str(i):
        sum1 += int(x)
    return sum1


result_2 = max(nums, key=temp)
print(result_2)

案例4：

将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': '男'}
]
result3 = sorted(students, key=lambda i: i['score'], reverse=True)
print(result3)

（二）map

1）map(函数,序列)

根据函数制定规则，将指定序列中的元素转换成新序列中的元素

函数的要求：a.有且只有1个参数，代表后面序列中的元素
b.有返回值（返回对应的就是新序列中的元素）

2）map(函数,序列1,序列2)

函数的要求：a.有且只有2个参数，分别代表后面两个序列中的元素
b.有返回值（返回对应的就是新序列中的元素）

3）map(函数,序列1,序列2,序列3,…)

函数的要求：a.有且只有n个参数

案例1：

将nums中所有的元素乘以10

nums = [82, 67, 89, 6617, 90, 23, 71]

result = map(lambda i: i * 10, nums)
print(list(result))

案例2：

基于scores创建一个列表，列表中元素根据nums中元素确定为’及格’或者’不及格’

scores = [82, 67, 89, 66, 90, 23, 71]
# ['及格', '及格', '及格', '及格', '不及格', '及格']
result1 = map(lambda i: '及格' if i >= 60 else '不及格', scores)
print(list(result1))

案例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: {'names': i1, 'ages': i2, 'scores': i3}, names, ages, scores)
print(list(result))

（三）reduce

将序列中所有的元素通过指定的规则合并成一个数据

reduce(函数,序列,默认值)

函数的要求：

​ a.有且只有两个参数：第一个参数指向默认值，第二个参数指向序列中的每个元素
​ b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么样的操作得到的）

案例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)
print(result)