Python基础-函数和lambda表达式

主要介绍函数的用法，函数的参数以及lambda表达式

函数的定义以及参数
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
"""
函数 封装特定功能的代码块 可重复调用
def 关键字定义函数
def f_name(args):
    [return result]
"""


def add_two_num(a, b):
    """
    这是函数的说明文档
    add_two_num(a, b) 返回a和b的和
    """
    return a + b


# 调用函数
s = add_two_num(10, 15)
print(s)
# help()函数查看文档 或者 调用函数的__doc__
print(help(add_two_num))
print(add_two_num.__doc__)


# 多个返回值 可以直接返回多个 会封装成元组
def sum_and_avg(l_list):
    the_sum = 0
    count = 0
    for e in l_list:
        the_sum += e
        count += 1
    return the_sum, the_sum / count


l_l = [10, 30, 20]
tp = sum_and_avg(l_l)
print(tp)
s, avg = sum_and_avg(l_l)
print("总和：%s,平局值:%s" % (s, avg))


# 递归函数 函数内部调用函数 类似循环 需要向已知方向结束函数
def fn(n):
    if n == 0:
        return 1
    else:
        return n * fn(n - 1)


print(fn(6))

"""
关键字参数
1.调用参数使用参数名来传入参数 称为关键字参数 可以不按照参数顺序传入
2.不使用参数名出入参数 称为位置参数 需要按照参数位置顺序传入
3.调用时位置参数要在前，关键在参数在后
"""


def girth(width, height):
    return 2 * (width + height)


# 位置参数
print(girth(2, 3))
# 关键字参数
print(girth(height=3, width=2))
# 混用 位置参数必须在前
print(girth(2, height=3))

"""
默认关键字 定义函数式指定参数默认值 有默认值的参数必须在最后 
调用时有默认值的参数可以不传参
"""


def say_hi(name, message='hello'):
    print("my name is %s,%s" % (name, message))


say_hi('joke', 'hi')
"""
多参数
1.参数前面加一个星号 * 多参数转成元组 最多一个
2.参数前面加2个星号 ** 关键字多参数 转成字典 最多一个
** 要在一个 * 后面
"""


def test(x, y, *book, z=3, **scores, ):
    print(x, y, z)
    print(book)
    print(scores)


test(1, 2, "first use python", "learn python", z=10, 语文=90, 数学=99, 英语=10)

"""
逆向参数收集 将元组 列表 字典等前面加星号* 字典两个* 自动拆开传入函数 
"""


def test_second(name, message):
    print("name is %s , this is message:%s" % (name, message))


the_list = ['joke', 'hello python']
test_second(*the_list)


def coo(name, *tu):
    print(name)
    print(tu)


the_tuple = (1, 2, 3, 4)
coo('cool', *the_tuple)


def bar(name, price, desc):
    print("name:%s,price:%s,desc:%s" % (name, price, desc))


book = {'name': 'python', 'price': 20, 'desc': 'this is desc'}
bar(**book)

"""
参数的传递 参数传递传入的是变量的复制 
1.对于不可变变量  函数内对变量参数修改无影响
2.对于可变变量 列表和字典 参数复制的是变量地址 改变参数变量影响传入的变量
"""
函数变量的作用域
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
"""
变量作用域
函数内定义的变量 局部变量 作用在函数体内
函数外 全局范围定义的变量 全局变量 所有函数内可以访问
 globals()：获取全局变量 修改会产生影响
 locals()：当前范围的全部变量 局部或者全局 看当前范围
 vars(object):指定对象范围的所有变量 不指定object作用同locals
"""


def test():
    age = 20
    print(locals())
    print(globals())
    locals()['age'] = 12
    print(age)
    print(locals())


x = 15
test()
globals()['x'] = 18
print(x)
locals()['x'] = 20
print(x)

"""
局部变量 屏蔽全局变量
"""
name = "haha"


def print_name():
    print("name is:", name)
    '''
     引起错误 这是定义了一个name局部变量 而上面的print语句的name变成了局部变量
     认为name为未定义，local variable 'name' referenced before assignment
     '''
    # name="july"


print_name()


# 解决办法1 globals
def print_name_one():
    print("name is:", globals()['name'])
    name = "july"


print_name_one()
print(name)


# 解决办法2 函数中声明全局变量 global
def print_name_two():
    # 声明name是全局变量 不重新定义局部变量
    global name
    print('name is:', name)
    name = 'july'


print_name_two()
print(name)

"""
局部函数  函数内定义函数 默认不对外可见
"""


def math_fun(t, num):
    def add(k):
        return 2 * k

    def multi(k):
        return k * k

    if t == 'a':
        return add(num)
    else:
        return multi(num)


print(math_fun('a', 10))
print(math_fun('m', 10))
'''
局部函数内的变量也会屏蔽外层函数的局部变量
nonlocal 声明访问的是外层函数的变量
'''


def foo():
    age = 15

    def bar():
        nonlocal age
        print(age)
        age = 66

    bar()
    print("out age:", age)


foo()
函数的用法和lambda表达式
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
"""
函数本身是一个对象 function
可用于赋值 作为返回值 函数的参数使用
"""


# 赋值
def add(a, b):
    return a + b


print(type(add))
the_add = add
print(type(the_add))
print(the_add(2, 3))


# 作为参数
def mult_self(n):
    return n * n


def test(b, fun):
    result = []
    for i in b:
        result.append(fun(i))
    return result


a_list = [2, 3, 5, ]
print(test(a_list, mult_self))


# 作为返回值
def get_add_fun():
    def add_self(n):
        return n + n

    return add_self


my_f = get_add_fun()
print(my_f(13))

"""
lambda 表达式 只能是当行表达式
格式:lambda [parameter_list]:表达式 参数列表多个 逗号隔开 表达式为返回值
本质是匿名的 单行函数体的函数
"""


def get_add_l_fun():
    return lambda n: n + n


my_f_s = get_add_l_fun()
print(my_f_s(18))

# 调用内置 map函数
x = map(lambda a: a * a, range(5))
print([e for e in x])