#!/usr/bin/env python
#-*- coding:utf-8 -*-
import os,sys,time,shutil,re
from _ast import Num
from django.db.models.sql.datastructures import Join
”’
—————————
此脚本用于之前学习内容的回顾
装饰器还需要多看，目前还是不是很清楚
类的继承
property需要学习
抽象方法/私有字段/私有方法/静态字段/静态方法
__call__方法
__del__方法
—————————
”’
#——————-递归例子———————
”’
#函数
def fun2(n):
result = n
for i in range(1,n):
result *= i
return result
print ‘fun2’,fun2(5)
#递归
def fun3(n):
if n == 1:
return 1
else:
return n*fun3(n-1)
print ‘fun3’,fun3(5)
def fun(n):
if n == 1:
return 1
else:
return n+fun(n-1)
print fun(5)
def fun1(x):
if x == 0 or x ==1:
return 1
else:
return fun1(x-1) + fun1(x-2)
print fun1(5)
如果说兔子在出生两个月后，就有繁殖能力，在拥有繁殖能力之后，这对兔子每个月能生出
一对小兔子来。假设所有兔子都不会死去，能够一直干下去，那么一年之后可以繁殖多少对
兔子呢？
def tuzi(x):
if x==1 or x==2:
return 1
else:
return tuzi(x-1)+tuzi(x-2)
print tuzi(5)
”’
#——————-递归 遍历目录下所有文件———————
”’
#———-列表推导式列出所有文件
path = ‘d:/python’
os.chdir(path)
a = [i for i in os.listdir(path) if os.path.isfile(i)]
for x in a:
print x
#等同下面
for i in os.listdir(‘d:/python’):
a = os.path.join(‘d:/python’,i)
print os.path.isfile(a)
if os.path.isfile(i):
print i
path = ‘d:/python’
os.chdir(path)
a = [i for i in os.listdir(path) if os.path.isfile(i) and os.path.splitext(i)[1] ==’.zip’]
print a
path = ‘d:/python’
#———-递归方式
#可采用os.path.join拼接路径的方式，来确认完整路径，避免使用路径切换，os.chdir
def scan(path):
for file in os.listdir(path):
file_dir = os.path.join(path,file)
if not os.path.isdir(file_dir):
print file_dir
else:
scan(file_dir)
scan(path)
#———-os.walk方式
g = os.walk(‘d:/python’)
for path,folder,filelist in g:
print filelist
for filename in filelist:
print os.path.join(path,filename)
”’
#——————文件夹整理———————–
”’
def file_summary(path):
for file in os.listdir(path):
file_dir = os.path.join(path,file)
if os.path.isdir(file_dir):
file_summary(file_dir)
else:
file_name = ”.join(re.findall(‘201\d{5}’,file))
Folder_name = os.path.join(path,file_name)
try:
if not os.path.exists(Folder_name):
os.mkdir(Folder_name)
wjy_num += 1
try:
if file_dir not in os.listdir(Folder_name):
print file_dir
shutil.move(file_dir,Folder_name)
except:
print ‘error’
file_num += 1
except:
print ‘没找到日期’
file_summary(path)
”’
# print ”’
# ——————————————————-
# 此脚本用于整理文件，按图片名日期进行分类，每个日期建
# 一个新的文件夹，将同一天的文件放入文件夹中
# ——————————————————-
# ”’
”’
def fodler_time_fengnei(path):
wjy_num = 0
file_num = 0
os.chdir(path)
for i in os.listdir(path):
#print i
Folder_file = ”.join(re.findall(‘201\d{5}’,i))
#print Folder_file
try:
#lock.acquire()
if not os.path.exists(Folder_file):
os.mkdir(Folder_file)
wjy_num += 1
try:
if i not in os.listdir(Folder_file):
shutil.move(i,Folder_file)
except:
print ‘error’
#lock.release()
file_num += 1
except:
print ‘没找到日期’
print ‘处理了%d个文件’%file_num
print ‘创建了%d个文件夹’%wjy_num
print ‘分类完成’
#print os.getcwd()
def folder_vedio(path):
os.chdir(path)
#os.walk 得到一个三元数组：路径，路径下的文件夹，文件
for i,k,v in os.walk(path):
print i,k,v
#迭代文件夹目录
for folder in k:
#进入每个文件夹
os.chdir(folder)
#迭代当前文件夹下的文件
for img in os.listdir(os.curdir):
print img
try:
ext = img.split(‘.’)[1] #得到扩展名
print ext
except:
print ‘error’
if ext != ‘jpg’: #如果不是图片文件
shutil.move(img, os.pardir) #移动到上一级目录
os.chdir(os.pardir)
#此函数用于将文件夹下的所有文件移动到指定的目录中，
#目前只有一层目录功能 2016/12/27更新
def file_move(path,dst):
os.chdir(path) #这里一定要先进入到需要整理的目录中
for i,k,v in os.walk(path):
print i,k
for folder in k:
try:
print os.getcwd()
os.chdir(folder)
for file in os.listdir(os.curdir):
shutil.move(file, dst)
except Exception,e:
print e
os.chdir(os.pardir)
#以下用于移动文件,已成功实现所需功能 2016/12/28
def file_move(path,dst):
os.chdir(path)
n = 1
#dst = ‘d:\\pooto\\p’
#这里用os.walk产生一个生成器，再通过迭代，列出目录下所有的子目录和文件
#os.walk以递归的方式遍历当前目录下的所有文件和目录
for path1,file_dir,fs in os.walk(path):
# print ‘PATH 第%d次:’%n,path1
# print ‘DIR:第%d次:’%n,file_dir
# print ‘FS第%d次:’%n,fs
#确认当前目录下是否有文件，没有跳过
if fs==[]:
pass
#print ‘空的’
else:
file_num = 0
try:
#如果有文件，迭代一下
for file in fs:
#进入目录
os.chdir(path1)
#print ‘当前路径是： ‘+os.getcwd()+’, 当前文件是： ‘+file
ext = file.split(‘.’)[-1] #取最后一个就是扩展名
#print ext
if ext == ‘jpg’ or ext ==’png’:
try:
shutil.move(file,dst) #移动到指定目录
#print ‘move was ok’
file_num += 1 #统计移动文件的个数
except Exception,e: #出错了，提示原因
#print e
print u’移动文件出错了，快查一下原因’
#shutil.move(file,del_dir)
except:
print u’迭代序列出错了’
print u’移动了%d个文件’% file_num
os.chdir(os.pardir) #当前目录完成了，跳回主目录，进行下一次迭代目录
n += 1
if __name__ == ‘__main__’:
————————————————-
请选择你需要的功能：
1. 对图片按名称分组
2. 对图片按后缀分组
3. 将文件移动到另一目录中
————————————————-
select1 = raw_input(‘:’)
start_time = time.time()
if select1 == ‘1’:
#lock = threading.Lock()
path = raw_input(u’如:g:/software/DIM :’).strip()
fodler_time_fengnei(path)
# t1 = threading.Thread(target=fodler_time_fengnei,args=(path,))
# t2 = threading.Thread(target=fodler_time_fengnei,args=(path,))
# t3 = threading.Thread(target=fodler_time_fengnei,args=(path,))
elif select1 ==’2′:
pass
elif select1 == ‘3’:
print u’源文件夹：’
path = raw_input(u’如:g:/software/DIM :’).strip()
dst = raw_input(u’目标文件夹：’).strip()
file_move(path, dst)
# 多线程没什么效果
# t1 = Thread(target=file_move,args=(path,dst))
# t2 = Thread(target=file_move,args=(path,dst))
# t3 = Thread(target=file_move,args=(path,dst))
# p1.start()
# print ‘t1’
# t2.start()
# print ‘t2’
# t3.start()
# print ‘t3’
end_time = time.time()
print u’总共花了%.2f秒’%(end_time-start_time)
# path = raw_input(‘[eg:g:/software/DIM] :’).strip()
# #os.chdir(path)
# file_num = 0
# wjy_num = 0
# # folder_vedio(path)
# fodler_time_fengnei(path)
# print ‘总共整理了%d个文件’%file_num
# print ‘总共创建了%d个文件夹’%wjy_num
”’
#——————局部变量———————–
”’
var = 1
def a():
global var
var += 1
var1 = 2
# print var
def b():
print var1
nolocal #这里2.7好像有问题，3.x好像是好的
var1 = 5
#print var1
b()
a()
”’
#————————Pexpect练习———————-
”’
用于登录Cisco设备并获取相关信息，每次一个命令，完成后自动退出
适用于Linux
”’
”’
def get(pe,cmd):
login = ‘telnet %s’ % pe
username = ‘pingtest’
password = ‘pwdtest’
tn = pexpect.spawn(login,timeout = 300)
index = tn.expect([“Username”,pexpect.EOF, pexpect.TIMEOUT])
if index == 0:
tn.expect(‘Username:’)
tn.sendline(username)
tn.expect(‘Password:’)
tn.sendline(password)
tn.expect(‘#’)
tn.sendline(cmd)
tn.sendline(‘ ‘)
tn.expect(‘#’)
result = tn.before
tn.sendline(‘exit’)
print result
elif index == 1:
print ‘pexpect.EOF’
else:
print ‘pexpect.TIMEOUT’
if __name__ == ‘__main__’:
tupe1 = {
‘Mon’:’星期一’,
‘Tue’:’星期二’,
‘Wen’:’星期三’,
‘Thu’:’星期四’,
‘Fri’:’星期五’,
‘Sat’:’星期六’,
‘Sun’:’星期天’
}
wenday = time.strftime(‘%a’)
xiqi = tupe1[wenday]
while True:
print ‘\n’
pe = (raw_input(‘请输入你需要登录的PE[退出请用q]:’)).strip()
print ‘\n’
if pe == ‘q’:
break
else:
cmd = (raw_input(‘请输入你需要执行的命令[退出请用q]:’)).strip()
if cmd == ‘q’:
break
print ‘\n\n’
print ‘当前查询时间：%s’%((time.strftime(‘%Y/%m/%d %H:%M:%S’))+’ ‘+ xiqi)
print ‘—————————————————–‘
print ‘\n’
get(pe,cmd)
”’
#————————装饰器实验1———————-
# def out(fun):
# def watter():
# print ‘之前出现’
# fun()
# print ‘之后出现’
# return watter
#
# @out
# def fun1():
# print ‘这是Fun1的内容’
#
# fun1()
# ———带参数的装饰器
# def out(fun):
# def watter(args):
# print ‘之前出现’
# fun(args)
# print ‘之后出现’
# return watter
#
# @out
# def fun1(args):
# print ‘这是Fun1的内容’,args
#
# fun1(100)
#———带返回的装饰器
# def out(fun):
# def watter(args):
# print ‘之前出现’
# a =fun(args)
# print ‘之后出现’
# print a
# return watter
#
# @out
# def fun1(args):
# return u’这是Fun1的内容’,args
#
# fun1(100)
#—–下面这个例子很好说明的装饰器的运行
# def timeslong(func):
# def call():
# start = time.clock()
# print(“It’s time starting ! “)
# func()
# print(“It’s time ending ! “)
# end = time.clock()
# return “It’s used : %s .” % (end – start)
# return call
#
# @timeslong
# def f():
# y = 0
# for i in range(10):
# y = y + i + 1
# print(y)
# return y
#
# print(f())
#————————property———————
# class A:
# def __init__(self):
# print ‘这是A的Self’
#
# def B(self):
# print ‘这是B的方法’
#
# @property
# def C(self):
# # print ‘这是C的方法’
# return ‘这是C的方法’
#
# a = A()
# print a
# print a.B()
# print a.C
#
#
# class C:
# def __init__(self):
# self._x = None
#
# @property
# def x(self):
# “””I’m the ‘x’ property.”””
# return self._x
#
# @x.setter
# def x(self, value):
# self._x = value
#
# @x.deleter
# def x(self):
# del self._x
#
#
# c1 = C()
# c1.x = 3
# print c1.x
#########################################################
#————————抽象方法———————
#抽象类抽象方法＝＝接口
from abc import ABCMeta,abstractmethod
# class Bar:
# __metaclass__ = ABCMeta
#
# @abstractmethod
# def get(self):
# raise ‘no define get ‘
#
# class Car(Bar):
# def __init__(self):
# print ‘这是一个Car的类’
#
# # def get(self):
# # print ‘aaa’
#
# car = Car()
# class Bar:
# __metaclass__ = ABCMeta
#
# @abstractmethod
# def Fun(self):
# pass
#
# class Foo(Bar):
# def __init__(self):
# print ‘__init__’
#
# # def Fun(self):
# # print ‘告警’
#
# f = Foo()
# f.Fun()
#########################################################
#————————私有字段/方法———————
# class Bar:
# def __init__(self):
# self.__x = 10
#
# def __get(self):
# print ‘这是私有方法’
# #可以通过动态方法调用私有方法
# def show(self):
# print self.__get()
#
# b = Bar()
# print b._Bar__x #强制使用类的方式来访问私有方法
# print b.show()
#————————静态字段/方法———————
# class Bar:
# name = ‘liyang’
# @staricmethod
# def hello():
# print ‘Hello’
#
# b = Bar()
# print b.name
# print b.hello()
# 静态字段和静态方法无需实例化，可通过用类来调用
#########################################################
#————————静态字段/方法———————
#__call__ 最后执行
#__del__ 什么时候使用,直接用对象加括号就可以调用了
# class Bar:
# def __init__(self):
# print ‘这是__init__’
#
# def __call__(self):
# print ‘这是__call__’
#
# def __del__(self):
# print ‘我就要被删除了’
#
# def show(self):
# print ‘这是一个显示的函数’
#
# b = Bar()
# print b
# print b() #调用call方法
# print b.show()
#########################################################
#————————类的继承———————
#新式类必须加object,同时多重继承是广度优先，经典类是深度优先
# class A(object):
# def __init__(self):
# print ‘这是A的__init__’
#
# def show(self):
# print ‘这是显示A的类’
#
# class B(A):
# def __init__(self):
# #A.__init__(self)
# super(B,self).__init__() #这里的super值为当前类，主类必须是新式类
# print ‘这是B的__init__’
#
# class C(A):
# def __init__(self):
# print ‘这是C的__init__’
#
# def show(self):
# print ‘这是显示C的类’
#
# class D(B,C):
# def __init__(self):
# print ‘这是D的__init__’
#
#
# # b1 = B()
# # print b1
#
# d1 = D()
# print d1
# print d1.show()
#——————–使用super也可以在经黄类中避免深度优先的问题——————
# class A():
# def __init__(self):
# print ‘这是A的__init__’
#
# def show(self):
# print ‘这是显示A的类’
#
# class B(A):
# def __init__(self):
# #A.__init__(self)
# super().__init__() #这里的super，可以避免深度优先的问题
# print ‘这是B的__init__’
#
# class C(A):
# def __init__(self):
# print ‘这是C的__init__’
#
# def show(self):
# print ‘这是显示C的类’
#
# class D(B,C):
# def __init__(self):
# print ‘这是D的__init__’
#
# b1 = B()
# print b1
# d1 = D()
# print d1
# print d1.show()
#########################################################
”’
——————————
字符编码：ASCII/Unicode/UTF-8
decode的作用是将其他编码的字符串转换成unicode编码，
encode的作用是将unicode编码转换成其他编码的字符串，
Unicode
Unicode—–encode—->UTF
——————————
”’
#————————编码学习———————
# name = ‘李明’
# print ‘第一次’,name
# if not isinstance(name,unicode):
# name = name.decode(‘utf-8’)
# print name
#
#########################################################
# import datetime
# #显示当前日期
# print datetime.date.today()
# print datetime.date.today() – datetime.timedelta(days = 2)
# #显示指定日期
# print datetime.date(2015, 4, 2)
#
# print datetime.time(1,2,3)
#————————生成器———————
# def a():
# for i in range(10):
# yield i
#
# a1 = a()
# print a1.next()
# print a1.next()
#########################################################
#——————–Excel Into Mysql——————–
# import pymysql
# import xlrd
#
# def xls_info():
# xls = xlrd.open_workbook(‘d:/bb.xls’) #打开Excel
# sheets = xls.sheet_names() #获取表
# table = xls.sheet_by_name(sheets[2]) #得到需要的表名
# rows = table.nrows #获取表的总行数
# return table,rows #返回表名和行数
#
# def mysql_info():
# myconn = pymysql.Connect(‘127.0.0.1′,’root’,”,’django’) #连接Mysql
# mycur = myconn.cursor() #创建游标
# mycur.execute(‘set names utf8’) #指定为utf8编码
# #创建表格
# # table_create = ‘CREATE TABLE mysql_test(name varchar(20),ip varchar(20));’
# # mycur.execute(table_create)
# mycur.execute(‘desc mysql_test’)
# #插入表格的命令
# insert_sql = ‘insert into mysql_test values(%s,%s);’
#
# #调用上个函数的值，得到表名和行数
# table,rows=xls_info()[0],xls_info()[1]
# for i in range(0,rows): #迭代每行
# xls_line = table.row_values(i) #得到每行的信息
# print xls_line
# print mycur.execute(insert_sql,xls_line) #插入每行的数据到数据库中
# mycur.execute(‘select * from mysql_test’)
# print mycur.fetchall()
# myconn.commit() #事务提交
# mycur.close()
# myconn.close()
#
# mysql_info()
#————-Mysql得到字典————————
#!/usr/bin/env python
# encoding: utf-8
#Created on 2017年1月13日
#@author: Administrator
”’
import pymysql
def main():
try:
conn = pymysql.connect(host = ‘127.0.0.1’, user = ‘root’, passwd = ”, db = ‘django’)
cur = conn.cursor(cursor=pymysql.cursors.DictCursor)
cur.execute(“select * from mysql_test”)
qur_result = cur.fetchall()
cur.close()
conn.close()
# for record in qur_result:
# user = record[0]
# passwd = record[1]
except pymysql.Error,e:
print ‘Mysql Error Msg:’,e
#print type(qur_result)
for k in qur_result:
#print k
for i,j in k.items():
print j
if __name__ == ‘__main__’:
main()
”’
#——————-线程练习————————
import threading
from IPython.utils.io import stdin, stderr
from sys import stdout
import paramiko
”’
def Foo(args):
for i in range(10):
print i
time.sleep(1)
print ‘开始’
t1 = Thread(target=Foo,args = (1,))
#t1.setDaemon(True)
t1.start()
print t1.getName()
”’
#——————-自定义线程练习————————
”’
class MyThread(Thread):
def run(self):
Thread.run(self)
print ‘run’
for i in range(10):
print i
time.sleep(1)
def Foo(args):
print ‘这是我的新函数’
t1 = MyThread(target=Foo,args =(1,))
t1.start()
print t1.getName()
print t1.isDaemon()
print t1.join(3)
”’
#——————-生产消费模型————————
”’
#两个类都是一样的，要用到队列，有两个判断条件，是否为空，是否为满
import Queue
class ShenChang(Thread):
def __init__(self,name,que):
self.__Name = name
self.__Que = que
Thread.__init__(self)
def run(self):
while True:
if self.__Que.full():
print ‘做完了，可以休息一下了’
time.sleep(1)
else:
self.__Que.put(‘xxx’)
print self.__Name,’生产包子’
Thread.run(self)
que = Queue.Queue(maxsize=30)
for x in range(10):
name = ‘alan%d’%x
s1 = ShenChang(name,que)
s1.start()
class XiaFei(Thread):
def __init__(self,name,que):
self.__Name = name
self.__Que = que
Thread.__init__(self)
def run(self):
while True:
if self.__Que.empty():
print ‘没有吃的了，先休息一下吧’
time.sleep(2)
else:
self.__Que.get()
print self.__Name,’吃了一个包子’
Thread.run(self)
for i in range(3):
name = ‘name%d’%i
t1 = XiaFei(name,que)
t1.start()
”’
#——————-paramiko用户名和密码————————
”’
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(‘114.28.37.23’, 50022, ‘root’, ‘263!@#$%^&*()’)
print ‘connected…………..’
while True:
cmd = raw_input(‘请输入你要执行的命令[退出q] : ‘)
if cmd == ‘q’:
print ‘\nbye———\n————‘
sys.exit()
stdin,stdout,stderr = ssh.exec_command(cmd)
print stdout.read()
ssh.close()
”’
#——————-paramiko Key———————–
”’
#在执行前要手工在目标机器上输入以下命令：
# ssh-keygen -t rsa 创建密钥
# ssh-copy-id root@114.28.37.209 将公钥Copy到服务器
private_key_path = ‘/root/.ssh/id_rsa’
key = paramiko.RSAKey.from_private_key_file(private_key_path)
paramiko.util.log_to_file(‘paramiko.log’) #加入日志
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(‘127.0.0.1′, 22, username=’root’, pkey=key)
stdin,stdout,stderr = ssh.exec_command(‘ls’)
print stdout.read()
ssh.close()
”’
#——————-paramiko 创建删除显示 ssh router———————–
”’
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#IP,Port,Username,Password=’114.141.185.5′,22, ‘opsinfo’, ‘pwdops’
IP,Port,Username,Password=’114.141.185.5′,22, ‘opsinfo’, ‘pwdops’
try:
ssh.connect(IP,Port,Username,Password, look_for_keys=False, allow_agent=False)
except Exception,e:
print e
print ‘ssh connection established to %s’ % IP
remote_conn = ssh.invoke_shell()
#print remote_conn.recv(1000)
remote_conn.send(‘\n’)
remote_conn.send(‘sh ip int bri\n’)
time.sleep(2)
print remote_conn.recv(10000)
#stdin,stdout,stderr = ssh.exec_command(‘sh ver’)
# ssh.connect(‘1172.16.4.1’, 23, ‘opsinfo’, ‘pwdops’)
# stdin,stdout,stderr = ssh.exec_command(‘sh ver’)
#print stdout.read()
ssh.close()
”’
#————-socket登录路由器测试—————–
”’
import socket
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port =(‘172.16.4.1’,23)
sock.connect(ip_port)
sock.send(‘opsinfo\n’)
time.sleep(1)
sock.send(‘pwdops\n’)
time.sleep(1)
sock.send(‘sh ver’)
time.sleep(1)
data1 = sock.recv(1024)
time.sleep(1)
print data1
”’
#——————-paramiko上传下载———————–
”’
print os.getcwd()
os.chdir(‘d:/’)
print os.getcwd()
t = paramiko.Transport((‘114.28.37.23’, 50022))
t.connect(username=’root’, password=’263!@#$%^&*()’)
sftp = paramiko.SFTPClient.from_transport(t)
local_path = ‘d:/lsdksmq-v2.0.0.200.zip’
base_name = os.path.basename(local_path)
remote_path = ‘/home/’+base_name
sftp.put(local_path,remote_path) #上传
#sftp.get(remote_path,local_path) #下载
t.close()
”’
”’
t = paramiko.Transport((‘114.28.13.143’, 22))
t.connect(username=’root’, password=’111111′)
sftp = paramiko.SFTPClient.from_transport(t)
print sftp.listdir(‘/smb’)
print sftp.rename(‘/smb/Flow.rrd.bak’,’/smb/Flow.rrd.bak1′)
print sftp.mkdir(‘/home/aa1’,0755)
print sftp.listdir(‘/home’)
”’
#——————-paramiko+threading———————–
”’
用函数将Paramiko的代码包起来，再通过我线程来同时操作
def SshCmd(server,username,password,cmd):
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(server,50022,username, password)
stdin,stdout,stderr = ssh.exec_command(cmd)
print server, ‘\n %s’% cmd,
print stdout.read()
ssh.close()
if __name__ ==’__main__’:
username = ‘root’
password = ‘263!@#$%^&*()’
cmds = [‘ls -lh /’]
ips = [‘114.28.37.23′,’114.28.37.24’]
for ip in ips:
for cmd in cmds:
temp = Thread(target=SshCmd,args=(ip,username,password,cmd))
temp.start()
”’
#——————-threading 异步模型———————–
”’
import threading
def shengchang():
print u’P:做包子………………’
event.wait()
event.clear()
print u’P:做包子’
time.sleep(3)
print u’P:你的包子做好了’
event.set()
def xiaofei():
print u’C:买包子去………………’
event.set()
time.sleep(2)
print u’C:等做包子……………… ‘
#print event.wait()
while True:
if event.isSet():
print u’C:太好了’
break
else:
print ‘做其他事情去了……’
time.sleep(0.08)
event = threading.Event()
p = threading.Thread(target=shengchang)
c = threading.Thread(target=xiaofei)
p.start()
c.start()
”’
#——————-IP换算———————-
”’
def ch1(num):
s = []
for i in range(4):
s.append(str(num%256))
print s
num /= 256
return ‘.’.join(s[::-1])
print ch1(123456789)
#用lambda的方式，整数toIP 地址 一行代码搞定
ch2 = lambda x: ‘.’.join([str(x/(256**i)%256) for i in range(3,-1,-1)])
print ch2(123456789)
#用lambda的方式，IP地址转换到整数
ch3 = lambda x:sum([256**j*int(i) for j,i in enumerate(x.split(‘.’)[::-1])])
print ch3(‘7.91.205.21’)
”’
#——————-IP敬意计算———————-
import os
”’
def getip(ip, count):
count = int(count)
ip2 = int(ip.split(‘.’)[-2])
ip1 = int(ip.split(‘.’)[-1])
ip_before = ‘%s.%s’ % (ip.split(‘.’)[0], ip.split(‘.’)[1])
for i in range(0,count,4):
new_ip1 = ip1 + i
if 11 <= new_ip1 <= 254:
print ‘%s.%s.%s’ % (ip_before, str(ip2), str(new_ip1))
else:
new_ip2 = ip2 + int(new_ip1/254)
new_ip1 = new_ip1%254 + 0
print ‘%s.%s.%s’ % (ip_before, str(new_ip2), str(new_ip1))
if __name__ == ‘__main__’:
getip(‘10.0.1.0’, 1000)
”’
”’
def getip(ip, count,step):
count = int(count)
ip1 = int(ip.split(‘.’)[-1])
ip2 = int(ip.split(‘.’)[-2])
ip3 = int(ip.split(‘.’)[-3])
ip4 = int(ip.split(‘.’)[-4])
ip_before = ‘%s.%s’ % (ip.split(‘.’)[0], ip.split(‘.’)[1])
for i in range(0,count,step):
new_ip1 = ip1 + i
#print ‘%s.%s.%s’ % (ip_before, str(ip2), str(new_ip1))
if new_ip1 <= 255:
pass
print ‘%s.%s.%s’ % (ip_before, str(ip2), str(new_ip1))
else :
new_ip2 = ip2 + int(new_ip1/256)
if new_ip2 <= 255:
new_ip1 = new_ip1%256
print ‘%s.%s.%s’ % (ip_before, str(new_ip2), str(new_ip1))
else:
new_ip3 = ip3 + int(new_ip2/256)
new_ip2 = ip1 + int(new_ip1/256)
new_ip1 = new_ip1%256
#print ‘ip1————:’,new_ip1
new_ip2 = 0
if new_ip1 >= (256/step-1)*step:
new_ip2 += 1
new_ip1 = new_ip1%256
#print ‘ip2—–:’,new_ip2
print ‘%s.%s.%s.%s’ % (str(ip4),str(new_ip3), str(new_ip2), str(new_ip1))
if __name__ == ‘__main__’:
getip(‘10.0.255.192’,830,32)
”’
#———————pexpect 交互连接————————
”’
#!/usr/bin/env python
#coding=utf-8
import pexpect
import time,re
import pymysql
loginprompt = ‘#’
def get(login_ip):
login = ‘telnet %s’ % login_ip
tn = pexpect.spawn(login,timeout = 300)
#tn.expect(‘Username:’)
flag = tn.expect([“login”,”Username:”, “(?i)Unknown host”, pexpect.EOF, pexpect.TIMEOUT])
username = ‘opsinfo’
password = ‘pwdops’
if flag == 0 or flag == 1:
tn.sendline(username)
tn.expect(‘Password:’)
tn.sendline(password)
tn.expect(r'[#>]’)
print tn.before
#交互开始
tn.interact()
print ‘Left interactv mode’
else:
print ‘error’
if __name__ == ‘__main__’:
login_ip = raw_input(‘IP: ‘)
get(login_ip)
”’
#———————ping 主机————————
”’
#!/usr/bin/env python
import multiprocessing
import subprocess
import time
start_time = time.time()
host_list = [‘192.168.100.254′,’1.1.1.1′,’192.168.100.253′,’114.28.127.2′,’114.28.127.72′,’114.28.127.70′,’114.28.127.12′,’114.28.127.56′,’114.28.127.102’]
if len(host_list) > 30:
process_number = 30
else:
process_number = len(host_list)
def ping_host(ipaddr):
if subprocess.call(‘ping -c5 -W 1 %s > /dev/null’ % ipaddr, shell=True) == 0:
#if subprocess.call(‘ping -c1 -W 1 %s ‘ % ipaddr, shell=True) == 0:
print ‘%s is OK’ % ipaddr
else:
print ‘%s is DOWN’ % ipaddr
pool = multiprocessing.Pool(processes=10)
for ip in host_list:
pool.apply_async(ping_host,(ip,))
#pool.map(ping_host,host_list)
pool.close()
pool.join()
end_time = time.time()
print ‘It is take %.2f seconds’%(start_time-end_time)
”’
#———————从文件中找出IP地址————————
”’
import re
f = file(‘d:\ip.txt’,’rb’)
set1 = set()
for line in f.xreadlines():
try:
ip = ”.join(re.findall(‘(?:\d+\.){3}\d{1,3}’, line))
#print ip
set1.add(ip)
except:
pass
f.close()
set1 = sorted(set1)
#print set1
for i in set1:
print i
”’
#———————用Pexpect登录设备并测试Ping———————–
”’
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import pexpect
import re
import time
问题：
1.迭代查询和Ping包，第二次总是看不到查询的结果，导致搜索错误，在Python中直接测试正常
2.另一个问题：通过expect如果PIng不到，是否有返回结果，好像看不到
f = file(‘/smb/python_s8/day8/ip.txt’,’rb’)
username = ‘pingtest’
password = ‘pwdtest’
tn = pexpect.spawn(‘telnet 219-mr01’)
#index = tn.expect([“Username:”,pexpect.EOF, pexpect.TIMEOUT])
try:
#if index == 0:
tn.expect(‘Username:’)
tn.sendline(username)
tn.expect(‘Password:’)
tn.sendline(password)
print ‘auth is ok’
x= 1
for line in f.xreadlines():
#print line
tn.expect(‘#’)
#print ‘is this running?’
tn.sendline(‘sh ip vrf interface | inc %s’ % line)
tn.expect(‘#’)
result = tn.before
tn.expect(‘#’)
# print len(result)
print ‘——————-this is %d result:—————\n%s\n’%(x,result)
ip = ”.join(re.findall(‘(?:\d+\.){3}\d{1,3}’, result))
vrf = ”.join(re.findall(‘(\w{3,5}\d{3,6}\w+)’,result))
print ‘ip: %s , vrf: %s’ %(ip,vrf)
#这里更改目标IP地址
ip1= ip.split(‘.’) #分割IP
if ip1[0] == ‘114’:
ip1[3] =str(int(ip.split(‘.’)[-1])+1) #替换最后一个IP数字
else:
ip1[3] =str(int(ip.split(‘.’)[-1])-1) #替换最后一个IP数字
targetIP =’.’.join(ip1)
#组合命令
cmd = ‘ping vrf %s %s re 2’%(vrf,targetIP)
print cmd
try:
tn.sendline(cmd)
except:
print ‘error’
time.sleep(10)
tn.expect(‘#’)
#tn.expect(‘#’)
result1 = tn.before
print result1
#tn.sendline(‘\r\r\r’)
x += 1
tn.sendline(‘exit’)
# elif index == 1:
# print ‘pexpect.EOF’
# else:
# print ‘pexpect.TIMEOUT’
except Exception,e:
print e
”’
#———————Jump跳板机———————-
#!/usr/bin/python
# # coding:utf-8
# import sys
# import time
# import re
# import pexpect
# import os
# import struct
# import fcntl
# import termios
# import signal
# import MySQLdb
#
#
# def sigwinch_passthrough (sig, data):
# winsize = getwinsize()
# global child
# child.setwinsize(winsize[0],winsize[1])
#
# def getwinsize():
# if ‘TIOCGWINSZ’ in dir(termios):
# TIOCGWINSZ = termios.TIOCGWINSZ
# else:
# TIOCGWINSZ = 1074295912L # Assume
# s = struct.pack(‘HHHH’, 0, 0, 0, 0)
# x = fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ, s)
# return struct.unpack(‘HHHH’, x)[0:2]
#
# def getServersList():
# sqlStr = ”’ select * from sys_info ”’
# cursor.execute(sqlStr)
# rows = cursor.fetchall()
# strList = ”
# for index, row in enumerate(rows):
# strList += ‘Hostname:%s , IP:\033[1;34;40m%s\033[0m \n’ % (row[0],row[1])
# return strList
#
# def sshLogin(choice):
# reip = re.compile(r'(?
# if len ( reip.findall(choice) ) == 0:
# print ‘\033[1;31;40mIP Error you entered.Please Enter again.\033[0m’
# return
# host = reip.findall(choice)[0]
# sqlStr = ”’ select count(*) from sys_info where ip=’%s’ ”’ % host
# cursor.execute(sqlStr)
# rows = cursor.fetchall()
# if rows[0][0] == 0:
# print ‘\033[1;31;40mThe IP you entered is not in the list.\033[0m’
# return
# sqlStr = ”’ select * from sys_info where ip=’%s’ ”’ % host
# cursor.execute(sqlStr)
# rows = cursor.fetchall()
# username =rows[0][2]
# passwd =rows[0][3]
# print ‘ssh ‘ + username + ‘@’ + host + ‘ …’
# global child
# child = pexpect.spawn(‘ssh %s@%s’ % (username,host))
# #child = pxssh.pxssh()
# child.logfile = fout
# #child.logfile = sys.stdout
# #child.logfile_send = sys.stdout
# signal.signal(signal.SIGWINCH, sigwinch_passthrough)
#
# winsize = getwinsize();
# child.setwinsize(winsize[0], winsize[1])
# flag = child.expect([‘continue’, ‘password’, pexpect.EOF, pexpect.TIMEOUT])
# #child.login (host, username, passwd, original_prompt='[$#>]’)
# #child.prompt()
# #print flag
# if flag == 0:
# child.sendline(‘yes’)
# child.expect(‘.*password:.*’)
# child.sendline(passwd)
# elif flag == 1:
# child.sendline(passwd)
# child.interact()
# pass
#
# if __name__ == ‘__main__’:
# DBHOST=’127.0.0.1′
# DBNAME=’jump’
# DBUSER = ‘root’
# DBPWD = ‘db03dUNG’
# FILENAME = ‘/data/build/command_jump.log’
# WELCOME = ”’\033[1;34;40m### Welcome use JumpServer to Login. ### \033[0m ”’
# CHOICE = “””1. Type \033[1;34;40mIP ADDRESS\033[0m To Login.
# 2. Type \033[1;34;40mP/p\033[0m To Print The Servers You Available.
# 3. Type \033[1;34;40mQ/q\033[0m To Quit.
# \033[1;34;40mOpt or IP>:\033[0m “””
# try:
# conn = MySQLdb.connect(host=’%s’ % DBHOST ,user=’%s’ % DBUSER , passwd=’%s’ % DBPWD , db=’%s’ % DBNAME , charset=’utf8′)
# except Exception, e:
# print e
# sys.exit()
# cursor = conn.cursor()
# fout = open (FILENAME , “ab”)
# print WELCOME
# while True:
# choice = raw_input( CHOICE )
# if cmp(choice,”P”) == 0 or cmp(choice,”p”) == 0 :
# print getServersList()
# elif cmp(choice,”Q”) == 0 or cmp(choice,”q”) == 0:
# print ‘Exit.’
# break
# else:
# sshLogin(choice)
#
# cursor.close()
# conn.close()
# fout.close()
#
# [root@jump1 build]#