飞天使-python的模块与包与装饰器

模块与包

标准模块

import os
print(os.getcwd())

import sys
print(sys.argv)
print(sys.platform)
print(sys.path)

import time

print(time.localtime())

print("开始")
time.sleep(5)
print("结束")

start=time.time()
for i in range(10000):
    i+=1
end = time.time()
print(end - start)



import time
print(time.time())    #返回当前时间的时间戳（1970年后经过的浮点秒数）。
print(time.localtime())
time.sleep(3)
print(time.time())

# struct_time元组共有9个元素：
# 0  tm_year（年）    
# 1  tm_mon（月）
# 2  tm_mday（日）
# 3  tm_hour（时）
# 4  tm_min（分）
# 5  tm_sec（秒）
# 6  tm_wday（weekday），0是周一，以此类推
# 7  tm_yday（一年中的第几天）
# 8  tm_isdst（是否是夏令时），0非夏令时、1夏令时、-1不确定是否是

输出结果:
开始
结束
0.0023679733276367188
1693381095.814861
time.struct_time(tm_year=2023, tm_mon=8, tm_mday=30, tm_hour=15, tm_min=38, tm_sec=15, tm_wday=2, tm_yday=242, tm_isdst=0)
1693381098.815426


import math
print(math.pi)
print(math.cos(3.14))


random  随机数
整数
randrange(start,stop[,step])
randint(a,b)



import random
print(random.randrange(1,20,7))   #1,8,15

print(random.randint(1,100))  #[1,100]范围，而不是[1,100)

for i in range(1,1000):
    print(random.randint(1,100))






序列
choice(seq)
shuffle(x)
sample
random()
uniform(a,b)
等等，这些要有使用场景在回来看



# search(pattern,string)	在字符串中寻找模式
# match(pattern,string)　　	在字符串开始处匹配模式
# split(pattern,string)	根据模式分割字符串
# findall(pattern,string)	列表形式返回匹配项
# compile(pattern)	创建模式对象

import re
x="李立宗的Python课程，在CSDN的课程"
print(re.search("，",x))
print(re.match("李立宗",x))
print(re.split("，",x))
print(re.findall("[nN]",x))

r=re.compile("[0-9]")
x="今天是2021年6月23日"
print(r.match(x))
print(r.search(x))
print(r.findall(x))

r=re.compile("：")
x="今天是：2021年6月23日"
print(r.split(x))

r=re.compile("[0-9]")
x="我买了6斤土豆，8斤黄瓜"
print(r.split(x))








import re
a="it's a very good lesson"

x=re.split(" ",a)
print(a)
print(x)

# re.match 尝试从字符串的起始位置匹配一个模式，
# 如果在起始位置匹配不成功，match()返回none。

x=re.match("李立宗","李立宗的Python入门")
print(x)
print(x.span())
x=re.match("入门","李立宗的Python入门")
print(x)


r=re.compile("[0-9]")
print(re.match(r,"lilizong"))
print(re.match(r,"13602153866"))
print(r.match("lilizong"))
print(r.match("13602153866"))
print(r.match("我买了6斤土豆，花了8块钱"))
print(r.search("我买了6斤土豆，花了8块钱"))
print(r.findall("我买了6斤土豆，花了8块钱"))
print(r.split("我买了6斤土豆，花了8块钱"))

第三方模块

查看版本 pip --version
看看安装了哪些包 pip list
安装指定的包 pip install numpy
安装指定的包 pip install numpy==1.19.3
升级到指定的版本 pip install --upgrade numpy 
卸载包 pip uninstall 包名

自定义模块

__name__ 的使用



from 和 import 的使用


参考下面截图

高级语法

切片

迭代器/生成器

列表、元组、集合、字典、字符串等对象被称为可迭代对象。

高级模式（闭包）

一个稳定的输出

高级模式（装饰器）

这个概念在其他的语言里面没有，相对难理解
最简单的装饰器
#在计算加减乘除前，先输出一个分隔线（=====）
#方案1：单独定义一个函数show，用于输出横线
#每次调用运算函数前，先调用函数show

def myAdd(a,b):
    return a+b

def mySubstract(a,b):
    return a-b

def myMultiply(a,b):
    return a*b

def myDivide(a,b):
    return a/b

def show():
    print("=====开始=======")

show()
print(myAdd(3,4))
show()
print(mySubstract(3,4))
show()
print(myMultiply(3,4))
show()
print(myDivide(3,4))

输出结果
=====开始=======
7
=====开始=======
-1
=====开始=======
12
=====开始=======
0.75




正版装饰器
#在计算加减乘除前，先输出一个分隔线（=====）
#方案4：使用修饰器完成
# 修饰器，既可以有返回值、也可以没有返回值，他的样式是多种多样的。
# 实现方式: 实际函数名=修饰器函数名(实际函数名)

def show(function):
    def temp(x,y):
        print("===========")
        z=function(x,y)
        return z
    return temp



def myAdd(a,b):
    return a+b


def mySubstract(a,b):
    return a-b

def myMultiply(a,b):
    return a*b

def myDivide(a,b):
    return a/b

myAdd=show(myAdd)
print(myAdd(3,4))
mySubstract=show(mySubstract)
print(mySubstract(3,4))
myMultiply=show(myMultiply)
print(myMultiply(3,4))
myDivide=show(myDivide)
print(myDivide(3,4))



升级一版本
#在计算加减乘除前，先输出一个分隔线（=====）
#方案5：使用修饰器语法糖：@修饰器
# 修饰器，既可以有返回值、也可以没有返回值，他的样式是多种多样的。
# 实现方式: @修饰器函数名        
# 等价于： 实际函数名=修饰器函数名(实际函数名)
# 注意点：位置：实际函数前



def show(function):
    def temp(x,y):
        print("===========")
        z=function(x,y)
        return z
    return temp


@show
def myAdd(a,b):
    return a+b

@show
def mySubstract(a,b):
    return a-b

@show
def myMultiply(a,b):
    return a*b

@show
def myDivide(a,b):
    return a/b


print(myAdd(3,4))
print(mySubstract(3,4))
print(myMultiply(3,4))
print(myDivide(3,4))




使用 funx(*args, **kwargs):


# 上述过程中，参数的个数是固定的
# 改进：能够适应不同的格式的参数

# args，arguments：收集所有位置参数
# kwargs,keyword args：关键字参数（字典等)
def funx(*args, **kwargs):
    print(args,kwargs)


funx(1)
funx(6,李立宗=13602153866)
funx(6,7,87,刘能=99,李立宗=100)
funx(刘能=99,李立宗=100)

funx(刘能=99,李立宗=100)

# args，arguments：收集所有位置参数
# kwargs,keyword args：关键字参数（字典等)






最后一版
#在计算加减乘除前，先输出一个分隔线（=====）
#方案6：使用修饰器完成
# 修饰器，既可以有返回值、也可以没有返回值，他的样式是多种多样的。
# 不同格式的参数，2个或3个，
# 当然，参数个数、类型都是可以多样的
def zhuangshiqi(function):
    def wrapper(*args,**kwargs):
        print("============")
        x=function(*args,**kwargs)
        return x
    return wrapper

@zhuangshiqi
def jiafa(a,b):
    return a+b
@zhuangshiqi
def jiafa3(a,b,c):
    return a+b+c
@zhuangshiqi
def jianfa(a,b):
    return a-b
@zhuangshiqi
def chengfa(a,b):
    return a*b
@zhuangshiqi
def chufa(a,b):
    return a/b

print(jiafa(3,5))
print(jiafa3(4,5,6))
print(jianfa(4,5))
print(chengfa(5,6))
print(chufa(4,8))

参考视频

https://edu.csdn.net/learn/35464/529482?spm=3001.4143