常用模块------时间模块 , random模块 ,os模块 , sys模块

一 . random模块

import random

random.random()             # 随机小数
random.uniform(1,3)        # 大于1小于3的随机小数

random.randint()              # 随机整数
random.randrange(n,m,d)  # 大于n小于m之间每隔d的整数

random.choice(list)             # 随机选择一个
random.sample(list,n)         # 在列表中随机选取n个

random.shuffle(list)              #打乱次序

　　练习 : 生成验证码

import random

def func(n , alpha = True):
    s = ""
    for el in range(n):
        
        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(func(实参))

二 . 时间模块

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（0000-9999）
%m 月份（1-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（1-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（1-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（0-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（0-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

python中时间日期格式化符号：

(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

索引（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（时）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第几天）	1 - 366
8	tm_isdst（是否是夏令时）	默认为0

首先，我们先导入time模块，来认识一下python中表示时间的几种格式：

import time

# 时间戳
time.time()

# 时间字符串/格式化时间
time.strftime("%Y-%m-%d %H:%M:%S")
"2018-8-20 15:32:49"

# 时间元组/结构化时间 : localtime 将一个时间戳转换为当地时区的struct_time
time.localtime()      当地时区
time.gmtime()        英国伦敦时间
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)

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

几种格式之间的转换

import time

# 时间戳 --> 结构化时间
time.gmtime()       # 伦敦时间
time.localtime()     # 当地时间


# 结构化时间 --> 时间戳
time.mktime(浮点数)


# 结构化时间 --> 字符串时间
time.strftime("格式定义","结构化时间")   # 结构化时间参数若不传,则显示当前时间

# 字符串时间 --> 结构化时间
time.strptime(时间字符串,字符串对应格式)

# 结构化时间 --> 字符串时间
time.asctime(结构化时间)     如果不传参数,直接返回当前时间的格式化串


#时间戳 --> 字符串时间
time.ctime(时间戳)          如果不传参数,直接返回当前时间的格式化串

计算时间差 :

str_time1 = '2018-8-19 22:10:8'
str_time2 = '2018-8-20 11: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)
# 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))

# 函数形式 :
def func(str_time1,str_time2):
    
    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)
    num = '过去了%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)
    
    return num

print(func('2018-8-19 22:10:8','2018-8-20 11:07:3'))

三 . os模块

　　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.system('dir 路径')  # 使用python语言直接执行操作系统的命令
os.listdir('路径')     # 使用python语言的os模块提供的方法 间接调用了操作系统命令

统计文件的大小
os.path.getsize('路径')   # python的命令
dir 路径 C     # 操作系统的命令

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

os.system('执行字符串数据类型的操作系统命令')
os.popen('执行字符串数据类型的操作系统命令,并返回结果')

os.stat结构:

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模块的属性:

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

四 . sys模块

　　sys模块是与python解释器打交道的

import sys

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

# 例如 :
 usr = sys.argv[1]
pwd = sys.argv[2]
if usr == 'alex' and pwd == 'alex3714':
    print('登录成功')
else:
    exit()

sys.modules
print(sys.modules)  # 是我们导入到内存中的所有模块的名字 : 这个模块的内存地址

print(sys.modules['re'].findall('d','abc126'))

结果:
['1', '2', '6']

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

getcwd  # 获取当前执行命令的时候所在的目录
chdir   # 修改当前执行命令的时候所在的目录

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

# 递归
def func(path):    # r'D:sylars15'
    size_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)
            size_sum += size
        else:
            size_sum += os.path.getsize(path_abs)
    return size_sum

ret = func(r'D:sylars15')
print(ret)


# 循环
lst = [r'D:sylars15',]  # 列表的第一个目录就是我要统计的目录
size_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:
            size_sum += os.path.getsize(abs_path)
print(size_sum)

五 . 序列化模块

　　1. json模块

ret = json.dumps(dic)  # 序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret) # 反序列化
print(res,type(res))

#问题1
dic = {1 : 'value',2 : 'value2'}
ret = json.dumps(dic)  # 序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret) # 反序列化
print(res,type(res))

#问题2
dic = {1 : [1,2,3],2 : (4,5,'aa')}
ret = json.dumps(dic)  # 序列化
print(dic,type(dic))
print(ret,type(ret))

res = json.loads(ret) # 反序列化
print(res,type(res))

#问题3
s = {1,2,'aaa'}
json.dumps(s)

#问题4 # TypeError: keys must be a string
json.dumps({(1,2,3):123})

# 问题5 不支持连续的存 取
dic = {'key1' : 'value1','key2' : 'value2'}
with open('json_file','a') as f:
    json.dump(dic,f)
    json.dump(dic,f)
    json.dump(dic,f)

with open('json_file','r') as f:
    dic = json.load(f)
print(dic.keys())

json 在所有的语言之间都通用 : json序列化的数据 在python上序列化了 那在java中也可以反序列化
能够处理的数据类型是非常有限的 : 字符串 列表 字典 数字
字典中的key只能是字符串

dump load 是直接操作文件的

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

　　2. pickle模块
　　　　1.支持在python中几乎所有的数据类型
　　　　 2.dumps 序列化的结果只能是字节
　　　　 3.只能在python中使用
　　　　 4.在和文件操作的时候,需要用rb wb的模式打开文件
　　　　 5.可以多次dump 和 多次load

dump
with open('pickle_file','wb') as f:
    pickle.dump(dic,f)

load
with open('pickle_file','rb') as f:
    ret = pickle.load(f)
    print(ret,type(ret))

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

 六 . 异常处理

语法错误 应该在写代码的时候就规避掉
SyntaxError
NameError name

什么时候最容易出异常
当你要处理的内容不确定的时候
    有用户参与
    有外界数据接入 : 从文件中读 从网络上获取

# 当有国行错误的时候的解决方法:
def func1():
    name

def func2():
    func1()

def main():
    func2()

main()

从下往上找,首先找到你写的代码,出错的那一行
把报错的最后一行,错误类型和详细提示翻译过来,结合报错的那一行解决问题

# 单分支
l = ['login','register']
for num,i in enumerate(l,1):
    print(num,i)

try:
    num = int(input('num >>>'))
    print(l[num - 1])
except ValueError :      # except处理的异常必须和实际报错的异常是相同的
    print('请输入一个数字')
print(l[num - 1])

# 多分支
l = ['login','register']
for num,i in enumerate(l,1):
    print(num,i)

try:
    num = int(input('num >>>'))
    print(l[num - 1])
except ValueError :
    # 从上向下报错的代码只要找到一个和报错类型相符的分支就执行这个分支中的代码,然后直接退出分支
    print('请输入一个数字')
except IndexError :
    # 如果找不到能处理和报错类型相同的分支,会一直往下走,最后还是没有找到就会报错
    print('只能输入1或2')

# 多分支合并
l = ['login','register']
for num,i in enumerate(l,1):
    print(num,i)

try:
    num = int(input('num >>>'))
    print(l[num - 1])
except (ValueError,IndexError) :
    print('您输入的内容不合法')

万能异常
def buy():
    print('buy')
    name

def back():
    print('back')
    [][1]

def show():
    print('show')
    1/0

def main():
    l = [('购物',buy),('退货',back),('查看订单',show)]
    while True:
        for num,i in enumerate(l,1):
            print(num,i[0])
        num = int(input('num >>>'))
        print(l[num - 1])
        try:
            func = l[num - 1][1]
            func()
        except Exception:
            print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0])

main()

as语法:

def buy():
    print('buy')
    name

def back():
    print('back')
    [][1]

def show():
    print('show')
    1/0

def main():
    l = [('购物',buy),('退货',back),('查看订单',show)]
    while True:
        for num,i in enumerate(l,1):
            print(num,i[0])
        num = int(input('num >>>'))
        print(l[num - 1])
        try:
            func = l[num - 1][1]
            func()
        except Exception as e:
            print(e)
            #print(e.args,e.__traceback__.tb_lineno,e.__traceback__.tb_frame)
            print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0])

main()

万能异常:

try:
    name
    [][1]
    int('aaa')
except:
    print(123)

多分支 + 万能异常 : 万能异常应该永远放在异常处理的最下面
def buy():
    print('buy')
    name

def back():
    print('back')
    [][1]

def show():
    print('show')
    1/0

def main():
    l = [('购物',buy),('退货',back),('查看订单',show)]
    while True:
        for num,i in enumerate(l,1):
            print(num,i[0])
        try:
            num = int(input('num >>>'))
            print(l[num - 1])
            func = l[num - 1][1]
            func()
        except (ValueError,IndexError) :
            print('您输入的内容不合法')
        except Exception as e:
            print(e)
            #print(e.args,e.__traceback__.tb_lineno,e.__traceback__.tb_frame)
            print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0])
main()

try:
    pass
except (ValueError,IndexError):
    print('针对性的处理')
except Exception as e:
    print(e)
    print('通用性的处理')

　　else分支:

try:
    print('aaa')  # 给某某某发邮件
    # name
    # [][1]
    # 1/0
except NameError:   # 网络不稳定,邮箱地址错误
    print('name error')
except IndexError:
    print('index error')
except Exception as e:
    print('Exception')
else:  # 当try中的代码不发生异常的时候 走else分支  如果发送成功了 进行一些处理
    print('else')

　　finally分支:

try:
    print('aaa')  # 给某某某发邮件
    name
    # [][1]
    # 1/0
except NameError:   # 网络不稳定,邮箱地址错误
    print('name error')
except IndexError:
    print('index error')
except Exception as e:
    print('Exception')
else:  # 当try中的代码不发生异常的时候 走else分支  如果发送成功了 进行一些处理
    print('else')
finally: # 无论如何都会被执行
    print('finally')

def func():
    f = open('file')
    try:
        while True:
            for line in f:
                if line.startswith('a'):
                    return line
    except:
        print('异常处理')
    finally:   # 即使return也会先执行fianlly中的代码
        f.close()

try:
    f = open('www','w')
    f.read()
finally:   # 即使遇到报错,程序结束,也会先执行finally中的代码,然后再结束程序
    f.close()
    print('文件已经关闭了')

# finally用来回收一些操作系统的资源 : 数据库连接 打开的文件句柄 网络连接

　　异常处理的几种情况:

# try ... except
# try ... except ... else
# try ... finally
# try ... except ... finally
# try ... except ... else ... finally

　　主动抛出异常 : 给其他开发者用的

raise ValueError
raise ValueError('你写的不对')
django是别人写的程序 框架 --> 程序员用

　　断言 -- 语法 :

assert 1==2  # 只能接受一个布尔值  False
assert 1==1  # 只能接受一个布尔值  False
print(123456)
if 1 == int(input()):
    pass
else:
    raise AssertionError