模块（Module）的概念：在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里的代码会越来越长，维护也越来越不易。为了编写可维护的代码，我们把很多函数分组，分别放在不同的文件里，很多语言都采用这个组织代码的方式，在python中一个.py文件就称之为模块。
使用模块的好处：大大提高代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

所以，模块一共三种：

另外，使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

import module1[, module2[,... moduleN]

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？答案就是解释器有自己的搜索路径，存在sys.path里。　　

['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']　```　因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。### 2 from…import 语句

from modname import name1[, name2[, ... nameN]]

这个声明不会把整个modulename模块导入到当前的命名空间中，只会将它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。### 3 From…import* 语句

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。### 4 运行本质　

#1 import test
#2 from test import add
```　　
无论1还是2，首先通过sys.path找到test.py,然后执行test脚本（全部执行），区别是1会将test这个变量名加载到名字空间，而2只会将add这个变量名加载进来。　　

os模块是与操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cdos.curdir 返回当前目录: ('.')os.pardir 获取当前目录的父目录字符串名：('..')os.makedirs('dirname1/dirname2') 可生成多层递归目录os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirnameos.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirnameos.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印os.remove() 删除一个文件os.rename("oldname","newname") 重命名文件/目录os.stat('path/filename') 获取文件/目录信息os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'os.system("bash command") 运行shell命令，直接显示os.environ 获取系统环境变量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不存在，返回Falseos.path.isabs(path) 如果path是绝对路径，返回Trueos.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回Falseos.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回Falseos.path.join(path2[, path3[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径sys.exit(n) 退出程序，正常退出时exit(0)sys.version 获取Python解释程序的版本信息sys.maxint 最大的Int值sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值sys.platform 返回操作系统平台名称小实例：进度条

import sys,timefor i in range(10): sys.stdout.write('#') time.sleep(1) sys.stdout.flush()JSON模块

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

import jsonx="[null,true,false,1]"print(eval(x))print(json.loads(x))什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

#----------------------------序列化import jsondic={'name':'alvin','age':23,'sex':'male'}print(type(dic))#<class 'dict'>j=json.dumps(dic)print(type(j))#<class 'str'>f=open('序列化对象','w')f.write(j) #-------------------等价于json.dump(dic,f)f.close()#-----------------------------反序列化import jsonf=open('序列化对象')data=json.loads(f.read())# 等价于data=json.load(f)

需要注意的是：

import json#dct="{'1':111}"#json 不认单引号#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}dct='{"1":"111"}'print(json.loads(dct))#conclusion:# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loadspickle模块

##----------------------------序列化import pickledic={'name':'alvin','age':23,'sex':'male'}print(type(dic))#<class 'dict'>j=pickle.dumps(dic)print(type(j))#<class 'bytes'>f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'f.write(j) #-------------------等价于pickle.dump(dic,f)f.close()#-------------------------反序列化import picklef=open('序列化对象_pickle','rb')data=pickle.loads(f.read())# 等价于data=pickle.load(f)print(data['age'])

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型。（了解）

import shelvef = shelve.open(r'shelve.txt')# f['stu1_info']={'name':'alex','age':'18'}# f['stu2_info']={'name':'alvin','age':'20'}# f['school_info']={'website':'oldboyedu.com','city':'beijing'}### f.close()print(f.get('stu_info')['age'])XML模块

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

<?xml version="1.0"?><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="Panama"> <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协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

import xml.etree.ElementTree as ETtree = ET.parse("xmltest.xml")root = tree.getroot()print(root.tag)#遍历xml文档for child in root: print(child.tag, child.attrib) for i in child: print(i.tag,i.text)#只遍历year 节点for node in root.iter('year'): print(node.tag,node.text)#---------------------------------------import xml.etree.ElementTree as ETtree = ET.parse("xmltest.xml")root = tree.getroot()#修改for node in root.iter('year'): new_year = int(node.text) + 1 node.text = str(new_year) node.set("updated","yes")tree.write("xmltest.xml")#删除nodefor country in root.findall('country'): rank = int(country.find('rank').text) if rank > 50: root.remove(country)tree.write('output.xml')

自己创建xml文档：

import xml.etree.ElementTree as ETnew_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'et = ET.ElementTree(new_xml) #生成文档对象et.write("test.xml", encoding="utf-8",xml_declaration=True)ET.dump(new_xml) #打印生成的格式re模块

import reret=re.findall('a..in','helloalvin')print(ret)#['alvin']ret=re.findall('^a...n','alvinhelloawwwn')print(ret)#['alvin']ret=re.findall('a...n$','alvinhelloawwwn')print(ret)#['awwwn']ret=re.findall('a...n$','alvinhelloawwwn')print(ret)#['awwwn']ret=re.findall('abc*','abcccc')#贪婪匹配[0,+oo] print(ret)#['abcccc']ret=re.findall('abc+','abccc')#[1,+oo]print(ret)#['abccc']ret=re.findall('abc?','abccc')#[0,1]print(ret)#['abc']ret=re.findall('abc{1,4}','abccc')print(ret)#['abccc'] 贪婪匹配

注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

ret=re.findall('abc*?','abcccccc')print(ret)#['ab']re.findall()

>>> re.findall('a|b','aliyunbooka') #返回所有满足匹配条件的结果,放在列表里['a', 'b', 'a']

下面这种情况需要注意：

>>> re.findall('www.(baidu).com','awww.baidu.comb')['baidu']

当规则中有分组时，findall会优先将分组中的元素放入列表，输出时也只输出分组中的元素。
如果需要输出匹配到的元素：

>>> re.findall('www.(?:baidu).com','awww.baidu.comb')['www.baidu.com']re.search()

函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

>>> re.search('a','aliyun').group()'a'

分组：

>>> ret=re.search('(?P<id>\d{2})-(?P<name>\w{3})','23-poe')>>> ret.group('id')'23'>>> ret.group('name')'poe're.match()

re.match('a','abc').group() #同search,不过只在字符串开始处进行匹配re.split()

ret=re.split('[ab]','abcd') #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割print(ret)#['', '', 'cd']re.sub()

ret=re.sub('\d','abc','alvin5yuan6',1) #参数1代表只匹配替换一次print(ret) #alvinabcyuan6ret=re.subn('\d','abc','alvin5yuan6')print(ret) #('alvinabcyuanabc', 2) #参数2，代表该函数匹配替换了两次re.compile()

obj=re.compile('\d{3}')ret=obj.search('abc123eeee')print(ret.group()) #123re.finditer()

findall()返回一个列表，finditer()返回一个可迭代对象

ret=re.finditer('\d','ds3sy4784a')print(ret) #<callable_iterator object at 0x10195f940>print(next(ret).group())print(next(ret).group())