python基础---常用模块（未完待续）

re模块（正则模块）
正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。\w 匹配字母数字及下划线
\W 匹配非字母数字下划线
\s 匹配任意空白字符，等价于【\t\n\r\f】
\S 匹配任意非空字符
\d 匹配任意数字，等价于【0-9】
\D 匹配任意非数字
\A 匹配字符串
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\z 匹配字符串结束
\G 匹配最后匹配完成的位置
\n 匹配一个换行符
\t 匹配一个制表符
^ 匹配字符串的开头
$ 匹配字符串的末尾
. 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[…] 用来表示一组字符，单独列出：【amk】匹配’a’，’m’或‘k’
[^…] 不在[]中的字符
* 匹配0个或多个的表达式
+ 匹配1个或多个的表达式
? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
{n} 精确匹配n个前面表达式
{n,m} 匹配n到m次由前面的正则表达式定义的片段，贪婪方式
a|b 匹配a或b
() 匹配括号内的表达式，也表示一个组

import re
print(re.findall('\w','hello_ | egon 123'))
print(re.findall('\W','hello_ | egon 123'))
print(re.findall('\s','hello_ | egon 123 \n \t'))
print(re.findall('\S','hello_ | egon 123 \n \t'))
print(re.findall('\d','hello_ | egon 123 \n \t'))
print(re.findall('\D','hello_ | egon 123 \n \t'))
print(re.findall('h','hello_ | hello h egon 123 \n \t'))
print(re.findall('\Ahe','hello_ | hello h egon 123 \n \t'))
print(re.findall('^he','hello_ | hello h egon 123 \n \t'))
print(re.findall('123\Z','hello_ | hello h egon 123 \n \t123'))
print(re.findall('123$','hello_ | hello h egon 123 \n \t123'))
print(re.findall('\n','hello_ | hello h egon 123 \n \t123'))
print(re.findall('\t','hello_ | hello h egon 123 \n \t123'))

输出：
['h', 'e', 'l', 'l', 'o', '_', 'e', 'g', 'o', 'n', '1', '2', '3']
[' ', '|', ' ', ' ']
[' ', ' ', ' ', ' ', '\n', ' ', '\t']
['h', 'e', 'l', 'l', 'o', '_', '|', 'e', 'g', 'o', 'n', '1', '2', '3']
['1', '2', '3']
['h', 'e', 'l', 'l', 'o', '_', ' ', '|', ' ', 'e', 'g', 'o', 'n', ' ', ' ', '\n', ' ', '\t']
['h', 'h', 'h']
['he']
['he']
['123']
['123']
['\n']
['\t']

re模块提供的方法：
re.findall() 查找所有满足匹配条件的结果，放在列表中

re.search()             只找到第一个匹配到的然后返回一个包含匹配信息的对象，该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None

re.match()              同search，不过在字符串开始出进行匹配，完全可以使用search+^代替match

re.split()                 按匹配内容对对象进行分割

re.sub()                  替换，（老的值，新的值，替换对象，替换次数），不指定替换次数，默认替换所有

re.subn()                同sub，不过结果中返回替换的次数

re.compile             重用匹配格式

3、time模块
Python中，通常有以下三种方式来计算时间：
a.时间戳：
时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型

b.格式化的时间字符串
c.结构化的时间
struct_time元组共有9个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

4、random模块

5、os模块

6、sys模块

7、json和pickle模块（序列化模块）
把对象(变量)从内存中变成可存储或传输的过程称为序列化
在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等序列化的作用：
a.持久保存状态
在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化

b.跨平台数据交互
序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling

json模块
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便，所以json适合数据跨平台交互时使用（但是跨平台意味着不会支持某种语言的所有数据类型，如不支持python函数的序列化）

内存中结构化的数据<---> 格式json <--->字符串 <---> 保存到文件中或基于网络传输

使用：
dump 序列化
load 反序列化

import json
dic={'name':'egon','age':18}
with open('a.json','w') as f: # 序列化字典到文件内容
f.write(json.dumps(dic))
with open('a.json','r') as f: # 反序列化输出
data=f.read()
dic=json.loads(data)

dumps 序列化
loads 反序列化

import json
dic={'name':'egon','age':18}
json.dump(dic,open('b.json','w'))     # 序列化字典到文件内容
print(json.load(open('b.json','r'))['name'])  # 反序列化输出

pickle模块
pickle只能用于Python（所有数据类型），并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

内存中结构化的数据<---> 格式pickl<---> bytes类型 <---> 保存到文件中或基于网络传输
dumps 序列化
loads 反序列化
dump 序列化
load 反序列化

import pickle
dic={'name':'egon','age':18}
with open('d.pkl','wb') as f:        # 序列化字典到文件内容
f.write(pickle.dumps(dic))
with open('d.pkl','rb') as f:        # 反序列化输出
dic=pickle.loads(f.read())
print(dic['name'])

import pickle
dic={'name':'egon','age':18}
pickle.dump(dic,open('e.pkl','wb'))   # 序列化字典到文件内容
print(pickle.load(open('e.pkl','rb'))['name']) # 反序列化输出

pickle是根据内存地址进行反序列化的，所以该内存地址对应的数据在命名空间中必须是已定义的

8、shelve模块

9、shutil模块
高级的文件、文件夹、压缩包处理模块

常用方法：

将文件内容拷贝到另一个文件中：
shutil.copyfileobj(源文件, 目标文件[, length])

拷贝文件：
shutil.copyfile(src, dst) # 目标文件无需存在

仅拷贝权限。内容、组、用户均不变
shutil.copymode(src, dst) # 目标文件必须存在

仅拷贝状态的信息，包括：mode bits,atime, mtime, flags
shutil.copystat(src, dst) #目标文件必须存在

拷贝文件和权限
shutil.copy(src, dst)

拷贝文件和状态信息
shutil.copy2(src, dst)

递归的去拷贝文件夹
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None) #目标目录不能存在，注意对dst目录父级目录要有可写权限，ignore的意思是排除

拷贝软连接
import shutil
shutil.copytree('f1', 'f2', symlinks=True,ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件

递归的去删除文件
shutil.rmtree(path[, ignore_errors[,onerror]])

递归的去移动文件，它类似mv命令，其实就是重命名
shutil.move(src, dst)

创建压缩包并返回文件路径，例如：zip、tar
shutil.make_archive(base_name, format,...)
base_name：压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径
如 data_bak =>保存至当前路径
如 /tmp/data_bak =>保存至/tmp/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir：要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象

练习：

#将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

#将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

import zipfile
# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()

import tarfile

# 压缩
t=tarfile.open('/tmp/egon.tar','w')
t.add('/test1/a.py',arcname='a.bak')
t.add('/test1/b.py',arcname='b.bak')
t.close()

# 解压
t=tarfile.open('/tmp/egon.tar','r')
t.extractall('/egon')
t.close()

10、xml模块
xml是实现不同语言或程序之间进行数据交换的协议，跟json功能差不多，但json使用起来更简单，由于比json出现的早，至今很多传统公司如金融行业的很多系统的接口还主要是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进行操作：

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,child.attrib['name'])
fori in child:
print(i.tag,i.attrib,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')
node.set('version','1.0')
tree.write('test.xml')

#删除node
for country in root.findall('country'):
rank = int(country.find('rank').text)
ifrank > 50:
root.remove(country)

tree.write('output.xml')

11、configparser模块
主要用来解析配置文件
配置文件为以下格式：
[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

操作方法如下：
import configparser # 导入模块
config=configparser.ConfigParser() #使用ConfigParser方法得到一个对象赋值给config

查看标题：
config.sections()

查看标题section1下所有key=value的key
config.options('section1')

查看标题section1下所有key=value的(key,value)格式
config.items('section1')

查看标题section1下user的值，字符串格式
config.get('section1','user')

查看标题section1下age的值，整数格式
val1=config.getint('section1','age')

查看标题section1下is_admin的值，布尔值格式
config.getboolean('section1','is_admin')

查看标题section1下salary的值，浮点型格式
config.getfloat('section1','salary')

删除整个标题section2
config.remove_section('section2')

删除标题section1下的某个k1和k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')

判断是否存在某个标题
config.has_section('section1')

判断标题section1下是否有user
config.has_option('section1','user')

添加一个标题
config.add_section('egon')

在标题egon下添加name=egon,age=18的配置
config.set('egon','name','egon')
config.set('egon','age',18) #报错,必须是字符串

最后将修改的内容写入文件,完成最终的修改
config.write(open('a.cfg','w'))

12、hashlib模块
hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
三个特点：
1.内容相同则hash运算结果相同，内容稍微改变则hash值则变
2.不可逆推
3.相同算法：无论校验多长的数据，得到的哈希值长度固定

import hashlib

m=hashlib.md5()# m=hashlib.sha256()
m.update('hello'.encode('utf8'))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
m.update('alvin'.encode('utf8'))
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
'''
注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
但是update多次为校验大文件提供了可能。
'''

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib

# ######## 256 ########
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

import hashlib
passwds=[
'alex3714',
'alex1313',
'alex94139413',
'alex123456',
'123456alex',
'a123lex',
]
def make_passwd_dic(passwds):
dic={}
for passwd inpasswds:
m=hashlib.md5()
m.update(passwd.encode('utf-8'))
dic[passwd]=m.hexdigest()
return dic

def break_code(cryptograph,passwd_dic):
for k,v inpasswd_dic.items():
if v == cryptograph:
print('密码是===>\033[46m%s\033[0m'%k)

cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))
python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:
import hmac
h = hmac.new('alvin'.encode('utf8'))
h.update('hello'.encode('utf8'))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

#要想保证hmac最终结果一致，必须保证：
#1:hmac.new括号内指定的初始key一样
#2:无论update多少次，校验的内容累加到一起是一样的内容

import hmac

h1=hmac.new(b'egon')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())

h2=hmac.new(b'egon')
h2.update(b'helloworld')
print(h2.hexdigest())

h3=hmac.new(b'egonhelloworld')
print(h3.hexdigest())

'''
f1bf38d054691688f89dcd34ac3c27f2
f1bf38d054691688f89dcd34ac3c27f2
bcca84edd9eeb86f30539922b28f3981
'''

5.subprocess模块
在python解释器中开启一个子进程执行shell命令
stdout 标准正确输出 # 输出内容为bytes类型，如果在windows输出需要解码为decode（‘gbk’），linux解码为decode（‘utf-8’）
stderr 标准错误输出
stdin 标准输入
shell=True 使用shell命令
subprocess.PIPE 把输出结果放到管道

res1=subprocess.Popen('ls/Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
# 先列出桌面上的文件
subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,stdout=subprocess.PIPE)
# 把上面的数据交给这条命令作为输入结果，过滤以txt结尾的文件