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)  # 显示月
 #

 # 时间戳时间
 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）是创建时间（详细信息参见平台的文档）。

stat 结构

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

os模块的属性

序列化模块

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

比如，我们在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)

pickle

 # 需求 :就是想要把一个一个的字典放到文件中,再一个一个取出来???
 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

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