模块&包

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

所以，模块一共三种：

  1. python标准库
  2. 第三方模块
  3. 应用程序自定义模块

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

模块导入方法

1 import 语句

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模块是与操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd os.curdir 返回当前目录: ('.') os.pardir 获取当前目录的父目录字符串名：('..') os.makedirs('dirname1/dirname2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname os.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不存在，返回False os.path.isabs(path) 如果path是绝对路径，返回True os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 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,time for i in range(10): sys.stdout.write('#') time.sleep(1) sys.stdout.flush()

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

import json x="[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内置的数据类型对应如下：
![](http://i2.51cto.com/images/blog/201808/21/494dc71a75522bcaba669b83c4040154.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)

#----------------------------序列化 import json

dic={'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 json f=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的数据才能loads

# pickle模块

##----------------------------序列化 import pickle

dic={'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 pickle f=open('序列化对象_pickle','rb')

data=pickle.loads(f.read())# 等价于data=pickle.load(f)

print(data['age'])

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
# shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型。（了解）

import shelve

f = 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 ET

tree = 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 ET

tree = 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")

#删除node for 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 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'

et = ET.ElementTree(new_xml) #生成文档对象 et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

# re模块
![](http://i2.51cto.com/images/blog/201808/21/328dbd9a1961096bf82a0f74fb217e55.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)

import re

ret=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) #alvinabcyuan6

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

## re.compile()

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

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

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

print(next(ret).group()) print(next(ret).group())