我在Python 2.7.3中使用日志记录功能。这个Python版本的文档说:
logging包的发布时间早于str.format()和string.Template等较新的格式选项。但这些较新的格式选项也得到了支持...
我喜欢用花括号的'新'格式。所以我尝试做一些类似以下的事情:
log = logging.getLogger("some.logger")
log.debug("format this message {0}", 1)
并且遇到了错误：
类型错误：在字符串格式化期间并非所有参数都转换
我错过了什么？
附言：我不想使用
log.debug("format this message {0}".format(1))
因为在这种情况下，消息始终会被格式化，无论记录器的级别如何。
编辑：看看@Dunes答案中的StyleAdapter方法，与此答案不同；它允许在调用记录器的方法（debug()、info()、error()等）时使用替代格式样式，而无需使用样板代码。
从文档中了解到 — 使用备选格式样式:
记录调用（logger.debug()，logger.info() 等）仅接受实际记录消息的位置参数，并且关键字参数仅用于确定如何处理实际记录调用的选项（例如 exc_info 关键字参数表示应记录回溯信息，extra 关键字参数表示要添加到日志中的其他上下文信息）。因此，您无法直接使用 str.format() 或 string.Template 语法进行记录调用，因为内部 logging 包使用 %-formatting 将格式字符串和变量参数合并。如果要保留向后兼容性，则不能更改此内容，因为所有现有代码中存在的记录调用都将使用 %-format 字符串。
以及：
然而，您可以使用 {} 和 $ 格式来构造个人日志消息。请记住，对于消息，您可以使用任意对象作为消息格式字符串，并且logging包将调用str()函数来获取实际的格式字符串。将此复制粘贴到“wherever”模块中：class BraceMessage(object):
def __init__(self, fmt, *args, **kwargs):
self.fmt = fmt
self.args = args
self.kwargs = kwargs
def __str__(self):
return self.fmt.format(*self.args, **self.kwargs)
然后：
from wherever import BraceMessage as __
log.debug(__('Message with {0} {name}', 2, name='placeholders'))
num = 2; name = 'placeholders'; log.debug(f'Message with {num} {name}') - Jacktose{0}），而不能处理关键字参数（{foo}）。它也不需要使用下划线进行两次格式化调用。它确实有子类化 str 的不适感：class BraceString(str):
def __mod__(self, other):
return self.format(*other)
def __str__(self):
return self
class StyleAdapter(logging.LoggerAdapter):
def __init__(self, logger, extra=None):
super(StyleAdapter, self).__init__(logger, extra)
def process(self, msg, kwargs):
if kwargs.pop('style', "%") == "{": # optional
msg = BraceString(msg)
return msg, kwargs
logger = StyleAdapter(logging.getLogger(__name__))
logger.info("knights:{0}", "ni", style="{")
logger.info("knights:{}", "shrubbery", style="{")
# optional的检查来强制所有通过适配器发送的消息使用新样式格式。
注意：本答案是针对未来数年的读者：从Python 3.2开始，您可以在Formatter对象中使用样式参数（use the style parameter）：
文本翻译如下：日志记录（自3.2起）为这两种附加格式提供了更好的支持。增强了Formatter类以接受一个额外的可选关键字参数，命名为
style。这个默认值为'%'，但其他可能的值是'{'和'$'，它们对应于另外两种格式。默认情况下保持向后兼容性（正如你所期望的那样），但通过显式指定样式参数，您可以获得使用str.format()或string.Template的格式字符串的能力。
文档提供了一个示例：logging.Formatter('{asctime} {name} {levelname:8s} {message}', style='{')
请注意，在这种情况下，您仍然不能使用新的格式调用logger。也就是说，以下仍然不起作用：
logger.info("knights:{say}", say="ni") # Doesn't work!
logger.info("knights:{0}", "ni") # Doesn't work either
BraceString是一个字符串子类，从__str__返回它本身是安全的。 - Felipelog.info(__("val is {}", "x"))。所需的代码更改是将记录器包装在StyleAdapter中。from inspect import getargspec
class BraceMessage(object):
def __init__(self, fmt, args, kwargs):
self.fmt = fmt
self.args = args
self.kwargs = kwargs
def __str__(self):
return str(self.fmt).format(*self.args, **self.kwargs)
class StyleAdapter(logging.LoggerAdapter):
def __init__(self, logger):
self.logger = logger
def log(self, level, msg, *args, **kwargs):
if self.isEnabledFor(level):
msg, log_kwargs = self.process(msg, kwargs)
self.logger._log(level, BraceMessage(msg, args, kwargs), (),
**log_kwargs)
def process(self, msg, kwargs):
return msg, {key: kwargs[key]
for key in getargspec(self.logger._log).args[1:] if key in kwargs}
使用方法如下：
log = StyleAdapter(logging.getLogger(__name__))
log.info("a log message using {type} substitution", type="brace")
值得注意的是，如果花括号替换中使用的关键字包括level、msg、args、exc_info、extra或者stack_info，则该实现存在问题。这些都是Logger方法中使用的参数名称。如果您需要使用其中一个名称，则修改process以排除这些名称，或者只需从_log调用中删除log_kwargs即可。此外，这个实现还会悄悄地忽略那些拼错了的关键字(例如：ectra)。
更简单的解决方案是使用优秀的logbook模块
import logbook
import sys
logbook.StreamHandler(sys.stdout).push_application()
logbook.debug('Format this message {k}', k=1)
或者更完整的：
>>> import logbook
>>> import sys
>>> logbook.StreamHandler(sys.stdout).push_application()
>>> log = logbook.Logger('MyLog')
>>> log.debug('Format this message {k}', k=1)
[2017-05-06 21:46:52.578329] DEBUG: MyLog: Format this message 1
# import the library
from bracelogger import get_logger
# set up the logger
__log__ = get_logger(__name__)
# use brace-style formatting in log messages
try:
process(some_obj)
except Exception:
__log__.warning(
"Failed to process object '{0!r}' with name '{0.name}' and path '{0.path}'",
some_obj,
exc_info=True
)
注意：
logging.getLogger的调用和消息模板即可）logging.LogRecord对象上。stacklevel 参数来修复堆栈跟踪。#log_helper.py
from inspect import getfullargspec
import logging
import typing as T
class BraceMessage(object):
def __init__(self, fmt, args, kwargs):
self.fmt = fmt
self.args = args
self.kwargs = kwargs
def __str__(self):
return str(self.fmt).format(*self.args, **self.kwargs)
class StyleAdapter(logging.LoggerAdapter):
def __init__(self, logger:logging.Logger):
self.logger = logger
def log(
self,
level: int,
msg: object,
*args, **kwargs,
) -> None:
if self.isEnabledFor(level):
msg, log_kwargs = self.process(msg, kwargs)
# Note the `stacklevel` keyword argument so that funcName and lineno are rendered correctly.
self.logger._log(level, BraceMessage(msg, args, kwargs), (), stacklevel=2, **log_kwargs)
def process(self, msg: T.Any, kwargs: T.MutableMapping[str, T.Any]) -> tuple[T.Any, T.MutableMapping[str, T.Any]]:
# .args[1:] skips over the `self` argument in `logger._log`
mapped = {key: kwargs[key] for key in getfullargspec(self.logger._log).args[1:] if key in kwargs}
return msg, mapped
def addHandler(self, handler):
self.logger.addHandler(handler)
def getLogger(namespace):
return StyleAdapter(logging.getLogger(namespace))
from log_helper import getLogger
log = getLogger(__name__)
log.info("Hello {}", "world")
logging.setLogRecordFactory：import collections
import logging
class _LogRecord(logging.LogRecord):
def getMessage(self):
msg = str(self.msg)
if self.args:
if isinstance(self.args, collections.Mapping):
msg = msg.format(**self.args)
else:
msg = msg.format(*self.args)
return msg
logging.setLogRecordFactory(_LogRecord)
class ColorFormatter(logging.Formatter):
def format(self, record):
# previous stuff, copy from logging.py…
try: # Allow {} style
message = record.getMessage() # printf
except TypeError:
message = record.msg.format(*record.args)
# later stuff…
结合了 string.Formatter 和 pprint.pformat 类型转换以及来自 logging 的 setLogRecordFactory、setLoggerClass，有一个巧妙的技巧- 为参数 args 创建额外的嵌套元组，用于 Logger._log 方法，然后在 LogRecord 初始化中解包它，以避免在 Logger.makeRecord 中覆盖。使用 log.f wraps 将每个属性（故意是日志方法）都与 use_format 包装起来，因此您不必显式编写它。这个解决方案向后兼容。
from collections import namedtuple
from collections.abc import Mapping
from functools import partial
from pprint import pformat
from string import Formatter
import logging
Logger = logging.getLoggerClass()
LogRecord = logging.getLogRecordFactory()
class CustomFormatter(Formatter):
def format_field(self, value, format_spec):
if format_spec.endswith('p'):
value = pformat(value)
format_spec = format_spec[:-1]
return super().format_field(value, format_spec)
custom_formatter = CustomFormatter()
class LogWithFormat:
def __init__(self, obj):
self.obj = obj
def __getattr__(self, name):
return partial(getattr(self.obj, name), use_format=True)
ArgsSmuggler = namedtuple('ArgsSmuggler', ('args', 'smuggled'))
class CustomLogger(Logger):
def __init__(self, *ar, **kw):
super().__init__(*ar, **kw)
self.f = LogWithFormat(self)
def _log(self, level, msg, args, *ar, use_format=False, **kw):
super()._log(level, msg, ArgsSmuggler(args, use_format), *ar, **kw)
class CustomLogRecord(LogRecord):
def __init__(self, *ar, **kw):
args = ar[5]
# RootLogger use CustomLogRecord but not CustomLogger
# then just unpack only ArgsSmuggler instance
args, use_format = args if isinstance(args, ArgsSmuggler) else (args, False)
super().__init__(*ar[:5], args, *ar[6:], **kw)
self.use_format = use_format
def getMessage(self):
return self.getMessageWithFormat() if self.use_format else super().getMessage()
def getMessageWithFormat(self):
msg = str(self.msg)
args = self.args
if args:
fmt = custom_formatter.format
msg = fmt(msg, **args) if isinstance(args, Mapping) else fmt(msg, *args)
return msg
logging.setLogRecordFactory(CustomLogRecord)
logging.setLoggerClass(CustomLogger)
log = logging.getLogger(__name__)
log.info('%s %s', dict(a=1, b=2), 5)
log.f.info('{:p} {:d}', dict(a=1, b=2), 5)
类似于pR0Ps的解决方案，通过将{{link1：getMessage}}包装在LogRecord中，通过将{{link2：makeRecord}}（而不是他们答案中的handle）包装在应该启用新格式的Logger实例中：
def getLogger(name):
log = logging.getLogger(name)
def Logger_makeRecordWrapper(name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None):
self = log
record = logging.Logger.makeRecord(self, name, level, fn, lno, msg, args, exc_info, func, sinfo)
def LogRecord_getMessageNewStyleFormatting():
self = record
msg = str(self.msg)
if self.args:
msg = msg.format(*self.args)
return msg
record.getMessage = LogRecord_getMessageNewStyleFormatting
return record
log.makeRecord = Logger_makeRecordWrapper
return log
我使用Python 3.5.3进行了测试。
log.debug("格式化此消息%d" % 1)- ronakFormatter，以使用'{'作为样式。 - mata