Python 如何将彩色文本打印到终端？

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

对于Windows，除非使用API，否则无法使用彩色打印到控制台

对于Linux，它与使用print一样简单，下面列出了转义序列：

对于像方框一样打印的字符，这实际上取决于您在控制台窗口中使用的字体。英镑符号效果良好，但取决于字体：

#

---

您可以使用库的Python实现：

此外，运行此命令，您将找到您的方框：

for i in range(255):
    print i, chr(i)

---

您想了解ANSI转义序列。下面是一个简单的例子：

CSI = "\x1B["
print(CSI+"31;40m" + "Colored Text" + CSI + "0m")

有关详细信息，请参阅

对于块字符，请尝试使用Unicode字符，如\u2588：

print(u"\u2588")

总而言之：

print(CSI+"31;40m" + u"\u2588" + CSI + "0m")

---

这在某种程度上取决于您所处的平台。最常用的方法是打印ANSI转义序列。对于一个简单的示例，以下是来自的一些Python代码：

要使用这样的代码，可以执行以下操作：

print(bcolors.WARNING + "Warning: No active frommets remain. Continue?" + bcolors.ENDC)

或者，使用Python 3.6+：

print(f"{bcolors.WARNING}Warning: No active frommets remain. Continue?{bcolors.ENDC}")

这将在Unix上工作，包括OSX、Linux和Windows（如果您使用，或在Windows10中启用）。有用于设置颜色、移动光标等的ANSI代码

如果你想把这个复杂化（如果你在写游戏的话，听起来像是这样），你应该研究一下“”模块，它为你处理很多复杂的部分。这是一个很好的介绍

如果您不使用扩展ASCII（即，不在PC上），您将无法使用127以下的ASCII字符，而“#”或“@”可能是块的最佳选择。如果您可以确保您的终端使用的是IBM，那么您就有了更多的选择。字符176、177、178和219是“块字符”

一些基于文本的现代程序，如“矮人堡垒”，以图形模式模拟文本模式，并使用经典PC字体的图像。您可以在see（）上找到一些可以使用的位图

---

有更多的资源用于在文本模式下进行图形处理。

如果您正在编写游戏，您是否希望更改背景颜色并仅使用空格？例如：

print " "+ "\033[01;41m" + " " +"\033[01;46m"  + "  " + "\033[01;42m"

from blessings import Terminal

t = Terminal()
print t.red('This is red.')
print t.bold_bright_red_on_black('Bright red on black')

---

在Windows上，您可以使用模块“Win32 Console”（在某些Python发行版中可用）或模块“ctypes”（Python 2.5及更高版本）来访问Win32 API

要查看支持两种方式的完整代码，请参阅中的

ctypes示例：

import ctypes

# Constants from the Windows API
STD_OUTPUT_HANDLE = -11
FOREGROUND_RED    = 0x0004 # text color contains red.

def get_csbi_attributes(handle):
    # Based on IPython's winconsole.py, written by Alexander Belchenko
    import struct
    csbi = ctypes.create_string_buffer(22)
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(handle, csbi)
    assert res

    (bufx, bufy, curx, cury, wattr,
    left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
    return wattr


handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
reset = get_csbi_attributes(handle)

ctypes.windll.kernel32.SetConsoleTextAttribute(handle, FOREGROUND_RED)
print "Cherry on top"
ctypes.windll.kernel32.SetConsoleTextAttribute(handle, reset)

还有一个问题。用法非常简单：

from termcolor import colored

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

或者在Python 3中：

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

但是，对于游戏编程和您想要执行的“彩色块”，它可能还不够复杂…

答案是Python中的所有跨平台着色

它支持Python3.5+和Python2.7

自2021年1月起，该计划得以维持

示例屏幕截图：

---

我最喜欢的方式是使用图书馆（完全公开：我写的）。例如：

print " "+ "\033[01;41m" + " " +"\033[01;46m"  + "  " + "\033[01;42m"

from blessings import Terminal

t = Terminal()
print t.red('This is red.')
print t.bold_bright_red_on_black('Bright red on black')

要打印彩色砖块，最可靠的方法是使用背景色打印空间。我使用此技术在以下位置绘制进度条：

您也可以在特定位置打印：

with t.location(0, 5):
    print t.on_yellow(' ')

如果你不得不在游戏过程中使用其他终端功能，你也可以这样做。您可以使用Python的标准字符串格式来保持可读性：

print '{t.clear_eol}You just cleared a {t.bold}whole{t.normal} line!'.format(t=t)

祝福的好处在于，它尽最大努力在各种终端上工作，而不仅仅是（绝大多数常见的）ANSI彩色终端。它还可以在代码中保留不可读的转义序列，同时保持简洁易用。玩得开心

您可以使用：

---

如果你使用的是Windows，那就给你

# Display text on a Windows console
# Windows XP with Python 2.7 or Python 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 ... ")

---

注意

with

关键字与需要重置的修饰符（使用Python 3和Colorama）的混合程度：

我已经包装成一个模块，其中包含全局函数，可以在代码中的任何地方使用

文件：log.py

def enable（）：
页眉='\033[95m'
OKBLUE='\033[94m'
OKGREEN='\033[92m'
警告='\033[93m'
失败='\033[91m'
ENDC='\033[0m'
BOLD=“\033[1m”
def disable（）：
标题=“”
OKBLUE=''
OKGREEN=''
警告=“”
失败=“”
ENDC=''
def infog（msg）：
打印（绿色+味精+ENDC）
def信息（msg）：
打印（OKBLUE+msg+ENDC）
def warn（消息）：
打印（警告+消息+结束）
def err（消息）：
打印（失败+消息+结束）
启用（）

使用方法如下：

导入日志
log.info（“你好，世界！”）
log.err（“系统错误”）

打印一个开始颜色/样式的字符串，然后打印该字符串，然后用

'\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()

黑暗中的光明示例（完整）

暗对亮示例（部分）

---

我使用

for

循环生成了一个包含所有颜色的类，以迭代每个颜色组合，最多迭代100个，然后使用Python颜色编写了一个类。请按照您的意愿复制和粘贴，我的GPLv2：

class colors:
    '''Colors class:
    Reset all colors with colors.reset
    Two subclasses fg for foreground and bg for background.
    Use as colors.subclass.colorname.
    i.e. colors.fg.red or colors.bg.green
    Also, the generic bold, disable, underline, reverse, strikethrough,
    and invisible work with the main class
    i.e. colors.bold
    '''
    reset='\033[0m'
    bold='\033[01m'
    disable='\033[02m'
    underline='\033[04m'
    reverse='\033[07m'
    strikethrough='\033[09m'
    invisible='\033[08m'
    class fg:
        black='\033[30m'
        red='\033[31m'
        green='\033[32m'
        orange='\033[33m'
        blue='\033[34m'
        purple='\033[35m'
        cyan='\033[36m'
        lightgrey='\033[37m'
        darkgrey='\033[90m'
        lightred='\033[91m'
        lightgreen='\033[92m'
        yellow='\033[93m'
        lightblue='\033[94m'
        pink='\033[95m'
        lightcyan='\033[96m'
    class bg:
        black='\033[40m'
        red='\033[41m'
        green='\033[42m'
        orange='\033[43m'
        blue='\033[44m'
        purple='\033[45m'
        cyan='\033[46m'
        lightgrey='\033[47m'

耶！另一个版本 虽然我觉得有用，但我对它做了一些修改。这就是结果

用法

此外，您还可以包装常见用法：

print colors.error('sorry, ')

愚蠢的简单，基于：

那就

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

如果您正在使用：

快照：

（我通常在runserver终端上使用彩色输出进行调试，所以我添加了它。）

您可以测试它是否安装在您的计算机中：

$python-c“导入django；打印django.VERSION”

。要安装它，请检查：

试试看！！

试试这个简单的代码

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!")

---

最后我做了这个，我觉得它是最干净的：

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)

---

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

CRED='\033[91m'
CEND='\033[0m'
打印（CRED+“错误，不计算！”+CEND）

这将在Bash中，在

urxvt

中，使用Zenburn样式的配色方案生成以下内容：

通过实验，我们可以得到更多的c

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')

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

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!")

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)

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'

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

>>> 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']

>>> 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

# Pure Python 3.x demo, 256 colors
# Works with bash under Linux and MacOS

fg = lambda text, color: "\33[38;5;" + str(color) + "m" + text + "\33[0m"
bg = lambda text, color: "\33[48;5;" + str(color) + "m" + text + "\33[0m"

def print_six(row, format, end="\n"):
    for col in range(6):
        color = row*6 + col - 2
        if color>=0:
            text = "{:3d}".format(color)
            print (format(text,color), end=" ")
        else:
            print(end="    ")   # four spaces
    print(end=end)

for row in range(0, 43):
    print_six(row, fg, " ")
    print_six(row, bg)

# Simple usage: print(fg("text", 160))