12函数进阶

小小药虫

函数进阶

函数的作用域

作用域又可以被称为命名空间，指变量起作用的范围。Python变量作用域可以分为四种，分别为局部作用域、嵌套作用域、全局作用域、内置作用域。
作用域英文局部作用域Local嵌套作用域Enclosing全局作用域Global内置作用域Buiit-in

内建作用域是特质python api内置的一些操作，例如 len 、max等函数，无需声明就可使用。

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量：定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
  
• 局部变量：局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
  

1. x = 2
3. def func():
4.     x = 3  # 局部变量   
5.     return x
7. result = func()
8. print(result)  # 3
9. print(x)  # 2

复制代码

当我们在代码里使用变量时，Python创建对象，改变对象或查找对象都是在一个所谓命名空间下进行的(一个保存变量名的地方)。而函数除了打包代码之外，还定义了一个新的变量空间，一个函数所有的变量，都与函数的命名空间相关联：

• def 内定义的变量名能够被 def内的代码使用，不能在函数外部引用这样的变量名
  
• def之中的变量名与def之外的变量名并不冲突
  

也就是说：

• 如果一个变量在def内被赋值，它就被定义在这个函数之内
  
• 如果在def之外赋值，它就是整个文件全局的
  

回到上面的那个例子：

1. x = 2
2. def func(x):
3.     x = 3
4. """
5. 尽管这两个变量名都是x，但是他们作用域(命名空间)可以把他们区别开。
6. 作用域(命名空间)有助于防止程序之间变量名的冲突，而且，有助于函数成为更加独立的单元。
7. 在Python中，函数定义了一个函数本地内的作用域，
8. 而像x = 2这样赋值语句定义了一个全局作用域(模块级别的变量，使用范围仅限于单个文件)。
9. 而像x = 3这样赋值语句定义了一个局部作用域(范围仅限于函数内部)。
10. """

复制代码

global关键字

函数中修改不了全局作用域的变量如需修改，加global关键字，声明变量为全局变量

1. y = 10
2. def func():
3.     global y
4.     y = 5
5.     print('y1 =', y)
7. func()        # y1 = 5
8. print('y2 =', y)  # y2 = 5
9. """
10. 函数体中使用了global关键字，声明y为全局变量，故在函数中就改变了y的值
11. 若函数体中没有global y 语句，最后的结果就是y1 = 5，y2 = 10 4；这就跟上面的那个案例相同了
12. """

复制代码

nonlocal关键字

1. # E(enclosing)：嵌套的父级函数的局部作用域
2. def mytest1():
3.     b = 6   # 局部变量    相对而言 我们的b是函数mytest2的全局变量
4.     def mytest2():
5.         #
6.         nonlocal b  # nonlocal 关键字用于在嵌套函数内部使用变量 了解即可 用的时候比较少
7.         b = 7  # 重新开辟了内存空间  注释掉直接打印b
8.         print(b, id(b))
10.     mytest2()
11.     print(b, id(b))
13. mytest1()
14. """
15. 7 1440395648
16. 7 1440395648
17. """

复制代码

函数作用域的优先级

高阶函数

概念与调用

高阶函数：一个函数可以作为参数传给另外一个函数，或者一个函数的返回值为另外一个函数（若返回值为该函数本身，则为递归），满足其一则为高阶函数。

• 一个函数的函数名作为参数传给另外一个函数
  

1. # 频繁的使用 需要其他的功能结合使用
2. def func():
3.     print("定义一个普通函数")
5. def high_level(func):
6.     print("定义一个高阶函数")  # 此函数的功能
7.     # 在函数内部，通过传入的函数参数调用
8.     func()  # 调用我传入的函数名的函数
10. high_level(func)
11. """
12. 定义一个高阶函数
13. 定义一个普通函数
14. """

复制代码

• 一个函数返回值（return）为另外一个函数（返回为自己，则为递归）
  

1. def func():
2.     print("定义一个普通函数")
4. def high_level(func):
5.     print("定义一个高阶函数")
6.     return func  # high_level
7.     #  return func() 这个是直接返回函数调用，递归函数就是如此
9. res = high_level(func)
10. # 高阶函数返回函数之后在调用func函数
11. res()
12. """
13. 定义一个高阶函数
14. 定义一个普通函数
15. """

复制代码

递归

• 函数内部自己调用自己
  
• 必须要有出口
  

1. # 打印1-9(range)
2. def func(start, end, step=1):
3.     print(start)
4.     if start >= end:
5.         return  # 结束函数运行，停止递归
6.     func(start + step, end, step)
8. func(1, 9)

复制代码

3、内置高阶函数

1）lambda函数

• 匿名函数
  
• 优点：节省内存空间，优化代码
  

1. # lambda函数
2. # 当函数里面只有一行代码时，可以转换为匿名函数
3. # 实际中，只使用一次，不需要考虑函数的名字，只需要功能
4. # lambda 传入的参数：返回的数据
5. def add(a, b):
6.     return a + b
8. print(add(1, 2))
10. print((lambda a, b: a + b)(1, 2))
11. add1 = (lambda a, b: a + b)  # 定义名字，重复使用
13. print(add1(2, 2))
14. print(add1(2, 3))

复制代码

• lamada参数实例
  

1. import random
3. # 无参数
4. sdds = lambda: random.random()
5. sdds()
7. # 一个参数
8. fun1 = lambda x: x
9. print(fun1('hello python'))
11. # 默认参数 (缺省参数)
12. fun2 = lambda a, b, c=100: a + b + c
13. print(fun2(10,19,1000))
15. # 可变参数之args
16. fun3 = lambda *args: args
17. print(fun3((1,2,3,4,5)))
19. # 可变参数之kwargs
20. fun4 = lambda  **kwargs: kwargs
21. print(fun4(name='yueyue',age=18,height='178cm'))
23. # 带判断的lambda表达式
24. asd = lambda x: x if (x > 10) else 10
25. print(asd(5))
26. #### 它是以下带有def和return 关键字的普通函数的更简单版本：
27. def fun(x):
28.     if x > 10:
29.         return x
30.     else:
31.         return 10
32. print(fun(5))

复制代码

• 列表中字典数据排序
  

1. # 列表中的字典排序
2. # 需求:假设我们需要对字典中的年龄进行排序
3. user_list = [
4.     {"name": 'zhangsan1', 'age': 18},
5.     {"name": 'lisi1', "age": 19},
6.     {"name": 'wangwu1', "age": 17}
7. ]
9. def getAge(element):
10.     return element['age']
12. # 传递给key参数的是一个函数，它指定可迭代对象中的每一个元素来按照该函数进行排序
13. user_list.sort(key=getAge,reverse=True)
14. print(user_list)
17. # 我们需要使用匿名函数，使用sort函数中的key这个参数，来指定字典比大小的方法
18. # reverse参数控制升序与降序排列
19. user_list.sort(key=lambda x:x['age'],reverse=True)
20. print(user_list)

复制代码

2）map函数

• 语法：map(function, iterable, ...)
  
• 参数：function —— 函数；iterable —— 可迭代对象
  
• 作用：通过将指定的function函数依次作用在给定序列iterable中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。
  

1. # map函数 映射
2. # 列表数据转为字符串
3. list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
4. print(list(map(lambda i: str(i), list1)))   # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
6. print(list(map(str, list1)))    # ['1', '2', '3', '4', '5', '6', '7', '8', '9']

复制代码

3）reduce函数

• reduce() 函数来自 functools 模块。使用 reduce() 函数，需要在代码开始时使用以下语句导入 functools 模块：
  

1. from functools import reduce

复制代码

关于模块（module）的知识和使用方法后续会进行深入学习。

• 作用：先从列表（或序列）中取出2个元素执行指定函数，并将输出结果与第3个元素传入函数，输出结果再与第4个元素传入函数，…，以此类推，直到列表每个元素都取完。
  

1. from functools import reduce  # 导入内置reduce函数
3. def fn(x, y):
4.     return x + y
6. res = reduce(fn, [1, 3, 5, 7, 9])
7. print(res)        # 25

复制代码

4）filter函数

• 语法：reduce(function, iterable)
  
• 参数：function —— 函数；iterable —— 可迭代对象
  
• 作用：filter函数也是接收一个函数和一个序列的高阶函数，其主要功能是过滤。
  

1. # 在一个list中，删掉偶数，只保留奇数
2. def is_odd(n):
3.     return n % 2 == 1
5. print(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))  # <filter object at 0x00000193E06AE860>
6. print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])))  # [1, 5, 9, 15]

复制代码

学员管理系统

这个建议自行去写一下，除了这个系统，还有图书馆管理系统，宿舍管理系统等，网络上都有许多教程，换汤不换药的，有需要可以联系。

来源:https://www.cnblogs.com/daguo118/p/17314962.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！