20181205（模块循环导入解决方案，json&pickle模块，time，date，random介绍）

 

一、补充内容

循环导入

解决方案：

1、将导入的语句挪到后面。

​ 2、将导入语句放入函数，函数在定义阶段不运行

#m1.py
print('正在导入m1')   #②能够正常打印
from m2 import y  #③跳转到m2模块寻找y
​
x='m1'  #此句暂未执行
​
#m2.py
print('正在导入m2')  #④能够正常打印
from m1 import x    #⑤此句无法正常运行，因为m1中没有x的数据
​
y='m2'  #此句也暂未执行
​
#run.py
import m1  #①导入m1模块

解决方案一：导入语句放到最后
#m1.py
print('正在导入m1')
​
x='m1'
​
from m2 import y
​
#m2.py
print('正在导入m2')
y='m2'
​
from m1 import x

解决方案二：导入语句放到函数中
#m1.py
print('正在导入m1')
​
def f1():   #在导入m1时，函数并没有运行
    from m2 import y
    print(x,y)
​
x = 'm1'   #获取x的值
​
​
#m2.py
print('正在导入m2')
​
def f2():
    from m1 import x
    print(x,y)
​
y = 'm2'
​
#run.py
import m1
​
m1.f1()

 

二、包

定义：包就是一个含有__init__.py文件的文件夹。

导包就是导入__init__文件中的内容

绝对导入：以包的顶级文件夹目录作为查找的起始位置。

先要添加环境变量；
import sys
sys.path.append(r'C:UserswangtPycharmProjects
ew20181205')
也就是说包放置在了20181205这个目录下的某处。
后续调用时，可以直接调用，目录均以文件夹20181205开始：
import m1  #导入20181205文件夹下的m1模块
import aaa.m2  #导入20181205文件夹下的aaa文件夹中的m2模块
import aaa  #导入20181205文件夹下的aaa文件夹中的所有模块  #此处假设aaa是文件夹的名字
from aaa.m2 import func1  #导入20181205文件夹下的aaa文件夹中m2模块中的func1函数
import aaa.bbb.m3   #导入文件夹20181205aaabb下的m3模块

 

#######此处存疑######相对导入：仅限在包内用，只能用于包内的模块互相引用。

.代表当前文件夹，..代表上一级文件夹，...代表上上级文件夹，以此类推。
import m1  #导入当前文件夹下的m1模块
import .m2  #导入当前文件夹的上一级文件夹中的m2模块
from ..m3 import func1  #导入当前文件夹的上一级文件夹的上一级文件夹中的m2模块中的func1函数

 

三、json&pickle模块

目的：为了解决序列化问题

序列化定义：序列化就是将内存中的数据类型转换成另外一种格式。

即： 字典----序列化---》其他格式---》--------》存到硬盘

硬盘------读取---》其他格式---反序列化-----》字典

序列化的目的：

1、持久保存程序的运行状态

2、数据的跨平台交互

 

序列化的使用：

json（最常用）：

优点：这种格式是一种通用的格式，所有编程语言都能识别。跨平台性好。

缺点：不能识别所有python类型（例如不能识别集合）

强调：json不能识别单引号，是能识别双引号。

pickle：

优点：能识别所有python类型

缺点：只能被python这门编程语言识别

dumps和loads方法都在内存中转换，dump和load的方法会多一个步骤，dump是把序列化后的字符串写到一个文件中，而load是从一个一个文件中读取文件

json储存成字符串类型，所以mode为t。

import json
dic={'k1':True,'k2':10,'k3':'egon'}
​
序列化：
dic_json=json.dumps(dic)
print（dic_json,type(dic_json)）
输出结果为：
{"k1": true, "k2": 10, "k3": "egon"} <class 'str'>   #这是跨平台的交互数据
​
持久化：
with open('a.json',mode='wt',encoding='utf8') as f:
    f.write(dic_json)
​
从文件中读取json格式的字符：
with open('a.json',mode='rt',encoding='utf8') as f:
    dic_json=f.read()
​
反序列化
dic=json.loads(dic_json)
print(dic)
​
​
序列化+持久化
with open('a.json',mode='wt',encoding='utf8') as f:
    json.dump(dic,f)
​
读取文件内容+反序列化
with open('a.json',mode='rt',encoding='utf8') as f:
    dic=json.load(f)
    print(dic)

 

pickle只能数据持久化，无法跨平台调用。储存成二进制类型，所以mode为b。

import pickle
dic={'k1':True,'k2':10,'k3':'egon'}
​
序列化：
dic_pkl=pickle.dumps(dic)
​
持久化：
with open('dic.pkl',mode='wb') as f:
    f.write(dic_pkl)
    
读取文件内容及反序列化
with open('dic.pkl',mode='rb') as f:
    dic_pkl=f.read()
    dic=pickle.loads(dic_pkl)
    print(type(dic))
    
序列化+持久化
with open('c.pkl',mode='wb') as f:
    pickle.dump(dic,f)
    
读取文件内容+反序列化
with open('c.pkl',mode='rb') as f:
    dic=pickle.load(f)
    print(dic,type(dic))

 

四、内置模块介绍

1、time&datatime

time模块

时间分为三种格式：

1、时间戳，参考1970年的时间

print(time.time())
输出结果为：
1544006378.4561322  #从格林威治时间1970年01月01日00时00分00秒到现在过去的秒数

 

2、格式化的字符串

print(time.strftime('%Y-%m-%d %H:%M:%S %p')) #p是上午下午的意思。
print(time.strftime('%Y-%m-%d %H:%M:%S'))
输出结果为：
2018-12-05 18:38:31 PM
2018-12-05 18:38:31

 

3、结构化的时间对象

print(time.localtime())  #当前时区时间
​
print(time.gmtime())   #格林尼治时间
​
print(time.localtime().tm_hour)     #一天的第几个小时
​
print(time.localtime().tm_wday)   #一周的第几天
​
print(time.localtime().tm_yday)   #一年的第几天

 

时间转换

时间戳——》struct time——》格式化的字符串时间

import time
struct_time=time.localtime(123123)  #秒数转化为结构化时间
print(struct_time)
输出结果为：
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=2, tm_hour=18, tm_min=12, tm_sec=3, tm_wday=4, tm_yday=2, tm_isdst=0)
​
​
print(time.strftime('%Y-%m-%d',struct_time)) #将结构化的时间转换为标准格式
输出结果为：
1970-01-02

格式化的字符串——》struct_time——》时间戳

import time
struct_time=time.strptime('2018-12-05','%Y-%m-%d')  #将格式化的字符串时间转换为结构化时间
print(time.mktime(struct_time))  #将结构化时间转换为时间戳
输出结果为：
1543939200.0

 

 

datetime模块

获取格式化的字符串的时间

import datetime
print(datetime.datetime.now())  #直接获取当前时间
输出结果：
2018-12-05 18:45:23.195833
        
        
print(datetime.datetime.fromtimestamp(5678989))     #将时间戳直接转换为结构化时间的字符串 
输出结果为：
1970-03-08 01:29:49

计算时间

import datetime
print(datetime.datetime.now())  #当前时间
print(datetime.datetime.now()+datetime.timedelta(days=3))  #三天后时间
print(datetime.datetime.now()+datetime.timedelta(hours=3)) #三小时后时间。    #支持weeks,days,seconds,minutes,hours,还有毫秒等，支持负号-，就是多久之前。
print(datetime.datetime.now()+datetime.timedelta(days=3,hours=3)) #三天三小时后
输出结果为：
2018-12-05 18:54:22.206142
2018-12-08 18:54:22.206142
2018-12-05 21:54:22.206142
2018-12-08 21:54:22.206142
​

 

2、random模块

import random
​
print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数 （包括1和10）
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数，顾头不顾尾，不包括100
a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.choice(['1','a','4','b']) )   # 从列表中随机选取一个元素
print( random.sample(['1','a','4','b'],2) )   # 从列表中随机选取两个元素

应用：随机验证码。

chr(num) 可以将数字按照ASCII表转换成对应得符号。
例如
print(chr(65))
print(chr(90))
print(chr(97))
print(chr(122))
输出结果为：
A
Z
a
z

import random
res=''  #空字符串
for i in range(5):  #循环五次，得到一个五位的验证码
    num=str(random.randint(0,9))   #得到0到9的随机数，并且改为字符串类型
    alp=chr(random.randint(65,90))  #对应ASCII表，得到大写字母
    res += random.choice([num,alp])  #二选一，字符串性价
print(res)  #输出随机的五位验证码
​
升级版本：
def make_code(max_size=5):
    import random
    res=''
    for i in range(max_size):
        num=str(random.randint(0,9))
        alp=chr(random.randint(65,90))
        res += random.choice([num,alp])
    return res
print(make_code(10))  #指定验证码长度