本随笔内容大部分来源自：http://www.cnblogs.com/yuanchenqi/articles/5732581.html
模块和包
一、模块
1、什么是模块
在python中，是一种组织函数的方式（将类似功能和函数放在一起），一个.py文件就称为一个模块（Module）
2、模块的好处
- 最大的好处是大大提高了代码的可维护性。
- 编写代码不用从零开始。可以对已存在模块进行引用。
3、模块的来源
- python标准库
- 第三方模块
- 应用程序自定义模块
4、模块导入方法
（1）import 模块1, 模块2， eg. import cal1, cal2
- import模块等于将模块内所有代码解释一遍并付给模块名(cal1，cal2)。多个模块，用逗号隔开。
- 如果调用模块中的函数（变量），需要用“模块名.函数名（变量）”来调用。
（2）from 模块名 import 函数 （变量）1,函数（变量）2,....， eg. from cal import add, sub
- 这种方式只调用模块中指定的函数（变量），如果有多个函数（变量），用逗号隔开。
- 这种方式不需要“模块名.函数名”这种方式调用，直接写函数名即可。eg. print(add(1, 2))
（3）form 模块名 import *（此方式不建议用）
- 将模块下的所有内容引入
- 这样可以直接使用模块下的函数名（变量），无需用“模块名.函数名”方式。
- 注：如果引用模块与当前模块函数名（变量名）相同时，则调用离调用最近的函数（变量）。
（4）别名方式调用：from 模块名 import 函数（变量） as 别名，eg. from cla import add as fun1
- 这种方式调用函数必须使用别名来调用。eg.print(fun1)
二、包
1、什么是包
为了按目录来组织模块，含__init__.py的目录就是包。
2、包的引用
（1）引用包下的模块
eg.from web.web2 import cal，这个意思import本路径下web包下的web2包下的cal模块。
（2）引用包下的模块下的函数（变量）
eg.from web.web2.cal import logger，这个意思import本路径下web包下的web2包下的cal模块下的logger函数。
3、__init__.py用途
import一个包，将执行包下面的__init__.py内代码。
关于项目路径的引入
一、__file__变量
相对目前环境（当前运行的py）的相对路径。
二、os模块下的abspath()获取绝对路径
os.path.abspath(__file__)
三、os模块下的dirname()获取当前文件的所在目录绝对路径
os.path.dirname(os.path.abspath(__file__))
四、BASE_DIR，通过两次dirname()获取项目目录的绝对路径
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
五、sys.path.append(BASE_DIR)，将BASE_DIR即项目根路径添加到python解释器的环境变量路径中
if "__name__" == "__main__": 的作用
一、作用
模块内部测试使用，其他模块引用时，不会被执行。
二、__name__变量说明
调用不同显示值不同：
- 在本模块调用时，__name__的值为“__main__”
- 在其他模块调用时，__name__的值为__name__所在模块的名字。
smod.py---sys模块(跟python解释器交互)
import sys print(sys.path) # 打印环境变量 print(sys.argv) # 显示py文件相对路径 print(sys.argv[2]) # 显示第三个参数 需要命令行运行： python smod.py 1 2 3 结果将显示： C:\\WINDOWS\\system32\\python34.zip', 'C:\\Python34\。。。 ['smod.py', '1', '2', '3', '4', '5'] 2
sys.argv 命令行参数List，第一个元素是程序本身路径 sys.exit(n) 退出程序，正常退出时exit(0) sys.version 获取Python解释程序的版本信息 sys.maxint 最大的Int值 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.path.append('path') 增加模块搜索路径。 sys.platform 返回操作系统平台名称 sys.stdout.write('please:') val = sys.stdin.readline()[:-1]
omod.py---os模块（和系统进行交互）
import os a = os.system("dir") print(a) # 输出的是0，而不是命令结果 b = os.popen("dir") print(b) # 输出的是内存地址 print(b.read()) # 输出命令实际结果
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下为"\r\n",mac下为"\r"，Linux下为"\n" os.pathsep 输出用于分割文件路径的字符串，linux为":",win下为"；" 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所指向的文件或者目录的最后修改时间
time模块
- python三种表达时间的方式：
（1）时间戳：
时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至指定时间的总秒数，eg.1508829061.9984064
（2）结构化时间：
以元组方式表达，eg.time.struct_time(tm_year=2017, tm_mon=10, tm_mday=24, tm_hour=7, tm_min=11, tm_sec=6, tm_wday=1, tm_yday=297, tm_isdst=0)，其中tm_wday是周中的第几天，从周一开始（周一是0），其中tm_yday今年过了多少天。
（3）自定义格式时间字符串：
eg.'2017-10-24 15:00:47'
- time模块方法介绍：
import time print(help(time)) # 显示帮助 print(time.time()) # 显示时间戳 time.sleep(5) # 程序休眠时间，单位秒 print(time.clock()) # cpu计算花费时间
print(time.gmtime()) # 显示结构化时间（默认未英国格林威治时间UTC），中国在东八区需要加8个小时 ''' 显示结果： time.struct_time(tm_year=2017, tm_mon=10, tm_mday=23, tm_hour=1, tm_min=40, tm_sec=42, tm_wday=0, tm_yday=296, tm_isdst=0) 其中tm_wday是周中的第几天，从周一开始（周一是0），其中tm_yday今年过了多少天 '''
print(time.localtime()) # 显示本地结构化时间
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())) # 自定义格式时间字符串，第一参数是自定义格式，第二个参数是表示时间的元组 ''' 显示结果： 2017-10-24 15:00:47 '''
print(time.strptime('2017-10-24 15:00:47', '%Y-%m-%d %H:%M:%S')) # 将指定格式的时间字符串，转换成元组即结构化时间 ''' 显示结果： time.struct_time(tm_year=2017, tm_mon=10, tm_mday=24, tm_hour=15, tm_min=0, tm_sec=47, tm_wday=1, tm_yday=297, tm_isdst=-1) '''
# 获取结构化时间中的元素方法 a = time.strptime('2017-10-24 15:00:47', '%Y-%m-%d %H:%M:%S') print(a.tm_wday) # 获取指定结构化时间中的tm_wday值，即周2 ''' 显示结果： 1 '''
print(time.ctime()) # 输出固定格式时间字符串，可传时间戳参数 ''' 显示结果： Tue Oct 24 15:40:41 2017 '''
print(time.mktime(time.localtime())) # 将结构化时间转换成时间戳 ''' 显示结果： 1508831151.0 '''
datetime模块
import datetime print(datetime.datetime.now()) # 显示固定格式时间字符串 ''' 显示结果： 2017-10-24 15:52:58.471340 '''
random模块
import random # 随机输出0-1之间的浮点数 print(random.random()) ''' 显示结果： 0.3004628089708309 '''
# 随机输出指定范围的随机整数，范围包括范围参数本身 print(random.randint(1, 8)) ''' 显示结果： 7 '''
# 随机输出指定范围的随机数，范围不包括第二参数 print(random.randrange(1, 3)) ''' 显示结果： 2 '''
# 随机输出指定序列中元素 print(random.choice('abcde')) print(random.choice(['abc', 4, ['AM', 2]])) ''' 显示结果： e ['AM', 2] '''
# 打乱指定序列元素位置，并输出指定数量元素的新序列 print(random.sample([1, 2, ['a', 'b'], [4], ['TT']], 2)) ''' 显示结果： [[4], ['a', 'b']] '''
# 随机生成序列号例子 code = '' for i in range(5): add = random.choice([random.randrange(10), chr(random.randrange(65, 91))]) # 从字母和数字组成的序列里选择，chr是ascii码转字符函数 code += str(add) print(code) ''' 显示结果： S7I3P '''
hashlib模块
import hashlib m = hashlib.md5() # 生成MD5对象 print(m) # 输出对象地址 m.update('hello world'.encode('utf-8')) # 转换成MD5，update只接受二进制参数，所以需要将unicode进行utf8编码 print(m.hexdigest()) # 对MD5进行十六进制获取，其中hexdigest中的hex表示十六进制 m.update('sy'.encode('utf-8')) # 对原m再次进行MD5转换 print(m.hexdigest()) # 显示新MD5十六进制显示 m2 = hashlib.md5() m2.update('hello worldsy'.encode('utf-8')) # m2是讲字符串hello world和sy进行了拼接 print(m2.hexdigest()) # 显示结果和m再次进行转换相同，即拼接后的MD5 ''' 显示结果： <md5 HASH object @ 0x0000000001DED3A0> 5eb63bbbe01eeed093cb22bb8f5acdc3 08e31f8a7ac62ba13fdd62045deea7f5 08e31f8a7ac62ba13fdd62045deea7f5 '''
sha = hashlib.sha256() # 生成sha256对象，比MD5更安全，算法更复杂。 sha.update('hello world'.encode('utf-8')) print(sha.hexdigest()) ''' 显示结果： b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9 '''
logging模块
一、简单应用
import logging logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message')
输出：
WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message
可见，默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET），默认的日志格式为日志级别：Logger名称：用户输出消息。
二 灵活配置日志级别，日志格式，输出位置
import logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', datefmt='%a, %d %b %Y %H:%M:%S', filename='/tmp/test.log', filemode='w') logging.debug('debug message') logging.info('info message') logging.warning('warning message') logging.error('error message') logging.critical('critical message')
输出：
cat /tmp/test.log
Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message
可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open('test.log','w'))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息
三、logger对象
上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）
先看一个最简单的过程：
import logging logger = logging.getLogger() # 创建一个handler，用于写入日志文件 fh = logging.FileHandler('test.log') # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 logger.addHandler(ch) logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message')
先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式
1、简介
Logger是一个树形层级结构，输出信息之前都要获得一个Logger（如果没有显示的获取则自动创建并使用root Logger，如第一个例子所示）。
logger = logging.getLogger()返回一个默认的Logger也即root Logger，并应用默认的日志级别、Handler和Formatter设置。
当然也可以通过Logger.setLevel(lel)指定最低的日志级别，可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。
logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical messa
只输出了
2014-05-06 12:54:43,222 - root - WARNING - logger warning message
2014-05-06 12:54:43,223 - root - ERROR - logger error message
2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message
从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别，所以使用默认的日志级别WARNIING，故结果只输出了大于等于WARNIING级别的信息。
2、如果我们再创建两个logger对象：
################################################## logger1 = logging.getLogger('mylogger') logger1.setLevel(logging.DEBUG) logger2 = logging.getLogger('mylogger') logger2.setLevel(logging.INFO) logger1.addHandler(fh) logger1.addHandler(ch) logger2.addHandler(fh) logger2.addHandler(ch) logger1.debug('logger1 debug message') logger1.info('logger1 info message') logger1.warning('logger1 warning message') logger1.error('logger1 error message') logger1.critical('logger1 critical message') logger2.debug('logger2 debug message') logger2.info('logger2 info message') logger2.warning('logger2 warning message') logger2.error('logger2 error message') logger2.critical('logger2 critical message')
################################################## logger1 = logging.getLogger('mylogger') logger1.setLevel(logging.DEBUG) logger2 = logging.getLogger('mylogger') logger2.setLevel(logging.INFO) logger1.addHandler(fh) logger1.addHandler(ch) logger2.addHandler(fh) logger2.addHandler(ch) logger1.debug('logger1 debug message') logger1.info('logger1 info message') logger1.warning('logger1 warning message') logger1.error('logger1 error message') logger1.critical('logger1 critical message') logger2.debug('logger2 debug message') logger2.info('logger2 info message') logger2.warning('logger2 warning message') logger2.error('logger2 error message') logger2.critical('logger2 critical message')
结果：
这里有两个个问题：
<1>我们明明通过logger1.setLevel(logging.DEBUG)将logger1的日志级别设置为了DEBUG，为何显示的时候没有显示出DEBUG级别的日志信息，而是从INFO级别的日志开始显示呢？
原来logger1和logger2对应的是同一个Logger实例，只要logging.getLogger（name）中名称参数name相同则返回的Logger实例就是同一个，且仅有一个，也即name与Logger实例一一对应。在logger2实例中通过logger2.setLevel(logging.INFO)设置mylogger的日志级别为logging.INFO，所以最后logger1的输出遵从了后来设置的日志级别。
<2>为什么logger1、logger2对应的每个输出分别显示两次?
这是因为我们通过logger = logging.getLogger()显示的创建了root Logger，而logger1 = logging.getLogger('mylogger')创建了root Logger的孩子(root.)mylogger,logger2同样。而孩子,孙子，重孙……既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。
ok,那么现在我们把
# logger.addHandler(fh)
# logger.addHandler(ch) 注释掉，我们再来看效果：
因为我们注释了logger对象显示的位置，所以才用了默认方式，即标准输出方式。因为它的父级没有设置文件显示方式，所以在这里只打印了一次。
孩子,孙子，重孙……可逐层继承来自祖先的日志级别、Handler、Filter设置，也可以通过Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。设置自己特别的日志级别、Handler、Filter。若不设置则使用继承来的值。
<3>Filter
限制只有满足过滤规则的日志才会输出。
比如我们定义了filter = logging.Filter('a.b.c'),并将这个Filter添加到了一个Handler上，则使用该Handler的Logger中只有名字带 a.b.c前缀的Logger才能输出其日志。
filter = logging.Filter('mylogger')
logger.addFilter(filter)
这是只对logger这个对象进行筛选
如果想对所有的对象进行筛选，则：
filter = logging.Filter('mylogger')
fh.addFilter(filter)
ch.addFilter(filter)
这样，所有添加fh或者ch的logger对象都会进行筛选。
完整代码1：
import logging logger = logging.getLogger() # 创建一个handler，用于写入日志文件 fh = logging.FileHandler('test.log') # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) # 定义一个filter filter = logging.Filter('mylogger') fh.addFilter(filter) ch.addFilter(filter) # logger.addFilter(filter) logger.addHandler(fh) logger.addHandler(ch) logger.setLevel(logging.DEBUG) logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message') ################################################## logger1 = logging.getLogger('mylogger') logger1.setLevel(logging.DEBUG) logger2 = logging.getLogger('mylogger') logger2.setLevel(logging.INFO) logger1.addHandler(fh) logger1.addHandler(ch) logger2.addHandler(fh) logger2.addHandler(ch) logger1.debug('logger1 debug message') logger1.info('logger1 info message') logger1.warning('logger1 warning message') logger1.error('logger1 error message') logger1.critical('logger1 critical message') logger2.debug('logger2 debug message') logger2.info('logger2 info message') logger2.warning('logger2 warning message') logger2.error('logger2 error message') logger2.critical('logger2 critical message')
完整代码2：
#coding:utf-8 import logging # 创建一个logger logger = logging.getLogger() logger1 = logging.getLogger('mylogger') logger1.setLevel(logging.DEBUG) logger2 = logging.getLogger('mylogger') logger2.setLevel(logging.INFO) logger3 = logging.getLogger('mylogger.child1') logger3.setLevel(logging.WARNING) logger4 = logging.getLogger('mylogger.child1.child2') logger4.setLevel(logging.DEBUG) logger5 = logging.getLogger('mylogger.child1.child2.child3') logger5.setLevel(logging.DEBUG) # 创建一个handler，用于写入日志文件 fh = logging.FileHandler('/tmp/test.log') # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() # 定义handler的输出格式formatter formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) #定义一个filter #filter = logging.Filter('mylogger.child1.child2') #fh.addFilter(filter) # 给logger添加handler #logger.addFilter(filter) logger.addHandler(fh) logger.addHandler(ch) #logger1.addFilter(filter) logger1.addHandler(fh) logger1.addHandler(ch) logger2.addHandler(fh) logger2.addHandler(ch) #logger3.addFilter(filter) logger3.addHandler(fh) logger3.addHandler(ch) #logger4.addFilter(filter) logger4.addHandler(fh) logger4.addHandler(ch) logger5.addHandler(fh) logger5.addHandler(ch) # 记录一条日志 logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message') logger1.debug('logger1 debug message') logger1.info('logger1 info message') logger1.warning('logger1 warning message') logger1.error('logger1 error message') logger1.critical('logger1 critical message') logger2.debug('logger2 debug message') logger2.info('logger2 info message') logger2.warning('logger2 warning message') logger2.error('logger2 error message') logger2.critical('logger2 critical message') logger3.debug('logger3 debug message') logger3.info('logger3 info message') logger3.warning('logger3 warning message') logger3.error('logger3 error message') logger3.critical('logger3 critical message') logger4.debug('logger4 debug message') logger4.info('logger4 info message') logger4.warning('logger4 warning message') logger4.error('logger4 error message') logger4.critical('logger4 critical message') logger5.debug('logger5 debug message') logger5.info('logger5 info message') logger5.warning('logger5 warning message') logger5.error('logger5 error message') logger5.critical('logger5 critical message')
应用：
import os import time import logging from config import settings def get_logger(card_num, struct_time): if struct_time.tm_mday < 23: file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon, 22) else: file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon+1, 22) file_handler = logging.FileHandler( os.path.join(settings.USER_DIR_FOLDER, card_num, 'record', file_name), encoding='utf-8' ) fmt = logging.Formatter(fmt="%(asctime)s : %(message)s") file_handler.setFormatter(fmt) logger1 = logging.Logger('user_logger', level=logging.INFO) logger1.addHandler(file_handler) return logger1
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)
生成的配置文件内容：
[DEFAULT] serveraliveinterval = 45 compression = yes compressionlevel = 9 forwardx11 = yes [bitbucket.org] user = hg [topsecret.server.com] host port = 50022 forwardx11 = no
二、读取
readconfig = configparser.ConfigParser()
readconfig.read('example.ini')
print(readconfig.defaults()) # 读取DEFAULT配置项及其内部键值对
print(readconfig.sections()) # 读取DEFAULT配置项以外的其它配置项
print('abc' in readconfig) # 结果：False 判断配置项是否在配置对象内(不包含)
print('topsecret.server.com' in readconfig) # 结果：True 判断配置项是否在配置对象内(包含)
print(readconfig['bitbucket.org']['User']) # 结果：hg 读取配置项下面的键值堆中的值
for key in readconfig['bitbucket.org']:
print(key)
'''
显示结果： 此结果包含指定配置项下的内容，同时也会显示DEFAULT配置项下内容
user
serveraliveinterval
compression
compressionlevel
forwardx11
'''
三、删除
1、删除指定配置项
removeconfig = configparser.ConfigParser()
removeconfig.read('example.ini')
removeconfig.remove_section('topsecret.server.com') # 删除配置项topsecret.server.com
removeconfig.write(open('example.ini', 'w'))
removeconfig.has_section('topsecret.server.com') # 结果：False 判断配置项是否存在
2、删除指定配置项内键值对
removeconfig.remove_option('DEFAULT', 'Compression') # 删除指定配置DEFAULT项下的键值对Compression
removeconfig.write(open('example.ini', 'w'))
removeconfig.has_option('DEFAULT', 'CompressionLevel') # 结果：True 判断配置DEFAULT项下CompressionLevel是否存在
四、修改和增加设置
1、修改已有配置项下的键值对
modifyconfig = configparser.ConfigParser()
modifyconfig.read('example.ini')
modifyconfig.set('DEFAULT', 'CompressionLevel', '10') # CompressionLevel的值为10
modifyconfig.write(open('example.ini', 'w'))
2、增加新配置项，增加新键值对
addconfig = configparser.ConfigParser()
addconfig.read('example.ini')
addconfig.add_section('new') # 增加new新的配置项
addconfig.set('new', 'user2', 'pig') # 在new配置项下增加user2新键值对
addconfig.write(open('example.ini', 'w'))
re模块(正则)
一、正则表达式说明
正则表达式用于匹配字符串
二、元字符
1、. 代指任意一个字符，除了换行符\n
import re
ret = re.findall('w..l', 'hello world')
print(ret)
'''
显示结果：
['worl']
'''
2、^ 只在开始位置匹配
ret = re.findall('^h...o', '123hello456')
print(ret) # 结果：[] 返回空，因为从字符开始进行匹配
ret = re.findall('^h...o', 'hello123456')
print(ret) # 结果：['hello'] 返回字符
3、 $ 只在结束位置匹配
放在模式结尾，与^类似
4、 * 重复匹配，匹配范围【0，无穷】，贪婪匹配按最多匹配
ret = re.findall('ba*', 'skfjbaaaaa')
print(ret) # 结果：['baaaaa']
ret = re.findall('ba*', 'skfjb')
print(ret) # 结果：['b'] 匹配0次
ret = re.findall('b.*', 'sfsfbfffft')
print(ret) # 结果：['bfffft']
5、 + 重复匹配，最少出现一次，匹配范围【1，无穷】个
ret = re.findall('cb+', 'aacb33')
print(ret) # 结果：['cb']
ret = re.findall('cb+', 'aac33')
print(ret) # 结果：[] b一次都没有出现过，所以没有匹配到，返回空
6、 ? 匹配【0,1】个，惰性匹配，按最小匹配
ret = re.findall('a?b', 'aaaabhghabfb')
print(ret) # 结果：['ab', 'ab', 'b'] a可以是0到1个，所以ab和单独的b都可以匹配到
ret = re.findall('abc*?', 'abccccc')
print(ret) # 结果：['ab'] 没有输出c，因为?是惰性匹配
7、 {} 匹配自定义范围个（贪婪模式：贪婪匹配按最多的结果返回）
*等价于{0，} +等价于{1，} ?等价于{0,1}，推荐使用前者代替大括号形式。
ret = re.findall('a{5}b', 'aaaaaabb')
print(ret) # 结果：['aaaaab'] 匹配5个a，一个b，贪婪匹配输出
ret = re.findall('a{1,5}b', 'aabb')
print(ret) # 结果：['aab'] 匹配2个a，一个b
8、 [] 字符集，取消字符的特殊功能（三个例外）
ret = re.findall('[a-z]', 'adx')
print(ret) # 结果：['a', 'd', 'x']
ret = re.findall('[w*]', 'awcd*')
print(ret) # 结果：['w', '*'] 取消了原有*号重复功能
特别注意的是[]内字符集之间元素是或者关系，所以只能取其一，例如[a,b]的意思就是从a , b三者之间选其一，其中逗号也是字符集中的元素之一。
ret = re.findall('a[bc]d', 'abcd')
print(ret) # 结果：[] 因为[]内字符集是或者关系，所以b和c只能取其一，要么abc，要么acd，abcd无法匹配，结果返回空
三个例外：
（1）- 表示范围
例如：[0-9a-zA-Z]其中-表示范围：
ret = re.findall('[0-9a-zA-Z]', 'sdEG3d45')
print(ret) # 结果：['s', 'd', 'E', 'G', '3', 'd', '4', '5']
（2）^ 表示取非
例如：[^t,4]返回除了t和4的其他字符
ret = re.findall('[^t,4]', 'abc3tU4k')
print(ret) # 结果：['a', 'b', 'c', '3', 'U', 'k'] 返回除了t和4的其他字符
（3）\ 见9章节
9、 \ 反斜杠跟着元字符则去除特殊功能，跟着普通字实现特殊功能
（1）反斜杠加普通字符功能列表：
\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: 匹配一个特殊字符边界，也就是指单词和空格间的位置
print(re.findall('\d{11}', 'dsf78uoi887878689687987ssd')) # 结果：['88787868968'] 显示11个数字
print(re.findall('\sasd', 'abc asd')) # 结果：[' asd'] 显示11个数字
print(re.findall(r'I\b', 'hello I am a LIST')) # 结果：['I']，取第一个I，因为有特殊字符边界\b
（2）反斜杠跟元字符去除特殊功能
ret = re.search('a\*b', 'a*bcd')
print(ret.group()) # 结果：a*b 这里的模式中的*失去了特殊字符的功能，就作为普通字符
（3）对反斜杠本身进行匹配说明
- \\\\ 来匹配 \
为什么要用四个反斜杠来匹配反斜杠本身，因为python的反斜杠本身需要两个做转义，然后re正则的反斜杠本身也需要两个反斜杠做转义。
ret = re.findall('\\\\', "a\ocd")
print(ret) # 结果：['\\'] 这里匹配\用了四个\
- 模式前加r，用\\来匹配\
加r告诉python解释器字符串为原生字符串不需要转义，所以直接传给了re正则，则re用\\就匹配了\
ret = re.findall(r'\\', "a\ocd") print(ret) # 结果：['\\'] 这里匹配\用了两个\
10、()分组
print(re.search('(as)+', 'fcasast').group()) # 结果：asas as作为分组出现
print(re.search('(as)|3', 'tasp3').group()) # 结果：as
ret = re.search('(?P<id>\d{3})/(?P<name>\w{3})', 'sdf123/ooo') # 其中?P<>是固定格式，<>内位分组名称
print(ret.group()) # 结果：123/ooo
print(ret.group('id')) # 结果：123 分组名称为id
print(ret.group('name')) # 结果：ooo 分组名称为
三、正则表达式的方法
1、findall()：返回所有结果，结果是列表形式
2、search()：返回一个对象（object），对象调用group()返回结果
ret = re.search('s.b', 'fjaskdsebkksab')
print(ret) # 结果：<_sre.SRE_Match object; span=(6, 9), match='seb'>
print(ret.group()) # 结果：seb
3、match()：只在字符串开始匹配，返回一个对象（object），对象可以调用group()返回结果
ret = re.match('asd', 'asd13r')
print(ret) # 结果：<_sre.SRE_Match object; span=(0, 3), match='asd'>
print(ret.group()) # 结果：asd
4、split()：分割，可以匹配正则
ret = re.split('[j, s]', 'djksal')
print(ret) # 结果： ['d', 'k', 'al'] 先以j进行分割，然后再用s进行分割
ret = re.split('[j, s]', 'sdjksal')
print(ret) # 结果： ['', 'd', 'k', 'al'] 先以j进行分割，然后再用s进行分割，这里s在开头，所以以s分割出现一个空
5、sub()：替换
ret = re.sub('h...t', 'short', 'hight man')
print(ret) # 结果：short man
ret = re.sub('\d', 'super', '1 man 2 woman', 1) # 最后一个参数表示替换次数
print(ret) # 结果：super man 2 woman 因为限制了替换次数，1被替换了，而2没有被替换
subn()：替换，和sub一样，只不过多返回一个替换次数
ret = re.subn('\d', 'super', '1 man 2 woman')
print(ret) # 结果：('super man super woman', 2) 多返回了一个参数（替换次数）
6、compile()：预编译模式，多次调用可以提高效率
obj = re.compile('\.com')
print(obj.findall('www.baidu.com')) # 结果：['.com'] 省略了模式部分
print(obj.split('www.baidu.com')) # 结果：['www.baidu', ''] 省略了模式部分
7、finditer()：返回迭代器对象
ret = re.finditer('\d', 'a1b2c3d4e5')
print(ret) # 结果： <callable_iterator object at 0x0000000002435438> 是一个迭代器对象
print(next(ret)) # 结果：<_sre.SRE_Match object; span=(1, 2), match='1'> 还是一个对象
print(next(ret).group()) # 结果：2 返回了对象内的值
序列化模块json & pickle & shelve
eval内置方法可以将一个字符串转成python对象，不过，eval方法有局限，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了，所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
import json x="[null,true,false,1]" print(eval(x)) print(json.loads(x))
一、什么是序列化
- 我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
- 序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
- 反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling
二、json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
#----------------------------序列化
import json
dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>
j=json.dumps(dic)
print(type(j))#<class 'str'>
f=open('序列化对象','w')
f.write(j) #-------------------等价于json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open('序列化对象')
data=json.loads(f.read())# 等价于data=json.load(f)
import json #dct="{'1':111}"#json 不认单引号 #dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1} dct='{"1":"111"}' print(json.loads(dct)) #conclusion: # 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads
三、pickle
##----------------------------序列化
import pickle
dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j) #-------------------等价于pickle.dump(dic,f)
f.close()
#-------------------------反序列化
import pickle
f=open('序列化对象_pickle','rb')
data=pickle.loads(f.read())# 等价于data=pickle.load(f)
print(data['age'])
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
四、shelve
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型(打开即可添加内容，便于修改)
import shelve
f = shelve.open(r'shelve.txt')
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()
print(f.get('stu_info')['age'])
xml模块
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。
xml的格式如下，就是通过<>节点来区别数据结构的:
<?xml version="1.0"?> <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作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)
for i in child:
print(i.tag,i.text)
#只遍历year 节点
for node in root.iter('year'):
print(node.tag,node.text)
#---------------------------------------
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
#修改
for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
node.set("updated","yes")
tree.write("xmltest.xml")
#删除node
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('output.xml')
自己创建xml文档：
import xml.etree.ElementTree as ET new_xml = ET.Element("namelist") name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"}) age = ET.SubElement(name,"age",attrib={"checked":"no"}) sex = ET.SubElement(name,"sex") sex.text = '33' name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"}) age = ET.SubElement(name2,"age") age.text = '19' et = ET.ElementTree(new_xml) #生成文档对象 et.write("test.xml", encoding="utf-8",xml_declaration=True) ET.dump(new_xml) #打印生成的格式
自定义模块
- 自定义模块可以放入pyton的环境变量中
- 自定义模块可以放入系统的\Lib\site-packages
浙公网安备 33010602011771号