Python每日笔记07（lambda表达式详解+变量作用域+高阶函数）_lambda函数python使用的参数变量作用域确定

本次内容：lambda表达式详解+变量作用域+高阶函数

>> Python每日笔记—目录 <<

lambda表达式：匿名函数

    没有函数名，没有def关键字，只有函数体，使用匿名函数的原因：该函数的逻辑只使用一次。
    关键字lambda表达式：函数体比def的方式简洁很多
     lambda的主体是一个表达式，而非逻辑代码块，只能封装有限的代码块。
     lambda有自己的命名空间，且不能访问自己参数列表之外的参数或者全局命名空间的参数

'''lambda案例：相对来说，lambda函数的结构比较简单'''
sum1 = lambda arg1, arg2: arg1+arg2
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print("调用sum1的方法的结果为：", sum1(10, 20))   # 30
print("调用sum1的方法的结果为：", sum1(list1, list2))   # [1, 2, 3, 4, 5, 6]
1
2
3
4
5
6

构造lambda表达式的几种参数形式

# 1、匿名函数的参数形式
'''无参类型'''
fn1 = lambda: 10
print(fn1())

'''参数*运算符'''
fn2 = lambda a: a*2
print(fn2("你好"))

'''默认参数函数'''
fn3 = lambda a, b, c = 100: a + b + c
print(fn3(100, 200))

'''元组参数'''
fn4 = lambda *args: args
print(fn4(10, 10))

'''字典参数'''
fn5 = lambda **kwargs: kwargs
print(fn5(name = '张三', sex = '男'))

'''三目运算符参数'''
fn6 = lambda a, b: a if a > b else b
print(fn6(100, 50))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

lambda表达式和sort排序函数组合使用案例

students = [
    {'name': "Tom", 'age': 20},
    {'name': "Rose", 'age': 19},
    {'name': "Java", 'age': 18},
]

# name,key对应的值进行升序排序
students.sort(key = lambda x: x['name'])
print(students)

# name,key对应的值进行降序排序
students.sort(key = lambda x: x['name'], reverse = True)
print(students)

# age,key对应的值进行升序排序
students.sort(key = lambda x: x['age'])
print(students)

# age,key对应的值进行降序排序
students.sort(key = lambda x: x['age'], reverse = True)
print(students)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

函数作用域和关键字global

1. 外部尝试访问函数内部的变量，试试看能得到什么？

# 定义一个变量，在函数内部和外部同时访问，关注该变量的特点
def test_a():
    a = 10
    if a > 0:
        print("%d是一个正数" % a)
        if a > 10:
            a = 1000
            print("%d是一个10-1000之间的整数" % a)
    print(a)

test_a()
# print(a)  无法直接访问函数体内的变量
1
2
3
4
5
6
7
8
9
10
11
12

运行过之后，会报错，很显然外部不能访问函数内部的变量
得到一个结论：局部变量，只能作用在局部区域，全局不能访问

def test_b():
    a = 10   # 局部变量，只能作用在局部区域，全局不能访问，否则会报编译错误
    if a > 0:
        b = 10
        print(b)
1
2
3
4
5

2. 我们都知道局部变量可以获取全局变量的值，那函数内部可以修改全局变量吗？

# 全局变量
a = 10
def test_c():
    print(a)
    if a > 0:
        a += 1    全局变量不允许在局部进行修改，会报错
test_c()

a = 10
def test_d():
    a = 100
    print(a)
    print(id(a))
print(a)      # 10
print(id(a))  # 1983513360

test_d()    # 100 和  1983516240
'''
此时函数体内可选的a有两个 10 和 100
但是打印出了100，作用域符合就近原则
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

       结果很显而易见，还没有运行程序就报错。或者在函数里创建了新的变量，但这好像不是我们想要的结果，那么我非要做修改呢？
       没有办法就创造办法，这里给出一个关键字global，顾名思义，将变量置为全局变量，大家都可以使用他，并且修改。

'''第一种，函数内变量声明为global'''
def test_e():
    global e    # 在局部函数中声明全局变量需要使用global关键字
    e = 200
test_e()    # 必须运行此函数！
print(e)    # 此时可以在函数外访问变量e

'''第二种,全局变量在函数内声明为global'''
f = 10
def test_f():
    global f    # 如果想在函数内修改全部变量需要加上global关键字
    f = 200     # 此时函数体内的f都指向同一个f
test_f()
print(f)    # 200
1
2
3
4
5
6
7
8
9
10
11
12
13
14

高阶函数

首先给出一个案例，再进行描述：

# 提供任意两个数组，对该数字进行处理（取绝对值或者四舍五入），然后再求和计算
# print(abs(-10))
# print(round(1.6)

# 第一种写法：
def add_num1(a, b):
    return abs(a) + abs(b)
result = add_num1(1.1, -1.9)
print(result)

# 写法2 写入第三个参数，用来接收传过来的函数
def add_num2(a, b, f):
    return f(a) + f(b)
result = add_num2(1.5, 2.3, round)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

       第一种写法是正常的方式，给函数传参。第二种方式有很大的区别，将另一个函数名作为参数传入了函数中，并且调用它。
       第二种就是所谓的高阶函数，给出定义：高阶函数：一个函数可以作为参数传给另外一个函数，或者一个函数的返回值为另外一个函数（若返回值为该函数本身，则为递归），满足其一则为高阶函数。

自定义函数传入
方法大同小异，样例如下：

# 自定义函数作为参数传入
def test(a):
    return a**2 + a**2
def add_num2(a, b, f):
    return f(a) + f(b)
result = add_num2(2, 3, test)
print(result)
1
2
3
4
5
6
7

常用内置高阶函数

''' 
    map(func, iter1, iter2)
    map(func, list):
    将函数func作用到list中的每一个元素，并且迭代返回
'''
list1 = [1, 2, 3, 4, 5]
def func(x):
    return x**2
result = map(func, list1)
print(list(result))  # [1, 4, 9, 16, 25]


'''
    reduce(func,list):func(必须是两个参数), 每次func计算的结果继续和序列的下一个元素累计计算
    下一个元素累计计算
'''
import functools
list1 = [1, 2, 3, 4, 5]
def func_1(a, b):
    return a + b
result = functools.reduce(func_1, list1)
print(result)   # 15       (1+2+3+4+5)累加的过程


''' filter(func,list):用于过滤序列，过滤掉不符合条件的元素，返回filter对象，
    可以转化为list
'''
list1 = [4, 6, 7, 77]
def fun_2(x):
    return x % 2 != 0
result = filter(fun_2, list1)
print(list(result))     # [7, 77]   过滤掉了偶数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

学生管理系统案例（改进版）

# 定义功能界面函数
def info_print():
    print("请选择功能:")
    print("1、添加学生")
    print("2、删除学生")
    print("3、修改学生")
    print("4、查询学生")
    print("5、查看所有学生")
    print("6、退出")
    print("-" * 20)
# 存储学员信息变量 ，使用列表
info = [
        {'tel': '110', 'id': '1', 'name': '小敬'},
        {'tel': '119', 'id': '2', 'name': '小火'},
        {'tel': '120', 'id': '3', 'name': '小护'}
        ]
# 添加学生信息
def add_info():
    """添加学生的函数"""
    ''' 1、用户输入学生的学号、姓名、手机号'''
    new_id = input("请输入学号：")
    new_name = input("请输入姓名：")
    new_tel = input("请输入手机号：")
    '''2、判断是否添加这个学员，如果学员的姓名已经存在，报错提示，如果姓名不存在
        则添加学员信息'''
    # 2.1 设置全局变量
    global info
    for i in info:
        if new_name == i['name']:
            print("该用户已存在")
            return  # 退出当前函数，后面添加信息的代码不执行
    # 如果输入的姓名不存在，添加数据，准备一个空的字典，列表追加到字典中
    info_dict = {}
    # 字典新增数据 key,value
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel
    '''注意：函数体内访问全局变量，需要用global做修饰！！！'''
    # 列表追加字典
    info.append(info_dict)
    print(info)

# 删除学生信息
def del_info():
    """删除学生的函数"""
    # 1、用户输入要删除的学生的姓名
    del_name = input("请输入要删除的学生的姓名：")
    # 2、判断输入的学生是否存在，如果存在则删除，不存在则提示信息
    # 2.1 设置全局变量
    global info
    # 2.2 循环遍历info检查是否存在
    for i in info:
        if del_name == i['name']:
            info.remove(i)
            break
    else:   # 对应的for循环，for循环结束后的操作
        print("该学员不存在")
    print(info)
# 修改学生信息
def mod_info():
    """修改学员信息的函数"""
    mod_name = input("请输入要修改的学生姓名：")
    global info
    for i in info:
        if mod_name == i['name']:
            i['tel'] = input("请输入新的手机号：")
            print("修改成功")
            break
    else:
        print("学生不存在")
# 查找学生信息
def search_info():
    """查询学生信息函数"""
    search_name = input("请输入要查找的学生姓名")
    global info
    for li in info:
        if search_name == li['name']:
            print("name:%s id:%s tel:%s" % (li['name'], li['id'], li['tel']))
    else:
        print("学生不存在")

def all_info():
    """查看所有学生信息函数"""
    global info
    for li in info:
        print("name:%s id:%s tel:%s" % (li['name'], li['id'], li['tel']))

if __name__ == '__main__':
    while True:
        # 1、显示功能界面
        info_print()
        # 2、用户输入功能序号
        user_num = input("请输入功能序号")
        if user_num == '1':
            add_info()
        elif user_num == '2':
            del_info()
        elif user_num == '3':
            mod_info()
        elif user_num == '4':
            search_info()
        elif user_num == '5':
            all_info()
        elif user_num == '6':
            print("退出系统")
            break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

明天补充文件File的内容，今天的内容就到这里了。

如果这篇文章对你有帮助的话，点个赞呗