Python'da terminale renkli metin nasıl verebilirim? Katı bir bloğu temsil eden en iyi Unicode sembolü nedir?

Bu, hangi platformda olduğunuza bağlıdır. Bunu yapmanın en yaygın yolu ANSI kaçış dizileri basmaktır. Basit bir örnek için, blender oluşturma komut dosyalarından bazı python kodları :

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'

Bunun gibi bir kod kullanmak için böyle bir şey yapabilirsiniz

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

veya Python3.6 + ile:

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

Bu, OS X, linux ve pencereler ( ANSICON kullanmanız koşuluyla veya VT100 öykünmesini etkinleştirmeniz koşuluyla Windows 10'da) gibi unix'lerde çalışır . Rengi ayarlamak, imleci hareket ettirmek ve daha fazlası için ansi kodları vardır.

Bununla karmaşıklaşacaksanız (ve eğer bir oyun yazıyorsanız, kulağa hoş geliyorsa), bunun sizin için çok karmaşık kısımlarını işleyen "curses" modülüne bakmalısınız. Python Lanetler NASIL'ı iyi bir giriştir.

Genişletilmiş ASCII kullanmıyorsanız (yani bir PC'de değil), 127'nin altında ascii karakterlerle sıkışmışsınızdır ve '#' veya '@' muhtemelen bir blok için en iyi bahistir. Terminalinizin IBM genişletilmiş ascii karakter kümesi kullandığından emin olabilirseniz , daha birçok seçeneğiniz vardır. 176, 177, 178 ve 219 karakterleri "blok karakterlerdir".

"Cüce Kalesi" gibi bazı modern metin tabanlı programlar, grafik modda metin modunu taklit eder ve klasik PC yazı tipinin görüntülerini kullanır. Cüce Kalesi Wiki'de kullanabileceğiniz bu bitmap'lerden bazılarını bulabilirsiniz ( kullanıcı tarafından yapılan döşemeler ).

Metin Modu Demo Yarışma metin modunda grafik yapımı için daha fazla kaynak vardır.

Hmm .. Bence bu cevap biraz taşındı. Yine de destansı bir metin tabanlı macera oyunu planlamanın ortasındayım. Renkli metninizde iyi şanslar!

Kimsenin Python termcolor modülünden bahsetmediğine şaşırdım . Kullanımı oldukça basit:

from termcolor import colored

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

Veya Python 3'te:

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

Ancak, oyun programlaması ve yapmak istediğiniz "renkli bloklar" için yeterince karmaşık olmayabilir ...

Cevap Python'daki tüm platformlar arası renklendirme için Colorama .

A Python 3.6 örnek ekran görüntüsü:

Bir renk / stil başlatan bir dize, ardından dize yazdırın ve ardından renk / stil değişikliğini şu şekilde bitirin '\x1b[0m':

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

Kabuk metni için aşağıdaki kodla bir biçim seçenekleri tablosu alın:

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

Işık-karanlık örneği (tam)

Işıkta karanlık örneği (kısmi)

Bir rengi başlatan bir dize ve rengi biten bir dize tanımlayın, ardından metninizi önde başlangıç ​​dizesi ve sonunda bitiş dizesi ile yazdırın.

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

Bu içinde aşağıdakileri üretir bashiçinde, urxvtbir Zenburn tarzı renk düzeni ile:

Deneyler yoluyla daha fazla renk elde edebiliriz:

Not: \33[5mve \33[6myanıp sönüyor.

Bu şekilde tam renkli bir koleksiyon oluşturabiliriz:

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'

Testi oluşturmak için kod:

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 kaçış dizileri hakkında bilgi edinmek istiyorsunuz. Kısa bir örnek:

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

Daha fazla bilgi için bkz. Http://en.wikipedia.org/wiki/ANSI_escape_code

Bir blok karakteri için \ u2588 gibi bir unicode karakteri deneyin:

print(u"\u2588")

Hepsini bir araya koy:

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

Windows 10'da ANSI kodlarını kullanmanın bir yolunu bulduğum için yanıt veriyorum, böylece yerleşik olmayan herhangi bir modül olmadan metnin rengini değiştirebilirsiniz:

Bu işi yapan hat os.system("")veya Terminalde ANSI kodlarını yazdırmanıza izin veren başka bir sistem çağrısıdır:

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

Not: Bu, diğer Windows seçenekleriyle aynı seçenekleri sunmasına rağmen, Windows bu hile ile bile ANSI kodlarını tam olarak desteklemez. Tüm metin dekorasyon renkleri çalışmaz ve tüm 'parlak' renkler (90-97 ve 100-107 Kodları) normal renklerle aynı görüntüler (30-37 ve 40-47 Kodları)

Edit : Daha kısa bir yöntem bulmak için @jl sayesinde.

tl; dr : os.system("")Dosyanızın üst kısmına ekleyin.

Python Sürümü: 3.6.7

En sevdiğim yol Blessings kütüphanesi ile (tam açıklama: yazdım). Örneğin:

from blessings import Terminal

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

Renkli tuğlaları yazdırmanın en güvenilir yolu, arka plan renkleri olan boşluklar yazdırmaktır. Bu tekniği burun ilerlemeli ilerleme çubuğunu çizmek için kullanıyorum :

print t.on_green(' ')

Belirli konumlara da yazdırabilirsiniz:

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

Oyun sırasında diğer terminal yetenekleriyle uğraşmak zorunda kalırsanız, bunu da yapabilirsiniz. Okunabilir olmasını sağlamak için Python'un standart dize biçimlendirmesini kullanabilirsiniz:

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

Blessings ile ilgili güzel olan şey, sadece (ezici derecede yaygın olan) ANSI renkli olanlar üzerinde değil, her türlü terminalde çalışmak için elinden geleni yapmasıdır. Ayrıca, okunamayan kaçış dizilerini kodunuzdan uzak tutarken kullanımı özlü kalır. İyi eğlenceler!

arpacık kolorama benzer, ancak daha az ayrıntılı, 8bit ve 24bit (rgb) renkleri destekler, kendi stillerinizi kaydetmenizi sağlar, muting'i destekler, gerçekten esnek, iyi belgelenmiş ve daha fazlası.

Örnekler:

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

baskılar:

Demo:

100'e kadar her renk kombinasyonunu yinelemek için bir for döngüsü kullanarak tüm renklerle bir sınıf oluşturduktan sonra python renkleriyle bir sınıf yazdı. GPLv2'yi istediğiniz gibi kopyalayıp yapıştırın:

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'

Bu basit kodu deneyin

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'ta Win32 API'ya erişmek için 'win32console' modülünü (bazı Python dağıtımlarında bulunur) veya 'ctypes' modülünü (Python 2.5 ve üstü) kullanabilirsiniz.

Destekleri her iki yönde, gördükleri tam kodunu görmek için renk konsol kodu raporlama dan Testoob .

ctypes örneği:

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'in cevabına dayanarak aptalca basit

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)

O zaman sadece

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

Kodumun herhangi bir yerinde kullanabileceğim global işlevlere sahip bir modüle @joeld cevabını tamamladım.

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

aşağıdaki gibi kullanın:

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

Windows için win32api'yi kullanmadığınız sürece renkler ile konsola yazdıramazsınız.

Linux için, burada belirtilen kaçış dizileriyle baskı kullanmak kadar basit:

Renkler

Karakterin kutu gibi yazdırılması, konsol penceresi için hangi yazı tipini kullandığınıza bağlıdır. Pound simgesi iyi çalışıyor, ancak yazı tipine bağlı:

#

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

Bunu yaptım, en temiz olduğunu hissettim:

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)

, @Joeld cevabına Bina kullanarak 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

Ekran görüntüsü:

color_printYeni biçimlendiricilerle yapılan bazı güncellemeler , örneğin:

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

Not: italic, fast blinkingve strikethroughtüm terminaller çalışmayabilir, Mac / Ubuntu üzerinde çalışma yapmaz.

Örneğin

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

Ekran görüntüsü:

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

Çevrimiçi deneyin

withanahtar kelimenin sıfırlanması gereken bu gibi değiştiricilerle ne kadar iyi karıştığına dikkat edin (Python 3 ve Colorama kullanılarak):

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

Lanetler kütüphanesinin Python uygulamasını kullanabilirsiniz: http://docs.python.org/library/curses.html

Ayrıca, bunu çalıştırın ve kutunuzu bulacaksınız:

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

CLINT'i kullanabilirsiniz:

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

GitHub'dan alın .

Geç kaldığımı biliyorum. Ama ColorIt adında bir kütüphanem var . Süper basit.

İşte bazı örnekler:

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

Bu size şunları sağlar:

Bunun çapraz platform olduğunu ve mac, linux ve pencerelerde test edildiğini de belirtmek gerekir.

Denemek isteyebilirsiniz: https://github.com/CodeForeverAndEver/ColorIt

Not: Birkaç gün içinde yanıp sönme, italik, kalın vb. Eklenecektir.

Bir oyunu programlıyorsanız, arka plan rengini değiştirmek ve yalnızca boşluk kullanmak istersiniz? Örneğin:

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

Windows kullanıyorsanız, işte başlıyoruz!

# 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 kullanıyorsanız

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

enstantane fotoğraf:

(Runserver terminalinde hata ayıklamak için genellikle renkli çıktı kullanıyorum, bu yüzden ekledim.)

_{Makinenize kurulup kurulmadığını test edebilirsiniz:
$ python -c "import django; print django.VERSION"
Kurmak için kontrol edin: Django nasıl kurulur}

Bir şans ver!!

İşte bir lanet örneği:

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 , metin kullanıcı arayüzü ve animasyonlar oluşturmak için taşınabilir bir destek sağlar:

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

Python 3 yazdırma işlevini tamamlayan başka bir pypi modülü:

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

Ayrıca python 2.x sürümünde de kullanılabilir from __future__ import print. Modüller pypi sayfasından bir python 2 örneği:

from __future__ import print_function
from colorprint import *

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

"Merhaba dünya!" mavi kelimelerle ve ünlem işareti koyu kırmızı ve yanıp sönüyor.