Python常用模块一

importlib模块

具有动态导入模块功能。

import importlib

name = "time"
module = importlib.import_module(name)
print(module.time())

sys模块

有关python运行环境的变量和函数；

sys.argv：一个列表，包含脚本外部传入的参数，argv[0]为脚本名
sys.exit([arg])：退出当前程序，可指定返回值或错误信息
sys.modules：一个字典，导入的新模块，就会记录其中
sys.path：一个列表，包含模块所有搜索路径的字符串
sys.platform：一个字符串，包含当前的平台标识符
sys.version：Python解释器版本
sys.maxsize：获取最大int值，9223372036854775807
sys.stdin,sys.stdou,sys.stderr：解释器用于标准输入，输出和错误的文件对象
sys.getdefaultencoding()，sys.setdefaultencoding()，sys.getfilesystemencoding()，sys.getdefaultencoding()：获取或设置系统当前编码
sys.getrecursionlimit()，sys.setrecursionlimit(n)：获取或设置最大递归限制

os模块

访问多个操作系统服务；

os.getcwd()：获取脚本工作的目录路径；
os.chdir(dirpath)：改变脚本工作路径；
os.curdir：返回当前目录路径('.')；
os.pardir：返回当前目录的父目录('..')；
os.makedirs(dirpath)：递归创建目录；
os.removedirs(dirpath)：如果目录为空则删除，如果上级目录为空也删除，一直递归；
os.mkdir(dirpath)：创建单级目录，存在则异常；
os.rmdir(dirpath)：删除单级目录，不为空则异常；
os.listdir(dirpath)：列出指定目录下的所有文件和目录，包括隐藏文件，返回一个list；
os.remove()：删除一个文件；
os.rename(old,new)：可移动或重命名一个文件或目录，与mv相似；
os.stat(dirpath)：获取文件或目录的信息；
os.sep：操作系统特定的路径分隔符；
os.linesep：当前平台使用的行终止符；
os.pathsep：用于分割文件路径的字符串，PATH="/usr/bin/:$PATH"；
os.name：字符串返回当前使用的平台windows -> 'nt'，linux -> 'posix'；
os.system('bash')：执行指定的shell命令，返回结果；
os.environ：获取系统环境变量；
os.path模块主要用于获取文件的属性；
    os.path.abspath(path)：返回path规范化绝对路径；
    os.path.split(path)：将path分割成目录和文件名，二元组返回(''dirpath,'filename')
    os.path.dirname(path)：返回path目录的绝对路径，'dirpath'
    os.path.basename(path)：返回path最后的文件名，如果时/结尾则返回空值；'filename'
    os.path.exists(path)：如果path存在，返回True
    os.path.isabs(path)：如果path是绝对路径，返回True
    os.path.isfile(path)：如果path是一个存在的文件，返回True
    os.path.isdir(path)：如果path是一个存在的目录，返回True
    os.path.join(path1[,path2...])：将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
    os.path.join('/root/test/a','/app','python','a')　==>　'/app/python/a'
    os.path.getatime(path)：返回path所指向的文件或目录的最后存取时间
    os.path.getmtime(path)：返回path所指向的文件或目录的最后修改时间
    os.path.getsize(path)：获取path文件的大小(字节)

fileinput模块

 模块fileinput可以对一个或多个文件的内容所有行进行迭代、遍历等操作。

fileinput.input(files=None, inplace=False, backup='', bufsize=0, mode='r', openhook=None)：返回一个能够在for循环中迭代的对象；
# files：文件的路径列表；
# inplace：是否重写文件；
# backup：指定备份文件的扩展名，如.bak，如果存在该扩展名的文件，则覆盖；
# buffsize：缓冲区大小，文件过大时可修改；
# mode：读写模式，默认只读；
# openhook：打开钩子，不知道什么意思；
fileinput.filename()：返回当前文件名；
fileinput.fileno()：返回当问文件描述符
fileinput.lineno()：返回当前已经读取行的数量；
fileinput.filelineno()：返回当前读取的行号；
fileinput.isfirstline()：当前行是否为第一行；
fileinput.isstdin()：判断最后一行是否从stdin读取；
fileinput.nextfile()：关闭当前文件，便于读取下个文件，未读取的行不会加进行数计数中；文件第一行被读后此函数才会有效，就是不可以跳过某个文件；
fileinput.close()：关闭队列；

re模块

模块re提供了正则表达式支持；

.：一个任意字符，不包含换行符，DOTALL模式下包含换行符；
*：0个或任意个前一个字符；
+：1个以上前一个字符；
?：0个或1个前一个字符；
{}：自定义范围，默认贪婪模式匹配最大的
^：开头；
$：结尾；
[...]：字符集，除了(^, -, \)其余的元字符都失去特殊含义；
[^str]：除了str以外的字符，意味着取反；
\：反斜杠后面跟元字符除去特殊含义，
\\, 去掉\的特殊含义，用来匹配字符\；在re里如果匹配一个\，就需要另一个\让它去掉特殊含义，但是\在Python解释器里是转移符，所以要分别对\和\进行转义，那么就会要传入'\\\\'；如果不对\\转义，那么运行时Python解释器就认为它们是转移符，而不是字符\。也可以使用原生字符表示，r'\\'。
反斜杠后面跟普通字符实现特殊含义；
    \d, 匹配任何十进制数，[0-9]
    \D, 匹配任何非数字字符，[^0-9] 
    \s, 匹配任何空白字符，[ \t\n\r\f\v]
    \S, 匹配任何非空白字符，[^ \t\n\r\f\v]
    \w, 匹配任何字母数字字符，[a-zA-Z0-9_]
    \W, 匹配任何非字母数字字符，[^a-zA-Z0-9_]
    \b, 匹配单词和特殊字符的边界， 'I am a LI#ST'中第一个I与后面空格的边界，第二个I与#的边界都会被捕捉
|：先匹配左侧，不通过再匹配右侧；
()：分组，可以设置组名;

当一个pattern匹配字符串时，会匹配尽可能多的内容，
pattern=re.compile(r'\*\*(.+)\*\*')
re.findall(pattern,'**This** is **it**!')
['This** is **it']　　#一直匹配到最后一个\*\*

对于所有的重复运算符，都可在后面加上问号来将其指定为非贪婪的；
pattern=re.compile(r'\*\*(.+?)\*\*')
re.findall(pattern,'**This** is **a** **dog**!')
['This', 'a', 'dog']　　#只匹配到下一个\*\*

re.I(IGNORECASE)：忽略大小写
re.M(MULITELINE)：多行匹配，影响 ^ 和 $
re.S(DOTALL)：使'.'包含换行符在内的所有字符
re.U(UNICODE)：表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X(VERBOSE)：为了增加可读性，忽略空格和' # '后面的注释

re.compile(pattern[,flag])：生产一个pattern对象；flags为匹配模式；
re.match(pattern,string[,flags])：从string的起始位置匹配pattern，返回一个对象，可调用group方法获取值；如果开头没有匹配成功，返回none；
re.search(pattern,string[,flags])：匹配出满足条件的第一个结果，返回一个对象，可调用group方法获取值；
re.split((pattern,string[,max=0，flags]))：返回一个列表，包含根据pattern分割后的字符串，max最大分割次数；
re.findall(pattern,string[,flags])：返回一个列表，包含字符串中所有被匹配的子串；如果规则里有()，只返回()中匹配的内容；
re.finditer(pattern,string[,flags])：与findall一样，但返回的是一个迭代器；
re.sub(pattern,repl,string,max=0)：将staring中的匹配到的字符替换为repl，repl可为函数，max为替换最大次数，默认0为所有；

time模块

模块time能够获取修改多种格式时间；

(2018,11,20,11,8,13,1,324,0)
(tm_year=2018, tm_mon=11, tm_mday=20, tm_hour=11, tm_min=8, tm_sec=13, tm_wday=1, tm_yday=324, tm_isdst=0)；
四位年数，月，日，时，分，秒，周(0为周一)，一年的第几日，夏令时(1夏令时、0不是夏令时、-1未知)；

%y：两位年份(00-99)
%Y：四位年份(000-9999)
%m：月份(01-12)
%d：天(01-31)
%w：周(0-6)是0周一
%H：时(0-23)
%M：分(0-59)
%S：秒(0-59)
%x：本地相应的日期表示
%X：本地相应的时间表示
%a：本地简化星期名称
%b：本地简化的月份名称
%Z：当前时区的名称

time.sleep(secs)：sleep；
time.time()：返回当前系统时间戳，1542691945.7587576；
time.ctime([secs])：将时间戳转换为可读时间，无参时返回当前系统时间，'Tue Nov 20 13:32:25 2018'；
time.localtime([secs])：转换为当地时间下的元组时间，无参时返回当前系统时间，time.struct_time(tm_year=2018, tm_mon=11, tm_mday=20, tm_hour=13, tm_min=32, tm_sec=25, tm_wday=1, tm_yday=324, tm_isdst=0)；
time.gmtime([secs])：转换为格林威治天文时间下的元组时间，无参时返回当前系统时间，time.struct_time(tm_year=2018, tm_mon=11, tm_mday=20, tm_hour=5, tm_min=32, tm_sec=25, tm_wday=1, tm_yday=324, tm_isdst=0)；
time.mktime(tupletime)：将元组时间转换为时间戳，
time.asctime([tupletime])：接受元组时间返回可读形式时间，
time.strftime(fmt[,tupletime])：将元组时间转换为指定格式的当地时间，strftime("%Y-%m-%d %H:%M:%S",time.localtime());
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')：与strftime相反，根据指定格式将字符串时间转换为tupletime，strptime("30 Nov 00", "%d %b %y")

random模块

模块random包含生产伪随机数的函数，有助于编写模拟程序或生成随机输出的程序；

random.random()：返回一个0~1（含）的随机实数；
random.uniform(a,b)：返回一个a~b（含）的随机实数；
random.randint(a,b)：返回一个a~b（含）的随机整数；
random.randrange([start,]stop[,step])：从range(start, stop, step)中随机选择一个数；
random.choice(seq)：从序列seq中随机选择一个；
random.shuffle(seq,[random])：打乱序列，洗牌；
random.sample(seq,n)：从制定的序列中随机选择n个元素；

hashlib模块

hashlib模块为一些消息摘要算法(algorithm)提供了公共接口，如MD5, SHA1, SHA224, SHA256, SHA384和SHA512。加密过程是不可逆的。

MD5是最常见的摘要算法，速度很快，生成一个128bit的散列值(hash value)，通常用一个32位的16进制字符串表示。

　　如果想对一个明文进行加密，首先要定义一个md5类型的加密器对象，打印加密器可以看到是一个md5 hash object，然后调用update方法加密明文；通过调用hexdigest()方法可以获取加密密文，是一个十六进制的32位字符串。

import hashlib
 
encryption = hashlib.md5()
encryption.update('hello '.encode('utf8'))
encryption.update('world!'.encode('utf8'))
print(encryption.hexdigest())
 
#运行结果
fc3ff98e8c6a0d3087d515c0473f8677

pickle模块

可以通过tumps和loads方法对数据进行操作，序列化后的数据为bytes类型，反序列化后的数据为str类型。

import pickle

user_info = {'name': 'Alice', 'age': 28}
# 序列化
bytes_data = pickle.dumps(user_info)
print(bytes_data)  #b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00Aliceq\x02X\x03\x00\x00\x00ageq\x03K\x1cu.'
# 反序列化
str_data = pickle.loads(bytes_data)
print(str_data)  #{'name': 'Alice', 'age': 28}

import pickle

class Person():
    def __init__(self, name):
        self.name = name

    def talk(self):
        print('i am %s' % self.name)

p = Person('Alice')
with open('pickle.txt', 'wb') as f:
    bytes_data = pickle.dump(p, f)

with open('pickle.txt', 'rb') as f:
    str_data = pickle.load(f)
    str_data.talk() #i am Alice

json模块

pickle可以很方便地序列化所有对象。不过json作为更为标准的格式，具有更好的可读性（pickle是二进制数据）和跨平台性。

import json

user_info = {'name': 'Alice', 'age':28, 'job': ['IT','Teacter']}

bytes_data = json.dumps(user_info)
print(bytes_data)    #{"name": "Alice", "age": 28, "job": ["IT", "Teacter"]}

str_data = json.loads(bytes_data)
print(str_data)    #{'name': 'Alice', 'age': 28, 'job': ['IT', 'Teacter']}

json只能实例化python的基础数据类型，一些复杂的数据类型需要手动处理。可以自定义处理类；

# 引入django中form验证错误的数据类型ValidationError
from django.core.exceptions import ValidationError
# 定义一个json数据转换的类
class FormJson(json.JSONEncoder):
    # 定义default转换函数
    def default(self, obj):
        # 如果数据是这种类型，那么就按照下面格式输出
        # 这里可以自定义一些特殊数据类型的处理方式
        if isinstance(obj, ValidationError):
            return {'code': obj.code, 'message': obj.message}
        else:
            # 其他的类型都还是按照json默认的方式处理
            return json.JSONEncoder.default(self, obj)

shelve模块

shelve是python中用来持久化存储的模块，类似于一个key-value的数据库，key必须时str类型，value可以是python中任意的数据类型，也可以是自己定义的数据类型。

import shelve

age = 28
job_list = ['IT', 'Teacher']

def run(name):
    print('name: %s' % name)

with shelve.open('shelve') as f:
    f['run'] = run
    f['age'] = age
    f['job'] = job_list

with shelve.open('shelve') as f:
    foo = f['run']
    num = f['age']
    l = f['job']
    foo('Alice')  #name: Alice
    print(num)  #28
    print(l)  #['IT', 'Teacher']

ConfigParser模块

此模块提供ConfigParser实现基本配置语言的类，生成和修改常见配置文档；格式如下:

[DEFAULT]
log = debug
state = alive

[mysql]
db_user = root
db_pass = 123

[time]
zone = Asia/Shanghai

import configparser
 
# 实例化一个解析器
conf_file = configparser.ConfigParser()
# 添加数据
conf_file['DEFAULT'] = {'log':'debug','state':'alive'}
conf_file['mysql'] = {'db_user':'root','db_pass':123}
conf_file['time'] = {'zone':'Asia/Shanghai'}
 
# 将解析器处理过的内容写入文件
with open('system.conf','w') as f:
    conf_file.write(f)

import configparser
 
# 实例化一个解析器
conf_file = configparser.ConfigParser()
# 解析器读取到文件
conf_file.read('system.conf',encoding='utf8')
# 返回[deflaut]范围的字典
default = conf_file.defaults()
print(default)
# 返回sections的一个列表，deflaut不会被返回
sections = conf_file.sections()
print(sections)
# 返回指定section中option的列表，包含DEFAULT中的option
options = conf_file.options('mysql')
print(options)
# 返回具体option的值
mysql_user = conf_file.get('mysql', 'db_user')
print(mysql_user)
mysql_passwd = conf_file['mysql']['db_pass']
print(mysql_passwd)
 
#运行结果
OrderedDict([('log', 'debug'), ('state', 'alive')])
['mysql', 'time']
['db_user', 'db_pass', 'log', 'state']
root
123

import configparser
 
conf_file = configparser.ConfigParser()
conf_file.read('system.conf')
# 重新设置section中option的值
conf_file.set('mysql', 'db_pass', 'abc123')
# 删除整个section
conf_file.has_section('time')   #True
conf_file.remove_section('time')
# 删除指定的option
conf_file.has_option('mysql', 'db_user')    #True
conf_file.remove_option('mysql', 'db_user')
 
# 将变动重新写入文件
conf_file.write(open('system.conf', 'w'))

logging模块

logging模块定义了为应用程序和库实现灵活事件日志记录系统的函数和类。

日志级别：logging默认WARNING

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

logging模块级函数：

　　下面是通过模块中的函数打印日志，在终端上显示。并且root logger默认是WARNING日志级别，所以只打印出WARNING级别以上的日志信息。

import logging
 
logging.debug('DEBUG LOG')
logging.info('INFO LOG')
logging.warning('WARNING LOG')
logging.error('ERROR LOG')
logging.critical('CRITICAL LOG')
 
logging.log(logging.CRITICAL,'CRITICAL LOG')
logging.log(40,'level 40 LOG')    #可以使用日志等级数
 
#运行结果
#由于logging默认为warning级别，所以debug, info不会被打印
WARNING:root:WARNING LOG
ERROR:root:ERROR LOG
CRITICAL:root:CRITICAL LOG
 
CRITICAL:root:CRITICAL LOG
ERROR:root:level 40 LOG

basicConfig(**kw)方法通过StreamHandler使用默认值创建Formatter并将其添加到根记录器来为日志记录系统执行基本配置。

• filename: 指定使用指定的文件名创建FileHandler。
• filemode: 如果指定了filename，通过此模式打开文件，默认为'a'。
• format: 指定处理日志信息的字符串格式。
• datefmt: 指定日期时间格式，使用元组时间格式。
• level: 指定日志级别。
• stream: 指定一个stream初始化StreamHandler，与filenam不相容。
• handlers: 指定一个Handler

import logging
 
logging.basicConfig(
    filename='file.log',
    filemode='a',
    format='%(asctime)s %(filename)s %(name)s %(levelno)s %(message)s',
    datefmt="%Y-%m-%d %H:%M:%S %p",
    level=10
)
 
logging.debug('DEBUG LOG')
logging.error('ERROR LOG')
 
#运行结果
#会在同级目录下生成文件‘file.log’，并以追加模式写入两行debug、error日志
2019-04-30 17:44:29 PM model_logging.py root 10 DEBUG LOG
2019-04-30 17:44:29 PM model_logging.py root 40 ERROR LOG

Logger Objects

　　记录器公开应用程序代码直接使用的接口；’Logger永远不会直接实例化，而是始终通过模块级函数实例化logging.getLogger(name)。

Headler Objects

　　处理程序将日志记录（由记录器创建）发送到适当的目标(文件、终端)；Handler永远不会直接实例化，只是充当FileHandler文件处理和StreamHandler流处理等类的父类。

Formatter Objects

　　指定最终输出中日志记录的布局；如果未提供，则使用默认值'%(message)s'，该值仅包括日志记录调用中的消息。

Filter Objects

　　过滤器提供了更精细的设施，用于确定要输出的日志记录；Filters可以用于Handlers和Loggers更复杂的过滤，而不是由级别提供。

一个日志处理系统可以由以上四个基本类构建成，并且能够对显示方式、过滤规则、日志格式自定义设置。

import logging
 
# 生成一个logger日志记录器
logger = logging.getLogger()
# 实例化一个文件处理器和流处理器
fileHandler = logging.FileHandler('system.log',mode='w')    #默认模式为'a'
stremHandler = logging.StreamHandler()
# 实例化一个格式化器，并指定了一定的格式，username为自定义参数
formatter = logging.Formatter('%(asctime)s %(filename)s %(username)s %(levelname)s: %(message)s')
# 为处理器设置Formatter的格式
fileHandler.setFormatter(formatter)
stremHandler.setFormatter(formatter)
# 将处理器添加至logger记录器里
logger.addHandler(fileHandler)
logger.addHandler(stremHandler)
# 为logger记录器设置日志级别
logger.setLevel(logging.INFO)
# 此时logger记录器就拥有了两个自定义的处理器，并且两个处理器还指定了固定的格式
 
#格式化中自定义了参数，执行时需添加参数
logger.debug('debug-log', extra={'username': 'root'})
logger.info('info-log', extra={'username': 'root'})
logger.warning('warning-log', extra={'username': 'admin'})
logger.error('error-log', extra={'username': 'admin'})
logger.critical('critical-log', extra={'username': 'admin'})
 
#运行结果
2019-05-09 15:19:08,355 model_logging.py root INFO: info-log
2019-05-09 15:19:08,355 model_logging.py root WARNING: warning-log
2019-05-09 15:19:08,355 model_logging.py admin ERROR: error-log
2019-05-09 15:19:08,355 model_logging.py admin CRITICAL: critical-log