random,time,sys,os,序列化模块

random模块(随机数模块)

　　取随机小数:

　　　　random.random()　　取0-1之间的小数

　　　　random.uniform(x, y)　　取x-y之间的小数

　　取随机整数:

　　　　random.randint(x, y)　　取x-y之间的整数([x, y]顾头也顾尾)

　　　　random.randrange(x, y)　　取x-y之间的整数([x, y)顾头不顾尾)

　　　　random.randrange(x, y, z)　　取x-y之间的整数([x, y)顾头不顾尾,z为步长)

　　随机抽取:

　　　　random.choice(lst)　　从列表中随机抽取一个值

　　　　random.sample(lst, n)　　从列表中随机抽取n个值

　　打乱顺序:

　　　　random.shuffle(lst)　　将列表的顺序打乱

#默认6位数字字母可变长度验证码
def code(n = 6,alpha = True):
    s = ''
    for i in range(n):                           #取验证码长度
        num = str(random.randint(0, 9))          #随机抽取数字
        if alpha:
            alpha_upper = chr(random.randint(65, 90))     #通过ascii码取大写字母
            alpha_lower = chr(random.randint(97, 122))    #通过ascii码取小写字母
            num = random.choice([num, alpha_upper, alpha_lower])    #从随机生成的数字,大写字母,小写字母中随机抽取一个作为验证码的一位
        s += num        #拼接验证码
    return s
print(code(4,False))
print(code(alpha=False))
print(code(4))

time模块(时间模块)

　　时间格式:时间戳,格式化时间,结构化时间

　　时间戳(浮点型数据类型,以s为单位,计算机计算时间用): 1000000000

　　格式化时间(字符串数据类型):  1990-1-20  

　　结构化时间: time.struct_time(tm_year=2018, tm_mon=8, tm_mday=22, tm_hour=17, tm_min=9, tm_sec=45, tm_wday=2, tm_yday=234, tm_isdst=0)

　　时间戳:

print(time.time())　　#获取当前时间时间戳
结果:1534322642.617272

　　格式化时间(%Y-%m-%d %H:%M:%S):

print(time.strftime('%Y-%m-%d %H:%M:%S')) # str format time    
print(time.strftime('%y-%m-%d %H:%M:%S')) # str format time
结果:1990-08-20 17:12:10
90-08-20 17:12:10

　　结构化时间(是元组,只能读取,不能修改):

struct_time = time.localtime()  # 北京时间
print(struct_time)
print(struct_time.tm_mon)
结果:time.struct_time(tm_year=2018, tm_mon=8, tm_mday=22, tm_hour=17, tm_min=15, tm_sec=10, tm_wday=2, tm_yday=234, tm_isdst=0)
8

　　time.localtime()　　获取当地的结构化时间(在此为北京时间)

　　time.gmtime()　　  获取utc结构化时间(北京时间减去八小时)

　　time.strftime('%Y-%m-%d %H:%M:%S')　　获取格式化时间 (1990-01-20 16:20:13)

　　time.strptime('2008-8-8', '%Y-%m-%d')　　  将格式化时间转换为结构化时间

　　time.mktime(结构化时间)　　将结构化时间转换为时间戳

各种格式的时间之间的转换(时间戳与格式化时间不能直接转换)

　　时间戳-time.localtime()/time.gmtime()->结构化时间-time.strftime->格式化时间

　　时间戳<-time.mktime()-结构化时间<-time.strptime()-格式化时间

时间戳-->格式化时间

struct_time = time.localtime(time.time())      #获取结构化时间并结构化
ret = time.strftime('%y-%m-%d %H:%M:%S', struct_time)    #将结构化时间转换为格式化时间
print(ret)
结果:
08-08-20 16:20:13　　

格式化时间-->时间戳

struct_time = time.strptime('2008-8-8', '%Y-%m-%d')
res = time.mktime(struct_time)
print(res)
结果:
1218124800.0

获取当前月1号的时间戳

def get_time():
    st = time.localtime()
    st2 = time.strptime('%s-%s-1' % (st.tm_year, st.tm_mon), '%Y-%m-%d')
    return time.mktime(st2)
print(get_time())　　

计算时间差

str_time1 = '2008-8-8 20:10:8'
str_time2 = '2008-8-9 13: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)     #将时间戳转换为utc时间
# # 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))

sys模块(与python解释器交互的接口)

　sys.argv　　命令行参数list,第一个元素是程序本身路径

　sys.exit(n)　　退出程序,正常退出时exit(0),错误退出sys.exit(1)

　sys.version　　获取python解释程序的版本信息

　sys.path　　　返回模块的搜索路径,初始化时使用pythonpath环境变量的值

　sys.platform　　返回操作系统平台名称

　sys.modules　　所有被导入的模块的内存地址都存在sys.module里　

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

　对文件夹或文件进行相关操作(创建文件夹, 删除文件夹, 重命名文件, 删除文件, 获取文件信息, 获取文件目录)

os.makedirs('dir1/dir2')        #生成多层递归目录   在当前路径生成多层目录
os.mkdir('dir3')            #生成单层目录
os.mkdir('dir3/dir4')       #在已经存在的dir3文件下生成一个dir4文件
#只能删除空文件夹
os.rmdir('dir3/dir4')       #删除dir3文件下的dir4文件
os.removedirs('dir3/dir4')    #删除dir3和dir4文件
os.removedirs('dir1/dir2')    #删除dir1和dir2文件
os.stat(文件路径)                #获取文件信息
os.listdir  列出指定目录下所有文件和子目录,包括隐藏文件,并以列表方式打印
os.rename('oldname', 'newname')        #重命名文件
#system和popen都相当于运行shell命令
os.system()是执行字符串数据类型的命令行代码(运行shell命令,直接显示)
os.popen().read()也是执行字符串数据类型的命令行代码(运行shell命令,获取执行结果)
os.getcwd()  current work dir  当前工作目录(python脚本工作的目录路径)
os.chdir('dirname')    改变当前的工作目录,相当于shell下的cd
os.path.join(path1,path2)    将多个路径组合后返回
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是否存在,并返回bool值
os.path.isabs(path)    判断是否是绝对路径
os.path.isfile(path)    判断是否是文件
os.path.isdir(path)    判断是否是文件夹
os.path.getatime(path)    返回path指向的路径的最后访问时间
os.path.getmtime(path)    返回path指向的路径的最后修改时间
os.path.getsize(path)    返回path的大小

　　使用递归计算路径文件大小

import os
def file_all(file_path):
    file_size = 0
    file_lst = os.listdir(file_path)
    for file_name in file_lst:
        file = os.path.join(file_path, file_name)
        if os.path.isdir(file):
            size = file_all(file)
            file_size += size
        else:
            file_size += os.path.getsize(file)
    return file_size

　　使用循环计算路径文件大小

lst = [r'C:user123',]  
size_sum = 0
while lst:   
    path = lst.pop()      #删除列表元素,通过pop得到删除的值
    path_list = os.listdir(path)      #获取path目录下的所有文件
    for name in path_list:  
        abs_path = os.path.join(path, name)
        if os.path.isdir(abs_path):   # 文件夹的逻辑
            lst.append(abs_path)       
        else:
            size_sum += os.path.getsize(abs_path)
print(size_sum)

序列化模块(json和pickle)

json模块(一种通用的序列化格式)

　　json能够操作的数据类型十分有限(字符串,字典,列表,数字.并且字典中的键必须是字符串)

　　序列化:

　　　　json.dumps()　　其它数据类型  转换成  字符串/字节  序列化

　　　　json.dump()　　  其它数据类型  写入  文件中  序列化

　　反序列化:

　　　　json.loads()　　　字符串/字节  转换成其他数据类型  反序列化

　　　　json.load()　　　  文件中  读出  其他数据类类型  反序列化

　　区别:

　　　　dumps, loads:   　 在内存中做数据转换

　　　　dump,load:　　　  直接将数据类型写入文件,直接从文件中读出数据类型

　　　　json不支持连续的存取

pickle模块(支持python中的所有数据类型)

 　　dumps序列化的结果只能是字节,只能在python中使用,在进行文件操作的时候需要用rb和wb模式打开文件.

　　  可以多次dump和多次load

with open('pickle_file', 'rb') as f:
    while True:
        try:
            ret = pickle.load(f)
            print(ret, type(ret))
        except EOFError:
            break