random、os、时间模块

一.random 模块

1.随机小数

random.random()   #产生大于0且小于1之间的小数

random.uniform(1,3)   #产生1到3之间的随机小数

2.随机整数

random.randint (1,5)      # [1  ,  5 ]   #大于等于1且小于等于5之间的整数 
random.randrange(1,10,2) #[  1,    10  )  #大于等于1且小于10之间的偶数

3.随机列表

random.choice([1,23,[6,4,7],4,654])

随机返回一个数都可能

random.sample([1,23,[6,4,7],4,654]  ,  2)  #随机返回2两个

随机返回多个,返回的数作为函数的第二个参数

random.shuffle(lst)

随机打乱列表的顺序

练习  随机生成验证码

#------------------验证码-----------------------------------
# 目标一:随机产生任意个数字的验证码
def yanzhenma(x):                  #定义随机产生的验证码数字个数x的值可以随便的更改
    import random                  #引入随机数模块
    s = ""                         #定义一个空字符串来接验证码
    for i in range(x):
        num = random.randint(0,9)  #从0-9的数里面随机产生一个数
        s += str(num)              #将产生的随即数累加
    return s                       #返会最后的结果
print(yanzhenma(4))                #打印随机产生的四个验证码,当然也可以是6个依照需求来定
#
#
#  目标二:如何产生字母和数字组合在一起的验证码
def yanzhenma(x):                           #定义验证码的函数
    import random                           #引入随机数模块
    s = ""                                  #定义一个字符串类型的数来承接你随机产生的验证码
    for i in range(x):                      #定义需要随机数产生的次数
        digle = random.randint(0,9)         #随机产生数字
#介绍一个知识点chr(数字)调出来的是ASDII码中数字所对应的字母
        alph_upper = chr(random.randint(65,90))  #随机产生小写字母利用小写子母在ASDII码中的位置
        alph_lower = chr(random.randint(97,122))  # 同上,因为在ASDII中大小写不是连在一起的所以要分开写
        num = random.choice([str(digle),alph_lower,alph_upper])  #在前面的产生的随机数列表中随机产生一个字符
        s += num                              #将产生的随机数进行累加
    return s                                   #返回随机产生的数
print(yanzhenma(4))                            #打印随机验证码4位的
#
#
# 目标三:那么如果我想让他产生的是纯数字有时候产生的是字母加数字改怎么办??
#         很有挑战但是用最简单的方法去做
def yanzhenma(x,alpha=True):                #定义一个验证码的函数位数由自己设定字母默认是有的
    import random                           #引入随机数模块
    s = ''                                  #用s字符串来承接验证码
    for i in range(x):                      #随机循环的次数
        num = str(random.randint(0, 9))     #随机产生数字
        if alpha:                           #判断是不是需要字母
            alpha_upper = chr(random.randint(65, 90))  #随机产生小写字母
            alpha_lower = chr(random.randint(97, 122)) #随机产生大写字母
            num = random.choice([num, alpha_upper, alpha_lower])    #将产生的数字字母放在一起在随机产生一个需要位数的数
        s += num                                                #将随机产生的数放在一起
    return (s)                                                  #返回随机产生的数
print(yanzhenma(6,alpha=True ))                                 #调用函数并且给初始值

抢红包

#------------------抢红包--------------------
import random
def func(s, n):
    lst = []
    sum = 0
    for i in range(n):
        if i == n-1:
            lst.append(s-sum)
            break
        m = random.uniform(s//(n+1), s//(n-1))
        sum += m
        lst.append(m)
    return random.sample(lst, n)
print(func(10, 5))

二. 时间模块

1.time.sleep()

线程推迟指定的时间运行,单位秒

2.time.time()

获取当前的时间戳

表示时间的三种方式

1.浮点型时间\时间戳

>>>time.time()

150008754514.545

2.字符串时间\格式化时间

time.strftime(%Y-%m-%d %H-%M-%S)

"2018-08-20"

3.结构化时间\元组时间

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,

　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37,

　　　　　　　　tm_wday=0, tm_yday=205, tm_isdst=0)

元组的索引有特殊的意义

重点重点重点

三种时间的转换

一张图安排的明明白白 只要把这张图的 内容吃透时间模块就没有问题

例子:

#--------------计算时差,函数----------------------
def dif(x,y):

    import time                                         #引入时间模块
    true_time = time.mktime(time.strptime(x,"%Y-%m-%d %H:%M:%S"))       #将开始的字符串时间先编程结构化时间然后在转换成时间戳时间便于计算时间差
    time_now = time.mktime(time.strptime(y,"%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-,struct_time.tm_mon-,  #结构化时间与1970-- ::
                                               struct_time.tm_mday-,struct_time.tm_hour,       #作差值显示时间差的结构化输出
                                               struct_time.tm_min,struct_time.tm_sec))
dif("2018-8-9 8:0:0","2018-8-9 9:0:0")

三.sys 模块

首先要明白sys模块是针对python解释器打交道的

1.sys.argv

这个命令经常用在用户登陆上,命令可以帮助我们抢占cpu 的使用权为用户争取时间

sys.argv[0] :是模块运行的计算机内存地址

sys.argv[1]: 是你输入的字符串的第一位 在登陆的时候可以是你的用户名,或者是密码

sys.argv[2]:同上是你输入的第二个字符串

不过这个命令是在终端运行的,一定要注意

2.sys.exit()

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

3.sys.version

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

4.sys.path

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

5.sys.platform

返回操作系统平台名称

四.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
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模块详解

os.path.abspath(path) 返回path规范化的绝对路径
　　把路径中不符合规范的/改成操作系统默认的格式

import os
path = os.path.abspath(r"C:/Users/asus/PycharmProjects/untitled/day19/练习.py")
print(path)
#结果:C:\Users\asus\PycharmProjects\untitled\day19\练习.py

　　能够给能找到的相对路径改成绝对路径

import os
path = os.path.abspath("练习.py")
print(path)

os.path.split(path) 将path分割成目录和文件名二元组返回
　　就是把一个路径分成两段,第二段是一个文件/文件夹

import os
path = os.path.split("C:/Users/asus/PycharmProjects/untitled/day19/练习.py")
print(path)
#结果:('C:/Users/asus/PycharmProjects/untitled/day19', '练习.py')
path = os.path.split("C:/Users/asus/PycharmProjects/untitled/day19")
print(path)
#结果:('C:/Users/asus/PycharmProjects/untitled', 'day19')

os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素

import os
ret1 = os.path.dirname("C:/Users/asus/PycharmProjects/untitled/day19/练习.py")
print(ret1)
#结果:C:/Users/asus/PycharmProjects/untitled/day19

os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

import os
ret2 = os.path.basename("C:/Users/asus/PycharmProjects/untitled/day19/练习.py")
print(ret2)
#结果:练习.py

　　如果你两个值都需要 os.path.split
　　 如果你只要一个值 os.path.dirname/os.path.basename

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
判断文件/文件夹是否存在

import os
res = os.path.exists("练习.py")
print(res)
#结果:True

os.path.isabs(path)  如果path是绝对路径，返回True

import os
res1 = os.path.isabs('练习.py')
res2 = os.path.isabs(r'C:/Users/asus/PycharmProjects/untitled/day19/练习.py')
print(res1)    #  False
print(res2)    #   True

os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

import os
print(os.path.isdir(r'C:/Users/asus/PycharmProjects/untitled\aaa'))    #   False
print(os.path.isfile(r'C:/Users/asus/PycharmProjects/untitled\aaa'))     #   False
print(os.path.isfile('C:/Users/asus/PycharmProjects/untitled\day01'))    #   False
print(os.path.isdir('C:/Users/asus/PycharmProjects/untitled\day01'))     #    True

os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

import os
path = os.path.join('C:/Users/asus/PycharmProjects/untitled','bbb')
print(path)
#结果:C:/Users/asus/PycharmProjects/untitled\bbb

os.path.getsize(path) 返回path的大小

import os
size= os.path.getsize(r'C:/Users/asus/PycharmProjects/untitled/day19/练习.py')  # 查看文件大小
print(size)
# 结果: 7826

　　使用python代码统计一个文件夹中所有文件的总大小

递归
import os
def func(path):
    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)
            sum += size
        else:
            sum += os.path.getsize(path_abs)
    return sum
ret =func(r'C:/Users/asus/PycharmProjects/untitled')
print(ret)
# 结果: 192435586

循环
lst = [r'C:/Users/asus/PycharmProjects/untitled']
sum = 0
while lst:
    path = lst.pop()
    path_list = os.listdir(path)
    for name in path_list:
        abs_path = os.path.join(path,name)
        if os.path.isdir(abs_path):
            lst.append(abs_path)
        else:
            sum +=os.path.getsize(abs_path)
print(sum)
# 结果: 192435586

　　exec('字符串数据类型的python代码')
　　eval('执行字符串数据类型的python代码')

os模块所做的事情
定制了很多方法 间接的帮助你去调用操作系统的命令 获得结果
然后帮助你分析整理成我们需要的数据类型的形态
你也可以os.popen/os.system直接取调用操作系统的命令 获得结果
但是 分析和整理的工作需要你自己做
用os模块的方法本身能够完成的功能我们就用定制好的方法就够了
如果有一天 你发现os模块定制好的功能解决不了我们的问题了
而刚好操作系统的命令能够很好地帮助我们解决问题
这个时候就用os.popen/os.system