python常用运维脚本实例

拼搏现实的明天。 2022-07-14 17:59 208阅读 0赞

file是一个类，使用file('file\_name', 'r+')这种方式打开文件，返回一个file对象，以写模式打开文件不存在则会被创建。但是更推荐使用内置函数open()来打开一个文件 .

首先**open是内置函数**，使用方式是open('file\_name', mode, buffering)，返回值也是一个file对象，同样，以写模式打开文件如果不存在也会被创建一个新的。

f=open('/tmp/hello','w')

\#open(路径+文件名,读写模式)

\#读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

如:'rb','wb','r+b'等等

读写模式的类型有：

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)

w     以写方式打开，

a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)

r+     以读写模式打开

w+     以读写模式打开 (参见 w )

a+     以读写模式打开 (参见 a )

rb     以二进制读模式打开

wb     以二进制写模式打开 (参见 w )

ab     以二进制追加模式打开 (参见 a )

rb+    以二进制读写模式打开 (参见 r+ )

wb+    以二进制读写模式打开 (参见 w+ )

ab+    以二进制读写模式打开 (参见 a+ )

注意：

1、使用'W'，文件若存在，首先要清空，然后（重新）创建，

2、使用'a'模式 ，把所有要写入文件的数据都追加到文件的末尾，即使你使用了seek（）指向文件的其他地方，如果文件不存在，将自动被创建。

f.read(\[size\]) size未指定**则返回整个文**件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)

**file.readline() 返回一行**

file.readline(\[size\]) 返回包含size行的列表,size 未指定则返回全部行

for line in f:

print line \#通过迭代器访问

f.write("hello\\n") \#如果要写入字符串以外的数据,**先将他转换为字符串**.

f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

f.seek(偏移量,\[起始位置\])

用来移动文件指针

偏移量:单位:比特,可正可负

**起始位置:0-文件头,默认值;1-当前位置;2-文件尾**

f.close() 关闭文件

要进行读文件操作，只需要把模式换成'r'就可以，也可以把模式为空不写参数，也是读的意思，因为程序默认是为'r'的。

>>>f = open('a.txt', 'r')

>>>f.read(5)

'hello'

read( )是读文件的方法，括号内填入要读取的字符数，这里填写的字符数是5，如果填写的是1那么输出的就应该是‘h’。

打开文件文件读取还有一些常用到的技巧方法，像下边这两种：

1、**read( )：表示读取全部内容**

2、readline( )：表示逐行读取

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

\#!/usr/bin/env python

import os

for root,dirs,files in **os.walk**('/tmp'):

for name in files:

print (**os.path.join**(root,name))

os.walk()

原型为：os.walk(top, topdown=True, οnerrοr=None, followlinks=False)

我们一般只使用第一个参数。（topdown指明遍历的顺序）

该方法对于每个目录返回一个三元组，(dirpath, dirnames, filenames)。

第一个是路径，第二个是路径下面的目录，第三个是路径下面的非目录（对于windows来说也就是文件）

**os.listdir(path)**

其参数含义如下。path 要获得内容目录的路径

二、写程序打印三角形

\#!/usr/bin/env python

input = int(raw\_input('input number:'))

for i in range(input):

for j in range(i):

print '\*',

print '\\n'

三、猜数器，程序随机生成一个个位数字，然后等待用户输入，输入数字和生成数字相同则视为成功。成功则打印三角形。失败则重新输入（提示：随机数函数:random)

\#!/usr/bin/env python

import random

while True:

input = int(raw\_input('input number:'))

random\_num = **random.randint**(1, 10)

print input,random\_num

if input == random\_num:

for i in **range**(input):

for j in range(i):

print '\*',

print '\\n'

else:

print 'please input number again'

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

\#!/usr/bin/env python

\#!coding=utf-8

import time

import os

new\_time = time.strftime('%Y-%m-%d')

disk\_status = os.popen('df -h').**readlines**()

str1 = ''.join(disk\_status)

f = file(new\_time+'.log','w')

f.write('%s' % str1)

f.flush()

f.close()

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

\#!/usr/bin/env python

\#!coding=utf-8

list = \[\]

f = file('/tmp/1.log')

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' %(j,num)

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

2. 根据用户输入数字，输出从0到该数字之间所有的素数。(只能被1和自身整除的数为素数）

\#!/usr/bin/env python

\#coding=utf-8

import tab

import sys

while True:

try:

n = int(raw\_input('请输入数字:').strip())

for i in range(2, n + 1):

for x in range(2, i):

if i % x == 0:

break

else:

print i

except ValueError:

print('你输入的不是数字，请重新输入:')

except KeyboardInterrupt:

sys.exit('\\n')

python练习 抓取web页面

from urllib import urlretrieve

def firstNonBlank(lines):

for eachLine in lines:

if not eachLine.strip():

continue

else:

return eachLine

def firstLast(webpage):

f=open(webpage)

lines=f.readlines()

f.close

print firstNonBlank(lines), \#调用函数

lines.reverse()

print firstNonBlank(lines),

def download(url= 'http://search.51job.com/jobsearch/advance\_search.php',process=firstLast):

try:

retval = urlretrieve(url) \[0\]

except IOError:

retval = None

if retval:

process(retval)

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

download()

Python中的sys.argv\[\]用法练习

\#!/usr/bin/python

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

import sys

def readFile(filename):

f = file(filename)

while True:

fileContext = f.readline()

if len(fileContext) ==0:

break;

print fileContext

f.close()

if len(sys.argv) < 2:

print "No function be setted."

sys.exit()

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

**option = sys.argv\[1\]\[1:\]**

if option == 'version':

print "Version1.2"

elif option == 'help':

print "enter an filename to see the context of it!"

else:

print "Unknown function!"

sys.exit()

else:

for **filename in sys.argv\[1:\]:**

readFile(filename)

python迭代查找目录下文件

\#两种方法

\#!/usr/bin/env python

import os

dir='/root/sh'

'''

def fr(dir):

filelist=**os.listdir**(dir)

for i in filelist:

fullfile=**os.path.join**(dir,i)

if not **os.path.isdir**(fullfile):

if i == "1.txt":

\#print fullfile

**os.remove**(fullfile)

else:

fr(fullfile)

'''

def fw()dir:

for root,dirs,files in os.walk(dir):

for f in files:

if f == "1.txt":

\#os.remove(os.path.join(root,f))

print os.path.join(root,f)

'''

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

（提示，使用ps aux 列出所有进程，过滤出RSS那列，然后求和）

\#!/usr/bin/env python

\#!coding=utf-8

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)

写一个脚本，判断本机的80端口是否开启着，如果开启着什么都不做，如果发现端口不存在，那么重启一下httpd服务，并发邮件通知你自己。脚本写好后，可以每一分钟执行一次，也可以写一个死循环的脚本，30s检测一次。

\#!/usr/bin/env python

\#!coding=utf-8

import os

import time

import sys

import smtplib

from email.mime.text import MIMEText

from email.MIMEMultipart import MIMEMultipart

def sendsimplemail (warning):

msg = **MIMEText**(warning)

msg\['Subject'\] = 'python first mail'

msg\['From'\] = 'root@localhost'

try:

smtp = smtplib.SMTP()

smtp.connect(r'smtp.126.com')

smtp.login('要发送的邮箱名', '密码')

smtp.sendmail('要发送的邮箱名', \['要发送的邮箱名'\], msg.as\_string())

smtp.close()

except Exception, e:

print e

while True:

http\_status = os.popen('netstat -tulnp | grep httpd','r').readlines()

try:

if http\_status == \[\]:

os.system('service httpd start')

new\_http\_status = os.popen('netstat -tulnp | grep httpd','r').readlines()

str1 = ''.join(new\_http\_status)

is\_80 = str1.split()\[3\].split(':')\[-1\]

if is\_80 != '80':

print 'httpd 启动失败'

else:

print 'httpd 启动成功'

sendsimplemail(warning = "This is a warning!!!")\#调用函数

else:

print 'httpd正常'

**time.sleep(5)**

except KeyboardInterrupt:

sys.exit('\\n')

\#!/usr/bin/python

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

\#输入这一条就可以在Python脚本里面使用汉语注释！此脚本可以直接复制使用；

while True:            \#进入死循环

input = raw\_input('Please input your username:')

\#交互式输入用户信息，输入input信息；

if input == "wenlong":

\#如果input等于wenlong则进入此循环（如果用户输入wenlong）

password = raw\_input('Please input your pass:')

\#交互式信息输入，输入password信息；

p = '123'

\#设置变量P赋值为123

while password != p:

\#如果输入的password 不等于p（123）， 则进此入循环

password = raw\_input('Please input your pass again:')

\#交互式信息输入，输入password信息；

if password == p:

\#如果password等于p（123），则进入此循环

print 'welcome to select system!'              \#输出提示信息；

while True:

\#进入循环；

match = 0

\#设置变量match等于0；

input = raw\_input("Please input the name whom you want to search :")

\#交互式信息输入，输入input信息；

while not input.strip():

\#判断input值是否为空，如果input输出为空，则进入循环；

input = raw\_input("Please input the name whom you want to search :")

\#交互式信息输入，输入input信息；

name\_file = file('search\_name.txt')

\#设置变量name\_file，file('search\_name.txt')是调用名为search\_name.txt的文档

while True:

\#进入循环；

line = name\_file.readline()           \#以行的形式，读取search\_name.txt文档信息；

if len(line) == 0:      \#当len(name\_file.readline() )为0时，表示读完了文件，len(name\_file.readline() )为每一行的字符长度，空行的内容为\\n也是有两个字符。len为0时进入循环；

break       \#执行到这里跳出循环；

if input in line:    \#如果输入的input信息可以匹配到文件的某一行，进入循环；

print 'Match item: %s'  %line     \#输出匹配到的行信息；

match = 1    \#给变量match赋值为1

if match == 0 :              \#如果match等于0，则进入   ；

print 'No match item found!'         \#输出提示信息；

else: print "Sorry ,user  %s not found " %input      \#如果输入的用户不是wenlong，则输出信息没有这个用户；

\#!/usr/bin/python

while True:

input = raw\_input('Please input your username:')

if input == "wenlong":

password = raw\_input('Please input your pass:')

p = '123'

while password != p:

password = raw\_input('Please input your pass again:')

if password == p:

print 'welcome to select system!'

while True:

match = 0

input = raw\_input("Please input the name whom you want to search :")

while not input.strip():

print 'No match item found!'

input = raw\_input("Please input the name whom you want to search :")

name\_file = file('search\_name.txt')

while True:

line = name\_file.readline()

if len(line) == 0:

break

if input in line:

print 'Match item: '  , line

match = 1

if match == 0 :

print 'No match item found!'

else: print "Sorry ,user  %s not found " %input

Python监控CPU情况

1、实现原理：通过SNMP协议获取系统信息，再进行相应的计算和格式化，最后输出结果

2、特别注意：被监控的机器上需要支持snmp。yum install -y net-snmp\*安装

"""

\#!/usr/bin/python

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

date = \[\]

rate = \[\]

cpu\_total = 0

\#us = us+ni, sy = sy + irq + sirq

for item in items:

float\_item = float(item.split(' ')\[3\])

cpu\_total += float\_item

if item == items\[0\]:

date.append(float(item.split(' ')\[3\]) + float(items\[1\].split(' ')\[3\]))

elif item == item\[2\]:

date.append(float(item.split(' ')\[3\] + items\[5\].split(' ')\[3\] + items\[6\].split(' ')\[3\]))

else:

date.append(float\_item)

\#calculate cpu usage percentage

for item in date:

rate.append((item/cpu\_total)\*100)

mean = \['%us','%ni','%sy','%id','%wa','%cpu\_irq','%cpu\_sIRQ'\]

\#calculate cpu usage percentage

result = map(None,rate,mean)

return result

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

hosts = \['192.168.10.1','192.168.10.2'\]

for host in hosts:

print '==========' + host + '=========='

result = getDate(host)

print 'Cpu(s)',

\#print result

for i in range(5):

print ' %.2f%s' % (result\[i\]\[0\],result\[i\]\[1\]),

Python监控系统负载

1、实现原理：通过SNMP协议获取系统信息，再进行相应的计算和格式化，最后输出结果

2、特别注意：被监控的机器上需要支持snmp。yum install -y net-snmp\*安装

"""

\#!/usr/bin/python

import os

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\_\_':

hosts = \['192.168.10.1','192.168.10.2'\]

\#check\_system\_load

print '==============System Load=============='

for host in hosts:

load1 = getload(host, 1)

load10 = getload(host, 2)

load15 = getload(host, 3)

print '%s load(1min): %s ,load(10min): %s ,load(15min): %s' % (host,load1,load10,load15)

Python监控网卡流量

1、实现原理：通过SNMP协议获取系统信息，再进行相应的计算和格式化，最后输出结果

2、特别注意：被监控的机器上需要支持snmp。yum install -y net-snmp\*安装

"""

\#!/usr/bin/python

import re

import os

\#get SNMP-MIB2 of the devices

def getAllitems(host,oid):

sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\\n')\[:-1\]

return sn1

\#get network device

def getDevices(host):

device\_mib = getAllitems(host,'RFC1213-MIB::ifDescr')

device\_list = \[\]

for item in device\_mib:

if re.search('eth',item):

device\_list.append(item.split(':')\[3\].strip())

return device\_list

\#get network date

def getDate(host,oid):

date\_mib = getAllitems(host,oid)\[1:\]

date = \[\]

for item in date\_mib:

byte = float(item.split(':')\[3\].strip())

date.append(str(round(byte/1024,2)) + ' KB')

return date

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

hosts = \['192.168.10.1','192.168.10.2'\]

for host in hosts:

device\_list = getDevices(host)

inside = getDate(host,'IF-MIB::ifInOctets')

outside = getDate(host,'IF-MIB::ifOutOctets')

print '==========' + host + '=========='

for i in range(len(inside)):

print '%s : RX: %-15s   TX: %s ' % (device\_list\[i\], inside\[i\], outside\[i\])

Python监控磁盘

1、实现原理：通过SNMP协议获取系统信息，再进行相应的计算和格式化，最后输出结果

2、特别注意：被监控的机器上需要支持snmp。yum install -y net-snmp\*安装

"""

\#!/usr/bin/python

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 getDate(source,newitem):

for item in source\[5:\]:

newitem.append(item.split(':')\[3\].strip())

return newitem

def getRealDate(item1,item2,listname):

for i in range(len(item1)):

listname.append(int(item1\[i\])\*int(item2\[i\])/1024)

return listname

def caculateDiskUsedRate(host):

hrStorageDescr = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageDescr')

hrStorageUsed = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageUsed')

hrStorageSize = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageSize')

hrStorageAllocationUnits = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageAllocationUnits')

disk\_list = \[\]

hrsused = \[\]

hrsize = \[\]

hrsaunits = \[\]

\#get disk\_list

for item in hrStorageDescr:

if re.search('/',item):

disk\_list.append(item.split(':')\[3\])

\#print disk\_list

getDate(hrStorageUsed,hrsused)

getDate(hrStorageSize,hrsize)

\#print getDate(hrStorageAllocationUnits,hrsaunits)

\#get hrstorageAllocationUnits

for item in hrStorageAllocationUnits\[5:\]:

hrsaunits.append(item.split(':')\[3\].strip().split(' ')\[0\])

\#caculate the result

\#disk\_used = hrStorageUsed \* hrStorageAllocationUnits /1024 (KB)

disk\_used = \[\]

total\_size = \[\]

disk\_used = getRealDate(hrsused,hrsaunits,disk\_used)

total\_size = getRealDate(hrsize,hrsaunits,total\_size)

diskused\_rate = \[\]

for i in range(len(disk\_used)):

diskused\_rate.append(str(round((float(disk\_used\[i\])/float(total\_size\[i\])\*100), 2)) + '%')

return diskused\_rate,disk\_list

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

hosts = \['192.168.10.1','192.168.10.2'\]

for host in hosts:

result = caculateDiskUsedRate(host)

diskused\_rate = result\[0\]

partition = result\[1\]

print "==========",host,'=========='

for i in range(len(diskused\_rate)):

print '%-20s used: %s' % (partition\[i\],diskused\_rate\[i\])

Python监控内存(swap)的使用率

1、实现原理：通过SNMP协议获取系统信息，再进行相应的计算和格式化，最后输出结果

2、特别注意：被监控的机器上需要支持snmp。yum install -y net-snmp\*安装

'''

\#!/usr/bin/python

import os

def getAllitems(host, oid):

sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\\n')\[:-1\]

return sn1

def getSwapTotal(host):

swap\_total = getAllitems(host, 'UCD-SNMP-MIB::memTotalSwap.0')\[0\].split(' ')\[3\]

return swap\_total

def getSwapUsed(host):

swap\_avail = getAllitems(host, 'UCD-SNMP-MIB::memAvailSwap.0')\[0\].split(' ')\[3\]

swap\_total = getSwapTotal(host)

swap\_used = str(round(((float(swap\_total)-float(swap\_avail))/float(swap\_total))\*100 ,2)) + '%'

return swap\_used

def getMemTotal(host):

mem\_total = getAllitems(host, 'UCD-SNMP-MIB::memTotalReal.0')\[0\].split(' ')\[3\]

return mem\_total

def getMemUsed(host):

mem\_total = getMemTotal(host)

mem\_avail = getAllitems(host, 'UCD-SNMP-MIB::memAvailReal.0')\[0\].split(' ')\[3\]

mem\_used = str(round(((float(mem\_total)-float(mem\_avail))/float(mem\_total))\*100 ,2)) + '%'

return mem\_used

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

hosts = \['192.168.10.1','192.168.10.2'\]

print "Monitoring Memory Usage"

for host in hosts:

mem\_used = getMemUsed(host)

swap\_used = getSwapUsed(host)

print '==========' + host + '=========='

print 'Mem\_Used = %-15s   Swap\_Used = %-15s' % (mem\_used, swap\_used)

Python运维脚本 生成随机密码

\#!/usr/bin/env python

\# -\*- coding=utf-8 -\*-

\#Using GPL v2.7

\#Author: leexide@126.com

import random, string        \#导入random和string模块

def GenPassword(length):

\#随机出数字的个数

numOfNum = **random.randint**(1,length-1)

numOfLetter = length - numOfNum

\#选中numOfNum个数字

slcNum = \[**random.choice**(string.digits) **for i in range**(numOfNum)\]

\#选中numOfLetter个字母

slcLetter = \[random.choice(string.ascii\_letters) for i in range(numOfLetter)\]

\#打乱组合

slcChar = slcNum + slcLetter

**random.shuffle**(slcChar)

\#生成随机密码

getPwd = ''.join(\[i for i in slcChar\])

return getPwd

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

print GenPassword(6)

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

import random

li = \[\]

for i in range(6):

r = **random.randrange**(0, 5)

if r == 2 or r == 4:

num = random.randrange(0, 9)

li.append(str(num))

else:

temp = random.randrange(65, 91)

c = chr(temp)

li.append(c)

result = "".join(li)  \# 使用join时元素必须是字符串

print(result)

输出

335HQS

VS6RN5

...

**random.random()用于生成一个指定范围内的随机符点数**，两个参数其中一个是上限，一个是下限。如果a > b，则生成随机数

n: a <= n <= b。如果 a <b， 则 b <= n <= a。

print random.uniform(10, 20)

print random.uniform(20, 10)

\#----

\#18.7356606526

\#12.5798298022

**random.randint 用于生成一个指定范围内的整数**。其中参数a是下限，参数b是上限，Python生成随机数

print random.randint(12, 20) \#生成的随机数n: 12 <= n <= 20

print random.randint(20, 20) \#结果永远是20

\#print random.randint(20, 10) \#该语句是错误的。

**下限必须小于上限。**

**random.randrange 从指定范围内，按指定基数递增的集合中**

random.randrange的函数原型为：random.randrange(\[start\], stop\[, step\])，从指定范围内，按指定基数递增的集合中 获取一个随机数。

如：

random.randrange(10, 100, 2)，结果相当于从\[10, 12, 14, 16, ... 96, 98\]序列中获取一个随机数。

**random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效**。

随机整数：

>>> import random

>>> random.randint(0,99)

随机选取0到100间的偶数：

>>> import random

>>> random.randrange(0, 101, 2)

随机浮点数：

>>> import random

>>> random.random()

0.85415370477785668

>>>** random.uniform**(1, 10)

5.4221167969800881

随机字符：

**random.choice从序列中获取一个随机元素**。

其函数原型为：random.choice(sequence)。**参数sequence表示一个有序类型**。

这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。

list, tuple, 字符串都属于sequence。

print random.choice("学习Python")

print random.choice(\["JGood", "is", "a", "handsome", "boy"\])

print random.choice(("Tuple", "List", "Dict"))

>>> import random

>>> random.choice('abcdefg&\#%^\*f')

'd'

多个字符中选取特定数量的字符：

**random.sample的函数原型为：random.sample(sequence, k)，从指定序列中随机获取指定长度的片断**。

sample函数不会修改原有序列。

>>> import random

random.sample('abcdefghij',3)

\['a', 'd', 'b'\]

多个字符中选取特定数量的字符组成新字符串：

>>> import random

>>> import string

>>> **string.join**(random.sample(\['a','b','c','d','e','f','g','h','i','j'\], 3)).r

eplace(" ","")

'fih'

随机选取字符串：

>>> import random

>>> **random.choice** ( \['apple', 'pear', 'peach', 'orange', 'lemon'\] )

'lemon'

洗牌：

**random.shuffle的函数**原型为：random.shuffle(x\[, random\])，**用于将一个列表中的元素打乱** .

>>> import random

>>> items = \[1, 2, 3, 4, 5, 6\]

>>> random.shuffle(items)

>>> items

\[3, 2, 5, 6, 4, 1\]

1、random.random

**random.random()用于生成一个0到1的随机符点数**: 0 <= n < 1.0

2、random.uniform

**random.uniform(a, b)，用于生成一个指定范围内的随机符点数**，

两个参数其中一个是上限，一个是下限。

如果a < b，则生成的随机数n: b>= n >= a。

如果 a >b，则生成的随机数n: a>= n >= b。

print random.uniform(10, 20)

print random.uniform(20, 10)

\# 14.73

\# 18.579

3、random.randint

random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

print random.randint(1, 10)

4、random.randrange

random.randrange(\[start\], stop\[, step\])，从指定范围内，按指定基数递增的集合中 获取一个随机数。

如：random.randrange(10, 100, 2)，结果相当于从\[10, 12, 14, 16, ... 96, 98\]序列中获取一个随机数。

5、random.choice

random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。

这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。

print random.choice("Python")

print random.choice(\["JGood", "is", "a", "handsome", "boy"\])

print random.choice(("Tuple", "List", "Dict"))

6、random.shuffle

**random.shuffle(x\[, random\])，用于将一个列表中的元素打乱**。

如:

p = \["Python", "is", "powerful", "simple", "and so on..."\]

random.shuffle(p)

print p

\# \['powerful', 'simple', 'is', 'Python', 'and so on...'\]

7、random.sample

**random.sample(sequence, k)，从指定序列中随机获取指定长度的片断**。sample函数不会修改原有序列。

例如：

list = \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12\]

slice = random.sample(list, 6)  \# 从list中随机获取6个元素，作为一个片断返回

print slice

print list  \# 原有序列并没有改变

1.生成随机整数：  
  
random.randint(a,b)  
  
  
random.randint(a,b) \#返回一个随机整数，范围是a <=x <= b  
>>> random.randint(888,999)  
897  
>>> random.randint(888,999)  
989  
>>> random.randint(888,999)  
995  
  
  
random.randrange(start, stop\[, step\]) \#返回指定范围的整数  
>>> random.randrange(2,20,2)  
6  
>>> random.randrange(2,20,2)  
4  
>>> random.randrange(2,20,2)  
14  
2.浮点数  
  
  
random.random() \#返回一个浮点数，范围是0.0 到1.0  
>>> random.random()  
0.22197993728352594  
>>> random.random()  
0.8683996624230081  
>>> random.random()  
0.29398514954873434  
  
  
random.uniform(a,b)\#返回一个指定范围的浮点数  
>>> random.uniform(1, 10)  
3.0691737651343636  
>>> random.uniform(1, 10)  
9.142357395475619  
>>> random.uniform(1, 10)  
6.927435868405478  
  
  
3.随机序列  
  
  
random.choice()\#从非空序列中返回一个随机元素  
>>> name  
\['du', 'diao', 'han', 'jiang', 'xue'\]  
>>> random.choice(name)  
'xue'  
>>> random.choice(name)  
'xue'  
>>> random.choice(name)  
'du'  
>>> random.choice(name)  
'du'  
>>> random.choice(name)  
'du'  
>>> random.choice(name)  
'jiang'  
  
  
\#随机返回指定长度的子序列  
>>> random.sample(name,2)  
\['xue', 'du'\]  
>>> random.sample(name,2)  
\['diao', 'jiang'\]  
>>> random.sample(name,2)  
\['xue', 'du'\]  
  
  
生成指定长度的随机密码：  
  
  
\[root@zhu ~\]\# python jiang.py  
GrDUytJE  
\[root@zhu ~\]\# python jiang.py  
8XaCoUTz  
\[root@zhu ~\]\# cat jiang.py  
  
import random,string  
  
chars=string.ascii\_letters+string.digits  
  
print ''.join(\[random.choice(chars) for i in range(8)\])

**\#!/usr/bin/env python**

import random

import string

import sys

similar\_char = '0OoiI1LpP'

upper = ''.join(set(string.uppercase) - set(similar\_char))

lower = ''.join(set(string.lowercase) - set(similar\_char))

symbols = '!\#$%&\\\*+,-./:;=?@^\_\`~'

numbers = '123456789'

group = (upper, lower, symbols, numbers)

def getpass(lenth=8):

pw = \[random.choice(i) for i in group\]

con = ''.join(group)

for i in range(lenth-len(pw)):

**pw.append(random.choice(con))**

random.shuffle(pw)

return ''.join(pw)

genpass = getpass(int(sys.argv\[1\]))

print genpass

\#!/usr/bin/env python

import random

import string

def GenPassword(length):

chars=string.ascii\_letters+string.digits

return ''.join(\[random.choice(chars) for i in range(length)\])

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

for i in range(10):

print GenPassword(15)

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

'''

简短地生成随机密码，包括大小写字母、数字，可以指定密码长度

'''

\#生成随机密码

from random import choice

import string

\#python3中为string.ascii\_letters,而python2下则可以使用string.letters和string.ascii\_letters

def GenPassword(length=8,chars=string.ascii\_letters+string.digits):

return ''.join(\[choice(chars) for i in range(length)\])

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

\#生成10个随机密码

for i in range(10):

\#密码的长度为8

print(GenPassword(8))

\#!/usr/bin/env python

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

\#导入random和string模块

import random, string

def GenPassword(length):

\#随机出数字的个数

numOfNum = random.randint(1,length-1)

numOfLetter = length - numOfNum

\#选中numOfNum个数字

slcNum = \[random.choice(string.digits) for i in range(numOfNum)\]

\#选中numOfLetter个字母

slcLetter = \[random.choice(string.ascii\_letters) for i in range(numOfLetter)\]

\#打乱这个组合

slcChar = slcNum + slcLetter

random.shuffle(slcChar)

\#生成密码

genPwd = ''.join(\[i for i in slcChar\])

return genPwd

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

print GenPassword(6)

**round取相邻整数**

print(round(1.4))

print(round(1.8))

输出：

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

\#!/usr/bin/env python

\# -\*- coding=utf-8 -\*-

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 \[./diskio.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+)\$: (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()

Python自动化运维之简易ssh自动登录

\#!/usr/bin/env python

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

import pexpect

import sys

ssh = **pexpect.spawn**('ssh root@192.168.20.103 ')

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

ssh.logfile = fout

**ssh.expect**("root@192.168.20.103's password:")

**ssh.sendline**("yzg1314520")

ssh.expect('\#')

ssh.sendline('ls /home')

ssh.expect('\#')

Python运维-获取当前操作系统的各种信息

\#通过Python的psutil模块，获取当前系统的各种信息（比如内存，cpu,磁盘，登录用户等），并将信息进行备份

\# coding=utf-8

\# 获取系统基本信息

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 ) ) + " MB\\n"

print\_str = print\_str + "   系统的内存以使用容量为: "+str( mem.used/( memory\_convent ) ) + " MB\\n"

print\_str = print\_str + "   系统可用的内存容量为: "+str( mem.total/( memory\_convent ) - mem.used/( 1024\*1024 )) + "MB\\n"

print\_str = print\_str + "   内存的buffer容量为: "+str( mem.buffers/( memory\_convent ) ) + " MB\\n"

print\_str = print\_str + "   内存的cache容量为:" +str( mem.cached/( memory\_convent ) ) + " MB\\n"

\#获取cpu的相关信息

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

Python自动化运维学习笔记

psutil  跨平台的PS查看工具

执行pip install psutil 即可，或者编译安装都行。

\# 输出内存使用情况（以字节为单位）

import psutil

mem = psutil.virtual\_memory()

print mem.total,mem.used,mem

print psutil.swap\_memory()  \# 输出获取SWAP分区信息

\# 输出CPU使用情况

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()   进程打开的线程数

\#下面的例子中，Popen类的作用是获取用户启动的应用程序进程信息，以便跟踪程序进程的执行情况

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