Python批量管理主机(paramiko、fabric与pexpect)

Dear 丶 2022-07-14 18:46 205阅读 0赞

paramiko

paramiko模块是基于Python实现的SSH远程安全连接，用于SSH远程执行命令、文件传输等功能。

默认Python没有，需要手动安装：pip install paramiko

如安装失败，可以尝试yum安装：**yum install python-paramiko**

\#!/usr/bin/env python  
import paramiko  
import threading  
   
def ssh2(ip,username,passwd,cmd):  
    try:  
        ssh = paramiko.SSHClient()  
        ssh.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())  
        ssh.connect(ip,22,username,passwd,timeout=5)  
        for m in cmd:  
            stdin, stdout, stderr = ssh.exec\_command(m)  
            out = stdout.readlines()  
            for o in out:  
                print o,  
        print '%s\\tOK\\n'%(ip)  
        ssh.close()  
    except :  
        print '%s\\tError\\n'%(ip)  
   
   
if \_\_name\_\_=='\_\_main\_\_':  
    cmd = \['date'\]  
    username = "root"    
    passwd = "\*\*\*\*\*\*"      
    threads = \[\]     
    print "Begin......"  
    for i in range(1,254):  
        ip = '10.0.0.'+str(i)  
        a=threading.Thread(target=ssh2,args=(ip,username,passwd,cmd))  
        a.start()

基于账号密码的形式，执行命令或上传下载文件  
  
import paramiko  
   
\# 基于账号密码执行命令  
\# 创建SSH对象  
ssh = paramiko.SSHClient()  
\# 允许连接不在know\_hosts文件中的机器  
ssh.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())  
\# 连接服务器  
ssh.connect(hostname="192.168.80.20", port=22, username="root", password="test@2015")  
\# 执行命令  
stdin, stdout, stderr = ssh.exec\_command("free -m")  
\# 获取命令结果  
res, err = stdout.read(), stderr.read()  
result = res if res else err  
print(result.decode())  
\# 关闭连接  
ssh.close()  
   
\# 基于账号密码的上传下载  
transport = paramiko.Transport(("192.168.80.20", 22))  
transport.connect(username="root", password="test@2015")  
sftp = paramiko.SFTPClient.from\_transport(transport)  
\# 将location.py上传至服务器的/tmp/test.py  
sftp.put("高级FTP.png", "/root/高级FTP.png")  
\# 将remove\_path下载到本地local\_path  
sftp.get("remove\_path", "local\_path")  
transport.close()  
   
\# SSHClient 封装 Transport  
transport = paramiko.Transport(('hostname', 22))  
transport.connect(username='wupeiqi', password='123')  
ssh = paramiko.SSHClient()  
ssh.\_transport = transport  
stdin, stdout, stderr = ssh.exec\_command('df')  
print(stdout.read().decode())  
transport.close()  
  
  
  
  
  
  
基于密钥的形式，执行命令或上传下载文件  
  
  
  
  
import paramiko  
   
\# 基于密钥执行命令  
private\_key = paramiko.RSAKey.from\_private\_key\_file("id\_rsa")  
ssh = paramiko.SSHClient()  
ssh.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())  
ssh.connect(hostname="192.168.80.24", port=22, username="root", pkey=private\_key)  
stdin, stdout, stderr = ssh.exec\_command("ifconfig")  
res, err = stdout.read(), stderr.read()  
result = res if res else err  
print(result.decode())  
ssh.close()  
   
\# 基于密钥的上传下载  
private\_key = paramiko.RSAKey.from\_private\_key\_file("id\_rsa")  
transport = paramiko.Transport(("192.168.80.24", 22))  
transport.connect(username="root", pkey=private\_key)  
sftp = paramiko.SFTPClient.from\_transport(transport)  
sftp.get("test.txt", "1")  
transport.close()  
   
\# SSHClient 封装 Transport  
private\_key = paramiko.RSAKey.from\_private\_key\_file('/home/auto/.ssh/id\_rsa')  
transport = paramiko.Transport(('hostname', 22))  
transport.connect(username='wupeiqi', pkey=private\_key)  
ssh = paramiko.SSHClient()  
ssh.\_transport = transport  
stdin, stdout, stderr = ssh.exec\_command('df')  
transport.close()

**SSH密码认证远程执行命令**

\#!/usr/bin/python

\# -\*- coding: utf-8 -\*-

import paramiko

import sys

hostname = '192.168.1.215'

port = 22

username = 'root'

password = '123456'

client = paramiko.SSHClient()  \# 绑定实例

client.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())

client.connect(hostname, port, username, password, timeout=5)

stdin, stdout, stderr = client.exec\_command('df -h')   \# 执行bash命令

result = stdout.read()

error = stderr.read()

\# 判断stderr输出是否为空，为空则打印执行结果，不为空打印报错信息

if not error:

print result

else:

print error

client.close()

**私钥认证远程执行命令**

\#!/usr/bin/python

\# -\*- coding: utf-8 -\*-

import paramiko

import sys

hostname = '192.168.1.215'

port = 22

username = 'root'

key\_file = '/root/.ssh/id\_rsa'

cmd = " ".join(sys.argv\[1:\])

def ssh\_conn(command):

client = paramiko.SSHClient()

key = paramiko.RSAKey.from\_private\_key\_file(key\_file)

client.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())

client.connect(hostname, port, username, pkey=key)

stdin, stdout, stderr = **client.exec\_command**(command)  \# 标准输入，标准输出，错误输出

result = stdout.read()

error = stderr.read()

if not error:

print result

else:

print error

client.close()

if \_\_name\_\_ == "\_\_main\_\_":

ssh\_conn(cmd)

**上传文件到远程服务器**

\#!/usr/bin/python

\# -\*- coding: utf-8 -\*-

import os, sys

import paramiko

hostname = '192.168.1.215'

port = 22

username = 'root'

password = '123456'

local\_path = '/root/test.txt'

remote\_path = '/opt/test.txt'

if not os.path.isfile(local\_path):

print local\_path + " file not exist!"

sys.exit(1)

try:

s = **paramiko.Transport**((hostname, port))

**s.connect**(username = username, password=password)

except Exception as e:

print e

sys.exit(1)

sftp = **paramiko.SFTPClient.from\_transport**(s)

\# 使用put()方法把本地文件上传到远程服务器

**sftp.put**(local\_path, remote\_path)

\# 简单测试是否上传成功

try:

\# 如果远程主机有这个文件则返回一个对象，否则抛出异常

sftp.file(remote\_path)

print "上传成功."

except IOError:

print "上传失败!"

finally:

s.close()

**从远程服务器下载文件**

\#!/usr/bin/python

\# -\*- coding: utf-8 -\*-

import os, sys

import paramiko

hostname = '192.168.1.215'

port = 22

username = 'root'

password = '123456'

local\_path = '/root/test.txt'

remote\_path = '/opt/test.txt'

try:

s = **paramiko.Transport**((hostname, port))

s.connect(username=username, password=password)

sftp = **paramiko.SFTPClient.from\_transport**(s)

except Exception as e:

print e

sys.exit(1)

try:

\# 判断远程服务器是否有这个文件

**sftp.file**(remote\_path)

\# 使用get()方法从远程服务器拉去文件

**sftp.get**(remote\_path, local\_path)

except IOError as e:

print remote\_path + "remote file not exist!"

sys.exit(1)

finally:

s.close()

\# 测试是否下载成功

if **os.path.isfile**(local\_path):

print "下载成功."

else:

print "下载失败!"

上传目录到远程服务器

paramiko模块并没有实现直接上传目录的类，已经知道了如何上传文件，再写一个上传目录的代码就简单了，**利用os库的os.walk()方法遍历目录，再一个个上传：**

\#!/usr/bin/python

\# -\*- coding: utf-8 -\*-

import os, sys

import paramiko

hostname = '192.168.1.215'

port = 22

username = 'root'

password = '123456'

local\_path = '/root/abc'

remote\_path = '/opt/abc'

\# 去除路径后面正斜杠

if local\_path\[-1\] == '/':

local\_path = local\_path\[0:-1\]

if remote\_path\[-1\] == '/':

remote\_path = remote\_path\[0:-1\]

file\_list = \[\]

if os.path.isdir(local\_path):

for root, dirs, files in os.walk(local\_path):

for file in files:

\# 获取文件绝对路径

file\_path = os.path.join(root, file)

file\_list.append(file\_path)

else:

print path + "Directory not exist!"

sys.exit(1)

try:

s = paramiko.Transport((hostname, port))

s.connect(username=username, password=password)

sftp = paramiko.SFTPClient.from\_transport(s)

except Exception as e:

print e

for local\_file in file\_list:

\# 替换目标目录

remote\_file = **local\_file.replace**(local\_path, remote\_path)

remote\_dir = **os.path.dirname**(remote\_file)

\# 如果远程服务器没目标目录则创建

try:

**sftp.stat**(remote\_dir)

except IOError:

sftp.mkdir(remote\_dir)

print "%s -> %s" % (local\_file, remote\_file)

sftp.put(local\_file, remote\_file)

s.close()

传输文件

\#!/usr/bin/python

\#-\*- coding:UTF-8 -\*-

try:

import os,sys

import re

import datetime

import shutil

import commands

from optparse import OptionParser

except ImportError,e:

print "Error:",e

sys.exit()

def Get\_And\_ScpLogfile(host,list,tmpdir,yestoday):

logdir = '/log/'

desdir = '/home/haoren/logdir/'

global dirs;dirs = \[\]

for ip in list:

ident = ip.split('.')\[3\]

ldir = '%s%s\_%s' % (tmpdir,yestoday,ident)

dirs.append(ldir)

if not os.path.exists(ldir):

os.makedirs(ldir)

s,o = **commands.getstatusoutput**('ssh %s /bin/ls -ld %s%s ' % (ip,logdir,yestoday))

print "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*%s\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" % ip

print "BEGIN:"

if s == 0:

os.system('/usr/bin/scp -r %s:%s%s/\* %s' % (ip,logdir,yestoday,ldir))

else:

os.system('/usr/bin/scp -r %s:%s\*%s\* %s' % (ip,logdir,yestoday,ldir))

for ip in host:

print "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*SCP\_To\_%s\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" % ip

print "BEGIN:"

os.system('/usr/bin/scp -r %s%s\* %s:%s' % (tmpdir,yestoday,ip,desdir))

def CleanLogFile():

for d in dirs:

**shutil.rmtree**(d,True)

def main():

\#\#\#\#option\#\#\#\#

parser = **OptionParser()**

parser.add\_option("-t","--time",action="store",dest="filedate",help="appoint the logfile time,use like this '-t 130825'")

(options,args) = **parser.parse\_args()**

\#\#\#\#option\#\#\#\#

if options.filedate:

filedate = options.filedate

else:

filedate = (datetime.datetime.now() - datetime.timedelta(days=1)).strftime('%y%m%d')

iplist = \[\]

host = \[\]

tmpdir = '/home/haoren/tempdir/'

f = open('/home/haoren/tools/log\_config.ini','r')

for line in f:

line = **line.strip()**

if re.search(r'^\[0-9\]\{1,2\}=.\*',line):

iplist.append(line.split('=')\[1\])

elif re.search(r'^host=.\*',line):

\#host = line.split('=')\[1\]

host.append(line.split('=')\[1\])

elif **re.search**(r'^host2=.\*',line):

\#    host2 = line.split('=')\[1\]

host.append(line.split('=')\[1\])

f.close()

Get\_And\_ScpLogfile(host,iplist,tmpdir,filedate)

CleanLogFile()

if \_\_name\_\_ == "\_\_main\_\_":

main()

shutil 用来处理 文件 文件夹 压缩包 的模块

import shutil

\# 拷贝文件内容

shutil.copyfileobj(open('old.xml', 'r'), open('new.xml', 'w'))

\# 拷贝文件

shutil.copyfile('f1.log', 'f2.log')

\# 拷贝权限

shutil.copymode('f1.log', 'f2.log')

\# 拷贝文件状态信息

shutil.copystat('f1.log', 'f2.log')

\# 拷贝文件和权限

shutil.copy('f1.log', 'f2.log')

\# 递归地拷贝文件夹

\# shutil.copytree('folder1', 'folder2',

ignore=shutil.ignore\_patterns('\*.pyc', '\*.txt'))

\# 递归地删除文件

\# shutil.rmtree('folder2')

\# 递归地移动重命名文件

\# shutil.move('folder2', 'folder3')

\# 打包文件

ret = shutil.make\_archive(r'C:\\GitHub\\Python\\day7\\shutil\\www', 'gztar',

root\_dir=r'C:\\GitHub\\Python\\day7\\shutil\\folder1')

zipfile tarfile

import zipfile

\# 压缩

z = zipfile.ZipFile('z.zip', 'w')

z.write('xo.xml')

z.write('xxxoo.xml')

z.close()

\# 解压

z = zipfile.ZipFile('z.zip', 'r')

for item in z.namelist():

print(item)

\# z.extractall()

z.extract('xo.xml')

import tarfile

\# 压缩

tar = tarfile.open('z.tar', 'w')

tar.add('xo.xml', arcname='bbs2.log')

tar.add('xxxoo.xml', arcname='cmdb.log')

tar.close()

\# 解压

tar = tarfile.open('z.tar', 'r')

\# for item in tar.getmembers():

\#     print(item, type(item))

obj = tar.getmember('cmdb.log')  \# 和zipfile不同的是 再解压特定文件前要先获取文件特殊对象值

tar.extract(obj)

tar.close()

和处理shell相关的命令

import subprocess

\# 返回命令执行结果

\# result = subprocess.call('ls -l', shell=True)

\# result = subprocess.call(\['ls', '-l'\], shell=False)

\# print(result)

\# subprocess.check\_call(\["ls", "-l"\])

\# subprocess.check\_call("exit 1", shell=True)

\# 好像没Python废弃了

subprocess.check\_output(\["echo", "Hello World!"\], shell=False)

subprocess.check\_output("exit 1", shell=True)

\# 2、执行复杂的系统相关命令

\# 1）切换目录再执行命令

obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

\# 2）有多行且复杂的命令使用三个接口

\# obj = subprocess.Popen(\["python"\], stdin=subprocess.PIPE,

stdout=subprocess.PIPE， stderr=subprocess.PIPE, universal\_newlines=True)

\# obj.stdin.write("print(1)\\n")  \# 传命令接口

\# obj.stdin.write("print(2)")

\# obj.stdin.close()

\# cmd\_out = obj.stdout.read()  \# 读接口

\# obj.stdout.close()

\# cmd\_error = obj.stderr.read()  \# 读错误接口

\# obj.stderr.close()

\# print(cmd\_out)

\# print(cmd\_error)

\# 3）一次读输出

\# obj = subprocess.Popen(\["python"\], stdin=subprocess.PIPE,

stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal\_newlines=True)

\# obj.stdin.write("print(1)\\n")

\# obj.stdin.write("print(2)")

\# out\_error\_list = obj.communicate()

\# print(out\_error\_list)

\# 4）简单写法

\# obj = subprocess.Popen(\["python"\], stdin=subprocess.PIPE,

stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal\_newlines=True)

\# out\_error\_list = obj.communicate('print("hello")')

\# print(out\_error\_list)

xml 是实现不同语言和程序之间进行数据交换的协议

from xml.etree import ElementTree as ET

\# xml有两个常见格式

\# 1）直接读取字符串格式的xml

str\_xml = open('xo.xml', 'r').read()

root = ET.XML(str\_xml)  \# 这里没有建立 xml tree 所以不能直接将内存中的xml写回文件

\# 2）读取xml格式文件

\# tree = ET.parse('xo.xml')  \# 首先建立了一个 xml tree 对象

\# root = tree.getroot()

\# print(root)  \# 获取根节点

\# print(root.tag)  \# 取根节点名

\# print(root.attrib)  \# 获取节点属性

\# 3) 遍历多层xml

for child in root:

print(child.tag, child.attrib)

for child\_second in child:

print(child\_second.tag, child\_second.text)  \# child\_second.text 节点内容

\# 4) 遍历指定的节点

for node in root.iter('year'):

print(node.tag, node.text)

\# 5) 修改节点内容

for node in root.iter('year'):

new\_year = int(node.text) + 1

node.text = str(new\_year)

node.set('name', 'london')

node.set('age', '18')

del node.attrib\['age'\]

tree = ET.ElementTree(root)

tree.write('new\_xo.xml', encoding='utf-8')

\# 6、删除节点

str\_xml = open('xo.xml', 'r').read()

root = ET.XML(str\_xml)

for country in root.findall('country'):

rank = int(country.find('rank').text)

if rank > 50:

root.remove(country)

tree = ET.ElementTree(root)

tree.write('new\_xoo.xml', encoding='utf-8')

\# 7、创建 xml 文档

from xml.dom import minidom

def prettify(elem):

"""将节点转换成字符串，并添加缩进。

"""

rough\_string = ET.tostring(elem, 'utf-8')

reparsed = minidom.parseString(rough\_string)

return reparsed.toprettyxml(indent="\\t")

\# 创建根节点

root = ET.Element("famliy")

\# 创建大儿子

\# son1 = ET.Element('son', \{'name': '儿1'\})

son1 = root.makeelement('son', \{'name': '儿1'\})

\# 创建小儿子

\# son2 = ET.Element('son', \{"name": '儿2'\})

son2 = root.makeelement('son', \{"name": '儿2'\})

\# 在大儿子中创建两个孙子

\# grandson1 = ET.Element('grandson', \{'name': '儿11'\})

grandson1 = son1.makeelement('grandson', \{'name': '儿11'\})

\# grandson2 = ET.Element('grandson', \{'name': '儿12'\})

grandson2 = son1.makeelement('grandson', \{'name': '儿12'\})

son1.append(grandson1)

son1.append(grandson2)

\# 把儿子添加到根节点中

root.append(son1)

raw\_str = prettify(root)  \# 自动添加缩进

f = open("xxxoo.xml", 'w', encoding='utf-8')

f.write(raw\_str)

f.close()

configparser 用于处理特定格式的文件 实质上是通过open来操作文件

源文件特定格式

\[section1\]

k1 = 123

k2 = v2

\[section2\]

k1 = 456

k2 = v2

k3 = v3

常见操作

import configparser

\# 1、读取文件 读取节点

config = configparser.ConfigParser()

config.read('conf\_file', encoding='utf-8')

ret = config.sections()  \# 获取所有节点 返回一个列表

ret1 = config.items('section1')  \# 读取节点下的键值对

ret2 = config.options('section1')  \# 读取某个节点下的键

print(ret)

print(ret1)

print(ret2)

\# 2、读取节点键值

v = config.get('section1', 'k1')  \# 获取指定key下的值 默认 str 类型

\# v = config.getint('section1', 'k1')

\# v = config.getfloat('section1', 'k1')

\# v = config.getboolean('section1', 'k1')

print(v, type(v))

\# 3、检查 添加 删除节点

has\_sec = config.has\_section('section1')

print(has\_sec)

\# config.add\_section('section5')

\# config.write(open('conf\_file', 'w'))

\# config.remove\_section('section3')

\# config.write(open('conf\_file', 'w'))

\# 4、检查 删除 设置 指定组内的键值对

has\_opt = config.has\_option('section1', 'k1')

print(has\_opt)

\# config.remove\_option('section2', 'k3')

\# config.write(open('conf\_file', 'w'))

config.set('section5', 'k1', '123')

config.write(open('conf\_file', 'w'))

re 模块

.  匹配除换行符以外的任意字符

\\w 匹配字母或数字或下划线或汉字

\\s 匹配任意的空白符

\\d 匹配数字

\\b 匹配单词的开始或结束

^  匹配字符串的开始

$  匹配字符串的结束

\*  重复零次或更多次

\+  重复一次或更多次

?  重复零次或一次

\{n\}   重复n次

\{n,\}  重复n次或更多次

\{n,m\} 重复n到m次

\# import re

\# match

\# print(re.match('com', 'comwww.runcombb').group())  \# match 匹配起始位置

\# print(re.search('com', 'www.runcombb').group())  \# search 匹配第一次位置

\# sub subn 匹配 替换

\# print(re.sub("g.t", "have", 'I get A, get B', 1))  \# 1表示只替换1次

\# print(re.subn("g.t", "have", 'I get A, get B'))  \# 提示替换了几次

\# split

\# print(re.split('\\d+', 'one1two2three3four4'))  \# 有空格

\# 输出

\# \['one', 'two', 'three', 'four', ''\]

\# compile 封装一个固定匹配规则供多次调用

\# s = "JGood is a boy,so cool..."

\# r = re.compile(r'\\w\*oo\\w\*')   \# 查找所有包含oo的单词

\# print(r.findall(s))

\# 输出：

\# \['JGood', 'cool'\]

\# 反斜杠

\# 在Python中 要进行两次转义才能匹配一个带反斜杠的字符 所以需要4个 \\\\\\\\

\# print(re.search("\\\\\\\\com", "\\comcn").group())

\# 单词

\# print(re.findall(r'I\\b', 'I&am Ikobe')) \# 有很多字符可以用来分隔单词 这里使用&

\# 分组

\# 去已经匹配到的数据中再提取数据

\# origin = 'has sdfsdfsdfwer432'

\# r = re.match("h\\w+", origin)  \# 输出：has () \{\}

\# r = re.match("h(\\w+)", origin)  \# 输出：has ('as',) \{\}

\# r = re.match("h(?P<name>\\w+)", origin)  \# 输出：has ('as',) \{'name': 'as'\}

\# print(r.group())

\# print(r.groups())

\# print(r.groupdict())

\# findall 分组

\# origin = "hasaabc halaaabc"

\# r = re.findall("h(\\w+)a(ab)c", origin)  \# 首先整体匹配 再将分组放入结果

\# print(r)

\# 输出：

\# \[('as', 'ab'), ('ala', 'ab')\]

\# spilt 分组

\# origin = "hello alex abc alex age"

\# r = re.split("a(le)x", origin, 1)  \# 忽略了alex 直接匹配le

\# print(r)

\# 输出：

\# \['hello ', 'le', ' abc alex age'\]

常用正则表达式

\# 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\_-\]+)+

hashlib

\# import hashlib

\# obj = hashlib.md5(bytes('sdfsdfsadf', encoding='utf-8'))  \# 加bytes任意字符防止被撞库破译

\# obj.update(bytes('123', encoding='utf-8'))

\# r = obj.hexdigest()

\# print(r)

\# python内置还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密

\# import hmac

\# h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))

\# h.update(bytes('admin',encoding="utf-8"))

\# print(h.hexdigest())

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所指向的文件或者目录的最后修改时间

sys

用于对Python解释器相关操作：

sys.argv           命令行参数List，第一个元素是程序本身路径

sys.exit(n)        **退出程序，正常退出时exit(0)**

sys.version        获取Python解释程序的版本信息

sys.maxint         最大的Int值

sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform       返回操作系统平台名称

sys.stdin          输入相关

sys.stdout         输出相关

sys.stderror       错误相关

关于sys运用：进度条

def view\_bar(num, total):

rate = num / total

rate\_num = int(rate \* 100)

r1 = '\\r%s>%d%%' % ("="\*num, rate\_num,)  \# 加 r 的话让每次输出回到初始最前面位置

sys.stdout.write(r1)  \# 和print的区别就是不加换行符

sys.stdout.flush()  \# 清空屏幕输出

for i in range(0, 101):

time.sleep(0.1)

view\_bar(i, 100)

python的内置模块中对于命令行的解析模块共两个getopt 和 optparse 。不过getopt过于简单，往往不能满足需求。此时可以使用optparse模块。这个模块相对于getopt更新，功能更强大。

那么如何使用optparse模块呢? optparse 模块的官方文档给出了很详细的说明。

第一步、导入模块，并在主函数中创建实例

from optparse import OptionParser

\[...\]

parser = OptionParser()

第二步、使用add\_option定义需要的option

parser.add\_option(opt\_str, ...,

attr=value, ...)

add\_option 方法中有很多可选的参数，及一些影响optparse函数行为的属性。这些东西都很值得去细细推敲。

最后一步、当定义完所有option 后，通过parse\_args 去解析所有的option。并返回解析结果

(options, args) = parser.parse\_args()

parse\_args 默认解析的是sys.argv\[1:\] 的所有参数。不过若你喜欢，也可以自己传递参数到parse\_args。例如如下的形式：

args = \["-f", "foo.txt"\]

(options, args) = parser.parse\_args(args)

parse\_args 有两个返回值，options 和 args 。其中options是一个对象，通过这个对象可以获取到所有定义的option相应信息。而args是一个list，里面存储了所有没有被定义的参数信息。

以上三个步骤，就是使用optparse模块的完整体现。不过在第二步中add\_option中存在很多影响pars\_args行为的属性，将在下面逐步记录解释。

action 属性：

它将告诉optparse 遇到相应的命令行时应该怎么去做。默认若不指定action属性，它将被赋予默认值store。那么store是什么意义呢？以官方的实例说明

当添加如下的option：

parser.add\_option("-f", "--file",

action="store", type="string", dest="filename")

且传递如下的参数：

args = \["-f", "foo.txt"\]

(options, args) = parser.parse\_args(args)

当optparse 发现参数-f 时，它会将-f后面的一个参数也消费掉(将-f 和 foo.txt绑定到一起了)。并将foo.txt存储到options.filename中。当经过parse\_args解析后，调用options.filename时将得到foo.txt这个值。

以上是action的默认值store。另外还有布尔类型的action。这样类型的东西主要是在命令行参数不需要值的时候使用。例如 -v 查看版本号， -v 后面就需要再写参数了。

Example：

parser.add\_option("-v", action="store\_true", dest="verbose")

parser.add\_option("-q", action="store\_false", dest="quit")

以上两个例子，当经过parse\_args后调用options.verbose将为true。而调用options.quit将为false

当然，action还有其他一些值。如：store\_const、append、count 和 callback 。研究后再呈上文章吧。

default属性：

给相应的参数设置默认值，也是一个很有必要知道的属性

Example:

parser.add\_option("-v", action="store\_true", dest="verbose", default=False)

parser.add\_option("-q", action="store\_false", dest="verbose", default=True)

另外一种比较清晰的方法设置默认值：

parser.set\_defaults(verbose=True)

parser.add\_option(...)

(options, args) = parser.parse\_args()

optparse，是一个能够让程式设计人员轻松设计出简单明了、易于使用、符合标准的Unix命令列程式的Python模块。生成使用和帮助信息。

使用此模块前，首先需要导入模块中的类OptionParser，然后创建它的一个实例（对象）：

from optparse import OptionParser

parser = OptionParser()  \#这里也可以定义类的参数

例子1：

from optparse import OptionParser

def opt():

parser=OptionParser("Usage: %prog -a command")

parser.add\_option('-a',

dest='addr',

action='store',

help='ip or iprange EX: 192.168.1,192.168.1.3 or192.168.1.1-192.168.1.100')

options,args=parser.parse\_args()

return options, args

options,args=parser.parse\_args()是一个方法返回的是一个元组里面包括选项和参数及options和args

例子2

\#!/usr/bin/python

from optparse import OptionParser

import sys

import os

parser = OptionParser()

parser.add\_option("-c","--char",

dest="chars",

action="store\_true",

default=False,

help="only count chars")

parser.add\_option("-w", "--word",

dest="words",

action="store\_true",

default=False,

help="only count words")

parser.add\_option("-l", "--line",

dest="lines",

action="store\_true",

default=False,

help="only count lines")

options, args=parser.parse\_args()

print options,args

执行这个脚本 python  aa.py

\{'chars': False, 'lines': False, 'words': False\} \[\]

\[root@133 day1\]\# python hu.py -w hu.py

\{'chars': False, 'lines': False, 'words': True\}\['hu.py'\]

这个hu.py就代表args  参数。大括号里面的代表options选项

**注意：不要用模块的名字做脚本的名字，否则运行时会报错**

\#!/usr/bin/env python

\#coding:utf-8

\#对标准输入进行统计

import sys, os

from optparse import OptionParser

def opt():

usage = "usage: %prog \[options\] arg1 arg2"

parser = OptionParser()

parser.add\_option("-c", "--char",

dest="chars",

action="store\_true",

default=False,

help="only count chars")

parser.add\_option("-w", "--word",

dest="words",

action="store\_true",

default=False,

help="only count words")

parser.add\_option("-l", "--line",

dest="lines",

action="store\_true",

default=False,

help="only count lines")

parser.add\_option("-n", "--nototal",

dest="nototal",

action="store\_true",

default=False,

help="nototal")

options, args = parser.parse\_args()

return options, args

opt()

print sys.argv\[:\]    //打印出脚本运行时的参数，注意和parse\_args返回的参数做对比

options, args = opt()

print options, args    //打印出parse\_args返回的args的值。

\#!/usr/bin/env python

\# coding=utf-8

import sys, os

from optparse import OptionParser

def opt():

parser = OptionParser()

parser.add\_option("-c", "--char",

dest="chars",

action="store\_true",

default=False,

help="only count chars")

parser.add\_option("-w", "--ward",

dest="words",

action="store\_true",

default=False,

help="only count words")

parser.add\_option("-l", "--line",

dest="lines",

action="store\_true",

default=False,

help="only count lines")

parser.add\_option("-n", "--no-total",

dest="nototal",

action="store\_true",

default=False,

help="show total or not")

options, args = parser.parse\_args()

return options, args

def get\_count(data):

chars =  len(data)

words = len(data.split())

lines = data.count('\\n')

return lines, words, chars

def print\_wc(options, lines, words, chars, fn):

if options.lines:

print lines,

if options.words:

print words,

if options.chars:

print chars,

print(fn)

def main():

options, args = opt()

if not (options.words or options.chars or options.lines):

options.words, options.chars, options.lines = True, True, True

if args:

total\_lines, total\_words, total\_chars = 0, 0, 0

for fn in args:

if os.path.isfile(fn):

with open(fn) as fd:

data = fd.read()

lines, words, chars = get\_count(data)

print\_wc(options, lines, words, chars, fn)

total\_lines += lines

total\_words += words

total\_chars += chars

elif os.path.isdir(fn):

print("%s: is a directory" % fn, file=sys.stderr)

else:

sys.stderr.write("%s: No such file or direcotry\\n" % fn)

if len(args) > 1 and not options.nototal:

print\_wc(options, total\_lines, total\_words, total\_chars, 'total')

else:

data = sys.stdin.read()

fn = ''

lines, words, chars = get\_count(data)

print\_wc(options, lines, words, chars, fn)

if \_\_name\_\_ == '\_\_main\_\_':

main()

\#!/usr/bin/env python

import sys, os

from optparse import OptionParser

parser = OptionParser()

parser.add\_option("-c", "--char",

dest="chars",

action="store\_true",

default=False,

help="only count chars")

parser.add\_option("-w", "--word",

dest="words",

action="store\_true",

default=False,

help="only count words")

parser.add\_option("-l", "--line",

dest="lines",

action="store\_true",

default=False,

help="only count lines")

options, args = parser.parse\_args()

print options, args

data = sys.stdin.read()

chars = len(data)

words = len(data.split())

lines = data.count('\\n')

if options.chars:

print chars,

if options.words:

print words,

if options.lines:

print lines

parse\_args()这个方法返回两个值，options和args，分别是对象和列表，options里包括所有使用parser.add\_option()这个方法定义的选项，比如‘-w'。

options.words就是存储'-w'这个选项的，它的值是True或者False，比如脚本后面带-w选项时，那么options.words的值就是True。

下面这个在ipython下的输出，由于没有使用add\_option()定义任何选项，所以options的输出里没有选项的值。

这个是python自带的模块，想具体了解它的内部是如何实现的，源码文件在这个位置，/usr/lib64/python2.6/optparse.py。

脚本中这样定义的：dest = "characters",

后面应该这样判断：if options.characters，而不是if options.chars

dest和action有什么用？看Help似乎没怎么提到？

在代码里引用选项时需要dest后面定义的那个名字，比如引用-c选项，就使用options.characters，每个选项都需要dest去定义一个名字，这个值就是选项的名字，目的就是在程序中去引用这个选项，比如：if not (options.characters or options.words or options.lines):括号里就是在引用这些选项。

有的命令后面的选项就是一个字母，有的不仅有字母，而且后面还有值，比较一下下面这两个命令：

wc -l /etc/passwd

tail -n 20 /etc/passwd

\-l与-n都是选项，但是行为不一样，-l后面没有值，-n后面有值，那么选项后面带不带值是action决定的，如果action="store\_true",那么说明选项后面没有值，如果action='store',说明选项后面需要带值。

脚本后面跟-h时，可以看到help定义的内容。

那default又是有什么作用，为False和True分别表示什么？

拿-c选项举例子，

default如果为True，表示脚本后面如果不加-c选项，默认也是有-c的行为的。

default为False时，表示脚本后面不加-c选项，就没有-c的行为，比如wc -l /etc/hosts，没有-c选项，就说明不对字符统计，只对行数统计

sftp是安全文件传输协议，提供一种安全的加密方法，sftp是SSH的一部分，SFTPClient类实现了sftp客户端，通过已建立的SSH通道传输文件，与其他的操作，如下：

sftp.getcwd()返回当前工作目录

sftp.chdir(path)改变工作目录

sftp.chmod(path, mode)修改权限

sftp.chown(path, uid, gid)设置属主属组

sftp.close()关闭sftp

sftp.file(filename, mode='r', bufsize=-1)读取文件

sftp.from\_transport(s)创建SFTP客户端通道

sftp.listdir(path='.')列出目录，返回一个列表

sftp.listdir\_attr(path='.')列出目录，返回一个SFTPAttributes列表

sftp.mkdir(path, mode=511)创建目录

sftp.normalize(path)返回规范化path

sftp.open(filename, mode='r', bufsize=-1)在远程服务器打开文件

sftp.put(localpath, remotepath, callback=None) localpath文件上传到远程服务器remotepath

sftp.get(remotepath, localpath, callback=None) 从远程服务器remotepath拉文件到本地localpath

sftp.readlink(path)返回一个符号链接目标

sftp.remove(path)删除文件

sftp.rename(oldpath, newpath)重命名文件或目录

sftp.rmdir(path)删除目录

sftp.stat(path)返回远程服务器文件信息（返回一个对象的属性）

sftp.truncate(path, size)截取文件大小

sftp.symlink(source, dest)创建一个软链接（快捷方式）

sftp.unlink(path)删除软链接

fabric

fabric模块是在paramiko基础上又做了一层封装，操作起来更方便。主要用于多台主机批量执行任务。

默认Python没有，需要手动安装：pip install fabric

如安装失败，可以尝试yum安装：yum install fabric

Fabric常用API：

API类

描述

示例

local执行本地命令 local('uname -s')

lcd切换本地目录 lcd('/opt')

run执行远程命令 run('uname -s')

cd切换远程目录 cd('/opt')

sudosudo方式执行远程命令sudo('/etc/init.d/httpd start')

put上传本地文件或目录到远程主机put(remote\_path, local\_path)

get从远程主机下载文件或目录到本地put(local\_path, remote\_path)

open\_shell打开一个shell，类似于SSH连接到了远程主机open\_shell("ifconfig eth0")

prompt获得用户输入信息prompt('Please input user password: ')

confirm获得提示信息确认confirm('Continue\[Y/N\]?')

reboot重启远程主机 reboot()

@task函数装饰器，引用说明函数可调用，否则不可见

@runs\_once函数装饰器，函数只会执行一次

当我们写好fabric脚本后，需要用fab命令调用执行任务。

命令格式：fab \[options\] <command>\[:arg1,arg2=val2,host=foo,hosts='h1;h2',...\] ...

fab命令有以下常用选项：

选项

描述

\-l打印可用的命令（函数）

\--set=KEY=VALUE,...逗号分隔，设置环境变量

\--shortlist简短打印可用命令

\-c PATH指定本地配置文件

\-D不加载用户known\_hosts文件

\-f PATH指定fabfile文件

\-g HOST逗号分隔要操作的主机

\-i PATH指定私钥文件

\-k不加载来自~/.ssh下的私钥文件

\-p PASSWORD使用密码认证and/or sudo

\-P默认为并行执行方法

\--port=PORT指定SSH连接端口

\-R ROLES根据角色操作，逗号分隔

\-s SHELL指定新shell，默认是'/bin/bash -l -c'

\--show=LEVELS以逗号分隔的输出

\--ssh-config-path=PATHSSH配置文件路径

\-t N设置连接超时时间，单位秒

\-T N设置远程命令超时时间，单位秒

\-u USER连接远程主机用户名

\-x HOSTS以逗号分隔排除主机

\-z INT并发进程数

本地执行命令

from fabric.api import local

def command():

local('ls')

\# fab command

\[localhost\] local: ls

fabfile.py  fabfile.pyc  tab.py  tab.pyc

Done.

使用fab命令调用，默认寻找当前目录的fabfile.py文件。

from fabric.api import run

def command():

run('ls')

\# fab -H 192.168.1.120 -u user command

\[192.168.1.120\] Executing task 'command'

\[192.168.1.120\] run: ls

\[192.168.1.120\] Login password for 'user':

\[192.168.1.120\] out: access.log  a.py

\[192.168.1.120\] out:

Done.

Disconnecting from 192.168.1.120... done.

**如果在多台主机执行，只需要-H后面的IP以逗号分隔即可**。

给脚本函数传入位置参数

from fabric.api import run

def hello(name="world"):

print("Hello %s!" % name)

\# fab -H localhost hello

\[localhost\] Executing task 'hello'

Hello world!

Done.

\# fab -H localhost hello:name=Python

\[localhost\] Executing task 'hello'

Hello Python!

Done.

主机列表组

from fabric.api import run, env

env.hosts = \['root@192.168.1.120:22', 'root@192.168.1.130:22'\]

env.password = '123.com'

env.exclude\_hosts = \['root@192.168.1.120:22'\]   \# 排除主机

def command():

run('ls')

env作用是定义fabfile全局设定，类似于变量。还有一些常用的属性：

env属性

描述

示例

env.hosts定义目标主机env.hosts = \['192.168.1.120:22'\]

env.exclude\_hosts排除指定主机env.exclude\_hosts = '\[192.168.1.1\]'

env.user定义用户名env.user='root'

env.port定义端口 env.port='22'

env.password定义密码env.password='123'

env.passwords定义多个密码，不同主机对应不同密码env.passwords = \{'root@192.168.1.120:22': '123'\}

env.gateway定义网关env.gateway='192.168.1.2'

env.roledefs定义角色分组env.roledef = \{'web':\['192.168.1.11'\], 'db':\['192.168.1.12'\]\}

env.deploy\_release\_dir自定义全局变量，格式：env.+ '变量名'env.var

\# vi install.py

from fabric.api import run, env

env.roledefs = \{

'web': \['192.168.1.10', '192.168.1.20'\],

'db': \['192.168.1.30', '192.168.1.40'\]

env.password = '123'

@roles('web')

def task1():

run('yum install httpd -y')

@roles('db')

def task2():

run('yum install mysql-server -y')

def deploy():

execute(task1)

execute(task2)

\# fab -f install.py deploy

上传目录到远程主机

from fabric.api import \*

env.hosts = \['192.168.1.120'\]

env.user = 'user'

env.password = '123.com'

def task():

put('/root/abc', '/home/user')

run('ls -l /home/user')

\# fab task

从远程主机下载目录

from fabric.api import \*

env.hosts = \['192.168.1.120'\]

env.user = 'user'

env.password = '123.com'

def task():

get('/home/user/b', '/opt')

local('ls -l /opt')

\# fab task

**打印颜色，有助于关键地方醒目**

from fabric.colors import \*

def show():

print green('Successful.')

print red('Failure!')

print yellow('Warning.')

\# fab show

pexpect

pexpect是一个用来启动子程序，并使用正则表达式对程序输出做出特定响应，以此实现与其自动交互的Python模块。暂不支持Windows下的Python环境执行。

这里主要讲解run()函数和spawn()类，能完成自动交互，下面简单了解下它们使用。

安装Python

download pexpect-2.3.tar.gz

tar zxvf pexpect-2.3.tar.g

cd pexpect-2.3

python setup.py install  (do this as root)

下载pexpect模块：https://pypi.python.org/pypi/pexpect/\#downloads

解压后在目录下运行：python ./setup.py install　（必须是root权限）

如果没有使用root权限，你只需要把lib的路径放入sys.path，这样便可以使用pexpect

import sys

sys.path.append('pexpect-4.2.1/build/lib')

确认是否安装成功

import pexpect

dir(pexpect)

\['EOF', 'ExceptionPexpect', 'Expecter', 'PY3', 'TIMEOUT', '\_\_all\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_file\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_path\_\_', '\_\_revision\_\_', '\_\_version\_\_', 'exceptions', 'expect', 'is\_executable\_file', 'searcher\_re', 'searcher\_string', 'split\_command\_line', 'sys', 'utils', 'which'\]

18.3.1 run()

**run()函数用来运行bash命令，类似于os模块中的system()函数。**

参数：run(command, timeout=-1, withexitstatus=False, events=None, extra\_args=None, logfile=None, cwd=None, env=None)

run(command,timeout=-1,withexitstatus=False,events=None,extra\_args=None,logfile=None, cwd=None, env=None)

函数 run 可以用来运行命令，其作用与 Python os 模块中 system() 函数相似。

run() 是通过 Pexpect 类实现的。

如果命令的路径没有完全给出，则 run 会使用 which 命令尝试搜索命令的路径 。

例1：执行ls命令

>>> import pexpect

>>> pexpect.run("ls")

例2：获得命令状态返回值

>>> command\_output, exitstatus = pexpect.run("ls", withexitstatus=1)

command\_outout是执行结果，exitstatus是退出状态值。

使用 run()执行 svn 命令

from pexpect import \*

run ("svn ci -m 'automatic commit' my\_file.py")

与 os.system() 不同的是，**使用 run() 可以方便地同时获得命令的输出结果与命令的退出状态** 。

run() 的返回值

from pexpect import \*

(command\_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)

command\_out 中保存的就是 /bin 目录下的内容

spawn()是pexpect模块主要的类，实现启动子程序，**使用pty.fork()生成子进程，并调用exec()系列函数执行命令。**

参数：spawn(command, args=\[\], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None)

spawn()类几个常用函数：

expect(pattern, timeout=-1, searchwindowsize=None) \#匹配正则表达式，pattern可以是正则表达式。

**send(s)给子进程发送一个字符串**

sendline(s='')就像send()，但添加了一个换行符（os.lineseq）

sendcontrol(char)**发送一个控制符**，比如ctrl-c、ctrl-d

spawn() 使用示例

child = pexpect.spawn ('/usr/bin/ftp') \#执行ftp客户端命令

child = pexpect.spawn ('/usr/bin/ssh user@example.com') \#使用ssh登录目标机器

child = pexpect.spawn ('ls -latr /tmp') \#显示 /tmp目录内容

当子程序需要参数时，还可以使用一个参数的列表：

child = pexpect.spawn ('/usr/bin/ftp', \[\])

child = pexpect.spawn ('/usr/bin/ssh', \['user@example.com'\])

child = pexpect.spawn ('ls', \['-latr', '/tmp'\])

在构造函数中，maxread 属性指定了 Pexpect 对象试图从 tty 一次读取的最大字节数，它的默认值是2000字节 。

由于需要实现不断匹配子程序输出， searchwindowsize 指定了从输入缓冲区中进行模式匹配的位置，默认从开始匹配。

logfile 参数指定了 Pexpect 产生的日志的记录位置。

记录日志

child = pexpect.spawn('some\_command')

fout = file('mylog.txt','w')

child.logfile = fout

还可以将日志指向标准输出：

child = pexpect.spawn('some\_command')

child.logfile = sys.stdout

如果不需要记录向子程序输入的日志，只记录子程序的输出，可以使用：

child = pexpect.spawn('some\_command')

child.logfile\_send = sys.stdout

ftp交互

用ftp命令登录是这样的，需要手动输入用户名和密码，才能登录进去。

\# ftp 192.168.1.10

Connected to 192.168.1.10 (192.168.1.10).

220-FileZilla Server version 0.9.46 beta

220-written by Tim Kosse (tim.kosse@filezilla-project.org)

220 Please visit http://sourceforge.net/projects/filezilla/

Name (192.168.1.10:root): yunwei

331 Password required for yunwei

Password:

230 Logged on

Remote system type is UNIX.

ftp>

下面我们用pexpect帮我们完成输入用户名和密码：

import pexpect

child = pexpect.spawn('ftp 192.168.1.10')

child.expect('Name .\*: ')

child.sendline('yunwei')

child.expect('Password:')

child.sendline('yunweipass')

child.expect('ftp> ')

child.sendline('ls')

child.sendline('bye')

child.expect(pexpect.EOF)   \# pexpect.EOF程序打印提示信息

print child.before   \# 保存命令执行结果

Python 远程批量修改密码脚本

\#tar -zxvf pexpect-3.0.tar.gz

\#cd pexpect-3.0

\#python setup.py install

\#!/usr/bin/env python

\#coding:utf8

import pexpect

import sys

iplist = \['192.168.140.142','192.168.140.145'\] \#\#定义主机列表

oldpasswd = '234567' \#\#旧密码

newpasswd = '1234567' \#\#新密码

while iplist:

ip = iplist\[-1\] \#\#获取一个IP

iplist.pop() \#\#列表去掉一个值

child = pexpect.spawn('ssh root@'+ip) \#\#定义触发

fout = file('passlog.txt','a') \#\#定义日志文件，

child.logfile = fout

try:

while True:

index = child.expect(\['(yes/no)','(?i)password:'\])

if index == 0:

child.sendline('yes')

elif index == 1:

child.sendline(oldpasswd)

child.expect('\#')

child.sendline('echo  '+newpasswd+' | passwd --stdin root')

child.expect('\#')

child.sendline('exit')

except pexpect.TIMEOUT:

print >>sys.stderr, ip+' timeout'

except pexpect.EOF:

print >>sys.stderr, ip+' <the end>'

（1）spawn类

class pexpect.spawn(command,args=\[\],timeout=30,maxread=2000,searchwidowsize=None

,logfile=None,cwd=None,env=None,ignore\_sighup=True)

（2）run函数

pexpect.run(command,timeout=-1,withexitstatus=False,events=None,extra\_args=None,

logfile=None,cwd=None,env=None).

（3）pxssh类

class pexpect.pxssh.pxssh(timeout=30,maxread=2000,searchwidowsize=None,logfile=None,

cwd=None,env=None)

pxssh常用的三个方法：

logout()断开连接；

prompt()等待系统提示符，用于等待命令执行结束

python之pexpect用法及scp新用途

import pexpect

def scp\_cmd():

passwd='\*\*\*\*\*\*\*'

passwd1='\*\*\*\*\*\*\*'

ssh = pexpect.spawn('scp -rp root@192.168.1.107:/backup root@192.168.1.102:/data')

r = ''

try:

i = ssh.expect(\['password: ', 'continue connecting (yes/no)?'\])

if i == 0 :

ssh.sendline(passwd)

elif i == 1:

ssh.sendline('yes')

ssh.expect('password:')

ssh.sendline(passwd)

b=ssh.expect(\['password: ','continue connecting (yes/no)?'\])

if b==0:

ssh.sendline(passwd1)

elif b==1:

ssh.sendline('yes')

ssh.expect('password:')

ssh.sendline(passwd1)

except pexpect.EOF:

ssh.close()

else:

r = ssh.read()

ssh.expect(pexpect.EOF)

ssh.close()

return r

scp\_cmd()

python安装setuptools模块之后，便可使用easy\_install来安装python的第三方扩展模块，默认安装路径是：

/usr/lib/python2.6/site-packages/

easy\_install 模块名 \#可以直接安装

easy\_install  pexpect

\[root@zhu ~\]\# easy\_install pexpect

Searching for pexpect

Reading http://pypi.python.org/simple/pexpect/

Reading http://pexpect.readthedocs.org/

Reading http://pexpect.sourceforge.net/

Reading http://sourceforge.net/project/showfiles.php?group\_id=59762

Best match: pexpect 3.1

Downloading https://pypi.python.org/packages/source/p/pexpect/pexpect-3.1.tar.gz\#md5=5a8e1573062e2e2c203c9a6d213b16e7

Processing pexpect-3.1.tar.gz

Running pexpect-3.1/setup.py -q bdist\_egg --dist-dir /tmp/easy\_install-KOPmVQ/pexpect-3.1/egg-dist-tmp-GnQBTg

zip\_safe flag not set; analyzing archive contents...

Adding pexpect 3.1 to easy-install.pth file

Installed /usr/lib/python2.6/site-packages/pexpect-3.1-py2.6.egg

Processing dependencies for pexpect

Finished processing dependencies for pexpect

\#由于pexpect-3.1-py2.6.egg此时仍是一个压缩文件，所以需要进行解压。

cd /usr/lib/python2.6/site-packages/

unzip pexpect-3.1-py2.6.egg

pexpect是一个用来启动子程序并对其进行自动控制的python模块，可以用来和ssh，ftp，telnet等需要输入密码的命令行程序进行自动交互。

安装过程如上。

另一种安装方法如下：

wget http://pexpect.sourceforge.net/pexpect-2.3.tar.gz

tar xzf pexpect-2.3.tar.gz

cd pexpect-2.3

python ./setup.py install

pexpect 模块的使用如下：

>>> pexpect.

pexpect.EOF(                 pexpect.\_\_path\_\_             pexpect.run(

pexpect.ExceptionPexpect(    pexpect.\_\_reduce\_\_(          pexpect.runu(

pexpect.PY3                  pexpect.\_\_reduce\_ex\_\_(       pexpect.searcher\_re(

pexpect.TIMEOUT(             pexpect.\_\_repr\_\_(            pexpect.searcher\_string(

pexpect.\_\_all\_\_              pexpect.\_\_revision\_\_         pexpect.select

pexpect.\_\_class\_\_(           pexpect.\_\_setattr\_\_(         pexpect.signal

pexpect.\_\_delattr\_\_(         pexpect.\_\_sizeof\_\_(          pexpect.spawn(

pexpect.\_\_dict\_\_             pexpect.\_\_str\_\_(             pexpect.spawnu(

pexpect.\_\_doc\_\_              pexpect.\_\_subclasshook\_\_(    pexpect.split\_command\_line(

pexpect.\_\_file\_\_             pexpect.\_\_version\_\_          pexpect.struct

pexpect.\_\_format\_\_(          pexpect.\_run(                pexpect.sys

pexpect.\_\_getattribute\_\_(    pexpect.codecs               pexpect.termios

pexpect.\_\_hash\_\_(            pexpect.errno                pexpect.time

pexpect.\_\_init\_\_(            pexpect.fcntl                pexpect.traceback

pexpect.\_\_loader\_\_           pexpect.os                   pexpect.tty

pexpect.\_\_name\_\_             pexpect.pty                  pexpect.types

pexpect.\_\_new\_\_(             pexpect.re                   pexpect.which(

pexpect.\_\_package\_\_          pexpect.resource

1.pexpect.run(）函数的使用

run(command, timeout=-1, withexitstatus=False, events=None, extra\_args=None, logfile=None, cwd=None, env=None)

\#默认情况下该指令：

\#1.运行给出的指令command，如果指令不是以绝对路径给出，会自动在PATH中寻找。结果输出作为字符串返回，行与行之间以\\r\\n分割。

\#2.withexitstatus设置为True时，结果返回一个元组，(command\_output,

exitstatus)

\#events是一个字典，有模式和应答组成，可以自动输入内容，如果应答需要输入enter键时，此时需要为一个新行，即添加\\n.

>>> pexpect.run('cat /root/a.txt')

'qian shan\\r\\nniao fei jue\\r\\ndu diao han jiang xue\\r\\n'

>>> pexpect.run('cat /root/a.txt',withexitstatus=1)

('qian shan\\r\\nniao fei jue\\r\\ndu diao han jiang xue\\r\\n', 0)

>>> pexpect.run('scp /root/a.txt 192.168.56.102:/root',withexitstatus=1,events=\{'password': '123456\\n'\})

("root@192.168.56.102's password: \\r\\n\\ra.txt                                           0%    0     0.0KB/s   --:-- ETA\\ra.txt                                         100%   45     0.0KB/s   00:00    \\r\\n", 0)

2.pexpect.spawn()类的使用

spawn是Pexpect模块主要的类，用以实现启动子程序，它有丰富的方法与子程序交互从而实现用户对子程序的控制。它主要使用 pty.fork() 生成子进程，并调用 exec() 系列函数执行 command 参数的内容。

child = pexpect.spawn ('/usr/bin/ftp') \#执行ftp客户端命令

child = pexpect.spawn ('/usr/bin/ssh user@example.com') \#使用ssh登录目标机器

child = pexpect.spawn ('ls -latr /tmp') \#显示 /tmp目录内容

child = pexpect.spawn ('/usr/bin/ftp', \[\])

child = pexpect.spawn ('/usr/bin/ssh', \['user@example.com'\])

child = pexpect.spawn ('ls', \['-latr', '/tmp'\])

child = pexpect.spawn('some\_command')

fout = file('mylog.txt','w')

child.logfile = fout

child = pexpect.spawn('ssh root@192.168.56.102')

child.expect(self, pattern, timeout=-1, searchwindowsize=-1)

为了控制子程序，等待子程序产生特定输出，做出特定的响应，可以使用 expect 方法

在参数中： pattern 可以是正则表达式， pexpect.EOF ， pexpect.TIMEOUT ，或者由这些元素组成的列表。需要注意的是，当 pattern 的类型是一个列表时，且子程序输出结果中不止一个被匹配成功，则匹配返回的结果是缓冲区中最先出现的那个元素，或者是列表中最左边的元素。使用 timeout 可以指定等待结果的超时时间 ，该时间以秒为单位。当超过预订时间时， expect 匹配到pexpect.TIMEOUT。

3.打印before的内容

>>> child = pexpect.spawn('ls -l')

>>> child.expect(pexpect.EOF)

>>> print child.before

总用量 64

drwxr-xr-x.  3 root root  4096 4月   2 10:09 aaa

\-rw-r--r--.  1 root root    45 4月   3 15:01 a.txt

drwxr-xr-x. 16 root root  4096 3月   6 21:36 biaozhunku

drwxr-xr-x.  2 root root  4096 3月  27 17:03 mypython

drwxr-xr-x.  2 root root  4096 4月   3 13:21 mysource

drwxr-xr-x.  2 root root  4096 4月   3 13:20 mywork

drwxr-xr-x.  2 root root 36864 3月  19 11:09 pythoncook

\-rw-r--r--.  1 root root   276 4月   3 14:26 zhu.py

\#child.before 保存的就是在根目录下执行 ls 命令的结果

send(self, s)

sendline(self, s='')

sendcontrol(self, char)

这些方法用来向子程序发送命令，模拟输入命令的行为。与 send() 不同的是 sendline() 会额外输入一个回车符 ，更加适合用来模拟对子程序进行输入命令的操作。当需要模拟发送 “Ctrl+c” 的行为时，还可以使用 sendcontrol() 发送控制字符。

手动输入时，是来自键盘的标准输入，而pexpect是先匹配到关键字，再向子进程发送字符串。

pexpect.EOF打印提示信息，child.before保存的是命令执行结果。

通过上面的例子想必你已经知道pexpect主要功能了，在交互场景下很有用，这里就讲解这么多了，目的是给大家提供一个自动交互实现思路。

小结：

通过对Python下paramiko、fabric和pexpect模块使用，它们各有自己擅长的一面。

paramiko：方便嵌套系统平台中，擅长远程执行命令，文件传输。

fabric：方便与shell脚本结合，擅长批量部署，任务管理。

pexpect：擅长自动交互，比如ssh、ftp、telnet。

\#!/usr/bin/env python   
\# -\*- coding: utf-8 -\*-   
       
import pexpect   
       
def ssh\_cmd(ip, passwd, cmd):   
    ret = -1   
    ssh = pexpect.spawn('ssh root@%s "%s"' % (ip, cmd))   
    try:   
       i = ssh.expect(\['password:', 'continue connecting (yes/no)?'\], timeout=5)   
       if i == 0 :   
          ssh.sendline(passwd)   
       elif i == 1:   
          ssh.sendline('yes\\n')   
          ssh.expect('password: ')   
          ssh.sendline(passwd)   
          ssh.sendline(cmd)   
          r = ssh.read()   
          print r   
          ret = 0   
    except pexpect.EOF:   
       print "EOF"   
       ssh.close()   
       ret = -1   
    except pexpect.TIMEOUT:   
       print "TIMEOUT"   
       ssh.close()   
       ret = -2   
    return ret   
  
  
  
  
  
  
  
  
\#-\*- coding: utf-8 -\*-    
\#!/usr/bin/python     
import paramiko    
import threading    
def ssh2(ip,username,passwd,cmd):    
    try:    
        ssh = paramiko.SSHClient()    
        ssh.set\_missing\_host\_key\_policy(paramiko.AutoAddPolicy())    
        ssh.connect(ip,22,username,passwd,timeout=5)    
        for m in cmd:    
            stdin, stdout, stderr = ssh.exec\_command(m)    
\#           stdin.write("Y")   \#简单交互，输入 ‘Y’     
            out = stdout.readlines()    
            \#屏幕输出    
            for o in out:    
                print o,    
        print '%s\\tOK\\n'%(ip)    
        ssh.close()    
    except :    
        print '%s\\tError\\n'%(ip)    
if \_\_name\_\_=='\_\_main\_\_':    
    cmd = \['cal','echo hello!'\]\#你要执行的命令列表    
    username = ""  \#用户名    
    passwd = ""    \#密码    
    threads = \[\]   \#多线程    
    print "Begin......"   
    for i in range(1,254):    
        ip = '192.168.1.'+str(i)    
        a=threading.Thread(target=ssh2,args=(ip,username,passwd,cmd))     
        a.start()