Python日志、序列化、正则模块

使用Python内置模块的目的：拿来别人已经写好的模块功能，直接import内置模块使用，简化程序，避免重复造轮子的过程，提示自己的开发效率；

一、 loging日志模块：

1、 loging模块可以记录不同安全级别日志：

debug、info、warning、error、critical（关键的）可以灵活使用；（5中安全级别日志全部记录，或选择其中几种级别记录）

import logging

logging.debug("修复") #5种安全级别 灵活使用
logging.info("提示")
logging.warning("注意")#--------注意---------高于waring（默认等级）此安全级别的日志才会显示到屏幕上
logging.error("错误")
logging.critical("重要")

执行结果
WARNING:root:注意
ERROR:root:错误
CRITICAL:root:重要

2、日志输出流

既然记录了日志就应该  显示到屏幕 或者 保存至文件，这就是日志输出流；

3、日志格式配置

上述日志信息单纯，记录价值不大，我们可以设置它的日志格式。loging模块提供了2种 日志配置方式；

（1）basicConfig函数配置方式（一切围绕basicConfig函数里放什么参数展开）

logging.DEBUG     　　           #设置日志安全级别 

format='%(asctime)s'            #asctime：配置当前时间

'---%(message)s'                #message：配置日 义信息
'%(lineno)s',                   #lineno:打印输出日志函数所在的行号
datefmt='%Y-%m-%d %H:%M:%S',    #设置日期格式  datefmt
filename="loger",               #设置"日志输出流的文件'filename
filemode="a")                   #设置以追加方式记录到文件 filemode

logging.basicConfig(level=logging.DEBUG,               #设置日志安全级别 logging.DEBUG
                    format='%(asctime)s'               #asctime：配置当前时间
                        '---%(message)s'               #message：配置日志的自定义信息
                        '%(lineno)s',                  #lineno:打印输出日志函数所在的行号
                    datefmt='%Y-%m-%d %H:%M:%S',       #设置日期格式  datefmt
                    filename="loger",                  #设置"日志输出流的文件'filename
                    filemode="a")                      #设置以追加方式记录到文件 filemode
logging.debug("修复")
logging.info("提示")
logging.warning("注意")
logging.error("错误")
logging.critical("重要")

（2）loger对象配置日志格式

basicConfig只能同时选择一种日志输出流，而loger对象可以把日志信息，同时输出到屏幕和文件里。

loger对象配置日志格式，一切围绕高度定制化、组装原则，1 创建loger 2创建输出对象 3创建输出格式对象， 相互组装起来；

loger=logging.getLogger()                   #得到一个原始的loger对象

file_stream=logging.FileHandler("Loger2")  #创建1个文件输出对象
sh=logging.StreamHandler()                 #创建一个屏幕输出对象

Format=logging.Formatter("%(asctime)s-%(levelname)s-%(message)s") #创建一个日志格式对象
#-------------------------------------------------------------------------------------------------------------
#loger配置日志格式方式：就是围绕一切高度定制化的原则展开

#（1）先创建出 loger对象，屏幕输出对象，文件输出对象，日志格式对象
# （2）让 loger对象 吸取 文件、屏幕输出流对象
#（3） 让 文件、屏幕输出流对象吸取日志格式对象功能

file_stream.setFormatter(Format)   #文件输出流吸取 日志格式对象
sh.setFormatter(Format)            #屏幕输出流吸取 日志格式对象

loger.setLevel(logging.DEBUG)      #设置日志等级
loger.addHandler(file_stream)      #原始的loger对象 吸走文件输出对象，就可以把日志信息输出到文件了；
loger.addHandler(sh)               #原始的loger对象，吸走屏幕输出对象，就可以把日志信息输出到屏幕了；
                            #loger对象貌似有了吸星大法，可以通过addHandler（）方法，吸取对象的功能，以为己用；
loger.debug("修复")
loger.info("提示")
loger.warning("注意")      #默认安全级别也是waring，waring以上安全级别的日志才回输出
loger.error("错误")
loger.critical('重要')

 二、序列化模块 json、picle

1、 josn就是各种语言 之间 信息交换的桥梁，一种各语言普遍支持的 中间数据类型；

每种编程语言都有自己的数据类型，不同语言之间 交换数据就就需要 通过序列化来完成；

序列化：把对象（Python的变量、列表、字典...）从内存中变成可以存储或传输的过程就是序列化；

json.dumps()、json.loads()方法：

import json
d={'name':'zhanggen'}
j=json.dumps(d)             # 序列化：json.dumps()把 Python里面的字典类型转出成 json字符串；
                            # 这样就可以把数据写入文本、网络传输了；
with open('b.txt','w') as f:
    f.write(j)
    f.flush()
#----------------------------------------   反序列化：把json字符串 转换成，Python对应的数据类型。
with open('b.txt','r') as f:
    d1=json.loads(f.read())    #

print(d1['name'])

json.dump()、json.load()方法：

with open("new_b.txt",'w') as f:
    json.dump(d,f)                       # json.dump(d,f)方法比较对应写入文件，该方法可以传2个参数 （数据，写入的文件）
                                         #省略了 f.write()这一步了；
                                         #1、把d转换成json字符串，把json字符串直接写入f文件对象

with open("new_b.txt",'r') as f:
   print(json.load(f)['name'])          #load（文件句柄）方法 可以直接把文件句柄传进去，自动转换成Python相应类型

 三、正则表达式模块 re

 

正则表达式 用来描述 匹配、查找字符的  某一种规则；

Python字符串的方法（replace，） 只有一些简单的完全匹配模式，查找处理的内容比较单一；（说1找1 说2找2），固有了Python有了 re模块；

re：实现对字符串的模糊匹配 （可以写一个正则规则，批量匹配，找出符合某些规则的字符，匹配多个字符）

1、 正则表达式 由 元字符（有特殊功能的字符）+查找对象组成

 

2、re基本元字符介绍：人类世界里如果想要表达自己的意图，可以使用语言或者文字+你的对象。在正则里想要表达自己的匹配意图使用元字符+匹配对象；

（1）单个字符匹配：

. : 匹配除了换行符之外的，任意1个字符
[] :匹配指定范围内的任意单个字符，如果[ab]里有两个字符，就是a或者b的意思 （注意在 字符集[]里 *，+，.都是普通字符，不再具有元字符功能， -,^,\除外）
[^]:匹配指定范围外的任意单个字符 （注意^符号在[]字符集里面表示取反）
|：管道符 或 的意思和[ab]功能一样
^ab ：以什么开头的字符；（只匹配开始的位置）
ab$ :以什么结尾的字符 （只匹配结束位置，$符号要放在要匹配的字符后面）
\d:匹配0-9之间的任意1个数字 
\D：非0-9之间的数字
\w匹配任意1个字母和数字（除了特殊符号）
\W匹配非字母和数字
\s匹配空白字符
\S 匹配非空白的字符(只要不是空白都可以匹配 * 、- 、+)

\b:匹配一个特殊字符（空格、&、#）边界

\：转意符，把一部分普通字符（\d,\w）变成具有特殊意义的元字符，把具有特殊意义的元字符变成普通字符；

(): 分组 使用N个匹配规则对1个字符串进行匹配，得到N组匹配结果，（）里的内容优先显示;

str1=''

pattern1=re.compile(r'(\d+)(4961\d+)')                         #无名名分组
pattern2=re.compile(r'(?P<bao_ding>\d+)(?P<tang_xian>496\d+)') #有名分组

match_obj1=re.match(pattern1,str1)
match_obj2=re.match(pattern2,str1)

print(match_obj2.groups())              #查看匹配到的所有分组        ('0312', '4961103')

print(match_obj1.group(1))             #根据索引位置查看
print(match_obj1.group(2))             #根据索引位置查看

print(match_obj2.group('bao_ding'))   #根据组名查看             0312
print(match_obj2.group('tang_xian'))  #根据组名查看            4961103

无名分组|有名分组

(?:) 取消分组的优先级

一定要注意正则表达式里的元字符有 两种类型 一种是表示单个字符意义的，另一种是表示重复意义的；

（2）重复元字符：（表示从复表达  左边的字符 多少次 ）

* ：       匹配*左边的字符 0-N次；

+ ：      从复+左边的字符 1-无穷次

{1} :      从复指定的次数

{1，6} : 从复1-6次数

？:        从复0次或者1次

常用：(.*?)

3、re模块的方法

re.findall（）：找到所有符合匹配规则的元素，返回一个列表；基本正则表达式元字符：（匹配找到的所有结果）

print(re.findall( '-?\d+\.?\d*\*-?\d+\.?\d*','2*-6+7*45+1.4*3-8/4')

re.finditer()：匹配结果为一个迭代器

patten=re.compile(r'hello') :编写一个匹配规则

import re

str0='h123elloworld'
pattern0=re.compile(r'^h(.*?)e')      #创建1条匹配规则

match_obj=re.match(pattern0,str0)   #march方法返回1个match对象

# print(match_obj)                    #<_sre.SRE_Match object; span=(0, 5), match='hello'>
print(match_obj.group())            #匹配成功的字符串 hello

# print(match_obj.start())            #开始匹配的index位置 0
# print(match_obj.end())              #结束匹配的index位置 5
#
# print(match_obj.span())             #字符串 索引跨度
# print(match_obj.span(2))

re.match()

re.search()：只匹配找到的第一个结果

re.sub()：替换匹配结果

re.sub([all ],flags=re.S)：替换所有匹配结果，flags=re.S匹配所有换行和空格

desc=mark_safe(re.sub (r'[\n]','<br/>',desc1,flags=re.S)) #替换所有换行，在前端显示

re.match()和re.search()的区别？

性能

match()函数只检测RE是不是在string的开始位置匹配

search()会扫描整个string查找匹配,会扫描整个字符串并返回第一个成功的匹配