Python学习-----Day09

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

#导入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

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回数字的下入整数，如math.floor(11.3)返回 11                                        math.floor(-11.6)返回 -12
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
fabs(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。如math.pow(2,3)表示2的3次方，返回8
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

九、OS模块

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

方法	描述
os.chdir(path)	改变当前工作目录
os.getcwd()	获取当前工作路径
os.chmod(path, mode)	更改权限
os.chdir()	切换工作路径
os.mkdir()	创建一个新的文件价夹，不能创建多级的文件夹
os.makedirs()	创建多级目录
os.rmdir()	删除空文件夹
s.remove()	删除文件
os.rename(src, dst)	src 原路径，dst修改后的命名 只能重命名原路径 src 最后的路径或文件的名字，中间路径都必须要存在，否则就会抛出FileNotFoundError # 将文件名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.curdir()	返回当前目录: ('.')
os.listdir()	列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.sep	输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.environ	获取系统环境变量
os.getpid()	获取当前进程编号
os.getppid()	获取父进程编号
os.kill()	杀死进程
os.path 模块	获取文件的属性信息
os.listdir(path)	返回指定的文件夹包含的文件或文件夹的名字的列表

十、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的大小