python钢琴块自动脚本的简单介绍

本文目录一览：

1、python开发命令行脚本
2、python自动化脚本怎么编写？
3、教你如何在win10下自动运行python程序脚本
4、python 运维常用脚本
5、python有哪些脚本

python开发命令行脚本

工作中会经常需要写一些命令行脚本，如果还是用if,else判断用户输入实在是太丑陋了。这里介绍几个python里的命令行脚本库，可以帮助我们快速开发好用的命令行脚本。

使用方式是继承Cmd,实现自己的子类。

参数comletekey是自动补全操作，默认值是Tab, 如果不为None 且readline可用的话，命令会自动完成。

这里的readline指的是python实现的 GNU readline 接口（标准python库里没有，Windows系统不支持）。

参数stdin,stdout是输入输出流，默认是sys.stdin,sys.stout。

cmd提供了一个简单的框架，但是功能比较简单，python还有其他的很多第三方库可以用来写命令行程序。

这篇文章对比了各个库的功能，贴在这里：

看起来fire是最简单的，来试一下。

fire 则是用一种面向广义对象的方式来玩转命令行，这种对象可以是类、函数、字典、列表等，它更加灵活，也更加简单。你都不需要定义参数类型，fire 会根据输入和参数默认值来自动判断，这无疑进一步简化了实现过程。

以下示例为 fire 实现的计算器程序：

从上述示例可以看出，fire 提供的方式无疑是最简单、并且最 Pythonic 的了。我们只需关注业务逻辑，而命令行参数的定义则和函数参数的定义融为了一体。

不过，有利自然也有弊，比如 nums 并没有说是什么类型，也就意味着输入字符串'abc'也是合法的，这就意味着一个严格的命令行程序必须在自己的业务逻辑中来对期望的类型进行约束。

python自动化脚本怎么编写？

首先你需要在北鲲云超算上申请python这款软件，然后选择配置后就可以直接开始作业了，运行软件后就可以开始搭建脚本界面，编写脚本代码，用超算跑作业很方便，直接线上就可以使用，不需要下载到本地，而且计算效率非常的高。

教你如何在win10下自动运行python程序脚本

写一个小的python程序，如test.py

由于python执行的比较快，窗口会一闪而过，所以加入while循环保持窗口。

在和test.py文件的同文件夹下，新建一个.bat文件，例如run.bat 这是由于python文件不是可执行文件，所以需要借助bat文件进行操作。

第二行是执行这个test.py文件

右键单击此电脑或我的电脑，点击管理 -系统工具 -任务计划程序 -任务计划程序库

之后点击右侧创建基本任务

上述操作的图就不放了，参考链接：

进入创建基本任务后，名称随意取，描述可选填，点击下一步

触发器，什么时候触发脚本，这里先选择一次，点击系一部之后选择一次的时间，这里往后写几分钟，方便一会查看结果点击下一步

操作这里默认启动程序就可以，点击下一步

选择要执行的脚本文件，选择浏览，选中run.bat文件点击打开，点击下一步

点击完成

在任务计划程序库中找到刚才建立的测试任务，在右下方有属性选项点击，更改红色圈出来的地方。也可以在触发器中更改触发时间，或者新建触发条件

等待触发时间到，就会运行改脚本，按住Ctrl+C停止运行，测试成功

原文链接：

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 n"%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("------------------------------n")

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

print("------------------------------n")

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

python3-实现钉钉报警

import requests

import sys

import json

dingding_url = ' '

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

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

send_data = json.dumps(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 = ' '

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(('127.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 = ' '

data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}

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

send_data = json.dumps(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(('127.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('n'))

ssh.connect(hostname=line[i].strip('n'),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("n")

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 lyshark@59.110.167.239')

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

ssh.logfile = fout

ssh.expect("lyshark@59.110.167.239'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))+"MBn")

print("已使用内存:"+str(mem.used/(memory_convent))+"MBn")

print("可用内存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MBn")

print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MBn")

print("cache容量:"+str(mem.cached/(memory_convent))+"MBn")

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('n')[:-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('n')

return sn1

def getload(host,loid):

load_oids = '1.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('n')[:-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_dump')

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_dump')

sys.exit(0)

if name ==" main ":

main()

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

import pexpect

import sys

ssh = pexpect.spawn('ssh root@59.110.167.239')

fout = file('sshlog.log', 'w')

ssh.logfile = fout

ssh.expect("root@59.110.167.239'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 += " 内存状态如下:n"

print_str = print_str + " 系统的内存容量为: "+str( mem.total/( memory_convent ) ) + " MBn"

print_str = print_str + " 系统的内存以使用容量为: "+str( mem.used/( memory_convent ) ) + " MBn"

print_str = print_str + " 系统可用的内存容量为: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MBn"

print_str = print_str + " 内存的buffer容量为: "+str( mem.buffers/( memory_convent ) ) + " MBn"

print_str = print_str + " 内存的cache容量为:" +str( mem.cached/( memory_convent ) ) + " MBn"

if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :

print_str += " CPU状态如下:n"

cpu_status = psutil.cpu_times()

print_str = print_str + " user = " + str( cpu_status.user ) + "n"

print_str = print_str + " nice = " + str( cpu_status.nice ) + "n"

print_str = print_str + " system = " + str( cpu_status.system ) + "n"

print_str = print_str + " idle = " + str ( cpu_status.idle ) + "n"

print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + "n"

print_str = print_str + " irq = " + str( cpu_status.irq ) + "n"

print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + "n"

print_str = print_str + " steal = " + str ( cpu_status.steal ) + "n"

print_str = print_str + " guest = " + str ( cpu_status.guest ) + "n"

if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :

print_str += " 硬盘信息如下:n"

disk_status = psutil.disk_partitions()

for item in disk_status :

print_str = print_str + " "+ str( item ) + "n"

if ( print_type == 1 ) or isset ( sys.argv,"user" ) :

print_str += " 登录用户信息如下:n "

user_status = psutil.users()

for item in user_status :

print_str = print_str + " "+ str( item ) + "n"

print_str += "---------------------------------------------------------------n"

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的namedutples列表

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

python有哪些脚本

Python常用的30个脚本：

1、冒泡排序

2、计算x的n次方的方法

3、计算a*a + b*b + c*c + ……

4、计算阶乘 n!

6、把一个list中所有的字符串变成小写：

7、输出某个路径下的所有文件和文件夹的路径

8、输出某个路径及其子目录下的所有文件路径

9、输出某个路径及其子目录下所有以.html为后缀的文件

10、把原字典的键值对颠倒并生产新的字典