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 um código como este, você pode fazer algo como

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

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

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

Se não estiver a usar ASCII estendido (ou seja, não num PC), está preso com os caracteres ascii abaixo de 127, e '#' ou '@' é provavelmente a sua melhor aposta para um bloco. Se você pode garantir que o seu terminal está a usar um conjunto de caracteres ASCII extended ASCII, você tem muitas mais opções. Os caracteres 176, 177, 178 e 219 são os "caracteres em bloco".

Alguns programas modernos baseados em texto, tais como" Fortaleza anÃ", emulam o modo texto em um modo gráfico, e usam imagens da fonte clássica do PC. Você pode encontrar alguns desses bitmaps que você pode usar na Fortaleza anà Wiki veja (tilesets feitos pelo usuário ).

O Concurso De Demonstração Do Modo De Texto tem mais recursos para fazer gráficos no modo de texto.

Estou surpreendido que ninguém tenha mencionado o Módulo Python termcolor . A utilização é bastante simples:

from termcolor import colored

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

Ou em Python 3:

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

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

Uma imagem de exemplo em Python 3.6:

Imprime um texto que inicia uma cor/estilo, depois o texto, e depois termina a mudança de cor / estilo com '\x1b[0m':

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

Obter uma tabela de opções de formato para o texto da linha de comandos 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 sobre as trevas (completo)

Exemplo (parcial)

Define um texto que inicia uma cor e um texto que termina a cor, depois imprime o seu texto com o texto inicial na frente e o texto final no fim.

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

Isto produz o seguinte em bash, em urxvt com um esquema de cores ao estilo Zenburn:

Nota: \33[5m e \33[6m estão a piscar.

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

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

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

Para um carácter de bloco, tente um carácter unicode como \u2588:

print u"\u2588"

Juntando tudo:

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

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 forma mais fiável é imprimir espaços com cores de fundo. Eu uso esta técnica para desenhar a barra de progresso em nariz-progressivo:

print t.on_green(' ')

Também pode imprimir em locais específicos:

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

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

Gerou uma classe com todas as cores usando um laço for para iterar todas as combinações de cores até 100, depois escreveu uma classe com cores python. Copiar e colar 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'

Tenta 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, poderá usar o módulo ' win32console '(disponível em algumas distribuições em Python) ou o módulo' ctypes ' (python 2.5 e up) para aceder à API Win32.

Para ver o código completo que suporta ambas as formas, veja o código de Relato da consola de cores de Testoob .

Ctypes exemplo:

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

Embrulhei a resposta @joeld num módulo com funções globais que posso usar em qualquer parte do meu código.

Ficheiro: 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 do seguinte modo:

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

Baseado na resposta de @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

Imagem:

Algumas actualizações de color_print com novos 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 blinking e strikethrough pode 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

Imagem:

Para as janelas, não pode imprimir para consola com cores, a menos que esteja a usar o win32api.

Para o Linux é tão simples como usar a impressão, com as sequências de escape descritas aqui:

Cores

Para o carácter imprimir como uma caixa, depende realmente do tipo de letra que está a usar para a janela da consola. O símbolo do Libra funciona bem, mas depende do tipo de letra:

#

Repare como a palavra-chave with se mistura com modificadores como estes que precisam de ser repostos (usando o Python 3 e o 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")

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)

O Sty é semelhante ao colorama, mas é menos descritivo, suporta 8bit e 24bit (rgb) cores, permite-lhe registar as suas próprias cores, é realmente flexível e bem documentado. Se você não se importa com a compatibilidade com os emuladores de terminal que estão presos no 90º e gostam de usar novos recursos, você pode querer dar-lhe uma tentativa.

from sty import fg, bg, ef, rs, Rule

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 new colors:

fg.orange = Rule('rgb_fg', 255, 150, 50)

buf = fg.orange + 'Yay, Im orange.' + fg.rs


print(foo, bar, baz, qux, qui, buf, sep='\n')

Impressões Digitais:

Demo:

Podias usar o CLINT:

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

Vai buscá-lo ao GitHub.

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

Também, execute isto e encontrará a sua caixa:

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

Se está a programar 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"

Asciimatics fornece um suporte portátil para a construção de 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:

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

Https://pypi.python.org/pypi/colorprint

Pode ser usado no python 2.x se também from __future__ import print. Aqui está um exemplo em python 2 da página de módulos pypi:

from __future__ import print_function
from colorprint import *

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

Outputs " Hello, world!"com as palavras em azul e o ponto de exclamação vermelho e a piscar.

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)

Enquanto eu acho esta Resposta útil, eu modifiquei-a um pouco. este Github Gist é o resultado

Utilização

print colors.draw("i'm yellow", bold=True, fg_yellow=True)

Além disso, pode embrulhar usagens comuns:

print colors.error('sorry, ')

Https://gist.github.com/Jossef/0ee20314577925b4027f

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

Se estás a usar o Windows, então aqui tens!

# 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 estiver a utilizar 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:

(normalmente uso o resultado colorido para depuração no terminal runserver, por isso adicionei-o.)

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

Uma opção mais fácil seria usar a função cprint Do pacote termcolor.

Ele também suporta %s, %d formato de impressão

# Pure Python 3.x demo, 256 colors
# Works with bash under Linux

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):
    for col in range(6):
        color = row*6 + col + 4
        if color>=0:
            text = "{:3d}".format(color)
            print (format(text,color), end=" ")
        else:
            print("   ", end=" ")

for row in range(-1,42):
    print_six(row, fg)
    print("",end=" ")
    print_six(row, bg)
    print()

Para os caracteres

O seu terminal provavelmente usa caracteres Unicode( tipicamente codificados em UTF-8), por isso é apenas uma questão de selecção de tipos de letra apropriada para ver o seu carácter favorito. Unicode char U + 2588," bloco completo " é o que eu sugiro que você use.

Tente o seguinte:

import unicodedata
fp= open("character_list", "w")
for index in xrange(65536):
    char= unichr(index)
    try: its_name= unicodedata.name(char)
    except ValueError: its_name= "N/A"
    fp.write("%05d %04x %s %s\n" % (index, index, char.encode("UTF-8"), its_name)
fp.close()

Examine o ficheiro mais tarde com o seu visualizador favorito.

Para as cores

As maldições são o módulo que deseja usar. Verificar tutorial .