Python自动化运维 - day6 - 常用模块

re模块

　　re模块，包含所有正则表达式的功能，可以使用正则表达式对字符串进行匹配过滤的，那么先来看一下正则表达式。

正则表达式

正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。

常用的规则如下表所示：

符号	含义
\w	字母、数字、下划线
\W	非字母、数字、下划线
\s	任意空白字符串，等价于[\t\n\r\f]
\S	任意非空字符串
\d	任意数字，等价于[0-9]
\D	任意非数字
\n	换行符(在windows下换行符为\r\n)
\t	制表符
^	字符串的开头
$	字符串的结尾
.	任意单个字符串,但是\n等是无法匹配到的，findall指定参数re.S(可以让.匹配到换行符)
[...]	用来表示一组，一个范围[a-c],等于a,b,c
*	表示前面的字符出现0次或者N次(前边可以是字符也可以是一个正则表达式)
+	表示前面的字符出现1次或者多次(前边可以是字符也可以是一个正则表达式)
?	匹配前面的字符或表达式，出现0次或者1次
{n}	表示前面的字符出现n次
{n,m}	表示前面的字符串最少出现n次，最多出现m次
.*	表示匹配任意长度的字符串(贪婪匹配)
.*?	表示匹配任意长度的字符串(非贪婪匹配)，
a|b	匹配a或b，如果匹配到a就不会继续匹配b，没有匹配到a才会继续匹配b
()	分组，这样只会返回分组里面的内容，就算后面有其他表达式也不会返回，在括号里面用?: 内部表示不单纯匹配括号里面的内容
compan(?:y|ies)	等于 company | companie

 

　更多常用的正则表达式在线转换工具：tool.oschina.net/regex/#

功能函数

re.findall(expression,val)
　　从val的左边进行查找，查找所有expression匹配到的字符串，并用list进行存储

例子：匹配所有的数字
                s = '1-2*(60+(-40.35/5.3+1.2)-(-4*3))'
                num = re.findall('\-?\d+\.?\d*',s)  #会匹配所有数字，包涵正负数，小数等

扩展：re.findall(r'\-?\d+\.\d+|(\-?\d+)','1-2*(60+(-40.35/5.3+1.2)-(-4*3))')   
                由于使用了(),既只显示()里面匹配到的元素，既只匹配到了正负整数

re.search(expression,val)
　　从value的左边进行查找，查找匹配expression的对象，找到1个既返回，找到则返回SRE对象，找不到就返回None，通过对象的.group()方法读取匹配到的信息

例子：匹配数字
s = '1-2*(60+(-40.35/5.3+1.2)-(-4*3))'
num = re.search('\-?\d+\.?\d*',s).group() #会匹配到第一个数字1，
扩展：re.search('exp1|exp2',val) 同时拿着exp1,exp2去val中匹配，满足任意一个，则返回
s = '1.3-2*(60+(-40.35/5.3+1.2)-(-4*3))'
num = re.search('\-?\d+\.\d+|\-?\d+',s).group() #匹配正负整数或者正负小数，任意一个匹配到则返回

re.match(expression,val)
　　从value开头开始找，匹配则返回SRE对象，不匹配就返回None，功能类似于 ^

例子：匹配a
s = 'daxin like Linux'
match = re.match('a',s) #返回None,re.match('d',s)则返回d

group()
　　对表达式进行分组

re.search('al(e)x mak(e)','alex make love').group() 结果类似于findall里面的 ?: ，如果 group(1)，则会匹配到底一个()里面的e，group(2),则会匹配到第二个()里面的e。    
group(int) int 表示匹配到的第几个括号的内容，如果不指定，则显示所有匹配到字符串
例子:
re.search('al(e)x mak(e)','alex make love').group() #结果：alex make
re.search('al(e)x mak(e)','alex make love').group(1) #结果: e

re.split(expression,val)
　　把val按照expression进行分割,支持按照正则表达式进行分割，返回list

例子：针对数字进行分隔
s = r'9+63+2-(12*2)/9'
list1 = re.split('[0-9]',s) #结果：['', '+', '', '+', '-(', '', '*', ')/', '']

re.sub('sub1','sub2',string)
　　把字符串中的sub1，替换为sub2

例子:
s = r'1.3-2*(60+(-40.35/5.3+1.2)-(-4*3))'
match = re.sub('-','A',s) #把-号，替换为A

扩展:
re.sub('(\w+)(\s)(\w+)(\s)(\w)$',r'\5\2\3\4\1','alex make love')
字符串换位，后面的数字表示前面括号匹配到的字符串，类似于Linxu下的sed命令

time模块

　　时间戳： time.time()
　　　　从1970年开始(unix元年),的秒数
　　结构化时间： time.localtime() #当前时区 UTC时区time.gmtime()
　　　　元祖的形式显示时间(time.localtime().tm_year()获取年，)
　　格式化时间： time.strftime('%Y-%m-%d %H:%M:%S')
　　　　%X 效果等同于 %H:%M:%S

　　转换关系：

#时间戳
print(time.time())
#时间戳转换为结构化时间
print(time.localtime(time.time()))
#时间戳转换为格式化时间(时间戳不能直接转换为格式化时间，需要使用结构化时间中继)
print(time.strftime('%Y-%m-%d',time.localtime(time.time())))

#结构化时间
print(time.localtime())
#结构化时间转换为时间戳
print(time.mktime(time.localtime()))
#结构化时间转换为格式化时间
print(time.strftime('%Y-%m-%d',time.localtime()))

#格式化时间
print(time.strftime('%Y-%m-%d %X'))
#格式化时间转换为结构化时间
print(time.strptime('2017-06-04','%Y-%m-%d'))
#格式化时间转换为时间戳(格式化时间不能直接转换为时间戳，需要使用结构化时间中继)
print(time.mktime(time.strptime(time.strftime('%Y-%m-%d'),'%Y-%m-%d')))

random模块

　　主要用来产生随机数

random.random() 0和1之间的小数

>>> random.random()
0.37989514876249375
>>> random.random()
0.3337038388412016
>>> 

random.randint(1,3) 取出1-3之间的整数,包含1,3

>>> random.randint(1,10)
4
>>> random.randint(1,10)
9
>>> random.randint(1,10)
1
>>> 

random.randrange(1,3) 取出1-3之间的整数,和普通 range 用法相同,顾前不顾后. (包含1不包含3)

>>> random.randrange(1,4)
2
>>> random.randrange(1,4)
1
>>> random.randrange(1,4)
2
>>> 

random.choice(iterable) 随机在iterable中去随机抽取一个对象

>>> random.choice([1,2,3,4,5,6])
1
>>> random.choice([1,2,3,4,5,6])
4
>>> random.choice([1,2,3,4,5,6])
3
>>> 

random.sample(iterable,int) 每次在iterable对象中选取 int 个元素，组成列表并返回

>>> random.sample([1,2,3,4,5,6,7,8],3)
[2, 8, 4]
>>> random.sample([1,2,3,4,5,6,7,8],3)
[4, 7, 8]
>>> random.sample([1,2,3,4,5,6,7,8],3)
[1, 6, 8]
>>> 

random.uniform(1,3) 随机选出1和3之间的小数

>>> random.uniform(1,2)
1.343193035913123
>>> random.uniform(1,2)
1.8532874990121724
>>> random.uniform(1,2)
1.960351385197145
>>> 

random.shuffle(itarable) 把 iterable 对象 的顺序进行打乱(洗牌)

>>> a = [ i for i in range(100)]
>>> random.shuffle(a)
>>> a
[46, 24, 48, 17, 50, 10, 34, 90, 29, 33, 85, 21, 71, 14, 78, 58, 55, 54, 45, 12, 60, 70, 66, 73, 95, 23, 59, 69, 68, 35, 88, 93, 53, 84, 61, 36, 82, 30, 31, 20, 56, 64, 4, 40, 42, 32, 7, 77, 27, 22, 1, 74, 28, 19, 96, 8, 94, 80, 2, 9, 16, 44, 57, 11, 41, 92, 5, 43, 83, 81, 37, 47, 15, 86, 6, 13, 89, 87, 79, 98, 38, 72, 99, 51, 63, 26, 0, 18, 67, 3, 91, 25, 97, 62, 76, 75, 65, 52, 49, 39]
>>> 

注意：会直接作用在iterabel对象上,不会产生副本

例子：编写随机验证码

import random

def check(n):
    code = ''
    for i in range(n):
        num = random.randint(1,9)
        s = chr(random.randint(65,90))
        add = random.choice([num,s])
        code += str(add)
return code

print(check(3))    

os模块

os.getcwd():获取当前路径
os.chdir()：切换当前目录，当路径中存在\的时候，由于是转意的意思，那么就需要对\进行转意，那么路径就是c:\\User,或者在目录前面加r，表示后面的字符串不进行解释
os.curdir():获取当前目录名
os.pardir():获取上级目录名
os.mkdir('dir'):创建目录，注意只能创建一级目录
os.makedirs('dir_path'):创建多级目录
os.rmdir('dir'):删除一个目录
os.removedir('dir_path')：删除多级目录（目录为空的话）
os.listdir('dir'):显示目录下的所有文件,默认为当前目录,返回的结果为list
os.remove('file'):删除一个文件
os.rename('old_name','new_name'):修改文件名称
os.stat('file/dir')：获取文件/目录的stat信息
os.sep:返回当前操作系统的路径分隔符
Windows下：\\ , Linux下:/
os.linesep:返回当前操作系统的换行符
Windows下:\r\n  ,Linux下:\n
os.pathsep:返回当前操作系统环境变量分隔符
Windows下：;   ,   Linux下： :
os.name:返回当前系统的类型
nt 表示Windows,  posix表示Linux
os.system('Commmand'):执行命令
os.environ:获取系统环境变量，使用字典存储
os.path.abspath('dir/file'):获取dir/file的绝对路径
os.path.split('path'):把路径分割为目录和文件名组成的元组格式，不管path是否存在
os.dirname('path')：获取文件的父目录名称，不管path是否存在
os.basename('path'):获取文件的名称，不管path是否存在
os.path.exists('path'):判断path是否存在,return bool
os.path.isabs('path')：判断path是否是从根开始,return bool
Linux下：从/开始    Windows下从C,D,E盘开始
os.path.isfile('path'):判断path是否是一个文件
os.path.isdir('path')：判断path是否是一个目录
os.path.join('path1','path2','path3')：把path1和path2及path3进行组合，但如果path2中包含了根路径，那么就会舍弃path1,从path2开始组合
os.path.getatime('path'):获取文件的atime时间，返回时间戳
os.path.getmtime('path')：获取文件的mtime时间，返回时间戳
os.path.getsize(filename)： 获取文件的大小，单位是字节

os.walk

　　日常的工作中，可能常常需要使用查找某个目录下的符合某些规则的文件，并且可能是递归查询，对于这类需求可以使用os.walk模块。

　　walk函数便利某个目录及其子目录，对于每一个目录，os.walk返回一个三元组(dirpath,dirnames,filenames)。

• • dirname：表示目录名
  • dirnames：表示目录下的子目录名称
  • filenames：表示目录下的文件名

>>> name = os.walk('/Users/DahlHin/Python')  # 返回的是一个生成器
>>> for roots,dirs,filenames in name:
	for file in filenames:
		filename = os.path.join(roots,file)
		file_list.append(filename)

# file_list 则存储了Python目录下的所有文件

列出目录下所有以.txt结尾的文件

>>> 
>>> import fnmatch
>>> import os
>>> file_list = []
>>> name = os.walk('/Users/DahlHin/Python')
>>> for roots,dirs,files in name:
	for file in files:
		filename = os.path.join(roots,file)
		if fnmatch.fnmatch(filename,"*.txt"):
			file_list.append(filename)		
>>> file_list

sys模块

sys.argv  命令行参数List，第一个元素是程序本身路径（空表示当前目录）
sys.exit(n)  退出程序，如果n为数字的话，那么就是 echo $?的值，如果是 str,那么会直接打印在屏幕上
sys.version  获取python解释器的版本信息
sys.maxint  获取当前操作系统最大的int值（2.x的时候，32位主机和64为主机int值范围不同） --> python 2
sys.path  Python的初始环境变量
sys.platform  返回操作系统的平台名称
sys.stdout  标准输出(其实就是屏幕，本质上标注你输出也是一个文件，也有write方法)
sys.stdout.write('str')  把 str 写到标准输出中去 注意：'\r'跳到行首

PS：在sys.path中添加当前目录，可以让Python解释器，在当前目录寻找模块，或者包，不过还有另一种方法是设置环境变量PYTHONPATH，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径，Python自己本身的搜索路径不受影响。

shutil模块

shutil.copyfileobj(fsrc,fdes,length)  将文件内容拷贝到另一个文件中，可以只拷贝部分内容，需要我们自行打开文件对象进行copy

>>> import os,shutil
>>> os.system('ls')
1.txt
>>> shutil.copyfileobj(open('1.txt'),open('2.txt','w'))
>>> os.system('ls')
1.txt  2.txt
>>> 

 

shutil.copyfile(fsrc,fdes)  复制文件，我们只需要传入文件名称即可进行复制，不用自行预先打开，等于创建一个新的文件，把老文件写入到新文件中然后关闭，新创建的文件权限和属主等信息遵循操作系统规定

>>> shutil.copyfile('1.txt','3.txt')
>>> os.system('ls')
1.txt  2.txt  3.txt

 

shutil.copymode(src,des)  复制文件权限，既把src文件的权限复制给 des文件，只改变权限，不改变其他比如属组，内容等(des文件必须存在)

>>> os.system('ls -l')
total 12
-rwxrwxrwx 1 root root 6 Mar  9 18:35 1.txt
-rw-r--r-- 1 root root 6 Mar  9 18:36 2.txt
-rw-r--r-- 1 root root 6 Mar  9 18:38 3.txt
>>> shutil.copymode('1.txt','2.txt')
>>> os.system('ls -l')
total 12
-rwxrwxrwx 1 root root 6 Mar  9 18:35 1.txt
-rwxrwxrwx 1 root root 6 Mar  9 18:36 2.txt
-rw-r--r-- 1 root root 6 Mar  9 18:38 3.txt
>>> 

shutil.copystat(src,des)  复制文件的权限，还包括，atime，mtime，flags等信息，不改变文件内容（des需存在）

>>> os.system('stat 1.txt')
  File: `1.txt'
  Size: 6             Blocks: 8          IO Block: 4096   regular file
Device: fd00h/64768d    Inode: 926326      Links: 1
Access: (0777/-rwxrwxrwx)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2017-03-09 18:36:59.223738919 +0800
Modify: 2017-03-09 18:35:23.148738381 +0800
Change: 2017-03-09 18:39:59.061738605 +0800

>>> os.system('stat 3.txt')
  File: `3.txt'
  Size: 6             Blocks: 8          IO Block: 4096   regular file
Device: fd00h/64768d    Inode: 940237      Links: 1
Access: (0644/-rw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2017-03-09 18:39:42.214738376 +0800
Modify: 2017-03-09 18:38:13.862738316 +0800
Change: 2017-03-09 18:38:13.862738316 +0800

>>> shutil.copystat('1.txt','3.txt')
>>> os.system('stat 3.txt')
  File: `3.txt'
  Size: 6             Blocks: 8          IO Block: 4096   regular file
Device: fd00h/64768d    Inode: 940237      Links: 1
Access: (0777/-rwxrwxrwx)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2017-03-09 18:36:59.223738000 +0800
Modify: 2017-03-09 18:35:23.148738000 +0800
Change: 2017-03-09 18:44:33.286738354 +0800
>>> 

shutil.copy(src,des)  复制文件的同时复制权限信息（等于shutil.copyfile + shutil.copystat）

shutil.copytree(des,src,ignore = shutil.ignore_patterns('*py'))  递归复制文件，类似于copy -r

>>> os.system('ls -l')
total 4
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test

>>> shutil.copytree('test','test1')
>>> os.system('ls -l')
total 8
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test1

>>> os.system('ls -l test1')
total 12
-rwxrwxrwx 1 root root 6 Mar  9 18:35 1.txt
-rwxrwxrwx 1 root root 6 Mar  9 18:36 2.txt
-rwxrwxrwx 1 root root 6 Mar  9 18:35 3.txt
>>> 

shutil.rmtree(des)  递归的删除文件，类似于　rm -rf

>>> os.system('ls -l')
total 8
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test1

>>> shutil.rmtree('test1')
>>> os.system('ls -l')
total 4
drwxr-xr-x 2 root root 4096 Mar  9 18:46 test
>>> 

shutil.move(src,des)  移动文件/目录，类似于mv 命令

shutil.make_archive('data_bak','gztar',roots_dir = '/data' )  压缩，data_bak 可以写为绝对路径

import tarfile
t = tarfile.open('data_bak.tar.gz') #打开我呢间
t.extractall('/tmp') #解压缩到某个路径
t.close()

#tar打包
t = tarfile.open('data_bak.tar','w')
t.add(r'/tmp/1.txt') -->　#会把程序的路径也进行打包
t.close()

#tar打包
t =tarfile.open('data_bak.tar.gz')
t.add('/tmp/1.txt',arcname='1.txt_bak') # 打包的时候把 /tmp/1.txt　打包成 1.txt_bak

json&pickle模块

为什么要序列化
　　1、持久保存状态
　　2、跨平台数据交互
如何序列化：
　　1、json(跨平台) 支持字典(dict)、列表(list)、字符串(str)、整型浮点型(int/float)、bool(True,False),null(None)
　　2、pickle(纯Python)

eval不能识别非Python语法的数据类型，所以很多时候要用json

json

序列化：

import json
string = json.dumps(obj)   #直接把obj转换成str
with open('a.json','w') as f:
    f.write(string)

　　反序列化：

import json
with open('a.json','r') as f:
    res = f.read()
json.loads(res)      #把str转换成Python识别的数据格式

　　直接序列化到文件中去：

import json
json.dump(obj,文件对象(w方式))

　　直接从文件中反序列化：

import json
json.load(文件对象（r模式)

PS：Json默认情况下，dumps()方法不知道如何将类实例变为一个JSON的{}对象。可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为类专门写一个转换函数，再把函数传进去即可：

import json

class Student(object):

    def __init__(self,name,age,job):
        self.name = name
        self.age = age
        self.job = job


def converclass(std):

    return {
        'name':std.name,
        'age':std.age,
        'job':std.job
    }

a = Student('daxin',20,'Pythoner')
a_json = json.dumps(a,default=converclass)
print(a_json)

但是如果再来一个Teacher类的话，那么上面的转换方法就不适用了，这里我们可以偷个懒，使用类的__dict__属性

import json

class Student(object):

    def __init__(self,name,age,job):
        self.name = name
        self.age = age
        self.job = job

a = Student('daxin',20,'Pythoner')
a_json = json.dumps(a,default=lambda obj:obj.__dict__)
print(a_json)

同样反序列化的时候，使用object_hook可以定制反序列化的规则

import json

class Student(object):

    def __init__(self,name,age,job):
        self.name = name
        self.age = age
        self.job = job

a = Student('daxin',20,'Pythoner')
a_json = json.dumps(a,default=lambda obj:obj.__dict__)

def restoclass(s):
    return Student(s['name'],s['age'],s['job'])

b = json.loads(a_json,object_hook=restoclass)

pickle

　　序列化：需要用b模式打开文件

import pickle
dic = {
'name':'daxin',
'age':18,
'job':'Linux'
}

pic_dumps = pickle.dumps(dic) #序列化存储
with open('a.pickle','wb') as fd:
    fd.write(pic_dumps)

　　反序列化：

import pickle
with open('a.pickle','rb') as fd:
    dic = pickle.loads(fd.read())

　　直接序列化到文件中去：

import pickle
dic = {
'name':'daxin',
'age':18,
'job':'Linux'
}
pickle.dump(dic,open('b.pickle','wb'))

　　直接从文件中反序列化：

import pickle
with open('b.pickle','rb') as fd:
    print(pickle.loads(fd.read()))

小结

　　1、json是通用的格式，如果涉及多个系统之间的交互，选用json
　　2、pickle是python特有的，可以序列化一些python独特的数据类型，比如函数
　　3、pickle序列化函数的时候，只会序列化函数的内存地址，在脚本执行完毕，那么函数的内存地址就会释放，在其他文件反序列化的时候，那么因为原脚本已经执行完毕，原函数已经释放，所以就会报找不到该函数

shevle模块

　　shelve是一个简单的k,v将内存数据通过文件持久化的模块，是对pickle的更高级的封装，可以持久化任何pickle可支持的python数据格式，可以对数据进行多次的dump和load，而不用担心数据混乱。

　　注意：它的格式为k,v存储。默认会生成三个文件（.bak/.dat/.dir）

例子：
import shelve

l = [1,2,3,4,5]
d = {'name':'daxin','age':20}
s = {1,2,3,4,5}

#dump
f = shelve.open('shevle')
f['l'] = l
f['d'] = d
f['s'] = s
f.close()

#load
t = shelve.open('shevle')
print(t['l'])
print(t['d'])
print(t['s'])
t.close()

hashlib模块

　　用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

使用方法1：
 hashlib.md5('str').hexdigest() #用MD5对str进行加密，使用hexdigest(),16进制的方式打印 

使用方法2：

md5 = hashlib.md5()
md5.update('hello')  #如果第一次执行update，那么就是对hello这个字符串进行MD5加密（注意，这里是累加，如果多次update，那么求得是累加的md5值）
md5.hexdigest()  #把md5对象保存的str，以16进制进行显示

例子：把文件读入，然后用md5进行校验

import hashlib
import sys

def md5sum(f):
    m = hashlib.md5()
    with open(f) as fd:
        while True:
            data = fd.read(4096)
            if data:
                m.update(data)
            else:
                break
    return m.hexdigest()
if __name__ == '__main__':
   try:
       print md5sum(sys.argv[1]),sys.argv[1]
   except IndexError as e:
       sys.stderr.write('%s want a file\n' %  __file__)

 以上加密算法，可以通过撞库（枚举），去破解，所以我们可以在字符前面加上指定的字符串进行二次加密

>>> import hashlib
>>> m = hashlib.md5('12asvac23as')
>>> m.update('hello')
>>> m.hexdigest()
'cedc722f4b9836fb510c1cc5a4af890c'
>>> 

subprocess模块

　　运行python的时候，我们都是在创建并运行一个进程。像Linux进程那样，一个进程可以fork一个子进程，并让这个子进程exec另外一个程序。在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。
　　subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用。另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

subprocess.call('cmd') 父进程等待子进程完成，返回退出信息(return code，相当于Linux exit code)，功能类似于os.system 无法捕获结果。

>>> import subprocess
>>> subprocess.call('w')
19:27:07 up 4 days, 11:55, 5 users, load average: 0.00, 0.00, 0.00
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root tty1 - Sun07 28:08m 0.03s 0.03s -bash
root pts/2 10.0.0.1 17:13 1:37m 0.13s 0.13s -bash
root pts/3 10.0.0.1 17:18 2:07m 0.01s 0.01s -bash
root pts/4 10.0.0.1 18:01 0.00s 0.10s 0.07s python
root pts/5 10.0.0.1 18:39 40:55 0.08s 0.08s -bash
>>> 

注意：
　　subprocess.call('ls -l')
　　注意当执行的cmd中有空格的时候，python解释器会认为后面的是文件，就会报错，那么就需要添加参数shell = True,标识使用shell的方式执行
　　或者使用列表 subprocess.call(['ls','-l'])
　　subprocess.call('ps axu | grep python',shell=True) 这样就可以

subprocess.check_call('cmd') 功能和call相同，无法捕捉结果。与call不同的是，check_call默认会检查命令的返回值，如果不是0，则会返回subprocess.CalledProcessError异常，

>>> subprocess.check_call(['rm' ,'-rf' ,'/etc/hosts'])
rm: cannot remove `/etc/hosts': Permission denied
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib64/python2.6/subprocess.py", line 505, in check_call
raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command '['rm', '-rf', '/etc/hosts']' returned non-zero exit status 1
>>>

　　try抓取subprocess.CalledProcessError异常，然后处理

[redis@linux-node1 ~]$ cat sub.py 
#!/usr/bin/env python

import subprocess

try:
subprocess.check_call(['rm','-rf','/etc/hosts'])
except subprocess.CalledProcessError as e:
print('hello world')
[redis@linux-node1 ~]$ 
[redis@linux-node1 ~]$ python3 sub.py 
rm: cannot remove `/etc/hosts': Permission denied
hello world

subprocess.Popen() 调用外部命令的时候，也会像C那样fork一个子进程进行执行
　　通用语法1：subprocess.Popen('cmd',shell=True,stdout=subprocess.PIPE)
　　通用语法2：subprocess.Popen(['cmd'],stdout=subprocess.PIPE) -->一般用这种
　　上面两行代码功能相同，不写stdout的话，默认会把输出打印到当前的屏幕上
　　PIPE 表示管道符，会把命令的输出方式暂时缓存，然后通过对应的方式进行读取
　　p.stdout.read() 从管道符中读取命令执行结果
　　　　stdout 表示标准输出
　　　　stdin 表示标准输入
　　　　stdin=subprocess.PIPE,表示输入从PIPE读取
　　　　stderr 表示错误输出
　　Popen对象的方法:
　　　　p.pid 查看子进程的PID
　　　　p.poll() 查看执行状态，完毕返回0
　　　　p.returncode 获取进程的返回值
　　　　p.kill()　kill掉相关进程
　　　　p.terminate() 暂停进程
　　　　p.wait() 等待进程执行完毕
　　　　p.communicate() 可以和子进程进行交互，可以给子进程的stdin传递参数（子进程的stdin为PIPE），会返回一个元组，（stdout,stderr）,需要子进程也输出到PIPE，这样才能接收到 ，所以它会等待子进程执行完毕，相当于p.stdin.write()、p.stdin.close()，p.stdout.read()三个方法
　　例子：

 p = Popen(['ls'],stdout=PIPE,stderr=PIPE) ; stdout,stderr = p.communicate() 获取p的stdout和stderr  

注意：
　　Popen会fork一个子进程去执行命令，父脚本会继续向下执行，如果要等待Popen执行完毕，那么就需要使用p.wait()来等待子进程执行完毕，再继续执行

PIPE 管道会把命令的结果进行储存
例子：

p1 = Popen(['ls'],stdout = PIPE)
p2 = Popen(['grep','py'],stdin=p1.stdout,stdout=PIPE)
p2.stdout.read()

log模块

　　主要用于输出日志信息的模块，其根据日志的级别分为六部分：NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL，只有大于当前日志等级的操作才会被记录。

例子：直接输出日志到屏幕上

import logging

logging.warning('user [root] attempted wrong password more than 3 times')
logging.critical('Mysql Service is gone down')

如果想把日志输出到文件中去

import logging
logging.basicConfig(filename='access.log',level=logging.INFO) #这里可以使用日志级别对应的数字进行指定
logging.info('hello info')
logging.warning('hello warning')
logging.error('hello error')

指定日志格式

import logging

logging.basicConfig(filename='access.log', level=logging.INFO,
　　format = '%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',
　　datefmt = '%Y-%m-%d %X')
logging.info('hello info')
logging.warning('hello warning')

logging.basicConfig函数各参数:
　　filename: 指定日志文件名
　　filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
　　datefmt: 指定时间格式，同time.strftime()
　　level: 设置日志级别，默认为logging.WARNING
　　stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略
　　format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:

%(name)s Logger的名字
%(levelno)s 数字形式的日志级别()
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s 用户输出的消息

日志等级(数字表达形式)：

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

confingparser模块

　　用于生成和修改常见配置文档，比如：MySQL
　　在2.x里，模块名为ConfigParser，在3.x里为configparser
　　在configparser的参数通过字典进行定义

例子：利用configparser编写一个配置文件

import configparser

config = configparser.ConfigParser() # 实例化一个配置对象
#定义方法1：直接利用key：value定义
config['Default'] = {'name':'daxin','age':20,'job':'Linux'}

#定义方法2：
config['Global'] = {}
config['Global']['name'] = 'daxin'
config['Global']['age'] = '20'
config['Global']['job'] = 'Linux'

#定义方法3：
config['localhost'] = {}
localconfig = config['localhost']
localconfig['name'] = 'daxin'
localconfig['age'] = '20'
localconfig['job'] = 'Linux'

#写入配置文件
with open('example.ini','w') as fd:
config.write(fd) #这里的确是通过实例化的对象的write，写入一个打开的文件中去

读取配置文件内容：

# Author:Lee Sir

import configparser
conf = configparser.ConfigParser() #创建一个configparser对象
conf.read('example.ini') #读取配置文件
for node in conf.sections(): #sections表示列出配置文件中配置段的title
    print(node)
    for item in conf[node]:
        print(item,conf[node][item])

XML模块

　　xml可扩展标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。
　　功能是实现不同语言或程序之前进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，json还没有诞生的黑暗年代，大家只能选择用xml进行数据交换，所以很多老系统的接口还是xml

　　xml的格式，主要通过<>节点来区别数据结构的

示例数据：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>      -->    rank为开头   /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/自结束标签，可以在/之前添加参数等
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

利用python处理xml数据
　　python有三种方法来解析xml，SAX、DOM、以及ElementTree
　　因为elementTree更轻量级，所以这里用ElementTree进行学习

例子：

# Author:Lee Sir
import xml.etree.ElementTree as ET #引入ElementTree模块对xml进行处理

tree = ET.parse("xmltest.xml") #ElementTree.parse(source,parser=None) 将xml文件进行加载，并返回ElementTree对象，parser表示使用什么解析器，默认使用标准的xml解析器

root = tree.getroot() #得到根节点，返回根节点的element对象（既最外层的tag名称），这里也可以使用find，查找匹配到的第一个tag,tree.find('data'),并返回以该tag为起始的根结点树状结构

print(root.tag) #打印最外层的tag的名称

# 遍历xml文档
for child in root: #遍历根节点
    print(child.tag, child.attrib) #打印根节点下的tag的名称和属性
    for i in child: #如果有嵌套tag，那么打印tag的名称是对应的值
       print(i.tag, i.text)

# 只遍历year 节点
for node in root.iter('year'): #root.iter对所有tag节点进行过滤year
    print(node.tag, node.text) #打印对应的tag名称和值

 

增删改查：
http://www.tuicool.com/articles/fmMz2m