[Python知识库]day 12

day 12

匿名函数

1.匿名函数

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

相当于：
def (形参列表):
return 返回值

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

写一个匿名函数求两个数的和:
sum1 = lambda a, b: a + b
result = sum1(10, 20)
print(result)

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

练习：写一个匿名函数判断指定的年是否是闰年
nian=lambda year : year % 400==0 or (year % 4==0 and year%100!=0)
print(nian(2012))

变量的作用域

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

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

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'循环里面b，x：{b}，{x}')

print(f'循环外面b，x：{b}，{x}')

3.局部变量

局部变量：定义在函数中的变量使局部变量(形参也是局部变量)
局部变量的作用域: 是从定义开始到函数结束

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


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

4.全局变量和局部变量的底层

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

5.global

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

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

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

函数就是变量

1.函数就是变量

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

a=10
b=lambda :b

#1)打印变量
print(a)
print(b)

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

#3)用变量给其他变量赋值
m=a
n=b
print(m+100)
result=n(10)
print(result)

#4)变量
list1=[a,b,b(2)]
print(list1)

2.高阶函数

1） 实参高阶函数 – 如果一个函数的参数是函数，这个函数就是实参高阶函数

2）返回值高阶函数
返回值是函数的函数

def func2():
   def func3():
       return 100
   return func3()

print(func2()())

实参高阶函数

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

1.max、min、sorted

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

#练习1：求num中个位位数最大的元素
#使用匿名函数
nums = [10, 29, 81, 23]

result = max(nums, key=lambda x: x % 10)
print(result)


#使用普通函数
def temp(x):
    return x % 10


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

#练习2：求nums中分数最高的元素
nums = [10, '23.8', 34, '89']
result = max(nums, key=lambda x: float(x))
print(result)

print('==================')
#练习3：求students中分数最高的学生。
students = [
    {'name': 'stu1', 'age': 29, 'score': 59},
    {'name': 'stu2', 'age': 23, 'score': 89},
    {'name': 'stu3', 'age': 12, 'score': 76},
    {'name': 'stu4', 'age': 22, 'score': 77}
]

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

#练习4：求nums中各个位数的和最小的元素
[7, 17, 3, 7, 13]  -> 102
nums = [70, 89, 102, 34, 67]

result = min(nums, key=lambda x: x % 10 + x // 10 % 10 + x // 100 % 10)
print(result)


#方法二：
#x 相当于列表中的元素
def temp(x):
    sum1 = 0
    for i in str(x):
        sum1 += int(i)
    return sum1


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

2.map

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

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

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

4）map（函数,序列1,序列2,序列3，…）

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

#练习1：提取nums中所有元素的个数
nums = [12, 34, 56, 78, 89]
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']
['12a','34b','56c','67d','19e','83f']
result = map(lambda x1, x2: str(x1) + x2, nums, strs)
print(list(result))

names = ['stu1', 'stu2', 'stu3', 'stu4', 'stu5']
ages = [18, 20, 45, 78, 26]
score = [90, 87, 69, 71, 82]

result=map(lambda x1,x2,x3:f'{x1}:{str(x2)}:{str(x3)}',names,ages,score)
print(list(result))
result = map(lambda n, a, s: {'name': n, 'age': a, 'score': s}, names, ages, score)
print(list(result))

3.reduce - 将序列中的元素合并成一个数据

注意：reduce在使用前必须先导入:
from functools import reduce
resuce(函数，序列，初始值)
函数的要求：
a.有且只有两个参数：第一个参数执行初始值，第二个参数指向序列中的每个元素
b.有一个返回值，返回值需要描绘清除合并方式

from functools import reduce

#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)