python stack模块_Python基础（八）模块2

目录：

模块&包

常用模块

time模块

random模块

os模块

sys模块

configparse模块

hashlib模块

logging模块

正则表达式

一、模块&包(* * * * *)

1、模块(modue)的概念

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块(Module)。

使用模块有什么好处？

最大的好处是大大提高了代码的可维护性。

其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

所以，模块一共三种：

python标准库

第三方模块

应用程序自定义模块

另外，使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

2、模块导入方法

2.1 import 语句

1 import module1[, module2[,... moduleN]

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？答案就是解释器有自己的搜索路径，存在sys.path里。

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。因为所有的路径是按照sys.path返回列表中的顺序进行搜索的，找到了对应的模块就不会往下继续搜索了。

2.2 from…import 语句

1 from modname import name1[, name2[, ... nameN]]

这个声明不会把整个modulename模块导入到当前的命名空间中，只会将它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。

2.3 From…import* 语句 不推荐使用

1 from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义

2.4 运行的本质

1 #1 import test

2 #2 from test import add

无论是1还是2，首先通过sys.path找到test.py , 然后执行test脚本(全部执行)，区别是1会将test这个变量名加载到名字空间，2会将add这个变量名加载到名字空间。

3、包(package)

如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包(Package)。

举个例子，一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。

现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。方法是选择一个顶层包名：

引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，view.py模块的名字就变成了hi_django.app_web.views，类似的，manage.py的模块名则是hi_django.manage。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

调用包就是执行包下的__init__.py文件, 调用包不会去执行包下面的模块

注意点(important)

1--------------

在nod1里import  hello是找不到的，有同学说可以找到呀，那是因为你的pycharm为你把myapp这一层路径加入到了sys.path里面，所以可以找到，然而程序一旦在命令行运行，则报错。有同学问那怎么办？简单啊，自己把这个路径加进去不就OK啦：

1 importsys,os2 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))3 #print(BASE_DIR)

4 #print(__file__) # 这里的__file__和sys.argv[0]是一样的

5 #print(sys.argv[0])

7 #print(sys.path)

8 importhello9 print(hello.hello())

2 --------------

1 if __name__=='__main__':2 print('ok')

“Make a .py both importable and executable”

如果我们是直接执行某个.py文件的时候，该文件中那么”__name__ == '__main__'“是True,但是我们如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__。

这个功能还有一个用处：调试代码的时候，在”if __name__ == '__main__'“中加入一些我们的调试代码，我们可以让外部模块调用的时候不执行我们的调试代码，但是如果我们想排查问题的时候，直接执行该模块文件，调试代码能够正常运行！s

3---------------

模块之间的导入

1 ##-------------cal.py

2 defadd(x,y):3

4 return x+y5 ##-------------main.py

6 import cal #from module import cal

7

8 defmain():9

10 cal.add(1,2)11

12 ##--------------bin.py

13 from module importmain14

15 main.main()

说明：

1 #from module import cal 改成 from . import cal同样可以，这是因为bin.py是我们的执行脚本，

2 #sys.path里有bin.py的当前环境。即/Users/yuanhao/Desktop/whaterver/project/web这层路径，

3 #无论import what , 解释器都会按这个路径找。所以当执行到main.py时，import cal会找不到，因为

4 #sys.path里没有/Users/yuanhao/Desktop/whaterver/project/web/module这个路径，而

5 #from module/. import cal 时，解释器就可以找到了。

在一个包下面的模块相互调用也必须使用

1 #main.py文件

2

3

4 from module importcal5

6 # 因为bin或者被其他模块调用main.py模块的时候，也可以找到cal，7 如果直接imort cal 的话，main.py是可以找到cal 的，bin.py导入main.py就找不到cal，则会报错

二、常用模块

1、time 模块

三种时间表示

在Python中，通常有这几种方式来表示时间：

时间戳(timestamp) ：         通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

格式化的时间字符串

元组(struct_time)   ：         struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

1 importtime2

3 #1 time() :返回当前时间的时间戳

4 time.time() #1473525444.037215

5

6 #----------------------------------------------------------

7

8 #2 localtime([secs])

9 #将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

10 time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,

11 #tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)

12 time.localtime(1473525444.037215)13

14 #----------------------------------------------------------

15

16 #3 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。

17

18 #----------------------------------------------------------

19

20 #4 mktime(t) : 将一个struct_time转化为时间戳。

21 print(time.mktime(time.localtime()))#1473525749.0

22

23 #----------------------------------------------------------

24

25 #5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

26 #如果没有参数，将会将time.localtime()作为参数传入。

27 print(time.asctime())#Sun Sep 11 00:43:43 2016

28

29 #----------------------------------------------------------

30

31 #6 ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为

32 #None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

33 print(time.ctime()) #Sun Sep 11 00:46:38 2016

34

35 print(time.ctime(time.time())) #Sun Sep 11 00:46:38 2016

36

37 #7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time(如由time.localtime()和

38 #time.gmtime()返回)转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个

39 #元素越界，ValueError的错误将会被抛出。

40 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

41

42 #8 time.strptime(string[, format])

43 #把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

44 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))45

46 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

47 #tm_wday=3, tm_yday=125, tm_isdst=-1)

48

49 #在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

50

51

52 #9 sleep(secs)

53 #线程推迟指定的时间运行，单位为秒。

54

55 #10 clock()

56 #这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数(时间戳)。

57 #而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行

58 #时间，即两次时间差。

time模块

2、random模块

1 #author:wanstack

2 importrandom3

4 print(random.random()) #0.822387499496826 用于生成一个0到1的随机符点数: 0 <= n < 1.0

5 print(random.randint(1,4)) #用于生成一个指定范围内的整数

6 print(random.randrange(1,10)) #从1到10的范围内取一个随机整数

7 print(random.uniform(1,10)) #从1到10的范围内取一个随机浮点数

8 print(random.choice([1,2,3,4,[1,2,],'abc'])) #从序列中获取一个随机元素

9

10 a = [1,2,3,4] #tuple不支持，set不支持,str不支持

11 random.shuffle(a) #用于将一个列表中的元素打乱

12 print(a)13 b = random.sample(a,2) #从列表a中随机获取2个元素作为返回值

14 print(b)15

16

17 #随机验证码，5位数的随机验证码,大小写字母数字混杂

18

19 defverification_code():20 code=''

21 num_code = random.choice(range(10))22 supper_alpha_code = chr((random.choice(range(65,90))))23 lower_alpha_code = chr((random.choice(range(97,122))))24 for i in range(5):25 #从序列中获取一个随机元素

26 choice =random.choice([num_code,supper_alpha_code,lower_alpha_code])27 choice =str(choice)28 code = code +choice29 print(code)30

31

32 verification_code()

random模块

3、os模块

os模块是与操作系统交互的一个接口

1 #author:wanstack

2 importos3

4 print(os.getcwd()) #E:\workspace\learning_python3\基础篇\函数\模块 获取当前工作目录，即当前python脚本工作的目录路径

5 os.chdir('D:\\') #改变当前脚本工作目录；相当于shell下cd

6 print(os.getcwd()) #路径被修改了

7 os.curdir #返回当前目录: ('.')

8 os.pardir #获取当前目录的父目录字符串名：('..')

9 os.makedirs('D:\\dirname1\\dirname2') #可生成多层递归目录

10 os.makedirs('dirname1\\dirname2') #默认相对路径是工作目录

11 os.removedirs('D:\\dirname1\\dirname2') #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

12 os.removedirs('dirname1\\dirname2') #默认相对路径是工作目录

13 os.mkdir('dirname1') #生成单级目录；相当于shell中mkdir dirname 默认相对路径是工作目录

14 os.rmdir('dirname1') #删除单级空目录，如果目录不为空则无法删除会报错，相当于shell中的rmdir dirname

15 print(os.listdir('D:\\')) #列出指定目录下(为指定则为当前目录下)的所有文件和子目录(子目录中的文件不列出)包括隐藏文件，并以列表方式打印

16 os.remove() #删除一个文件

17 os.rename("oldname","newname") #重命名文件/目录

18 print(os.stat(os.getcwd())) #获取文件/目录信息 参数为必填项

19 print(os.sep) #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

20 print(os.linesep) #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

21 print(os.pathsep) #输出用于分割文件路径的字符串

22 print(os.name) #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

23 os.system('bash command') #运行shell命令，直接显示

24 print(os.environ) #获取系统环境变量

25

26 print(os.path.abspath('os模块.py')) #返回path规范化的绝对路径

27 print(os.path.abspath('字符编码.py')) #看到了，这个绝对路径是不检查文件是否存在的

28 print(os.path.abspath('最近要做的事情.txt')) #看到了，这个绝对路径是不检查文件是否存在的

29 print(os.path.split('E:\workspace\learnifileng_python3\基础篇\函数\模块\最近要做的事情.txt')) #将path分割成目录和文件名二元组返回

30 print(os.path.dirname('E:\workspace\learning_python3\基础篇\函数\模块\最近要做的事情.txt')) #返回path的目录。其实就是os.path.split(path)的第一个元素

31 print(os.path.basename('E:\workspace\learning_python3\基础篇\函数\模块\最近要做的事情.txt')) #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

32 print(os.path.exists('E:\workspace\learning_python3\基础篇\函数\模块\最近要做的事情.txt')) #如果path存在，返回True；如果path不存在，返回False

33 print(os.path.isabs('E:\workspace\learning_python3\基础篇\函数\模块\最近要做的事情.txt')) #如果path是绝对路径，返回True, 不检查文件是否存在

34 print(os.path.isfile('E:\workspace\learning_python3\基础篇\函数\模块\最近要做的事情.txt')) #如果path是绝对路径，返回True, 不检查文件是否存在

35 print(os.path.isfile('os模块.py')) #如果path是一个存在的文件，返回True。否则返回False ,可以是相对路径

36 print(os.path.isfile('近要做的事情.txt')) #如果path是一个存在的文件，返回True。否则返回False ,只在本目录检查

37 print(os.path.isdir('E:\workspace\learning_python3\基础篇\函数\模块')) #如果path是一个存在的目录，则返回True。否则返回False

38 print(os.path.join('dir1','dir2','dir3')) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

39 print(os.path.getatime('E:\workspace\learning_python3\基础篇\函数\模块\os模块.py')) #Return the last access time of a file, reported by os.stat().

40 print(os.path.getmtime('E:\workspace\learning_python3\基础篇\函数\模块\os模块.py')) #Return the last modification time of a file, reported by os.stat().

41 print(os.path.getctime('E:\workspace\learning_python3\基础篇\函数\模块\os模块.py')) #Return the metadata change time of a file, reported by os.stat().

os模块

4、sys模块

sys模块是与python代码文件交互的一个接口

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

1 importsys2 importtime3

4 for i in range(10):5 sys.stdout.write('#')6 time.sleep(1)7 sys.stdout.flush()

手撸进度条

5、configparse模块

用于生成，解析配置文件的模块

1 #author:wanstack

2

3 importconfigparser4

5 #使用configparse 生成一个文档

6

7 #创建

8 config =configparser.ConfigParser()9

10 config['DEFAULT'] ={11 'bind_address': '192.168.110.1',12 'bind_port' : '9696',13 'log_file' : '/var/log/neutron/neutron.log',14 }15

16 config['neutron'] ={}17 config['neutron']['username'] = 'neutron'

18 config['neutron']['password'] = 'root1234'

19

20 config['nova'] ={}21 config['nova']['Listen_address'] = 'localhost'

22

23 with open('neutron.conf','w') as configfile:24 config.write(configfile)25

26 #查

27 config =configparser.ConfigParser()28 print(config.sections()) #[] 新的对象没有关联文件

29 print(config.read('neutron.conf'))30 print(config.sections()) #['neutron', 'nova'] DEFAULT是一个特殊的section

31 print(config.default_section) #DEFAULT 读出DEFAULT section

32 print('neutron' in config) #True 检查section是否在配置文件中

33 print('usernmae' in config) #False 不是检查section中的section

34 print(config['neutron']['username']) #neutron

35 print(config['neutron']) #

36 print(config['DEFAULT']['bind_address']) #192.168.110.1

37

38 #循环取出所有的section

39 for key inconfig:40 print(key)41 """

42 DEFAULT43 neutron44 nova45 """

46

47 #循环取出DEFAULT section 中的section

48 for key in config['DEFAULT']:49 print(key)50 """

51 bind_address52 bind_port53 log_file54 """

55 print(config.options('neutron')) #['username', 'password', 'bind_address', 'bind_port', 'log_file']

56 print(config.items('neutron')) #包含DEFAULT [('bind_address', '192.168.110.1'), ('bind_port', '9696'), ('log_file', '/var/log/neutron/neutron.log'), ('username', 'neutron'), ('password', 'root1234')]

57

58 print(config.items('DEFAULT')) #['username', 'password', 'bind_address', 'bind_port', 'log_file']

59 print(config.get('neutron','username')) #neutron 获取不到会报错

60

61 #删,改,增(config.write(open('i.cfg', "w")))

62 #修改配置文件的过程是新建一个新的配置文件，然后把修改好的配置文件拷贝一份到新的配置文件中，这点从模式中的w就可以看出来

63

64 #增

65 config.add_section('rabbitmq') #在配置文件中新增一个section

66 config.write(open('neutron.conf','w'))67 config.set('rabbitmq','bind','localhost') #必须是一个存在的section

68 config.write(open('neutron.conf','w'))69

70 #改

71 config.set('rabbitmq','bind','192.168.110.1')72 config.write(open('neutron.conf','w'))73 #如果修改section，可以删除，然后添加新的section

74

75 #删

76

77 #删除一个section, 会把整个section下面的所有内容全部删除

78 config.remove_section('rabbitmq')79 config.write(open('neutron.conf','w'))80

81 #删除一个options

82 config.remove_option('neutron','password')83 config.write(open('neutron.conf','w'))

configparse模块

6、hashlib模块

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

1 #author:wanstack

2

3 importhashlib4

5 m = hashlib.md5() #m = hashlib.sha256()

6 m.update('Hello'.encode('utf8'))7 print(m.hexdigest()) #8b1a9953c4611296a827abf8c47804d7

8 m.update('wanstack'.encode('utf8'))9 print(m.hexdigest()) #a008c5648a2ffd8ea72f3d2e3510443b

10

11 m2 =hashlib.md5()12 m2.update('Hellowanstack'.encode('utf8'))13 print(m2.hexdigest()) #a008c5648a2ffd8ea72f3d2e3510443b

14

15 #以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

16

17 m3 = hashlib.md5('test@#!'.encode('utf8')) #加入了'test@#!' 的key

18 m3.update('Hellowanstack'.encode('utf8'))19 print(m3.hexdigest()) #e50ee4b9db03be0bfe29ca92594418ab

20

21 #python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:

22 importhmac23 m4 = hmac.new('test#@!'.encode('utf8')) #key='test#@!'

24 m4.update('Hellowanstack'.encode('utf8'))25 print(m4.hexdigest()) #34685a315fb39f3e5632ea6e36f8fa42

hashlib模块

7、logging模块

7.1 简单的应用

1 importlogging2

3 logging.debug('debug message')4 logging.info('info message')5 logging.warning('warning message')6 logging.error('error message')7 logging.critical('critical message')8 """

9 WARNING:root:warning message10 ERROR:root:error message11 CRITICAL:root:critical message12 """

可见，默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING(日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET)，默认的日志格式为日志级别：Logger名称：用户输出消息。

7.2 灵活配置日志级别，日志格式，输出位置

1 importlogging2 logging.basicConfig(level=logging.DEBUG,3 format='%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s',4 datefmt='%a %d %b %Y %H:%M:%S',5 filename='E:\\workspace\\learning_python3\\基础篇\\函数\\模块\\test.log',6 filemode='a'

7 )8 logging.debug('debug message')9 logging.info('info message')10 logging.warning('warning message')11 logging.error('error message')12 logging.critical('critical message')

1 Fri 16 Jun 2017 15:42:48 logging_module.py [line:22] DEBUG debug message2 Fri 16 Jun 2017 15:42:48 logging_module.py [line:23] INFO info message3 Fri 16 Jun 2017 15:42:48 logging_module.py [line:24] WARNING warning message4 Fri 16 Jun 2017 15:42:48 logging_module.py [line:25] ERROR error message5 Fri 16 Jun 2017 15:42:48 logging_module.py [line:26] CRITICAL critical message6

7 可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有8 filename：用指定的文件名创建FiledHandler(后边会具体讲解handler的概念)，这样日志会被存储在指定的文件中。9 filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”，一般指定为'a'模式，因为'w'模式会不断覆写之前的内容。10 format：指定handler使用的日志显示格式。11 datefmt：指定日期时间格式。12 level：设置rootlogger(后边会讲解具体概念)的日志级别13 stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open('test.log','w'))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。14 使用这种方式只能有一种输出流，即要么输出到文件，要么输出到屏幕上。如果想要2中输出方式，参照7.3

15

16 format参数中可能用到的格式化串：17 %(name)s Logger的名字18 %(levelno)s 数字形式的日志级别19 %(levelname)s 文本形式的日志级别20 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有21 %(filename)s 调用日志输出函数的模块的文件名22 %(module)s 调用日志输出函数的模块名23 %(funcName)s 调用日志输出函数的函数名24 %(lineno)d 调用日志输出函数的语句所在的代码行25 %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示26 %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数27 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒28 %(thread)d 线程ID。可能没有29 %(threadName)s 线程名。可能没有30 %(process)d 进程ID。可能没有31 %(message)s用户输出的消息

7.3 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)

1 importlogging2

3 #创建一个logger对象

4 logger =logging.getLogger()5

6 #创建一个handler，用于写入日志文件

7 fn = logging.FileHandler('E:\\workspace\\learning_python3\\基础篇\\函数\\模块\\testfile.log')8 #再创建一个handler，用于输出到控制台

9 cn =logging.StreamHandler()10

11 #创建一个日志格式对象

12 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(message)s')13

14 #将这个日志格式应用到2中输出流中

15 fn.setFormatter(formatter)16 cn.setFormatter(formatter)17

18 logger.addHandler(fn)19 logger.addHandler(cn)20

21 logger.debug('logger debug message')22 logger.info('logger info message')23 logger.warning('logger warning message')24 logger.error('logger error message')25 logger.critical('logger critical message')

先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。

ogger是一个树形层级结构，输出信息之前都要获得一个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()输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。

1 logger.debug('logger debug message')2 logger.info('logger info message')3 logger.warning('logger warning message')4 logger.error('logger error message')5 logger.critical('logger critical message')

只输出了如下：

2017-06-16 16:34:20,922 - root - WARNING -logger warning message

2017-06-16 16:34:20,922 - root - ERROR -logger error message

2017-06-16 16:34:20,923 - root - CRITICAL -logger critical message

从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别，所以使用默认的日志级别WARNIING，故结果只输出了大于等于WARNIING级别的信息。

(2) 如果我们再创建两个logger对象：

1 ##################################################

2 logger1 = logging.getLogger('mylogger')3 logger1.setLevel(logging.DEBUG)4

5 logger2 = logging.getLogger('mylogger')6 logger2.setLevel(logging.INFO)7

8 logger1.addHandler(fh)9 logger1.addHandler(ch)10

11 logger2.addHandler(fh)12 logger2.addHandler(ch)13

14 logger1.debug('logger1 debug message')15 logger1.info('logger1 info message')16 logger1.warning('logger1 warning message')17 logger1.error('logger1 error message')18 logger1.critical('logger1 critical message')19

20 logger2.debug('logger2 debug message')21 logger2.info('logger2 info message')22 logger2.warning('logger2 warning message')23 logger2.error('logger2 error message')24 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对象都会进行筛选。

7.4 logging的完整例子

例子1：

1 importlogging2

3 #创建一个logger对象

4 logger = logging.getLogger('mylogger')5

6 #设置日志级别

7 logger.setLevel(logging.DEBUG)8

9 #创建format日志格式

10 formatter = logging.Formatter('%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s')11

12 #创建2个输出流对象

13 fh = logging.FileHandler('test.log')14 ch =logging.StreamHandler()15

16 #添加formatter日志格式

17 fh.setFormatter(formatter)18 ch.setFormatter(formatter)19

20 #创建filter，并作用在输出流上

21 filter = logging.Filter('mylogger')22 fh.addFilter(filter)23 ch.addFilter(filter)24

25 #将logger对象关联到输出流上

26 logger.addHandler(fh)27 logger.addHandler(ch)28

29 logger.debug('debug message')30 logger.info('info message')31 logger.warning('warning message')32 logger.error('error message')33 logger.critical('critical message')

完整例子1

例子2：

1 importlogging2

3 #创建一个logger对象

4 logger = logging.getLogger('mylogger')5

6 #设置日志级别

7 logger.setLevel(logging.DEBUG)8

9 #创建format日志格式

10 formatter = logging.Formatter('%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s')11

12 #创建2个输出流对象

13 fh = logging.FileHandler('test.log')14 ch =logging.StreamHandler()15

16 #添加formatter日志格式

17 fh.setFormatter(formatter)18 ch.setFormatter(formatter)19

20 #创建filter，并作用在输出流上

21 filter = logging.Filter('mylogger')22 fh.addFilter(filter)23 ch.addFilter(filter)24

25 #将logger对象关联到输出流上

26 logger.addHandler(fh)27 logger.addHandler(ch)28

29 logger.debug('debug message')30 logger.info('info message')31 logger.warning('warning message')32 logger.error('error message')33 logger.critical('critical message')34

35 logger1 = logging.getLogger('mylogger')36 logger.setLevel(logging.DEBUG)37

38 logger1.addHandler(fh)39 logger1.addHandler(ch)40

41 logger2 = logging.getLogger('mylogger')42 logger2.setLevel(logging.INFO)43 logger2.addHandler(fh)44 logger2.addHandler(ch)45

46

47 logger1.debug('logger1 debug message')48 logger1.info('logger1 info message')49 logger1.warning('logger1 warning message')50 logger1.error('logger1 error message')51 logger1.critical('logger1 critical message')52

53 logger2.debug('logger2 debug message')54 logger2.info('logger2 info message')55 logger2.warning('logger2 warning message')56 logger2.error('logger2 error message')57 logger2.critical('logger2 critical message')

完整例子2

例子3：

1 #coding:utf-8

2 importlogging3

4 #创建一个logger

5 logger =logging.getLogger()6

7 logger1 = logging.getLogger('mylogger')8 logger1.setLevel(logging.DEBUG)9

10 logger2 = logging.getLogger('mylogger')11 logger2.setLevel(logging.INFO)12

13 logger3 = logging.getLogger('mylogger.child1')14 logger3.setLevel(logging.WARNING)15

16 logger4 = logging.getLogger('mylogger.child1.child2')17 logger4.setLevel(logging.DEBUG)18

19 logger5 = logging.getLogger('mylogger.child1.child2.child3')20 logger5.setLevel(logging.DEBUG)21

22 #创建一个handler，用于写入日志文件

23 fh = logging.FileHandler('test1.log')24

25 #再创建一个handler，用于输出到控制台

26 ch =logging.StreamHandler()27

28 #定义handler的输出格式formatter

29 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')30 fh.setFormatter(formatter)31 ch.setFormatter(formatter)32

33 #定义一个filter

34 filter = logging.Filter('mylogger')35 fh.addFilter(filter)36

37 #给logger添加handler

38 #logger.addFilter(filter)

39 logger.addHandler(fh)40 logger.addHandler(ch)41

42 #logger1.addFilter(filter)

43 logger1.addHandler(fh)44 logger1.addHandler(ch)45

46 logger2.addHandler(fh)47 logger2.addHandler(ch)48

49 #logger3.addFilter(filter)

50 logger3.addHandler(fh)51 logger3.addHandler(ch)52

53 #logger4.addFilter(filter)

54 logger4.addHandler(fh)55 logger4.addHandler(ch)56

57 logger5.addHandler(fh)58 logger5.addHandler(ch)59

60 #记录一条日志

61 logger.debug('logger debug message')62 logger.info('logger info message')63 logger.warning('logger warning message')64 logger.error('logger error message')65 logger.critical('logger critical message')66

67 logger1.debug('logger1 debug message')68 logger1.info('logger1 info message')69 logger1.warning('logger1 warning message')70 logger1.error('logger1 error message')71 logger1.critical('logger1 critical message')72

73 logger2.debug('logger2 debug message')74 logger2.info('logger2 info message')75 logger2.warning('logger2 warning message')76 logger2.error('logger2 error message')77 logger2.critical('logger2 critical message')78

79 logger3.debug('logger3 debug message')80 logger3.info('logger3 info message')81 logger3.warning('logger3 warning message')82 logger3.error('logger3 error message')83 logger3.critical('logger3 critical message')84

85 logger4.debug('logger4 debug message')86 logger4.info('logger4 info message')87 logger4.warning('logger4 warning message')88 logger4.error('logger4 error message')89 logger4.critical('logger4 critical message')90

91 logger5.debug('logger5 debug message')92 logger5.info('logger5 info message')93 logger5.warning('logger5 warning message')94 logger5.error('logger5 error message')95 logger5.critical('logger5 critical message')

完整例子3

8、正则表达式

正则表达式的元字符：所有的元字符默认都是贪婪匹配(可以调整为非贪婪模式)。具体参见{} 会有解释

. 只能代指任意一个字符 除了换行符(\n)不能代指

^ 匹配字符串的开始部分，其他位置不匹配 例如 re.findall('^h...o','hesdfsfsdfshello') 是匹配不到的hello的

$ 匹配字符串结束的部分，其他位置不匹配 例如 re.findall('h...o$,'sdfhellosf') 是匹配不到

* 重复匹配星号前面的内容0到多次例如 .* 代表重复匹配. 0到多次

+ 重复匹配加号前面的内容1到多次 例如 .+ 代表重复匹配. 1到多次

? 重复匹配问号前面的内容0或者1次 例如 .? 代表重复匹配. 0或者1次

{} 重复匹配大括号前面的内容。范围自己定义，

比如 a{5} 匹配5个a

比如 a{1,3} 匹配1到3个a，1个a可以，2个a可以，3个a可以，但是这个是贪婪匹配，如果最多有3个a会优先匹配3个a，最多2个a会优先匹配到2个a，最多是1个a会优先匹配1个a

比如 a{1,} 表示匹配1到正无穷

小结： * 等价于{0,正无穷} + 等价于 {1,正无穷} ? 等价于{0,1}

[] 字符集 匹配里面的内容：注意是或的关系 ，还有一个功能，取消元字符的特殊功能(\ ^ -)三个是例外

例如: [ab] 可以匹配到a，可以匹配到b，但是匹配不到ab

例如: [abc] 可以匹配到a，可以匹配到b，可以匹配到c，其他的匹配不到

例子: 可以匹配网址后面的[c,o,m] 可以匹配到com

例子： [a-z] 匹配a到z中的任意一个字母

取消元字符特殊功能例子：

re.findall('[w,*]','wsdf*') 可以匹配到w和* 字符，取消了* 的元字符的功能

[a-z] 其中- 表示范围

[^a] 表示取反，匹配除了a以外的所有元素

[^14] 表示对 1和4 取反 其中1和4是一组 ，表示非1或者非4

\

# 反斜杠后面跟元字符去除特殊功能

# 反斜杠后面跟普通字符实现特殊功能

python转义，re转义，如果加r，则告诉python不需要转义，如果不加r，怎匹配一个\ 需要\\\\才可以，因为经过了python解释器和re 2层转义

\b 匹配一个特殊字符边界，也就是指单词和特殊字符之间的位置 例如 re.findall(r'I\b', 'hello,I LIKE THIS') 只能匹配到 I单词，因为I后面是一个空格，空格会被\b 捕捉到

() 分组，(as)+ 把as当作一个整体，意思是匹配as一次或者多次

| 或

################

8.1 re模块

就其本质而言，正则表达式(或 RE)是一种小型的、高度专业化的编程语言，(在Python中)它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

字符匹配(普通字符，元字符)：

1 普通字符：大多数字符和字母都会和自身匹配

>>> re.findall('alvin','yuanaleSxalexwupeiqi')

['alvin']

2 元字符：. ^ $ * + ? { } [ ] | ( ) \

元字符之. ^ $ * + ? { }

1 importre2

3 ret=re.findall('a..in','helloalvin')4 print(ret)#['alvin']

5

6

7 ret=re.findall('^a...n','alvinhelloawwwn')8 print(ret)#['alvin']

9

10

11 ret=re.findall('a...n$','alvinhelloawwwn')12 print(ret)#['awwwn']

13

14

15 ret=re.findall('a...n$','alvinhelloawwwn')16 print(ret)#['awwwn']

17

18

19 ret=re.findall('abc*','abcccc')#贪婪匹配[0,+oo]

20 print(ret)#['abcccc']

21

22 ret=re.findall('abc+','abccc')#[1,+oo]

23 print(ret)#['abccc']

24

25 ret=re.findall('abc?','abccc')#[0,1]

26 print(ret)#['abc']

27

28

29 ret=re.findall('abc{1,4}','abccc')30 print(ret)#['abccc'] 贪婪匹配

注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

1 ret=re.findall('abc*?','abcccccc')2 print(ret)#['ab']

元字符之字符集［］：

1 #--------------------------------------------字符集[]

2 ret=re.findall('a[bc]d','acd')3 print(ret)#['acd']

4

5 ret=re.findall('[a-z]','acd')6 print(ret)#['a', 'c', 'd']

7

8 ret=re.findall('[.*+]','a.cd+')9 print(ret)#['.', '+']

10

11 #在字符集里有功能的符号: - ^ \

12

13 ret=re.findall('[1-9]','45dha3')14 print(ret)#['4', '5', '3']

15

16 ret=re.findall('[^ab]','45bdha3')17 print(ret)#['4', '5', 'd', 'h', '3']

18

19 ret=re.findall('[\d]','45bdha3')20 print(ret)#['4', '5', '3']

元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.

反斜杠后边跟普通字符实现特殊功能,比如\d

\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  匹配一个特殊字符边界，比如空格 ，&，＃等

1 ret=re.findall('I\b','I am LIST')2 print(ret)#[]

3 ret=re.findall(r'I\b','I am LIST')4 print(ret)#['I']

现在我们聊一聊\,先看下面两个匹配：

1 #-----------------------------eg1:

2 importre3 ret=re.findall('c\l','abc\le')4 print(ret)#[]

5 ret=re.findall('c\\l','abc\le')6 print(ret)#[]

7 ret=re.findall('c\\\\l','abc\le')8 print(ret)#['c\\l']

9 ret=re.findall(r'c\\l','abc\le')10 print(ret)#['c\\l']

11

12 #-----------------------------eg2:

13 #之所以选择\b是因为\b在ASCII表中是有意义的

14 m = re.findall('\bblow', 'blow')15 print(m)16 m = re.findall(r'\bblow', 'blow')17 print(m)

元字符之分组()

1 m = re.findall(r'(ad)+', 'add')2 print(m)3

4 ret=re.search('(?P\d{2})/(?P\w{3})','23/com')5 print(ret.group())#23/com

6 print(ret.group('id'))#23

元字符之｜

1 ret=re.search('(ab)|\d','rabhdg8sd')2 print(ret.group())#ab

3

4 ret=re.search('(ab)|\d','1rabhdg8sd')5 print(ret.group())#1

6

7 #优先匹配到谁就是谁，然后不往下继续匹配了

re模块下的常用方法：

1 importre2 #1

3 re.findall('a','alvin yuan') #返回所有满足匹配条件的结果,放在列表里

4 #2

5 re.search('a','alvin yuan').group() #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以

6 #通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

7

8 #3

9 re.match('a','abc').group() #同search,不过尽在字符串开始处进行匹配

10

11 #4

12 ret=re.split('[ab]','abcd') #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割

13 print(ret)#['', '', 'cd']

14

15 #5

16 ret=re.sub('\d','abc','alvin5yuan6',1)17 print(ret)#alvinabcyuan6

18 ret=re.subn('\d','abc','alvin5yuan6')19 print(ret)#('alvinabcyuanabc', 2)

20

21 #6

22 obj=re.compile('\d{3}')23 ret=obj.search('abc123eeee')24 print(ret.group())#123

注意：

1 importre2

3 ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')4 print(ret)#['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

5

6 ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')7 print(ret)#['www.oldboy.com']

补充：

importreprint(re.findall("\w+)>\w+(?P=tag_name)>","

hello

"))print(re.search("\w+)>\w+(?P=tag_name)>","

hello

"))print(re.search(r"\w+\1>","

hello

").group())#这里的\1表示\w+，表示引用()里面的第一个组 规则

print(re.search(r"\w+\w+>","

hello

").group())

补充2：

1 #匹配出所有的整数

2 importre3

4 #ret=re.findall(r"\d+{0}]","1-2*(60+(-40.35/5)-(-4*3))")

5 ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")6 ret.remove("")7

8 print(ret)