关于python：用颜色在终端上输出？


Print in terminal with colors?

如何用python将彩色文本输出到终端？代表实体块的最佳Unicode符号是什么？

相关讨论

这在一定程度上取决于您所处的平台。最常见的方法是打印ansi转义序列。举个简单的例子，下面是Blender构建脚本中的一些python代码：

1
2
3
4
5
6
7
8
9
class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

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

1
2
print bcolors.WARNING +"Warning: No active frommets remain. Continue?"
      + bcolors.ENDC

这将在包括OS X、Linux和Windows在内的Unix上工作(前提是使用Ansicon，或者在启用VT100仿真的Windows 10中)。有用于设置颜色、移动光标等的ANSI代码。

如果你想把这件事复杂化(听起来好像你在写游戏)，你应该看看"诅咒"模块，它为你处理了很多复杂的部分。Python诅咒如何是一个很好的介绍。

如果您不使用扩展的ASCII(即不在PC上)，则会遇到127以下的ASCII字符，而""或"@"可能是块的最佳选择。如果您可以确保您的终端使用IBM扩展的ASCII字符集，那么您有更多的选项。字符176、177、178和219是"块字符"。

一些现代的基于文本的程序，如"矮人堡垒"，在图形模式下模拟文本模式，并使用经典PC字体的图像。您可以在矮人堡垒wiki上找到一些可以使用的位图，请参阅(用户制作的tileset)。

文本模式演示比赛有更多的资源在文本模式下进行图形处理。

隐马尔可夫模型。。我觉得这个答案有点过意不去。不过，我正在计划一款基于文本的史诗级冒险游戏。祝你的彩色文字好运！

相关讨论

我很惊讶没有人提到python termcolor模块。使用非常简单：

1
2
3
from termcolor import colored

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

或者在Python 3中：

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

然而，对于游戏编程和你想做的"彩色块"来说，它可能不够复杂……

相关讨论

答案是对所有跨平台的python着色的colorama。

python 3.6示例屏幕截图：example screenshot

相关讨论

打印开始颜色/样式的字符串，然后打印该字符串，然后使用'\x1b[0m'结束颜色/样式更改：

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

Success with green background example

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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('
')

print_format_table()

明暗示例(完整)

enter image description here

明暗示例(部分)

top part of output

相关讨论

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

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

这在bash和urxvt中产生了以下具有zenburn风格的颜色方案：

output colors

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

color matrix

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

通过这种方式，我们可以创建一个完整的颜色集合：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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'

下面是生成测试的代码：

1
2
3
4
5
6
7
8
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
相关讨论

您希望了解有关ansi转义序列的信息。下面是一个简单的例子：

1
2
CSI="\x1B["
print CSI+"31;40m" +"Colored Text" + CSI +"0m"

有关详细信息，请参阅http://en.wikipedia.org/wiki/ansi_escape_code。

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

1
print u"\u2588"

把它们放在一起：

1
print CSI+"31;40m" + u"\u2588" + CSI +"0m"
相关讨论

我最喜欢的方式是与祝福图书馆(完全披露：我写了它)。例如：

1
2
3
4
5
from blessings import Terminal

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

要打印彩色砖块，最可靠的方法是用背景色打印空间。我用这个技巧画鼻子进步的进度条：

1
print t.on_green(' ')

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

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

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

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

祝福的好处在于它尽最大努力在各种终端上工作，而不仅仅是(绝大多数常见的)ANSI彩色终端。它还将不可读的转义序列保留在代码之外，同时保持简洁以供使用。玩得高兴！

相关讨论

使用for循环生成一个包含所有颜色的类，将颜色的每个组合迭代到100，然后用python颜色编写一个类。按您的意愿复制和粘贴，gplv2由我：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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'

尝试这个简单的代码

1
2
3
4
5
6
7
8
9
10
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")
相关讨论

sty与colorama类似，但它不那么冗长，支持8bit和24位(rgb)颜色，允许您注册自己的颜色，非常灵活并且有良好的文档记录。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from sty import fg, bg, ef, rs, RgbFg

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 new colors:

fg.set_style('orange', RgbFg(255, 150, 50))

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

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

印刷品：

enter image description here

演示：enter image description here

相关讨论

在Windows上，您可以使用模块"win32console"(在某些python发行版中可用)或模块"ctypes"(python 2.5及更高版本)访问win32 api。

要查看支持这两种方式的完整代码，请参阅来自testoob的颜色控制台报告代码。

范例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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)

基于@joeld的答案，这真是太简单了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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)

然后只是

1
2
PrintInColor.red('hello', end=' ')
PrintInColor.green('world')
相关讨论

我已经将@joeld answer包装到一个模块中，该模块具有全局函数，可以在代码中的任何地方使用。

文件：Log.Py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD ="\033[1m"

def disable():
    HEADER = ''
    OKBLUE = ''
    OKGREEN = ''
    WARNING = ''
    FAIL = ''
    ENDC = ''

def infog( msg):
    print OKGREEN + msg + ENDC

def info( msg):
    print OKBLUE + msg + ENDC

def warn( msg):
    print WARNING + msg + ENDC

def err( msg):
    print FAIL + msg + ENDC

用途如下：

1
2
3
 import log
    log.info("Hello World")
    log.err("System Error")

对于Windows，除非使用win32api，否则无法使用颜色打印到控制台。

对于Linux，它与使用print一样简单，这里概述了转义序列：

颜色

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

1
#

基于@joeld answer构建，使用https://pypi.python.org/pypi/lazyme pip install -U lazyme：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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

截图：

enter image description here

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

1
2
3
4
5
6
7
8
>>> 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。

例如。

1
2
3
4
5
6
7
8
9
10
11
12
>>> 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

截图：

enter image description here

您可以使用Curses库的python实现：http://docs.python.org/library/curses.html网站

另外，运行这个，你会发现你的盒子：

1
2
for i in range(255):
    print i, chr(i)
相关讨论

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

1
2
3
4
5
6
7
8
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)
相关讨论

请注意，with关键字与需要重置的修饰符(使用python 3和colorama)的混合程度如何：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from colorama import Fore, Style
import sys

class Highlight:
  def __init__(self, clazz, color):
    self.color = color
    self.clazz = clazz
  def __enter__(self):
    print(self.color, end="")
  def __exit__(self, type, value, traceback):
    if self.clazz == Fore:
      print(Fore.RESET, end="")
    else:
      assert self.clazz == Style
      print(Style.RESET_ALL, end="")
    sys.stdout.flush()

with Highlight(Fore, Fore.GREEN):
  print("this is highlighted")
print("this is not")
相关讨论

您可以使用clint：

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

从Github获取。

相关讨论

如果你正在编程一个游戏，也许你想改变背景色，只使用空格？例如：

1
print""+"\033[01;41m" +"" +"\033[01;46m"  +" " +"\033[01;42m"
相关讨论

asciimatics为构建文本用户界面和动画提供了可移植的支持：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/env python
from asciimatics.effects import RandomNoise  # $ pip install asciimatics
from asciimatics.renderers import SpeechBubble, Rainbow
from asciimatics.scene import Scene
from asciimatics.screen import Screen
from asciimatics.exceptions import ResizeScreenError


def demo(screen):
    render = Rainbow(screen, SpeechBubble('Rainbow'))
    effects = [RandomNoise(screen, signal=render)]
    screen.play([Scene(effects, -1)], stop_on_resize=True)

while True:
    try:
        Screen.wrapper(demo)
        break
    except ResizeScreenError:
        pass

Asciicast：

rainbow-colored text among ascii noise

下面是一个诅咒的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import curses

def main(stdscr):
    stdscr.clear()
    if curses.has_colors():
        for i in xrange(1, curses.COLORS):
            curses.init_pair(i, i, curses.COLOR_BLACK)
            stdscr.addstr("COLOR %d!" % i, curses.color_pair(i))
            stdscr.addstr("BOLD!", curses.color_pair(i) | curses.A_BOLD)
            stdscr.addstr("STANDOUT!", curses.color_pair(i) | curses.A_STANDOUT)
            stdscr.addstr("UNDERLINE!", curses.color_pair(i) | curses.A_UNDERLINE)
            stdscr.addstr("BLINK!", curses.color_pair(i) | curses.A_BLINK)
            stdscr.addstr("DIM!", curses.color_pair(i) | curses.A_DIM)
            stdscr.addstr("REVERSE!", curses.color_pair(i) | curses.A_REVERSE)
    stdscr.refresh()
    stdscr.getch()

if __name__ == '__main__':
    print"init..."
    curses.wrapper(main)
相关讨论

包装python 3打印功能的另一个pypi模块：

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

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

1
2
3
4
5
from __future__ import print_function
from colorprint import *

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

输出"你好，世界！"蓝色的字和感叹号，粗体的红色，闪烁着。

如果你用的是窗户，那就给你！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# display text on a Windows console
# Windows XP with Python27 or Python32
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 ...")
相关讨论

哎呀！另一版本

当我发现这个答案有用时，我做了一些修改。这个Github要点就是结果

使用

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

enter image description here

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

1
print colors.error('sorry, ')

asd

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

https://raw.github.com/fabric/fabric/master/fabric/colors.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
"""
.. versionadded:: 0.9.2

Functions for wrapping strings in ANSI color codes.

Each function within this module returns the input string ``text``, wrapped
with ANSI color codes for the appropriate color.

For example, to print some text as green on supporting terminals::

    from fabric.colors import green

    print(green("This text is green!"))

Because these functions simply return modified strings, you can nest them::

    from fabric.colors import red, green

    print(red("This sentence is red, except for" + \
          green("these words, which are green") +"."))

If ``bold`` is set to ``True``, the ANSI flag for bolding will be flipped on
for that particular invocation, which usually shows up as a bold or brighter
version of the original color on most terminals.
"""


def _wrap_with(code):

    def inner(text, bold=False):
        c = code
        if bold:
            c ="1;%s" % c
        return"\033[%sm%s\033[0m" % (c, text)
    return inner

red = _wrap_with('31')
green = _wrap_with('32')
yellow = _wrap_with('33')
blue = _wrap_with('34')
magenta = _wrap_with('35')
cyan = _wrap_with('36')
white = _wrap_with('37')

如果你在使用Django

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

快照：

image

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

您可以测试它是否安装在您的计算机中： $ python -c"import django; print django.VERSION"要安装它，请检查：如何安装Django

试一试！！

一个更简单的选择是使用来自termcolor包的cprint功能。

color-print-python

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

enter image description here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Pure Python 3.x demo, 256 colors
# Works with bash under Linux

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):
    for col in range(6):
        color = row*6 + col + 4
        if color>=0:
            text ="{:3d}".format(color)
            print (format(text,color), end="")
        else:
            print("  ", end="")

for row in range(-1,42):
    print_six(row, fg)
    print("",end="")
    print_six(row, bg)
    print()

Text with altering foreground and background, colors 0..141Text with altering foreground and background, colors 142..255

我之所以回应，是因为我找到了一种在Windows上使用ANSI代码的方法，这样您就可以在不使用任何模块的情况下更改文本的颜色：

使这项工作起作用的行是os.system('color')，但为了确保在该人不在Windows上时不会引发错误，可以使用以下脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import os, sys

if sys.platform.lower() =="win32":
    os.system('color')

# Group of Different functions for different styles
class style():
    BLACK = lambda x: '\033[30m' + str(x)
    RED = lambda x: '\033[31m' + str(x)
    GREEN = lambda x: '\033[32m' + str(x)
    YELLOW = lambda x: '\033[33m' + str(x)
    BLUE = lambda x: '\033[34m' + str(x)
    MAGENTA = lambda x: '\033[35m' + str(x)
    CYAN = lambda x: '\033[36m' + str(x)
    WHITE = lambda x: '\033[37m' + str(x)
    UNDERLINE = lambda x: '\033[4m' + str(x)
    RESET = lambda x: '\033[0m' + str(x)

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

python版本：3.6.7(32位)

对于角色

您的终端很可能使用Unicode(通常是UTF-8编码的)字符，所以只有适当的字体选择才能看到您最喜欢的字符。Unicode字符U+2588，"完整块"是我建议您使用的。

尝试以下操作：

1
2
3
4
5
6
7
8
9
import unicodedata
fp= open("character_list","w")
for index in xrange(65536):
    char= unichr(index)
    try: its_name= unicodedata.name(char)
    except ValueError: its_name="N/A"
    fp.write("%05d %04x %s %s
" % (index, index, char.encode("UTF-8"), its_name)
fp.close()

稍后使用您最喜欢的查看器检查该文件。

为了颜色

诅咒是你想要使用的模块。查看本教程。

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

网址：https://github.com/robpol86/colorclass

example on Windows cmd.exe

我写了一个简单的模块，可在：http://pypi.python.org/pypi/colorconsole

它适用于Windows、Mac OS X和Linux。它对Linux和Mac使用ANSI，但对Windows上的控制台函数使用本机调用。您有颜色、光标定位和键盘输入。它不是诅咒的替代品，但如果需要在简单的脚本或ASCII游戏中使用，它会非常有用。

使用PyFancy这是一种在终端中进行着色的简单方法！

例子：

1
print(pyfancy.RED +"Hello Red" + pyfancy.END)
相关讨论

您可以使用shell转义符，这可以从任何语言中获得。这些转义符以esc字符开头，后跟一些参数。

例如，要在终端中输出一个红色的Hello world字符串：

1
echo"\e[31m Hello world \e[0m"

或者从python脚本：

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

另外，我还写了一篇关于转义序列的文章，它可能会帮助您更好地理解这种机制。我希望它能帮助你。

相关讨论

我的2分(Pycoloterm)：

安装：

1
2
sudo apt-get install python-pip
pip install pycolorterm

Python脚本：

1
2
3
4
from pycolorterm import pycolorterm

with pycolorterm.pretty_output(pycolorterm.FG_GREEN) as out:
    out.write('Works OK!')

"工作还行！"用绿色显示。

为了解决这个问题，我创建了一个非常简单的包来打印带有内插颜色代码的字符串，称为iColor。

iColor包括两个函数：cformat和cprint，每个函数都接受一个字符串，其中包含插入以映射到ansi转义序列的子字符串，例如。

1
2
3
4
from icolor import cformat # there is also cprint

cformat("This is #RED;a red string, partially with a #xBLUE;blue background")
'This is \x1b[31ma red string, partially with a \x1b[44mblue background\x1b[0m'

包括所有的ANSI颜色(如#RED;、#BLUE;等)，以及#RESET;、#BOLD;等。

背景色有一个x前缀，所以绿色背景将是#xGREEN;。

可以用##逃出#。

考虑到它的简单性，最好的文档可能就是代码本身。

它在Pypi上，所以我们可以使用cx1(10)。

我不懂python，每次我发现像这样的主题，我都很兴奋。但这次(突然)我觉得我有话要说。特别是因为几分钟前我在Python中发现了一个令人惊叹的东西(至少现在对我来说是这样)：

上下文管理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

例子

或者像这样：

1
2
3
4
5
6
7
8
9
10
#   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')