python网络设备脚本

A. 我想用python脚本telnet电脑Ensp里的交换机，但是没效果，也没报错，是有什么问题吗求解答

1、在备份配置之前进行ping操作，所有IP地址放在HW_IP_List.txt中，ping通的地址放到HW_IP_True.txt中，ping不通的地址放到HW_IP_False.txt中。
脚本文件icmp_reply.py
#!/usr/bin/python
# -*- coding:gb2312 -*-
#import tab
import time,os
start_time = int (time.time())
def hw_ping_test():
ips = open('HW_IP_List.txt','r')
ip_True = open('HW_IP_True.txt','w')
ip_False = open('HW_IP_False.txt','w')
count_True,count_False=0,0
for ip in ips.readlines():
ip = ip.replace('\n','')
return1= os.system('ping -n 1 -w 1 %s'%ip)
if return1 :
print 'ping %s is fail'%ip
ip_False.write(ip+'\n')
count_False += 1
else:
print 'ping %s is ok'%ip
ip_True.write(ip+'\n')
count_True += 1
ip_True.close()
ip_False.close()
ips.close()
end_Time = int(time.time())
print "time(sencond):",end_Time - start_time,"s"
print "ping OK IP:",count_True," ping False IP:",count_False
hw_ping_test()
2、编辑核心脚本，调用icmp_reply.py，程序执行时会先自动运行icmp_reply.py,调用生成的HW_IP_True.txt文件，先要选择设备类型，然后选择执行的动作，输入TFTP服务器地址，程序就开始执行选择的相应的动作。

B. 用python写一个重启路由器的脚本，怎么做

执行python脚本只需要对python文件做如下操作即可：
在python文件里第一行加上#! /usr/bin/python，即你的python解释器所在的目录。另外还有一种写法是#! /usr/bin/env python
编辑完成python脚本文件后为它加上可执行权限。
例如你的python脚本文件叫做runit.py，那么就在shell中输入如下命令：chmod +x runit.py
之后直接在shell中输入./runit.py就可以执行你的python程序了。
当然这是在linux下的操作，如果想在windows下直接执行Python程序，就需要使用py2exe工具将python源程序编译成exe文件了。

C. 如果要使用python写网络设备的脚本，那么学习python要从哪里学起

如果没有一点语言基础，学什么都很吃力。从网络工程师转行的话建议你先精通linux。

D. 如何使用python执行远程shell脚本

可以使用Python的Fabric包来完成这项任务。
既然是谈到Shell脚本，系统应该是Linux/Unix的，远程访问，应该是ssh吧。

Fabric功能是将一个任务通过ssh在多台服务器上执行，而每个任务可以是单条shell指令或是一段python脚本。
Fabric是将Python, Shell和SSH的功能很优雅地结合在了一起，同时自身又非常的轻量，适合大部分服务器群的日常管理工作。

E. 如何在ubuntu终端运行python脚本

在ubuntu终端运行python脚本的方法：1、打开终端，查看当前存在的虚拟环境；2、激活需要使用的虚拟环境；3、进入到python脚本所在的目录下；4、执行【python 脚本名】命令即可运行脚本。
具体方法：
（推荐教程：Python入门教程）
1、打开终端，输入'conda env list'命令查看当前存在的虚拟环境（如果没有合适的环境，则需要新建）；
2、使用'conda activate pytorch1.0'命令激活将要使用的虚拟环境；
3、使用'cd'命令进入存放demo.py文件的目录下；
4、使用'python'命令运行demo.py文件，同时给部分参数赋值；
参数：
--net vgg16：backbone网络选择vgg16
--cuda：启用gpu
--load_dir models：在models文件夹下加载所需的文件

F. python 运维常用脚本

Python 批量遍历目录文件,并修改访问时间

import os

path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp=[];

for file in dirs:
temp.append(os.path.join(path, file))
for x in temp:
os.utime(x, (1577808000, 1577808000))
Python 实现的自动化服务器管理

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):

def ssh_put(user,passwd,source,target):

while True:
try:
shell=str(input("[Shell] # "))
if (shell == ""):
continue
elif (shell == "exit"):
exit()
elif (shell == "put"):
ssh_put("root","123123","./a.py","/root/a.py")
elif (shell =="cron"):
temp=input("输入一个计划任务: ")
temp1="(crontab -l; echo "+ temp + ") |crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
elif (shell == "uncron"):
temp=input("输入要删除的计划任务: ")
temp1="crontab -l | grep -v " "+ temp + "|crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
else:
ssh_cmd("lyshark","123123","22","./user_ip.conf",shell)

遍历目录和文件

import os

def list_all_files(rootdir):
import os
_files = []
list = os.listdir(rootdir) #列出文件夹下所有的目录与文件
for i in range(0,len(list)):
path = os.path.join(rootdir,list[i])
if os.path.isdir(path):
_files.extend(list_all_files(path))
if os.path.isfile(path):
_files.append(path)
return _files

a=list_all_files("C:/Users/LyShark/Desktop/a")
print(a)
python检测指定端口状态

import socket

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(1)

for ip in range(0,254):
try:
sk.connect(("192.168.1."+str(ip),443))
print("192.168.1.%d server open "%ip)
except Exception:
print("192.168.1.%d server not open"%ip)

sk.close()

python实现批量执行CMD命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

print("------------------------------> ")
print("使用说明,在当前目录创建ip.txt写入ip地址")
print("------------------------------> ")

user=input("输入用户名:")
passwd=input("输入密码:")
port=input("输入端口:")
cmd=input("输入执行的命令:")

file = open("./ip.txt", "r")
line = file.readlines()

for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip(' '))

python3-实现钉钉报警

import requests
import sys
import json

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

data = {"msgtype": "markdown","markdown": {"title": "监控","text": "apche异常"}}

headers = {'Content-Type':'application/json;charset=UTF-8'}

send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

import psutil
import requests
import time
import os
import json

monitor_name = set(['httpd','cobblerd']) # 用户指定监控的服务进程名称

proc_dict = {}
proc_name = set() # 系统检测的进程名称
monitor_map = {
'httpd': 'systemctl restart httpd',
'cobblerd': 'systemctl restart cobblerd' # 系统在进程down掉后，自动重启
}

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

while True:
for proc in psutil.process_iter(attrs=['pid','name']):
proc_dict[proc.info['pid']] = proc.info['name']
proc_name.add(proc.info['name'])

判断指定端口是否开放

import socket

port_number = [135,443,80]

for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
print("Port %d is not open" % index)
sock.close()

判断指定端口并且实现钉钉轮询报警

import requests
import sys
import json
import socket
import time

def dingding(title,text):
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

def net_scan():
port_number = [80,135,443]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
return index
sock.close()

while True:
dingding("Warning",net_scan())
time.sleep(60)

python-实现SSH批量CMD执行命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):
file = open(userfile, "r")
line = file.readlines()
for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip(' '))
ssh.connect(hostname=line[i].strip(' '),port=port,username=user,password=passwd)
cmd=cmd
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()

ssh_cmd("lyshark","123","22","./ip.txt","free -h |grep 'Mem:' |awk '{print $3}'")

用python写一个列举当前目录以及所有子目录下的文件，并打印出绝对路径

import sys
import os

for root,dirs,files in os.walk("C://"):
for name in files:
print(os.path.join(root,name))
os.walk()

按照这样的日期格式（xxxx-xx-xx）每日生成一个文件，例如今天生成的文件为2013-09-23.log， 并且把磁盘的使用情况写到到这个文件中。

import os
import sys
import time

new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()

str1 = ''.join(disk_status)
f = open(new_time+'.log','w')
f.write("%s"%str1)

f.flush()
f.close()

统计出每个IP的访问量有多少？（从日志文件中查找）

import sys

list = []

f = open("/var/log/httpd/access_log","r")
str1 = f.readlines()
f.close()

for i in str1:
ip=i.split()[0]
list.append(ip)

list_num=set(list)

for j in list_num:
num=list.count(j)
print("%s -----> %s" %(num,j))

写个程序，接受用户输入数字，并进行校验，非数字给出错误提示，然后重新等待用户输入。

import tab
import sys

while True:
try:
num=int(input("输入数字：").strip())
for x in range(2,num+1):
for y in range(2,x):
if x % y == 0:
break
else:
print(x)
except ValueError:
print("您输入的不是数字")
except KeyboardInterrupt:
sys.exit(" ")

ps 可以查看进程的内存占用大小，写一个脚本计算一下所有进程所占用内存大小的和。

import sys
import os

list=[]
sum=0

str1=os.popen("ps aux","r").readlines()

for i in str1:
str2=i.split()
new_rss=str2[5]
list.append(new_rss)
for i in list[1:-1]:
num=int(i)
sum=sum+num

print("%s ---> %s"%(list[0],sum))

关于Python 命令行参数argv

import sys

if len(sys.argv) < 2:
print ("没有输入任何参数")
sys.exit()

if sys.argv[1].startswith("-"):
option = sys.argv[1][1:]

利用random生成6位数字加字母随机验证码

import sys
import random

rand=[]

for x in range(6):
y=random.randrange(0,5)
if y == 2 or y == 4:
num=random.randrange(0,9)
rand.append(str(num))
else:
temp=random.randrange(65,91)
c=chr(temp)
rand.append(c)
result="".join(rand)
print(result)

自动化-使用pexpect非交互登陆系统

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.txt', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密码")
ssh.expect('#')

ssh.sendline('ls /home')
ssh.expect('#')

Python-取系统时间

import sys
import time

time_str = time.strftime("日期：%Y-%m-%d",time.localtime())
print(time_str)

time_str= time.strftime("时间：%H:%M",time.localtime())
print(time_str)

psutil-获取内存使用情况

import sys
import os
import psutil

memory_convent = 1024 * 1024
mem =psutil.virtual_memory()

print("内存容量为:"+str(mem.total/(memory_convent))+"MB ")
print("已使用内存:"+str(mem.used/(memory_convent))+"MB ")
print("可用内存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MB ")
print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MB ")
print("cache容量:"+str(mem.cached/(memory_convent))+"MB ")

Python-通过SNMP协议监控CPU
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split(' ')[:-1]
return sn1

def getDate(host):
items = getAllitems(host, '.1.3.6.1.4.1.2021.11')

if name == ' main ':

Python-通过SNMP协议监控系统负载
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os
import sys

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')
return sn1

def getload(host,loid):
load_oids = Ƈ.3.6.1.4.1.2021.10.1.3.' + str(loid)
return getAllitems(host,load_oids)[0].split(':')[3]

if name == ' main ':

Python-通过SNMP协议监控内存
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os

def getAllitems(host, oid):

def getSwapTotal(host):

def getSwapUsed(host):

def getMemTotal(host):

def getMemUsed(host):

if name == ' main ':

Python-通过SNMP协议监控磁盘
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):

def getDate(source,newitem):

def getRealDate(item1,item2,listname):

def caculateDiskUsedRate(host):

if name == ' main ':

Python-通过SNMP协议监控网卡流量
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')[:-1]
return sn1

def getDevices(host):
device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')
device_list = []

def getDate(host,oid):
date_mib = getAllitems(host,oid)[1:]
date = []

if name == ' main ':

Python-实现多级菜单

import os
import sys

ps="[None]->"
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
flage=1

while True:
ps="[None]->"
temp=input(ps)
if (temp=="test"):
print("test page !!!!")
elif(temp=="user"):
while (flage == 1):
ps="[User]->"
temp1=input(ps)
if(temp1 =="exit"):
flage=0
break
elif(temp1=="show"):
for i in range(len(ip)):
print(i)

Python实现一个没用的东西

import sys

ps="[root@localhost]# "
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]

while True:
temp=input(ps)
temp1=temp.split()

检查各个进程读写的磁盘IO

import sys
import os
import time
import signal
import re

class DiskIO:
def init (self, pname=None, pid=None, reads=0, writes=0):
self.pname = pname
self.pid = pid
self.reads = 0
self.writes = 0

def main():
argc = len(sys.argv)
if argc != 1:
print ("usage: please run this script like [./lyshark.py]")
sys.exit(0)
if os.getuid() != 0:
print ("Error: This script must be run as root")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
os.system('echo 1 > /proc/sys/vm/block_mp')
print ("TASK PID READ WRITE")
while True:
os.system('dmesg -c > /tmp/diskio.log')
l = []
f = open('/tmp/diskio.log', 'r')
line = f.readline()
while line:
m = re.match(
'^(S+)(d+)(d+): (READ|WRITE) block (d+) on (S+)', line)
if m != None:
if not l:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
continue
found = False
for item in l:
if item.pid == m.group(2):
found = True
if m.group(3) == "READ":
item.reads = item.reads + 1
elif m.group(3) == "WRITE":
item.writes = item.writes + 1
if not found:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
time.sleep(1)
for item in l:
print ("%-10s %10s %10d %10d" %
(item.pname, item.pid, item.reads, item.writes))
def signal_handler(signal, frame):
os.system('echo 0 > /proc/sys/vm/block_mp')
sys.exit(0)

if name ==" main ":
main()

利用Pexpect实现自动非交互登陆linux

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.log', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密码")

ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')

利用psutil模块获取系统的各种统计信息

import sys
import psutil
import time
import os

time_str = time.strftime( "%Y-%m-%d", time.localtime( ) )
file_name = "./" + time_str + ".log"

if os.path.exists ( file_name ) == False :
os.mknod( file_name )
handle = open ( file_name , "w" )
else :
handle = open ( file_name , "a" )

if len( sys.argv ) == 1 :
print_type = 1
else :
print_type = 2

def isset ( list_arr , name ) :
if name in list_arr :
return True
else :
return False

print_str = "";

if ( print_type == 1 ) or isset( sys.argv,"mem" ) :
memory_convent = 1024 * 1024
mem = psutil.virtual_memory()
print_str += " 内存状态如下: "
print_str = print_str + " 系统的内存容量为: "+str( mem.total/( memory_convent ) ) + " MB "
print_str = print_str + " 系统的内存以使用容量为: "+str( mem.used/( memory_convent ) ) + " MB "
print_str = print_str + " 系统可用的内存容量为: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB "
print_str = print_str + " 内存的buffer容量为: "+str( mem.buffers/( memory_convent ) ) + " MB "
print_str = print_str + " 内存的cache容量为:" +str( mem.cached/( memory_convent ) ) + " MB "

if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :
print_str += " CPU状态如下: "
cpu_status = psutil.cpu_times()
print_str = print_str + " user = " + str( cpu_status.user ) + " "
print_str = print_str + " nice = " + str( cpu_status.nice ) + " "
print_str = print_str + " system = " + str( cpu_status.system ) + " "
print_str = print_str + " idle = " + str ( cpu_status.idle ) + " "
print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + " "
print_str = print_str + " irq = " + str( cpu_status.irq ) + " "
print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + " "
print_str = print_str + " steal = " + str ( cpu_status.steal ) + " "
print_str = print_str + " guest = " + str ( cpu_status.guest ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :
print_str += " 硬盘信息如下: "
disk_status = psutil.disk_partitions()
for item in disk_status :
print_str = print_str + " "+ str( item ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"user" ) :
print_str += " 登录用户信息如下: "
user_status = psutil.users()
for item in user_status :
print_str = print_str + " "+ str( item ) + " "

print_str += "--------------------------------------------------------------- "
print ( print_str )
handle.write( print_str )
handle.close()

import psutil

mem = psutil.virtual_memory()
print mem.total,mem.used,mem
print psutil.swap_memory() # 输出获取SWAP分区信息

cpu = psutil.cpu_stats()
printcpu.interrupts,cpu.ctx_switches

psutil.cpu_times(percpu=True) # 输出每个核心的详细CPU信息
psutil.cpu_times().user # 获取CPU的单项数据 [用户态CPU的数据]
psutil.cpu_count() # 获取CPU逻辑核心数，默认logical=True
psutil.cpu_count(logical=False) # 获取CPU物理核心数

psutil.disk_partitions() # 列出全部的分区信息
psutil.disk_usage('/') # 显示出指定的挂载点情况【字节为单位】
psutil.disk_io_counters() # 磁盘总的IO个数
psutil.disk_io_counters(perdisk=True) # 获取单个分区IO个数

psutil.net_io_counter() 获取网络总的IO，默认参数pernic=False
psutil.net_io_counter(pernic=Ture)获取网络各个网卡的IO

psutil.pids() # 列出所有进程的pid号
p = psutil.Process(2047)
p.name() 列出进程名称
p.exe() 列出进程bin路径
p.cwd() 列出进程工作目录的绝对路径
p.status()进程当前状态[sleep等状态]
p.create_time() 进程创建的时间 [时间戳格式]
p.uids()
p.gids()
p.cputimes() 【进程的CPU时间，包括用户态、内核态】
p.cpu_affinity() # 显示CPU亲缘关系
p.memory_percent() 进程内存利用率
p.meminfo() 进程的RSS、VMS信息
p.io_counters() 进程IO信息，包括读写IO数及字节数
p.connections() 返回打开进程socket的nametples列表
p.num_threads() 进程打开的线程数

import psutil
from subprocess import PIPE
p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)
p.name()
p.username()
p.communicate()
p.cpu_times()

psutil.users() # 显示当前登录的用户，和Linux的who命令差不多

psutil.boot_time() 结果是个UNIX时间戳，下面我们来转换它为标准时间格式，如下：
datetime.datetime.fromtimestamp(psutil.boot_time()) # 得出的结果不是str格式，继续进行转换 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')

Python生成一个随机密码

import random, string
def GenPassword(length):

if name == ' main ':
print (GenPassword(6))

G. 在电脑上为android设备编写Python脚本的好用编译器

Android模拟器上安装Python解释器
我了解的有两种方法可以下载并安装Android软件。一个是通过Android直接访问网络，下载安装；另一个是通过PC下载，然后通过模拟器工具ADB安装。这里介绍第二种方式。
下载Python for Android解释器；
解释器框架，点击下载：http://code.google.com/p/android-scripting/downloads/detail?name=sl4a_r3.apk&can=2&q=
python解释器，点击下载：http://code.google.com/p/android-scripting/downloads/detail?name=PythonForAndroid_r4.apk&can=2&q=
安装Python for Android解释器；
设置环境变量，加入Android模拟器工具 adb.exe所在的路径。
打开cmd运行界面，输入adb。你会看到如下信息：

输入adb device。

输入adb install –s <解释器框架所在路径>；比如adb install –s c:/sl4a_r3.apk。安装完毕后，在你的android中就会出现SL4A图标。

同上的步骤，再把python解释器安装上。比如adb install –s c:/PythonForAndroid_r4.apk。安装完毕后，在你的Android中就会出现Python for Android图标。

在Android中点击Python for Android。进去后，有一个install的button，点击安装。这个程序会通过网络，下载到所需要的所有程序包。
测试Python for Android解释器；
当一切安装妥当后，在Android中点击SL4A图标。
在出现的列表中点击hello_world.py（或者其他的脚本）；界面左上角会出现一个小的SL4A的图标，同时界面也会出现“hello world！”

如果你的Android运行结果如上所述，证明你的安装成功了，继续下一步。
Step4 : 编写可在Android模拟器运行的Python Script并执行
编写Python Script For Android；

传递Python Script到Android模拟器;
假设你编写的python脚本存放在c:/Hello_world.py中
打开cmd界面，运行adb push <local> <remote>;例如，adb push c:/Hello_world.py /sdcard/sl4a/scripts/Hello_wold.py
在Android模拟器上运行Python Script;
在Android上运行脚本，你会看到“Hello world!”出现在屏幕上。 （如同step3的结果）
如果你的运行结果如上所述，那么恭喜你，你已成功上传并运行了你的第一个android python脚本，继续下一步。

H. 用PYTHON写脚本

importos
#在当前目录下创建文件夹
os.mkdir('newfile')
os.mkdir('newfile/commence')
#或者直接用下面这条代码一次性创建这两个文件夹
#os.makedirs('newfile/commence')

I. 如何用python实现网游自动做任务的脚本

这个挺难的。除非游戏被破解了，或者是游戏内置有脚本。否则做一个游戏外挂要研究好久，而且要一点点的试验。如果游戏升级了，可能参数又不能用了，又要重新做。

技术只是一方面，麻烦的是需要理解游戏的一些数据与规则。