我已经知道了颜色转义，我在不久前的bash提示中使用了它们。谢谢。< br > 我想要的是将它与日志模块集成在一起，经过几次尝试和错误后，我最终做到了 这是我最终得到的:

BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)


#The background is set with 40 plus the number of the color, and the foreground with 30


#These are the sequences need to get colored ouput
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ = "\033[1m"


def formatter_message(message, use_color = True):
if use_color:
message = message.replace("$RESET", RESET_SEQ).replace("$BOLD", BOLD_SEQ)
else:
message = message.replace("$RESET", "").replace("$BOLD", "")
return message


COLORS = {
'WARNING': YELLOW,
'INFO': WHITE,
'DEBUG': BLUE,
'CRITICAL': YELLOW,
'ERROR': RED
}


class ColoredFormatter(logging.Formatter):
def __init__(self, msg, use_color = True):
logging.Formatter.__init__(self, msg)
self.use_color = use_color


def format(self, record):
levelname = record.levelname
if self.use_color and levelname in COLORS:
levelname_color = COLOR_SEQ % (30 + COLORS[levelname]) + levelname + RESET_SEQ
record.levelname = levelname_color
return logging.Formatter.format(self, record)

要使用它，请创建自己的Logger:

# Custom logger class with multiple destinations
class ColoredLogger(logging.Logger):
FORMAT = "[$BOLD%(name)-20s$RESET][%(levelname)-18s]  %(message)s ($BOLD%(filename)s$RESET:%(lineno)d)"
COLOR_FORMAT = formatter_message(FORMAT, True)
def __init__(self, name):
logging.Logger.__init__(self, name, logging.DEBUG)


color_formatter = ColoredFormatter(self.COLOR_FORMAT)


console = logging.StreamHandler()
console.setFormatter(color_formatter)


self.addHandler(console)
return




logging.setLoggerClass(ColoredLogger)

以防有人需要。

如果使用多个记录器或处理程序，请小心:ColoredFormatter正在更改记录对象，该对象将进一步传递给其他处理程序或传播给其他记录器。如果你已经配置了文件记录器等，你可能不想在日志文件中有颜色。为了避免这种情况，最好是在操作levelname属性之前用copy.copy()创建一个record的副本，或者在返回格式化的字符串之前将levelname重置为前一个值(注释中要感谢迈克尔)。

下面是一个适用于任何平台的解决方案。如果没有，告诉我，我会更新的。

它是如何工作的:在支持ANSI转义的平台上使用它们(非Windows)，在Windows上它确实使用API调用来改变控制台颜色。

该脚本确实破解了标准库中的logging.StreamHandler.emit方法，并向其添加了包装器。

TestColorer.py

# Usage: add Colorer.py near you script and import it.
import logging
import Colorer


logging.warn("a warning")
logging.error("some error")
logging.info("some info")

Colorer.py

#!/usr/bin/env python
# encoding: utf-8
import logging
# now we patch Python code to add color support to logging.StreamHandler
def add_coloring_to_emit_windows(fn):
# add methods we need to the class
def _out_handle(self):
import ctypes
return ctypes.windll.kernel32.GetStdHandle(self.STD_OUTPUT_HANDLE)
out_handle = property(_out_handle)


def _set_color(self, code):
import ctypes
# Constants from the Windows API
self.STD_OUTPUT_HANDLE = -11
hdl = ctypes.windll.kernel32.GetStdHandle(self.STD_OUTPUT_HANDLE)
ctypes.windll.kernel32.SetConsoleTextAttribute(hdl, code)


setattr(logging.StreamHandler, '_set_color', _set_color)


def new(*args):
FOREGROUND_BLUE      = 0x0001 # text color contains blue.
FOREGROUND_GREEN     = 0x0002 # text color contains green.
FOREGROUND_RED       = 0x0004 # text color contains red.
FOREGROUND_INTENSITY = 0x0008 # text color is intensified.
FOREGROUND_WHITE     = FOREGROUND_BLUE|FOREGROUND_GREEN |FOREGROUND_RED
# winbase.h
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12


# wincon.h
FOREGROUND_BLACK     = 0x0000
FOREGROUND_BLUE      = 0x0001
FOREGROUND_GREEN     = 0x0002
FOREGROUND_CYAN      = 0x0003
FOREGROUND_RED       = 0x0004
FOREGROUND_MAGENTA   = 0x0005
FOREGROUND_YELLOW    = 0x0006
FOREGROUND_GREY      = 0x0007
FOREGROUND_INTENSITY = 0x0008 # foreground color is intensified.


BACKGROUND_BLACK     = 0x0000
BACKGROUND_BLUE      = 0x0010
BACKGROUND_GREEN     = 0x0020
BACKGROUND_CYAN      = 0x0030
BACKGROUND_RED       = 0x0040
BACKGROUND_MAGENTA   = 0x0050
BACKGROUND_YELLOW    = 0x0060
BACKGROUND_GREY      = 0x0070
BACKGROUND_INTENSITY = 0x0080 # background color is intensified.


levelno = args[1].levelno
if(levelno>=50):
color = BACKGROUND_YELLOW | FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_INTENSITY
elif(levelno>=40):
color = FOREGROUND_RED | FOREGROUND_INTENSITY
elif(levelno>=30):
color = FOREGROUND_YELLOW | FOREGROUND_INTENSITY
elif(levelno>=20):
color = FOREGROUND_GREEN
elif(levelno>=10):
color = FOREGROUND_MAGENTA
else:
color =  FOREGROUND_WHITE
args[0]._set_color(color)


ret = fn(*args)
args[0]._set_color( FOREGROUND_WHITE )
#print "after"
return ret
return new


def add_coloring_to_emit_ansi(fn):
# add methods we need to the class
def new(*args):
levelno = args[1].levelno
if(levelno>=50):
color = '\x1b[31m' # red
elif(levelno>=40):
color = '\x1b[31m' # red
elif(levelno>=30):
color = '\x1b[33m' # yellow
elif(levelno>=20):
color = '\x1b[32m' # green
elif(levelno>=10):
color = '\x1b[35m' # pink
else:
color = '\x1b[0m' # normal
args[1].msg = color + args[1].msg +  '\x1b[0m'  # normal
#print "after"
return fn(*args)
return new


import platform
if platform.system()=='Windows':
# Windows does not support ANSI escapes and we are using API calls to set the console color
logging.StreamHandler.emit = add_coloring_to_emit_windows(logging.StreamHandler.emit)
else:
# all non-Windows platforms are supporting ANSI escapes so we use them
logging.StreamHandler.emit = add_coloring_to_emit_ansi(logging.StreamHandler.emit)
#log = logging.getLogger()
#log.addFilter(log_filter())
#//hdlr = logging.StreamHandler()
#//hdlr.setFormatter(formatter())

我修改了Sorin提供的原始的例子，并将StreamHandler子类化为ColorizedConsoleHandler。

他们的解决方案的缺点是它修改了消息，并且因为修改了实际的日志消息，任何其他处理程序也将得到修改后的消息。

在我们的例子中，这导致日志文件中有颜色代码，因为我们使用了多个记录器。

下面的类只在支持ANSI的平台上工作，但是向它添加Windows颜色代码应该很简单。

import copy
import logging




class ColoredConsoleHandler(logging.StreamHandler):
def emit(self, record):
# Need to make a actual copy of the record
# to prevent altering the message for other loggers
myrecord = copy.copy(record)
levelno = myrecord.levelno
if(levelno >= 50):  # CRITICAL / FATAL
color = '\x1b[31m'  # red
elif(levelno >= 40):  # ERROR
color = '\x1b[31m'  # red
elif(levelno >= 30):  # WARNING
color = '\x1b[33m'  # yellow
elif(levelno >= 20):  # INFO
color = '\x1b[32m'  # green
elif(levelno >= 10):  # DEBUG
color = '\x1b[35m'  # pink
else:  # NOTSET and anything else
color = '\x1b[0m'  # normal
myrecord.msg = color + str(myrecord.msg) + '\x1b[0m'  # normal
logging.StreamHandler.emit(self, myrecord)

import logging


BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)


COLORS = {
'WARNING'  : YELLOW,
'INFO'     : WHITE,
'DEBUG'    : BLUE,
'CRITICAL' : YELLOW,
'ERROR'    : RED,
'RED'      : RED,
'GREEN'    : GREEN,
'YELLOW'   : YELLOW,
'BLUE'     : BLUE,
'MAGENTA'  : MAGENTA,
'CYAN'     : CYAN,
'WHITE'    : WHITE,
}


RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ  = "\033[1m"


class ColorFormatter(logging.Formatter):


def __init__(self, *args, **kwargs):
# can't do super(...) here because Formatter is an old school class
logging.Formatter.__init__(self, *args, **kwargs)


def format(self, record):
levelname = record.levelname
color     = COLOR_SEQ % (30 + COLORS[levelname])
message   = logging.Formatter.format(self, record)
message   = message.replace("$RESET", RESET_SEQ)\
.replace("$BOLD",  BOLD_SEQ)\
.replace("$COLOR", color)
for k,v in COLORS.items():
message = message.replace("$" + k,    COLOR_SEQ % (v+30))\
.replace("$BG" + k,  COLOR_SEQ % (v+40))\
.replace("$BG-" + k, COLOR_SEQ % (v+40))
return message + RESET_SEQ


logging.ColorFormatter = ColorFormatter

所以现在你可以在配置文件中简单地执行以下操作:

[formatter_colorFormatter]
class=logging.ColorFormatter
format= $COLOR%(levelname)s $RESET %(asctime)s $BOLD$COLOR%(name)s$RESET %(message)s

airmind的另一种方法是将所有东西都放在一个类中:

class ColorFormatter(logging.Formatter):
FORMAT = ("[$BOLD%(name)-20s$RESET][%(levelname)-18s]  "
"%(message)s "
"($BOLD%(filename)s$RESET:%(lineno)d)")


BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)


RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ = "\033[1m"


COLORS = {
'WARNING': YELLOW,
'INFO': WHITE,
'DEBUG': BLUE,
'CRITICAL': YELLOW,
'ERROR': RED
}


def formatter_msg(self, msg, use_color = True):
if use_color:
msg = msg.replace("$RESET", self.RESET_SEQ).replace("$BOLD", self.BOLD_SEQ)
else:
msg = msg.replace("$RESET", "").replace("$BOLD", "")
return msg


def __init__(self, use_color=True):
msg = self.formatter_msg(self.FORMAT, use_color)
logging.Formatter.__init__(self, msg)
self.use_color = use_color


def format(self, record):
levelname = record.levelname
if self.use_color and levelname in self.COLORS:
fore_color = 30 + self.COLORS[levelname]
levelname_color = self.COLOR_SEQ % fore_color + levelname + self.RESET_SEQ
record.levelname = levelname_color
return logging.Formatter.format(self, record)

要使用将格式化程序附加到处理程序，如下所示:

handler.setFormatter(ColorFormatter())
logger.addHandler(handler)

我遇到的麻烦是正确设置格式化程序:

class ColouredFormatter(logging.Formatter):
def __init__(self, msg):
logging.Formatter.__init__(self, msg)
self._init_colour = _get_colour()


def close(self):
# restore the colour information to what it was
_set_colour(self._init_colour)


def format(self, record):
# Add your own colourer based on the other examples
_set_colour( LOG_LEVEL_COLOUR[record.levelno] )
return logging.Formatter.format(self, record)


def init():
# Set up the formatter. Needs to be first thing done.
rootLogger = logging.getLogger()
hdlr = logging.StreamHandler()
fmt = ColouredFormatter('%(message)s')
hdlr.setFormatter(fmt)
rootLogger.addHandler(hdlr)

然后使用:

import coloured_log
import logging


coloured_log.init()
logging.info("info")
logging.debug("debug")


coloured_log.close()    # restore colours

请看下面的解决方案。流处理程序应该是做着色的事情，然后你可以选择着色单词而不仅仅是整行(与Formatter)。

http://plumberjack.blogspot.com/2010/12/colorizing-logging-output-in-terminals.html

快速和肮脏的解决方案预定义的日志级别，而不定义一个新的类。

logging.addLevelName( logging.WARNING, "\033[1;31m%s\033[1;0m" % logging.getLevelName(logging.WARNING))
logging.addLevelName( logging.ERROR, "\033[1;41m%s\033[1;0m" % logging.getLevelName(logging.ERROR))

刚刚回答了类似的问题:在shell中更改文本颜色

其思想是使用克林特库。它支持MAC, Linux和Windows shell (CLI)。

几年前，我为自己编写了一个彩色流处理程序。然后我偶然发现了这个页面，发现了一组人们复制/粘贴的代码片段:-(。我的流处理程序目前只适用于UNIX (Linux, Mac OS X)，但优点是它是可在PyPI上使用(和GitHub)，使用起来非常简单。它也有一个Vim语法模式:-)。将来我可能会把它扩展到Windows上。

安装软件包:

$ pip install coloredlogs

要确认它是否有效:

$ coloredlogs --demo

要开始使用自己的代码:

$ python
> import coloredlogs, logging
> coloredlogs.install()
> logging.info("It works!")
2014-07-30 21:21:26 peter-macbook root[7471] INFO It works!

上面示例中显示的默认日志格式包含日期、时间、主机名、记录器名称、PID、日志级别和日志消息。这是它在实践中的样子:

注意:当使用Git Bash与MinTTY

Git Bash在windows上有一些记录的怪癖: Winpty和Git Bash < / p >

对于ANSI转义代码和ncurses风格的字符重写和动画，你需要用winpty作为命令的前缀。

$ winpty coloredlogs --demo
$ winpty python your_colored_logs_script.py

现在有一个发布的PyPi模块，用于自定义彩色日志输出:

https://pypi.python.org/pypi/rainbow_logging_handler/ < a href = " https://pypi.python.org/pypi/rainbow_logging_handler/ " > < / >

而且

https://github.com/laysakura/rainbow_logging_handler < a href = " https://github.com/laysakura/rainbow_logging_handler " > < / >

• 支持Windows

• 支持Django

• 可定制的颜色

由于它是作为Python卵分发的，因此非常容易为任何Python应用程序安装它。

更新:因为这是我一直想要挠的痒，所以我继续写了一个库，为像我这样只想要简单方法做事的懒人:zenlog

Colorlog在这方面非常出色。它是可在PyPI上使用(因此可以通过pip install colorlog安装)，并且是积极维护。

下面是一个快速复制粘贴代码片段，用于设置日志记录和打印像样的日志消息:

import logging
LOG_LEVEL = logging.DEBUG
LOGFORMAT = "  %(log_color)s%(levelname)-8s%(reset)s | %(log_color)s%(message)s%(reset)s"
from colorlog import ColoredFormatter
logging.root.setLevel(LOG_LEVEL)
formatter = ColoredFormatter(LOGFORMAT)
stream = logging.StreamHandler()
stream.setLevel(LOG_LEVEL)
stream.setFormatter(formatter)
log = logging.getLogger('pythonConfig')
log.setLevel(LOG_LEVEL)
log.addHandler(stream)


log.debug("A quirky message only developers care about")
log.info("Curious users might want to know this")
log.warn("Something is wrong and any user should be informed")
log.error("Serious stuff, this is red for a reason")
log.critical("OH NO everything is on fire")

输出:

以下是我的解决方案:

class ColouredFormatter(logging.Formatter):
RESET = '\x1B[0m'
RED = '\x1B[31m'
YELLOW = '\x1B[33m'
BRGREEN = '\x1B[01;32m'  # grey in solarized for terminals


def format(self, record, colour=False):
message = super().format(record)


if not colour:
return message


level_no = record.levelno
if level_no >= logging.CRITICAL:
colour = self.RED
elif level_no >= logging.ERROR:
colour = self.RED
elif level_no >= logging.WARNING:
colour = self.YELLOW
elif level_no >= logging.INFO:
colour = self.RESET
elif level_no >= logging.DEBUG:
colour = self.BRGREEN
else:
colour = self.RESET


message = colour + message + self.RESET


return message




class ColouredHandler(logging.StreamHandler):
def __init__(self, stream=sys.stdout):
super().__init__(stream)


def format(self, record, colour=False):
if not isinstance(self.formatter, ColouredFormatter):
self.formatter = ColouredFormatter()


return self.formatter.format(record, colour)


def emit(self, record):
stream = self.stream
try:
msg = self.format(record, stream.isatty())
stream.write(msg)
stream.write(self.terminator)
self.flush()
except Exception:
self.handleError(record)




h = ColouredHandler()
h.formatter = ColouredFormatter('{asctime} {levelname:8} {message}', '%Y-%m-%d %H:%M:%S', '{')
logging.basicConfig(level=logging.DEBUG, handlers=[h])

使用pyfancy。

例子:

print(pyfancy.RED + "Hello Red!" + pyfancy.END)

虽然其他解决方案看起来不错，但它们存在一些问题。有些人会给整条线上色，有时这是不需要的，有些人会省略你可能在一起的任何配置。下面的解决方案只影响消息本身。

代码

class ColoredFormatter(logging.Formatter):
def format(self, record):
if record.levelno == logging.WARNING:
record.msg = '\033[93m%s\033[0m' % record.msg
elif record.levelno == logging.ERROR:
record.msg = '\033[91m%s\033[0m' % record.msg
return logging.Formatter.format(self, record)

例子

logger = logging.getLogger('mylogger')
handler = logging.StreamHandler()


log_format = '[%(asctime)s]:%(levelname)-7s:%(message)s'
time_format = '%H:%M:%S'
formatter = ColoredFormatter(log_format, datefmt=time_format)
handler.setFormatter(formatter)
logger.addHandler(handler)


logger.warn('this should be yellow')
logger.error('this should be red')

输出

[17:01:36]:WARNING:this should be yellow
[17:01:37]:ERROR  :this should be red

如您所见，其他所有内容仍然输出并保持初始颜色。如果你想改变消息以外的任何东西，你可以简单地将颜色代码传递给例子中的log_format。

我有两个提交要添加，其中一个只着色消息(ColoredFormatter)，另一个着色整行(ColorizingStreamHandler)。与以前的解决方案相比，这些方案还包括更多的ANSI颜色代码。

部分内容来自(经过修改): 上面的帖子，和http://plumberjack.blogspot.com/2010/12/colorizing-logging-output-in-terminals.html.

只给信息上色:

class ColoredFormatter(logging.Formatter):
"""Special custom formatter for colorizing log messages!"""


BLACK = '\033[0;30m'
RED = '\033[0;31m'
GREEN = '\033[0;32m'
BROWN = '\033[0;33m'
BLUE = '\033[0;34m'
PURPLE = '\033[0;35m'
CYAN = '\033[0;36m'
GREY = '\033[0;37m'


DARK_GREY = '\033[1;30m'
LIGHT_RED = '\033[1;31m'
LIGHT_GREEN = '\033[1;32m'
YELLOW = '\033[1;33m'
LIGHT_BLUE = '\033[1;34m'
LIGHT_PURPLE = '\033[1;35m'
LIGHT_CYAN = '\033[1;36m'
WHITE = '\033[1;37m'


RESET = "\033[0m"


def __init__(self, *args, **kwargs):
self._colors = {logging.DEBUG: self.DARK_GREY,
logging.INFO: self.RESET,
logging.WARNING: self.BROWN,
logging.ERROR: self.RED,
logging.CRITICAL: self.LIGHT_RED}
super(ColoredFormatter, self).__init__(*args, **kwargs)


def format(self, record):
"""Applies the color formats"""
record.msg = self._colors[record.levelno] + record.msg + self.RESET
return logging.Formatter.format(self, record)


def setLevelColor(self, logging_level, escaped_ansi_code):
self._colors[logging_level] = escaped_ansi_code

为整行上色:

class ColorizingStreamHandler(logging.StreamHandler):


BLACK = '\033[0;30m'
RED = '\033[0;31m'
GREEN = '\033[0;32m'
BROWN = '\033[0;33m'
BLUE = '\033[0;34m'
PURPLE = '\033[0;35m'
CYAN = '\033[0;36m'
GREY = '\033[0;37m'


DARK_GREY = '\033[1;30m'
LIGHT_RED = '\033[1;31m'
LIGHT_GREEN = '\033[1;32m'
YELLOW = '\033[1;33m'
LIGHT_BLUE = '\033[1;34m'
LIGHT_PURPLE = '\033[1;35m'
LIGHT_CYAN = '\033[1;36m'
WHITE = '\033[1;37m'


RESET = "\033[0m"


def __init__(self, *args, **kwargs):
self._colors = {logging.DEBUG: self.DARK_GREY,
logging.INFO: self.RESET,
logging.WARNING: self.BROWN,
logging.ERROR: self.RED,
logging.CRITICAL: self.LIGHT_RED}
super(ColorizingStreamHandler, self).__init__(*args, **kwargs)


@property
def is_tty(self):
isatty = getattr(self.stream, 'isatty', None)
return isatty and isatty()


def emit(self, record):
try:
message = self.format(record)
stream = self.stream
if not self.is_tty:
stream.write(message)
else:
message = self._colors[record.levelno] + message + self.RESET
stream.write(message)
stream.write(getattr(self, 'terminator', '\n'))
self.flush()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.handleError(record)


def setLevelColor(self, logging_level, escaped_ansi_code):
self._colors[logging_level] = escaped_ansi_code

import logging
import sys


colors = {'pink': '\033[95m', 'blue': '\033[94m', 'green': '\033[92m', 'yellow': '\033[93m', 'red': '\033[91m',
'ENDC': '\033[0m', 'bold': '\033[1m', 'underline': '\033[4m'}


logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)




def str_color(color, data):
return colors[color] + str(data) + colors['ENDC']


params = {'param1': id1, 'param2': id2}


logging.info('\nParams:' + str_color("blue", str(params)))`

'colout'是为任何终端文本上色的一个简单但非常灵活的工具。

pip install colout
myprocess | colout REGEX_WITH_GROUPS color1,color2...

其中'myprocess'输出中的任何匹配正则表达式第1组的文本都将用color1着色，第2组用color2着色，等等。

例如:

tail -f /var/log/mylogfile | colout '^(\w+ \d+ [\d:]+)|(\w+\.py:\d+ .+\(\)): (.+)$' white,black,cyan bold,bold,normal

也就是说，第一个正则表达式组(parens)匹配日志文件中的初始日期，第二组匹配python文件名、行号和函数名，第三组匹配其后的日志消息。我还使用了“粗体/法线”的平行序列以及颜色序列。这看起来像:

.

请注意，不匹配任何正则表达式的行或行的一部分仍然被回显，因此这与'grep——color'不同——输出中没有过滤掉任何内容。

显然，这是足够灵活的，您可以将它用于任何进程，而不仅仅是跟踪日志文件。每当我想给一些东西上色时，我通常只是快速地创建一个新的正则表达式。出于这个原因，我更喜欢colout而不是任何自定义日志文件着色工具，因为我只需要学习一种工具，不管我在为什么着色:日志记录、测试输出、在终端中突出显示代码片段的语法等等。

它还避免了在日志文件本身中实际转储ANSI代码，恕我说这是一个坏主意，因为它会破坏日志文件中的grepping模式之类的事情，除非您始终记得在grep正则表达式中匹配ANSI代码。

你可以导入colorlog模块，并使用它的ColoredFormatter为日志消息着色。

例子

主模块样板:

import logging
import os
import sys
try:
import colorlog
except ImportError:
pass


def setup_logging():
root = logging.getLogger()
root.setLevel(logging.DEBUG)
format      = '%(asctime)s - %(levelname)-8s - %(message)s'
date_format = '%Y-%m-%d %H:%M:%S'
if 'colorlog' in sys.modules and os.isatty(2):
cformat = '%(log_color)s' + format
f = colorlog.ColoredFormatter(cformat, date_format,
log_colors = { 'DEBUG'   : 'reset',       'INFO' : 'reset',
'WARNING' : 'bold_yellow', 'ERROR': 'bold_red',
'CRITICAL': 'bold_red' })
else:
f = logging.Formatter(format, date_format)
ch = logging.StreamHandler()
ch.setFormatter(f)
root.addHandler(ch)


setup_logging()
log = logging.getLogger(__name__)

该代码仅在安装了colorlog模块并且输出实际发送到终端时才启用日志消息中的颜色。这可以避免在日志输出重定向时将转义序列写入文件。

此外，还设置了一个自定义配色方案，更适合具有深色背景的终端。

一些日志调用示例:

log.debug   ('Hello Debug')
log.info    ('Hello Info')
log.warn    ('Hello Warn')
log.error   ('Hello Error')
log.critical('Hello Critical')

输出:

import logging


logging.basicConfig(filename="f.log" filemode='w', level=logging.INFO,
format = "%(logger_name)s %(color)s  %(message)s %(endColor)s")




class Logger(object):
__GREEN = "\033[92m"
__RED = '\033[91m'
__ENDC = '\033[0m'


def __init__(self, name):
self.logger = logging.getLogger(name)
self.extra={'logger_name': name, 'endColor': self.__ENDC, 'color': self.__GREEN}




def info(self, msg):
self.extra['color'] = self.__GREEN
self.logger.info(msg, extra=self.extra)


def error(self, msg):
self.extra['color'] = self.__RED
self.logger.error(msg, extra=self.extra)

使用

Logger("File Name").info("This shows green text")

另一个解决方案，用ZetaSyanthis的颜色:

def config_log(log_level):


def set_color(level, code):
level_fmt = "\033[1;" + str(code) + "m%s\033[1;0m"
logging.addLevelName( level, level_fmt % logging.getLevelName(level) )


std_stream = sys.stdout
isatty = getattr(std_stream, 'isatty', None)
if isatty and isatty():
levels = [logging.DEBUG, logging.CRITICAL, logging.WARNING, logging.ERROR]
for idx, level in enumerate(levels):
set_color(level, 30 + idx )
set_color(logging.DEBUG, 0)
logging.basicConfig(stream=std_stream, level=log_level)

在__main__函数中调用它一次。我这里有这样的东西:

options, arguments = p.parse_args()
log_level = logging.DEBUG if options.verbose else logging.WARNING
config_log(log_level)

它还验证输出是否为控制台，否则不使用颜色。

好吧，我想我应该加上我的彩色记录器的变化。

这没什么特别的，但是使用起来非常简单，并且不会更改记录对象，因此如果使用文件处理程序，就可以避免将ANSI转义序列记录到日志文件中。不影响日志信息的格式化。

如果你已经在使用日志模块的格式化程序，你所要做的就是用ColoredFormatter替换你的忠告处理程序Formatter来获得有颜色的级别名称。如果你正在记录整个应用程序，你只需要为顶级记录器这样做。

colored_log.py

#!/usr/bin/env python


from copy import copy
from logging import Formatter


MAPPING = {
'DEBUG'   : 37, # white
'INFO'    : 36, # cyan
'WARNING' : 33, # yellow
'ERROR'   : 31, # red
'CRITICAL': 41, # white on red bg
}


PREFIX = '\033['
SUFFIX = '\033[0m'


class ColoredFormatter(Formatter):


def __init__(self, patern):
Formatter.__init__(self, patern)


def format(self, record):
colored_record = copy(record)
levelname = colored_record.levelname
seq = MAPPING.get(levelname, 37) # default white
colored_levelname = ('{0}{1}m{2}{3}') \
.format(PREFIX, seq, levelname, SUFFIX)
colored_record.levelname = colored_levelname
return Formatter.format(self, colored_record)

示例使用

app.py

#!/usr/bin/env python


import logging
from colored_log import ColoredFormatter


# Create top level logger
log = logging.getLogger("main")


# Add console handler using our custom ColoredFormatter
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
cf = ColoredFormatter("[%(name)s][%(levelname)s]  %(message)s (%(filename)s:%(lineno)d)")
ch.setFormatter(cf)
log.addHandler(ch)


# Add file handler
fh = logging.FileHandler('app.log')
fh.setLevel(logging.DEBUG)
ff = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(ff)
log.addHandler(fh)


# Set log level
log.setLevel(logging.DEBUG)


# Log some stuff
log.debug("app has started")
log.info("Logging to 'app.log' in the script dir")
log.warning("This is my last warning, take heed")
log.error("This is an error")
log.critical("He's dead, Jim")


# Import a sub-module
import sub_module

sub_module.py

#!/usr/bin/env python


import logging
log = logging.getLogger('main.sub_module')


log.debug("Hello from the sub module")

结果

终端输出

app.log内容

2017-09-29 00:32:23,434 - main - DEBUG - app has started
2017-09-29 00:32:23,434 - main - INFO - Logging to 'app.log' in the script dir
2017-09-29 00:32:23,435 - main - WARNING - This is my last warning, take heed
2017-09-29 00:32:23,435 - main - ERROR - This is an error
2017-09-29 00:32:23,435 - main - CRITICAL - He's dead, Jim
2017-09-29 00:32:23,435 - main.sub_module - DEBUG - Hello from the sub module

当然，您可以随心所欲地设置终端和日志文件输出的格式。只有日志级别将被着色。

我希望有人发现这是有用的，而不是只是太多的相同。：）

有很多回复。但没有人谈论装修师。这是我的。

因为它要简单得多。

不需要导入任何东西，也不需要编写任何子类:

#!/usr/bin/env python
# -*- coding: utf-8 -*-




import logging




NO_COLOR = "\33[m"
RED, GREEN, ORANGE, BLUE, PURPLE, LBLUE, GREY = \
map("\33[%dm".__mod__, range(31, 38))


logging.basicConfig(format="%(message)s", level=logging.DEBUG)
logger = logging.getLogger(__name__)


# the decorator to apply on the logger methods info, warn, ...
def add_color(logger_method, color):
def wrapper(message, *args, **kwargs):
return logger_method(
# the coloring is applied here.
color+message+NO_COLOR,
*args, **kwargs
)
return wrapper


for level, color in zip((
"info", "warn", "error", "debug"), (
GREEN, ORANGE, RED, BLUE
)):
setattr(logger, level, add_color(getattr(logger, level), color))


# this is displayed in red.
logger.error("Launching %s." % __file__)

这将错误设置为红色，调试消息设置为蓝色，等等。就像问题中问的那样。

我们甚至可以使包装器接受color参数来使用logger.debug("message", color=GREY)动态设置消息的颜色

def add_color(logger_method, _color):
def wrapper(message, *args, **kwargs):
color = kwargs.pop("color", _color)
if isinstance(color, int):
color = "\33[%dm" % color
return logger_method(
# the coloring is applied here.
color+message+NO_COLOR,
*args, **kwargs
)
return wrapper


# blah blah, apply the decorator...


# this is displayed in red.
logger.error("Launching %s." % __file__)
# this is displayed in blue
logger.error("Launching %s." % __file__, color=34)
# and this, in grey
logger.error("Launching %s." % __file__, color=GREY)

这是一个包含颜色代码的Enum:

class TerminalColour:
"""
Terminal colour formatting codes
"""
# https://stackoverflow.com/questions/287871/print-in-terminal-with-colors
MAGENTA = '\033[95m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
GREY = '\033[0m'  # normal
WHITE = '\033[1m'  # bright white
UNDERLINE = '\033[4m'

这可以应用于每个日志级别的的名字。注意这是一个可怕的黑客

logging.addLevelName(logging.INFO, "{}{}{}".format(TerminalColour.WHITE, logging.getLevelName(logging.INFO), TerminalColour.GREY))
logging.addLevelName(logging.WARNING, "{}{}{}".format(TerminalColour.YELLOW, logging.getLevelName(logging.WARNING), TerminalColour.GREY))
logging.addLevelName(logging.ERROR, "{}{}{}".format(TerminalColour.RED, logging.getLevelName(logging.ERROR), TerminalColour.GREY))
logging.addLevelName(logging.CRITICAL, "{}{}{}".format(TerminalColour.MAGENTA, logging.getLevelName(logging.CRITICAL), .GREY))

%(levelname)

    LOGGING = {
...
'verbose': {
'format': '%(asctime)s %(levelname)s %(name)s:%(lineno)s %(module)s %(process)d %(thread)d %(message)s'
},
'simple': {
'format': '[%(asctime)s] %(levelname)s %(name)s %(message)s'
},