Python 模块（二）

Posted on

1 logging 模块

logging有两种的配置的方式，configure、logger

1.1 config方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import logging
'''
日志的配置：config模式
只能选择在屏幕或者在文件输出
'''
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s [%(lineno)s] %(message)s' ,
                    filename='log.txt',
                    filemode='a'
                    )
# logging.debug('debug message')  只有这些内容的时候是只显示在屏幕
# logging.info('info message')
# logging.warning('warning message')
# logging.error('error message')
# logging.critical('critical message')
logging.info('info message')

通过logging.basicConig可以配置输出的格式，level=DEBUG，还可以是INFO、WARNING、ERROR、DIGITAL,这个的优先级是从上往下的。设置好了哪一个就会显示他后面的。

1.2 logger

推荐用logger

默认的情况是输出到屏幕的

1
2
3
4
5
6
7
8
import logging
logger=logging.getLogger()
logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')

可通过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import logging
logger=logging.getLogger()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh=logging.FileHandler('test.txt') # 文件流
sh=logging.StreamHandler() # 屏幕流
fh.setFormatter(formatter)  # 这是通过对象实现的设置格式
sh.setFormatter(formatter)  #
logger.addHandler(fh)
logger.addHandler(sh)
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')

函数的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def logger():
    logger = logging.getLogger()  # 吸星大法
    fh = logging.FileHandler('logger.txt')  # 文件流
    sh = logging.StreamHandler()            # 屏幕流
    logger.addHandler(fh)  # 追加写  设置成文件写入
    logger.addHandler(sh)  # 默认是屏幕流 关闭后就屏幕不输出
    logger.setLevel(logging.DEBUG)  # 设置等级 操作的对象是logger
    fm = logging.Formatter('%(asctime)s [%(lineno)s] %(message)s')
    fh.setFormatter(fm)  # 文件的对象
    # sh.setFormatter(fm) # 屏幕的对象 添加格式
    return logger
logger1=logger()  # 现在是把函数的运行结果给一个对象
# 对象能够使用方法
logger1.debug('debug message')
logger1.info('info message')
logger1.warning('warning message')
logger1.error('error message')
logger1.critical('critical message')

2 序列化模块

2.1 JSON

json是不同语言之间的数据准换

序列化 反序列化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import json
'''
序列化
'''
d={'a':123,"b":456} # 数据格式是字典
s=json.dumps(d)  # 转换成json字符串（实际是Unicode）
print(s)  # 这是json中的数据  {"a": 123, "b": 456}  是双引号
print(type(s))
# f=open('b.txt','w')
# f.write(s)
# f.close()
'''
反序列化
'''
f=open('b.txt')
data=f.read()
print(data)
data2=json.loads(data)   # 现在就是字典的格式
print(data2)

1
json.dump(d,f) # d 是字典  f是文件句柄  有写入的操作

json 应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"aa"}
json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)
print(json_str1)   #'10'
print(json_str2)   #'"hello"'
print(json_str3)   #'[1, 4, 6]'   # 元组转换成json格式
print(json_str4)   #'[3, 5, 7]'
print(json_str5)   #'{"name": "aa"}'

2.2 pickle模块

在python中能够序列化任何数据类型，是Python专用 的

序列化

1
2
3
4
5
6
7
8
9
10
import pickle  # pickle 是Python文件中间转换的
import datetime
# print(datetime.datetime.now())
t=datetime.datetime.now()
d={'data':t}
s=pickle.dump(d,open('new','wb'))  # json 不支持时间的格式
print(s)

反序列化

1
2
3
f=open('new','rb')
data=pickle.loads(f.read())
print(data)

3 正则模块re

正则是对字符串的模糊匹配

re.findall(‘元字符’,”字符串”)

是字符串中的每一个去对应元字符中的规则

元字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1.通配符"."    # 不能配换行符\n,如果有换行符，返回一个空列表
2.模糊匹配"*"    [0,+∞]
3.              +     [1,+∞]
4.             ？	 [0,1]
5.              {}   	{0,}==*   {1,}==+   {0,1}==？
6.字符集 [ab]  a b 是或者的关系
	\* + 是普通字符
	\- ^ \ 有特殊用处  
	[0-9]+
    [a-z]+
    [^2]   取反
    [^\d ]  单个
    [^\d]+  多个连续的
7.分组（）    "（ab）+","add"  # 分组中默认只有一个
取消优先级（？：）
8. | ：或
9. \  
		  \d   
          \w
          \.   
          \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  匹配一个特殊字符边界，比如空格 ，&，＃等
		r'\b',''  \b在ASCII中有专门的意思

命名分组

1
2
3
4
res=re.search(r"(?P<A>\w+)\\article\\(?P<id>\d+)", r"abc\article\123", flags=0)
print(res)
print(res.group("A"))
print(res.group("id"))

结果：
abc
123

无命名分组

1
2
res=re.findall("(ad)+abc", "adabcnnf", flags=0)  
res=re.findall("(?:ad)+abc", "adabcnnf", flags=0)  # 取消优先级

结果：
[‘ad’]
[‘adabc’]

finditer 方法

1
2
res=re.finditer("\d+", "ad324daa", flags=0)
print(res)

结果：是一个生成器
callable_iterator object at 0x0000000002B29240>
用next方法

1
2
print(next(res).group())
print(next(res).group())

search 方法

search 值匹配第一个结果

1
2
3
res= re.search("\d+", "sjasdff454asef2352", flags=0)
print(res)
print(res.group())

match 方法

mach只在字符串开始的位置匹配

1
2
3
res = re.match("\d+", "123nljklkl2565+6", flags=0)
print(res)
print(res.group())

split 方法

maxsplit是最大的分割次数，默认是0

1
2
res=re.split("\d+", "asd123fk234as123df1231sdf132fff", maxsplit=4, flags=0)
print(res)

[‘asd’, ‘fk’, ‘as’, ‘df’, ‘sdf132fff’] 第5次没有继续分割

sub 方法

1
2
res = re.sub("\d+", "A","abc2342abc123aaa123",  count=3,flags=0)
print(res)

结果：
abcAabcAaaaA

compile 方法

1
2
3
res = re.compile("\d+", flags=0)
res2 = res.findall("hello1232")   # 把编译好的直接用
print(res2)
© 2018 Peter's Blog Center All Rights Reserved.
Theme by hiero