Python之路【第七篇】:常用模块
一. 模块介绍
1. 什么是模块
在前面的几个章节中我们基本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。
为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
如：os 是系统相关的模块；file是文件操作相关的模块
模块分为三种：
- 自定义模块
- 第三方模块
- 内置模块
自定义模块 和 开源模块的使用参考： http://www.cnblogs.com/wupeiqi/articles/4963027.html
2、导入模块
Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：
import module from module.xx.xx import xx from module.xx.xx import xx as rename from module.xx.xx import *
导入模块其实就是告诉Python解释器去解释那个py文件
- 导入一个py文件，解释器解释该py文件
- 导入一个包，解释器解释该包下的 __init__.py 文件 【py2.7】
那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path
import sys print(sys.path)
如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。
import sys import os project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(project_path)
3. 使用原则
内置模块是Python自带的功能，在使用内置模块相应的功能时，需要遵循【先导入】再【使用】的原则
二. 常用模块
time模块
在Python中，通常有这几种方式来表示时间：
- 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
- 格式化的时间字符串(Format String)
- 结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
import time print(time.time()) # 时间戳:1496238345.38 print(time.strftime("%Y-%m-%d %X")) # 格式化的时间字符串:'2017-05-31 21:45:45' print(time.localtime()) # 本地时区的struct_time ''' time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0) # ''' print(time.gmtime()) # UTC时区的struct_time ''' time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=13, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0) '''
其中计算机认识的时间只能是'时间戳'格式，而程序员可处理的或者说人类能看懂的时间有: '格式化的时间字符串'，'结构化的时间' ，于是有了下图的转换关系
# --------------------------按图1转换时间 # localtime([secs]) # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。 print(time.time()) print(time.localtime()) print(time.localtime(1496238894.0)) # gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。 # mktime(t) : 将一个struct_time转化为时间戳。 print(time.mktime(time.localtime())) # 1496238894.0 # strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。 print(time.strftime("%Y-%m-%d %X", time.localtime())) # 2017-05-31 21:52:58 # time.strptime(string[, format]) # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。 print(time.strptime('2017-05-31 21:52:58', '%Y-%m-%d %X')) # time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58, # 在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。 ''' 1496238989.034 time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=56, tm_sec=29, tm_wday=2, tm_yday=151, tm_isdst=0) time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=54, tm_sec=54, tm_wday=2, tm_yday=151, tm_isdst=0) 1496238989.0 2017-05-31 21:56:29 time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58, tm_wday=2, tm_yday=151, tm_isdst=-1) '''
asctime及ctime用法
# --------------------------按图2转换时间 # asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。 # 如果没有参数，将会将time.localtime()作为参数传入。 print(time.asctime())# Wed May 31 22:00:10 2017 # ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。 print(time.ctime()) # Wed May 31 22:00:10 2017 print(time.ctime(time.time())) # Wed May 31 22:00:10 2017 ''' Wed May 31 22:00:10 2017 Wed May 31 22:00:10 2017 Wed May 31 22:00:10 2017 '''
其他用法(sleep)
# 脚本或线程推迟指定的时间运行，单位为秒。 time.sleep(5)
random模块
import random print(random.random())#(0,1)----float 大于0且小于1之间的小数 print(random.randint(1,3)) #[1,3] 大于等于1且小于等于3之间的整数 print(random.randrange(1,3)) #[1,3) 大于等于1且小于3之间的整数 print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5] print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合 print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716 item=[1,3,5,7,9] random.shuffle(item) #打乱item的顺序,相当于"洗牌" print(item)
#!/usr/bin/env python #-*- coding:utf-8 -*- import random def v_code(): code = '' for i in range(5): # 验证码位数 num=random.randint(0,9) alf=chr(random.randint(65,90)) add=random.choice([num,alf]) code += str(add) return code print(v_code())
OS模块
提供对操作系统进行调用的接口
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd os.curdir 返回当前目录: ('.') os.pardir 获取当前目录的父目录字符串名：('..') os.makedirs('dir1/dir2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 os.remove() 删除一个文件 os.rename("oldname","new") 重命名文件/目录 os.stat('path/filename') 获取文件/目录信息 os.sep 操作系统特定的路径分隔符，win下为"\\",Linux下为"/" os.linesep 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" os.pathsep 用于分割文件路径的字符串 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所指向的文件或者目录的最后修改时间
#!/usr/bin/env python #-*- coding:utf-8 -*- import os # 在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为反斜杠。 print(os.path.normcase('c:/windows\\system32\\')) ''' os.path.normcase('c:/windows\\system32\\') ''' # 规范化路径，如..和 / print(os.path.normpath('c://windows\\System32\\../Temp/')) ''' c:\windows\Temp ''' path = '/Users/shuke/data/\\file/\\\\update.py/../..' print(os.path.normpath(path)) ''' \Users\shuke\data
#方式一：推荐使用 import os #具体应用 import os,sys possible_topdir = os.path.normpath(os.path.join( os.path.abspath(__file__), os.pardir, #上一级 os.pardir, os.pardir )) sys.path.insert(0,possible_topdir) #方式二：不推荐使用 os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys模块
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
import sys,time for i in range(50): sys.stdout.write('%s\r' %('#'*i)) sys.stdout.flush() time.sleep(0.1) ''' 注意：在pycharm中执行无效，请到命令行中以脚本的方式执行 ''' 进度条
shutil模块
模块作用: 一个比较高级的 文件、文件夹、压缩包 处理模块
#!/usr/bin/env python #-*- coding:utf-8 -*- import shutil # 1.shutil.copyfileobj(fsrc, fdst[, length]) # 将文件内容拷贝到另一个文件中,可以copy指定大小的内容 shutil.copyfileobj(open('Readme','r'),open('Readme_bak','w')) # 2.shutil.copyfile(src, dst) # 拷贝文件 shutil.copyfile('login.log','login_2017-06-05') # 3.shutil.copymode(src, dst) # 仅拷贝权限。内容、组、用户均不变 shutil.copymode('login.log','login_2017-06-05') # 文件必须存在 # 4.shutil.copystat(src, dst) # 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags shutil.copystat('Readme','Readme_bak') # 5.shutil.copy(src, dst) # 拷贝文件和权限 shutil.copy('Readme','Readme_bk') # 6.shutil.copy2(src, dst) # 拷贝文件和状态信息 shutil.copy2('Readme','Readme_bk') # 7.shutil.ignore_patterns(*patterns) # shutil.copytree(src, dst, symlinks=False, ignore=None) # 递归的去拷贝目录,以及软连接的处理方式 shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',ignore=shutil.ignore_patterns('*.log')) ''' 注意: 目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 ''' shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',symlinks=True,ignore=shutil.ignore_patterns('*.log')) ''' 注意: 通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件 ''' # 8.shutil.rmtree(path[, ignore_errors[, onerror]]) # 递归的去删除文件 shutil.rmtree(r'E:\YQLFC\study\day06\study01') # 9.shutil.move(src, dst) # 递归的去移动文件，它类似mv命令，其实就是重命名。 shutil.move(r'E:\YQLFC\study\day06\study01',r'E:\YQLFC\study\day06\study02')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
创建压缩包并返回文件路径，例如：zip、tar
- 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('study.zip', 'w') # 包名 z.write('login.log') # 将指定文件压缩至压缩包中 z.write('Readme') z.close() # 解压 z = zipfile.ZipFile('study.zip', 'r') z.extractall(path='.') # 解压路径，可以指定，默认当前 z.close()
import tarfile # 压缩 t=tarfile.open('/tmp/study.tar','w') t.add('/data/study/Readme',arcname='Readme_bk') t.add('/data/study/login.log',arcname='login.log_bk') t.close() # 解压 t=tarfile.open('/tmp/study.tar','r') t.extractall('/data/tmp') t.close()
json和pickle模块
之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
import json x="[null,true,false,1]" print(eval(x)) #报错，无法解析null类型，而json就可以 print(json.loads(x))
什么是序列化？
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
为什么要序列化？
1：持久保存状态
需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。
内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。
在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。
具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。
2：跨平台数据交互
序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
json序列化应用
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
示例:
import json # ********dumps&&loads搭配使用*********** # 1. 序列化 dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} j = json.dumps(dic) print(type(j)) # <class 'str'> # 将dumps后的str类型的数据写入文件 f = open('info.json', 'w') f.write(j) # 等价于json.dump(dic,f) f.close() # 2.反序列化(读取数据加载到内存中) f = open('info.json') data = json.loads(f.read()) # 等价于data=json.load(f)
# ********dump&&load搭配使用*********** # (大多应用于将内存中的数据保存至本地存储进行读写操作时) # 1. 序列化 dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} json.dump(dic,open('info1.json','w')) # 2. 反序列化 data=json.load(open('info1.json','r')) print(data,type(data)) ''' 执行结果: {'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'> '''
注意的问题:
import json # dct="{'1':111}" #json 不认单引号 # dct=str({"1":111}) # 报错,因为生成的数据还是单引号:{'one': 1} # print(dct) # 转换后还是单引号 dct='{"1":"111"}' print(json.loads(dct)) ''' 执行结果: {'1': '111'} '''
注: 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads
pickle序列化应用
import pickle dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} # 1. 序列化 p = pickle.dumps(dic) print(type(p)) # <class 'bytes'> f = open('info.pkl', 'wb') # 注意是w是写入str,wb是写入bytes,p是'bytes'类型 f.write(p) # 等价于pickle.dump(dic,f) f.close() # 2.反序列化 import pickle f = open('info.pkl', 'rb') data = pickle.loads(f.read()) # 等价于data=pickle.load(f) print(data,type(data),data['age']) ''' {'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'> 23 '''
import pickle dic = {'name': 'shuke', 'age': 23, 'sex': 'male'} # 1. 序列化 pickle.dump(dic,open('info.pkl','wb')) # 反序列化 data=pickle.load(open('info.pkl','rb')) print(data,data['name']) ''' {'sex': 'male', 'age': 23, 'name': 'shuke'} shuke '''
注: Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve f=shelve.open(r'sheve.txt') f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']} f['stu2_info']={'name':'gangdan','age':53} f['school_info']={'website':'http://www.pypy.org','city':'beijing'} print(f['stu1_info']['hobby']) f.close() ''' 执行结果: ['piao', 'smoking', 'drinking'] '''
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数据
xml协议在各个语言里的都 是支持的，在python中常用以下方法操作xml：
# print(root.iter('year')) #全文搜索 # print(root.find('country')) #在root的子节点找，只找一个 # print(root.findall('country')) #在root的子节点找，查找所有
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']) for i 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) if rank > 50: root.remove(country) tree.write('output.xml')
#在country内添加（append）节点year2 import xml.etree.ElementTree as ET tree = ET.parse("a.xml") root=tree.getroot() for country in root.findall('country'): for year in country.findall('year'): if int(year.text) > 2000: year2=ET.Element('year2') year2.text='新年' year2.attrib={'update':'yes'} country.append(year2) #往country节点下添加子节点 tree.write('a.xml.swap')
创建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) #打印生成的格式
configparser模块
针对key/value形式的配置文件进行增删改查操作
# 注释1 ; 注释2 [Block] zoneid = 4000 opendatasys = True [db] dbhost = 192.168.1.100 dbuser = root dbpassword = 123456 dbadmin = admin [center] centerhost = 127.0.0.1 centerport = 42000 [gateway] host = 192.168.1.101 transferport = 40001
注： 其中的key/value也可以形如k1:v1的格式
常用操作
#!/usr/bin/env python #-*- coding:utf-8 -*- import configparser config=configparser.ConfigParser() config.read('settings.ini') # 查看所有的标题 res=config.sections() print(res) # ['Block', 'log', 'db', 'center'] #查看标题Block下所有key=value的key options=config.options('Block') print(options) # ['zoneid', 'opendatasys'] # 查看标题db下所有key=value的(key,value)格式 item_list=config.items('db') print(item_list) # [('dbhost', '192.168.1.100'), ('dbuser', 'root'), ('dbpassword', '123456'), ('dbadmin', 'admin')] #查看标题log下BEBUG的值=>字符串格式 val=config.get('log','DEBUG') print(val) # 0; 字符串格式 #查看标题Block下ZONEID的值=>整数格式 val1=config.getint('Block','ZONEID') print(val1) # 40002; 整数 #查看标题Block下的opendatasys值=>布尔值格式 val2=config.getboolean('Block','opendatasys') print(val2) # True; 布尔值True #查看标题center下CENTERPORT的值=>浮点型格式 val3=config.getfloat('center','CENTERPORT') print(val3) # 42000.0; 浮点数
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') # 删除整个标题Block config.remove_section('log') # 删除标题center下的某个CENTERHOST和CENTERPORT config.remove_option('center','CENTERHOST') config.remove_option('center','CENTERPORT') # 判断是否存在某个标题 print(config.has_section('log')) #判断标题Block下是否有GAMEID print(config.has_option('Block','GAMEID')) #添加一个标题 # config.add_section('gateway') # 在标题gateway下添加HOST=192.168.1.101,TRANSFERPORT=40001的配置 config.set('gateway','HOST','192.168.1.101') config.set('gateway','TRANSFERPORT','40001') # 正确 config.set('gateway','TRANSFERPORT',40001) # 报错,必须是字符串数据类型 #最后将修改的内容写入文件,完成最终的修改 config.write(open('settings.ini','w'))
程序中使用的配置文件key/value格式相对比较常见，如php.ini文件就遵循这种格式。
示例文件的格式如下，文件名为settings.ini：
[Block]
zoneid = 40002
opendatasys = True
[db]
dbhost = 192.168.1.100
dbuser = root
dbpassword = 123456
dbadmin = admin
[center]
CENTERHOST=127.0.0.1
CENTERPORT=42000
[gateway]
host = 192.168.1.101
transferport = 40001
获取所有节点
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') res=config.sections() print(res) ''' 打印结果: ['Block', 'db', 'center', 'gateway'] '''
获取指定节点下所有的键值对
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') res=config.items('Block') print(res) ''' 打印结果: [('zoneid', '40002'), ('opendatasys', 'True')] '''
获取指定节点下所有的键
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') res=config.options('Block') print(res) ''' 打印结果: ['zoneid', 'opendatasys'] '''
获取指定节点下指定key的值
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') res1=config.get('center','CENTERHOST') res2=config.getint('center','CENTERPORT') print(res1) print(res2) ''' 打印结果: 127.0.0.1 42000 '''
增删改查
import configparser config=configparser.ConfigParser() config.read('settings.ini',encoding='utf-8') #添加节点 config.add_section('global') # 已经存在则报错 config['global']['username']='shuke' config['global']['passwd']='123456' config.write(open('settings.ini','w')) # 将修改写入文件保存 #删除节点 config.remove_section('global') # 删除节点section config.remove_option('global','host') # 删除节点section下的某一个option(key) config.write(open('settings.ini','w')) # 修改 config.set('Block','zoneid','4000') config.write(open('settings.ini','w')) #检查 has_sec=config.has_section('Block') print(has_sec) # True has_sec=config.has_option('Block','zoneid') # Block下是否有一个键zoneid print(has_sec) # True
基于上述的方法新建一个配置文件
import configparser config = configparser.ConfigParser() # 默认的section config["DEFAULT"] = {'ServerAliveInterval': '45', 'Compression': 'yes', 'CompressionLevel': '9'} # 新建一个section,方法1 config['bitbucket.org'] = {} config['bitbucket.org']['User'] = 'hg' # key/value # 新建一个section,方法2 config['topsecret.server.com'] = {} topsecret = config['topsecret.server.com'] topsecret['Host_Port'] = '50022' # mutates the parser topsecret['ForwardX11'] = 'no' # same here # 在默认的section中增加一个新的option config['DEFAULT']['ForwardX11'] = 'yes' with open('example.ini', 'w') as configfile: config.write(configfile)
DEFAULT section
如果配置文件中存在一个名为 DEFAULT 的 section，那么其他 section 会扩展它的 option 并且可以覆盖它的 option。
[DEFAULT] host = 127.0.0.1 port = 3306 [db_root] user = root pass = root [db_huey] host = 192.168.1.101 user = huey pass = huey
import configparser cp = configparser.ConfigParser() cp.read('db.conf') print(cp.get('db_root', 'host')) # 127.0.0.1 print(cp.get('db_huey', 'host')) # 192.168.1.101
插值 Interpolation
SafeConfigParser 提供了插值的特性来结合数据。
[DEFAULT] url = %(protocol)s://%(server)s:%(port)s/ [http] protocol = http server = localhost port = 8080 [ftp] url = %(protocol)s://%(server)s/ protocol = ftp server = 192.168.1.102
import configparser cp = configparser.ConfigParser() cp.read('url.conf') print(cp.get('http', 'url')) # http://localhost:8080/ print(cp.get('ftp', 'url')) # ftp://192.168.1.102/
hashlib模块
hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
三个特点：
- 内容相同则hash运算结果相同，内容稍微改变则hash值则变
- 不可逆推
- 相同算法：无论校验多长的数据，得到的哈希值长度固定。
#!/usr/bin/env python #-*- coding:utf-8 -*- import hashlib string = "HelloWorld" # ######## md5 ######## md5 = hashlib.md5() md5.update(string.encode('utf-8')) # 注意转码 res = md5.hexdigest() print("md5加密结果:",res) # ######## sha1 ######## sha1 = hashlib.sha1() sha1.update(string.encode('utf-8')) res = sha1.hexdigest() print("sha1加密结果:",res) # ######## sha256 ######## sha256 = hashlib.sha256() sha256.update(string.encode('utf-8')) res = sha256.hexdigest() print("sha256加密结果:",res) # ######## sha384 ######## sha384 = hashlib.sha384() sha384.update(string.encode('utf-8')) res = sha384.hexdigest() print("sha384加密结果:",res) # ######## sha512 ######## sha512= hashlib.sha512() sha512.update(string.encode('utf-8')) res = sha512.hexdigest() print("sha512加密结果:",res) # ######## 注意 ######## m = hashlib.md5() m.update('Hello'.encode('utf8')) print('Hello的md5值: ',m.hexdigest()) # Hello字符串的md5值 m.update('World'.encode('utf8')) print('World的md5值: ',m.hexdigest()) # World字符串的md5值 m2 = hashlib.md5() m2.update('HelloWorld'.encode('utf8')) print('HelloWorld的md5值: ',m2.hexdigest()) # HelloWorld字符串的md5值 ''' md5加密结果: 68e109f0f40ca72a15e05cc22786f8e6 sha1加密结果: db8ac1c259eb89d4a131b253bacfca5f319d54f2 sha256加密结果: 872e4e50ce9990d8b041330c47c9ddd11bec6b503ae9386a99da8584e9bb12c4 sha384加密结果: 293cd96eb25228a6fb09bfa86b9148ab69940e68903cbc0527a4fb150eec1ebe0f1ffce0bc5e3df312377e0a68f1950a sha512加密结果: 8ae6ae71a75d3fb2e0225deeb004faf95d816a0a58093eb4cb5a3aa0f197050d7a4dc0a2d5c6fbae5fb5b0d536a0a9e6b686369fa57a027687c3630321547596 Hello的md5值: 8b1a9953c4611296a827abf8c47804d7 World的md5值: 68e109f0f40ca72a15e05cc22786f8e6 HelloWorld的md5值: 68e109f0f40ca72a15e05cc22786f8e6 '''
注： 把一段很长的数据update多次，与一次update这段长数据，得到的结果一样，但是update多次为校验大文件提供了可能。
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
low = hashlib.md5() low.update('HelloWorld'.encode('utf-8')) res = low.hexdigest() print("普通加密:",res) high = hashlib.md5(b'e1b8klemn3L') # 默认自定义一个key值 high.update('HelloWorld'.encode('utf-8')) res = high.hexdigest() print("采用key加密:",res) ''' 普通加密: 68e109f0f40ca72a15e05cc22786f8e6 采用key加密: 94774db9f7276dbcb9b75cf690c568ac '''
import hashlib passwds=[ 'alex3714', 'alex1313', 'alex94139413', 'alex123456', '123456alex', 'a123lex', ] def make_passwd_dic(passwds): dic={} for passwd in passwds: m=hashlib.md5() m.update(passwd.encode('utf-8')) dic[passwd]=m.hexdigest() return dic def break_code(cryptograph,passwd_dic): for k,v in passwd_dic.items(): if v == cryptograph: print('密码是===>\033[46m%s\033[0m' %k) cryptograph='aee949757a2e698417463d47acac93df' break_code(cryptograph,make_passwd_dic(passwds)) 模拟撞库破解密码
python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:
1 import hmac 2 h = hmac.new('Hello'.encode('utf8')) 3 h.update('World'.encode('utf8')) 4 print (h.hexdigest()) # c71c0cd0dc2449bdd89d28eb03bef204
subprocess模块
subprocess.Popen(
args,
bufsize=0,
executable=None,
stdin=None,
stdout=None,
stderr=None,
preexec_fn=None,
close_fds=False,
shell=False,
cwd=None,
env=None,
universal_newlines=False,
startupinfo=None,
creationflags=0)
1)、args可以是字符串或者序列类型（如：list，元组），用于指定进程的可执行文件及其参数。如果是序列类型，第一个元素通常是可执行文件的路径。我们也可以显式的使用executeable参数来指定可执行文件的路径。
2)、bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲(全缓冲)
3)、stdin, stdout, stderr分别表示程序的标准输入、输出、错误句柄。他们可以是PIPE，文件描述符或文件对象，也可以设置为None，表示从父进程继承。
4)、preexec_fn只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用。
5)、Close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。我们不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
6)、shell设为true，程序将通过shell来执行。
7)、cwd用于设置子进程的当前目录
8)、env是字典类型，用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
Universal_newlines:不同操作系统下，文本的换行符是不一样的。如：windows下用'/r/n'表示换，而Linux下用'/n'。如果将此参数设置为True，Python统一把这些换行符当作'/n'来处理。startupinfo与createionflags只在windows下用效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等。
9)、startupinfo与createionflags只在windows下有效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等。
Popen方法
1)、Popen.poll()：用于检查子进程是否已经结束。设置并返回returncode属性。
2)、Popen.wait()：等待子进程结束。设置并返回returncode属性。
3)、Popen.communicate(input=None)：与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。
4)、Popen.send_signal(signal)：向子进程发送信号。
5)、Popen.terminate()：停止(stop)子进程。在windows平台下，该方法将调用Windows API TerminateProcess（）来结束子进程。
6)、Popen.kill()：杀死子进程。
7)、Popen.stdin：如果在创建Popen对象是，参数stdin被设置为PIPE，Popen.stdin将返回一个文件对象用于策子进程发送指令。否则返回None。
8)、Popen.stdout：如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
9)、Popen.stderr：如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
10)、Popen.pid：获取子进程的进程ID。
11)、Popen.returncode：获取进程的返回值。如果进程还没有结束，返回None。
12)、subprocess.call(*popenargs, **kwargs)：运行命令。该函数将一直等待到子进程运行结束，并返回进程的returncode。文章一开始的例子就演示了call函数。如果子进程不需要进行交互,就可以使用该函数来创建。
13)、subprocess.check_call(*popenargs, **kwargs)：与subprocess.call(*popenargs, **kwargs)功能一样，只是如果子进程返回的returncode不为0的话，将触发CalledProcessError异常。在异常对象中，包括进程的returncode信息。
常用操作：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import subprocess
'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''
# 模拟管道操作
res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE) # stderr为标准错误输出,stdout为标准输出
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout, # 将res1的stdout作为res的stdin
stdout=subprocess.PIPE)
print(res.stdout.read().decode('utf-8')) # 读取标准输出管道中的内容,读取后管道内容会被置为空
# 等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE) # 执行命令
print(res1.stdout.read().decode('utf-8'))
#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir E:\YQLFC\study\day06',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
stdout=subprocess.PIPE)
print(res.stdout.read().decode('gbk')) # subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码
参考链接: https://docs.python.org/2/library/subprocess.html?highlight=subprocess#frequently-used-arguments
logging模块
1. 总结：用于便捷记录日志且线程安全的模块
- 如果不指定filename,则默认打印到终端
- 指定日志级别:
指定方式:
1:level=10
2:level=logging.ERROR
日志级别种类:
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
- 指定日志级别为ERROR,则只有ERROR及其以上级别的日志会被打印
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log') # 如果level=40,则只有logging.critical和loggin.error的日志会被打印
2. 可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有:
- filename：用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。
- filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
- format：指定handler使用的日志显示格式。
- datefmt：指定日期时间格式。
- level：设置rootlogger（后边会讲解具体概念）的日志级别
- stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
- 点击查看更详细
3. 日志格式
|
%(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 |
用户输出的消息 |
paramiko模块
paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。
安装
pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto pip3 install pycrypto pip3 install paramiko
注：如果在安装pycrypto2.0.1时发生如下错误
command 'gcc' failed with exit status 1...
可能是缺少python-dev安装包导致
如果gcc没有安装，请事先安装gcc
应用:
SSHClient
用于连接远程服务器并执行基本命令
基于用户名密码连接：
import paramiko # 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在know_hosts文件中的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='c1.salt.com', port=22, username='shuke', password='123') # 执行命令 stdin, stdout, stderr = ssh.exec_command('df') # 获取命令结果 result = stdout.read() # 关闭连接 ssh.close()
import paramiko transport = paramiko.Transport(('hostname', 22)) transport.connect(username='shuke', password='123') ssh = paramiko.SSHClient() ssh._transport = transport stdin, stdout, stderr = ssh.exec_command('df') print stdout.read() transport.close()
基于公钥密钥连接：
import paramiko private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa') # 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在know_hosts文件中的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='c1.salt.com', port=22, username='shuke', key=private_key) # 执行命令 stdin, stdout, stderr = ssh.exec_command('df') # 获取命令结果 result = stdout.read() # 关闭连接 ssh.close()
import paramiko private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa') transport = paramiko.Transport(('hostname', 22)) transport.connect(username='shuke', pkey=private_key) ssh = paramiko.SSHClient() ssh._transport = transport stdin, stdout, stderr = ssh.exec_command('df') transport.close()
import paramiko from io import StringIO key_str = """-----BEGIN RSA PRIVATE KEY----- MIIEpQIBAAKCAQEAq7gLsqYArAFco02/55IgNg0r7NXOtEM3qXpb/dabJ5Uyky/8 NEHhFiQ7deHIRIuTW5Zb0kD6h6EBbVlUMBmwJrC2oSzySLU1w+ZNfH0PE6W6fans H80whhuc/YgP+fjiO+VR/gFcqib8Rll5UfYzf5H8uuOnDeIXGCVgyHQSmt8if1+e 7hn1MVO1Lrm9Fco8ABI7dyv8/ZEwoSfh2C9rGYgA58LT1FkBRkOePbHD43xNfAYC tfLvz6LErMnwdOW4sNMEWWAWv1fsTB35PAm5CazfKzmam9n5IQXhmUNcNvmaZtvP c4f4g59mdsaWNtNaY96UjOfx83Om86gmdkKcnwIDAQABAoIBAQCnDBGFJuv8aA7A ZkBLe+GN815JtOyye7lIS1n2I7En3oImoUWNaJEYwwJ8+LmjxMwDCtAkR0XwbvY+ c+nsKPEtkjb3sAu6I148RmwWsGncSRqUaJrljOypaW9dS+GO4Ujjz3/lw1lrxSUh IqVc0E7kyRW8kP3QCaNBwArYteHreZFFp6XmtKMtXaEA3saJYILxaaXlYkoRi4k8 S2/K8aw3ZMR4tDCOfB4o47JaeiA/e185RK3A+mLn9xTDhTdZqTQpv17/YRPcgmwz zu30fhVXQT/SuI0sO+bzCO4YGoEwoBX718AWhdLJFoFq1B7k2ZEzXTAtjEXQEWm6 01ndU/jhAasdfasdasdfasdfa3eraszxqwefasdfadasdffsFIfAsjQb4HdkmHuC OeJrJOd+CYvdEeqJJNnF6AbHyYHIECkj0Qq1kEfLOEsqzd5nDbtkKBte6M1trbjl HtJ2Yb8w6o/q/6Sbj7wf/cW3LIYEdeVCjScozVcQ9R83ea05J+QOAr4nAoGBAMaq UzLJfLNWZ5Qosmir2oHStFlZpxspax/ln7DlWLW4wPB4YJalSVovF2Buo8hr8X65 lnPiE41M+G0Z7icEXiFyDBFDCtzx0x/RmaBokLathrFtI81UCx4gQPLaSVNMlvQA 539GsubSrO4LpHRNGg/weZ6EqQOXvHvkUkm2bDDJAoGATytFNxen6GtC0ZT3SRQM WYfasdf3xbtuykmnluiofasd2sfmjnljkt7khghmghdasSDFGQfgaFoKfaawoYeH C2XasVUsVviBn8kPSLSVBPX4JUfQmA6h8HsajeVahxN1U9e0nYJ0sYDQFUMTS2t8 RT57+WK/0ONwTWHdu+KnaJECgYEAid/ta8LQC3p82iNAZkpWlGDSD2yb/8rH8NQg 9tjEryFwrbMtfX9qn+8srx06B796U3OjifstjJQNmVI0qNlsJpQK8fPwVxRxbJS/ pMbNICrf3sUa4sZgDOFfkeuSlgACh4cVIozDXlR59Z8Y3CoiW0uObEgvMDIfenAj 98pl3ZkCgYEAj/UCSni0dwX4pnKNPm6LUgiS7QvIgM3H9piyt8aipQuzBi5LUKWw DlQC4Zb73nHgdREtQYYXTu7p27Bl0Gizz1sW2eSgxFU8eTh+ucfVwOXKAXKU5SeI +MbuBfUYQ4if2N/BXn47+/ecf3A4KgB37Le5SbLDddwCNxGlBzbpBa0= -----END RSA PRIVATE KEY-----""" private_key = paramiko.RSAKey(file_obj=StringIO(key_str)) transport = paramiko.Transport(('10.0.1.40', 22)) transport.connect(username='shuke', pkey=private_key) ssh = paramiko.SSHClient() ssh._transport = transport stdin, stdout, stderr = ssh.exec_command('df') result = stdout.read() transport.close() print(result)
SFTPClient
用于连接远程服务器并执行上传下载
基于用户名密码上传下载
import paramiko transport = paramiko.Transport(('hostname',22)) transport.connect(username='shuke',password='123') sftp = paramiko.SFTPClient.from_transport(transport) # 将location.py 上传至服务器 /tmp/test.py sftp.put('/tmp/location.py', '/tmp/test.py') # 将remove_path 下载到本地 local_path sftp.get('remove_path', 'local_path') transport.close()
基于公钥密钥上传下载
import paramiko private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa') transport = paramiko.Transport(('hostname', 22)) transport.connect(username='shuke', pkey=private_key ) sftp = paramiko.SFTPClient.from_transport(transport) # 将location.py 上传至服务器 /tmp/test.py sftp.put('/tmp/location.py', '/tmp/test.py') # 将remove_path 下载到本地 local_path sftp.get('remove_path', 'local_path') transport.close()
#!/usr/bin/env python # -*- coding:utf-8 -*- import paramiko import uuid class Haproxy(object): def __init__(self): self.host = '172.16.103.191' self.port = 22 self.username = 'shuke' self.pwd = '123' self.__k = None def create_file(self): file_name = str(uuid.uuid4()) with open(file_name,'w') as f: f.write('sb') return file_name def run(self): self.connect() self.upload() self.rename() self.close() def connect(self): transport = paramiko.Transport((self.host,self.port)) transport.connect(username=self.username,password=self.pwd) self.__transport = transport def close(self): self.__transport.close() def upload(self): # 连接，上传 file_name = self.create_file() sftp = paramiko.SFTPClient.from_transport(self.__transport) # 将location.py 上传至服务器 /tmp/test.py sftp.put(file_name, '/home/wupeiqi/tttttttttttt.py') def rename(self): ssh = paramiko.SSHClient() ssh._transport = self.__transport # 执行命令 stdin, stdout, stderr = ssh.exec_command('mv /home/wupeiqi/tttttttttttt.py /home/shuke/ooooooooo.py') # 获取命令结果 result = stdout.read() ha = Haproxy() ha.run() Demo
re模块
1.什么是正则？
正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
2.常用匹配模式(元字符)
#!/usr/bin/env python #-*- coding:utf-8 -*- import re # =================================匹配模式================================= # 一对一的匹配 print('hello'.replace('ll','gg')) # heggo 用new字符串替换掉old字符串 print('hello'.find('ll')) # 2 匹配到的索引位置 # ******正则匹配****** str = "Hello shuke, 123" # \w与\W print(re.findall('\w',str)) # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', '1', '2', '3'] print(re.findall('\W',str)) # [' ', ',', ' '] # \s与\S print(re.findall('\s',str)) # [' ', ' '] print(re.findall('\S',str)) # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', ',', '1', '2', '3'] # \d与\D print(re.findall('\d',str)) # ['1', '2', '3'] print(re.findall('\D',str)) # ['H', 'e', 'l', 'l', 'o', ' ', 's', 'h', 'u', 'k', 'e', ',', ' '] #\A与\Z print(re.findall('\AHe',str)) # ['He'] print(re.findall('123\Z',str)) # ['123'] #\n与\t print(re.findall(r'\n','Hello shuke \n123')) # ['\n'] print(re.findall(r'\t','Hello shuke\t123')) # ['\t'] #^与$ print(re.findall('^H',str)) #['H'] print(re.findall('3$',str)) #['3'] # 重复匹配：| . | * | ? | .* | .*? | + | {n,m} | #. print(re.findall('a.b','a1b abc a*b a$b')) # ['a1b', 'a*b', 'a$b'] print(re.findall('a.b','a\nb')) # [] .不能匹配到\n符 print(re.findall('a.b','a\nb',re.S)) # ['a\nb'] print(re.findall('a.b','a\nb',re.DOTALL)) # ['a\nb']同上一条意思一样 #* print(re.findall('He*','hello ')) # [] print(re.findall('He*',str)) # ['He'] print(re.findall('ab*','b ab abbbb')) # ['ab', 'abbbb'] #? print(re.findall('He?',str)) # ['He'] print(re.findall('ab?','abbb')) # ['ab'] #匹配所有包含小数在内的数字 print(re.findall('\d+\.?\d*',"asd123fd1.23asdls12dkk3.4esf5")) # ['123', '1.23', '12', '3.4', '5'] #.* 默认为贪婪匹配 print(re.findall('a.*b','a1b222ahjhsk22222b')) # ['a1b222ahjhsk22222b'] #.*?为非贪婪匹配：推荐使用 print(re.findall('a.*?b','a1b222ahjhsk22222b')) # ['a1b', 'ahjhsk22222b'] #+ print(re.findall('ab+','a accc')) # [] print(re.findall('ab+','abbb')) # ['abbb'] #{n,m} print(re.findall('ab{2}','abbb')) # ['abb'] print(re.findall('ab{2,4}','abbb')) # ['abbb'] print(re.findall('ab{1,}','abbb')) # ['abbb'] 'ab{1,}' == 'ab+' print(re.findall('ab{0,}','abbb')) # ['abbb'] 'ab{0,}' == 'ab*' #[] #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾 print(re.findall('a[1*-]b','a1b a*b a-b')) # ['a1b', 'a*b', 'a-b'] #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) # ['a=b'] #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[0-9]b','a1b a*b a-b a=b')) # ['a1b'] #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) # ['aeb'] #[]内的^代表的意思是取反，所以结果为['a=b'] print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) # ['aeb', 'aEb'] #\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常 #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义 print(re.findall(r'a\\c','a\c')) # ['a\\c'] #同上面的意思一样，和上面的结果一样都是['a\\c'] print(re.findall('a\\\\c','a\c')) # ['a\\c'] #():分组 print(re.findall('ab+','ababab123')) # ['ab', 'ab', 'ab'] print(re.findall('(ab)+123','ababab123')) # ['ab']，匹配到末尾的ab123中的ab #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容 print(re.findall('(?:ab)+123','ababab123')) # ['ababab123'] #| print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company')) # ['companies', 'company']
#!/usr/bin/env python #-*- coding:utf-8 -*- import re # ===========================re模块提供的方法介绍=========================== str = 'Hello jack john shuke' #1 print(re.findall('o',str) ) # ['o', 'o'],返回所有满足匹配条件的结果,放在列表里 #2 print(re.search('o',str).group()) # o,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。 #3 print(re.match('o',str)) # None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match print(re.search('^o',str)) # None,用search+^代替match #4 print(re.split('[ab]','abcd')) # ['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割 print(re.split('ke','jake shuke echo keke')) # ['ja', ' shu', ' echo ', '', '']; 不带括号结果不包含分割的字符串 print(re.split('(ke)','jake shuke echo keke')) # ['ja', 'ke', ' shu', 'ke', ' echo ', 'ke', '', 'ke', '']；带括号结果包含分割的字符串 #5 print('===>',re.sub('j','J',str)) # ===> Hello Jack John shuke，不指定n，默认替换所有 print('===>',re.sub('j','J',str,1)) # ===> Hello Jack john shuke 替换一次 print('===>',re.sub('j','J',str,2)) # ===> Hello Jack John shuke 替换二次 print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1',str)) # ===> john jack Hello print('===>',re.subn('j','J',str)) # ===> ('Hello Jack John shuke', 2),结果带有总共替换的次数 #6 obj=re.compile('\d{2}') print(obj.search('abc123eeee').group()) # 12 print(obj.findall('abc123eeee')) # ['12'],重用了obj
从网页源码中匹配标签的应用:
#!/usr/bin/env python #-*- coding:utf-8 -*- import re print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) # ['h1'] print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) # <h1>hello</h1> print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) # {'tag_name': 'h1'} print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group()) # <h1>hello</h1> print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group()) # <h1>hello</h1>
#!/usr/bin/env python #-*- coding:utf-8 -*- import re print(re.findall(r'-?\d+\.?\d*',"1-12*(60+(-40.35/5)-(-4*3))")) # ['1', '-12', '60', '-40.35', '5', '-4', '3'] 找出所有数字 #使用|，先匹配的先生效，|左边是匹配小数，而findall最终结果是查看分组，所有即使匹配成功小数也不会存入结果 #而不是小数时，就去匹配(-?\d+)，匹配到的自然就是，非小数的数，在此处即整数 print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) # ['1', '-2', '60', '', '5', '-4', '3'] 找出所有整数
#!/usr/bin/env python #-*- coding:utf-8 -*- #在线调试工具:tool.oschina.net/regex/# import re # 常规匹配 content='Hello 123 456 World_This is a Regex Demo' res=re.match('Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo',content) print(res) print(res.group()) # Hello 123 456 World_This is a Regex Demo print(res.span()) # (0, 40) # 泛匹配 content='Hello 123 456 World_This is a Regex Demo' res=re.match('^Hello.*Demo',content) print(res.group()) # Hello 123 456 World_This is a Regex Demo # 匹配目标,获得指定数据 content='Hello 123 456 World_This is a Regex Demo' res=re.match('^Hello\s(\d+)\s(\d+)\s.*Demo',content) print(res.group()) # Hello 123 456 World_This is a Regex Demo; 匹配所有的内容 print(res.group(1)) # 123; 匹配第一个括号内的内容 print(res.group(2)) # 456; 匹配第二个括号内的内容 # 贪婪匹配:.*代表匹配尽可能多的字符 content='Hello 123 456 World_This is a Regex Demo' res=re.match('^He.*(\d+).*Demo$',content) print(res.group(1)) # 6; 只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字 # 非贪婪匹配.*?匹配尽可能少的字符 content='Hello 123 456 World_This is a Regex Demo' res=re.match('^He.*?(\d+).*Demo$',content) print(res.group(1)) # 123; 因为.*?会尽可能少的匹配,至少有一个任意字符 # 匹配模式:.不能匹配换行符 content="Hello 123456 World_This is a Regex Demo" res=re.match('He.*?(\d+).*?Demo$',content) print(res) # 输出None res=re.match('He.*?(\d+).*?Demo$',content,re.S) # re.S让.可以匹配换行符 print(res) print(res.group(1)) # 123456 #转义:\ content='price is $5.00' res=re.match('price is $5.00',content) print(res) # None res=re.match('price is \$5\.00',content) # print(res) print(res.group()) # price is $5.00 # *********总结:尽量精简,详细的如下********* # 尽量使用泛匹配模式.* # 尽量使用非贪婪模式:.*? # 使用括号得到匹配目标:用group(n)去取得结果 # 有换行符就用re.S:修改模式 # ***********re.search************ # re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回 content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' res=re.match('Hello.*?(\d+).*?Demo',content) # print(res) # 输出结果为None content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' res=re.search('Hello.*?(\d+).*?Demo',content) # print(res.group(1)) # 123; 扫描整个字符串进行匹配 # re.search:只要一个结果 content='''<tbody><tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&quality=100"></a><span data-res-id="476630320"''' res=re.search('<a\shref=.*?\<\/a\>',content) print(res.group()) # <a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>; 匹配成功就立刻返回，失败则返回None # re.findall:找到符合条件的所有结果 res=re.findall('<a\shref=.*?\<\/a\>',content) print(res) # 返回一个列表 for i in res: print(i) ''' 输出结果 ['<a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>', '<a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&quality=100"></a>'] <a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a> <a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&quality=100"></a> ''' # *********re.sub:字符串替换******** # re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。 content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' content=re.sub('\d+','',content) print(content) # Extra strings Hello World_This is a Regex Demo Extra strings;将数字替换为空 # 用\1取得第一个括号的内容 # 用法:将123与456换位置 content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' content=re.sub('(Extra.*?)(\d+)(\s)(\d+)(.*?strings)',r'\1\4\3\2\5',content) content=re.sub('(\d+)(\s)(\d+)',r'\3\2\1',content) print(content) # 带命名的组:\g content = "hello shuke, nihao shuke"; res = re.sub(r"hello (\w+), nihao \1", "\g<1>", content); print("replacedStr=",res) # replacedStr= shuke 明名组的用法: 反斜杠加g以及中括号内一个名字，即：\g<name>，对应着命了名的组，named group # 带命名的组:named group content = "hello shuke, nihao shuke"; res = re.sub(r"hello (?P<name>\w+), nihao (?P=name)", "\g<name>", content); print("replacedStr=",res) # replacedStr= shuke # 匹配一次 content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings' res=re.search('Extra.*?(\d+).*strings',content) if res: print('res.group(0): ',res.group(0),'res.group(1): ',res.group(1)) # res.group(0): Extra strings Hello 123 456 World_This is a Regex Demo Extra strings res.group(1): 123 else: print('not search') # 正则在爬虫的应用 import requests,re respone=requests.get('https://book.douban.com/').text # print(respone) print('======'*100) res=re.findall('<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>',respone,re.S) # res=re.findall('<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>',respone,re.S) # 格式化输出 for i in res: print('%s %s %s %s' %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip())) 示例
IP： ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$ 手机号： ^1[3|4|5|8][0-9]\d{8}$ 邮箱： [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+
常用匹配语法:
re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub 匹配字符并替换
三. 软件开发目录结构规范
为什么要设计好目录结构?
"设计项目目录结构"，就和"代码编码风格"一样，属于个人风格问题。对于这种风格上的规范，一直都存在两种态度:
- 一类同学认为，这种个人风格问题"无关紧要"。理由是能让程序work就好，风格问题根本不是问题。
- 另一类同学认为，规范化能更好的控制程序结构，让程序具有更高的可读性。
我是比较偏向于后者的，因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目，其实现的逻辑并不复杂，但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，我们设计一个层次清晰的目录结构，就是为了达到以下两点:
- 可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。
- 可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好。
所以，我认为，保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录，其实是一件很简单的事儿。
目录组织方式
关于如何组织一个较好的Python工程目录结构，已经有一些得到了共识的目录结构。在Stackoverflow的这个问题上，能看到大家对Python目录结构的讨论。
这里面说的已经很好了，我也不打算重新造轮子列举各种不同的方式，这里面我说一下我的理解和体会。
假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:
Foo/ |-- bin/ | |-- foo | |-- foo/ | |-- tests/ | | |-- __init__.py | | |-- test_main.py | | | |-- __init__.py | |-- main.py | |-- docs/ | |-- conf.py | |-- abc.rst | |-- setup.py |-- requirements.txt |-- README
简要解释一下:
bin/: 存放项目的一些可执行文件，当然你可以起名script/之类的也行。foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。docs/: 存放一些文档。setup.py: 安装、部署、打包的脚本。requirements.txt: 存放软件依赖的外部Python包列表。README: 项目说明文件。
除此之外，有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等，我没有列在这里，因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件，目录该如何组织，可以参考这篇文章。
下面，再简单讲一下我对这些目录的理解和个人要求吧。
关于README的内容
这个我觉得是每个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。
它需要说明以下几个事项:
- 软件定位，软件的基本功能。
- 运行代码的方法: 安装环境、启动命令等。
- 简要的使用说明。
- 代码目录结构说明，更详细点可以说明软件的基本原理。
- 常见问题说明。
我觉得有以上几点是比较好的一个README。在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候，是需要撰写这样的一个文档的。
可以参考Redis源码中Readme的写法，这里面简洁但是清晰的描述了Redis功能和源码结构。
关于requirements.txt和setup.py
setup.py
一般来说，用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，一个项目一定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
这个我是踩过坑的。
我刚开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，遇到过以下问题:
- 安装环境时经常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
- Python包的版本依赖问题，有时候我们程序中使用的是一个版本的Python包，但是官方的已经是最新的包了，通过手动安装就可能装错了。
- 如果依赖的包很多的话，一个一个安装这些依赖是很费时的事情。
- 新同学开始写项目的时候，将程序跑起来非常麻烦，因为可能经常忘了要怎么安装各种依赖。
setup.py可以将这些事情自动化起来，提高效率、减少出错的概率。"复杂的东西自动化，能自动化的东西一定要自动化。"是一个非常好的习惯。
setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点。学习技术的方式就是看他人是怎么用的，可以参考一下Python的一个Web框架，flask是如何写的: setup.py
当然，简单点自己写个安装脚本（deploy.sh）替代setup.py也未尝不可。
requirements.txt
这个文件存在的目的是:
- 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中，避免在
setup.py安装依赖时漏掉软件包。 - 方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明，通常是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明： 点这里。
关于配置文件的使用方法
注意，在上面的目录结构中，没有将conf.py放在源码目录下，而是放在docs/目录下。
很多项目对配置文件的使用做法是:
- 配置文件写在一个或多个python文件中，比如此处的conf.py。
- 项目中哪个模块用到这个配置文件就直接通过
import conf这种形式来在代码中使用配置。
这种做法我不太赞同:
- 这让单元测试变得困难（因为模块内部依赖了外部配置）
- 另一方面配置文件作为用户控制程序的接口，应当可以由用户自由指定该文件的路径。
- 程序组件可复用性太差，因为这种贯穿所有模块的代码硬编码方式，使得大部分模块都依赖
conf.py这个文件。
所以，我认为配置的使用，更好的方式是，
- 模块的配置都是可以灵活配置的，不受外部配置文件的影响。
- 程序的配置也是可以灵活控制的。
能够佐证这个思想的是，用过nginx和mysql的同学都知道，nginx、mysql这些程序都可以自由的指定用户配置。
所以，不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py，是给出的一个配置样例，不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然，这里的conf.py你可以换个类似的名字，比如settings.py。或者你也可以使用其他格式的内容来编写配置文件，比如settings.yaml之类的。
相关链接:
1. http://www.cnblogs.com/wupeiqi/articles/5501365.html
2. http://www.cnblogs.com/linhaifeng/articles/6384466.html
