常用模块

一. time模块

# 字符串数据类型    (格式化时间)-给人看的
# 2018-08-20 16:42:53

# 结构化时间(共有9个元素)
# (tm_year=2018, tm_mon=8, tm_mday=20, tm_hour=16, tm_min=42, tm_sec=53, tm_wday=0, tm_yday=232, tm_isdst=0)
# (年, 月, 日, 时, 分, 秒, 一周的第几天(0-6,0表示周一), 一年中的第几天, 夏令时(默认0))

# 浮点型数据类型,以秒(S)为单位  (时间戳时间)-给机器计算用的
# 时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
# 1534754573.2385244

import tim
-----------我们先以当前时间为准,让大家快速认识三种形式的时间
print(time.time()) # 时间戳:1534754573.2385244
print(time.strftime("%Y-%m-%d %X"))  # 结构化时间:2018-08-20 16:42:53
 
print(time.localtime())  #本地时区的struct_time
print(time.gmtime())    #UTC时区的struct_time

===================================几种格式之间的转换======================================

时间戳换成字符串时间
struct_time = time.localtime(1534754573.2385244)
print(struct_time)                       # 北京时间
print(time.gmtime(1534754573.2385244))   # 伦敦时间
ret = time.strftime('%Y-%m-%d %H:%M:%S',struct_time)
print(ret)



结果:
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20, tm_hour=16, tm_min=42, tm_sec=53, tm_wday=0, tm_yday=232, tm_isdst=0)
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20, tm_hour=8, tm_min=42, tm_sec=53, tm_wday=0, tm_yday=232, tm_isdst=0)
2018-08-20 16:42:53

字符串时间转成时间戳
struct_time = time.strptime('2018-08-20 16:42:53','%Y-%m-%d %H:%M:%S')
ret = time.mktime(struct_time)
print(ret)

结果:
1534754573.0

2018-8-19 22:10:8   2018-8-20 11:07:3
经过了多少时分秒

true_time = time.mktime(time.strptime('2018-8-19 22:10:8', '%Y-%m-%d %H:%M:%S'))
time_now = time.mktime(time.strptime('2018-8-20 11:07:3', '%Y-%m-%d %H:%M:%S'))
dif_time = time_now - true_time
struct_time = time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒' % (struct_time.tm_year - 1970, struct_time.tm_mon - 1,
                                   struct_time.tm_mday - 1, struct_time.tm_hour,
                                   struct_time.tm_min, struct_time.tm_sec))

str_time1 = '2018-8-19 22:10:8'
str_time2 = '2018-8-20 11:07:3'
struct_t1 = time.strptime(str_time1,'%Y-%m-%d %H:%M:%S')   # 转成结构化时间
struct_t2 = time.strptime(str_time2,'%Y-%m-%d %H:%M:%S')
timestamp1 = time.mktime(struct_t1)    # 转成时间戳时间
timestamp2 = time.mktime(struct_t2)
sub_time = timestamp2 - timestamp1    # 计算差
gm_time = time.gmtime(sub_time)  # 把差值转成伦敦时间
# 1970-1-1 00:00:00
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(gm_time.tm_year-1970,gm_time.tm_mon-1,
                                 gm_time.tm_mday-1,gm_time.tm_hour,
                                 gm_time.tm_min,gm_time.tm_sec))

import datetime

print(datetime.datetime.now())  # 返回 2016-08-19 12:47:03.941925
print(datetime.date.fromtimestamp(time.time()))  # 时间戳直接转成日期格式 2016-08-19
print(datetime.datetime.now() + datetime.timedelta(3))  # 当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(-3))  # 当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3))  # 当前时间+3小时
print(datetime.datetime.now() + datetime.timedelta(minutes=30))  # 当前时间+30分


c_time = datetime.datetime.now()
print(c_time.replace(minute=3, hour=2))  # 时间替换

二.random模块

import random

取随机小数
print(random.random())  # 取0-1之间的小数
print(random.uniform(1, 2))  # 取一个范围内的小数

取随机整数
print(random.randint(1, 2))  # 取范围内的一个整数(可顾头顾尾)
print(random.randrange(1, 5))  # 取范围内的一个整数(不顾尾)不会取末尾数
print(random.randrange(1, 100, 2))  # 可以给范围内加一个步长参数,1-100的奇数随机取

从一个列表中随机抽取
lst = ['a', 'b', 'c', (1, 2, 3), 456]
print(random.choice(lst))  # 从列表中随机返回一个元素
print(random.sample(lst, 2))  # 从列表中随机返回多个,返回的个数为函数的第二个参数(返回的是列表)

打乱列表的顺序, 在原列表的基础上直接进行修改,节省空间
lst = ['a', 'b', 'c', (1, 2, 3), 456]
random.shuffle(lst)
print(lst)

def code(n=6):
    s = ''
    for i in range(n):
        num = str(random.randint(0, 9))
        alpha_upper = chr(random.randint(65, 90))
        alpha_lower = chr(random.randint(97, 122))
        ret = random.choice((num, alpha_upper, alpha_lower))
        s += ret
    return s


print(code())

三.os模块

os模块是与操作系统交互的一个接口

os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息

os.system("bash command") 运行shell命令，直接显示
os.popen("bash command).read() 运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd

os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小(字节)

def func(path):
    size_sum = 0
    name_lst = os.listdir(path)
    for name in name_lst:
        path_abs = os.path.join(path,name)
        if os.path.isdir(path_abs):   # 判断是否是一个文件夹
            size = func(path_abs)
            size_sum += size
        else:
            size_sum += os.path.getsize(path_abs)
    return size_sum
ret = func(r'文件夹的路径')
print(ret)

四.序列化模块

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化

　　dumps  序列化.   把对象转化成bytes
　　loads  反序列化. 把bytes转化成对象
　　dump   序列化.   把对象转化成bytes并写入文件
　　load   反序列化. 把文件中的bytes读取,并转化成对象

import pickle

class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def catchMouse(self):
        print(self.name, self.age, '抓老鼠')

c = Cat('Jerry',18)

# dumps   把对象转化成bytes   序列化
bs = pickle.dumps(c)
print(bs)
# b'x80x03c__main__
Cat
qx00)x81qx01}qx02(Xx04x00x00x00nameqx03Xx05x00x00x00Jerryqx04Xx03x00x00x00ageqx05Kx12ub.'

# 把bytes转回对象 反序列化
cc = pickle.loads(bs)
cc.catchMouse()

dic = {'a':'钢铁侠','b':'蝙蝠侠','c':'煎饼侠'}
bs = pickle.dumps(dic)
print(bs)
# b'x80x03}qx00(Xx01x00x00x00aqx01X	x00x00x00xe9x92xa2xe9x93x81xe4xbexa0qx02Xx01x00x00x00bqx03X	x00x00x00xe8x9dx99xe8x9dxa0xe4xbexa0qx04Xx01x00x00x00cqx05X	x00x00x00xe7x85x8exe9xa5xbcxe4xbexa0qx06u.'
dd = pickle.loads(bs)
print(dd)
# {'a': '钢铁侠', 'b': '蝙蝠侠', 'c': '煎饼侠'}



class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def catchMouse(self):
        print(self.name, self.age, '抓老鼠')

c = Cat('Jerry',18)

f = open('pickle_test',mode='wb')
pickle.dump(c,f)    # 写入文件中的内容是看不了的
f.close()

f = open('pickle_test',mode='rb')
cc = pickle.load(f)
cc.catchMouse()
# Jerry 18 抓老鼠

lst = [Cat("猫1", 50), Cat("猫2", 40), Cat("猫3", 30), Cat("猫4", 20), Cat("猫5", 10)]
f = open('pickle_test',mode='wb')
pickle.dump(lst,f)


f = open('pickle_test',mode='rb')
cc = pickle.load(f)
for el in cc:
    el.catchMouse()
# 猫1 50 抓老鼠
# 猫2 40 抓老鼠
# 猫3 30 抓老鼠
# 猫4 20 抓老鼠
# 猫5 10 抓老鼠

# 也可以用for循环
f = open('pickle_test',mode='wb')
for el in lst:
    pickle.dump(el,f)
f.flush()
f.close()
f = open('pickle_test',mode='rb')
while True:
    try:
        c = pickle.load(f)
        c.catchMouse()
    except EOFError:
        break
# 猫1 50 抓老鼠
# 猫2 40 抓老鼠
# 猫3 30 抓老鼠
# 猫4 20 抓老鼠
# 猫5 10 抓老鼠

import json

dic = {'a':'李茶的姑妈','b':'找到你','c':'看不见的客人'}
s = json.dumps(dic)
print(s,type(s))
# {"a": "u674eu8336u7684u59d1u5988", "b": "u627eu5230u4f60", "c": "u770bu4e0du89c1u7684u5ba2u4eba"} <class 'str'>
# 如果key或value超出了ascii码表的范畴,就会显示成uxxx

ss = json.dumps(dic,ensure_ascii=False)  # ensure_ascii = False 会干掉ascii码
print(ss,type(ss))
# {"a": "李茶的姑妈", "b": "找到你", "c": "看不见的客人"} <class 'str'>


# 把字符串解析成 字典
dic = json.loads(ss)
print(dic,type(dic))
# {'a': '李茶的姑妈', 'b': '找到你', 'c': '看不见的客人'} <class 'dict'>

# 写入
f = open("电影.json", mode="w", encoding="utf-8")
json.dump(dic, f, ensure_ascii=False)   # 把json写入到文件中
f.close()

# 读出
f = open("电影.json", mode="r", encoding="utf-8")
s = json.load(f) # 把文件中的json串。读取成字典
print(s, type(s))
# {'a': '李茶的姑妈', 'b': '找到你', 'c': '看不见的客人'} <class 'dict'>


lst = [{"a": "胡辣汤"},{"b":"吱吱冒油的大猪蹄子"},{"c": "盖浇饭"},{"d":"马拉"},{"e":"法国大蜗牛"}]
f= open('menu.json',mode='w',encoding='utf-8')
for el in lst:
    json.dump(el,f,ensure_ascii=False)
f.close()
f = open('menu.json',mode='r',encoding='utf-8')
print(json.load(f))
# 总结:以上方法读取的时候会报错
# 写入文件的时候,直接一行写入,读取的时候无法分辨写入几个字典

# 解决方案
# 写入的时候
#     1.循环
#     2.用dumps把字典转化成字符串,然后手动在湖面加一个

#     3.写出
lst = [{"a": "胡辣汤"}, {"b": "吱吱冒油的大猪蹄子"}, {"c": "盖浇饭"}, {"d": "马拉"}, {"e": "法国大蜗牛"}]
f = open('new_menu.json', mode='w', encoding='utf-8')
for el in lst:
    s = json.dumps(el,ensure_ascii=False)+'
'
    f.write(s)

# 读取的时候
#     1.循环
#     2.strip() 去掉换行
#     3. loads() 变成字典

f = open('new_menu.json',mode='r',encoding='utf-8')
for line in f:
    line = line.strip()
    dic = json.loads(line)
    print(dic)
# {'a': '胡辣汤'}
# {'b': '吱吱冒油的大猪蹄子'}
# {'c': '盖浇饭'}
# {'d': '马拉'}
# {'e': '法国大蜗牛'}