Python中常用模块一

random模块

import random

# 应用数学计算
print(random.random())  # 取随机小数   范围是 0-1之间

# 应用抽奖 , 彩票
print(random.randint(1,10))  # 取随机整数, 范围是 1 -  10   顾头又顾尾
print(random.randrange(1,2))  # 取随机整数 , 范围是 1 -  2  顾头不顾尾


# 从列表中随机抽取   应用抽奖
l = ['a','b',('a','b','c'),123,[1,3]]
print(random.choice(l))  #  从列表中随机取出一个元素
print(random.choices(l))  # 从列表中随机取出一个元素,并且是以列表的形式返回
print(random.sample(l,2))  #  从列表中随机取出两个元素

# 打乱一个列表的顺序,可以洗牌
random.shuffle(l)  #  打乱列表的顺序 ,没有返回值, 在原列表中打乱
print(l)

 

随机验证码  函数版  可以自己更改位数

 

import random
def YZM(n=6,fal = True):
    s = ""
    for i in range(n):
        num = str(random.randint(0,9))  #  随机数字
        if fal:
            apl1 = chr(random.randint(65,90))    #    随机大写字母
            apl2 = chr(random.randint(97,122))  #   随机小写字母
            num = random.choice([num,apl1,apl2])  #  从三个中随机再取出一个
        s += num
    return s
print(YZM(4))

 

发红包   拼手气红包

 

import random
def red_packet(money,num):
    money = money * 100
    ret = random.sample(range(1,money),num-1)
    ret.sort()
    ret.insert(0,0)
    ret.append(money)
    for i in range(len(ret)-1):
        yield (ret[i+1] - ret[i])/100

ret_g = red_packet(200,10)
for money in ret_g:
    print(money)

 

import random
def Bonus(person,money):  # 5,200
    dict_person_money = {}
    for i in range(person):
        num = random.randint(1,100)  # 99 99 99 99 99
        dict_person_money["Person%s"%(i+1)] = num  # person1:99
    num_sum = 0
    for i in dict_person_money:
        num_sum += dict_person_money[i]  # 5 * 99 = 495
    for i in dict_person_money:    # 99/495 1/5 * 200 = 40
        x =round(dict_person_money[i]/num_sum*money,2)
        dict_person_money[i] = '$%s'%x
    return dict_person_money

result = Bonus(10,1)
print(result)

 

时间模块

import time
常用方法
time.sleep(2)  # 当程序走到这里会停顿两秒   可以称睡眠
print("你好")

时间戳
print(time.time())

time  模块主要是和时间打交道的
时间格式:
        2018-08-20  16:20:30   字符串时间,  格式化时间  ,  给人看的
结构化时间:
1534752966.3648965  浮点型数据类型,  以S为单位, 时间戳时间,   给计算机用的
时间戳时间是从伦敦时间     1970-1-1 00:00:00   开始计

 

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

import time

# 格式化时间
print(time.strftime("%Y-%m-%d %H:%M:%S")) #  str format  time
# 2018-08-20 16:32:15
print(time.strftime('%y-%m-%d %H:%M:%S'))
# 18-08-20 16:33:38
print(time.strftime('%D'))
# 08/20/18
print(time.strftime('%c'))
# 伦敦时间 :  Mon Aug 20 16:35:01 2018


# 结构化时间
bendi_time = time.localtime()  # 北京时间
print(bendi_time)
# time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20, tm_hour=16, tm_min=40, tm_sec=27, tm_wday=0, tm_yday=232, tm_isdst=0)
print(bendi_time.tm_mon)  # 显示月
# 8

# 时间戳时间
print(time.time())
#  1534754582.3888912

 

格式化时间   ,   结构化时间    ,   时间戳时间     三者之间的转换

 

 

 

 

 

 

 

 

 

 

#  时间戳时间转化成字符串时间
import time
struct_time = time.localtime(1500000000)  #  将时间戳转成结构化时间
print(struct_time)  #  北京时间
# time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
print(time.gmtime(1500000000))  #  伦敦时间
# time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
ret = time.strftime("%Y-%m-%d %H:%M:%S",struct_time)   #  将结构化时间转化成字符串时间
print(ret)
# 2017-07-14 10:40:00

 

# 字符串时间转化成时间戳时间
import time
struc_time = time.strptime("2018-08-16","%Y-%m-%d")  #  将字符串时间转化成结构化时间
print(struc_time)
ret = time.mktime(struc_time)  #  将结构化时间转化成时间戳时间
print(ret)

 

例题:

# 将当前时间的当前月的1号的时间戳取出来
import time
def benyue_time():
    struct_time = time.localtime()
    st = time.strptime('%s-%s-01' % (struct_time.tm_year,struct_time.tm_mon),"%Y-%m-%d")  # 按格式化时间取出年月,然后转成结构时间
    get_time= time.mktime(st)  #转成时间戳时间
    return get_time
print(benyue_time())

 

# 计算时间差
import time
def get_time(n1,n2):
    st1 = time.strptime(n1,"%Y-%m-%d %H:%M:%S")
    st2 = time.strptime(n2,"%Y-%m-%d %H:%M:%S")
    struct_time1 = time.mktime(st1)
    struct_time2 = time.mktime(st2)
    num1 = struct_time2 - struct_time1
    time_cha = time.gmtime(num1)
    return "经历了%s年%s月%s日%s时%s分%s秒" % (time_cha.tm_year-1970,time_cha.tm_mon-1,time_cha.tm_mday-1,
          time_cha.tm_hour,time_cha.tm_min,time_cha.tm_sec)

print(get_time('2018-05-06 06:05:03',"2018-08-20 08:10:30"))

 

时间差   datetime

 

import datetime

datetime.datetime   #  获取年月日时分秒

datetime.date  #  获取年月日

datetime.time  #  获取时分秒

datetime.timedelta   # 做时间差

now=datetime.datetime.now().date()    #  获取当前时间的年月日

date=datetime.date(year=2018,month=11,day=18)   
print(now-datetime.timedelta(days=1)>date)   # 时间比大小 

 

 

import datetime
        now=datetime.datetime.now().date()  # 今天
        delta1=datetime.timedelta(days=1)   #  昨天
        delta2=datetime.timedelta(weeks=1)  #   一周前
        delta3=datetime.timedelta(weeks=4)  #  4周前

 

 

sys模块   

sys模块是与Python交互的一个接口

迷糊不懂

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 

os模块

import os
os.makedirs('dir1/dir2')  # 创建文件目录,一次性可以创建多级目录
os.mkdir("dir3/dir4")   # 创建文件目录  只能创建单级目录
 # 只能删除空文件夹
os.rmdir('dir1/dir2')  # 删除单级目录
os.removedirs("dir3/dir4")  #可以删除多级目录  前提是空文件夹
print(os.stat(r'E:\Python\day18')
print(os.listdir('E:\Python\day18')) # 列出指定目录下的所有文件和子目录,包括隐藏文件 并以列表的方式返回
os.rename("旧文件名","新文件名")  # 重命名文件/目录
os.stat("path  路径")   # 获取文件/目录信息
os.getcwd()  # 获取当前工作目录,即当前Python脚本工作的目录路径
os.chdir('E:\Python\day18')   #  切换当前的工作的目录
ret = os.path("dir")  #  是和做查看类的操作
print(ret.read())

 

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
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的大小

 

os.stat("path/filename")   获取文件/目录信息的结构说明

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
 

 

序列化模块

什么叫序列化------------------将原本的字典  , 列表 等内容转换成一个字符的过程叫做序列化.

比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？
现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。
但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字典放到文件中。
你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，
但是你要怎么把一个字符串转换成字典呢？
聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。
eval()函数十分强大，但是eval是做什么的？e官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。
ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。
想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

序列化的目的

1  以某种存储形式使自定义对象持久化;

2  将对象从一个地方传递到另一个地方

3  是程序更具有维护性

 

 

 

 

 

 

json  &   pickle   模块     

用于序列化的两个模块

一　　json ,  用于字符串和Python数据类型间进行转换

二　　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(1000000000)
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_time2.tm_year)

# 需求 :就是想要把一个一个的字典放到文件中,再一个一个取出来???
dic = {'key1' : 'value1','key2' : 'value2'}

with open('json_file','a') as f:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
    str_dic = json.dumps(dic)
    f.write(str_dic + '\n')
    str_dic = json.dumps(dic)
    f.write(str_dic + '\n')

with open('json_file','r') as f:
    for line in f:
        dic = json.loads(line.strip())
        print(dic.keys())

json
 dumps loads
     在内存中做数据转换 :
         dumps 数据类型 转成 字符串 序列化
         loads 字符串 转成 数据类型 反序列化
 dump load
     直接将数据类型写入文件,直接从文件中读出数据类型
         dump 数据类型 写入 文件 序列化
         load 文件 读出 数据类型 反序列化
 json是所有语言都通用的一种序列化格式
     只支持 列表 字典 字符串 数字
     字典的key必须是字符串