模块2

时间模块  

random模块

os模块

sys模块

序列化模块 

time模块

import time
表示时间的几种方式
print(time.time())#数字，时间戳，在存时间，给计算机看的时候
print(time.strftime('%Y-%m-%d %H:%M:%S')) #需要打印和记录的时候用，让人看
m=time.localtime( #类似命名元组，用于计算机对时间进行计算
print(m.tm_year)
给计算机读存时间戳
print(time..time(1500000000))  #伦敦时间
print(time.localtime(1500000000))#本地时间
print(time.time())
print(time.mktime(time.localtime()))# mktime将时间转换为自1970年1月1日以来持续时间的秒数，发生错误是返回-1
gmtime()函数将日历时间timep转换为UTC时间表示的时间，它返回NULL
从结构化转成字符串
t=time.localtime()    loacaltime是将日历时间timep转换为用户指定的时间时间
print(time.strftime('%Y-%m-%d',t))strftime() #函数根据区域设置格式化本地时间/日期，函数的功能将时间格式化，或者说格式化一个时间字符串。
                                              又转成结构化时间
print(time.strptime('2017-08-08','%Y-%m-%d')) #strptime()，按照特定时间格式将字符串转换为时间类型。
print(time.ctime(time.time()))           #把时间转换成字符串 ctime把日期和时间转换为字符串
print(time.asctime(time.localtime()))     #asctime是把时间转化成ascii
t=time.localtime()       #当地时间
s=time.strftime("%B",t)#
s=time.strftime('%a %b %d %H:%M,%S,%Y',t)
print(s)
时间戳是计算机能够识别的时间；
时间字符串是人能够看懂的时间

随机数时间
random模块

import random
print(random.random())#生成0-1之间的小数
print(random.uniform(1,3))#生成1-3之间的小数
元组则是用来操作时间的
生成一个随机整数
print(random.randint(1,5))#大于等于1且小于等于5之间的整数
print(random.randint(1,100))
print(random.randrange(1,10,2))#顾头不顾尾#步长为2，输出结果随机（1,3,5,7,9）
import random
print(random.choice([1,'123',[4,5]]))  #只选择一个，并且是随机的
随机选择多个返回，返回的个数为函数的第二个参数（3）
print(random.sample([1,'123',[4,5],{7,8}],3))
打乱列表的顺序
l=[1,2,4,8,9,10]
random.shuffle(l)
print(l)
生成验证码
l=[]
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))

print('',join(l))
print(random.randint(1000,9999))

ret=random.choice([1,2,'b',3,4,5,'d',6])#只能选一个
print(ret)
ret=random.sample([1,2,'b',3,4,5,'d',6],3) #3是结果为几个，可以选多个
print(ret)
l=list(range(100))
print(l)
random.shuffle(l)
print(l)
写一个验证码要有数字字母，一共4位 可以重复
num_list=list(range(10))
new_num_list=list(map(str,num_list))
alph_l=list(range(65,90))
alph_l=[]
for i in range(65,91):
    alph=chr(i)
    alph_l.append(alph)
new_num_list.extend(alph_l)
# 拿到所有的字母
num_list.extend(alph_l)#改变原来的
print(new_num_list)
ret_l=[]
for i in range(4):

    ret_l.append(random.choice(new_num_list))

# ret=random.sample(new_num_list,4)
print(''.join(ret_l))

# num_lst=list(range(10))
# new_num_l=list(map(str,num_lst))
# alph_l=[]
# for i in range(65,91):
#     alph=chr(i)
#     alph_l.append(alph)
#     new_num_l.extend(alph_l)
#     print(new_num_l)
#     ret_l=[]
#     for i in range(4):
#         ret_l.append(random.choice(new_num_l))
#     print(''.join(ret_l))
方法二
def func():
    s=''
    for i in range(4):
        s+=random.choice([chr(i)for i in range(65,117)]+[str(i) for i in range(0,10)])
    return s
print(func())
方法三
from random import choice,randint
l=[choice((chr(randint(65,90)),chr(randint(97,112)),str(randint(0,9))))for i in range(4)]
print(''.join(l))


sys模块

sys模块是与python解释器交互的一个接口
import sys
name=sys.argv[1]
password=sys.argv[2]
if name=='lan'and password=='123':
    print("go on")   #权限控制
else:
    exit()
sys.exit(n)#退出程序，正常退出是exit(0)
print(sys.version)#获取python解释程序版本信息
print(sys.maxsize)#最大的Int值
print(sys.path)#返回模块的搜素路径，初始化时使用PYTHONPATH环境变量
print(sys.path.clear())
print(sys.platform) #返回操作系统




os模块

import os
print(os.getcwd())#获取当前目录
# a = os.getcwd()
os.chdir('E:Python所有代码w1')#改变当前目录，括号里是我想要改变成的东西
print(os.getcwd())
os.chdir(a) #比如我写了一个很大的程序，但是我又想返回到我想要去的地方，这个时候用这一句，给开始的
              #目录赋值，直接调用，简洁方便
print(os.getcwd())
print(os.pardir)#获取当前目录的父目录字符串名
print(os.makedirs('f1/f2/f3'))#可生成多层递归目录
print(os.removedirs('f1/f2/f4'))#若目录为空则删除，并且递归到上一层目录，如若也为空，删除，以此类推
print(os.mkdir('s1'))#生成单级目录
print(os.rmdir('s1'))#删除单级目录
print(os.listdir('E:Python所有代码day13装饰器1')) #列出指定目录下的所有文件和目录，包括隐藏文件，并以列表的方式打印
os.remove('E:Python所有代码day4 if whiles2.py')#删除指定文件
os.rename('E:Python所有代码day4 if while','E:Python所有代码w1')#重命名文件
os.stat('E:Python所有代码day4 if whiles1.py')
print(os.sep)#输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
print(os.linesep)#输出当前平台使用的终止符，win下"	
",Linux下为"
"
print(os.pathsep)#输出用于分割文件路径的字符串，win下";",Linux下为":"
print(os.name)#输出字符串指示当前使用平台，win下"nt",Linux下为"posix"
print(os.system("bash command"))#运行shell命令，直接显示
print(os.popen("bash command"))#运行shell命令，获取执行结果
print(os.environ)#获取系统环境变量

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

序列化模块
序列化：将列表、字典的内容转换成字符串的过程
eval用来做执行  不安全性
序列化目的
1.以某种存储形式使自定义对象持久化；
2.将对象从一个地方传到另一个地方；
3.使程序更具维护性。

json提供的四个功能
loads dumps load dump
import json

loads dumps

dic={'k1':'v1','k2':'v2','k3':'v3'}
str_dic=json.dumps(dic) #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)
执行结果：<class 'str'> {"k1": "v1", "k2": "v2", "k3": "v3"}
dic2=json.loads(str_dic)#反序列化，将字符串格式的字典转换成字典
print(type(str_dic),str_dic)
list_dic=[1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic=json.dumps(list_dic)
print(type(str_dic),str_dic)
list_dic2=json.loads(str_dic)
print(type(list_dic2),list_dic2)

load dump
import json
f=open('json_file','w')
dic={'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f=open('json_file')
dic2=json.load(f)#load方法接收一个文件句柄，直接将json字符串转成数据结构返回
f.close()
print(type(dic2),dic2)

import json  不支持元组
ret_s=json.dumps(d)#将列表、字典的内容转换成字符串
print(ret_s,type(ret_s))
ret_d=json.loads(ret_s)
print(ret_d,type(ret_d))

dumps结构化的数据类型转字符串
loads 字符串转结构化数据类型  结构化数据类型的所有字符串必须是双引号


pickle

pickle   用于python特有的类型和python的数据类型间进行转换
pickle模块提供四个功能
dumps dump(序列化、存)、
loads(反序列化、读)、load（不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
import  pickle
dic={'k1':'v1','k2':'v2','k3':'v3'}
str_dic=pickle.dumps(dic)
print(str_dic)

dic2=pickle.loads(str_dic)
print(dic2)

import time
struct_time=time.localtime(100000000)
print(struct_time)
f=open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()
f=open('pickle_file','rb')
struct_time2=pickle.load(f)
print(struct_time.tm_year)


shelve
python提供给我们的序列化工具
shelve只提供给我们一个open方法是用key来访问的，使用起来和字典类似
import shelve
f=shelve.open('shelve_file')
f['key']={'int':10,'float':9.5,'string':'Sample data'}#直接文件句柄操作，就可以存入数据
f.close()

import shelve
f1=shelve.open('shelve_file')
existing=f1['key']
f.close()
print(existing)

shelve只读操作
import shelve
f=shelve.open('shelve_file',flag='r')
existing=f['key']
f.close()
print(existing)

设置writeback
import shelve
f1=shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value']='this was not here before'
f1.close()

f2=shelve.open('shelve_file',writeback=True)
print(f2['key'])
f2['key']['new_value']='this was not here before'
f2.close()