Python常用模块

Time 模块

时间模块常用的有如下几种。

import time
print(time.time())  # 1513319911.3789327 1970年到当前的总时间s。
print(time.strftime('%Y-%m-%d %X')) # 2017-12-15 14:38:31

元组形式显示时间：

print(time.localtime())
# time.struct_time(tm_year=2017, tm_mon=12, tm_mday=15, tm_hour=14, tm_min=53, tm_sec=39, tm_wday=4, tm_yday=349, tm_isdst=0)

print(time.localtime().tm_mon) # 12

UTC时间：

print(time.gmtime())

将格式化的时间转换为元组形式的时间:

print(time.localtime(3243543544))
print(time.gmtime(3243543544))

时间转换:

print(time.ctime(12334454))
print(time.asctime(time.gmtime()))

Sun May 24 02:14:14 1970
Fri Dec 15 07:38:07 2017

random模块

import random
 
print(random.random())#(0,1)----float    大于0且小于1之间的小数
 
print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
 
print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数
 
print(random.choice([1,'23',[4,5]]))# 1或者23或者[4,5] 随机选取
 
print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合
 
print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716 
 
 
item=[1,3,5,7,9]
random.shuffle(item) #打乱item的顺序,相当于"洗牌"
print(item)

生成随机验证码:

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

print(make_code(4))

os模块常用函数

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

os.path.normcase()此函数在Linux和mac平台上，该函数会原样返回path，在windows平台上会将路径中的所有字符转换为小写的形式，并将斜转换为反斜杠：

# Linux 平台：
>>> import os
>>> os.path.normcase('c:/windows\\system32\\')
'c:/windows\\system32\\'

# Windows平台：
>>> import os
>>> os.path.normcase('c:/windows\\system32\\')
'c:\\windows\\system32\\'

使用.. 可以表示上一级目录。对目录进行格式化：

#Windows 平台：
>>> os.path.normpath('c://windows\\System\\../Temp/')
'c:\\windows\\Temp'

# Linux 平台：
>>> os.path.normpath('/etc/system/sysconfig/\\\\network/\\\ifconfig/../..')
'/etc/system/sysconfig'

获取文件目录的两种方式（有多少层，就使用多少次os.path.dirname）：

方式一：
>>> os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath('/etc/sysconfig/network-scripts/ifcfg-eth0'))))
'/etc'

方式二： os.pardir想当与  ..    sys.path是一个目录列表.使用insert(0,..)的方式可以优先将目录加入到列表的最前面.
>>> topdir = os.path.normpath(os.path.join(os.path.abspath('/etc/sysconfig/network-scripts/ifcfg-eth0'),os.pardir,os.pardir,os.pardir))
>>> print(topdir)
/etc
>>> sys.path.insert(0,topdir)

sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称

打印进度条的示例:

>>> print('[%-20s]' %'##')
[##                  ]
# -20 表示宽度,[%-20s]是固定写法,后面引用字符变量 %'##'

'\r' 表示跳到行首打印

#=========实现打印进度条函数==========
import sys
import time

def progress(percent,width=50):
    if percent >= 1:
        percent=1
    show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')
    print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

shutil 模块

shutil模块主要是对文件，文件夹，和压缩包进行操作处理的模块，相当于系统中常用的文件操作命令。
shutil.copyfileobj(fsrc, fdst[, length]) :复制文件，如果目标文件存在，则覆盖目标文件。

import shutil
shutil.copyfileobj(open('old.xml', 'r'), open('new.xml', 'w'))

shutil.copyfile(src, dst) 拷贝文件。

shutil.copyfile('new.xml', 'f2.log')

shutil.copymode(src, dst) 仅拷贝权限。文件的内容，所属用户和所属组都不变。
shutil.copystat(src, dst) 仅拷贝状态信息，包括： mode bits,atime,mtime,flages.
shutil.copy(src,dst) : 拷贝文件和权限。

shutil.copy('f2.log','f1.log')

shutil.copy2(src, dst) 拷贝文件和状态信息

shutil.copy2('f1.log', 'f2.log')

shutil.copytree(src, dst, symlinks=False, ignore=None) 递归的拷贝文件目录，和shutil.ignore_patterns(*patterns)连用，排除不需要拷贝的内容：

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) 
#目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 

拷贝软连接：

import shutil

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
# 通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件

shutil.rmtree(path[, ignore_errors[, onerror]])递归的删除文件。

shutil.rmtree('folder1')

shutil.move(src, dst)递归的去移动文件，它类似mv 命令，其实就是重命名。

shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,...) 创建压缩包，并返回文件路径，如 zip,tar。

• base_name:压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存当前至当前目录，否则保存至指定路径。如 data_bak =>保存至当前路。如：/tmp/data_bak =>保存至/tmp/
• format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”
• root_dir：要压缩的文件夹路径（默认当前目录）
• owner：用户，默认当前用户
• group： 组，默认当前组
• logger：用于记录日志，通常是logging.Logger对象

示例：

#将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

#将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data') 

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

json&pickle模块

把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling.

• json: json支持所有通用类型的操作，对于python特有的功能不支持，就有很好的跨平台性。
  在使用eval执行字符串表达式是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
  使用json.dump()可以将字典函数等类型转换为字符串类型，方便存储：

import  json
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
print(type(dic))

j=json.dumps(dic)
print(type(j))
print(j)

输出：


{"name": "alvin", "age": 23, "sex": "male"}

使用json.loads()方式可以将符合json格式的数据进行序列化：

# 读取json.txt的文件内容为：{"name": "alvin", "age": 23, "sex": "male"}
import  json
with open('json.txt','r') as f2:
    data=json.loads(f2.read())
    print(type(data))
    print(data)

输出：

{'name': 'alvin', 'age': 23, 'sex': 'male'}

• pickle： 是python 特有序列化操作，可以序列化函数等特殊类型。与json的使用方式类似。

import pickle
def func():
    print('this is func')    
j=pickle.dumps(func)
print(j)

输出的是bytes类型：
b'\x80\x03c__main__\nfunc\nq\x00.'

反序列化：

import pickle
f=open('序列化对象_pickle','rb')
data=pickle.loads(f.read())  #  等价于data=pickle.load(f)
print(data['age'])   

shelve模块

shelve模块和pickle功能相近，但是比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型。

import shelve

f=shelve.open(r'sheve.txt')
# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
# f['stu2_info']={'name':'gangdan','age':53}
# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()

xml模块

xml是程序之间进行数据交互的协议，在有些应用中还会使用XML协议。xml和json类似，也是跨平台，xml协议在各个语言中都是支持的。
xml文件是一个树形结构的数据，python 的xml模块支持对xml文件的操作。
xml分为三个部分：标签（tag），属性(attrib)，内容(text)。标签一般有多级标签。

# 获取xml的根标签
import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)

#遍历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'):  # root.iter()表示从根节点开始扫描整个xml
    print(node.tag,node.text)

#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')   # tag.set用于设置属性
    node.set('version','1.0')
tree.write('test.xml')
 
#删除node
for country in root.findall('country'): #  tag.findall 只查找tag的下一层。 tag.find只查找tag下一层的一个符合数据。
   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")
root=tree.getroot()
for country in root.findall('country'):    # 使用两层for循环遍历整个标签下的数据
    for year in country.findall('year'):  
        if int(year.text) > 2000:               #  标签.text 用于指定标签对应的数据项
            year2=ET.Element('year2')     #
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) # 往country节点下添加子节点

tree.write('a.xml.swap')

configparser 模块

在使用mysql或者openstack的配置文件中，通常可以看到如下的配置文件格式：

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
symbolic-links=0
[mysqld_safe]
log-error=/var/log/mariadb/mariadb.log
pid-file=/var/run/mariadb/mariadb.pid

使用configparser可以很方便的读写配置信息的内容.

import configparser

config=configparser.ConfigParser()
config.read('my.cnf')
print(config.sections())   # 查看标题
print(config.options(config.sections()[0])) # 查看某个标题下的配置项
print(config.get('mysqld','socket')) # 查看某个标题下的某个配置项的值

输出：

['mysqld', 'mysqld_safe']
['datadir', 'socket', 'symbolic-links']
/var/lib/mysql/mysql.sock

如果获取的值中包含数字和布尔值，可以使用get的方式直接转换为对应的类型。

res1=config.getint('title','conf_option')
res2=config.getfloat('title','conf_option')
res3=config.getboolean('title','conf_option')

修改配置：

config.remove_section('mysqld') # 删除整个标题区域
config.remove_option('mysqld_safe','log-error') # 删除指定title的配置项
config.write(open('my.cnf','w'))  # 写入文件

添加配置：

config.add_section('client')   # 添加一个标题
config.set('client','socket','/var/run/mysql.sock') # 在client标题下添加 socket = /var/run/mysql.sock
config.write(open('my.cnf','w'))  # 写入文件

hashlib模块

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
哈希算法的特点：
1.内容相同则hash运算结果相同，内容稍微改变则hash值则变
2.不可逆推
3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

对数据进行校验：

import hashlib
# 相同的内容校验结果一样
n=hashlib.md5('helloworld'.encode('utf-8'))   # 
print(n.hexdigest())

m=hashlib.md5('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
print(m.hexdigest())

输出：

fc5e038d38a57032085441e7fe7010b0
fc5e038d38a57032085441e7fe7010b0

对文件进行校验：

import hashlib
m=hashlib.md5()
with open('my.cnf','rb') as f:
    for line in f:
        m.update(line)
print(m.hexdigest())

# 文件较大时不推荐使用一次读取文件的方式
m=hashlib.md5()
with open('my.cnf','rb') as f:
    m.update(f.read())
print(m.hexdigest())

在做加密算法时，通过撞库可以反解密码，所以一般对加密算法添加salt进行加密：

# 加盐处理
password='123456'
m=hashlib.md5('add salt code str'.encode('utf-8'))
m.update(password.encode('utf-8'))
print(m.hexdigest())

# 实际的处理字符串
n=hashlib.md5('add salt code str123456'.encode('utf-8'))
print(n.hexdigest())

输出的结果相同：

b7709cddef6897748d66663afdb5a003
b7709cddef6897748d66663afdb5a003

与 hashlib模块类似的还有一个hmac模块,这个模块用法和hashlib一样,但是必须保证首个字符一样,才能校验出相同的结果:

import hmac

h=hmac.new('hello'.encode('utf-8'))
h.update('world'.encode('utf-8'))
print(h.hexdigest())

k=hmac.new('hello'.encode('utf-8'))
k.update('wor'.encode('utf-8'))
k.update('ld'.encode('utf-8'))
print(k.hexdigest())

# 这里输出和上面两种结果不一致
g=hmac.new('hell'.encode('utf-8'))
g.update('oworld'.encode('utf-8'))
print(g.hexdigest())

输出：

0e2564b7e100f034341ea477c23f283b
0e2564b7e100f034341ea477c23f283b
e705e80d60a2e0851a23dcd1773099ab

suprocess 模块

suprocess模块用于调用系统的shell命令. 执行命令之后,可以将命令的执行结果分别通过管道赋值给标准输出和错误输出:

import subprocess

res=subprocess.Popen(r'ipconfig|findstr 192.168',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(res.stdout.read().decode('gbk'))
print(res.stderr.read().decode('gbk'))

输出结果：

   IPv4 地址 . . . . . . . . . . . . : 192.168.20.191
   默认网关. . . . . . . . . . . . . : 192.168.20.254
   IPv4 地址 . . . . . . . . . . . . : 192.168.56.1

如果发生错误，提示信息就会从stderr中输出。
在linux平台也可以使用相同的用法。
也可以使用stdin将之前的输出结果输入到当前的命令中执行，返回结果：

import subprocess

res=subprocess.Popen(r'ipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
res1=subprocess.Popen(r'findstr 192.168.20',shell=True,stdin=res.stdout,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(res1.stdout.read().decode('gbk'))

输出结果：

   IPv4 地址 . . . . . . . . . . . . : 192.168.20.191
   默认网关. . . . . . . . . . . . . : 192.168.20.254