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__))))

os路径处理

 

 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()

zipfile压缩解压缩

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()

tarfile压缩解压缩

 

 

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))  # 

# 将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)

json.dumps和json.loads

# ********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'} 
'''

json.dump和json.load

 注意的问题:

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))          # 
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'}  23
'''

pickle.dumps和pickle.loads

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.dump和pickle.load

注: 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的格式如下，就是通过<>节点来区别数据结构的:

"1.0"?>

    "Liechtenstein">
        "yes">2
        2008
        141100
        "Austria" direction="E"/>
        "Switzerland" direction="W"/>
    
    "Singapore">
        "yes">5
        2011
        59900
        "Malaysia" direction="N"/>
    
    "Panama">
        "yes">69
        2011
        13600
        "Costa Rica" direction="W"/>
        "Colombia" direction="E"/>
    


xml数据

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

settings.ini

注： 其中的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

db.conf

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

default_section.py

插值 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

url.conf

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/

interpolation_demo.py

 

 

hashlib模块

 hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
三个特点：

1. 内容相同则hash运算结果相同，内容稍微改变则hash值则变
2. 不可逆推
3. 相同算法：无论校验多长的数据，得到的哈希值长度固定。

#!/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信息。

subprocess.Popen参数介绍

常用操作：

#!/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模块默认行为，可用参数有:

1. filename：用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。
2. filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
3. format：指定handler使用的日志显示格式。 
4. datefmt：指定日期时间格式。 
5. level：设置rootlogger（后边会讲解具体概念）的日志级别 
6. stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
7. 点击查看更详细

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()

SSHClient 封装 Transport

基于公钥密钥连接：

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()

SSHClient封装Transport

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

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']

re匹配模式

#!/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

re模块提供的方法

从网页源码中匹配标签的应用:

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import re
print(re.findall("<(?P\w+)>\w+","
hello")) # ['h1']
print(re.search("<(?P\w+)>\w+","
hello").group()) # 
hello
print(re.search("<(?P\w+)>\w+","
hello").groupdict()) # {'tag_name': 'h1'}

print(re.search(r"<(\w+)>\w+","
hello").group())    # 
hello
print(re.search(r"<(\w+)>\w+","
hello").group())       # 
hello

匹配标签

#!/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='''
1
'''
res=re.search('',content)
print(res.group())      # # re.findall:找到符合条件的所有结果
res=re.findall('',content)
print(res)      # 返回一个列表
for i in res:
    print(i)
'''
输出结果
['']

'''


# *********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，对应着命了名的组，named group

# 带命名的组:named group
content = "hello shuke, nihao shuke";
res = re.sub(r"hello (?P\w+), nihao (?P=name)", "\g", 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('.*?more-meta.*?author">(.*?)(.*?)(.*?)',respone,re.S)
# res=re.findall('(.*?)(.*?)(.*?).*?',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_-]+)+

IP|手机号|邮箱

常用匹配语法:

re.match 　　　 从头开始匹配
re.search 　　　匹配包含
re.findall 　　 把所有匹配到的字符放到以列表中的元素返回
re.splitall 　　以匹配到的字符当做列表分隔符
re.sub       　 匹配字符并替换

 

三. 软件开发目录结构规范

为什么要设计好目录结构?

"设计项目目录结构"，就和"代码编码风格"一样，属于个人风格问题。对于这种风格上的规范，一直都存在两种态度:

1. 一类同学认为，这种个人风格问题"无关紧要"。理由是能让程序work就好，风格问题根本不是问题。
2. 另一类同学认为，规范化能更好的控制程序结构，让程序具有更高的可读性。

我是比较偏向于后者的，因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目，其实现的逻辑并不复杂，但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，我们设计一个层次清晰的目录结构，就是为了达到以下两点:

1. 可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。
2. 可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好。

所以，我认为，保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录，其实是一件很简单的事儿。

目录组织方式

关于如何组织一个较好的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

简要解释一下:

1. bin/: 存放项目的一些可执行文件，当然你可以起名script/之类的也行。
2. foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。
3. docs/: 存放一些文档。
4. setup.py: 安装、部署、打包的脚本。
5. requirements.txt: 存放软件依赖的外部Python包列表。
6. README: 项目说明文件。

除此之外，有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等，我没有列在这里，因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件，目录该如何组织，可以参考这篇文章。

下面，再简单讲一下我对这些目录的理解和个人要求吧。

关于README的内容

这个我觉得是每个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。

它需要说明以下几个事项:

1. 软件定位，软件的基本功能。
2. 运行代码的方法: 安装环境、启动命令等。
3. 简要的使用说明。
4. 代码目录结构说明，更详细点可以说明软件的基本原理。
5. 常见问题说明。

我觉得有以上几点是比较好的一个README。在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候，是需要撰写这样的一个文档的。

可以参考Redis源码中Readme的写法，这里面简洁但是清晰的描述了Redis功能和源码结构。

关于requirements.txt和setup.py

setup.py

一般来说，用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，一个项目一定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。

这个我是踩过坑的。

我刚开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，遇到过以下问题:

1. 安装环境时经常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
2. Python包的版本依赖问题，有时候我们程序中使用的是一个版本的Python包，但是官方的已经是最新的包了，通过手动安装就可能装错了。
3. 如果依赖的包很多的话，一个一个安装这些依赖是很费时的事情。
4. 新同学开始写项目的时候，将程序跑起来非常麻烦，因为可能经常忘了要怎么安装各种依赖。

setup.py可以将这些事情自动化起来，提高效率、减少出错的概率。"复杂的东西自动化，能自动化的东西一定要自动化。"是一个非常好的习惯。

setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点。学习技术的方式就是看他人是怎么用的，可以参考一下Python的一个Web框架，flask是如何写的: setup.py

当然，简单点自己写个安装脚本（deploy.sh）替代setup.py也未尝不可。

requirements.txt

这个文件存在的目的是:

1. 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中，避免在setup.py安装依赖时漏掉软件包。
2. 方便读者明确项目使用了哪些Python包。

这个文件的格式是每一行包含一个包依赖的说明，通常是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明： 点这里。

关于配置文件的使用方法

注意，在上面的目录结构中，没有将conf.py放在源码目录下，而是放在docs/目录下。

很多项目对配置文件的使用做法是:

1. 配置文件写在一个或多个python文件中，比如此处的conf.py。
2. 项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。

这种做法我不太赞同:

1. 这让单元测试变得困难（因为模块内部依赖了外部配置）
2. 另一方面配置文件作为用户控制程序的接口，应当可以由用户自由指定该文件的路径。
3. 程序组件可复用性太差，因为这种贯穿所有模块的代码硬编码方式，使得大部分模块都依赖conf.py这个文件。

所以，我认为配置的使用，更好的方式是，

1. 模块的配置都是可以灵活配置的，不受外部配置文件的影响。
2. 程序的配置也是可以灵活控制的。

能够佐证这个思想的是，用过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

 

转载于:https://www.cnblogs.com/aslongas/p/6926000.html