包、常用模块

一.模块的循环导入

模块循环/嵌套导入抛出异常的根本原因是由于在python中模块被导入一次之后，就不会重新导入，只会在第一次导入时执行模块内代码。在我们的项目中应该尽量避免出现循环/嵌套导入，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某一个地方。

在程序出现了循环/嵌套导入后的异常分析、解决方法如下：

方法一:导入语句放到最后
#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():
    from m2 import y
    print(x,y)

x = 'm1'

# f1()

#m2.py
print('正在导入m2')

def f2():
    from m1 import x
    print(x,y)

y = 'm2'

#run.py
import m1

m1.f1()

 二.包

1.什么是包？

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

注：

    1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错 　　

    2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

2.为何要用包？

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来， 随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性。

3.如何用包？

#m1.py

def func1():
    print('from func1')

def func2():
    print('from func2')


def func3():
    print('from func3')

def func4():
    print('from func4')

#m2.py

def f1():
    print('from f1')

def f2():
    print('from f2')

def f3():
    print('from f3')

def f4():
    print('from f4')

#m3.py

# from aaa.m2 import f1

from ..m2 import f1

def fff():
    print('fff====>')
    f1()


#run.py

import sys
sys.path.append(r'E:脱产5期内容day16dir')

import aaa # aaa--------->__init__.py

aaa.func1()
aaa.func2()
aaa.func3()
aaa.func4()
aaa.f1()
aaa.f2()
aaa.f3()
aaa.f4()
aaa.fff()

#__init__.py

#把aaa这个包内子文件内的所有名字都要导入到__init__.py这个文件中
#方式一：
绝对导入：以包的顶级目录作为起始，往下查找
from aaa.m1 import func1,func2,func3,func4 

from aaa.m2 import f1,f2,f3,f4

from aaa.bbb.m3 import fff
#方式二：
相对导入：它只能在包内使用，具体用法是from .模块名 import 名字
from .m1 import func1,func2,func3,func4

from .m2 import f1,f2,f3,f4

from .bbb.m3 import fff

三.json模块与pickle模块

1.什么是序列化？

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

例如：

字典————>序列化——————>其他格式——————>存到硬盘

硬盘————>读到内存——————>其他格式——————>反序列化——————>字典

2.为什么要序列化？

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

  2.实现数据的跨平台交互

3.如何序列化？

json模块：json.dumps() （序列化），json.loads() （反序列化）

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

缺点：不能识别所有python的数据类型（不能识别单引号）

pickle模块：pickle.dumps() （序列化），pickle.loads() （反序列化）

优点：可以识别python的所有数据类型

缺点：只能被python的编程语言识别，跨平台性差

# ========================json
import json

dic={'k1':True,'k2':10,'k3':'egon','k4':'你好啊'}

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

# 持久化
with open('a.json',mode='wt',encoding='utf-8') as f:
    f.write(dic_json)

序列化+持久化
with open('a.json',mode='wt',encoding='utf-8') as f:
    json.dump(dic,f)


import json
# 从文件中读取json格式化的字符
with open('a.json',mode='rt',encoding='utf-8') as f:
    dic_json=f.read()

# 反序列化
dic=json.loads(dic_json)
print(dic,dic['k1'])

# 读取文件内容+f反序列化
with open('a.json',mode='rt',encoding='utf-8') as f:
    dic=json.load(f)
    print(dic['k1'])



# ========================pickle
import pickle

dic={'k1':True,'k2':10,'k3':'egon','k4':'你好啊',}


#===========>1 pickle.dumps与pickle.loads

dic_pkl=pickle.dumps({1,2,3,4})
print(dic_pkl)

with open('b.pkl',mode='wb') as f:
    f.write(dic_pkl)





with open('b.pkl',mode='rb') as f:
    s_pkl=f.read()
    s=pickle.loads(s_pkl)
    print(type(s))


#===========>2 pickle.dump与pickle.load
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))

四.time模块和datetime模块

time模块：

时间分为三种格式：

1.时间戳

import time

print(time.time()) #从1970年到当前时间所经历的秒数，主要用于时间运算，比如时间差

2.格式化的字符串

print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
#固定格式，2018-12-5 15:15:10 pm
#主要用在展示时间，记录日志

3.结构化的时间对象

print(time.localtime()) #本地时间
print(time.localtime().tm_hour) #截取当前小时
print(time.localtime().tm_wday) #截取本周第几天
print(time.localtime().tm_yday) #截取本月第几天
print(time.gmtime()) #世界标准时间

时间转换：

# 时间戳---->struct_time------->格式化的字符串
 struct_time=time.localtime(123123)
 print(struct_time)

 print(time.strftime('%Y-%m-%d',struct_time))

 #格式化的字符串---->struct_time------->时间戳
 struct_time=time.strptime('2017-03-11','%Y-%m-%d')
 print(struct_time)

 print(time.mktime(struct_time))

datetime模块：

#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
# print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #时间替换

五.random模块

import random
 
print(random.random())#(0,1)----float    大于0且小于1之间的小数
 
print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
 
print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数
 
print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]
 
print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合
 
print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716 
 
 
item=[1,3,5,7,9]
random.shuffle(item) #打乱item的顺序,相当于"洗牌"
print(item)

def make_code(max_size=5):
    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