1、模块
1.1模块的概念
在计算机程序的开发过程中，随着程序代码的越写越多，在一个文件里代码越来越长，这就不便于维护。为了便于维护代码，把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言采用这种方式。在python中，一个.py文件就称之为一个模块（Module）。
使用模块的好处：（1）提高了代码的可维护性
（2）编写代码不必从零开始，当一个模块编写完毕，就可以被其他地方应用
（3）使用模块还可以避免函数名与变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中。
模块有：Python标准库、第三方模块、应用程序自定义模块
1.2 模块导入的方法
（1）import语句
mport module1[,module2[,...moduleN]]
（2）from......import语句
from modname import name1[,name2[,......nameN]]
这个申明不会把整个modulename模块导入当前的命名空间中，只会讲它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。
（3）From......import*语句
2、包
2.1包的概念
为了避免不同的人编写的模块名冲突，python中引入了按目录来组织模块的方法，成为包（Package）。
例如：一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。现在假设abc与xyz模块的名字与其他模块的名字起冲突了，问了避免冲突，我们可以通过包来组织模块。方法是选择一个顶层报名：引入包以后，只要顶层的报名不与别人的起冲突，那么所有的模块都不会与别人冲突。
注意：每一个包目录下都会有一个__init__.py的文件，这个文件是必须存在的，否则，python就把这个目录当成普通目录（文件夹），而不是一个包。__init__.py可以是空文件，也可以有python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。
3、常用的模块
3.1time模块
import time 时间戳，用秒是因为做计算用 print(time.time()) #1563248318.8498843秒 结构化时间----当地时间 print(time.localtime()) #默认当时的时间print(time.localtime(time.time())) print(time.localtime(134134645)) t=time.localtime() print(t.tm_year) print(t.tm_wday) 结构化时间----世界标准时间(UTC) print(time.gmtime()) ------将结构化时间转换成时间戳 print(time.mktime(time.localtime())) ------将结构化时间转换成字符串时间 print(time.strftime("%Y-%m-%d %X",time.localtime())) ------将字符串时间转换成结构化时间 print(time.strptime("2019:07:16:12:04:38","%Y:%m:%d:%X")) print(time.asctime()) print(time.ctime())
3.2 random模块
import random 生成0-1之间的随机浮点数 ret=random.random() print(ret) 用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b ret=random.randint(a,b) print(ret) 从指定范围内，按指定基数递增的集合中 获取一个随机数。 random.randrange(10, 30, 2)，结果相当于从[10, 12, 14, 16, ... 26, 28]序列中获取一个随机数。 random.randrange(10, 30, 2)在结果上与 random.choice(range(10, 30, 2) 等效。 ret=random.randrange(1,3) print(ret) random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。 参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定 的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。 ret=random.choice([11,22,33]) print(ret) 从指定序列中随机获取指定长度的片断并随机排列。注意：sample函数不会修改原有序列。 ret=random.sample([11,22,33,44,55],2) print(ret) 用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。 ret=random.uniform(1,4) print(ret) item=[1,3,5,6,8] random.shuffle(item) #用于将一个列表中的元素打乱,即将列表内的元素随机排列。 print(item)
3.3 os模块
(1) os.name #显示当前使用的平台 (2) os.getcwd() #显示当前python脚本工作路径 (3) os.listdir('dirname') #返回指定目录下的所有文件和目录名 (4) os.remove('filename') #删除一个文件 (5) os.makedirs('dirname/dirname') #可生成多层递规目录 (6) os.rmdir('dirname') #删除单级目录 (7) os.rename("oldname","newname") #重命名文件 (8) os.system() #运行shell命令,注意：这里是打开一个新的shell，运行命令，当命令结束后，关闭shell (9) os.sep #显示当前平台下路径分隔符 (10) os.linesep #给出当前平台使用的行终止符 (11) os.environ #获取系统环境变量 (12) os.path.abspath(path) #显示当前绝对路径 (13) os.path.dirname(path) #返回该路径的父目录 (14) os.path.basename(path) #返回该路径的最后一个目录或者文件,如果path以／或结尾，那么就会返回空值。 (15) os.path.isfile(path) #如果path是一个文件，则返回True (16) os.path.isdir(path) #如果path是一个目录，则返回True (17) os.stat() #获取文件或者目录信息 (18) os.path.split(path) #将path分割成路径名和文件名。（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在） (19) os.path.join(path,name) #连接目录与文件名或目录 结果为path/name
3.4 sys模块
(1)sys.argv #命令行参数List，第一个元素是程序本身路径 (2)sys.modules.keys() #返回所有已经导入的模块列表 (3)sys.exit(n) #退出程序，正常退出时exit(0) (4)sys.version #获取Python解释程序的版本信息 (5)sys.maxsize #最大的Int值 (6)sys.modules #返回系统导入的模块字段，key是模块名，value是模块 (7)sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 (8)sys.platform #返回操作系统平台名称
3.5 json&pickle模块
(1)序列化的概念
我们把对象（变量）从内存中变成可存储或传输的过程称之为序列化，在python中叫pickling。
序列化后，就可以把序列化的内容写入磁盘或通过网络传输到别的机器上。
反序列化：把变量内容从序列化对象重新读到内存里，即unpickling。
(2)json的概念
如果在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如xml，但更好的方法是序列化为JSON。因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储磁盘或者通过网络传输，json不仅是标准格式，并且比xml快，而且可以直接在WEB页面中读取，非常方便。
JSON表示的对象就是标准的javascript语言的对象，JSON和python内置的数据类型对应如下：
| Json类型 | python类型 |
| {} | dict |
| [] | list |
| "string" | str |
| 1234.56 | int或float |
| true/false | True/False |
| null |
None |
(3)pickle
pickle的问题和所有其他编程语言特有的序列化问题一样，只用于python，并且不同版本的python可能不兼容，因此，只能用pickle保存那些不重要的数据。
(4) Json和pickle
Json 模块提供了四个方法： dumps、dump、loads、load
pickle 模块也提供了四个功能：dumps、dump、loads、load
a. dumps 和 dump:
dumps和dump 序列化方法
dumps只完成了序列化为str，
dump必须传文件描述符，将序列化的str保存到文件中 b. loads 和 load
查看源码：
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw): # Serialize ``obj`` to a JSON formatted ``str``. # 序列号 “obj” 数据类型 转换为 JSON格式的字符串
def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw): """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). 我理解为两个动作，一个动作是将”obj“转换为JSON格式的字符串，还有一个动作是将字符串写入到文件中，也就是说文件描述符fp是必须要的参数 """
示例代码（json）：
>>> import json >>> json.dumps([]) # dumps可以格式化所有的基本数据类型为字符串 '[]' >>> json.dumps(1) # 数字 '1' >>> json.dumps('1') # 字符串 '"1"' >>> dict = {"name":"Tom", "age":23} >>> json.dumps(dict) # 字典 '{"name": "Tom", "age": 23}'
a = {"name":"Tom", "age":23}
with open("test.json", "w", encoding='utf-8') as f:
# indent 超级好用，格式化保存字典，默认为None，小于0为零个空格
f.write(json.dumps(a, indent=4))
# json.dump(a,f,indent=4) # 和上面的效果一样
# ----------序列化 import json dic = {'name':'czd','age':23,'sex':'male'} print(type(dic)) #<class 'dict'> j=json.dumps(dic) print(type(j)) #<class 'str'> f=open('序列化对象1','w') f.write(j) #等价于json.dump(dic,f) f.close() # -----------反序列化 import json f=open('序列化对象1') data=json.loads(f.read()) #等价于data=json.load(f)
loads和load 反序列化方法
loads 只完成了反序列化，
load 只接收文件描述符，完成了读取文件和反序列化
查看源码
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``s`` (a ``str`` instance containing a JSON document) to a Python object. 将包含str类型的JSON文档反序列化为一个python对象"""
def load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. 将一个包含JSON格式数据的可读文件反序列化为一个python对象"""
import json with open("test.json", "r", encoding='utf-8') as f: aa = json.loads(f.read()) f.seek(0) bb = json.load(f) # 与 json.loads(f.read()) print(aa) print(bb) # 输出： {'name': 'Tom', 'age': 23} {'name': 'Tom', 'age': 23}
示例代码（pickle）
import pickle dic = {'name':'czd','age':23,'sex':'male'} print(type(dic)) #<class 'dict'> p=pickle.dumps(dic) print(type(p)) #<class 'str'> f=open('序列化对象1','w') f.write(j) #等价于pickle.dump(dic,f) f.close() # -----------反序列化 import pickle f=open('序列化对象1') data=pickle.loads(f.read()) #等价于data=pickle.load(f)
3.6 shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写；keys必须为字符串，而值可以是python所支持的数据类型。
##---------------shelve模块 import shelve f=shelve.open(r'shelve') #目的：将字典放入文本中 f={} f=shelve.open(r'shelve') # f['stu1_info']={'name':'alex','age':18} # f['stu2_info']={'name':'czd','age':21} # f['school_info']={'website':'fzuniversity.edu','city':"fuzhou"} # # f.close() print(f.get('stu1_info')['age'])
3.7 xml模块
xml模块是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来简单。
xml的格式如下，通过< >节点来区别数据结构的：
xml的格式： <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Pananma"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
xml的创建：
import xml.etree.ElementTree as ET new_xml=ET.Element("namelist") name=ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"}) age=ET.SubElement(name,"age",attrib={"checked":"no"}) sex=ET.SubElement(name,"sex") sex.text='33' name2=ET.SubElement(new_xml,"name",attrib={"enrolled":"no"}) age=ET.SubElement(name2,"age") age.text='19'