python之路5：常用模块

1. 模块简介
2. time & datetime模块
3. random
4. os
5. sys
6. shutil
7. json & pickle
8. shelve
9. xml处理
10. configparser
11. hashlib
12. subprocess
13. logging模块
14. re正则表达式

模块简介：

模块，是用一堆代码实现了某个功能的代码集合，n个.py文件组成的代码集合就称为模块。

模块分为三种：

• 自定义模块（自己手动编写的python代码文件）
• 内置标准模块（又称标准库）
• 开源模块

导入模块有以下几种方法：

import module #执行module.py文件的所有代码
import packages #执行packages目录下__init__.py下的代码
from module import test #从module.py文件只导入test方法
from module import test as t #从module.py文件只导入test方法并改名为t
from module import * #从module.py文件导入所有方法，如果有跟它同名的函数会被其覆盖，慎用

导入模块其实就是告诉Python解释器去解释那个py文件

• 导入一个py文件，解释器解释该py文件
• 导入一个包，解释器解释该包下的 __init__.py 文件

 

安装模块有以下两种方式：

1，使用系统命令：pip install

2，编译安装源代码包

编译源码    python setup.py build
安装源码    python setup.py install

time & datetime模块

时间相关的操作，时间有三种表示方式：

• 时间戳               1970年1月1日之后的秒，即：time.time()
• 格式化的字符串    2014-11-11 11:11，    即：time.strftime('%Y-%m-%d')
• 结构化时间          元组包含了：年、日、星期等... time.struct_time    即：time.localtime()

import time
import datetime
print(time.gmtime())#返回utc时间的struc时间对象格式
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))#将utc struct_time格式转成指定的字符串格式
#time.sleep(1)
print(time.localtime())
print(time.process_time())#测量处理器运算时间
print(time.asctime())#返回时间格式如“Sun Apr  1 17:18:24 2018”
print(time.ctime())#返回时间格式如“Sun Apr  1 17:18:24 2018”
string_2_struct = time.strptime("2018/04/11","%Y/%m/%d")#将日期字符串转成struct时间对象格式
print(string_2_struct)

print(datetime.datetime.now())#返回时间格式 2018-04-01 17:28:23.644249
print(datetime.date.fromtimestamp(time.time()))#时间戳直接转成日期格式 2018-04-01
print(datetime.datetime.now() + datetime.timedelta(1))#当前时间+1天
print(datetime.datetime.now() + datetime.timedelta(-1))#当前时间-1天
print(datetime.datetime.now() + datetime.timedelta(hours=1))#当前时间+1小时
print(datetime.datetime.now() + datetime.timedelta(minutes=10),'\n')#当前时间+10分
c_time = datetime.datetime.now()
print(c_time.replace(minute=1,hour=3))#时间替换,把小时改为3，分钟改为1。

 

 

 

random模块

随机验证码实例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'lvlibing'

import random
checkcode = ''

for i in range(6):
    current = random.randrange(1,6)
    if current == i:
        tmp = chr(random.randint(65,90))
    else:
        tmp = random.randint(0,9)
    checkcode+=str(tmp)

print(checkcode)

OS模块

提供对操作系统进行调用的接口

sys模块

用于提供对解释器相关的操作

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'lvlibing'

import os
import sys

print(os.getcwd())#获取当前工作目录，即当前python脚本工作的目录路径
print(os.curdir)#返回当前目录: '.'
print(os.pardir)#获取当前目录的父目录字符串名：'..'
# os.chdir("dirname")#改变当前脚本工作目录
os.makedirs('J:\\test\\a\\b\\c\\d')#可递归生成多层目录
os.removedirs('J:\\test\\a\\b\\c\\d')#若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(r'J:\test\1')#生成单级目录
os.rmdir(r'j:\test\1')#删除单级空目录，若目录不为空则无法删除
print(os.listdir(r'j:\test'))#列出指定目录下的所有文件和子目录，包括隐藏文件
#os.remove(r'j:\test\test.txt')#删除一个文件
#os.rename('oldname','newname')#重命名文件/目录
print(os.stat(r'j:\test'))#获取文件/目录信息
print(os.name)#输出字符串指示当前使用平台
os.system('ipconfig')
print(os.environ)#获取系统环境变量
os.path.abspath(r'j:\test\test.txt')#返回文件的绝对路径
os.path.split(r'j:\test\test.txt')#将path分割成目录和文件名二元组返回
os.path.dirname(r'j:\test\test.txt')#返回目录名
os.path.basename(r'j:\test\test.txt')#返回文件名
os.path.exists(r'j:\test\test.txt')#如果存在，返回True；如果不存在，返回False
os.path.isfile(r'j:\test\test.txt')
print(os.path.isdir(r'j:\test'))
print(os.path.getatime(r'j:\test'))
print(os.path.getctime(r'j:\test'))
print(os.path.getmtime(r'j:\test'))
print(os.system('dir'))#运行dos命令，直接显示结果

print(sys.argv)#命令行参数List，第一个元素是程序本身路径
print(sys.exit(n))#退出程序，默认正常退出时exit(0)

shutil 模块

提供对文件、文件夹、压缩包处理

shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中，可以部分内容

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

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

shutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copy(src, dst)
拷贝文件和权限

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

shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件

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

shutil.move(src, dst)
递归的去移动文件

shutil.ignore_patterns(*patterns)

匹配模式到的文件忽略拷贝

json & pickle 模块

用于序列化的两个模块

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__ = 'lvlibing'

import pickle
import json

data = {'k1':'123','k2':'hello','k3':'你好'}
p_str1 = pickle.dumps(data)#将数据通过特殊的形式转换为只有python语言认识的字符串
p_str2 = json.dumps(data)#将数据通过特殊的形式转换为所有语言认识的字符串，只支持字符串、列表、字典类型转换
print(p_str1)
print(p_str2)

with open('data.pickle', 'wb') as f:
    pickle.dump(data,f)#将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件

#pickle.load(f)#恢复

if __name__ == '__main__':#只在程序本身被使用的时候运行
    with open('data.json', 'w') as fp:
       json.dump(data,fp)#将数据通过特殊的形式转换为所有语言认识的字符串，只支持字符串、列表、字典类型转换，并写入文件

#json.load(fp)#恢复

 

shelve 模块

shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

# -*- coding:utf-8 -*-
__author__ = 'BillyLV'

import shelve
import datetime

d = shelve.open('shelve_test')  # 打开一个文件

l1 = ["alex", "jack", "test"]
d1 = {'name':'lv','job':'it'}
d["list"] = l1  # 持久化列表
d["dict"] = d1 # 持久化字典
d['dtime'] = datetime.datetime.now()#持久化当前时间

print(d.get('list'))#获取l1列表信息
print(d.get('dict'))#获取d1字典信息
print(d.get('dtime'))

d.close()

xml处理模块

xml是实现不同语言或程序之间进行数据交换的协议，xml协议在各个语言里的都是支持的。

<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year updated="yes">2013</year>
        <gdppc>13600</gdppc>
        <neighbor direction="W" name="Costa Rica" />
        <neighbor direction="E" name="Colombia" />
    </country>
</data>

# -*- coding:utf-8 -*-
__author__ = 'BillyLV'

import xml.etree.ElementTree as ET

tree = ET.parse('xmltest.xml')
root = tree.getroot()
print(root.tag,'\n')

#遍历xml文档
for child in root:
    print(child.tag,child.attrib)
    for i in child:
        print(i.tag,i.text,'\n')

#只遍历year 节点
for node in root.iter('year'):
    print(node.tag, node.text)

#修改
for sec_node in root.iter('year'):
    new_year = int(sec_node.text) + 1
    node.text = str(new_year)
    node.set('updated','yes')

tree.write('xmltest.xml')

#删除
for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        root.remove(country)

tree.write('output.xml')

#创建xml文档
new_xml = ET.Element('namelist')
name = ET.SubElement(new_xml,'name',attrib={'encrolled':'no'})
sex = ET.SubElement(name,'age',attrib={'checked':'no'})
sex.text = '29'
name2 = ET.SubElement(new_xml,'name',attrib={'encrolled':'yes'})
age = ET.SubElement(name2,'age')
age.text = '18'
et = ET.ElementTree(new_xml)
et.write('test.xml',encoding='utf-8',xml_declaration=True)
ET.dump(new_xml)

 

ConfigParser模块

用于生成和修改常见配置文档

import configparser

config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9'}

config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'  # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
    config.write(configfile)
config.sections()
config.read('example.ini')
config.sections()

hashlib模块　

用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

hmac 模块

它内部对我们创建 key 和 内容 再进行处理然后再加密

import hashlib,hmac

hash = hashlib.sha512()
hash.update(b'admin')
print(hash.hexdigest())

m = hashlib.md5(b'sdfa23ds14')
m.update(b"Hello")
m.update(b"It's me")
print(m.hexdigest())#16进制格式
m.update(b"It's been a long time since last time we ...")
print(m.digest())#2进制格式

mac = hmac.new(b'dqqq33f')
mac.update(b"Enhanced")
print(mac.hexdigest())

Subprocess模块 

用于执行系统命令

可用参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
  所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
• shell：同上
• cwd：用于设置子进程的当前目录
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
• startupinfo与createionflags只在windows下有效
  将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

terminate() 杀掉所启动进程
communicate() 等待任务结束

 

logging模块

用于便捷记录日志且线程安全的模块

logging的日志可以分为 debug < info < warn(warning) < error < critical(fatal)5个级别，只有大于或等于当前日志级别的操作才会被记录。

# -*- coding:utf-8 -*-
__author__ = 'BillyLV'

import logging

logging.warning("user [lv] attempted wrong password more than 3 times")
logging.critical("server is down")

# 高于或等于INFO级别的才会输出
logging.basicConfig(filename='example.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

# 带时间格式
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)

formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)

logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")

re模块

用于对python的正则表达式的操作。

字符：

　　. 匹配除换行符以外的任意字符
　　\w 匹配字母或数字或下划线或汉字
　　\s 匹配任意的空白符
　　\d 匹配数字
　　\b 匹配单词的开始或结束
　　^ 匹配字符串的开始
　　$ 匹配字符串的结束

次数：

　　* 重复零次或更多次
　　+ 重复一次或更多次
　　? 重复零次或一次
　　{n} 重复n次
　　{n,} 重复至少n次
　　{n,m} 重复n到m次

re.match 从起始位置开始根据模型去字符串中匹配指定内容，匹配单个

re.search 根据模型去字符串中匹配指定内容，匹配单个

re.findall 匹配字符串中所有符合条件的元素

re.splitall 以匹配到的字符当做列表分隔符

re.sub     匹配字符并替换

反斜杠：

匹配一个数字的"\\d"可以写成r"\d"

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）

M(MULTILINE): 多行模式，改变'^'和'$'的行为

S(DOTALL): 点任意匹配模式，改变'.'的行为

# -*- coding:utf-8 -*-
__author__ = 'BillyLV'

import re

print(re.findall("ab*","cabb3abcbbac"))
print(re.findall("ab+","ab+cd+abb+bba"))
a = re.search("abc|ABC","ABCBabcCD").group()
print(a)
b = re.search("(abc){2}a(123|456)c", "abcabca123c").group()
print(b)
print(re.search("^al","alexabc"))
#分组匹配
c=re.search("(?P<province>[0-9]{3})(?P<city>[0-9]{3})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")
print(c)

　　

参考： 

http://www.cnblogs.com/alex3714

http://www.cnblogs.com/wupeiqi

internet＆python books

PS:如侵权，联我删。