python常用模块整理

random模块：随机数

random常用模块

import random
#随机打印0-1之间的小数
print(random.random())
#随机打印[1,3]之间的整数
print(random.randint(1,3))
#随机打印[1,3)之间的整数（在range中随机取值）
print(random.randrange(1,3))
#随机打印list中的元素
print(random.choice([1,'alex','sb']))
#随机打印list中的元素，每次打印俩个元素
print(random.sample([1,'alex','sb'],2))
#随机打印[1,4]之间的数（包括整数和小数）
print(random.uniform(1,4))
#打乱list中的元素的顺序
l=[4,12,11,1,4,2]
random.shuffle(l)
print(l)

打印验证码：

验证码是一个字母，数字乱序的一个多位组合

def make_code(n):
res=''
for i in range(n):
s1=str(random.randint(0,9))
s2=chr(random.randint(65,90))
res+=random.choice([s1,s2])
return res
print(make_code(5))

os模块：系统模块

os模块，常用模块

import os
print(os.stat(r'D:\python20期课程\day6').st_size) #打印目录或者文件的全部属性，后面加参数，可以打印出该文件的单一属性
res=os.system('tasklist') #调用并执行系统命令：
print(os.path.split(r'D:\python20期课程\day6')) #路径分组：('D:\\python20期课程', 'day6')
print(os.path.dirname(r'D:\python20期课程\day6')) #取出路径或者文件的上一层路径地址
print(os.path.basename(r'D:\python20期课程\day6')) #取出路径的本层路径的名字，或者文件的名字
print(os.path.isabs(r'D:\python20期课程\day6'))  #判断路径格式是否正确，如果path是绝对路径，返回True
print(os.path.join('D:\python20期课程\day6','a','b'))  #路径拼接
print(os.path.normcase('c:/windows\\SYstem32\\..'))  #规范路径，不能识别.和..
print(os.path.normpath('c:/windows\\SYstem32\\..'))  #规范路径，.和..意思是本层和上层目录的意思
print(os.getcwd())   #获取当前python脚本工作的目录路径：
os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
print(os.listdir('111'))    #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove(r'D:\python20期课程\day6\sa')  #删除一个文件
os.rename("oldname","newname")  #重命名文件/目录
print(os.environ)  #获取系统环境变量
print(os.path.exists(r'D:\python20期课程\day6\sa'))  #如果path存在，返回True；如果path不存在，返回False
print(os.path.isfile(r'D:\python20期课程\day6\sa'))  #如果path是一个存在的文件，返回True。否则返回False
print(os.path.isdir(r'D:\python20期课程\day6'))  #如果path是一个存在的目录，则返回True。否则返回False
print(os.path.getatime(r'D:\python20期课程\day6'))  #返回path所指向的文件或者目录的最后存取时间
print(os.path.getmtime(r'D:\python20期课程\day6'))  #返回path所指向的文件或者目录的最后修改时间
print(os.path.getsize(r'D:\python20期课程\day6')) #返回path的大小

取出本文件上层的上层目录的路径

#方法1：（使用本层文件或者目录的路径的，目录名的目录名的办法得到）
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
#方法2：(使用规范路径，路径拼接，获取本文件路径的办法得到)
print(os.path.normpath(os.path.join(os.path.abspath(__file__),os.pardir,os.pardir)))

了解模块

os.sep    #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    #输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    #输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.chdir('111')  #切换到路径下面的目录，之后可以看到的文件就是这个路径下面的内容
print(os.curdir)  #返回当前目录: ('.')
print(os.pardir)  #获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
os.removedirs('dirname1')    #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
print(os.getcwd())   #获取当前python脚本工作的目录路径：

sys模块

sys常用模块

import sys
#执行py脚本，后面添加的参数赋值
# a,b=sys.argv
# print(a,b)
#退出程序，正常退出时exit(0)
#sys.exit(0)
#获取Python解释程序的版本信息
# print(sys.version)
#返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
# print(sys.path)

#打印100%，（在打印的时候，俩个%%意思是取消第二个%的特殊含义）
# print('%s%%' %100)

#%s中间加-50，意思是左对齐输出打印，不足的部分使用空格填充
print('[%-50s]' %'#')
#%s中间加50，意思是右对齐输出打印
print('[%50s]' %'#')
#%d意思是传入的值必须是整数
print('[%d]' %50)
#打印传值有整数有字符：
print(('[%%-%ds]' %50) %'#')

打印进度条：

注意：\r的意思是光标回到初始位置再次打印，end=”取消换行符，%%意思是取消第二个%的特殊意思

import random
import time
def progress(percent,width=50):
show_str=('[%%-%ds]' %width) % ('#' * int(percent*width))
print('\r%s %d%%' %(show_str,int(100*percent)) ,end='')

recv_size=0
total_size=23112
while recv_size <= total_size:
time.sleep(0.1)
recv_size+=102
percent=recv_size / total_size
progress(percent)

shutil模块

高级文件、文件夹、压缩包处理模块

copy功能

import shutil
#copy功能:  格式：shutil.copyfileobj(fsrc, fdst[, length])
shutil.copyfileobj(open(r'D:\python20期课程\day6\常用模块\sys模块.py','rb'),open(r'D:\python20期课程\day6\常用模块\111\abc.py','wb'))
#copy:   格式：shutil.copyfile(src, dst)
shutil.copyfile(r'D:\python20期课程\day6\常用模块\111\abc.py',r'D:\python20期课程\day6\常用模块\111\asdfs.py')
#仅拷贝权限。内容、组、用户均不变    格式：shutil.copymode(src, dst)
shutil.copymode(r'D:\python20期课程\day6\常用模块\111\abc.py',r'D:\python20期课程\day6\常用模块\111\asdfs.py')
#仅拷贝状态的信息，包括：mode bits, atime, mtime, flags  格式：shutil.copystat(src, dst)
shutil.copystat(r'D:\python20期课程\day6\常用模块\111\abc.py',r'D:\python20期课程\day6\常用模块\111\asdfs.py')
#拷贝文件和权限 格式：shutil.copy(src, dst)
shutil.copy(r'D:\python20期课程\day6\常用模块\111\abc.py',r'D:\python20期课程\day6\常用模块\111\asdfs.py')
#拷贝文件和状态信息   格式：shutil.copy2(src, dst)
shutil.copy2(r'D:\python20期课程\day6\常用模块\111\abc.py',r'D:\python20期课程\day6\常用模块\111\asdfs.py')
#递归的去拷贝文件夹   格式：shutil.copytree(src, dst, symlinks=False, ignore=None)
#目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

删除、移动功能

#递归的去删除文件   格式：shutil.rmtree(path[, ignore_errors[, onerror]])
shutil.rmtree('folder1')
#递归的去移动文件，它类似mv命令，其实就是重命名。  格式：shutil.move(src, dst)
shutil.move('folder1', 'folder3')

压缩解压功能

创建压缩包并返回文件路径，例如：zip、tar

创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

如 data_bak =>保存至当前路径

如：/tmp/data_bak =>保存至/tmp/

format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir： 要压缩的文件夹路径（默认当前目录）

owner： 用户，默认当前用户

group： 组，默认当前组

logger： 用于记录日志，通常是logging.Logger对象

压缩打包

#
13385
将 /data 下的文件打包放置当前程序目录,并且返回打包文件的路径
# 格式：shutil.make_archive(base_name, format,...)
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

解压解包

import tarfile
t=tarfile.open(r'D:\python20期课程\day6\常用模块\111\dirname1.tar.gz')
t.extractall(r'D:\python20期课程\day6\常用模块\111\dirname1')
t.close()

压缩解压

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

import zipfile
# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()
# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()

import tarfile
# 压缩
>>> t=tarfile.open('/tmp/egon.tar','w')
>>> t.add('/test1/a.py',arcname='a.bak')
>>> t.add('/test1/b.py',arcname='b.bak')
>>> t.close()
# 解压
>>> t=tarfile.open('/tmp/egon.tar','r')
>>> t.extractall('/egon')
>>> t.close()

json与pickle模块

json与pickle序列化

#json支持序列化的字符类型：dict、list、str、fool、bool、null
#json序列化：
import json
user={'name':'egon','age':18,'nb':True}
with open('db.json','w',encoding='utf-8') as f:
f.write(json.dumps(user))
#或者
json.dump(user,open('user_new.json','w',encoding='utf-8'))

#pickle可以识别python的全部数据类型（全部对象），但是不能跨平台
#pickle序列化是b模式
#pickle序列化：
import pickle
import json
s={1,2,3,4,5}
# print(pickle.dumps(s))
asb=pickle.dumps(s)
print(pickle.loads(asb))

with open('s.pkl','wb') as f:
abs=pickle.dumps(s)
f.write(abs)
#或者
pickle.dump(s,open('s.pkl','wb'))

json与pickle反序列化

#json反序列化：
import json

with open('db.json','r',encoding='utf-8')as f:
user=json.loads(f.read())
print(user['name'])
#或者：
user=json.load(open('user_new.json','r',encoding='utf-8'))
print(user['name'])

#pickle反序列化：
with open('s.pkl','rb') as f:
print(pickle.loads(f.read()))
#或者
print(pickle.load(open('s.pkl','rb')))

扩展：shelve模块

import shelve
#用shelve打开一个文件：
f=shelve.open('db.sh1')
#把内存中的数据存放到文件中
# f['stu1']={'name':'alex1','age':18}
# f['stu3']={'name':'alex3','age':12}
#可以在文件中读取到之前存放到文件中的数据
print(f['stu1']['name'])
f.close()

xml模块

import xml.etree.ElementTree as ET

tree=ET.parse('db.xml')
root=tree.getroot()
# print(root)

#遍历xml文件
for child in root:
print('====>',child.tag,child.attrib,child.attrib['name'])
for i in child:
print(i.tag,i.attrib,i.text)
#只遍历year节点
for node in root.iter('year'):
print(node.tag,node.text)

import xml.etree.ElementTree as ET

tree=ET.parse('db.xml')
root=tree.getroot()

#修改：(修改year头，在头里面添加参数)
for node in root.iter('year'):
new_year=int(node.text)+1
node.text=str(new_year)
node.set('updated','yes')
node.set('version','1.0')
tree.write('test.xml')

#删除node：
for country in root.findall('country'):
rank=int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('output.xml')

#在country内添加（append）节点year2
import xml.etree.ElementTree as ET
tree = ET.parse('a.xml')  #解析xml文件
root = tree.getroot()  #获取xml文件内容

for country in root.findall('country'):
for year in country.findall('year'):
if int(year.text) > 2000:
year2=ET.Element('year2')
year2.text='new year'  #
year2.attrib={'update':'yes'}
country.append(year2)
tree.write('a.xml.swap')

configparser模块

用到的参数：

configparser.ConfigParser()   使用解析

config.sections()  #获取节段信息

config.options('mysql')  #查看节段下面的内容

config.get('mysql','host')   #查看节段下面的一个key的value

config.has_option('mysql','aaa')   #判断节点下面是否有这个key

config.getboolean('mysqld','skip-grant-table')  #取出来的True是boole值

读取my.ini文件

import configparser
config=configparser.ConfigParser()
config.read('my.ini') #读取文件

print(config.sections())  #获取节段信息
# >['mysqld', 'client']

# print(config.options('mysql'))  #查看节段下面的内容
# print(config.get('mysql','host'))  #查看节段下面的一个key的value

if config.has_option('mysql','aaa'): #判断节点下面是否有这个key
print(config.get('mysql','aaa'))

# print(config.get('mysqld','skip-grant-table')) #这样取出来的boole值是一个str类型，需要修改类型，或者使用下面的方法
print(config.getboolean('mysqld','skip-grant-table'))  #取出来的True是boole值
print(config.getint('mysqld','port'))   #整型
print(config.getfloat('mysqld','port'))  #浮点

写入my.ini文件

#添加配置：
import configparser
config=configparser.ConfigParser()
config.add_section('lqx')  #添加一个节段值
config.set('lqx','name','egon')
config.set('lqx','age','18')
config.set('client','password','sadfdas')   #第一个是节段值，如果没有会报错
config.write(open('my.ini','w',encoding='utf-8'))   #添加完成后，需要用这个模块去写入，不然会一直存在于内存中

hashlib模块

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

三个特点：

1.内容相同则hash运算结果相同，内容稍微改变则hash值则变

2.不可逆推

3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

用到的参数：

hashlib.md5() 指定一个算法

update(‘hello’,encode(‘utf-8’)) #意思是提交需要hash的参数，需要转换为b模式，才可以进行hash

m.hexdigest() 返回hash结果

import hashlib
#hash，提交多个，和提交一个只要字符串相同，hash出的hash值是相同的
#如下：
m=hashlib.md5()
m.update('hello'.encode('utf-8'))
print(m.hexdigest())
#另一种写法：
m=hashlib.md5('hello'.encode('utf-8))
print(m.hexdigest())

l=hashlib.md5()
l.update('he'.encode('utf-8'))
l.update('llo'.encode('utf-8'))
print(l.hexdigest())

md5加验

#MD5加严：
m=hashlib.md5()
m.update('wangbada'.encode('utf-8'))
m.update('lqx234'.encode('utf-8'))
m.update('aaaaa'.encode('utf-8'))
print(m.hexdigest())

suprocess模块

stdout=subprocess.PIPE 标准正确输出管道

stderr=subprocess.PIPE 标准错误输出管道

stdin=obj1 标准输入，把obj1的结果输入进入

shell=True 意思是调用命令解释器来使用前面的命令

#如果没有time.shell(1)，可能会看不到结果，原因是代码执行太快，导致命令没有执行完打印到屏幕，脚本就已经结束了
res1=subprocess.Popen('tasklist',shell=True)
print('-->zhu')
time.sleep(1)

#指定标准输出到管道中
obj=subprocess.Popen('raskfsdlist',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(obj.stdout.read().decode('gbk'))
print(obj.stderr.read().decode('gbk'))

#了解：实现shell中‘|’的作用
#把obj1中的标准输出结果传给obj2的标准输入，把obj2的标准输出输出到管道中，标准错误输出输出到错误的管道中
obj1=subprocess.Popen('tasklist',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
obj2=subprocess.Popen('findstr python',shell=True,stdin=obj1.stdout,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(obj2.stdout.read().decode('gbk'))

日志模块、正则表达式、时间模块

http://blog.csdn.net/qq_34857250/article/details/79008494

optparse模块

import optparse
class ArgvHandler(object):
def __init__(self):
self.parser=optparse.OptionParser()
self.parser.add_option('-s','--host',dest='host',help='server binding host address')
self.parser.add_option('-p','--port',dest='port',help='server binding port')
(options,args)=self.parser.parse_args()
print(options,args)
print(type(options))
print(dir(options))
print(options.host)
print(args[0])

https://www.cnblogs.com/captain_jack/archive/2011/01/11/1933366.html

requests模块的使用：

import requests
import json
payload={'companyId':'xxxx',
'companyName':'xxxxx',
'channel':'xxxx',
'userName':'xxxx'
}

headers = {'content-type': 'application/json'}
url='http://xxx.xxx.cn/aiapi/ai/robot/v1/create_account'
r=requests.post(url,headers=headers,data=json.dumps(payload))  #自定义头部信息，发送post请求
# print(r.json())  #得到的就是一个字典的格式
print(r.text,type(r.text))  #得到的是一个str类型

pymysql模块的使用：

import pymysql

user=input('用户名: ').strip()
pwd=input('密码: ').strip()
#连接
conn=pymysql.connect(host='localhost',user='root',password='123',database='db1',charset='utf8')
#游标
# cursor=conn.cursor() #执行完毕返回的结果集默认以元组显示
cursor=conn.cursor(cursor=pymysql.cursors.DictCursor)  #执行完毕返回的结果是以字典的形式显示

#执行cursor下面的一个方法，也就是执行sql,但是会出现sql注入的问题，如果解决，需要使用execute方法来自动做字符串拼接。
# res=cursor.execute('select * from t1 where name="%s" and passwrod="%s";' %(user,pwd))

#下面的方法是防止sql注入的问题
sql='select * from t1 where name=%s and passwrod=%s'
res=cursor.execute(sql,[user,pwd])

print(cursor.fetchone())  #查看执行的结果的一条
print(cursor.fetchall())  #查看sql执行的结果
print(cursor.DataError())  #打印sql执行的报错信息
cursor.close()
conn.close()

paramiko模块的使用：

SSHClient

import paramiko
#创建ssh对象
ssh=paramiko.SSHClient()
#允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#连接服务器
ssh.connect(hostname='119.28.17.250',port=22,username='root',password='xxxxxx')

#执行命令：
while True:
cmd=input('>>>').strip()
if not cmd :continue
if cmd=='exit':break
stdin,stdout,stderr=ssh.exec_command(cmd)
#获取命令结果
result=stdout.read() + stderr.read()
print(result.decode('utf-8'))
#关闭连接
ssh.close()

基于私钥文件进行连接

import paramiko
def login_server():
private_key=paramiko.RSAKey.from_private_key_file(r'D:\is_rsa')
ssh=paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname='172.66.66.15',port=8022,username='root',pkey=private_key)

while True:
cmd=input('>>>').strip()
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()
err_result=stderr.read()
print(result.decode('utf-8'))
if err_result.strip():
print('error: %s' % err_result.decode('utf-8'))

ssh.close()

if __name__ == '__main__':
login_server()

基于transport的加密会话连接

import paramiko

private_key=paramiko.RSAKey.from_private_key_file('/tmp/id_rsa')

transport=paramiko.Transport(('172.66.66.15',22))
transport.connect(username='root',pkey=private_key)

ssh=paramiko.SSHClient()
ssh._transport=transport

stdin,stdout,stderr=ssh.exec_command('df')
result=stdout.read()
print(result.decode('utf-8'))

transport.close()

基于私钥字符串进行加密连接

import paramiko
from io import StringIO
key_str='''
-----BEGIN RSA PRIVATE KEY-----
MIIEoQIBAAKCAQEAsJmFLrSeCumJvga0Gl5O5wVOVwMIy2MpqIyQPi5J87dg89a4
.........................................MqzsdPwLMJg==
-----END RSA PRIVATE KEY-----
'''
private_key=paramiko.RSAKey(file_obj=StringIO(key_str))
transport=paramiko.Transport(('172.66.66.15',22))
transport.connect(username='root',pkey=private_key)

ssh=paramiko.SSHClient()
ssh._transport=transport

stdin, stdout, stderr = ssh.exec_command('df')
result = stdout.read()
print(result.decode('utf-8'))
transport.close()

print(result)

基于用户名密码上传下载

import paramiko

transport=paramiko.Transport(('120.92.84.249',22))
transport.connect(username='root',password='xxx')

sftp=paramiko.SFTPClient.from_transport(transport)
#将location.py上传到服务器/tmp/test.py
sftp.put('/tmp/id_tsa','/tmp/test.rsa')
#remove_path下载到本地local_path
sftp.get('remove_path','local_path')

transport.close()

基于公钥密钥上传下载

import paramiko

private_key=paramiko.RSAKey.from_private_key_file('/tmp/id_rsa')

transport=paramiko.Transport(('120.92.84.249',22))
transport.connect(username='root',pkey=private_key)

sftp=paramiko.SFTPClient.from_transport(transport)
#将location.py上传至服务器/tmp/test.py
sftp.put('/tmp/id_rsa','/tmp/a.txt')
#将remove_path下载到本地 local_path
sftp.get('remove_path','local_path')

transport.close()