Python之常用模块（六）re模块与logging模块和包

re模块

re（正则）简介：正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。

re元字符

`元字符`	`匹配内容`
w	匹配字母（包含中文）或数字或下划线
W	匹配非字母（包含中文）或数字或下划线
s	匹配任意的空白符
S	匹配任意非空白符
d	匹配数字
D	匹配非数字
A	从字符串开头匹配
	匹配一个换行符
	匹配一个制表符
^	匹配字符串的开始
$	匹配字符串的结尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	匹配字符组中的字符
[^]	匹配除了字符组中的字符的所有字符
*	匹配0个或者多个左边的字符。
+	匹配一个或者多个左边的字符。
？	匹配0个或者1个左边的字符，非贪婪方式。
	精准匹配n个前面的表达式。
{n,m}	匹配n到m次由前面的正则表达式定义的片段，贪婪方式
a\|b	匹配a或者b
()	匹配括号内的表达式，也表示一个组

s = "meet 黑哥_dsb"
print(re.findall("w",s))
# 结果：['m', 'e', 'e', 't', '黑', '哥', '_', 'd', 's', 'b']
s = "meet @黑哥!_dsb"
print(re.findall("W",s))
# 结果：[' ', '@', '!']
s = "meet 黑哥
_dsb	"
print(re.findall("s",s))
# 结果：[' ', '
', '	']
s = "meet 黑哥
_dsb	"
print(re.findall("S",s))
# 结果：['m', 'e', 'e', 't', '黑', '哥', '_', 'd', 's', 'b']
s = "meet1 黑哥2_dsb3"
print(re.findall("d",s))
# 结果：['1', '2', '3']
s = "meet1 黑哥2_dsb3"
print(re.findall("D",s))
# 结果：['m', 'e', 'e', 't', ' ', '黑', '哥', '_', 'd', 's', 'b']
s = "meet 黑哥_dsb"
print(re.findall("Am",s))
print(re.findall("Ad",s))
# 结果：
['m']
[]
s = "meet 
黑哥	_
dsb"
print(re.findall("
",s))
# 结果：
['
', '
']
s = "meet 
黑哥	_
dsb"
print(re.findall("	",s))
# 结果：
['	']
s = "meet 黑哥_dsb"
print(re.findall("^m",s))
print(re.findall("^d",s))
# 结果：
['m']
[]
s = "meet 黑哥_dsb"
print(re.findall("b$",s))
print(re.findall("sb$",s))
# 结果：
['b']
['sb']
s = "meet 黑哥_dsb"
print(re.findall("m..",s))
# 结果：['mee']
s = "meet1 黑哥2_dsb3"
print(re.findall("[1-3]",s))
# 结果：['1', '2', '3']
s = "meet1 黑哥2_dsb3"
print(re.findall("[^(1-3)]",s))
# 结果：['m', 'e', 'e', 't', ' ', '黑', '哥', '_', 'd', 's', 'b']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("me*",s))
# 结果：['mee', 'm', 'mee', 'meee']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("me+",s))
# 结果：['mee', 'mee', 'meee']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("me*?",s))
print(re.findall("me+?",s))
# 结果:
['m', 'm', 'm', 'm']
['me', 'me', 'me']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("e{3}",s))
# 结果：
['eee']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("e{1,3}",s))
# 结果：
['ee', 'ee', 'eee']
s = "2019-7-26 20:30:30"
print(re.split(":|-|s",s))
# 结果：
['2019', '7', '26', '20', '30', '30']
s = "meet 黑m哥_dsb meet meee"
print(re.findall("m(.*?)t",s))
# 结果：
['ee', '哥_dsb mee']

re模块常用方法

findall 全部找到返回一个列表
search 从字符串中任意位置进行匹配查找到一个就停止了,返回的是一个对象. 获取匹配的内容必须使用.group()进行获取

import re
print(re.search("sb|nb","alexsb meetnb"))
print(re.search("sb|nb","alexsb meetnb").group())
# 结果
<_sre.SRE_Match object; span=(4, 6), match='sb'>
sb

match 从字符串开始位置进行匹配

import re
print()re.match("sb|nb","alexdsb,alex_sb,alexnb,al_ex")
print(re.match("sb|nb","alexdsb,alex_sb,alexnb,al_ex").group())
# 结果：
None
AttributeError: 'NoneType' object has no attribute 'group'  # 'NoneType'对象没有属性'group'

split 分隔可按照任意分隔符进行分隔

import re
s = "2019-7-26 20:30:30"
print(re.split(":|-|s",s))
# 结果：
['2019', '7', '26', '20', '30', '30']

sub 替换

import re
s = "meet是一位好老师，meet教会了我们很多知识"
print(re.sub("meet","苍老师"，s))
# 结果：
苍老师是一位好老师，苍老师教会了我们很多知识

compile 定义匹配规则

import re
fn = "d+"
s = "太白123meet456"
print(re.split(fn,s))
# 结果：
['太白', 'meet', '']

finditer 返回一个迭代器

import re
s = "太白123"
g = re.finditer("w",s)
for i in g:
    print(i)
    print(next(i))
# 结果：
<_sre.SRE_Match object; span=(0, 1), match='太'>
太
<_sre.SRE_Match object; span=(1, 2), match='白'>
白
<_sre.SRE_Match object; span=(2, 3), match='1'>
1
<_sre.SRE_Match object; span=(3, 4), match='2'>
2
<_sre.SRE_Match object; span=(4, 5), match='3'>
3

给分组起名字

import re
ret = re.search("<(?P<tag_name>w+)>w+</w+>","<h1>hello</h1>")  # 给分组1取名tag_name
print(ret.group("tag_name"))
print(ret.group())
# 结果：
h1
<h1>hello</h1>

import re
ret = re.search(r"<(w+)>w+</1>","<h1>hello</h1>")   # 1填充分组1中的内容
print(ret.group(1))
print(ret.group())
# 结果：
h1
<h1>hello</h1>

5.11 logging模块和包

logging模块简介：logging模块是记录我们软件的各种状态，还可以记录各种交易信息；其实每个软件都是有错误日志的,开发人员可以通过错误日志中的内容对他的程序进行修改

日志级别

import logging

logging.debug('调试debug')           # DEBUG = 10
logging.info('消息info')             # INFO = 20
logging.warning('警告warn')          # WARNING = 30
logging.error('错误error')           # ERROR = 40
logging.critical('严重critical')     # CRITICAL = 50

'''
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：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')

basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：
- filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中
- filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
- format：指定handler使用的日志显示格式。
- datefmt：指定日期时间格式。
- level：设置记录日志的级别
- 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用户输出的消息

logging对象配置

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') 

# 再创建一个handler，用于输出到控制台 
ch = logging.StreamHandler() 
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setLevel(logging.DEBUG)

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指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过
fh.setLevel(logging.Debug)单对文件流设置某个级别。

包

包的简介:包是一种通过使用‘.模块名’来组织python模块名称空间的方式。具体的：包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
需要强调的是：
1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块
为何要使用包
包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

glance/                   #Top-level package

├── __init__.py      #Initialize the glance package

├── api                  #Subpackage for api

│   ├── __init__.py

│   ├── policy.py

│   └── versions.py

├── cmd                #Subpackage for cmd

│   ├── __init__.py

│   └── manage.py

└── db                  #Subpackage for db

    ├── __init__.py

    └── models.py

注意项:

#1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

#2、import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

#3、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

文件内容:按 Ctrl+C 复制代码；执行文件与示范文件在同级目录下

包的使用之import

import glance.db.models
glance.db.models.register_models('mysql')

单独导入包名称时不会导入包中所有包含的所有子模块，如

#在与glance同级的test.py中
import glance
glance.cmd.manage.main()

'''
执行结果：
AttributeError: module 'glance' has no attribute 'cmd'

'''

解决方法：

#glance/__init__.py
from . import cmd

#glance/cmd/__init__.py
from . import manage

执行：

#在于glance同级的test.py中
import glance
glance.cmd.manage.main()

包的使用之from ... import ...
- 需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法
- ```
from glance.db import models
models.register_models('mysql')

from glance.db.models import register_models
register_models('mysql')
```
from glance.api import *
- 在讲模块时，我们已经讨论过了从一个模块内导入所有*，此处我们研究从一个包导入所有*。
- 此处是想从包api中导入所有，实际上该语句只会导入包api下__init**.py文件中定义的名字，我们可以在这个文件中定义_all**:
- ```
# 在__init__.py中定义
x=10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']
```
- 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入）。
- ```
# 在__init__.py中定义
x = 10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']
```
- 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入）。
- 练习：
- ```
# 执行文件中的使用效果如下，请处理好包的导入
from glance import *

get()
create_resource('a.conf')
main()
register_models('mysql')
```
绝对导入和相对导入
- 我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：
- 绝对导入：以glance作为起始
- 相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）
- 例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py
- ```
在glance/api/version.py

# 绝对导入
from glance.cmd import manage
manage.main()

# 相对导入
from ..cmd import manage
manage.main()
```
- 测试结果：注意一定要在于glance同级的文件中测试
- ```
from glance.api import versions 
```
- 包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的
- 比如我们想在glance/api/versions.py中导入glance/api/policy.py，有的同学一抽这俩模块是在同一个目录下，十分开心的就去做了，它直接这么做
- ```
# 在version.py中

import policy
policy.get()
```
- 没错，我们单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到
- 但是你想啊，你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入，比如我们在于glance同级下的一个test.py文件中导入version.py，如下
- ```
from glance.api import versions

'''
执行结果:
ImportError: No module named 'policy'
'''

'''
分析:
此时我们导入versions在versions.py中执行
import policy需要找从sys.path也就是从当前目录找policy.py,
# 这必然是找不到的
'''
```

绝对导入与相对导入总结

绝对导入与相对导入

# 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
#       优点: 执行文件与被导入的模块中都可以使用
#       缺点: 所有导入都是以sys.path为起始点,导入麻烦

# 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
# 符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
#       优点: 导入更加简单
#       缺点: 只能在导入包中的模块时才能使用
# 注意:
#　　1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内
#    2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之#       意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

相关阅读:
ssh 代理详细解释
 c++ extern c
php 删除换行符
 doxygen 模板
 php 判断字符串
 php 链接 mysql 数据库
 远程桌面管理:tsmmc.msc在xp系统中的使用
 更改Server 2008域用户密码策略
 Windows Server 2008 IIS7部署
 iis6中FTP配置的技巧和细节
原文地址：https://www.cnblogs.com/zhangdadayou/p/11415293.html