Como posso produzir texto colorido para o terminal, em Python? Qual é o melhor símbolo Unicode para representar um bloco sólido?

Isso depende um pouco da plataforma em que você está. A maneira mais comum de fazer isso é imprimindo seqüências de escape ANSI. Para um exemplo simples, aqui está um código python dos scripts de compilação do 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 código como este, você pode fazer algo como

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

ou, com Python3.6 +:

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

Isso funcionará em unixes, incluindo OS X, linux e windows (desde que você use o ANSICON ou no Windows 10, desde que você ative a emulação VT100 ). Existem códigos ansi para definir a cor, mover o cursor e muito mais.

Se você vai se complicar com isso (e parece que você está escrevendo um jogo), deve procurar o módulo "maldições", que lida com muitas das partes complicadas disso para você. O Python Curses HowTO é uma boa introdução.

Se você não estiver usando ASCII estendido (ou seja, não estiver em um PC), ficará com os caracteres ascii abaixo de 127 e '#' ou '@' provavelmente é sua melhor aposta para um bloco. Se você pode garantir que seu terminal esteja usando um conjunto de caracteres estendidos ascii da IBM , você terá muito mais opções. Os caracteres 176, 177, 178 e 219 são os "caracteres de bloco".

Alguns programas modernos baseados em texto, como o "Dwarf Fortress", emulam o modo de texto em modo gráfico e usam imagens da fonte clássica do PC. Você pode encontrar alguns desses bitmaps que podem ser usados ​​no Wiki do Dwarf Fortress (veja conjuntos de peças feitas pelo usuário ).

O Concurso de demonstração do modo de texto tem mais recursos para criar gráficos no modo de texto.

Hum ... acho que fiquei um pouco empolgado com essa resposta. No entanto, estou planejando um jogo épico de aventura baseado em texto. Boa sorte com o seu texto colorido!

Estou surpreso que ninguém tenha mencionado o módulo termcolor do Python . O uso é bem simples:

from termcolor import colored

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

Ou no Python 3:

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

No entanto, pode não ser sofisticado o suficiente para a programação de jogos e os "blocos coloridos" que você deseja executar ...

A resposta é Colorama para todas as cores de plataforma cruzada no Python.

Uma captura de tela de exemplo do Python 3.6:

Imprima uma sequência que inicie uma cor / estilo, depois a sequência e termine a alteração de cor / estilo com '\x1b[0m':

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

Obtenha uma tabela de opções de formato para o texto do shell com o seguinte 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()

Exemplo claro-escuro (completo)

Exemplo de luz escura (parcial)

Defina uma sequência que inicia uma cor e uma sequência que termina a cor e imprima o texto com a sequência inicial na frente e a sequência final no final.

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

Isso produz o seguinte em bash, urxvtcom um esquema de cores no estilo Zenburn:

Através da experimentação, podemos obter mais cores:

Nota: \33[5me \33[6mestão piscando.

Dessa forma, podemos criar uma coleção de cores:

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'

Aqui está o código para gerar o teste:

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

Você deseja aprender sobre seqüências de escape ANSI. Aqui está um breve exemplo:

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

Para mais informações, consulte http://en.wikipedia.org/wiki/ANSI_escape_code

Para um caractere de bloco, tente um caractere unicode como \ u2588:

print(u"\u2588")

Juntando tudo:

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

Estou respondendo porque descobri uma maneira de usar códigos ANSI no Windows 10, para que você possa alterar a cor do texto sem nenhum módulo que não esteja incorporado:

A linha que faz esse trabalho é os.system("")ou qualquer outra chamada do sistema, que permite imprimir códigos ANSI no 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: Embora isso ofereça as mesmas opções que outras opções do Windows, o Windows não oferece suporte completo a códigos ANSI, mesmo com esse truque. Nem todas as cores da decoração do texto funcionam e todas as cores 'brilhantes' (códigos 90-97 e 100-107) exibem as mesmas cores normais (códigos 30-37 e 40-47)

Edit : Obrigado a @jl por encontrar um método ainda mais curto.

tl; dr : adicione os.system("")próximo ao topo do seu arquivo.

Versão Python: 3.6.7

Minha maneira favorita é com a biblioteca Bênçãos (divulgação completa: eu escrevi). Por exemplo:

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 tijolos coloridos, a maneira mais confiável é imprimir espaços com cores de fundo. Eu uso essa técnica para desenhar a barra de progresso no nariz progressivo :

print t.on_green(' ')

Você também pode imprimir em locais específicos:

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

Se você precisar mexer com outros recursos do terminal durante o jogo, também poderá fazer isso. Você pode usar a formatação de string padrão do Python para mantê-lo legível:

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

O bom de Blessings é que ele faz o possível para trabalhar em todos os tipos de terminais, e não apenas nos (em grande parte comuns) de cores ANSI. Ele também mantém seqüências de escape ilegíveis fora do seu código, permanecendo conciso para uso. Diverta-se!

sty é semelhante ao colorama, mas é menos detalhado, suporta 8 bits e 24 bits cores de (rgb), permite registrar seus próprios estilos, suporta muting, é realmente flexível, bem documentado e muito mais.

Exemplos:

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

impressões:

Demo:

gerou uma classe com todas as cores usando um loop for para iterar todas as combinações de cores até 100, depois escreveu uma classe com cores python. Copie e cole como quiser, GPLv2 por mim:

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'

Experimente este código simples

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

No Windows, você pode usar o módulo 'win32console' (disponível em algumas distribuições Python) ou o módulo 'ctypes' (Python 2.5 e superior) para acessar a API do Win32.

Para ver o código completo compatível com os dois lados, consulte o código de relatório do console de cores do Testoob .

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

Estupidamente simples com base na resposta 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)

Então apenas

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

Coloquei a resposta @joeld em um módulo com funções globais que posso usar em qualquer lugar do meu código.

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

use da seguinte maneira:

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

No Windows, você não pode imprimir no console com cores, a menos que esteja usando o win32api.

Para Linux, é tão simples quanto usar print, com as seqüências de escape descritas aqui:

Cores

Para que o personagem seja impresso como uma caixa, isso realmente depende da fonte que você está usando na janela do console. O símbolo da libra funciona bem, mas depende da fonte:

#

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

Acabei fazendo isso, achei que era mais limpo:

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)

Com base na resposta @joeld, use 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 tela:

Algumas atualizações para os color_printnovos formatadores, por exemplo:

>>> 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 blinkinge strikethroughpode não funcionar em todos os terminais, não funciona em Mac / Ubuntu.

Por exemplo

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

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

Experimente on-line

observe como a withpalavra - chave combina com modificadores como esses que precisam ser redefinidos (usando Python 3 e 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")

Você pode usar a implementação Python da biblioteca de maldições: http://docs.python.org/library/curses.html

Além disso, execute isso e você encontrará sua caixa:

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

Você poderia usar o CLINT:

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

Obtê-lo no GitHub .

Eu sei que estou atrasado. Mas, eu tenho uma biblioteca chamada ColorIt . É super simples.

aqui estão alguns exemplos:

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

Isso lhe dá:

Também é importante notar que esta é uma plataforma cruzada e foi testada em mac, linux e windows.

Você pode tentar: https://github.com/CodeForeverAndEver/ColorIt

Nota: Piscando, itálico, negrito etc. serão adicionados em alguns dias.

Se você está programando um jogo, talvez queira mudar a cor de fundo e usar apenas espaços? Por exemplo:

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

Se você estiver usando o Windows, aqui está você!

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

Se você estiver 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âneo:

(Eu geralmente uso saída colorida para depuração no terminal runserver, então a adicionei.)

_{Você pode testar se está instalado em sua máquina:
$ python -c "import django; print django.VERSION"
Para instalá-lo, verifique: Como instalar o Django}

De uma chance!!

Aqui está um exemplo de maldições:

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

o asciimatics fornece um suporte portátil para criar UI de texto e animações:

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

Ainda outro módulo pypi que envolve a função de impressão python 3:

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

É utilizável no python 2.x se você também from __future__ import print. Aqui está um exemplo do python 2 da página modules pypi:

from __future__ import print_function
from colorprint import *

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

Resultados "Olá, mundo!" com as palavras em azul e o ponto de exclamação em negrito vermelho e piscando.