python-三方日志库loguru

最新推荐文章于 2024-08-12 11:43:00 发布

士别三日，当挖目相待

最新推荐文章于 2024-08-12 11:43:00 发布

阅读量1.2k

点赞数 20

分类专栏： Python GUI 文章标签： python 前端

本文链接：https://blog.csdn.net/qq_40597070/article/details/135297932

版权

Python GUI 专栏收录该内容

34 篇文章 8 订阅

订阅专栏

安装

pip install loguru

基本应用

loguru 中不同日志级别与日志记录方法对应关系如下：

级别名称	严重度值	记录器法
TRACE	5	logger.trace()
DEBUG	10	logger.debug()
INFO	20	logger.info()
SUCCESS	25	logger.success()
WARNING	30	logger.warning()
ERROR	40	logger.error()
CRITICAL	50	logger.critical()

from loguru import logger
logger.debug("This is a debug...")

"""
2022-04-11 21:55:56.882 | DEBUG    | __main__:<module>:6 - This is a debug...
"""

在 loguru 里面有且仅有一个主要对象，那就是 logger，loguru 里面有且仅有一个 logger，而且它已经被提前配置了一些基础信息，比如比较友好的格式化、文本颜色信息等等。

可以看到其默认的输出格式是上面的内容，有时间、级别、模块名、行号以及日志信息，不需要手动创建 logger，直接使用即可，另外其输出还是彩色的，看起来会更加友好。

简单输出到文件和控制台

以上的日志信息是直接输出到控制台的，并没有输出到其他的地方，如果想要输出到其他的位置，比如存为文件，我们只需要使用一行代码声明即可。

例如将结果同时输出到一个 runtime.log 文件里面，可以这么写：

from loguru import logger

logger.add("./log/2_add_file.log")
logger.debug("This is a debug...")
logger.warning("This is a debug...")

一行 add 语句搞定，运行之后会发现目录下 ./log/2_add_file.log 里面同样出现了刚刚控制台输出的 DEBUG 信息。

2020-05-03 09:26:09.212 | DEBUG    | __main__:<module>:4 - This is a debug...
2020-05-03 09:26:09.212 | WARNING  | __main__:<module>:5 - This is a debug...

也可以通过add自定义输出到控制台的样式

import sys
from loguru import logger

logger.remove()
log_format = "{time:YYYY-MM-DD HH:mm:ss.ms} | 行号：{line} | 错误级别：{level} | 用时：{elapsed} | 模块：{file} | 函数：{function} | 进程名：{process} | 线程名：{thread} | {message}"
logger.add(sys.stdout, format=log_format)

logger.trace("'trace'级别日志,严重度值5")
logger.debug("'debug'级别日志,严重度值10")
logger.info("'info'级别日志,严重度值20")
logger.success("'success'级别日志,严重度值25")
logger.warning("'warning'级别日志,严重度值30")
logger.error("'error'级别日志,严重度值40")
logger.critical("'critical'级别日志,严重度值50")


"""
2022-04-17 22:32:31.3231 | 行号：9 | 错误级别：DEBUG | 用时：0:00:00.006012 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'debug'级别日志,严重度值10
2022-04-17 22:32:31.3231 | 行号：10 | 错误级别：INFO | 用时：0:00:00.007009 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'info'级别日志,严重度值20
2022-04-17 22:32:31.3231 | 行号：11 | 错误级别：SUCCESS | 用时：0:00:00.007009 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'success'级别日志,严重度值25
2022-04-17 22:32:31.3231 | 行号：12 | 错误级别：WARNING | 用时：0:00:00.007009 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'warning'级别日志,严重度值30
2022-04-17 22:32:31.3231 | 行号：13 | 错误级别：ERROR | 用时：0:00:00.007009 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'error'级别日志,严重度值40
2022-04-17 22:32:31.3231 | 行号：14 | 错误级别：CRITICAL | 用时：0:00:00.007009 | 模块：test-1.py | 函数：<module> | 进程名：2888 | 线程名：5912 | 'critical'级别日志,严重度值50
=
"""

`add`介绍

日志常见的就是输出到文件。loguru 对输出到文件的配置有非常强大的支持，比如支持输出到多个文件，分级别分别输出，过大创建新文件，过久自动删除等等。

add 方法就相当于给 logger 添加了一个 Handler，它给我们暴露了许多参数来实现 Handler 的配置

add方法定义:

loguru.Logger 
@overload 
def add(self,
        sink: TextIO | Writable | (Message) -> None | Handler,
        *,
        level: str | int = ...,
        format: str | (Record) -> str = ...,
        filter: str | (Record) -> bool | Dict[str | None, str | int | bool] | None = ...,
        colorize: bool | None = ...,
        serialize: bool = ...,
        backtrace: bool = ...,
        diagnose: bool = ...,
        enqueue: bool = ...,
        catch: bool = ...) -> int

`loguru.add`参数

sink：可以传入一个 file 对象（file-like object），或一个 str 字符串或者 pathlib.Path 对象，或一个方法（coroutine function），或 logging 模块的 Handler（logging.Handler）。
level (int or str, optional) ：应将已记录消息发送到接收器的最低严重级别。
format (str or callable, optional) ：格式化模块，在发送到接收器之前，使用模板对记录的消息进行格式化。
filter (callable, str or dict, optional) ：用于决定每个记录的消息是否应该发送到接收器。
colorize (bool, optional) – 是否应将格式化消息中包含的颜色标记转换为用于终端着色的Ansi代码，或以其他方式剥离。如果None，根据水槽是否为TTY自动作出选择。
serialize (bool, optional) ：在发送到接收器之前，记录的消息及其记录是否应该首先转换为JSON字符串。
backtrace (bool, optional) ：格式化的异常跟踪是否应该向上扩展，超出捕获点，以显示生成错误的完整堆栈跟踪。
diagnose (bool, optional) ：异常跟踪是否应该显示变量值以简化调试。在生产中，这应该设置为“False”，以避免泄漏敏感数据。
enqueue (bool, optional) ：要记录的消息在到达接收器之前是否应该首先通过多进程安全队列。当通过多个进程将日志记录到文件中时，这是非常有用的。这还具有使日志调用非阻塞的优点。
catch (bool, optional) ：是否应该自动捕获接收器处理日志消息时发生的错误。如果True上显示异常消息 sys.stderr。但是，异常不会传播到调用者，从而防止应用程序崩溃。

如果当接收器（sink）是文件路径（ pathlib.Path ）时，可以应用下列参数，同时add() 会返回与所添加的接收器相关联的标识符：

rotation：分隔日志文件，何时关闭当前日志文件并启动一个新文件的条件，;例如，“500 MB”、“0.5 GB”、“1 month 2 weeks”、“10h”、“monthly”、“18:00”、“sunday”、“monday at 18:00”、“06:15”
retention (str, int, datetime.timedelta or callable, optional) ，可配置旧日志的最长保留时间，例如，“1 week, 3 days”、“2 months”
compression (str or callable, optional) ：日志文件在关闭时应转换为的压缩或归档格式，例如，“gz”、“bz2”、“xz”、“lzma”、“tar”、“tar.gz”、“tar.bz2”、“tar.xz”、“zip”
delay (bool, optional)：是否应该在配置了接收器之后立即创建文件，或者延迟到第一个记录的消息。默认为’ False '。
mode (str, optional) ：与内置open()函数一样的打开模式。默认为’ “a”(以附加模式打开文件)。
buffering (int, optional) ：内置open()函数的缓冲策略，它默认为1(行缓冲文件)。
encoding (str, optional) ：文件编码与内置的’ open() ‘函数相同。如果’ None '，它默认为’locale.getpreferredencoding() 。

例如 format、filter、level 等等。它们的概念和格式和 logging 模块都是基本一样的了，例如这里使用format、filter、level来规定输出的格式：

logger.add('runtime.log', format="{time} {level} {message}", filter="my_module", level="INFO")

字符串格式化

loguru 在输出 log 的时候还提供了非常友好的字符串格式化功能,

log_format = "{time:YYYY-MM-DD HH:mm:ss.ms} | 行号：{line} | 错误级别：{level} | 用时：{elapsed} | file：{file} | module{module} | name:{name} | function：{function} | 进程ID：{process} | 线程ID：{thread} | {message}

例子:

import platform
from loguru import logger

rounded_value = round(0.345, 2)

trace= logger.add('2021-3-28.log')

logger.info('If you are using Python {version}, prefer {feature} of course!', version=platform.python_version(), feature='f-strings')

"""
# 执行上述代码，输出结果为
2021-03-28 13:43:26.232 | INFO     | __main__:<module>:9 - If you are using Python 3.7.6, prefer f-strings of course!
"""

添加sink

sink参数非常重要 , 可以传入多种不同的数据结构，汇总如下：

sink 可以传入一个 file 对象，例如 sys.stderr 或者 open('file.log', 'w') 都可以。
sink 可以直接传入一个 str 字符串或者 pathlib.Path 对象，其实就是代表文件路径的，如果识别到是这种类型，它会自动创建对应路径的日志文件并将日志输出进去。
sink 可以是一个方法，可以自行定义输出实现。
sink 可以是一个 logging 模块的 Handler，比如 FileHandler、StreamHandler 等等，或者上文中我们提到的 CMRESHandler 照样也是可以的，这样就可以实现自定义 Handler 的配置。
sink 还可以是一个自定义的类，具体的实现规范可以参见官方文档。

前面所演示的输出到文件，仅仅给它传了一个 str 字符串路径，他就给我们创建了一个日志文件，就是这个原理。

添加 sink 之后我们也可以对其进行删除，相当于重新刷新并写入新的内容。

删除sink

停止日志记录到文件中

需要注意的是在需要自定义输出到控制台样式时，需要先logger.remove()删除默认样式，再添加其他样式否则会造成重复打印。

add 方法添加 sink 之后我们也可以对其进行删除，删除的时候根据刚刚 add 方法返回的 id 进行删除即可，还原到标准输出。如下：

from loguru import logger

trace= logger.add('2021-3-28.log')
logger.error('This is error information')

logger.remove(trace)
logger.warning('This is warn information')

"""
控制台输出如下：
2021-03-28 13:38:22.995 | ERROR    | __main__:<module>:7 - This is error information
2021-03-28 13:38:22.996 | WARNING  | __main__:<module>:11 - This is warn information

日志文件 2021-3-28.log 内容如下：
2021-03-28 13:38:22.995 | ERROR    | __main__:<module>:7 - This is error information
"""

首先 add 了一个 sink，然后获取它的返回值，赋值为 trace。随后输出了一条日志，然后将 trace 变量传给remove 方法，再次输出一条日志.

看看结果发现，在调用 remove 方法之后，确实将历史 log 删除了。

# 文件输出日志
2022-04-11 22:15:14.260 | DEBUG    | __main__:<module>:8 - this is a debug message
2022-04-11 22:15:14.261 | DEBUG    | __main__:<module>:9 - --------------------------------------------------


# 控制台输出日志
2022-04-11 22:15:14.260 | DEBUG    | __main__:<module>:8 - this is a debug message
2022-04-11 22:15:14.261 | DEBUG    | __main__:<module>:9 - --------------------------------------------------
2022-04-11 22:15:14.261 | DEBUG    | __main__:<module>:12 - this is another debug message

level 配置日志最低日志级别

from loguru import logger

trace = logger.add('2021-3-29.log', level='ERROR')

rotation 配置日志滚动记录的机制

rotation 配置日志滚动记录的机制. 我们想周期性的创建日志文件，或者按照文件大小自动分隔日志文件，我们可以直接使用 add 方法的 rotation 参数进行配置。

每 200MB 创建一个日志文件，避免每个 log 文件过大，如下：

from loguru import logger
trace = logger.add('2021-3-28.log', rotation="200 MB")

每天6点创建一个日志文件，如下:

from loguru import logger
trace = logger.add('2021-3-28.log', rotation='06:00')

每隔2周创建一个日志文件，如下：

from loguru import logger
trace = logger.add('2021-3-28.log', rotation='2 week')

retention 配置日志自动滚动

很多情况下，一些非常久远的 log 对我们来说并没有什么用处了，它白白占据了一些存储空间，不清除掉就会非常浪费。retention 这个参数可以配置日志的最长保留时间。

根据实际运用"1 week, 3 days", "2 months"参数，也可以直接用数字代表日志保留个数

比如我们想要设置日志文件+最长保留 10 天，可以这么来配置：
```
from loguru import logger
logger.add('runtime.log', retention='10 days')
```

设置日志文件最长保留 7 天，如下：

from loguru import logger
trace = logger.add('2021-3-28.log', retention='7 days')

固定时间滚动

比如要按时间滚动，只需要在 logger.add 参数中添加一个 rotation 参数即可。
```
from loguru import logger
logger.add("file_2.log", rotation="12:00") # Create new file at 12AM
logger.debug("That's it, beautiful and simple logging!")
```
这样，如果当前时间超过了这个设定的时间，就会生成一个新的日志文件。如果没有，请使用原始日志文件。
按大小滚动

除了按时间滚动日志外，Loguru 还可以按日志大小滚动。
```
from loguru import logger
logger.add("file_1.log", rotation="1 MB")
logger.debug("That's it, beautiful and simple logging!")
```
这样，一旦日志文件大小超过1MB，就会生成一个新的日志文件。

compression 配置日志压缩格式

loguru 还可以配置文件的压缩格式，比如使用 zip 文件格式保存

可选格式为"gz", "bz2", "xz", "lzma", "tar", "tar.gz", "tar.bz2","tar.xz", "zip"

比如使用 zip 文件格式保存，示例如下：

from loguru import logger

trace = logger.add('2021-3-28.log', compression='zip')

enqueue多进程安全

Loguru 默认是线程安全的，但它不是多进程安全的。

但如果你需要多进程/异步日志记录，它也支持，只需添加一个 enqueue 参数即可。

logger.add("somefile.log", enqueue=True)

serialize 日志序列化

输出类似于Json-line格式的结构化日志，我们可以通过 serialize 参数，将日志信息序列化的json格式写入log 文件，最后可以将日志文件导入类似于MongoDB、ElasticSearch 中用作后续的日志分析，代码示例如下：

from loguru import logger
import platform

rounded_value = round(0.345, 2)

trace= logger.add('2021-3-28.log', serialize=True)

logger.info('If you are using Python {version}, prefer {feature} of course!', version=platform.python_version(), feature='f-strings')

在2021-3-28.log日志文件，我们可以看到每条日志信息都被序列化后存在日志文件中，如下：

{
    "text": "2021-03-28 13:44:17.104 | INFO     | __main__:<module>:9 - If you are using Python 3.7.6, prefer f-strings of course!\n",
    "record": {
        "elapsed": {
            "repr": "0:00:00.010911",
            "seconds": 0.010911
        },
        "exception": null,
        "extra": {
            "version": "3.7.6",
            "feature": "f-strings"
        },
        "file": {
            "name": "2021-3-28.py",
            "path": "F:/code/MOC/2021-3-28.py"
        },
        "function": "<module>",
        "level": {
            "icon": "\u2139\ufe0f",
            "name": "INFO",
            "no": 20
        },
        "line": 9,
        "message": "If you are using Python 3.7.6, prefer f-strings of course!",
        "module": "2021-3-28",
        "name": "__main__",
        "process": {
            "id": 22604,
            "name": "MainProcess"
        },
        "thread": {
            "id": 25696,
            "name": "MainThread"
        },
        "time": {
            "repr": "2021-03-28 13:44:17.104522+08:00",
            "timestamp": 1616910257.104522
        }
    }
}

Traceback 记录（异常回溯支持）

很多情况下，如果遇到运行错误，而我们在打印输出 log 的时候万一不小心没有配置好 Traceback 的输出，很有可能我们就没法追踪错误所在了。

用了 loguru 之后，我们用它提供的装饰器就可以直接进行 Traceback 的记录，类似这样的配置即可：

from loguru import logger


@logger.catch
def my_function(x, y, z):
    # An error? It's caught anyway!
    return 1 / (x + y + z)


if __name__ == '__main__':
    # 做个测试，我们在调用时三个参数都传入 0，直接引发除以 0 的错误
    my_function(0, 0, 0)

"""
2022-04-11 22:26:20.896 | ERROR    | __main__:<module>:11 - An error has been caught in function '<module>', process 'MainProcess' (3736), thread 'MainThread' (1844):
Traceback (most recent call last):

> File "C:/Users/Hi/AppData/Roaming/JetBrains/PyCharm2021.3/scratches\test_01.py", line 11, in <module>
    my_function(0, 0, 0)
    └ <function my_function at 0x00000209F2EA3558>

  File "C:/Users/Hi/AppData/Roaming/JetBrains/PyCharm2021.3/scratches\test_01.py", line 6, in my_function
    return 1 / (x + y + z)
                │   │   └ 0
                │   └ 0
                └ 0

ZeroDivisionError: division by zero
"""

运行完毕之后，可以发现 log 里面就出现了 Traceback 信息，而且给我们输出了当时的变量值

附上对类中的类方法和静态方法的代码实例，以供参考

from loguru import logger

trace = logger.add('2021-3-28.log')

class Demo:
    @logger.catch
    def index_error(self, custom_list: list):
        for index in range(len(custom_list)):
            index_value = custom_list[index]
            if custom_list[index] < 2:
                custom_list.remove(index_value)

    @staticmethod
    @logger.catch
    def index_error_static(custom_list: list):
        for index in range(len(custom_list)):
            index_value = custom_list[index]
            if custom_list[index] < 2:
                custom_list.remove(index_value)


if __name__ == '__main__':
    # Demo().index_error([1, 2, 3])
    Demo.index_error_static([1, 2, 3])

通过 logger.exception 方法也可以实现异常的捕获与记录：

from loguru import logger

trace = logger.add('2021-3-28.log')

def index_error(custom_list: list):
    for index in range(len(custom_list)):
        try:
            index_value = custom_list[index]
        except IndexError as  err:
            logger.exception(err)
            break

        if custom_list[index] < 2:
            custom_list.remove(index_value)


if __name__ == '__main__':
    index_error([1, 2, 3])

运行上述代码，我们可以发现loguru输出的 Traceback 日志信息， Traceback 日志信息中同时输出了当时的变量值，如下：

filter 配置日志过滤规则

通过实现自定义方法error_only，判断日志级别，当日志级别为ERROR，返回TRUE，我们在add方法设置filter参数时，设置为error_only，即可过滤掉ERROR以外的所有日志。

from loguru import logger

def error_only(record):
    """
    error 日志 判断 
    Args:
        record: 

    Returns: 若日志级别为ERROR, 输出TRUE

    """
    return record["level"].name == "ERROR"

# ERROR以外级别日志被过滤掉
logger.add("2021-3-28.log", filter=error_only)

logger.error('This is error information')
logger.warning('This is warn information')

"""
在 2021-3-28.log 日志中，我们可以看到仅记录了ERROR级别日志。
2021-03-28 17:01:33.267 | ERROR    | __main__:<module>:11 - This is error information
"""

enqueue配置异步写入

loguru可以配置在多进程同时往日志文件写日志的时候使用队列达到异步功效。

要记录的消息是否应该在到达接收器之前首先通过一个多进程安全的队列。这在通过多个进程记录文件时非常有用。

logger.add("somefile.log", enqueue=True)  # 异步写入

format 配置日志记录格式化模板

格式化模板属性如下：

Key	Description
elapsed	从程序开始经过的时间差
exception	格式化异常(如果有)，否则为’ None ’
extra	用户绑定的属性字典(参见bind())
file	进行日志记录调用的文件
function	进行日志记录调用的函数
level	用于记录消息的严重程度
line	源代码中的行号
message	记录的消息(尚未格式化)
module	进行日志记录调用的模块
name	进行日志记录调用的__name__
process	进行日志记录调用的进程名
thread	进行日志记录调用的线程名
time	发出日志调用时的可感知的本地时间

我们可以看到在 2021-3-28.log 日志文件中，如 {time:YYYY-MM-DD HH:mm:ss} {level} From {module}.{function} : {message} 格式模板进行记录：

from loguru import logger

def format_log():
    """

    Returns:

    """
    trace = logger.add('2021-3-28.log', format="{time:YYYY-MM-DD HH:mm:ss} {level} From {module}.{function} : {message}")

    logger.warning('This is warn information')

if __name__ == '__main__':
    format_log()

"""
# 2021-3-28.log
2021-03-28 14:46:25 WARNING From 2021-3-28.format_log : This is warn information
"""

通过 extra bind() 添加额外属性来为结构化日志提供更多属性信息，如下：

from loguru import logger

def format_log():
    """

    Returns:

    """
    trace = logger.add('2021-3-28.log', format="{time:YYYY-MM-DD HH:mm:ss} {extra[ip]}  {extra[username]} {level} From {module}.{function} : {message}")
    
    extra_logger = logger.bind(ip="192.168.0.1", username="张三")
    extra_logger.info('This is info information')
    extra_logger.bind(username="李四").error("This is error information")

    extra_logger.warning('This is warn information')

if __name__ == '__main__':
    format_log()
  
"""
可以看到在 2021-3-28.log 日志文件中，看到日志按上述模板记录，如下：
2021-03-28 16:27:11 192.168.0.1  张三 INFO From 2021-3-28.format_log : This is info information
2021-03-28 16:27:11 192.168.0.1  李四 ERROR From 2021-3-28.format_log : This is error information
2021-03-28 16:27:11 192.168.0.1  张三 WARNING From 2021-3-28.format_log : This is warn information
"""

电子邮件提醒

Loguru 可以与强大的电子邮件通知模块结合使用，以便在程序意外失败时接收电子邮件，或发送许多其他类型的通知。

import notifiers

params = {
    "username": "test@gmail.com",
    "password": "abc123",
    "to": "test@gmail.com"
}

# Initialize email
notifier = notifiers.get_notifier("gmail")
notifier.notify(message="The application is running!", **params)

# Email alert for error
from notifiers.logging import NotificationHandler

handler = NotificationHandler("gmail", defaults=params)
logger.add(handler, level="ERROR")

这样配置后，每次产生 Error 日志时，程序都会自动向你的邮箱发送警报，真是方便。

除了这些功能之外，Loguru 还支持与 Python 原生 Logging 模块的兼容，你可以将原始标准记录器记录的所有信息转移到 Loguru 中。

你还可以基于 Loguru 自定义新的日志级别，并自定义你喜欢的结构化数据。

更改颜色标记

要向日志添加颜色，您只需将格式字符串与适当的标记（例如）括起来即可。如果接收器不支持 ansi 代码，则会自动删除这些标记。为方便起见，您可以使用关闭最后一个开始标记而不重复其名称（例如）。<red>some message</red> </> <red>another message</>

特殊标记（缩写为）根据记录的消息级别的配置颜色进行转换。<level> <lvl>

无法识别的标记将在解析过程中引发异常，以通知您可能误用。如果您希望按字面意思显示标记，则可以通过在 like 之前对其进行转义，

例如。如果由于某种原因需要以编程方式转义字符串，请注意，内部用于分析标记标记的正则表达式是 \\<blue>r"\\?</?((?:[fb]g\s)?[^<>\s]*)>"

请注意，当使用格式设置参数（和）中存在的颜色标记记录消息时，将完全忽略。如果需要记录包含可能干扰颜色标记的标记的字符串（在本例中，不要使用 f 字符串），这一点很重要。opt(colors=True)``args``kwargs

以下是可用的标签（请注意，兼容性可能因终端而异）：

颜色（缩写）	样式（缩写）
黑色（k）	黑体（b）
蓝色（e）	暗淡（d）
青色（c）	正常（n）
绿色（g）	斜体（i）
洋红色（m）	下划线（u）
红（r）	行使价（s）
白色（w）	反转（v）
黄色（Y）	眨眼（l）
	隐藏（h）

用法：

描述	前景	前景
基本颜色	`<red>`,`<r>`	`<GREEN>`,`<G>`
浅色	`<light-blue>`,`<le>`	`<LIGHT-CYAN>`,`<LC>`
8 位颜色	`<fg 86>`,`<fg 255>`	`<bg 42>`,`<bg 9>`
十六进制颜色	`<fg #00005f>`,`<fg #EE1>`	`<bg #AF5FD7>`,`<bg #fff>`
RGB 颜色	`<fg 0,95,0>`	`<bg 72,119,65>`
风格化	`<bold>` ,`<b>` `<underline>` `<u>`

可向如下样式进行标记颜色

import sys

from loguru import logger

log_format = " <r>{time:YYYY-MM-DD HH:mm:ss.ms}</r> |" \
             " <bold>行号：{line}</bold> |" \
             " <level>错误级别：{level} </level>|" \
             " <le>用时：{elapsed}</le> |" \
             " file：{file} |" \
             " module{module} |" \
             " name:{name} |" \
             " function：{function} |" \
             " 进程ID：{process} |" \
             " 线程ID：{thread} |" \
             " <level>{message} </level>"

logger.remove()  # 先删除默认样式
logger.add(sys.stdout, level=5, format=log_format, colorize=True)  # 输出到控制台,并设置输出最低为5，自定义日志颜色

logger.trace("'trace'级别日志,严重度值5")
logger.debug("'debug'级别日志,严重度值10")
logger.info("'info'级别日志,严重度值20")
logger.success("'success'级别日志,严重度值25")
logger.warning("'warning'级别日志,严重度值30")
logger.error("'error'级别日志,严重度值40")
logger.critical("'critical'级别日志,严重度值50")

效果图：

from loguru import logger
import sys

logger.remove()  # 删去import logger之后自动产生的handler，不删除的话会出现重复输出的现象

log_format = "<level> {time:YYYY-MM-DD HH:mm:ss.ms} | 行号：{line} | 错误级别：{level} | 用时：{elapsed} | file：{file} | module{module} | name:{name} | function：{function} | 进程ID：{process} | 线程ID：{thread} | {message} </level>"
logger.add(sink=sys.stdout, format=log_format, colorize=True)

logger.trace("'trace'级别日志,严重度值5")
logger.debug("'debug'级别日志,严重度值10")
logger.info("'info'级别日志,严重度值20")
logger.success("'success'级别日志,严重度值25")
logger.warning("'warning'级别日志,严重度值30")
logger.error("'error'级别日志,严重度值40")
logger.critical("'critical'级别日志,严重度值50")