今日主要内容

  • 正则表达式
  • logging模块

一、正则表达式

（一）什么是正则表达式

  1. 正则表达式的定义：
    • 是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
    • 简单来说，我们使用正则表达式就是为了对字符串进行 匹配 和 过滤
  2. 正则表达式的特点：
    • 灵活性强、逻辑性强、功能性强
    • 可以迅速的用极简单的方式控制复杂的字符串

（二）正则表达式的构成

  • 正则表达式由普通字符和元字符构成
    • 普通字符
    • 元字符

  1. 普通字符

    • 普通字符包括：大小写字母、数字，在匹配普通字符的时候直接写就可以了，Python也能实现同样的效果，很简单

      • 利用re模块，返回正则表达式匹配过滤出来的字符
      import re

s = "zxdnbzxdnb"
print(re.findall("zxd", s))  # 普通字符，直接写就好了

运行结果：
['zxd', 'zxd']  # 成功匹配过滤
      • Python基础逻辑也可以实现
      s = "zxdnbzxdnb"

print("zxd" in s)  # 是否存在
print(s.count("zxd"))  # 存在几个
print(["zxd"] * 2)  # 打印出来就好了

运行结果：
True
2
['zxd', 'zxd']  # 实现同样的效果

  2. 元字符

    • 元字符才是正则表达式的灵魂所在，介绍部分内容:

      • 字符组
      • 常用元字符（单一匹配）
      • 量词

    • 字符组

      • 字符组用[]表示，[]中出现的内容会被匹配到

        例：匹配到字符串"zxdhnbzxdznbzxdtnb"中的"hnb" "znb" "tnb"

        import re

s = "zxdhnbzxdznbzxdtnb"
print(re.findall("[hzt]nb", s))

运行结果：
['hnb', 'znb', 'tnb']  # 将字符串中含有"hnb"、"znb"、"tnb"的部分过滤出来

      • []还可填入一个范围，比如[0-9a-zA-Z]它可以匹配字符串中0到9，a到z，A到Z中的字符

        例：匹配到字符串"zxd123456zxdznb"中的数字

        import re

s = "zxd123456zxdznb"
print(re.findall("[0-9]", s))

运行结果：
['1', '2', '3', '4', '5', '6']  # 匹配到字符串中的0到9的数字

      • 范围遵循ascii码的从小到大规定，比如[A-z]可以匹配之间的所有字符，但[a-Z]只能匹配到a

        import re

s = "asdzxcqwe123!@#"
print(re.findall("[A-z]", s))
print(re.findall("[a-Z]", s))

运行结果：
['a', 's', 'd', 'z', 'x', 'c', 'q', 'w', 'e']  # [A-z]匹配成功
sre_constants.error: bad character range a-Z at position 1  # [a-Z]报错

      • 字符组还可以反向过滤，在[]中加入^，比如[^123]它可以匹配字符串中除了123以外的所有字符

        例：匹配到字符串"zxdznb123456789"中除数字以外的字符

        import re

s = "zxdznb123456789"
print(re.findall("[^0-9]", s))

运行结果：
['z', 'x', 'd', 'z', 'n', 'b']  # 匹配到字符串中除数字以外的字符

      • 应用举例：通过匹配判断手机号输入是否正确（有点low的例子）

        import re

number = input("手机号:")
if len(number) != 11:
    print("手机号输入有误！")
else:
 num = re.findall("[1][3-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]", number)
    if not num:
        print("手机号格式不正确！")
    else:
        print("手机号可以使用！")

    • 常用元字符（单一匹配）

      \w 匹配字母（含中文）、数字、下划线
      \W 匹配非字母（含中文）、数字、下划线
      \s 匹配空白符
      \S 匹配非空白符
      \d 匹配数字
      \D 匹配非数字
      \b 匹配单词的边界
      \B 匹配非单词的边界
      \A 匹配字符串的开始
      ^ 匹配字符串的开始
      \Z 匹配字符串的结尾
      $ 匹配字符串的结尾
      \n 匹配一个换行符
      \t 匹配一个制表符
      . 匹配除换行符以外任意字符
      a|b 匹配字符a或b
      () 分组，匹配括号内的表达式
      [] 匹配字符组内的字符
      [^] 匹配除字符组以外的字符

      • \w ：匹配字符串中字母（含中文）、数字、下划线

        例：匹配到字符串"zxd123\n456！@#￥"中的字母和数字

        import re

s = "zxd123\n456！@#￥"
print(re.findall("\w", s))

运行结果：
['z', 'x', 'd', '1', '2', '3', '4', '5', '6']

      • \W ：匹配字符串中非字母（含中文）、数字、下划线

        例：匹配到字符串"zxd123\n456！@#￥"中的非字母和数字的内容

        import re

s = "zxd123\n456！@#￥"
print(re.findall("\W", s))

运行结果：
['\n', '！', '@', '#', '￥']

      • \s ：匹配空白符（包含空格、制表符和换行符 ）

        例：匹配到字符串"zxd \t123 \n456 ！@#￥"中的空白符

        import re

s = "zxd  \t123  \n456  ！@#￥"
print(re.findall("\s", s))

运行结果：
[' ', ' ', '\t', ' ', ' ', '\n', ' ', ' ']

      • \S ：匹配非空白符

        例：匹配到字符串"zxd \t123 \n456 ！@#￥"中非空白符的内容

        import re

s = "zxd  \t123  \n456  ！@#￥"
print(re.findall("\S", s))

运行结果：
['z', 'x', 'd', '1', '2', '3', '4', '5', '6', '！', '@', '#', '￥']

      • \d ：匹配数字

        例：匹配到字符串"zxd123456zxdznb"中的数字

        import re

s = "zxd123456zxdznb"
print(re.findall("\d", s))

运行结果：
['1', '2', '3', '4', '5', '6']

      • \D ：匹配非数字

        例：匹配到字符串"zxd123456zxdznb"中的非数字的内容

        import re

s = "zxd123456zxdznb"
print(re.findall("\D", s))

运行结果：
['z', 'x', 'd', 'z', 'x', 'd', 'z', 'n', 'b']

      • \b ：匹配单词边界

        例：匹配到字符串"周杰伦-麻花藤-潘长江-赵本山-林俊周-韩周鸿-周猩猩-周星"中所有姓周的人名

        import re

s = "周杰伦-麻花藤-潘长江-赵本山-林俊周-韩周鸿-周猩猩-周星"
print(re.findall(r"\b周\w+", s))

运行结果：
['周杰伦', '周猩猩', '周星']

      • \B ：匹配非单词边界

        例：匹配到字符串"周杰伦-麻花藤-潘长江-赵本山-林俊周-韩周鸿-周猩猩-周星"中所有名带有周的人

        import re

s = "周杰伦-麻花藤-潘长江-赵本山-林俊周-韩周鸿-周猩猩-周星"
print(re.findall(r"\w+\B周\w*", s))

运行结果：
['林俊周', '韩周鸿']

      • \A ：匹配字符串的开头（不常用，知道就行）

        例：匹配到字符串"zxdhnbzxdznb"的开头

        import re

s = "zxdhnbzxdznb"
print(re.findall("\A\w", s))

运行结果：
['z']

      • ^ ：匹配字符串的开头（常用）

        例：匹配到字符串"zxdhnbzxdznb"的开头

        import re

s = "zxdhnbzxdznb"
print(re.findall("^\w", s))

运行结果：
['z']

      • \Z ：匹配字符串的结尾（不常用，知道就行）

        例：匹配到字符串"zxdhnbzxdznb"的结尾

        import re

s = "zxdhnbzxdznb"
print(re.findall("\w\Z", s))

运行结果：
['b']

      • $ ：匹配字符串的结尾（常用）

        例：匹配到字符串"zxdhnbzxdznb"的结尾

        import re

s = "zxdhnbzxdznb"
print(re.findall("\w$", s))

运行结果：
['b']

      • ^ 和 $ 结合使用时，两者之间的长度一定要和待匹配的字符串长度相同，否则匹配不上

        import re

s = "zxdznb666"
print(re.findall("^zxdznb666$", s))
print(re.findall("^zxdznb$", s))

运行结果：
['zxdznb666']
[]

      • ^ 和 $ 的应用举例：通过匹配判断手机号输入是否正确（升级版，还是很low）

        import re

number = input("手机号:")
num = re.findall("^[1][3-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]$", number)  # 匹配到以1开头，以0到9结尾的一串11位数字
if not num:
    print("手机号格式不正确！")
else:
 print("手机号可以使用！")

      • \n ：匹配换行符

        例：匹配到字符串"zxd \t123 \n456 ！@#$"中的换行符

        import re

s = "zxd  \t123  \n456  ！@#$"
print(re.findall("\n", s))

运行结果：
['\n']

      • \t ：匹配制表符

        例：匹配到字符串"zxd \t123 \n456 ！@#$"中的制表符

        import re

s = "zxd  \t123  \n456  ！@#$"
print(re.findall("\t", s))

运行结果：
['\t']

      • . ：匹配除换行符任意的字符，当指定re.DOTALL时，可以匹配含换行符以内的任意字符

        例：匹配字符串"zxd123\n456"中所有内容（含换行符|不含换行符)

        import re

s = "zxd123\n456"
print(re.findall(".", s))
print(re.findall(".", s, re.DOTALL))

运行结果：
['z', 'x', 'd', '1', '2', '3', '4', '5', '6']
['z', 'x', 'd', '1', '2', '3', '\n', '4', '5', '6']

      • a|b ：匹配字符a或b，优先匹配前面，只要前面匹配到了后面就不看了，继续向下匹配

        例：匹配到字符串"zxdnb666zxd"中的zxd 和666

        import re

s = "zxdnb666zxd"
print(re.findall("zxd|666", s))

运行结果：
['zxd', '666', 'zxd']

      • () ：分组，匹配括号内的表达式，可以在括号两端增加限制

        例：匹配到字符串"zxdnb66zxd66zxd"中的zxd，只匹配到66中间的zxd

        import re

s = "zxdnb66zxd66zxd"
print(re.findall("(zxd)", s))
print(re.findall("66(zxd)66", s))

运行结果：
['zxd', 'zxd', 'zxd']
['zxd']

      • [] ：匹配字符组范围内的字符

      • [^] ：匹配非字符组范围内的字符

    • 量词（多个匹配）

      ***** 重复零次或更多次
      + 重复一次或更多次
      ？ 重复零次或一次
      {n} 重复n次
      {n,} 重复n次或更多次
      {n,m} 重复n到m次
      • ***** ：重复零次或更多次
      import re

s = "zxdnb66zxd66zxd"
print(re.findall("6*", s))

运行结果：
 ['', '', '', '', '', '66', '', '', '', '66', '', '', '', '']
      • + ：重复一次或更多次
      import re

s = "zxdnb66zxd66zxd"
print(re.findall("6+", s)) 

运行结果：
['66', '66']
      • ？：重复零次或一次
      import re

s = "zxdnb66zxd66zxd"
print(re.findall("6?", s))

运行结果：
['', '', '', '', '', '6', '6', '', '', '', '6', '6', '', '', '', '']
      • {n} ：重复n次
      import re

s = "zxdnb66zxd66zxd"
print(re.findall("\w{3}", s))

运行结果：
['zxd', 'nb6', '6zx', 'd66', 'zxd']
      • {n,} ：重复n次或更多次
      import re

s = "zxdnb66-zxd-6-6zxd"
print(re.findall("\w{3,}", s))

运行结果：
['zxdnb66', 'zxd', '6zxd']
      • {n,m} ：重复n到m次
      import re

s = "zxdnb66-zxd-6-6zxd"
print(re.findall("\w{3,5}", s))

运行结果：
['zxdnb', 'zxd', '6zxd']
      • {} 的应用举例：通过匹配判断手机号输入是否正确（再次升级版）
      import re

number = input("手机号:")
num = re.findall("^[1][3-9][0-9]{9}$", number)  # 匹配到以1开头，以0到9结尾的一串11位数字
if not num:
    print("手机号格式不正确！")
else:
   print("手机号可以使用！")

  3. 贪婪匹配和非贪婪匹配（惰性匹配）

    • 贪婪匹配：尽可能多的匹配，量词中的 * + {} 都是贪婪匹配

      import re

s = "zxdznb666"
print(re.findall("\w*", s))
print(re.findall("\w+", s))
print(re.findall("\w{1,3}", s))

运行结果：
['zxdznb666', '']
['zxdznb666']
['zxd', 'znb', '666']
      • 贪婪匹配底层运用到的算法：回溯算法

    • 非贪婪匹配（惰性匹配）：尽可能少的匹配，量词中的 ? 是非贪婪匹配

      import re

s = "zxdznb666"
print(re.findall("\w{1,3}?", s))

运行结果：
['z', 'x', 'd', 'z', 'n', 'b', '6', '6', '6']
      • 非贪婪匹配底层用到的算法：先去找结束的值，再去判断规则

  4. 转义：定义规则时，会遇到类似于\n这样的具有特殊意义的词，可以使用转义表示，转义有两种方式：

    • 方式一：\\n
    • 方式二：r"\n"

（三）正则模块re

  • 核心方法：

    re.findall() 按规则查找，返回list
    re,finditer() 按规则查找，返回一个迭代器，通过group方法取值
    re.search() 任意位置匹配，匹配到就返回结果，没匹配上返回None
    re.match() 只能从字符串开头开始匹配，匹配到就返回结果，匹配不到返回None

    • re.findall()

      • 函数定义：findall(pattern, string, flags=0)
      • 函数说明：按规则查找，返回一个列表
      import re

s = "zxd123\n456！@#￥"
print(re.findall("\w", s))

运行结果：
['z', 'x', 'd', '1', '2', '3', '4', '5', '6']

    • re,finditer()

      • 函数定义：finditer(pattern, string, flags=0)
      • 函数说明：按规则查找，返回一个迭代器，通过group方法取值
      import re

s = "zxd"
it = re.finditer("\w", s)
for el in it:
    print(el.group())

运行结果：
z
x
d

    • re.search()

      • 函数定义：search(pattern, string, flags=0)
      • 函数说明：任意位置匹配，匹配到就返回结果，没匹配上返回None
      import re

s = "zxdnb66-zxd-6-6zxd"
print(re.search(r"\w+", s).group())

运行结果：
zxdnb66
      • 还可以给分组起名称，利用名称输出
        • 格式为：?P<名称> 
      import re

s = "<h1>hello</h1>"
ret = re.search("<(?P<h>\w+)>(?P<h1>\w+)</(?P<h2>\w+)>",s)
print(ret.group("h"))
print(ret.group("h1"))
print(ret.group("h2"))

运行结果：
h1
hello
h1

    • re.match()

      • 函数定义：match(pattern, string, flags=0)
      • 函数说明：只能从字符串开头开始匹配，匹配到就返回结果，匹配不到返回None
      import re

s = "zxdnb66-zxd-6-6zxd"
print(re.match(r"\w+", s).group())

s = "-zxdnb66-zxd-6-6zxd"
print(re.match(r"\w+", s))

运行结果：
zxdnb66
None

  • 其他方法

    re.split() 可按照任意分隔符进行分隔
    re.sub() 替换
    re.compile() 编译规则

    • re.split()

      • 函数定义：split(pattern, string, maxsplit=0, flags=0)
      • 函数说明：按照填入的参数进行切割，返回一个列表，将填入的参数用括号括起来，则在返回的列表中保留切割参数，还可指定最大切割次数，剩余部分作为最后一个元素存放在列表中
      import re

s = "zxd-nb-666-777-888"
print(re.split("-", s))
print(re.split("(-)", s))
print(re.split("-", s, maxsplit=2))

运行结果：
['zxd', 'nb', '666', '777', '888']
['zxd', '-', 'nb', '-', '666', '-', '777', '-', '888']
['zxd', 'nb', '666-777-888']

    • re.sub()

      • 函数定义：sub(pattern, repl, string, count=0, flags=0)
      • 函数说明：替换，可以通过count控制替换次数
      import re

s = "zxd-nb-666-777-888"
print(re.sub("-", "|", s))
print(re.sub("-", "|", s, 2))

运行结果：
zxd|nb|666|777|888
zxd|nb|666-777-888

    • re.compile()

      • 函数定义：compile(pattern, flags=0)
      • 函数说明：编译一个正则表达式，返回一个规则对象
      import re

s = "zxd-nb-666-777-888"
obj = re.compile("\w+")
print(obj.findall(s))

运行结果：
['zxd', 'nb', '666', '777', '888']

二、logging模块

（一）什么是日志

  • 我们在编写代码的时候，会报很多的错误，错误信息是不会自动生成的，这些错误信息是编写python解释器的程序员们预先写好的日志加入到程序中，如过触发了某种条件会显示到中控台上，我们在写程序的过程中也会不断调试，我们调试的方法一般都是使用print打印出来，这就可以通过日志显示和记录
  • 在python中使用logging模块就可以自定义日志，在我们编写程序的时候，就可以利用自定义日志来进行显示和记录
  • 最重要的一点，日志是给程序员看的，需要给用户看的还是需要print出来

（二）logging模块

  1. logging模块的使用：

    • 基础配置型：简单、可定制化差
    • 对象配置型：复杂、可定制化强

  2. 日志分级

    日志分级 对应解释 级别数值
    debug 调试 10
    info 信息 20
    warning 警告 30
    error 错误 40
    critical 危险 50

  3. 函数式简单配置

    • 基础版日志
    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

    • 说明：

      1. 运行时显示的的结果只有warning、error、critical三个级别的日志信息，logging模块默认从warning级别（30）的日志开始输出
      2. 输出的日志由日志级别、用户名、日志信息三部分构成

    • 通过日志配置函数 logging.basicConfig() 可以调整输出级别、日志内容等信息，配置函数如下：

      • 函数定义：basicConfig(**kwargs)
      • 关键字参数说明：
      filename 指定文件，日志内容将会存储在文件中
      filemode 文件打开方式，指定了filename后才能指定，默认为”a”
      format 日志显示格式，参数如下
      datefmt 时间显示格式
      level 日志级别
      • 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 用户输出的消息
      • 举例：
      import logging

logging.basicConfig(level=logging.DEBUG,  # 调整日志输出等级
                    format="Time:'%(asctime)s' FilePath:'%(pathname)s' [line:%(lineno)d] %(levelname)s Message:'%(message)s'",
                    datefmt='%Y-%m-%d %H:%M:%S')
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

运行结果：
Time:'2019-10-03 15:09:06' FilePath:'D:/python_S26/day17/exercise.py' [line:226] DEBUG Message:'debug message'
Time:'2019-10-03 15:09:06' FilePath:'D:/python_S26/day17/exercise.py' [line:227] INFO Message:'info message'
Time:'2019-10-03 15:09:06' FilePath:'D:/python_S26/day17/exercise.py' [line:228] WARNING Message:'warning message'
Time:'2019-10-03 15:09:06' FilePath:'D:/python_S26/day17/exercise.py' [line:229] ERROR Message:'error message'
Time:'2019-10-03 15:09:06' FilePath:'D:/python_S26/day17/exercise.py' [line:230] CRITICAL Message:'critical message'

  4. 列举三个应用，理解日志的用法

    • logging.debug()的应用
    import logging

logging.basicConfig(level=logging.DEBUG,  # 这里可以通过修改输出等级来控制需要调试的时候输出
                    format="Time:'%(asctime)s' FilePath:'%(pathname)s' [line:%(lineno)d] %(levelname)s Message:'%(message)s'",
                    datefmt='%Y-%m-%d %H:%M:%S')
lst = list()
for el in range(5):
    lst.append(el)
    logging.debug(lst)
print(lst)

运行结果：
[0, 1, 2, 3, 4]  # 并发问题导致先输出lst
Time:'2019-10-03 17:16:49' FilePath:'D:/python_S26/day17/exercise.py' [line:239] DEBUG Message:'[0]'
Time:'2019-10-03 17:16:49' FilePath:'D:/python_S26/day17/exercise.py' [line:239] DEBUG Message:'[0, 1]'
Time:'2019-10-03 17:16:49' FilePath:'D:/python_S26/day17/exercise.py' [line:239] DEBUG Message:'[0, 1, 2]'
Time:'2019-10-03 17:16:49' FilePath:'D:/python_S26/day17/exercise.py' [line:239] DEBUG Message:'[0, 1, 2, 3]'
Time:'2019-10-03 17:16:49' FilePath:'D:/python_S26/day17/exercise.py' [line:239] DEBUG Message:'[0, 1, 2, 3, 4]'
    • logging.info()的应用
    import logging

logging.basicConfig(level=logging.INFO,
                    format="Time:'%(asctime)s' FilePath:'%(pathname)s' [line:%(lineno)d] %(levelname)s Message:'%(message)s'",
                    datefmt='%Y-%m-%d %H:%M:%S')
userinfo = dict()
user = input("账号:")
pwd = input("密码:")
userinfo[user] = pwd
logging.info(f"注册的账号:{user},注册的密码:{pwd}")  # 记录程序运行时的信息

运行结果：
账号:zxd
密码:zxd123
Time:'2019-10-03 17:35:07' FilePath:'D:/python_S26/day17/exercise.py' [line:251] INFO Message:'注册的账号:zxd,注册的密码:zxd123'
    • logging.error()的应用
    import logging

logging.basicConfig(level=logging.INFO,
                    format="Time:'%(asctime)s' FilePath:'%(pathname)s' [line:%(lineno)d] %(levelname)s Message:'%(message)s'",
                    datefmt='%Y-%m-%d %H:%M:%S')
try:
    def division(a, b):
        c = a / b
        return c

    division(3, 0)
except ZeroDivisionError:
    print("除数不能为0")
    logging.error("输入除数为0")

运行结果：
除数不能为0
Time:'2019-10-03 17:51:46' FilePath:'D:/python_S26/day17/exercise.py' [line:266] ERROR Message:'输入除数为0'

  5. 函数式简单配置有两个弊端：

    • 编码不能修改
    • 中控台和文件不能同时进行（要么在中控台显示，要么写入文件）

  6. logger对象配置

    • 利用logger对象来操作日志文件，具体流程如下：
      • 创建一个logger对象，用来操作日志
      • 创建一个文件管理操作符，用来写入文件
      • 创建一个屏幕管理操纵符， 用来屏幕显示
      • 创建一个日志输出的格式
      • 将操作符与输出格式进行绑定
      • 将logger对象与操作符进行绑定
    import logging

logger = logging.getLogger()
# 创建一个logger对象，用来操作日志
fh = logging.FileHandler("log.log", encoding="utf-8")
# 创建一个文件管理操作符，用来写入文件
sh = logging.StreamHandler()
# 创建一个屏幕管理操纵符， 用来屏幕显示
fmt = logging.Formatter("Time:'%(asctime)s' FilePath:'%(pathname)s' [line:%(lineno)d] %(levelname)s Message:'%(message)s'")
# 创建一个日志输出的格式

fh.setFormatter(fmt)
# 将文件管理操作符与输出格式进行绑定
sh.setFormatter(fmt)
# 将屏幕管理操作符与输出格式进行绑定
logger.addHandler(fh)
# 将logger对象与文件管理操作符进行绑定
logger.addHandler(sh)
# 将logger对象与屏幕管理操作符进行绑定

logger.setLevel(logging.DEBUG)
# 调整日志输出级别

logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')

运行结果：
Time:'2019-10-03 18:31:18,217' FilePath:'D:/python_S26/day17/exercise.py' [line:283] DEBUG Message:'debug message'
Time:'2019-10-03 18:31:18,217' FilePath:'D:/python_S26/day17/exercise.py' [line:284] INFO Message:'info message'
Time:'2019-10-03 18:31:18,217' FilePath:'D:/python_S26/day17/exercise.py' [line:285] WARNING Message:'warning message'
Time:'2019-10-03 18:31:18,217' FilePath:'D:/python_S26/day17/exercise.py' [line:286] ERROR Message:'error message'
Time:'2019-10-03 18:31:18,218' FilePath:'D:/python_S26/day17/exercise.py' [line:287] CRITICAL Message:'critical message'
    • 说明：
      • 通过logger对象来操作日志可以让中控台和文件同时进行
      • 通过logger对象写入文件时，可以指定编码方式
      • 灵活性高，创建的对象之间没有关系，通过绑定链在一起，完全可以绑定两个文件管理操作符来写入不同的文件，也可以绑定不同的输出格式

版权声明：本文为tianlangdada原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/tianlangdada/p/11628400.html