day 12

day12函数进阶

1.匿名函数

语法：

• 变量（函数名） = lambda 形参列表：返回值

相当于：
def （形参列表）：
return 返回值

• 注意：匿名函数除了定义以及参数类型说明和普通函数不一样，其他的都一样

# 写一个匿名函数求两个数的和
sum1 = lambda num1, num2: num1 + num2
result = sum1(10, 30)
print(result)
result = sum1(11, 3.0)
print(result)

func1 = lambda a, b=2, c=3: a + b + c
print(func1(10))

print(func1(1, 20, c=30))
print(func1(a=1, b=29, c=10))

#  练习判定指定的年是否是闰年
year = lambda year1: year1 % 400 == 0 or (year1 % 4 == 0 and year1 % 100 != 0)
print(year(2019))

2.变量作用域

2.1 变量作用域——变量能作用的范围

• 根据变量作用域的不同将变量分为全局变量和局部变量

2.2全局变量

• 全局变量：没有定义在函数和类里面的变量都是全局变量，全局变量的作用域是从定义开始到程序结束

# a是全局变量
a = 10
print(f'函数外面；类外面，a:{a}')

def func1():
    print(f'函数里面，a:{a}')

func1()

class A:
    print(f'类里面，a:{a}')

# b 是全局变量
for x in range(5):
    b = 20
    print(f'循环里面x:{x} b:{b}')
print(f'循环外面x:{x} b:{b}')

2.3 局部变量

• 局部变量：定义在函数中的变量是局部变量（形参也是局部变量），局部变量的作用域是从定义开始到函数结束

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


func3(100)
# print(f'函数里面m，c{m},{c}')  #报错

2.4 全局变量和局部变量的底层

全局变量保存在全局的栈区间，全局栈区间是在程序结束的时候才会释放；
每次调用函数的时候系统会自动为这个函数创建一个临时的栈区间（从C开始就是这样），用来保存函数运行过程中产生的数据
所以局部变量也是保存在这个临时栈区间中的。当函数调用结束这个临时栈区间会释放

2.5 global

作用1：在函数内部去修改全局变量的值
作用2：在函数内部定义全局变量

• 注意：global只能在函数内部使用，使用的时候必须在第一次使用变量之前

abc = 100
name = '小明'

def func4():
    # 在函数内部给全局变量赋值，不会修改全局变量的值而是创建一个新的局部变量
    abc = 200
    print(f'函数内的abc：{abc}')
    # 函数内部使用变量前加global，操作的是全局变量，不会创建新的全局变量
    global name
    name = '小花'
    print(f'函数内的name：{name}')
    global age
    age = 18
func4()
print(f'函数外部的abc：{abc}')
print(f'函数外的name：{name}')

3.函数就是变量

3.1 函数就是变量

• python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名
• 变量能做的事情，函数都可以做

a=10
b=lambda x=2:x*2
# 1）打印变量
print(a)
print(b)

# 2）获取变量类型
print(type(a))
print(type(b))

# 3)用变量去赋值
m=a
n=b
print(m+100)
print(n())

# 4）变量

3.2高阶函数

• 1）实参高阶函数——如果一个函数的参数是函数，这个函数就是实参高阶函数
• 2）返回值高阶函数
• 返回值是函数的函数

4.实参高阶函数

• 常用实参高阶函数：max、min、sorted、map、reduce

4.1 max、min、sorted

max(序列,key=函数)- 根据函数制定的规则来获取序列中最大的元素
函数的要求:
a.有且只有一个参数，这个参数代表序列中的每个元素
b.有一个返回值，返回值就是比较对象

• 练习1 求nums中个位数最大的元素

nums = [10, 29, 81, 23]
result = max(nums, key=lambda x: x % 10)
print(result)

• 练习2：求nums中数值最大的元素

nums = [10, '80.34', 81, 23, '89']
result = max(nums, key=lambda x: float(x))
print(result)

• 练习3：求students中分数最高的学生

students = [
    {'name': 'stu1', 'age': 29, 'score': 59},
    {'name': 'stu2', 'age': 30, 'score': 89},
    {'name': 'stu3', 'age': 19, 'score': 79},
    {'name': 'stu4', 'age': 20, 'score': 99}

]
result = max(students, key=lambda x: x['score'])
print(result)

• 按年龄从小到大排序

result = sorted(students, key=lambda x: x['age'])
print(result)

• 练习4：求nums中各个位数的和最小的元素

nums = [70, 89, 102, 34, 67]


#  这里的x取得是nums中的每一个元素
def temp(x):
    sum1 = 0
    for i in str(x):
        sum1 += int(i)
    return sum1


result = min(nums, key=temp)
print(result)

4.2 map

1）map(函数，序列)
函数：
a.有且只有一个参数，参数指向后面序列中的每一个元素
b.有一个返回值，返回值就是新序列中的元素

2）map(函数，序列1，序列2)
a.有且只有两个参数，参数分别指向后面对应序列中的每一个元素
b.有一个返回值，返回值就是新序列中的元素

3)map(函数，序列1，序列2，序列3)
a.有且只有三个参数，参数分别指向后面对应序列中的每一个元素
b.有一个返回值，返回值就是新序列中的元素

• 注意：map函数的返回值是一个map对象（本质是一个序列）

• 练习1：提取nums中所有元素的个位数

nums = [12, 34, 56, 67, 19, 83]
result = list(map(lambda x: x % 10, nums))
print(result)

# 练习2：
nums = [12, 34, 56, 67, 19, 83]
strs = ['a', 'b', 'c', 'd', 'e', 'f']
result = map(lambda x1, x2: f'{x1}{x2}', nums, strs)
print(result)


# 练习3：
print('==================')
names = ['stu1', 'stu2', 'stu3', 'stu4', 'stu5']
ages = [18, 20, 45, 23, 22]
scores = [90.87, 69, 71, 89]
result = list(map(lambda x1, x2, x3: {'name': x1, 'age': x2, 'score': x3}, names, ages, scores))
print(result)

4.3reduce——将序列中的元素合并成一个数据

注意：reduce在使用之前必须先导入(from functools import reduce)
reduce(函数，序列，初始值)
函数的要求：
a.有且只有两个参数，第一个参数指向初始值，第二个参数指向序列中的每一个元素
B.有一个返回值，返回值需要描述清楚合并方式(初始值和元素进行什么样的操作）

• 1）求nums中的所有元素的和

nums = [10, 23, 89, 34]
result = reduce(lambda x1, x2: x1 + x2, nums, 0)
print(result)

• 2）求nums中所有个位数的和

nums = [10, 23, 89, 34]
result = reduce(lambda x1, x2: x1 + x2 % 10, nums, 0)
print(result)

• 3)将nums中的元素合并成一个字符串

nums = [10, 23, 89, 34]
result = reduce(lambda x1, x2: x1 + str(x2), nums, '')
print(result)

• 4)将nums中所有元素求乘积

nums = [10, 23, 89, 34]
result = reduce(lambda x1, x2: x1 * x2, nums, 1)
print(result)