day12- 函数进阶

day12- 函数进阶

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

匿名函数的本质还是函数，但是匿名函数只能实现一句代码就能实现的功能

"""
1)语法
函数名 = lambda 参数列表:返回值
相当于
def (参数列表):
	return 返回值
2）说明：
lambda - 关键字；固定写法

参数列表 - 普通函数写在()中的形参列表
:  -  固定写法
返回值  - 相当于普通函数的return后面的值

3）注意：匿名函数需要先保存才能调用
匿名函数不能声明参数类型
"""

sum1 = lambda x, y, z:x+y+z
# 和普通函数一样可直接用位置参数传参
result = sum1(10, 20, 30)
print(result)
# 和普通函数一样可用关键字参数传参
result = sum1(x=10, z=30, y=20)
print(result)

# 练习：写一个匿名函数判断指定整数是否是偶数
is_even = lambda num: num % 2 == 0
result = is_even(5)
print(result)  # False

list1 = [10, lambda x:x*2]
print(list1[-1](10))  # 20

dict1 = {'a': 10, 'b': lambda x: x+2}
print(dict1['b'](10))  # 12

2.变量作用域

1.变量作用域 - 变量可以使用的范围

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

​ 1）全局变量

"""
没有定义在函数或者类里面的变量就是全局变量
全局变量的作用域：从定义开始到程序结束（从定义开始到文件结束的任何位置都可以使用）
"""

# a是全局变量
a = 100
# x 和 b 都是全局变量
for x in range(3):
    b = 10
   print(f'函数外a:{a}, x:{x}, b:{b}')

​ 2)局部变量

"""
局部变量就是定义在函数里面的变量（形参也是局部变量）
局部变量的作用域：从定义开始到函数结束
"""

# m和n是局部变量
def func2(m):
    n = 10
    print(f'函数里面m:{m}, n:{n}')
func2(100)
# print(f'函数外面m:{m}, n:{n]')  # 报错,因为m和n是局部变量,若要使用必须用函数调用把他接受出来

2.全局变量和局部变量的底层逻辑

1）全局变量：全局变量是保存至全局的栈区间中，全局栈区间是在程序运行结束的时候才会被释放.
2）局部变量:当程序调用函数的时候，系统会自动给这个函数创建一个独立的栈区间,专门用来保存在函数中产生的数据（局部变量就是保存在这个内存区间中），当函数调用结束，这个栈区间就会自动释放

3.global 和 nonlocal

​ 1)global

​ 作用一：在函数内部修改全局变量的值使用global

​ 作用二：在函数内部定义一个全局变量

​ 注意：使用global的时候必须保证在函数里面global修饰的变量不会出现在它的前面

xx = 1000
yy = 1000
def func3():
    # 在函数里面不能直接修改全局变量的值，而是定义了一个新的局部变量
    xx = 2000
    print(f'函数里面xx:{xx}')
    
    # 注意：global
    # 应用一：在函数内部修改一个全局变量值使用global
    global yy
    yy = 2000
    print(f'函数里面yy:{yy}')
    # 应用二：在函数内部定义一个全局变量，在函数外部也可以使用
    global num
    num = 100
    print(f'函数里面num:{num}')
func3()
print(f'函数外面xx:{xx}')
print(f'函数外面yy:{yy}')
print(f'函数外面num:{num}')

​ 2）nonlocal - 在局部的局部修改一个局部变量的值

def func4():
    k = 100
    def func5():
        nonlocal k
        k = 200
        print(f'func5中k:{k}')
    func5()
    print(f'func4中k:{k}')
func4()   # func5中k:200
           # func4中k:200

3高阶函数

1.函数就是变量

Python中定义函数起始就是定义一个类型是function的变量，函数名就是变量名

变量能做的事，函数都能做

a = lambda x；x*2
print(type(a))  # <class 'function'>

# 场景1:可以通过使用变量来使用变量中保存的数据，如果这个数据就是函数，函数的通用操作是调用它
x = 100
print(x % 2)
x = 'abc'
print(x[-1])

def m():
    print('---------')
    
# 场景2：用一个变量给另外一个变量赋值
m = 100
n = m
print(n * 100)

def mm():
    print('------')
nn = mm
nn()

# 场景3：修改变量的值
m = 100
print(m % 10)
m = [10, 30, 20]
print(m[-1])

a = 100
mm()
mm = 100
# mm()   # 报错，因为将函数重新复制了

2.高阶函数

​ 1）函数可以作为函数的实参

​ 实参高阶函数 - 如果一个函数的参数是函数，那么这个函数就是一个实参高阶函数

​ 2）函数可以作为函数的返回值

​ 返回值高阶函数 - 如果一个函数的返回值是函数，那么这个函数就是一个返回值高阶函数

# func2就是实参高阶函数
def func2(x):
    x() + 10

    
def t()
return 12
func2(t)


def func3(x):
    def t():
        pass
    return t
func3(10)() # t()

4.实参高阶函数

1.max、min、sorted

​ 1)max(序列，key = 函数) - 根据函数提供的方式来获取序列中元素的最大值

​ 函数要求：a.有且仅有一个参数，这个参数指向的是序列中的每个元素

​ b.需要一个返回值，返回的是比较对象

nums = [28, 52, 61, 70, 84, 9]
print(max(nums))
print(max(nums, key=lambda item:item))

# 练习1：获取nums中个位数最大的元素
# [28, 52, 61, 70, 84, 39]  -> 39
nums = [28, 52, 61, 70, 84, 39]
# item是原来的元素，返回值是获取的最终最大的元素
print(max(nums, key=lambda item:item%10))

# 练习2：获取年龄最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]

print(max(students, key=lambda item: item['age']))

# 练习3：获取nums中各个位数的和最大的元素
# [123, 78, 90, 301, 49]   ->  [6, 15, 9, 4, 13]  -> 78
nums = [123, 78, 90, 301, 49]
# 列表推导式
print(max(nums, key=lambda item:sum(int(x) for x in str(item)))
# 函数做
def t(item):
      sum1 = 0
      for x in str(item):
      	sum1 += int(x)
      return sum1
# 练习4：获取分数最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]
print(max(students, key=lambda item: item['score']))

      
# 练习;将下面列表中的元素按照数值大小从大到小排序
nums = [23, '100', 56, '12.7', '100.2']
print(sorted(nums, key=lambda item:float(item)))

2.map

​ 1)map(函数，序列) - 将序列中的元素按照函数提供的方法进行变换

​ 函数的要求：a.有且仅有一个参数，指向序列中的每个元素

​ b.需要一个返回值，返回值就是新序列中的元素（描述清楚新序列的元素和原序列元素之间的关系）

相当于：[返回值 for 参数 in 序列]

​ 2）map(函数，序列1，序列2)

​ 函数的要求：1）有且仅有两个参数，分别指向两个序列中的元素

​ 2）需要一个返回值，返回值就是新序列中的元素（描述清楚新序列的元素和原序列元素之间的关系)）

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

# 练习:
# A = [10, 20, 30, 40]  B = ['a', 'b', 'c', 'm']
# 新序列= ['a10', 'b20', 'c30', 'm40']
result = list(map(lambda x, y: y+str(x), A，B))
print(result)
# 练习;
# name = ['张三', '小明', '李四', '小花']
# scores = [90, 89, 99, 70]
#  结束: [{'name': '张三', 'score': 90}, {'name': '小明', 'score': 89},....]
result = list(map(lambda key,value:{'name':key, 'score':value}, name, scores))
print(result)

3.reduce - 将一个序列中的元素按照指定的规则合并成一个新的数据

"""
reduce(函数，序列，初始值) - 用指定的初始值来将序列中的元素按照函数指定的规则合并成一个新的数据
函数的要求：1）有且仅有两个参数：第一个参数指向初始值，第二个参数指向序列中的每个元素；2）需要一个返回值：描述清楚最后合并的结果是初始值和序列中的元素通过什么样的方式合并产生的
注意：用reduce的时候先要导入functools包 即from functools import reduce
"""

from functools import reduce
# 练习
nums = [10, 20, 30]
# 1)初始值+10+20+30 -> 60
result = reduce(lambda x,y:x+y, nums, 0)
print(result)
#2) 初始值*10*20*30 ->6000
result = reduce(lambda x,y:x*y, nums, 1)
print(result)
# ->'102030'  ->102030
# 初始值+str(10)+str(20)+str(30)
result = reduce(lambda x, y:x+str(y), nums, '')
print(result)
# 初始值+str(10//10%10)+str(20//10%10)+str(30//10%10)-> ''+ '1' +'2'+'3' -> 123/'123'
result = reduce(lambda x, y: x + str(y // 10 % 10), nums, '')
print(result)