Bagaimana saya bisa menampilkan teks berwarna ke terminal, dengan Python? Apa simbol Unicode terbaik untuk mewakili blok padat?

Ini agak tergantung pada platform apa Anda berada. Cara paling umum untuk melakukan ini adalah dengan mencetak urutan pelarian ANSI. Sebagai contoh sederhana, inilah beberapa kode python dari skrip pembuat blender :

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'

Untuk menggunakan kode seperti ini, Anda dapat melakukan sesuatu seperti

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

atau, dengan Python3.6 +:

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

Ini akan bekerja pada unix termasuk OS X, linux dan windows (asalkan Anda menggunakan ANSICON , atau di Windows 10 asalkan Anda mengaktifkan emulasi VT100 ). Ada kode ansi untuk mengatur warna, memindahkan kursor, dan banyak lagi.

Jika Anda akan menjadi rumit dengan ini (dan sepertinya Anda adalah jika Anda sedang menulis permainan), Anda harus melihat ke dalam modul "kutukan", yang menangani banyak bagian rumit dari ini untuk Anda. The Python Kutukan HowTO adalah pengenalan yang baik.

Jika Anda tidak menggunakan ASCII yang diperluas (yaitu tidak pada PC), Anda terjebak dengan karakter ascii di bawah 127, dan '#' atau '@' mungkin merupakan taruhan terbaik Anda untuk satu blok. Jika Anda dapat memastikan terminal Anda menggunakan rangkaian karakter ascii IBM yang diperluas , Anda memiliki banyak opsi lagi. Karakter 176, 177, 178 dan 219 adalah "karakter blok".

Beberapa program berbasis teks modern, seperti "Dwarf Fortress", meniru mode teks dalam mode grafis, dan menggunakan gambar font PC klasik. Anda dapat menemukan beberapa dari bitmap ini yang dapat Anda gunakan pada Wiki Dwarf Fortress see ( tilesets buatan pengguna ).

The Text Mode Demo Contest memiliki lebih banyak sumber daya untuk melakukan grafis dalam modus teks.

Hmm .. Saya pikir agak terbawa dengan jawaban ini. Namun, saya sedang merencanakan permainan petualangan berbasis teks epik. Semoga berhasil dengan teks berwarna Anda!

Saya terkejut tidak ada yang menyebutkan modul termcolor Python . Penggunaannya cukup sederhana:

from termcolor import colored

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

Atau dengan Python 3:

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

Namun, itu mungkin tidak cukup canggih untuk pemrograman game dan "blok berwarna" yang ingin Anda lakukan ...

Jawabannya adalah Colorama untuk semua pewarnaan lintas-platform dengan Python.

Screenshot contoh Python 3.6:

Cetak string yang memulai warna / gaya, kemudian string, lalu akhiri perubahan warna / gaya dengan '\x1b[0m':

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

Dapatkan tabel opsi format untuk teks shell dengan kode berikut:

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

Contoh terang-gelap (lengkap)

Contoh gelap-terang (sebagian)

Tentukan string yang memulai warna dan string yang mengakhiri warna, lalu cetak teks Anda dengan string awal di depan dan string akhir di akhir.

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

Ini menghasilkan berikut bash, dalam urxvtdengan skema warna gaya Zenburn:

Melalui eksperimen, kita bisa mendapatkan lebih banyak warna:

Catatan: \33[5mdan\33[6m berkedip.

Dengan cara ini kita dapat membuat koleksi warna penuh:

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'

Berikut adalah kode untuk menghasilkan tes:

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

Anda ingin belajar tentang urutan pelarian ANSI. Berikut ini contoh singkatnya:

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

Untuk info lebih lanjut lihat http://en.wikipedia.org/wiki/ANSI_escape_code

Untuk karakter blok, coba karakter unicode seperti \ u2588:

print(u"\u2588")

Menyatukan semuanya:

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

Saya merespons karena saya menemukan cara untuk menggunakan kode ANSI pada Windows 10, sehingga Anda dapat mengubah warna teks tanpa modul apa pun yang tidak ada di dalamnya:

Garis yang membuat pekerjaan ini adalah os.system(""), atau panggilan sistem lainnya, yang memungkinkan Anda untuk mencetak kode ANSI di Terminal:

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

Catatan: Meskipun ini memberikan opsi yang sama dengan opsi Windows lainnya, Windows tidak mendukung penuh kode ANSI, bahkan dengan trik ini. Tidak semua warna dekorasi teks berfungsi dan semua warna 'cerah' (Kode 90-97 dan 100-107) ditampilkan sama dengan warna biasa (Kode 30-37 dan 40-47)

Sunting : Terima kasih kepada @jl untuk menemukan metode yang lebih pendek.

tl; dr : Tambahkan di os.system("")dekat bagian atas file Anda.

Versi Python: 3.6.7

Cara favorit saya adalah dengan perpustakaan Blessings (pengungkapan penuh: saya menulisnya). Sebagai contoh:

from blessings import Terminal

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

Untuk mencetak bata berwarna, cara yang paling dapat diandalkan adalah dengan mencetak ruang dengan warna latar belakang. Saya menggunakan teknik ini untuk menggambar progress bar di hidung-progresif :

print t.on_green(' ')

Anda dapat mencetak di lokasi tertentu juga:

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

Jika Anda harus bermain-main dengan kemampuan terminal lain selama permainan Anda, Anda bisa melakukannya juga. Anda dapat menggunakan pemformatan string standar Python agar tetap dapat dibaca:

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

Hal yang menyenangkan tentang Berkat adalah bahwa ia melakukan yang terbaik untuk bekerja pada semua jenis terminal, bukan hanya terminal ANSI (sangat umum). Itu juga menjaga urutan melarikan diri yang tidak terbaca dari kode Anda sambil tetap ringkas untuk digunakan. Selamat bersenang-senang!

sty mirip dengan colorama, tetapi kurang verbose, mendukung 8bit dan 24bit (rgb) warna, memungkinkan Anda untuk mendaftarkan gaya Anda sendiri, mendukung mematikan, sangat fleksibel, didokumentasikan dengan baik dan banyak lagi.

Contoh:

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

cetakan:

Demo:

menghasilkan kelas dengan semua warna menggunakan for loop untuk mengulangi setiap kombinasi warna hingga 100, lalu menulis kelas dengan warna python. Salin dan tempel sesuka Anda, GPLv2 oleh saya:

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'

Coba kode sederhana ini

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

Pada Windows Anda dapat menggunakan modul 'win32console' (tersedia dalam beberapa distribusi Python) atau modul 'ctypes' (Python 2.5 dan lebih tinggi) untuk mengakses API Win32.

Untuk melihat kode lengkap yang mendukung kedua cara, lihat kode pelaporan konsol warna dari Testoob .

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

Bodohnya sederhana berdasarkan jawaban @ 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)

Lalu saja

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

Saya telah memasukkan jawaban @ joeld ke dalam modul dengan fungsi global yang dapat saya gunakan di mana saja dalam kode saya.

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

gunakan sebagai berikut:

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

Untuk Windows Anda tidak dapat mencetak ke konsol dengan warna kecuali Anda menggunakan win32api.

Untuk Linux sesederhana menggunakan cetak, dengan urutan pelarian yang diuraikan di sini:

Warna

Untuk karakter yang dicetak seperti kotak, itu sangat tergantung pada font apa yang Anda gunakan untuk jendela konsol. Simbol pound berfungsi dengan baik, tetapi tergantung pada font:

#

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

Saya akhirnya melakukan ini, saya merasa itu paling bersih:

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)

Membangun jawaban @ joeld, menggunakan 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

Tangkapan layar:

Beberapa pembaruan color_printdengan format baru, misalnya:

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

Catatan: italic, fast blinkingdan strikethroughmungkin tidak bekerja pada semua terminal, tidak bekerja pada Mac / Ubuntu.

Misalnya

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

Tangkapan layar:

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

Coba online

perhatikan seberapa baik withkata kunci bercampur dengan pengubah seperti ini yang perlu diatur ulang (menggunakan Python 3 dan 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")

Anda dapat menggunakan implementasi Python dari perpustakaan kutukan: http://docs.python.org/library/curses.html

Juga, jalankan ini dan Anda akan menemukan kotak Anda:

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

Anda bisa menggunakan CLINT:

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

Dapatkan dari GitHub .

Saya tahu bahwa saya terlambat. Tapi, saya punya perpustakaan bernama ColorIt . Ini sangat sederhana.

Berikut ini beberapa contohnya:

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

Ini memberi Anda:

Perlu juga dicatat bahwa ini adalah platform silang dan telah diuji pada mac, linux, dan windows.

Anda mungkin ingin mencobanya: https://github.com/CodeForeverAndEver/ColorIt

Catatan: Berkedip, miring, tebal, dll. Akan ditambahkan dalam beberapa hari.

Jika Anda memprogram permainan, mungkin Anda ingin mengubah warna latar belakang dan hanya menggunakan spasi? Sebagai contoh:

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

Jika Anda menggunakan Windows, maka ini dia!

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

Jika Anda menggunakan Django

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

foto:

(Saya biasanya menggunakan output berwarna untuk debugging di terminal runserver jadi saya menambahkannya.)

_{Anda dapat menguji apakah itu diinstal di mesin Anda:
$ python -c "import django; print django.VERSION"
Untuk menginstalnya periksa: Cara menginstal Django}

Cobalah!!

Inilah contoh kutukan:

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 menyediakan dukungan portabel untuk membangun UI teks dan animasi:

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

Modul pypi lain yang membungkus fungsi cetak python 3:

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

Dapat digunakan dalam python 2.x jika Anda juga from __future__ import print. Berikut ini adalah contoh python 2 dari halaman modul pypi:

from __future__ import print_function
from colorprint import *

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

Keluaran "Halo, dunia!" dengan kata-kata berwarna biru dan tanda seru berwarna merah tebal dan berkedip.