第四周总结

第四周总结

本周内容概要

• 可变长实参
• 名称空间
• global与nonlocal关键字
• 闭包函数
• 装饰器
• 递归函数
• 算法之二分法
• 三元表达式
• 生成式
• 匿名函数
• 内置函数

可变长实参

可变长实参：指的是在调用函数时，传入的参数个数可以不固定
args输出：元组
可变长实参kwargs类型：字典
kwargs输出：字典
命名关键字参数：
	格式：func(a,b,c,*args,d=数据,**kwargs)

名称空间

定义：就是用来存放变量名与数据值之间绑定关系的地方
分类：
	1.内置名称空间：
		系统内置的方法名，变量，函数名，类名等存储的空间，我们不能操纵，python解释器运行时该空间自动创建，解释器关闭则清空。
	2.全局名称空间：
		py文件运行代码过程中产生的变量名，函数名，类名都会存入该空间，py文件运行结束清空。
	3.局部名称空间：
		函数体代码运行过程中产生的名字都会存入该空间，函数体代码运行结束清空。
作用域：
	1.内置名称空间
		在程序任意位置都可以使用(全局有效)
	2.全局名称空间
		在程序任意位置都可以使用(全局有效)
	3.局部名称空间
		在各自的局部空间可以使用(局部有效)

global与nonlocal关键字

global:将局部不可变类型的变量名变为全局变量名
nonlocal：嵌套局部下，将本层变量名变为外层变量名

闭包函数

定义：
	1.定义在函数内部的函数
	2.内部函数使用了外部函数名称空间的名字
例子：
	def func(username):
    # username = 'jason'
    def index():
        print(username)
    return index

装饰器

本质：在不改变被装饰对象原来的'调用方式'和'内部代码'的情况下给被装饰对象添加新的功能
原则：对修改封闭 对扩展开放
固定模板：
	from functools import wraps
    def outer(func_name):
        @wraps(func_name)  
        def inner(*args, **kwargs):
            print('执行被装饰对象之前可以做的额外操作')
            res = func_name(*args, **kwargs)
            print('执行被装饰对象之后可以做的额外操作')
            return res
        return inner
多层装饰器：
	谁离函数近 先装饰谁
	本质：套娃
有参装饰器：
	定义：为了能实现传参，在装饰器外再闭包一次

递归函数

定义：会直接或者间接调动自己的函数
python中允许函数最大递归调用的次数（官方：1000）
补充：
	1.getrecursionlimit()：获取函数最大递归调用的次数
	2.sys.setrecursionlimit()：设置函数最大递归调用的次数

算法之二分法

算法：算法就是解决问题的方法
二分法：不断的一分为二，缩减查找范围
缺点：
	1.数据集必须是有序的
	2.查找的数如果在开头或者结尾 那么二分法效率更低

三元表达式

语法结构：
	值1 if 条件 else 值2
优点：
	· 精简代码
缺点：
	· 仅限于二选一的境况
	· 不建议使用嵌套，可读性不强

生成式

生成式：用一行代码通过python快速生成某种数据类型
1.列表生成式
	格式：
		list[out_data for 循环 if 语句]
	举例：
		list[out_data for 循环  for 循环 if 语句]
	翻译：
		for 循环：
			for 循环：
                if 语句：
                    list.append(out_data)
                    
	注意：列表生成式里面只能有for和if

2.字典生成式
	格式：
		dict{生成内容 for循环 if判断}

3.集合生成式
	格式：
		set{生成内容 for循环 if判断}

匿名函数

定义：匿名函数就是没有函数名的函数
结构：
	lambda 形参: 返回值
应用场景：
	匿名函数通常都需要配合其他函数一起使用 用于减少代码

重要内置函数

1.min()：最小值
2.max()：最大值
3.map()：映射
	结构：map(func,item)
	理解：将item的每个元素传入func作为实参，运行函数并返回成迭代器
	列子：
		1.转换类型：
			l = [1, 2, 3, 4, 5]
			print(list(map(str,l)))
	"输出"：  ['1', '2', '3', '4', '5']
		2.调用有名函数：	# 调用函数时不用加（）
            def cal(x):
                return x**2
            l = [1, 2, 3, 4, 5]
            print(list(map(cal, l)))
	"输出"：  [1, 4, 9, 16, 25]
		3.用匿名函数：
            l = [1, 2, 3, 4, 5]
            print(list(map(lambda x: x**2, l)))	
	"输出"：  [1, 4, 9, 16, 25]
4.filter()：过滤
	结构：filter(func,item)
	理解：将item的每个元素传入func作为实参，运行函数并返回True的数据，然后组成一个迭代器。
	用法：与map相似
5.reduce()：求和
	结构：reduce(func,item，initiate)
	理解：将item参数传入func，以initiate为初始值调用方法 #主要做参数合并
	例子：
		result = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 
		print(result) 
	思路讲解：((((1+2)+3)+4)+5)
6.sum()：求和
7.zip()：打包
	不好解释直接上代码
	例子：
        a = [1,2,3]
        b = [4,5,6]
        c = [4,5,6,7,8]

        zipped = zip(a,b) # 打包为元组的列表
        # 输出：[(1, 4), (2, 5), (3, 6)]

        zip(a,c) # 元素个数与最短的列表一致
        # 输出：[(1, 4), (2, 5), (3, 6)]

        zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
        [(1, 2, 3), (4, 5, 6)]