【问题标题】：如何将彩色文本打印到终端
【发布时间】：2010-09-22 05:15:50
【问题描述】：

如何在 Python 中将彩色文本输出到终端？

【问题讨论】：

这个符号将成为一个很棒的彩色块：█ 唯一的问题是它是扩展的 ASCII，也许你可以使用 http://stackoverflow.com/questions/8465226/using-extended-ascii-codes-with-python 来让它工作
有些终端也可以显示Unicode字符。如果您的终端是这样，那么可能的字符几乎是无限的。
这个答案来得相当晚，但对我来说似乎是最好的......上面投票的那些需要 Windows 的特殊黑客，而这个只是有效：stackoverflow.com/a/3332860/901641
stackoverflow.com/a/42528796/610569 使用 pypi.python.org/pypi/lazyme 怎么样？（免责声明：无耻插件）
如果您不想安装额外的软件包，请关注new answer。

【解决方案1】：

sty 与 colorama 类似，但不那么冗长，支持8-bit 和24-bit (RGB) 颜色，支持所有effects（粗体、下划线等）允许您register your own styles，是完全类型化和高性能，支持muting，不会与sys.stdout 等全局变量混淆，非常灵活，documented 等等...

示例：

from sty import fg, bg, ef, rs

foo = fg.red + 'This is red text!' + fg.rs
bar = bg.blue + 'This has a blue background!' + bg.rs
baz = ef.italic + 'This is italic text' + rs.italic
qux = fg(201) + 'This is pink text using 8bit colors' + fg.rs
qui = fg(255, 10, 10) + 'This is red text using 24bit colors.' + fg.rs

# Add custom colors:

from sty import Style, RgbFg

fg.orange = Style(RgbFg(255, 150, 50))

buf = fg.orange + 'Yay, Im orange.' + fg.rs

print(foo, bar, baz, qux, qui, buf, sep='\n')

打印：

演示：

【讨论】：

如果您考虑将它与 colorama 进行比较，那将非常有用，我更喜欢您的库，但这只是因为盒子里的 api 更短，如果它更受欢迎那就太好了。谢谢！
我喜欢 sty，我正在尝试用 sty 格式化我的字符串，一个问题是，当我打印多种颜色时，我可以重置为以前的颜色而不是默认颜色吗？
@VictorGavro 这是个好主意！我可能会在文档中添加一个比较。
@intijk 您的问题并不适合评论部分。对于此类问题，请创建一个新的 SO Question 或使用 github issue tracker。
@intijk ：使用代码 fg.rs 和 bg.rs 分别将前景色和背景色重置为默认值。

【解决方案2】：

还有Python termcolor module。用法很简单：

from termcolor import colored

print colored('hello', 'red'), colored('world', 'green')

或者在 Python 3 中：

print(colored('hello', 'red'), colored('world', 'green'))

但是，对于游戏编程和您想要做的“彩色块”来说，它可能不够复杂......

要让 ANSI 代码在 Windows 上运行，请先运行

os.system('color')

【讨论】：

由于它发出 ANSI 代码，如果加载了 ansi.sys，它是否可以在 Windows（DOS 控制台）上运行？ support.microsoft.com/kb/101875
刚刚注意到，截至 2011 年 1 月 13 日，它现在处于 MIT 许可下
没有单元测试（与 colorama 不同）并且自 2011 年以来未更新
termcolor.COLORS 为您提供颜色列表
在 Windows 上首先运行 os.system('color')，然后 ANSI 转义序列开始工作。

【解决方案3】：

在 windows 10 中，您可以尝试这个小脚本，它用作颜色混合器，红色、绿色和蓝色的值介于 0-255 之间：

import os

os.system('')


def RGB(red=None, green=None, blue=None,bg=False):
    if(bg==False and red!=None and green!=None and blue!=None):
        return f'\u001b[38;2;{red};{green};{blue}m'
    elif(bg==True and red!=None and green!=None and blue!=None):
        return f'\u001b[48;2;{red};{green};{blue}m'
    elif(red==None and green==None and blue==None):
        return '\u001b[0m'

并调用 RGB 函数将任意颜色组合为：

g0 = RGB()
g1 = RGB(0,255,0)
g2 = RGB(0,100,0,True)+""+RGB(100,255,100)
g3 = RGB(0,255,0,True)+""+RGB(0,50,0)

print(f"{g1}green1{g0}")
print(f"{g2}green2{g0}")
print(f"{g3}green3{g0}")

RGB() 不带参数将清除并将前景/背景颜色设置为默认。如果您想要 black，则应将其称为 RGB(0,0,0)，而对于 white，则应称为 RGB(255,255,255)。而RGB(0,255,0) 会产生绝对绿色，RGB(150,255,150) 会产生浅绿色。

这支持 background 和 foreground 颜色，要将颜色设置为 background 颜色，您必须使用 bg=True 传递它，即 @987654329 @ 默认情况下。

例如：要将 red 设置为 背景颜色，应将其命名为 RGB(255,0,0,True)，但选择 red 作为 字体颜色只需将其称为RGB(255,0,0,False)，因为bg默认为False，这简化了将其称为RGB(255,0,0)

【讨论】：

每个人都记住这些颜色是terminal independent，这意味着如果你想要某种不是来自终端的TERM 256 colors的绿色，它的going to work

【解决方案4】：

更简单的选择是使用 termcolor 包中的 cprint 函数。

还支持%s, %d格式的打印：

结果可能取决于终端，因此请查看包文档的终端属性部分。

Windows 命令提示符和 Python IDLE 不起作用

JupyterLab 笔记本可以正常工作

【讨论】：

如果您正在寻找适用于 windows 10 的解决方案，请看这里 => stackoverflow.com/a/70599663/3057246

【解决方案5】：

您可以使用pygments 模块来执行此操作。例如：

from pygments import console
print(pygments.console.colorize("red", "This text is red."))

这不允许您为终端提供十六进制颜色，但您可以尝试许多内置颜色，例如“蓝色”、“深绿色”、“黄色”等。

【讨论】：

【解决方案6】：

这是我的现代 (2021) 解决方案：yachalk

它是少数几个正确支持嵌套样式的库之一：

除此之外，yachalk 支持自动完成，支持 256/真彩色，带有终端功能检测，并且是全类型化的。

以下是您在选择解决方案时可能会考虑的一些设计决策。

高级库与低级库/手动样式处理？

此问题的许多答案演示了如何直接转义 ANSI 代码，或建议需要手动启用/禁用样式的低级库。

这些方法有一些微妙的问题：手动插入开/关样式是

在语法上更详细，因为必须明确指定重置，
更容易出错，因为您可能会不小心忘记重置样式，
无法正确处理边缘情况：例如，在某些终端中，需要在换行符之前重置样式，并在换行后重新激活它们。此外，一些终端在简单地覆盖互斥样式方面存在问题，并且需要插入“不必要的”重置代码。如果开发者的本地终端没有这些怪癖，开发者不会立即发现这些怪癖。该问题只会由其他人稍后报告或导致问题，例如在 CI 终端上。

因此，如果与许多终端兼容是一个目标，最好使用提供自动处理样式重置的高级库。这允许库通过在需要的地方插入“虚假”ANSI 转义码来处理所有边缘情况。

为什么还要另一个库？

在 JavaScript 中，该任务的事实上的标准库是 chalk，在 JS 项目中使用了一段时间后，相比之下，Python 世界中可用的解决方案缺乏。 chalk API 不仅使用起来更方便（完全兼容自动完成），而且还能正确处理所有边缘情况。

yachalk 的想法是为 Python 生态系统带来同样的便利。如果您对与其他库的比较感兴趣，我已经在项目页面上开始 feature comparison。此外，这里有一个很长（但仍然不完整）的替代方案列表，这些替代方案在我的研究过程中出现——有很多可供选择:)

【讨论】：

【解决方案7】：

当我在寻找如何为日志着色时，我被谷歌搬到了那里：

彩色日志

安装

pip install coloredlogs

用法

最少使用：

import logging
import coloredlogs

coloredlogs.install()  # install a handler on the root logger

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

结果：

从消息级调试开始：

import logging
import coloredlogs

coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

结果：

隐藏库中的消息：

import logging
import coloredlogs

logger = logging.getLogger(__name__)  # get a specific logger object
coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug
coloredlogs.install(level='DEBUG', logger=logger)  # pass a specific logger object

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

结果：

格式化日志消息：

import logging
import coloredlogs

logger = logging.getLogger(__name__)  # get a specific logger object
coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug
coloredlogs.install(level='DEBUG', logger=logger)  # pass a specific logger object
coloredlogs.install(
    level='DEBUG', logger=logger,
    fmt='%(asctime)s.%(msecs)03d %(filename)s:%(lineno)d %(levelname)s %(message)s'
)

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

结果：

可用的格式属性：

%(asctime)s - 发出记录调用时作为人类可读字符串的时间
%(created)f - 发出记录调用时的浮点时间
%(filename)s - 文件名
%(funcName)s - 包含日志调用的函数名称
%(hostname)s - 系统主机名
%(levelname)s - 文本记录级别
%(levelno)s - 整数日志记录级别
%(lineno)d - 发出记录调用的行号
%(message)s - 传递给日志调用的消息（与 %(msg)s 相同）
%(module)s - 发出日志调用的文件名不带扩展名
%(msecs)d - 发出记录调用时的毫秒部分
%(msg)s - 消息传递给日志调用（与 %(message)s 相同）
%(name)s - 记录器名称
%(pathname)s - 包含日志调用的文件的完整路径名
%(process)d - 进程 ID
%(processName)s - 进程名称
%(programname)s - 系统程序名
%(relativeCreated)d - 发出记录调用时的整数毫秒数，相对于加载记录模块的时间
%(thread)d - 线程 ID
%(threadName)s - 线程名称
%(username)s - 系统用户名

来源：

Coloredlogs package

Logging library

【讨论】：

【解决方案8】：

此答案试图通过使用正则表达式对文本块中的关键字进行着色来扩展将彩色文本写入终端的概念。

这个答案还使用了 Python 库 Rich，在之前的这个问题的答案中简要介绍了该库。在这个答案中，我使用函数 rich.color.ANSI_COLOR_NAMES 来获取将用于突出显示预定义搜索词的随机颜色列表。

import random
import re as regex
from rich import color
from rich import print


def create_dynamic_regex(search_words):
    """
    This function is used to create a dynamic regular expression
    string and a list of random colors. Both these elements will
    be used in the function colorize_text()

    :param search_words: list of search terms
    :return: regular expression search string and a list of colors
    :rtype: string, list
    """
    colors_required = create_list_of_colors(len(search_words))
    number_of_search_words = len(search_words)
    combined_string = ''
    for search_word in search_words:
        number_of_search_words -= 1
        if number_of_search_words != 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)|')
            combined_string = (combined_string + current_string)
        elif number_of_search_words == 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)')
            combined_string = (combined_string + current_string)
    return combined_string, colors_required


def random_color():
    """
    This function is used to create a random color using the
    Python package rich.
    :return: color name
    :rtype: string
    """
    selected_color = random.choice(list(color.ANSI_COLOR_NAMES.keys()))
    return selected_color


def create_list_of_colors(number_of_colors):
    """
    This function is used to generate a list of colors,
    which will be used in the function colorize_text()
    :param number_of_colors:
    :return: list of colors
    :rtype: list
    """
    list_of_colors = [random_color() for _ in range(number_of_colors)]
    return list_of_colors


def colorize_text(text, regex_string, array_of_colors):
    """
    This function is used to colorize specific words in a text string.
    :param text: text string potentially containing specific words to colorize.
    :param regex_string: regular expression search string
    :param array_of_colors: list of colors
    :return: colorized text
    :rtype: string
    """
    available_colors = array_of_colors
    word_regex = regex.compile(f"{regex_string}", regex.IGNORECASE)
    i = 0
    output = ""
    for word in word_regex.finditer(text):
        get_color = available_colors[word.lastindex - 1]
        output += "".join([text[i:word.start()],
                           "[%s]" % available_colors[word.lastindex - 1],
                           text[word.start():word.end()], "[/%s]" % available_colors[word.lastindex - 1]])
        i = word.end()
    return ''.join([output, text[word.end():]])


def generate_console_output(text_to_search, words_to_find):
    """
    This function is used generate colorized text that will
    be outputting to the console.

    :param text_to_search: text string potentially containing specific words to colorize.
    :param words_to_find: list of search terms.
    :return: A string containing colorized words.
    :rtype: string
    """
    search_terms, colors = create_dynamic_regex(words_to_find)
    colorize_html = colorize_text(text_to_search, search_terms, colors)
    print(colorize_html)


text = "The dog chased the cat that was looking for the mouse that the dog was playing with."
words = ['dog', 'cat', 'mouse']
generate_console_output(text, words)

这是上面代码的打印输出：

我为文本着色创建了两个 GIST。

【讨论】：

【解决方案9】：

在我看来，这是最简单的方法。只要你有你想要的颜色的 RGB 值，这应该可以工作：

def colored(r, g, b, text):
    return "\033[38;2;{};{};{}m{} \033[38;2;255;255;255m".format(r, g, b, text)

打印红色文字的例子：

text = 'Hello, World!'
colored_text = colored(255, 0, 0, text)
print(colored_text)

#or

print(colored(255, 0, 0, 'Hello, World!'))

多色文字

text = colored(255, 0, 0, 'Hello, ') + colored(0, 255, 0, 'World')
print(text)

【讨论】：

这实际上是问题的正确答案，应该选择。问题是如何在 python 中打印颜色，而不是可以使用哪些外部库。
当我创建一个红色字符串“bubble”时，这会打印“←[38;2;255;0;0mbubble ←[38;2;255;255;255m”。这是一台 W10 机器……您的解决方案是 *nix 专用的吗？
@mike_rodent 这不是 *nix 特定的，但取决于终端是否支持 ANSI
这可以使用 lambda 和 f 字符串进一步整理：`colored = lambda r, g, b, text: f'\033[38;2;{r};{g}; {b}m{文本} \033[38;2;255;255;255m'

【解决方案10】：

如果您只想使用内置包，请遵循以下结构：

实际上，我增强了Mohamed Samy 答案，它现在负责多个输入和数字。此外，它还支持其他print() 参数，例如end=。此外，我添加了一个.store() 方法，以便将日志也写入文件。

您可以创建一个实用程序以在代码中的任何位置使用它：

# utility.py

from datetime import datetime

class ColoredPrint:
    def __init__(self):
        self.PINK = '\033[95m'
        self.OKBLUE = '\033[94m'
        self.OKGREEN = '\033[92m'
        self.WARNING = '\033[93m'
        self.FAIL = '\033[91m'
        self.ENDC = '\033[0m'

    def disable(self):
        self.PINK = ''
        self.OKBLUE = ''
        self.OKGREEN = ''
        self.WARNING = ''
        self.FAIL = ''
        self.ENDC = ''

    def store(self):
        date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        with open('logfile.log', mode='a') as file_:
            file_.write(f"{self.msg} -- {date}")
            file_.write("\n")

    def success(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.OKGREEN + self.msg + self.ENDC, **kwargs)
        return self

    def info(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.OKBLUE + self.msg + self.ENDC, **kwargs)
        return self

    def warn(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.WARNING + self.msg + self.ENDC, **kwargs)
        return self

    def err(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.FAIL + self.msg + self.ENDC, **kwargs)
        return self

    def pink(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.PINK + self.msg + self.ENDC, **kwargs)
        return self

例如

from utility import ColoredPrint

log = ColoredPrint()

log.success("Hello" , 123, "Bye").store()
log.info("Hello" , 123, "Bye")
log.warn("Hello" , 123, "Bye")
log.err("Hello" , 123, "Bye").store()
log.pink("Hello" , 123, "Bye")

输出：

[更新]：

现在，它的 PyPI package? 可用：

pip install python-colored-print

【讨论】：

【解决方案11】：

这是一个在 Windows 10 上原生运行的解决方案。

使用系统调用，例如os.system("")，允许在命令提示符和 Powershell 中本地打印颜色：

import os

# System call
os.system("")

# Class of different styles
class style():
    BLACK = '\033[30m'
    RED = '\033[31m'
    GREEN = '\033[32m'
    YELLOW = '\033[33m'
    BLUE = '\033[34m'
    MAGENTA = '\033[35m'
    CYAN = '\033[36m'
    WHITE = '\033[37m'
    UNDERLINE = '\033[4m'
    RESET = '\033[0m'

print(style.YELLOW + "Hello, World!")

注意：Windows 不完全支持 ANSI 代码，无论是通过系统调用还是模块。并非所有文本装饰都受支持，虽然显示的是亮色，但它们与常规颜色相同。

感谢@j-l 找到更短的方法。

tl;dr：添加os.system("")

【讨论】：

这行得通 - 我真的很惊讶 color 命令在 Windows 终端中启用了 ANSI 代码，我已经走了很多年而不知道这是可能的 - 命令本身并没有给出任何线索它会这样做。
非常感谢您的回答，@SimpleBinary！玩弄您的答案，我发现您可以进一步简化if sys.platform.lower() == "win32": os.system('color')，只需将其替换为os.system('')。不需要条件，代码在 Windows 10 和 Linux 中都可以运行（当我测试它时）。如您所见，您不必对color 进行系统调用。调用dir、cd、abcdef 和一个空字符串就可以正常工作（尽管非空字符串可能会打印您不想看到的输出）。
简而言之，对color 的调用不是关键部分；在 Windows 10 上运行时，正是 os.system(command) 行本身使打印颜色成为可能。“命令”可以是任何东西，真的 - 甚至只是一个空字符串。
这真的很有趣！为什么os.system("") 会导致颜色代码起作用？
@Starwarswii 这不是 python 的实现，在调用 system(""); (include <stdlib.h>) 之后在 Windows 中运行 printf(fmt, ...); 并使用 ASNI 代码打印彩色文本，我仍然很好奇为什么会这样?

【解决方案12】：

Rich 是一个相对较新的 Python 库，用于在终端中处理颜色。

在 Rich 中有几种处理颜色的方法。最快的入门方法是丰富的打印方法，它将类似BBCode 的语法呈现到 ANSI 控制代码中：

from rich import print
print("[red]Color[/] in the [bold magenta]Terminal[/]!")

还有其他方法可以通过 Rich（正则表达式、语法）和相关格式功能应用颜色。

【讨论】：

【解决方案13】：

表情符号

您可以像其他人在他们的答案中提到的那样为文本使用颜色，以获得带有背景或前景色的彩色文本。

但您可以改用表情符号！例如，您可以将⚠️ 用于警告消息，将? 用于错误消息。

或者简单地将这些笔记本用作颜色：

?: error message
?: warning message
?: ok status message
?: action message
?: canceled status message
?: Or anything you like and want to recognize immediately by color

? 奖励：

此方法还可以帮助您直接在源代码中快速扫描和查找日志。

_{但是某些操作系统（包括某些版本中带有一些窗口管理器的 Linux 发行版）默认的表情符号字体默认情况下是不彩色的，您可能希望首先使它们彩色。}

【讨论】：

这不是被问到的，但我很高兴你分享了它！比起文字颜色，我真的更喜欢这个。
Linux？什么发行版、版本和窗口管理器？ Ubuntu 20.04 (Focal Fossa)?
答案已更新，更准确。感谢指出@PeterMortensen

【解决方案14】：

import click

click.secho('Hello, World!', fg='green')
click.secho('Some more text', bg='blue', fg='white')
click.secho('ATTENTION', blink=True, bold=True)

click (CLI library) 有一种非常方便的方法，如果您正在编写命令行工具，则值得考虑。

【讨论】：

完美，这对我有用！ color-it 解决方案对我不起作用，因为我的文本没有被 Colors.etc 上提供的颜色着色......我所有的文本都变成了灰色文本，但色调不同（更亮/更暗）

【解决方案15】：

我创建了一个项目 (console-color) 并已将其发布到 PyPI。

你可以抛出pip install console-color来安装它。

我使用 Sphinx-read-the-doc 编写文档，请参阅here。

您可以从google-colab 获得更多示例。

我还是贴一些例子来吸引用户点击上面的链接：

# cprint is something like below
# cprint(text: str, fore: T_RGB = None, bg: T_RGB = None, style: Style = '')
# where T_RGB = Union[Tuple[int, int, int], str] for example. You can input (255, 0, 0) or '#ff0000' or 'ff0000'. They are OK.
# The Style you can input the ``Style.`` (the IDE will help you to choose what you wanted)

# from console_color import RGB, Fore, Style, cprint, create_print
from console_color import *

cprint("Hello, World!", RGB.RED, RGB.YELLOW, Style.BOLD+Style.URL+Style.STRIKE)
cprint("Hello, World!", fore=(255, 0, 0), bg="ffff00", style=Style.BOLD+Style.URL+Style.STRIKE)

当然，您不必输入所有参数。你可以添加你想要的属性。

说实话，这个项目并不特别。它只使用f"\033[{target};2;{r};{g};{b}m{text}{style}" 其中目标是 38 或 48，文本是您的输入字符串，样式是 '\33[0m'、'\33[1m' ... '\033[9m'。某种东西。

我只是让它易于使用（至少对我而言）。

【讨论】：

【解决方案16】：

我是 Python 新手，每次发现主题时我都会很兴奋，比如这个。但这一次（突然）我觉得我有话要说。特别是因为几分钟前我在 Python 中发现了一个 wow 的东西（至少现在对我来说）：

Context Managers

from contextlib import contextmanager
# FORECOLOR
BLACKFC,REDFC,GREENFC,YELLOWFC,BLUEFC = '38;30m','38;31m','38;32m','38;33m','38;34m'
# BACKGOUND
BLACKBG,REDBG,GREENBG,YELLOWBG,BLUEBG = '48;40m','48;41m','48;42m','48;43m','48;44m'

@contextmanager
def printESC(prefix, color, text):
  print("{prefix}{color}{text}".format(prefix=prefix, color=color, text=text), end='')
  yield
  print("{prefix}0m".format(prefix=prefix))

with printESC('\x1B[', REDFC, 'Colored Text'):
  pass

Example

或者像这样：

# FORECOLOR
BLACKFC,REDFC,GREENFC,YELLOWFC,BLUEFC = '38;30m','38;31m','38;32m','38;33m','38;34m'
# BACKGOUND
BLACKBG,REDBG,GREENBG,YELLOWBG,BLUEBG = '48;40m','48;41m','48;42m','48;43m','48;44m'

def printESC(prefix, color, text):
  print("{prefix}{color}{text}".format(prefix=prefix, color=color, text=text), end='')
  print("{prefix}0m".format(prefix=prefix))

printESC('\x1B[', REDFC, 'Colored Text')

【讨论】：

【解决方案17】：

以joeld's answer 为基础，使用https://pypi.python.org/pypi/lazyme
pip install -U lazyme：

from lazyme.string import color_print
>>> color_print('abc')
abc
>>> color_print('abc', color='pink')
abc
>>> color_print('abc', color='red')
abc
>>> color_print('abc', color='yellow')
abc
>>> color_print('abc', color='green')
abc
>>> color_print('abc', color='blue', underline=True)
abc
>>> color_print('abc', color='blue', underline=True, bold=True)
abc
>>> color_print('abc', color='pink', underline=True, bold=True)
abc

截图：

使用新格式化程序对color_print 进行了一些更新，例如：

>>> from lazyme.string import palette, highlighter, formatter
>>> from lazyme.string import color_print
>>> palette.keys() # Available colors.
['pink', 'yellow', 'cyan', 'magenta', 'blue', 'gray', 'default', 'black', 'green', 'white', 'red']
>>> highlighter.keys() # Available highlights.
['blue', 'pink', 'gray', 'black', 'yellow', 'cyan', 'green', 'magenta', 'white', 'red']
>>> formatter.keys() # Available formatter,
['hide', 'bold', 'italic', 'default', 'fast_blinking', 'faint', 'strikethrough', 'underline', 'blinking', 'reverse']

注意：italic、fast blinking 和 strikethrough 可能无法在所有终端上运行，并且它们不适用于 Mac 和 Ubuntu。

例如，

>>> color_print('foo bar', color='pink', highlight='white')
foo bar
>>> color_print('foo bar', color='pink', highlight='white', reverse=True)
foo bar
>>> color_print('foo bar', color='pink', highlight='white', bold=True)
foo bar
>>> color_print('foo bar', color='pink', highlight='white', faint=True)
foo bar
>>> color_print('foo bar', color='pink', highlight='white', faint=True, reverse=True)
foo bar
>>> color_print('foo bar', color='pink', highlight='white', underline=True, reverse=True)
foo bar

截图：

【讨论】：

【解决方案18】：

定义一个开始颜色的字符串和结束颜色的字符串。然后打印你的文本，开始字符串在前面，结束字符串在结尾。

CRED = '\033[91m'
CEND = '\033[0m'
print(CRED + "Error, does not compute!" + CEND)

这会在 Bash 中使用 Zenburn 风格的配色方案在 urxvt 中生成以下内容：

通过实验，我们可以得到更多的颜色：

注意：\33[5m 和 \33[6m 正在闪烁。

这样我们可以创建一个完整的颜色集合：

CEND      = '\33[0m'
CBOLD     = '\33[1m'
CITALIC   = '\33[3m'
CURL      = '\33[4m'
CBLINK    = '\33[5m'
CBLINK2   = '\33[6m'
CSELECTED = '\33[7m'

CBLACK  = '\33[30m'
CRED    = '\33[31m'
CGREEN  = '\33[32m'
CYELLOW = '\33[33m'
CBLUE   = '\33[34m'
CVIOLET = '\33[35m'
CBEIGE  = '\33[36m'
CWHITE  = '\33[37m'

CBLACKBG  = '\33[40m'
CREDBG    = '\33[41m'
CGREENBG  = '\33[42m'
CYELLOWBG = '\33[43m'
CBLUEBG   = '\33[44m'
CVIOLETBG = '\33[45m'
CBEIGEBG  = '\33[46m'
CWHITEBG  = '\33[47m'

CGREY    = '\33[90m'
CRED2    = '\33[91m'
CGREEN2  = '\33[92m'
CYELLOW2 = '\33[93m'
CBLUE2   = '\33[94m'
CVIOLET2 = '\33[95m'
CBEIGE2  = '\33[96m'
CWHITE2  = '\33[97m'

CGREYBG    = '\33[100m'
CREDBG2    = '\33[101m'
CGREENBG2  = '\33[102m'
CYELLOWBG2 = '\33[103m'
CBLUEBG2   = '\33[104m'
CVIOLETBG2 = '\33[105m'
CBEIGEBG2  = '\33[106m'
CWHITEBG2  = '\33[107m'

这是生成测试的代码：

x = 0
for i in range(24):
  colors = ""
  for j in range(5):
    code = str(x+j)
    colors = colors + "\33[" + code + "m\\33[" + code + "m\033[0m "
  print(colors)
  x = x + 5

【讨论】：

什么外壳或终端让它闪烁？
(u)rxvt 例如
仅供参考 - 上面标记为“米色”的是 Apple 终端上的浅青色（以及 Python 的许多其他颜色名称列表）。此外，一些双色是浅色/深色版本，白色变体我称之为白色和灰色......
@captain \33[25m 也应该表示“不闪烁”，无需重置其他样式 - en.wikipedia.org/wiki/…

【解决方案19】：

我最终这样做了，我觉得它最干净：

formatters = {
    'RED': '\033[91m',
    'GREEN': '\033[92m',
    'END': '\033[0m',
}

print 'Master is currently {RED}red{END}!'.format(**formatters)
print 'Help make master {GREEN}green{END} again!'.format(**formatters)

【讨论】：

这对于在没有第三方软件包的情况下进行操作非常好。

【解决方案20】：

试试这个简单的代码

def prRed(prt): print("\033[91m {}\033[00m" .format(prt))
def prGreen(prt): print("\033[92m {}\033[00m" .format(prt))
def prYellow(prt): print("\033[93m {}\033[00m" .format(prt))
def prLightPurple(prt): print("\033[94m {}\033[00m" .format(prt))
def prPurple(prt): print("\033[95m {}\033[00m" .format(prt))
def prCyan(prt): print("\033[96m {}\033[00m" .format(prt))
def prLightGray(prt): print("\033[97m {}\033[00m" .format(prt))
def prBlack(prt): print("\033[98m {}\033[00m" .format(prt))

prGreen("Hello, World!")

【讨论】：

建议：定义返回该彩色字符串的 lambda，而不是直接打印它们，以便与其他字符串结合使用。
感谢@gustafbstron。这就是我决定使用的：def prGreen: return '"\033[91m {}\033[00m" .format(prt)，这样使用：print(f'This will turn {prGreen("Hello world")} and change back')

【解决方案21】：

另一个封装了 Python 3 print 函数的 PyPI 模块：

https://pypi.python.org/pypi/colorprint

如果您还 from __future__ import print，它也可以在 Python 2.x 中使用。以下是模块 PyPI 页面中的 Python 2 示例：

from __future__ import print_function
from colorprint import *

print('Hello', 'world', color='blue', end='', sep=', ')
print('!', color='red', format=['bold', 'blink'])

它输出“你好，世界！”带有蓝色的单词和红色粗体的感叹号并闪烁。

【讨论】：

【解决方案22】：

如果您使用的是Django：

>>> from django.utils.termcolors import colorize
>>> print colorize("Hello, World!", fg="blue", bg='red',
...                 opts=('bold', 'blink', 'underscore',))
Hello World!
>>> help(colorize)

快照：

（我在runserver终端调试一般使用彩色输出，所以我加了。）

_{你可以测试它是否安装在你的机器上：
$ python -c "import django; print django.VERSION"。要安装它，请检查：How to install Django}

试一试！！

【讨论】：

请注意，在 python3.x 中，您应该在打印后添加一个额外的括号：print(colorize(...))

【解决方案23】：

非常简单，基于joeld's answer：

class PrintInColor:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    LIGHT_PURPLE = '\033[94m'
    PURPLE = '\033[95m'
    END = '\033[0m'

    @classmethod
    def red(cls, s, **kwargs):
        print(cls.RED + s + cls.END, **kwargs)

    @classmethod
    def green(cls, s, **kwargs):
        print(cls.GREEN + s + cls.END, **kwargs)

    @classmethod
    def yellow(cls, s, **kwargs):
        print(cls.YELLOW + s + cls.END, **kwargs)

    @classmethod
    def lightPurple(cls, s, **kwargs):
        print(cls.LIGHT_PURPLE + s + cls.END, **kwargs)

    @classmethod
    def purple(cls, s, **kwargs):
        print(cls.PURPLE + s + cls.END, **kwargs)

那么就

PrintInColor.red('hello', end=' ')
PrintInColor.green('world')

【讨论】：

如果您传递多个位置参数或字符串类型以外的任何内容，这将崩溃
@RomainVincent 那么不要传递多个位置参数或字符串 ty 以外的任何其他内容——等等，这些是 print-replacements？异议被撤销。
@wizzwizz4 我不确定你的评论是什么意思，反正我不明白这一点。如果您要提出一个类...，以替换像 print 这样简单的方法，您最好避免让它变得如此容易破坏。只是我的意见。
@RomainVincent 我要说你的反对意见是错误的，但是要替换像print 这样通用的功能，应该确保正确复制其功能。
@RomainVincent 实现使用无限参数： def purple(cls, *args, **kwargs): print(cls.PURPLE, *args, cls.END, **kwargs)

【解决方案24】：

耶！另一个版本

虽然我发现this answer 很有用，但我对其进行了一些修改。这个GitHub Gist是结果

用法

print colors.draw("i'm yellow", bold=True, fg_yellow=True)

另外，可以对常用的用法进行包装：

print colors.error('sorry, ')

https://gist.github.com/Jossef/0ee20314577925b4027f

【讨论】：

【解决方案25】：

使用pyfancy。很简单的在终端做颜色的方法！

例子：

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

【讨论】：

不是很好的代码，它甚至包含对 pythonw.exe 的引用；)

【解决方案26】：

您可以使用任何语言都可用的 shell 转义字符。这些转义字符以 ESC 字符开头，后跟多个参数。

例如，要在终端中输出红色 “Hello, World!” 字符串：

echo "\e[31m Hello, World! \e[0m"

或来自 Python 脚本：

print("\e[31m Hello world \e[0m")

另外，我写了一篇关于Escape sequences 的文章，或许可以帮助你更好地理解这个机制。

【讨论】：

Python 没有\e 转义序列。仅仅因为 some echo 实现支持它并不能使这些序列普遍可用。
而且\e 不是echo 的POSIX 规范的一部分，因此它也不是通用的。 GNU coreutils 版本支持它，但不支持 OS X（一种 BSD 变体）上使用的版本。最后但同样重要的是，该序列也不是 shell 功能，它特定于 echo 命令。
请看这个问题stackoverflow.com/questions/47121421/…，它导致了这些cmets。

【解决方案27】：

我在 Linux、OS X 和 Windows 中编写了一个处理颜色的模块。它支持所有平台上的所有 16 种颜色，您可以在不同时间设置前景色和背景色，并且字符串对象为 len() 和 .capitalize() 之类的东西提供了合理的结果。

https://github.com/Robpol86/colorclass

【讨论】：

【解决方案28】：

打印一个以颜色/样式开头的字符串，然后是字符串，然后以'\x1b[0m'结束颜色/样式更改：

print('\x1b[6;30;42m' + 'Success!' + '\x1b[0m')

使用以下代码获取 shell 文本的格式选项表：

def print_format_table():
    """
    prints table of formatted text format options
    """
    for style in range(8):
        for fg in range(30,38):
            s1 = ''
            for bg in range(40,48):
                format = ';'.join([str(style), str(fg), str(bg)])
                s1 += '\x1b[%sm %s \x1b[0m' % (format, format)
            print(s1)
        print('\n')

print_format_table()

明暗示例（完整）

暗光示例（部分）

【讨论】：

这适用于大多数 shell 以及 ipython，对于大多数应用程序来说已经足够了
请问，这是哪个终端？
便携性如何？
短独立实现：gist.github.com/Sheljohn/68ca3be74139f66dbc6127784f638920
@Flip 这将适用于任何支持 ANSI 转义序列的终端/控制台。

【解决方案29】：

如果您使用的是 Windows，那么就可以了！

# Display text on a Windows console
# Windows XP with Python 2.7 or Python&nbsp;3.2
from ctypes import windll

# Needed for Python2/Python3 diff
try:
    input = raw_input
except:
    pass
STD_OUTPUT_HANDLE = -11
stdout_handle = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
# Look at the output and select the color you want.
# For instance, hex E is yellow on black.
# Hex 1E is yellow on blue.
# Hex 2E is yellow on green and so on.
for color in range(0, 75):
     windll.kernel32.SetConsoleTextAttribute(stdout_handle, color)
     print("%X --> %s" % (color, "Have a fine day!"))
     input("Press Enter to go on ... ")

【讨论】：

如果您想在同一行使用不同的颜色，请在两次调用之间刷新标准输出流：print("%X --> %s" % (color, "Have a fine day!"), end='', flush=True)

【解决方案30】：

你可以使用Clint:

from clint.textui import colored
print colored.red('some warning message')
print colored.green('nicely done!')

【讨论】：

第一个链接已经消失，所以我删除了它； GH 链接仍然很好（尽管该项目已“存档”并且基本上已被放弃，据我所知）。