파이썬에서 어떻게 컬러 텍스트를 터미널에 출력 할 수 있습니까? 솔리드 블록을 나타내는 최고의 유니 코드 기호는 무엇입니까?

이것은 어느 플랫폼에 있는지에 따라 다릅니다. 이를 수행하는 가장 일반적인 방법은 ANSI 이스케이프 시퀀스를 인쇄하는 것입니다. 간단한 예를 들어, 다음은 블렌더 빌드 스크립트 의 파이썬 코드입니다 .

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)

또는 Python3.6 +를 사용하는 경우 :

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

이것은 OS X, linux 및 windows를 포함한 유닉스에서 작동합니다 ( ANSICON 을 사용 하거나 Windows 10에서 VT100 에뮬레이션 을 활성화 한 경우 ). 색상 설정, 커서 이동 등을위한 ansi 코드가 있습니다.

이것으로 복잡해질 것이라면 (그리고 게임을 작성하는 것처럼 들린다) "저주"모듈을 살펴보아야합니다.이 모듈은 많은 복잡한 부분을 처리합니다. 파이썬 저주 HOWTO는 좋은 소개합니다.

확장 ASCII를 사용하지 않는 경우 (예 : PC가 아닌 경우) 127 미만의 ASCII 문자가 표시되며 '#'또는 '@'이 블록에 가장 적합합니다. 터미널이 IBM 확장 ASCII 문자 세트를 사용하고 있는지 확인할 수 있으면 더 많은 옵션이 있습니다. 문자 176, 177, 178 및 219는 "블록 문자"입니다.

"Dwarf Fortress"와 같은 일부 최신 텍스트 기반 프로그램은 그래픽 모드에서 텍스트 모드를 에뮬레이트하고 클래식 PC 글꼴의 이미지를 사용합니다. Dwarf Fortress Wiki 에서 사용할 수있는 비트 맵 중 일부를 볼 수 있습니다 ( 사용자 제작 타일셋 ).

텍스트 모드 데모 콘테스트 텍스트 모드에서 그래픽 작업을 수행하기위한 더 많은 자원을 가지고있다.

흠 .. 나는이 대답에 약간의 영향을 미쳤다고 생각한다. 하지만 서사적 인 텍스트 기반 어드벤처 게임을 계획하고 있습니다. 컬러 텍스트로 행운을 빕니다!

아무도 파이썬 termcolor 모듈을 언급하지 않은 것에 놀랐습니다 . 사용법은 매우 간단합니다.

from termcolor import colored

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

또는 파이썬 3에서 :

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

그러나 게임 프로그래밍 및 "컬러 블록"에 대해서는 충분히 정교하지 않을 수 있습니다 ...

대답은 Python의 모든 크로스 플랫폼 색상에 대한 Colorama 입니다.

Python 3.6 예제 스크린 샷 :

색상 / 스타일을 시작하는 문자열을 인쇄 한 다음 문자열을 인쇄 한 다음 색상 / 스타일 변경을 종료합니다 '\x1b[0m'.

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

다음 코드를 사용하여 쉘 텍스트의 형식 옵션 표를 가져옵니다.

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

밝고 어두운 예 (완료)

어두운 조명 예 (일부)

색상으로 시작하는 문자열과 색상으로 끝나는 문자열을 정의한 다음 앞에 시작 문자열과 끝 문자열을 사용하여 텍스트를 인쇄하십시오.

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

이에 다음을 생산 bash에, urxvtZenburn 스타일의 색 구성표 :

실험을 통해 더 많은 색상을 얻을 수 있습니다.

참고 : \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

ANSI 이스케이프 시퀀스에 대해 배우고 싶습니다. 다음은 간단한 예입니다.

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

자세한 내용은 http://en.wikipedia.org/wiki/ANSI_escape_code를 참조하십시오 .

블록 문자의 경우 \ u2588과 같은 유니 코드 문자를 사용해보십시오.

print(u"\u2588")

함께 모아서:

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

Windows 10에서 ANSI 코드를 사용하는 방법을 찾았으므로 내장되지 않은 모듈없이 텍스트 색상을 변경할 수 있기 때문에 응답합니다.

이 작업을 수행하는 행 os.system("")은 터미널 또는 ANSI 시스템 코드를 인쇄 할 수있는 다른 시스템 호출입니다.

import os

os.system("")

# Group of Different functions for 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 코드를 완전히 지원하지는 않습니다. 모든 텍스트 장식 색상이 작동하는 것은 아니며 모든 '밝은'색상 (코드 90-97 및 100-107)은 일반 색상 (코드 30-37 및 40-47)과 동일하게 표시됩니다.

편집 : 더 짧은 방법을 찾은 @jl에게 감사드립니다.

tl; dr : os.system("")파일 상단 근처에 추가 하십시오.

파이썬 버전 : 3.6.7

내가 가장 좋아하는 방법은 Blessings 라이브러리 (전체 공개 : 내가 쓴 것)입니다. 예를 들면 다음과 같습니다.

from blessings import Terminal

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

컬러 벽돌을 인쇄하려면 가장 안정적인 방법은 배경색으로 공간을 인쇄하는 것입니다. 나는에서 진행 표시 줄 그릴이 기술을 사용하여 코 진보를 :

print t.on_green(' ')

특정 위치에서도 인쇄 할 수 있습니다.

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

게임 도중 다른 터미널 기능을 사용해야하는 경우에도 그렇게 할 수 있습니다. 파이썬의 표준 문자열 형식을 사용하여 읽을 수 있도록 유지할 수 있습니다.

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

축복에 대한 좋은 점은 (압도적으로 일반적인) ANSI 색상뿐만 아니라 모든 종류의 터미널에서 작동하는 것이 최선이라는 것입니다. 또한 코드에서 읽을 수없는 이스케이프 시퀀스를 간결하게 사용하면서 간결하게 유지합니다. 즐기세요!

sty 는 colorama와 유사하지만 덜 장황하고 8 비트 및 24 비트 (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')

인쇄물:

데모:

for 루프를 사용하여 모든 색상으로 클래스를 생성하여 모든 색상 조합을 최대 100까지 반복 한 다음 파이썬 색상으로 클래스를 작성했습니다. 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'

이 간단한 코드를 사용해보십시오

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

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)

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

@joeld 답변을 코드의 어느 곳에서나 사용할 수있는 전역 함수가있는 모듈로 래핑했습니다.

파일 : 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")

Windows의 경우 win32api를 사용하지 않으면 색상으로 콘솔에 인쇄 할 수 없습니다.

Linux의 경우 다음과 같이 이스케이프 시퀀스를 사용하여 print를 사용하는 것만 큼 간단합니다.

그림 물감

문자를 상자처럼 인쇄하려면 실제로 콘솔 창에 사용하는 글꼴에 따라 다릅니다. 파운드 기호는 잘 작동하지만 글꼴에 따라 다릅니다.

#

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

나는 이것을 끝내고 그것이 가장 깨끗하다고 ​​느꼈다.

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)

https://pypi.python.org/pypi/lazyme 사용하여 @joeld 답변을 기반으로 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모든 단말기에서 작동하지 않을 수 있습니다 맥 / 우분투에서 작동하지 않습니다.

예 :

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

스크린 샷 :

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

온라인으로 시도

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

curses 라이브러리의 Python 구현을 사용할 수 있습니다. http://docs.python.org/library/curses.html

또한 이것을 실행하면 상자가 나타납니다.

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

CLINT를 사용할 수 있습니다.

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

GitHub에서 가져옵니다 .

나는 늦었다는 것을 안다. 그러나 ColorIt이라는 라이브러리가 있습니다 . 매우 간단합니다.

여기 몇 가지 예가 있어요.

from ColorIt import *

# Use this to ensure that ColorIt will be usable by certain command line interfaces
initColorIt()

# Foreground
print (color ('This text is red', colors.RED))
print (color ('This text is orange', colors.ORANGE))
print (color ('This text is yellow', colors.YELLOW))
print (color ('This text is green', colors.GREEN))
print (color ('This text is blue', colors.BLUE))
print (color ('This text is purple', colors.PURPLE))
print (color ('This text is white', colors.WHITE))

# Background
print (background ('This text has a background that is red', colors.RED))
print (background ('This text has a background that is orange', colors.ORANGE))
print (background ('This text has a background that is yellow', colors.YELLOW))
print (background ('This text has a background that is green', colors.GREEN))
print (background ('This text has a background that is blue', colors.BLUE))
print (background ('This text has a background that is purple', colors.PURPLE))
print (background ('This text has a background that is white', colors.WHITE))

# Custom
print (color ("This color has a custom grey text color", (150, 150, 150))
print (background ("This color has a custom grey background", (150, 150, 150))

# Combination
print (background (color ("This text is blue with a white background", colors.BLUE), colors.WHITE))

이것은 당신에게 제공합니다 :

또한 이것이 크로스 플랫폼이며 mac, linux 및 windows에서 테스트되었다는 점에 주목할 가치가 있습니다.

https://github.com/CodeForeverAndEver/ColorIt 을 사용해보십시오.

참고 : 깜박임, 이탤릭체, 굵게 등은 며칠 후에 추가됩니다.

게임을 프로그래밍하는 경우 배경색을 변경하고 공백 만 사용 하시겠습니까? 예를 들면 다음과 같습니다.

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

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

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 설치 방법}

시도 해봐!!

여기 저주가 있습니다 :

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)

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

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

아스키 캐스트 :

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!"출력 파란색으로 된 단어와 느낌표가 굵은 빨간색으로 깜박입니다.