Comment puis-je sortir du texte en couleur sur le terminal, en Python? Quel est le meilleur symbole Unicode pour représenter un bloc solide?

Cela dépend quelque peu de la plateforme sur laquelle vous vous trouvez. La façon la plus courante de procéder consiste à imprimer des séquences d'échappement ANSI. Pour un exemple simple, voici du code python des scripts de construction 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'

Pour utiliser un code comme celui-ci, vous pouvez faire quelque chose comme

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

ou, avec Python3.6 +:

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

Cela fonctionnera sur unix, y compris OS X, Linux et Windows (à condition que vous utilisiez ANSICON , ou dans Windows 10 à condition d'activer l' émulation VT100 ). Il existe des codes ansi pour définir la couleur, déplacer le curseur, etc.

Si vous allez devenir compliqué avec cela (et il semble que vous le soyez si vous écrivez un jeu), vous devriez regarder dans le module "curses", qui gère une grande partie des parties compliquées de cela pour vous. Le Python Curses HowTO est une bonne introduction.

Si vous n'utilisez pas ASCII étendu (c'est-à-dire pas sur un PC), vous êtes coincé avec les caractères ascii en dessous de 127, et '#' ou '@' est probablement votre meilleur pari pour un bloc. Si vous pouvez vous assurer que votre terminal utilise un jeu de caractères ASCII étendu IBM , vous disposez de nombreuses autres options. Les caractères 176, 177, 178 et 219 sont les "caractères de bloc".

Certains programmes modernes basés sur du texte, tels que "Dwarf Fortress", émulent le mode texte en mode graphique et utilisent des images de la police PC classique. Vous pouvez trouver certains de ces bitmaps que vous pouvez utiliser sur le Wiki Dwarf Fortress voir (ensembles de tuiles créés par l'utilisateur ).

Le concours de démonstration en mode texte a plus de ressources pour faire des graphiques en mode texte.

Hmm .. Je pense que je me suis un peu laissé emporter par cette réponse. Je suis en train de planifier un jeu d'aventure épique basé sur du texte. Bonne chance avec ton texte en couleur!

Je suis surpris que personne n'ait mentionné le module Python termcolor . L'utilisation est assez simple:

from termcolor import colored

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

Ou en Python 3:

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

Cependant, il n'est peut-être pas assez sophistiqué pour la programmation de jeux et les "blocs de couleur" que vous voulez faire ...

La réponse est Colorama pour toutes les couleurs multiplateformes en Python.

Un exemple de capture d'écran Python 3.6:

Imprimez une chaîne qui commence une couleur / un style, puis la chaîne, puis terminez le changement de couleur / style avec '\x1b[0m':

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

Obtenez un tableau des options de format pour le texte shell avec le code suivant:

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

Exemple clair sur foncé (complet)

Exemple sombre sur lumière (partiel)

Définissez une chaîne qui commence une couleur et une chaîne qui termine la couleur, puis imprimez votre texte avec la chaîne de début à l'avant et la chaîne de fin à la fin.

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

Cela produit les éléments suivants dans bash, urxvtavec un jeu de couleurs de style Zenburn:

Grâce à l'expérimentation, nous pouvons obtenir plus de couleurs:

Remarque: \33[5met \33[6mclignotent.

De cette façon, nous pouvons créer une collection en couleur:

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'

Voici le code pour générer le 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

Vous souhaitez en savoir plus sur les séquences d'échappement ANSI. Voici un bref exemple:

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

Pour plus d'informations, voir http://en.wikipedia.org/wiki/ANSI_escape_code

Pour un caractère de bloc, essayez un caractère unicode comme \ u2588:

print(u"\u2588")

Mettre tous ensemble:

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

Je réponds car j'ai trouvé un moyen d'utiliser les codes ANSI sur Windows 10, afin que vous puissiez changer la couleur du texte sans aucun module non intégré:

La ligne qui fait ce travail est os.system(""), ou tout autre appel système, qui vous permet d'imprimer des codes ANSI dans le 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!")

Remarque: Bien que cela donne les mêmes options que les autres options de Windows, Windows ne prend pas complètement en charge les codes ANSI, même avec cette astuce. Toutes les couleurs de décoration de texte ne fonctionnent pas et toutes les couleurs `` lumineuses '' (codes 90-97 et 100-107) affichent la même chose que les couleurs normales (codes 30-37 et 40-47)

Edit : Merci à @jl d'avoir trouvé une méthode encore plus courte.

tl; dr : ajoutez en os.system("")haut de votre fichier.

Version Python: 3.6.7

Ma façon préférée est avec la bibliothèque Blessings (divulgation complète: je l'ai écrite). Par exemple:

from blessings import Terminal

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

Pour imprimer des briques colorées, le moyen le plus fiable consiste à imprimer des espaces avec des couleurs d'arrière-plan. J'utilise cette technique pour dessiner la barre de progression en nez progressif :

print t.on_green(' ')

Vous pouvez également imprimer dans des emplacements spécifiques:

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

Si vous devez jouer avec d'autres capacités de terminal au cours de votre jeu, vous pouvez également le faire. Vous pouvez utiliser le formatage de chaîne standard de Python pour le garder lisible:

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

La bonne chose à propos de Blessings, c'est qu'il fait de son mieux pour travailler sur toutes sortes de terminaux, pas seulement ceux (extrêmement courants) de couleur ANSI. Il garde également les séquences d'échappement illisibles hors de votre code tout en restant concis à utiliser. S'amuser!

sty est similaire à colorama, mais il est moins verbeux, prend en charge les couleurs 8 bits et 24 bits (rgb), vous permet d'enregistrer vos propres styles, prend en charge le muting, est vraiment flexible, bien documenté et plus encore.

Exemples:

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

impressions:

Démo:

a généré une classe avec toutes les couleurs en utilisant une boucle for pour itérer chaque combinaison de couleurs jusqu'à 100, puis a écrit une classe avec des couleurs python. Copiez et collez comme vous voulez, GPLv2 par moi:

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'

Essayez ce code 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")

Sous Windows, vous pouvez utiliser le module 'win32console' (disponible dans certaines distributions Python) ou le module 'ctypes' (Python 2.5 et supérieur) pour accéder à l'API Win32.

Pour voir le code complet qui prend en charge les deux façons, consultez le code de rapport de la console couleur de Testoob .

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

Incroyablement simple basé sur la réponse 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)

Alors juste

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

J'ai enveloppé la réponse @joeld dans un module avec des fonctions globales que je peux utiliser n'importe où dans mon code.

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

utiliser comme suit:

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

Pour Windows, vous ne pouvez pas imprimer sur une console avec des couleurs, sauf si vous utilisez win32api.

Pour Linux, c'est aussi simple que d'utiliser print, avec les séquences d'échappement décrites ici:

Couleurs

Pour que le caractère s'imprime comme une boîte, cela dépend vraiment de la police que vous utilisez pour la fenêtre de la console. Le symbole dièse fonctionne bien, mais cela dépend de la police:

#

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

J'ai fini par faire ça, j'ai senti que c'était le plus propre:

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)

En s'appuyant sur la réponse @joeld, en utilisant 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

Capture d'écran:

Quelques mises à jour du color_printavec de nouveaux formateurs, par exemple:

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

Note: italic, fast blinkingetstrikethrough peut ne pas fonctionner sur tous les terminaux, ne fonctionne pas sur Mac / Ubuntu.

Par exemple

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

Capture d'écran:

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

Essayez en ligne

notez à quel point le withmot - clé se mélange avec des modificateurs comme ceux-ci qui doivent être réinitialisés (en utilisant Python 3 et 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")

Vous pouvez utiliser l'implémentation Python de la bibliothèque curses: http://docs.python.org/library/curses.html

Exécutez également ceci et vous trouverez votre boîte:

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

Vous pouvez utiliser CLINT:

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

Obtenez-le de GitHub .

Je sais que je suis en retard. Mais j'ai une bibliothèque appelée ColorIt . C'est super simple.

Voici quelques exemples:

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

Cela vous donne:

Il convient également de noter qu'il s'agit d'une plateforme multiplateforme et a été testé sur mac, linux et windows.

Vous voudrez peut-être l'essayer: https://github.com/CodeForeverAndEver/ColorIt

Remarque: Clignotant, italique, gras, etc. sera ajouté dans quelques jours.

Si vous programmez un jeu, vous souhaitez peut-être changer la couleur d'arrière-plan et utiliser uniquement des espaces? Par exemple:

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

Si vous utilisez Windows, alors c'est parti!

# 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 vous utilisez Django

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

instantané:

(J'utilise généralement une sortie colorée pour le débogage sur le terminal runserver, je l'ai donc ajoutée.)

_{Vous pouvez tester s'il est installé sur votre machine:
$ python -c "import django; print django.VERSION"
Pour l'installer, vérifiez: Comment installer Django}

Essaie!!

Voici un exemple de malédictions:

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 fournit un support portable pour la construction d'interfaces texte et d'animations:

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

Encore un autre module pypi qui encapsule la fonction d'impression python 3:

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

Il est utilisable en python 2.x si vous aussi from __future__ import print. Voici un exemple de python 2 de la page pypi des modules:

from __future__ import print_function
from colorprint import *

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

Sorties "Bonjour, monde!" avec les mots en bleu et le point d'exclamation en gras rouge et clignotant.