各种模块的功能

昨天过得好吗？月亮挺圆的，有没有深夜出去找有趣的灵魂啊？希望经过昨天我的粉丝还能上线，如果不能上线了，那么一首灰色头像送给这位朋友。

今天的憨憨萌有没有给自己打气啊？来吧例行打气

今日洗脑金句：你挨过梦想的现实的痛快的，耳光火辣，若是拍不碎你，等你绝境生花。

time模块

time模块是一个内置模块，作用就是来搞一些关于时间的操作。

import time

这样就调用了。

都有啥用啊？来看看

时间戳

时间戳(timestamp)：时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

time_stamp = time.time()
print(time_stamp, type(time_stamp))

1552551519.291029 <class 'float'>

我甚至不知道这功能有什么用的？你用这个来算时间吗，我觉得这个可能是用来纪念什么东西的吧，反正我看时间是看北京时间的，也不去看格林尼治。。。

格式化时间

格式化的时间字符串(format string)：格式化时间表示的是普通的字符串格式的时间。

format_time = time.strftime("%Y-%m-%d %X")
print(format_time, type(format_time))

2019-03-07 16:22:11 <class 'str'>

你可以随便自己规定格式，只要知道哪个占位符代表什么就好了，这个挺好的。

结构化时间

结构化的时间(struct time)：struct_time元组共有9个元素共九个元素，分别为(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

print('本地时区的struct_time:
{}'.format(time.localtime()))
print('UTC时区的struct_time:
{}'.format(time.gmtime()))

本地时区的struct_time:
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=16, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0)
UTC时区的struct_time:
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=8, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0)

这个功能。。。。我就不多说了吧。。。。谁爱用谁用。

# 结构化时间的基准时间
print(time.localtime(0))

只要在这个方法里加一个参数0，他就会打印1970的那个时间，。。。。我就觉得他是一个纪念什么的东西的。也是以结构化的形式输出的。

# 结构化时间的基准时间上增加一年时间
print(time.localtime(3600*24*365))

time.struct_time(tm_year=1971, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=1, tm_isdst=0)

这到底。。。。有什么用。。。

不同格式时间的转换

# 结构化时间
now_time = time.localtime()
print(now_time)

time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=16, tm_min=22, tm_sec=11, tm_wday=3, tm_yday=66, tm_isdst=0)

# 把结构化时间转换为时间戳格式
print(time.mktime(now_time))

1551946931.0

# 把结构化时间转换为格式化时间
# %Y年-%m月-%d天 %X时分秒=%H时:%M分:%S秒
print(time.strftime("%Y-%m-%d %X", now_time))

2019-03-07 16:22:11

# 把格式化时间化为结构化时间，它和strftime()是逆操作
print(time.strptime('2013-05-20 13:14:52', '%Y-%m-%d %X'))

time.struct_time(tm_year=2013, tm_mon=5, tm_mday=20, tm_hour=13, tm_min=14, tm_sec=52, tm_wday=0, tm_yday=140, tm_isdst=-1)

# 把结构化时间表示为这种形式：'Sun Jun 20 23:21:05 1993'。
print(time.asctime())

Thu Mar 7 16:22:11 2019

# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime(time.localtime()))

Thu Mar 7 16:22:11 2019

# 把一个时间戳转化为time.asctime()的形式。
print(time.ctime())

Thu Mar 7 16:22:11 2019

# 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime(time.time()))

Thu Mar 7 16:22:11 2019

。。。。。。。这些方法我是连看都不看一下的，如果你喜欢用的话。。那你一定是有什么不知名的疾病，趁早就医。

其他用法

这个才是真的常用！有用！建议用！的方法

# 推迟指定的时间运行，单位为秒
start = time.time()
time.sleep(3)
end = time.time()

print(end-start)

3.0005428791046143

这个就是用来延时的，useful！

datetime模块

datetime模块可以看成是时间加减的模块

当然开始也要import导入这个模块才能用。

# 返回当前时间
print(datetime.datetime.now())

2019-03-07 16:22:14.544130

print(datetime.date.fromtimestamp(time.time()))

2019-03-07

# 当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(3))

2019-03-10 16:22:14.560599

# 当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(-3))

2019-03-04 16:22:14.568473

# 当前时间-3小时
print(datetime.datetime.now() + datetime.timedelta(hours=3))

2019-03-07 19:22:14.575881

# 当前时间+30分钟
print(datetime.datetime.now() + datetime.timedelta(minutes=30))

2019-03-07 16:52:14.585432

# 时间替换
c_time = datetime.datetime.now()
print(c_time.replace(minute=20, hour=5, second=13))

2019-03-07 05:20:13.595493

这也是一个鸡肋模块，个人认为没吊用

random模块

上一篇博客已经讲过了，可以去看上一篇博客。

os模块

作用：os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口，多用于文件处理。（记住这句话，重点）

print(os.getcwd()) # 获取当前文件目录

os.mkdir('m2') # 创建一个文件夹

os.rmdir('m2')  # 删除文件夹

经常用到

res = os.listdir(r'D:上海Python11期视频python11期视频day 17')  # 列出所有文件
print(res)

只需要在方法内加写入路径，就可以列出所有在这个路径下的文件。

os.rename('test.py','test1.py') #修改文件的名字
os.remove('test1.py') #删除文件

print('os.path.abspath(__file__):',os.path.abspath(__file__))  # 支持不同的平台(windows,ios,andirod,linux,unix)
print('__file__:',__file__)

用来查看当前文件的的路径。

print(os.path.exists('01 包.py'))  # 文件不存在False，存在True
print(os.path.isfile('01 包.py')) # 是否为文件
print(os.path.isdir('01 包.py')) # 是否为文件夹

#支持不同的平台(windows,ios,andirod,linux,unix)
res = os.path.join(r'D:上海Python11期视频python11期视频day 17m1bb','m5.py') # 拼接文件路径
res = os.path.join(r'D:上海Python11期视频python11期视频day17m1bb','m5','test.py') # 拼接文件路径
print(r'D:上海Python11期视频python11期视频day 17m1b'+'m5.py')
print(res)

print(os.path.abspath(__file__))#绝对路径查看
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))#查看爷爷文件夹，如果去掉一个os.path.dirname()就是查看父文件

os.walk()  # 返回三个值，第一个值是路径；第二个值是路径下的文件夹，第三个值是路径下的文件

就是遍历了一遍文件夹下的内容。

sys模块

作用：用来和python解释器交互的,提供了一系列的函数和变量，用于操控python的运行时环境。 （记住这句话，重点）

print(sys.path)


print(sys.argv)  # 接收参数（用cmd执行文件时运行才有效）


print(sys.modules)

还有一些奇奇怪怪的没用的方法，我就不列出来了。因为我真的不会用到。

json模块和pickle模块

json

相信大家总是能在别的编程语言里也能接触到 json 吧，没错，json是互通的，没错没错。

为什么这么说呢。

每种编程语言都有自己的规则，都有自己规定的数据类型，那我用python写在文件里的数据你java小崽子能拿去用吗？当然不行了，所以为了解决这一问题，就有了 json ，大家都用同一种方式来存取，所以他的优点就很突出了，跨平台。

序列化：从python的字典（最常用）变成json串， dump

反序列化：从json串变成python的字典（最常用），load

import json

dic = {'a': 1, 'b': 'abc', 'c': None}
data = json.dumps(dic)  # 序列化到内存中
print(data,type(data))  # 单引号全部变成双引号
data = json.loads(data)  # 从内存中获取json串
print(data,type(data))

{"a": 1, "b": "abc", "c": null} <class 'str'>
{'a': 1, 'b': 'abc', 'c': None} <class 'dict'>

with open('test.json','w',encoding='utf8') as fw:
    json.dump(dic,fw)

with open(f'{"test"}.json','r',encoding='utf8') as fr:
    data = json.load(fr)
    print(data)

{'a': 1, 'b': 'abc', 'c': None}

他会把所有存进去数据进行规划，给你转成大家都通用的东西。自己看清楚哦。

pickle

pickle: 可以序列化python中所有对象（数据类型），但是无法跨平台，这意味着他只是python独有的东西。

python：“是老子一个人的“

dic = {'a': 1, 'b': 'abc', 'c': None}
def func():
    x = 3
    print(x)

import pickle
with open('test.pkl','wb') as fw:
    pickle.dump(func,fw)


with open('test.pkl', 'rb') as fr:
    data = pickle.load(fr)
    data()
    print(data)

3
<function func at 0x00000265FB151EA0>

注意啊，这里读写文件要用wb或者rb，是以二进制形式存储的，这意味着我们无法打开文件去看内容了。

dic = {'a': 1, 'b': 'abc', 'c': None}
# def func():
#     x = 3
#     print(x)

import pickle
# with open('test.pkl','wb') as fw:
#     pickle.dump(func,fw)


with open('test.pkl', 'rb') as fr:
    data = pickle.load(fr)
    data()
    print(data)

注意，这里的代码注释了一部分，然后运行，就报错了，为什么？

因为你存进去的时候是什么？只是一个func对象啊！就是说你打开的时候他要去找func的内容，结果是什么呢，找不到func，就报错了。

这就好比一个人被拉去坐牢了，然后出来之后回家，发现家被抄了，当然程序就炸了啊。

所以func一定得放在那里。

某不知名同学：“那如果我一定要写在那里的话，那pickle有毛用？不还是得写一遍？”

呵呵，我只能告诉你，他确实没用。。。要到了面向对象了才有用，在函数里面没用。

hashlib模块和hmac模块

hashlib模块

密码加密：无论你丢什么字符串，他都会返回一串 固定长度的字符串

import hashlib

m = hashlib.md5()  # 固定的写法
m.update(b'123456')
# m.update(b'456')
print(m.hexdigest())

e10adc3949ba59abbe56e057f20f883e

import hashlib

m = hashlib.md5()  # 固定的写法
m.update(b'123')
m.update(b'456')
print(m.hexdigest())

e10adc3949ba59abbe56e057f20f883e

睿智的你一定发现了，这个可以搞事情吧

hashlib的特性

1. 变成固定的字符串
2. 相同的字符串哈希后结果一样
3. 叠加性

hmac模块

hmac模块：对密码加密，可以加盐

import hmac

m = hmac.new(b'abc')  # 加盐
m.update(b'123456')
# m.update(b'456')
print(m.hexdigest())

8c7498982f41b93eb0ce8216b48ba21d

import hmac

m = hmac.new(b'111')  # 加盐
m.update(b'123456')
# m.update(b'456')
print(m.hexdigest())

b9b5d5f076039c718c8ddaed8a92b484

睿智的你又发现了。

new后面的参数不一样，结果就不一样。没错，那就是盐，也就是密钥，密钥的不一样，结果就不一样。一定要在密钥和密码前面加b转换成字节哦，不然就报错了。

logging模块

logging就是日志，用来记录各种信息的模块，这是唯一一个python中可以用CV大法来搞的。

所以我不搞了。上cv版本，需要用logging的直接cv这个就好了。

配置日志文件

import os
import logging.config

# 定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 
                  '[%(levelname)s][%(message)s]'  # 其中name为getLogger()指定的名字；lineno为调用日志输出函数的语句所在的代码行
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录，需要自定义文件路径 # atm
logfile_dir = os.path.join(logfile_dir, 'log')  # C:UsersoldboyDesktopatmlog

logfile_name = 'log.log'  # log文件名，需要自定义路径名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):  # C:UsersoldboyDesktopatmlog
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)  # C:UsersoldboyDesktopatmloglog.log
# 定义日志路径 结束

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},  # filter可以不定义
    'handlers': {
        # 打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M  (*****)
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置。如果''设置为固定值logger1，则下次导入必须设置成logging.getLogger('logger1')
        '': {
            # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'handlers': ['default', 'console'],
            'level': 'DEBUG',
            'propagate': False,  # 向上（更高level的logger）传递
        },
    },
}



def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态
    
    return logger


if __name__ == '__main__':
    load_my_logging_cfg()

使用日志

import time
import logging
import my_logging  # 导入自定义的logging配置

logger = logging.getLogger(__name__)  # 生成logger实例


def demo():
    logger.debug("start range... time:{}".format(time.time()))
    logger.info("中文测试开始。。。")
    for i in range(10):
        logger.debug("i:{}".format(i))
        time.sleep(0.2)
    else:
        logger.debug("over range... time:{}".format(time.time()))
    logger.info("中文测试结束。。。")


if __name__ == "__main__":
    my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
    demo()

好了结束了，我真希望所有python的东西都是可以cv的，这样真的就很轻松，天气仿佛都会凉一点，那时候我就要称呼python为凉轻松！