day11-函数进阶

1. 函数调用过程

1. 函数栈区间的声明周期

每次调用函数的时候，系统会自动为这个函数创建一个临时的栈区间，用来保存在这个函数中产生的数据。
当函数调用结束，这个栈区间会自动释放，里面保存的数据也会自动销毁。

def func1():
    a = 100     # a是保存在func1对应的临时栈区间中的
    
func1()
# print(a)        # NameError: name 'a' is not defined。 函数调用结束的时候func1对应的临时栈区间会自动释放，数据全部销毁

2. return的作用

1) 确定函数返回值 - 执行函数体的时候如果遇到return，return后面的值是函数返回值；没有遇到return返回值是None。
2) 提前结束函数 - 执行函数体的时候如果遇到return，函数直接结束。

def func2():
    # return        -       直接结束函数，返回是None
    # return 100    -       返回一个返回值
    # return 100, 200      # -    返回多个返回值
    for x in range(100):
        print('======')
        return
    print('end')

参数

1. 位置参数和关键字参数 - （根据实参提供方式的不同分类）

1) 位置参数 - 调用函数的时候直接提供实参对应的数据，让实参和形参在位置上一一对应。
2) 关键字参数 - 调用函数的时候在实参前面加 ‘参数名=’。关键字参数在使用的时候可以随意交换位置。
3) 位置参数和关键字参数混用： 位置参数必须在关键字参数的前面。

def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')

位置参数

func1(10, 20, 30)       # a:10, b:20, c:30
func1(20, 10, 30)       # a:20, b:10, c:30

关键字参数

func1(a=10, b=20, c=30)     # a:10, b:20, c:30
func1(b=20, a=10, c=30)     # a:10, b:20, c:30

func1(10, b=20, c=30)
func1(100, c=300, b=200)
func1(10, 20, c=30)

# func1(a=10, 20, 30)       # SyntaxError: positional argument follows keyword argument


def func2(x, y):
    print(f'x:{x}, y:{y}')


func2(100, 200)

2. 参数默认值

定义函数的时候可以以’形参=值’的方式给参数提供默认值。
如果一个参数有默认值，那么调用函数的时候有默认值的参数可以不用传参。

注意: 如果定义函数的时候有的参数有默认值，有的参数没有，那么没有默认值的参数必须在有默认值参数的前面。

def func3(a=10, b=20, c=30):
    print(f'a:{a}, b:{b}, c:{c}')


func3()     # a:10, b:20, c:30
func3(100)      # a:100, b:20, c:30
func3(100, 200)     # a:100, b:200, c:30
func3(100, 200, 300)    # a:100, b:200, c:300
func3(b=200)        # a:10, b:200, c:30

3. 参数类型说明 - 定义函数的时候指定参数类型

方法一：在没有默认值的参数后面加’:类型名’
方法二：给参数赋默认值，默认值是什么类型的数据，类型提示就是什么类型

def func5(a: int, b: float, c: str):
    print(f'a:{a}, b:{b}, c:{c}')


func5(10, 12.5, 'abc')


def func6(str1: str, old, new: str, a=[]):
    new.join(str1.split(old))

(了解)4. 不定长参数 - 参数个数不确定

1） 带 * 的不定长参数 - 在某个参数前面加 *，那么这个参数就会变成一个不定长参数，调用的时候可以接收多个实参。
带 * 的参数的本质就是一个元组，接收的所有的实参是这个元组中的元素。
注意：给 * 的不定长参数传参的时候必须使用位置参数。
2） 带 ** 的不定长参数

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

def sum2(*nums):
    print(nums)

def func7(x, *y):
    print(x)
    print(y)

func7(10)
func7(10, 20, 30, 40, 50, 60) 

注意：定长和不定长混用的时候，如果定长参数在*的后面，后面的参数必须全部使用关键字参数传参

def func8(x, *y, z):
    pass

func8(10, 20, 30, 40, 50, z=60)

*后面的参数必须使用关键字参数传参

def func9(a, *, b, c):
   pass

func9(10, b=20, c=30)

匿名函数

1.匿名函数 - 没有名字的函数

语法:
变量 = lambda 参数列表:返回值
def 变量(参数列表):
return 返回值

2. 匿名函数和普通函数的关系

除了定义的语法不一样，其他都一样(无参参数类型说明匿名函数也不支持)

a = lambda num1, num2: num1 + num2

# def a(num1, num2):
#     return num1 + num2

result = a(10, 20)
print(result)


b = lambda x, y, z=30: print(f'x:{x}, y:{y}, z:{z}')

# def b(x, y, z=30):
#     return print(f'x:{x}, y:{y}, z:{z}')
b(10, 20, 30)
b(x=100, z=300, y=200)
b(100, 200)

c = lambda x, *, y: x*y
c(10, y=20)   

练习1：定义一个匿名函数，获取指定正整数的十位数

get_tens_digit = lambda num: num // 10 % 10
# def get_tens_digit(num):
#     return num // 10 % 10
print(get_tens_digit(234))

练习2：定义一个函数判断指定的年是否是闰年

is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
print(is_leap_year(2004))
print(is_leap_year(2011))

实参高阶函数

1. 参数类型的确定

函数的参数是什么样的数据由这个参数在函数中的使用来决定的
比如， 假设x是一个形参：
x + 10 -> x必须是数字
x * 10 -> x可以是数字，也可以是字符串、列表、元组
x[-1] -> x可以是字符串、列表、元组或者是有键为-1的字典
x.append(100) -> x必须是列表
…
x() -> x必须是函数，并且这个函数在调用的时候可以不用传参
x(10, 20) -> x必须是函数，并且这个函数在调用的时候可以接收两个传参
10 + x() -> x必须是函数，并且这个函数在调用的时候可以不用传参。返回值必须是数字

2. 如果参数是函数

如果一个函数的参数是函数，实参可以是普通函数的函数名，或者是匿名函数或者是保存匿名函数的变量来传参。

def func2(x):
    # x=t; x=a
    x(10, 20)       # t(10, 20); a(10, 20)

def t(a, b):
    pass

a = lambda x, y: x+y

func2(t)
func2(a)
func2(lambda m, n: m*n)

3. 系统常用实参高阶函数：max/min/sored/列表.sort、map、reduce

实参高阶函数 - 如果函数的参数是函数，那么这个函数就是实参高阶函数
1) max/min/sored/列表.sort
max基本用法：max(序列) - 直接比较序列中元素的大小求最大值
max高级用法：max(序列,key=函数) - 通过函数制定的比较规则来获取序列中元素的最大值
函数的要求：
a. 是一个函数
b. 有且只有一个参数，这个参数指向的是序列中的每个元素
c. 有一个返回值，返回值就是真正的比较对象

nums = [19, 82, 67, 34]

# 获取nums中值最大的元素
print(max(nums))

result = max(nums, key=lambda item: item)
print(f'result1:{result}')      

练习1：获取nums中个位数最大的元素 -> 19

nums = [190, 82, 67, 34]
result = max(nums, key=lambda item: item % 10)
print(f'result2:{result}')

# [190, 82, 34, 67]
nums.sort(key=lambda item: item % 10)
print(f'nums：{nums}')

练习2：获取nums中绝对值最大的元素 -> -340

nums = [19, 82, 67, -340]
result = max(nums, key=lambda item: item if item >= 0 else -item)
print(f'result3:{result}')

练习3：求students中年龄最大的学生

students = [
    {'name': 'stu1', 'age': 9, 'score': 90},
    {'name': 'stu2', 'age': 19, 'score': 66},
    {'name': 'stu3', 'age': 21, 'score': 72},
    {'name': 'stu4', 'age': 18, 'score': 89}
]
result = max(students, key=lambda student: student['age'])
print(f'result4:{result}')

result = sorted(students, key=lambda student: student['score'], reverse=True)
print(result)

练习4: 获取nums中数值最大的元素 -> ‘34’

nums = [10, '34', 9.9, '5.5']
result = max(nums, key=lambda item: float(item))
print(f'result5:{result}')

练习5：获取nums中各个位的和最大的元素

nums = [1000, 230, 97, 59, 101]     # [1, 5, 16, 14, 2]
def temp(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1

result = max(nums, key=temp)
print(f'result6:{result}')

result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(f'result6:{result}')