¿Cómo puedo enviar texto coloreado a la terminal, en Python? ¿Cuál es el mejor símbolo Unicode para representar un bloque sólido?

Esto depende un poco de la plataforma en la que se encuentre. La forma más común de hacerlo es imprimir secuencias de escape ANSI. Para un ejemplo simple, aquí hay un código de Python de los scripts de compilación de 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'

Para usar un código como este, puedes hacer algo como

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

o, con Python3.6 +:

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

Esto funcionará en unixes, incluidos OS X, Linux y Windows (siempre que use ANSICON , o en Windows 10 siempre que habilite la emulación VT100 ). Hay códigos ansi para configurar el color, mover el cursor y más.

Si te vas a complicar con esto (y parece que lo estás haciendo si estás escribiendo un juego), deberías mirar el módulo de "maldiciones", que maneja muchas de las partes complicadas de esto por ti. El Python maldice cómo es una buena introducción.

Si no está utilizando ASCII extendido (es decir, no en una PC), está atrapado con los caracteres ascii por debajo de 127, y '#' o '@' es probablemente su mejor opción para un bloque. Si puede asegurarse de que su terminal está utilizando un juego de caracteres ascii extendido de IBM , tiene muchas más opciones. Los caracteres 176, 177, 178 y 219 son los "caracteres de bloque".

Algunos programas modernos basados ​​en texto, como "Dwarf Fortress", emulan el modo de texto en modo gráfico y usan imágenes de la fuente clásica de PC. Puede encontrar algunos de estos mapas de bits que puede usar en la Wiki de Dwarf Fortress (conjuntos de fichas hechas por el usuario ).

El concurso de demostración de modo de texto tiene más recursos para hacer gráficos en modo de texto.

Hmm ... creo que me dejé llevar por esta respuesta. Sin embargo, estoy en medio de la planificación de un épico juego de aventuras basado en texto. ¡Buena suerte con tu texto a color!

Me sorprende que nadie haya mencionado el módulo Python termcolor . El uso es bastante simple:

from termcolor import colored

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

O en Python 3:

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

Sin embargo, puede que no sea lo suficientemente sofisticado para la programación de juegos y los "bloques de colores" que desea hacer ...

La respuesta es Colorama para todos los colores multiplataforma en Python.

Una captura de pantalla de ejemplo de Python 3.6:

Imprima una cadena que comience un color / estilo, luego la cadena, luego finalice el cambio de color / estilo con '\x1b[0m':

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

Obtenga una tabla de opciones de formato para el texto del shell con el siguiente código:

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

Ejemplo claro sobre oscuro (completo)

Ejemplo de oscuridad sobre luz (parcial)

Defina una cadena que comience un color y una cadena que termine el color, luego imprima su texto con la cadena inicial al frente y la cadena final al final.

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

Esto produce lo siguiente en bash, urxvtcon un esquema de color estilo Zenburn:

A través de la experimentación, podemos obtener más colores:

Nota: \33[5my \33[6mestán parpadeando.

De esta manera podemos crear una colección a todo color:

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'

Aquí está el código para generar la prueba:

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

Desea aprender sobre las secuencias de escape ANSI. Aquí hay un breve ejemplo:

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

Para obtener más información, visite http://en.wikipedia.org/wiki/ANSI_escape_code

Para un carácter de bloque, intente con un carácter unicode como \ u2588:

print(u"\u2588")

Poniendolo todo junto:

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

Estoy respondiendo porque he descubierto una forma de usar códigos ANSI en Windows 10, para que pueda cambiar el color del texto sin ningún módulo que no esté integrado:

La línea que hace que esto funcione es os.system(""), o cualquier otra llamada al sistema, que le permite imprimir códigos ANSI en la 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!")

Nota: aunque esto ofrece las mismas opciones que otras opciones de Windows, Windows no es totalmente compatible con los códigos ANSI, incluso con este truco. No todos los colores de decoración de texto funcionan y todos los colores 'brillantes' (Códigos 90-97 y 100-107) se muestran igual que los colores normales (Códigos 30-37 y 40-47)

Editar : Gracias a @jl por encontrar un método aún más corto.

tl; dr : Agregar os.system("")cerca de la parte superior de su archivo.

Versión de Python: 3.6.7

Mi forma favorita es con la biblioteca Blessings (divulgación completa: la escribí). Por ejemplo:

from blessings import Terminal

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

Para imprimir ladrillos de colores, la forma más confiable es imprimir espacios con colores de fondo. Utilizo esta técnica para dibujar la barra de progreso en nariz progresiva :

print t.on_green(' ')

También puede imprimir en ubicaciones específicas:

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

Si tiene que jugar con otras capacidades de terminal en el transcurso de su juego, también puede hacerlo. Puede usar el formato de cadena estándar de Python para mantenerlo legible:

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

Lo bueno de Blessings es que hace todo lo posible para trabajar en todo tipo de terminales, no solo en los de color ANSI (abrumadoramente comunes). También mantiene secuencias de escape ilegibles fuera de su código mientras se mantiene conciso para usar. ¡Que te diviertas!

pocilga es similar a Colorama, pero es menos detallado, soportes de 8 bits y 24 bits de colores (RGB), le permite registrar sus propios estilos, soportes desconectado, es muy flexible, bien documentados y más.

Ejemplos:

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

huellas dactilares:

Manifestación:

generó una clase con todos los colores usando un bucle for para iterar cada combinación de color hasta 100, luego escribió una clase con colores python. Copia y pega como quieras, GPLv2 por mí:

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'

Prueba este código simple

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

En Windows puede usar el módulo 'win32console' (disponible en algunas distribuciones de Python) o el módulo 'ctypes' (Python 2.5 y superior) para acceder a la API de Win32.

Para ver el código completo que admite ambas formas, consulte el código de informes de la consola de color de Testoob .

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

Estúpidamente simple basado en la respuesta de @ 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)

Entonces solo

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

He incluido la respuesta @joeld en un módulo con funciones globales que puedo usar en cualquier parte de mi código.

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

utilizar de la siguiente manera:

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

Para Windows no puede imprimir en la consola con colores a menos que esté utilizando win32api.

Para Linux es tan simple como usar print, con las secuencias de escape descritas aquí:

Colores

Para que el personaje se imprima como un cuadro, realmente depende de qué fuente esté utilizando para la ventana de la consola. El símbolo de la libra funciona bien, pero depende de la fuente:

#

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

Terminé haciendo esto, sentí que era más limpio:

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)

Basándose en la respuesta @joeld, usando 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

Captura de pantalla:

Algunas actualizaciones de la color_printcon nuevos formateadores, por ejemplo:

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

Nota: italic, fast blinkingy strikethroughpuede no funcionar en todos los terminales, no funciona en Mac / Ubuntu.

P.ej

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

Captura de pantalla:

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

Probar en línea

observe qué tan bien se withmezcla la palabra clave con modificadores como estos que deben restablecerse (usando Python 3 y 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")

Puede usar la implementación de Python de la biblioteca curses: http://docs.python.org/library/curses.html

Además, ejecute esto y encontrará su caja:

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

Puedes usar CLINT:

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

Obtenlo de GitHub .

Sé que llego tarde. Pero tengo una biblioteca llamada ColorIt . Es super simple.

Aquí hay unos ejemplos:

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

Esto te da:

También vale la pena señalar que esto es multiplataforma y se ha probado en mac, linux y windows.

Es posible que desee probarlo: https://github.com/CodeForeverAndEver/ColorIt

Nota: Parpadeo, cursiva, negrita, etc. se agregarán en unos días.

Si está programando un juego, ¿tal vez le gustaría cambiar el color de fondo y usar solo espacios? Por ejemplo:

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

Si está utilizando Windows, ¡aquí está!

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

Si estás usando Django

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

instantánea:

(Por lo general, utilizo resultados en color para depurar en el terminal del servidor de ejecución, así que lo agregué)

_{Puede probar si está instalado en su máquina:
$ python -c "import django; print django.VERSION"
Para instalarlo, verifique: Cómo instalar Django}

¡¡Darle una oportunidad!!

Aquí hay un ejemplo de maldiciones:

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 proporciona un soporte portátil para crear UI de texto y animaciones:

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

Otro módulo pypi que envuelve la función de impresión python 3:

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

Es utilizable en python 2.x si tú también from __future__ import print. Aquí hay un ejemplo de python 2 de la página de módulos de pypi:

from __future__ import print_function
from colorprint import *

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

Salidas "¡Hola, mundo!" con las palabras en azul y el signo de exclamación en negrita rojo y parpadeante.