当前位置:  开发笔记 > 编程语言 > 正文

在终端上打印颜色?

如何解决《在终端上打印颜色?》经验,为你挑选了31个好方法。

如何在Python中将彩色文本输出到终端?表示实体块的最佳Unicode符号是什么?



1> joeld..:

这在某种程度上取决于您所处的平台.最常见的方法是打印ANSI转义序列.举一个简单的例子,这里有一些来自blender构建脚本的 python代码:

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'

要使用这样的代码,你可以做类似的事情

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

这将适用于包括OS X,Linux和Windows的unix(如果您使用ANSICON,或者在Windows 10中,只要您启用VT100仿真).有ansi代码用于设置颜色,移动光标等.

如果你要复杂化这个(如果你正在编写一个游戏,听起来就是这样),你应该查看"curses"模块,它可以为你处理很多复杂的部分.在Python的诅咒HOWTO是一个很好的介绍.

如果你没有使用扩展的ASCII(即不在PC上),那么你会遇到127以下的ascii字符,而'#'或'@'可能是你阻止的最佳选择.如果您可以确保您的终端使用IBM 扩展的ascii字符集,那么您还有更多选择.字符176,177,178和219是"块字符".

一些现代的基于文本的程序,如"矮人要塞",在图形模式下模拟文本模式,并使用经典PC字体的图像.您可以在Dwarf Fortress Wiki上找到一些可以使用的位图(用户自制的tilesets).

在文本模式设计大赛已在文本模式下做图形更多的资源.

嗯......我觉得这个答案有点过分了.不过,我正在计划一个史诗般的基于文本的冒险游戏.祝你的彩色文字好运!


注意:你也可以添加`BOLD ="\ 033 [1m"`如果你想要粗体文字(对标题有用).
什么是'残疾人'用于?
在Linux上,您可能希望使用`tput`,[like so](https://gist.github.com/4007035),因为它会产生更多可移植代码.
@Cawas在我看来它是用于禁用使用特定`bcolors`实例打印的所有颜色的着色.例如,您可以创建一个`bcolors`实例,然后使用实例的成员变量打印出您的着色字符,但是如果您决定不再需要着色,则可以在打印出字符之前调用`disable`.他们只会打印出空字符串.
@Cawas:`disable`的一个真实用例是当你将输出传递给一个文件时; 虽然像`cat`这样的工具可能支持颜色,但通常最好不要将颜色信息打印到文件中.

2> Samat Jain..:

我很惊讶没人提到Python termcolor模块.用法非常简单:

from termcolor import colored

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

或者在Python 3中:

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

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


刚刚注意到截至2011年1月13日,它现在已经获得MIT许可
在Windows上首先运行`os.system('color')`,然后ANSI转义序列开始工作.
没有单元测试(与colorama不同),自2011年以来没有更新
由于它发出ANSI代码,如果加载ansi.sys,它是否适用于Windows(DOS控制台)?http://support.microsoft.com/kb/101875
`termcolor.COLORS`为您提供颜色列表
@Szabolcs您应该在Windows 10新终端上发现不需要它,它本身就支持它们。

3> priestc..:

答案是Colorama用于Python中的所有跨平台着色.

Python 3.6示例截图: 示例截图


作为Colorama的作者,感谢提及@ nbv4.我将尝试澄清一点:Colorama旨在让Python程序在所有平台上打印彩色终端文本,使用与本页上许多其他答案中描述的相同的ANSI代码.在Windows上,Colorama从stdout中剥离这些ANSI字符,并将它们转换为等效的win32调用彩色文本.在其他平台上,Colorama什么都不做.因此,您可以使用ANSI代码或类似Termcolor的模块,而使用Colorama,它们只能在所有平台上运行.无论如何,这个想法.
这应该在标准库中...我认为跨平台颜色支持很重要.
如果不调用colorama.init(),这将不起作用.投票!
Colorama很棒!另请参阅[ansimarkup](https://github.com/gvalkov/python-ansimarkup),它建立在colorama上,允许您使用简单的基于标签的标记(例如`粗体`)用于为终端文本添加样式
@Jonathan,这真是一个很棒的图书馆!跨平台颜色Python输出的能力真的非常好用.我正在为一个为自己的控制台着色的库提供工具.我可以将该控制台的输出重定向到终端并着色输出.现在我甚至可以上一个库并让用户选择颜色.这将允许色盲人员设置工作,以便他们能够正确地看到输出.谢谢

4> rabin utam..:

打印一个字符串,开始一个颜色/样式,然后打印字符串,然后结束颜色/样式更改'\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,足以满足大多数应用程序的要求
请问,哪个终端是这个?
它有多便携?
简短的独立实施:https://gist.github.com/Sheljohn/68ca3be74139f66dbc6127784f638920

5> qubodup..:

定义一个开始颜色的字符串和一个结束颜色的字符串,然后使用前面的起始字符串和结尾处的结束字符串打印文本.

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

这产生以下内容bash,urxvt采用Zenburn风格的配色方案:

输出颜色

通过预防,我们可以获得更多颜色:

颜色矩阵

注意:\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


闪烁的文本确实非常好。但是我该如何停止呢?由于某些原因,所有连续打印均闪烁。我的终端认为是聚会时间!
在要闪烁的字符串的末尾,将\ 33 [0m`或CEND置于上方。

6> Bryan Oakley..:

您想了解ANSI转义序列.这是一个简短的例子:

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

有关详细信息,请参阅http://en.wikipedia.org/wiki/ANSI_escape_code

对于块字符,请尝试像\ u2588这样的unicode字符:

print(u"\u2588")

把它们放在一起:

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


尝试`def d(*v):return'\ x1B ['+';'.join(map(str,v))+'m'`然后`print''.join([d(k,i)+ str(i%10)+ d(0)for i在范围(30,38)+范围(40,48)中k为范围(2)])

7> 小智..:

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

from blessings import Terminal

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

要打印彩色砖块,最可靠的方法是打印带有背景颜色的空间.我使用这种技术在nose-progressive中绘制进度条:

print t.on_green(' ')

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

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)

祝福Blessings的好处是它尽力在各种终端上工作,而不仅仅是(绝大多数)ANSI颜色的终端.它还保留了代码中不可读的转义序列,同时保持简洁易用.玩得开心!


将颜色作为函数名称而不是参数是一个值得怀疑的做法.
@progo你可以做到的事实并不意味着你应该这样做.如果颜色是您可以传递的参数,则更通用.
您可以通过python函数。

8> 小智..:

使用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'



9> Rotareti..:

sty类似于colorama,但它不那么冗长,支持8bit和24bit(rgb)颜色,允许您注册自己的颜色,非常灵活且记录良好.

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,如果它更受欢迎会很棒.谢谢!

10> dayitv89..:

试试这个简单的代码

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,而不是直接打印它们,以便它可以与其他字符串一起使用.

11> orip..:

在Windows上,您可以使用模块'win32console'(在某些Python发行版中提供)或模块'ctypes'(Python 2.5及更高版本)来访问Win32 API.

要查看支持的方式完整代码,请参见色控制台报告代码从Testoob.

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)



12> SimpleBinary..:

我之所以做出回应,是因为我找到了一种在Windows上使用ANSI代码的方法,这样您就可以更改文本的颜色而无需任何内置模块:

进行此操作的行是os.system('color'),但是要确保如果此人不在Windows上,则不会引起错误,您可以使用以下脚本:

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



13> zahanm..:

根据@ joeld的回答,愚蠢的简单

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


如果您传递多个位置参数或字符串类型以外的其他参数,则会崩溃

14> Mohamed Samy..:

我已经将@joeld的答案包装到一个具有全局函数的模块中,我可以在代码中的任何地方使用它.

file:log.py

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

用法如下:

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



15> UberJumper..:

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

对于Linux来说,它就像使用print一样简单,其中包含了转义序列:

颜色

对于像盒子一样打印的字符,它实际上取决于您用于控制台窗口的字体.英镑符号效果很好,但它取决于字体:

#



16> Ben174..:

我最终做到了这一点,我觉得它最干净:

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)



17> alvas..:

建立在@joeld的答案上,使用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> Giacomo Laca..:

你可以使用CLINT:

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

从GitHub获取它.



19> Janus Troels..:

注意with关键字与需要重置的修饰符(使用Python 3和Colorama)的混合程度如何:

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



20> daharon..:

您可以使用curses库的Python实现:http: //docs.python.org/library/curses.html

此外,运行此,你会找到你的盒子:

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



21> Andriy Makuk..:
# 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))

改变前景和背景的文本,颜色0..141 文本与改变前景和背景,颜色142..255



22> 小智..:

如果您正在编写游戏,或许您想要更改背景颜色并仅使用空格?例如:

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



23> Navweb..:

如果你使用的是Windows,那么就去吧!

# 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 ... ")



24> Vishal..:

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

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



25> jfs..:

asciimatics为构建文本UI和动画提供了便携式支持:

#!/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:

ascii噪音中的彩虹色文字



26> kmario23..:

一个更简单的选择是使用包中的cprint功能termcolor.

彩色打印蟒蛇

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

在此输入图像描述



27> nosklo..:

这是一个curses示例:

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)



28> Jossef Harus..:

好极了!另一个版本

虽然我觉得这个答案很有用,但我修改了一下.这个Github Gist就是结果

用法

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

在此输入图像描述

此外,你可以包装常见的用法:

print colors.error('sorry, ')

ASD

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



29> drevicko..:

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

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

如果你也可以在python 2.x中使用它from __future__ import print.这是模块pypi页面中的python 2示例:

from __future__ import print_function
from colorprint import *

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

输出"Hello,world!" 用蓝色的字和感叹号大胆的红色和闪烁.



30> Grijesh Chau..:

如果你使用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"
要安装它,请检查:如何安装Django

试试看!!



31> Vishal..:
def black(text):
    print('\033[30m', text, '\033[0m', sep='')

def red(text):
    print('\033[31m', text, '\033[0m', sep='')

def green(text):
    print('\033[32m', text, '\033[0m', sep='')

def yellow(text):
    print('\033[33m', text, '\033[0m', sep='')

def blue(text):
    print('\033[34m', text, '\033[0m', sep='')

def magenta(text):
    print('\033[35m', text, '\033[0m', sep='')

def cyan(text):
    print('\033[36m', text, '\033[0m', sep='')

def gray(text):
    print('\033[90m', text, '\033[0m', sep='')


black("BLACK")
red("RED")
green("GREEN")
yellow("YELLOW")
blue("BLACK")
magenta("MAGENTA")
cyan("CYAN")
gray("GRAY")

在线尝试

推荐阅读
贴进你的心聆听你的世界
这个屌丝很懒,什么也没留下!
DevBox开发工具箱 | 专业的在线开发工具网站    京公网安备 11010802040832号  |  京ICP备19059560号-6
Copyright © 1998 - 2020 DevBox.CN. All Rights Reserved devBox.cn 开发工具箱 版权所有