包、模块二

一、包

1.什么是包：

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

2.为何要用包：

　　为了用文件夹讲文件/模块组织起来，提高程序的结构性和可维护性

3.包的使用

　　实例一：

　　　　创建文件夹aaa，在aaa文件夹内创建__init__.py 和 m1.py文件,在aaa同级目录下创建一个执行文件run,py文件
　　　　　　#m1文件的内容:
　　　　　　　　def f1():
　　　　　　　　　　print(‘fff111’)
　　　　　　　　def f2():
　　　　　　　　　　print(‘fff222’)

　　　　　　在__init__.py添加内容，在aaa中拿到名字m1，m2：
　　　　　　　　from aaa.m1 import f1,f2

　　　　　　执行文件run.py:
　　　　　　　　import aaa
　　　　　　　　aaa.f1()
　　　　　　　　aaa.f2()

　　　　以上执行结果为：fff111 fff222

　　总结：

　　　　import导入文件时，产生名称空间中的名字来源于文件，import 包，

　　　　产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件__init__.py

　　另外：

　　　　包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

　　实例二：

　　　　在aaa文件夹内创建bbb文件夹，在bbb文件夹中创建m3.py文件。bbb和前面创建的m1.py、m2.py同级

　　　　#m3文件的内容:
　　　　　　def f3():
　　　　　　　　print(‘fff333’)
　　　　若想在run中调用m3中的f3：
　　　　要在__init__.py添加内容，在aaa中拿到名字m3：
　　　　　　from aaa.bbb.m3 import f3

　　　　执行文件run.py:
　　　　　　import aaa
　　　　　　aaa.f3()
　　执行结果即为：fff333

4.相对导入：

　　以上包内模块的绝对导入

　　　　from aaa.m1 import f1,f2
　　　　from aaa.bbb.m3 import f3

　　　　优点: 执行文件与被导入的模块中都可以使用
　　　　缺点: 所有导入都是以sys.path为起始点,导入麻烦

　　另外我们可以采用相对导入

　　　　一个.代表往上一级
　　　　__init__.py中的内容可以写成：
　　　　from .m1 import f1,f2
　　　　from ..m3 import f3
　　　　m1的上一级是aaa，所以.m1代表了aaa.
　　　　m3的上一级是bbb，再上一级是aaa，我们需要在aaa中拿到m3的名字，就要往上返两级，因此..m3表示aaa.bbb.m3

　　　　优点：导入更加简单
　　　　缺点: 只能在导入包中的模块时才能使用

　　强调：

　　　　包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的

二、json & pickle

　　1.什么是序列化：

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

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

　　2.为何要用序列化：

　　　　2.1 持久保存程序的运行状态
　　　　2.2 数据的跨平台交互

　　3.如何序列化

　　　　3.1 json

　　　　　　优点：这种格式是一种通用的格式，所有编程语言都能识别，跨平台性很强
　　　　　　缺点：不能识别所有python类型

　　　　　　强调：
　　　　　　　　json不能识别单引号

　　　　3.2 pickle

　　　　　　优点：可以识别所有python类型
　　　　　　缺点：只能被python这门编程语言识别

json的使用：

　　　　import json
　　序列化
　　　　dic_json=json.dumps(dic)
　　　　print(dic_json)

　　持久化
　　　　with open(‘a.json’,’wt’,encoding=’utf8′)as f:
　　　　f.write(dic_json)

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

　　从文件中读取json格式化的字符
　　　　with open(‘a.json’,’rt’,encoding=’utf8′)as f:
　　　　　　dic_json=f.read()

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

　　读取文件内容+反序列化
　　　　with open (‘a.json’,’rt’,encoding=’utf8′)as f:
　　　　　　dic = json.load(f)
　　　　　　print(dic,dic[‘k1’])

pickle的使用：

　　　　import pickle
　　　　dic = {‘k1′:True,’k2′:10,’k3′:’egon’,’k4′:’你好啊’}

　　序列化：
　　　　dic_pkl = pickle.dumps({1,2,3,4})
　　　　print(dic_pkl)

　　持久化
　　　　with open(‘b.pkl’,’wb’)as f:
　　　　　　f.write(dic_pkl)

　　序列化 + 持久化：
　　　　with open(‘c.pkl’,’wb’)as f:
　　　　　　pickle.dump(dic,f)

　　从文件中读取pickle格式化的字符 + 反序列化 ：
　　　　with open(‘b.pkl’,mode=’rb’)as f:
　　　　　　s_pkl = f.read()
　　　　　　s = pickle.loads(s_pkl)
　　　　　　print(type(s))

　　从文件中读取pickle格式化的字符 + 反序列化
　　　　with open(‘c.pkl’,’rb’)as f:
　　　　　　dic = pickle.load(f)
　　　　　　print(dic,type(dic))

三、time

　　import time
　　时间分为三种格式:

　　　　1. 时间戳

　　　　　　time.time()

　　　　2. 格式化的字符

　　　　　　print(time.strftime(‘%Y-%m-%d %H:%M:%S %p’))

　　　　3. 结构化的时间对象

　　　　　　当地时间：
　　　　　　　　print(time.localtime())
　　　　　　当天第几个小时：
　　　　　　　　print(time.localtime().tm_hour)
　　　　　　当天为本月第几周：
　　　　　　　　print(time.localtime().tm_wday)
　　　　　　当天为今年第几天：
　　　　　　　　print(time.localtime().tm_yday)
　　　　　　标准时间：
　　　　　　　　print(time.gmtime())

　　　　4.时间转换

　　　　　　时间戳—->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)

四、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)

生成随机验证码：

　　import random

　　def make_code(n):
　　　　res = ‘ ‘
　　　　for i in range(n):
　　　　　　s1=chr(random.randint(65,90))
　　　　　　s2=str(random.randint(0,9))
　　　　　　res+=random.choice([s1,s2])
　　　　return res

　　print(make_code(5))