一、利用装饰器来获取函数运行的时间、

#导入time模块
import timedef decorated(fn):def inner():#time.time获取函数执行的时间a = time.time()  # func开始的时间fn()b = time.time()  # func结束的时间print(f"{fn.__name__}程序运行的总数时间:{b - a}秒")return inner@decorated
def func():time.sleep(2)       #使程序睡眠2秒钟后在执行print("王者荣耀")func()

二、装饰器

了解：

*args         理解成传入一个元组
**kwargs      理解成传入一个字典

def guanjia(fun):def inner(*args, **kwargs):  # 可变参数    *args接过来是元组   **kwargs 接过来是字典print("123")ret = fun(*args, **kwargs)  # 解包拆包print("456")return retreturn inner@guanjia
def play1(uname, pwd):print("静安寺大家")print(f"用户{uname},密码是{pwd}")return "你真6"@guanjia
def play2(uname, pwd, area):print("案说法")print(f"用户{uname},密码是{pwd},地区是{area}")return "哈哈哈"a = play1("zs", "123456")
print(a)
print()
b = play2("zjj", "123456", "suqian")
print(b)

在这段代码中，*args和**kwargs允许函数接受任意数量的位置参数和关键字参数。*args将传入的位置参数打包成一个元组，**kwargs将传入的关键字参数打包成一个字典。

在inner函数中，使用*args和**kwargs来接收传入的参数，并调用原始函数fun时使用解包拆包的方式将这些参数传递给原始函数。

这样做的好处是，guanjia装饰器可以适用于任意数量和类型的参数的函数，而无需提前知道函数的参数个数和名称。

三、多个装饰器的执行顺序

函数外包裹函数的目的是为了向内部函数wrapper传参。
最终都是将原函数func_test换成wrapper函数。

装饰器的加载顺序从下到上。
装饰器的执行顺序从上到下

# 3. func1指向的是原函数wrapper2的内存地址
def deco1(func1):print('deco1 start')def wrapper1(*args, **kwargs):print('wrapper1 start')res = func1()  # 4 func1是wrapper2print('wrapper1 stop')return resprint('deco1 stop')return wrapper1# 2. func2指向的是原函数wrapper3的内存地址
def deco2(func2):print('deco2 start')def wrapper2(*args, **kwargs):print('wrapper2 start')res = func2()  # 5 func2是wrapper3print('wrapper2 stop')return resprint('deco2 stop')return wrapper2# 1. func3指向的是原函数func_test的内存地址
def deco3(func3):  print('deco3 start')def wrapper3(*args, **kwargs):print('wrapper3 start')res = func3()  # 6 func3是原函数func_testprint('wrapper3 stop')return resprint('deco3 stop')return wrapper3# 装饰器的加载顺序从下到上。
@deco1  
# func_test = deco1(func_test) 
# => func_test = deco1(wrapper2)  
# => func_test = wrapper1@deco2  
# func_test = deco2(func_test) 
# => func_test = deco2(wrapper3)
# => func_test = wrapper2 @deco3  
# func_test = deco3(func_test) 
# => func_test = wrapper3
def func_test():print('func_test')# 装饰器的执行顺序从上到下。
func_test()
'''
deco3 start
deco3 stop
deco2 start
deco2 stop
deco1 start
deco1 stop
wrapper1 start
wrapper2 start
wrapper3 start
func_test
wrapper3 stop
wrapper2 stop
wrapper1 stop
'''

四、高阶函数

什么是高阶函数？

• 一个函数的函数名作为参数传给另外一个函数
• 一个函数返回值（return）为另外一个函数（返回为自己，则为递归

 实例一：一个函数的函数名作为参数传给另外一个函数

def func():print("定义一个普通函数")def high_level(func):print("定义一个高阶函数")# 在函数内部，通过传入的函数参数调用func()high_level(func)
# 结果
"""
定义一个高阶函数
定义一个普通函数
"""

把一个函数名作为参数传给另外一个函数之后，就可以在高阶函数内部调用这个函数了

 实例二：一个函数返回值（return）为另外一个函数

def func():print("定义一个普通函数")def high_level(func):print("定义一个高阶函数")return func#  return func() 这个是直接返回函数调用，递归函数就是如此res = high_level(func)
# 高阶函数返回函数之后在调用func函数
res()
# 结果
"""
定义一个高阶函数
定义一个普通函数
"""

要高阶函数的返回值为函数，则必须要把函数作为参数传入

五、python内置的高阶函数 

1、map
2、filter
3、reduce：是functools模块中的函数，需要导入

 高阶函数：map

    map函数接收的是两个参数，一个是函数名，另外一个是序列，其功能是将序列中的数值作为函数的参数依次传入到函数值中执行，然后再返回到列表中。返回值是一个迭代器对象
eg:<map object at 0x00000214EEF40BA8>

def func(x):return x**2map(func, [2,3,4,5])
print(map(func, [2,3,4,5]))
print(type(map(func, [2,3,4,5])))res = map(func, [2,3,4,5])for i in res:print(i)list(map(func, [2,3,4,5]))# 结果
"""
<map object at 0x0000022C5F15CB00>
<class 'map'>
4
9
16
25
[4, 9, 16, 25]
"""

• 可以看出，只要用map函数，就可以让列表中的每一个数都完成一次对函数参数的调用，并将结果返回到一个可迭代对象中
• 可以通过 list(map()) 将map函数返回的迭代对象转化为列表

 高阶函数map一般 和 匿名函数 lambda联合使用

calc1 = lambda x:x**2
print(calc1(2))calc2 = lambda x, y : x*y
print(calc2(3, 5))print(list(map(calc1, [6,7,8,9])))
# 或   # 两者是一样的
print(list(map(lambda x, : x**2, [6,7,8,9])))print(list(map(calc2, [2,3,4,5], [6,7,8,9])))
# 或   # 两者是一样的
print(list(map(lambda x, y : x*y, [2,3,4,5], [6,7,8,9])))# 结果
"""
4
15
[36, 49, 64, 81]
[36, 49, 64, 81]
[12, 21, 32, 45]
[12, 21, 32, 45]
"""

 对于迭代器Iterator三种方式访问

• next（）
• for循环
• 变成列表

res = map(lambda x:x**3, [2,3,4])
next(res)res = map(lambda x:x**3, [2,3,4])
for i in res:print(i)res = map(lambda x:x**3, [2,3,4])
print(list(res))

高阶函数：filter

filter函数 也是接收一个函数和一个序列的高阶函数，其主要功能是过滤。其返回值也是迭代器对象，例如：<filter object at 0x000002042D25EA90>，其图示如下：

过滤
对指定的序列进行过滤，若为真，则传入数据   所有非零的数字都为真
filter(lambda x:x % 2,[1,2,3,4])
for i in a:print(i)

高阶函数：reduce

reduce函数也是一个参数为函数，另一个参数为可迭代对象 Iterable Object（eg: list列表）其返回值为一个值而不是迭代器对象，故其常用与叠加、叠乘等，图示例如下 

 reduce中的函数必须也要接收2个参数，执行时把前一个结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

from functools import reduce
def func(x, y):return x*10 + yreduce(func, [3,4,5,6])
# func(3,4) = 3*10+4 = 34
# func( func(3,4),5) = func(34, 5) = 34*10+5 = 345
# func( func( func(3,4), 5), 6) = 345*10 +6 = 3456# 结果
# 3456

各个容器的遍历

for i in list:          #列表print(i)tuple = (1,2,3,4,5,6)   #元组for i in tuple:print(i)dict = {"name": "zhangsan"    #遍历字典
}
print(dict.items())
for k, v in dict.items():  # 添加冒号(:)print(k, ":", v)

六、 模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端

import   需要引用的模块

import  support

from … import 语句 

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fibo 的 fib 函数，使用如下语句：

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

七、包、导包

包(package)的概念和结构

当一个项目中有很多个模块时，需要再进行组织。我们将功能类似的模块放到一起， 形成了“包”。本质上，“包”就是一个必须有__init__.py 的文件夹。典型结构如下：

包下面可以包含“模块(module)”，也可以再包含“子包(subpackage)”。就像文件 夹下面可以有文件，也可以有子文件夹一样。

上图中，a 是上层的包，下面有一个子包：aa。可以看到每个包里面都有__init__.py 文件。

 导入包操作和本质

上一节中的包结构，我们需要导入 module_AA.py。方式如下：

• 在使用时，必须加完整名称来引用

import a.aa.module_AA

• 在使用时，可以直接使用模块名

from a.aa import module_AA

• 在使用时，直接可以使用函数名

from a.aa.module_AA import fun_AA

• from package import item 这种语法中，item 可以是包、模块(文件)，也可以是单个函数、 类、变量。
• import item1.item2 这种语法中，item 必须是包或模块，不能是其他。

导入包的本质其实是“导入了包的__init__.py”文件。也就是说，”import pack1”意味 着执行了包 pack1 下面的__init__.py 文件。 这样，可以在__init__.py 中批量导入我们需要 的模块，而不再需要一个个导入

案例：

import random
#使用方法   对象. 方法
a = random.random()#0-1 [0,1)随机数
print(a)import  threading  as  th  #起别名
th.Thread()from threading import  Thread
Thread()from random import *
a = randm
perint(a)

 八、数学模块 math

九、OS模块

os 模块提供了非常丰富的方法用来处理文件和目录

# 将文件名b修改成文件名c
os.rename('a/b','a/c')# 文件目录：  a/c c文件夹是a文件夹的子文件夹
# 将文件c移动到和a同级目录下
os.rename('a/c','c')# 文件目录：  a/c c文件夹是a文件夹的子文件夹 
# 将文件c移动到和a同级目录下并改名为'newname'
os.rename('a/c','newname')# 文件目录: a/c/w.txt
# 将文件w.txt修改成ww.txr
os.rename('a/c/w.txt','a/c/ww.txt')
# 同样也可以移动文件并重名的方式一样，用法和移动文件并重名的方式一样

十、os.path 模块

os 模块是 Python 内置的与操作系统功能和文件系统相关的模块。该模块的子模块 os.path 是专门用于进行路径操作的模块。 常用的路径操作主要有判断目录是否存在、创建目录、删除目录和遍历目录等。

exists()方法——判断路径是否存在(准确)

exists() 方法用于判断路径(文件或目录)是否存在，如果存在则返回 True ；不存在则返回 False。如果是断开的符号链接，也返回 False

os.path.exists(path)

isdir()方法——判断是否为目录

os.path.isdir(path)

isdir() 方法用于判断指定的路径是否为目录

os.path.isfile(path)  

如果path是一个存在的文件，返回True。否则返回False path只可以是文件 

join()方法——拼接路径

join() 方法用于将两个或者多个路径拼接到一起组成一个新的路径

os.path.join(path, *paths)

参数说明：

• path：表示要拼接的文件路径。
• *paths：表示要拼接的多个文件路径，这些路径间使用逗号进行分隔。如果在要拼接的路径中，没有一个绝对路径，那么最后拼接出来的将是一个相对路径。
• 返回值：拼接后的路径。

实例：

import os.path  # 导入os.path模块print(os.path.join(r"E:\Code\lesson", "main.py"))  # 拼接字符串
# 如果要拼接的路径中，存在多个绝对路径，那么按从左到右顺序，以最后一次出现的绝对路径为准，
# 并且该路径之前的参数都将被忽略，代码如下：# C:/demo
print(os.path.join('E:/Code', 'E:/Code/lesson', 'Code', 'C:/', 'demo'))  # 拼接字符串

 abspath()方法——获取绝对路径

abspath() 方法用于返回文件或者目录的绝对路径

os.path.abspath(path)

basename()方法——从一个路径中提取文件名

 basename() 方法用于从一个路径中提取文件名。当指定的路径是一个不包括文件名的路径(如 E:\Code\lesson\) 时，返回空字符串

os.path.basename(path)

 dirname()方法——获取路径中的目录

dirname() 方法用于从一个路径中提取目录。它相当于使用 os.path.split() 方法分割路径后，得到的第一个元素

os.path.getsize(path) 返回path的大小