Come posso inviare testo colorato al terminale, in Python? Qual è il miglior simbolo Unicode per rappresentare un blocco solido?

Questo dipende in qualche modo dalla piattaforma su cui ti trovi. Il modo più comune per farlo è stampare le sequenze di escape ANSI. Per un semplice esempio, ecco un po 'di codice Python dagli script di build di 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'

Per usare un codice come questo, puoi fare qualcosa del genere

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

oppure, con Python3.6 +:

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

Funzionerà su unix tra cui OS X, Linux e Windows (a condizione che tu usi ANSICON , o in Windows 10 a condizione che tu abiliti l' emulazione VT100 ). Esistono codici ansi per l'impostazione del colore, lo spostamento del cursore e altro.

Se hai intenzione di complicarti con questo (e sembra che tu stia scrivendo un gioco), dovresti esaminare il modulo "maledizioni", che gestisce molte delle parti complicate di questo per te. Il Python Curses HowTO è una buona introduzione.

Se non stai usando ASCII esteso (cioè non su un PC), sei bloccato con i caratteri ASCII inferiori a 127 e '#' o '@' è probabilmente la soluzione migliore per un blocco. Se puoi assicurarti che il tuo terminale stia utilizzando un set di caratteri ASCII esteso IBM , hai molte più opzioni. I caratteri 176, 177, 178 e 219 sono i "caratteri di blocco".

Alcuni moderni programmi basati su testo, come "Dwarf Fortress", emulano la modalità testo in modalità grafica e usano immagini del classico font per PC. Puoi trovare alcune di queste bitmap che puoi usare sul Wiki di Dwarf Fortress ( set di tessere create dall'utente ).

Il Contest Demo in modalità testo ha più risorse per realizzare grafica in modalità testo.

Hmm .. Penso che mi sia lasciato un po 'trasportare da questa risposta. Sono nel bel mezzo della pianificazione di un epico gioco di avventura basato su testo, però. Buona fortuna con il tuo testo colorato!

Sono sorpreso che nessuno abbia menzionato il modulo termcolor Python . L'utilizzo è piuttosto semplice:

from termcolor import colored

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

O in Python 3:

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

Potrebbe non essere abbastanza sofisticato, tuttavia, per la programmazione di gioco e i "blocchi colorati" che vuoi fare ...

La risposta è Colorama per tutte le colorazioni multipiattaforma in Python.

Uno screenshot di esempio di Python 3.6:

Stampa una stringa che inizia un colore / stile, quindi la stringa, quindi termina la modifica di colore / stile con '\x1b[0m':

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

Ottieni una tabella di opzioni di formato per il testo della shell con il seguente codice:

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

Esempio chiaro-scuro (completo)

Esempio scuro-chiaro (parziale)

Definisci una stringa che inizia un colore e una stringa che termina il colore, quindi stampa il testo con la stringa iniziale nella parte anteriore e la stringa finale alla fine.

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

Questo produce quanto segue bash, in urxvtcon una combinazione di colori in stile Zenburn:

Attraverso la sperimentazione, possiamo ottenere più colori:

Nota: \33[5me \33[6mlampeggiano.

In questo modo possiamo creare una collezione a colori:

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'

Ecco il codice per generare il test:

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

Vuoi conoscere le sequenze di escape ANSI. Ecco un breve esempio:

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

Per maggiori informazioni vedi http://en.wikipedia.org/wiki/ANSI_escape_code

Per un personaggio a blocchi, prova un personaggio unicode come \ u2588:

print(u"\u2588")

Mettere tutto insieme:

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

Sto rispondendo perché ho scoperto un modo per utilizzare i codici ANSI su Windows 10, in modo che tu possa cambiare il colore del testo senza moduli che non sono integrati:

La linea che fa funzionare questo è os.system(""), o qualsiasi altra chiamata di sistema, che consente di stampare codici ANSI nel Terminale:

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: sebbene ciò fornisca le stesse opzioni di altre opzioni di Windows, Windows non supporta completamente i codici ANSI, anche con questo trucco. Non tutti i colori della decorazione del testo funzionano e tutti i colori "luminosi" (Codici 90-97 e 100-107) mostrano lo stesso colore dei colori normali (Codici 30-37 e 40-47)

Modifica : grazie a @jl per aver trovato un metodo ancora più breve.

tl; dr : aggiungi os.system("")nella parte superiore del file.

Versione Python: 3.6.7

Il mio modo preferito è con la biblioteca Blessings (divulgazione completa: l'ho scritto). Per esempio:

from blessings import Terminal

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

Per stampare mattoni colorati, il modo più affidabile è stampare spazi con colori di sfondo. Uso questa tecnica per disegnare la barra di avanzamento in modo progressivo :

print t.on_green(' ')

Puoi stampare anche in posizioni specifiche:

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

Se devi confondere con altre funzionalità del terminale nel corso del gioco, puoi farlo anche tu. Puoi usare la formattazione standard delle stringhe di Python per mantenerla leggibile:

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

La cosa bella di Blessings è che fa del suo meglio per lavorare su tutti i tipi di terminali, non solo su quelli (straordinariamente comuni) di colore ANSI. Mantiene anche sequenze di escape illeggibili dal tuo codice pur rimanendo conciso da usare. Divertiti!

porcile è simile a colorama, ma è meno dettagliato, supporta colori a 8 bit e 24 bit (rgb), consente di registrare i propri stili, supporta il muting, è davvero flessibile, ben documentato e altro ancora.

Esempi:

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

stampe:

demo:

ha generato una classe con tutti i colori usando un ciclo for per iterare ogni combinazione di colore fino a 100, quindi ha scritto una classe con colori pitone. Copia e incolla come vuoi, GPLv2 da me:

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'

Prova questo semplice codice

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

Su Windows è possibile utilizzare il modulo 'win32console' (disponibile in alcune distribuzioni Python) o il modulo 'ctypes' (Python 2.5 e versioni successive) per accedere all'API Win32.

Per vedere il codice completo che supporta entrambi i modi, vedere il codice di report della console colori di Testoob .

esempio di tipi:

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)

Stupidamente semplice basato sulla risposta di @ 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)

Quindi basta

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

Ho racchiuso la risposta @joeld in un modulo con funzioni globali che posso usare ovunque nel mio codice.

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

utilizzare come segue:

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

Per Windows non è possibile stampare su console con colori a meno che non si utilizzi win32api.

Per Linux è semplice come usare print, con le sequenze di escape descritte qui:

Colori

Per il personaggio da stampare come una scatola, dipende davvero dal tipo di carattere che stai usando per la finestra della console. Il simbolo della sterlina funziona bene, ma dipende dal carattere:

#

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

Ho finito per farlo, ho sentito che era il più pulito:

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)

Partendo dalla risposta @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

Immagine dello schermo:

Alcuni aggiornamenti color_printcon i nuovi formattatori, ad esempio:

>>> 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 strikethroughpotrebbe non funzionare su tutti i terminali, non funziona su Mac / Ubuntu.

Per esempio

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

Immagine dello schermo:

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

Prova online

nota quanto bene la withparola chiave si mescola con modificatori come questi che devono essere resettati (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")

Puoi usare l'implementazione Python della libreria curses: http://docs.python.org/library/curses.html

Inoltre, esegui questo e troverai la tua scatola:

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

Puoi usare CLINT:

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

Scarica da GitHub .

So di essere in ritardo. Ma ho una biblioteca chiamata ColorIt . È super semplice.

Ecco alcuni esempi:

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

Questo ti dà:

Vale anche la pena notare che questo è multipiattaforma ed è stato testato su Mac, Linux e Windows.

Potresti provare: https://github.com/CodeForeverAndEver/ColorIt

Nota: lampeggiante, corsivo, grassetto, ecc. Verranno aggiunti tra qualche giorno.

Se stai programmando un gioco, forse vorresti cambiare il colore di sfondo e usare solo spazi? Per esempio:

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

Se stai usando Windows, allora eccoti qui!

# 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 stai usando Django

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

snapshot:

(In genere utilizzo l'output colorato per il debug sul terminale di Runtime Server, quindi l'ho aggiunto.)

_{Puoi verificare se è installato sul tuo computer:
$ python -c "import django; print django.VERSION"
Per installarlo controlla: Come installare Django}

Provaci!!

Ecco un esempio di maledizioni:

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 fornisce un supporto portatile per la creazione di UI di testo e animazioni:

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

Ancora un altro modulo pypi che avvolge la funzione di stampa di python 3:

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

E 'utilizzabile in python 2.x se anche from __future__ import print. Ecco un esempio di Python 2 dalla pagina pypi dei moduli:

from __future__ import print_function
from colorprint import *

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

Output "Ciao, mondo!" con le parole in blu e il punto esclamativo in grassetto rosso e lampeggiante.