cela dépend un peu de la plate-forme sur laquelle vous êtes. La façon la plus courante de le faire est d'imprimer des séquences d'échappement ANSI. Pour un exemple simple, voici un code python du blender build scripts :

class bcolors:
    HEADER = '3[95m'
    OKBLUE = '3[94m'
    OKGREEN = '3[92m'
    WARNING = '3[93m'
    FAIL = '3[91m'
    ENDC = '3[0m'
    BOLD = '3[1m'
    UNDERLINE = '3[4m'

Pour utiliser ce code, vous pouvez faire quelque chose comme

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

cela fonctionnera sur unixes y compris OS X, linux et windows (à condition que vous utilisiez ANSICON , ou Windows 10 à condition que vous activiez emulation VT100 ). Il y a des codes ansi pour définir la couleur, déplacer le curseur, et plus encore.

si vous allez devenir compliqué avec cela (et il semble que vous êtes si vous écrivez un jeu), vous devriez regarder dans le module" malédictions", qui gère beaucoup des parties compliquées de ceci pour vous. Le Python Curses HowTO est une bonne introduction.

si vous n ' utilisez pas en ASCII étendu (c.-à-d. 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 IBM étendu jeu de caractères ascii , vous avez beaucoup plus d'options. Les caractères 176, 177, 178 et 219 sont les "caractères de bloc".

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

le concours de démo en mode texte a plus de ressources pour faire des graphiques en mode texte.

Hmm.. Je pense que suis un peu emporté sur cette réponse. Je suis en train de planifier un jeu d'aventure épique basé sur le texte, cependant. Bonne chance avec votre texte coloré!

je suis surpris que personne n'ait mentionné le module Python termcolor . L'Usage 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'))

il peut ne pas être assez sophistiqué, cependant, pour la programmation de jeu et les" blocs de couleur " que vous voulez faire...

la réponse est Colorama pour tous les coloris multiplateformes en Python.

un Python 3.6 exemple screenshot:

imprimer une chaîne de caractères qui commence une couleur / style, puis la chaîne de caractères, puis terminer le changement de couleur / style avec '\x1b[0m' :

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

Obtenir un tableau des options de format pour la coquille de texte 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 de la lumière sur l'obscurité (complet)

Dark-sur-la lumière de l'exemple (partiel)

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

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

cela produit ce qui suit dans bash , dans urxvt avec un arrangement de couleur de style Zenburn:

par experemination, nous pouvons obtenir plus de couleurs:

Note: [5m et [6m clignotent.

de cette façon nous pouvons créer une collection couleur complète:

CEND      = '[0m'
CBOLD     = '[1m'
CITALIC   = '[3m'
CURL      = '[4m'
CBLINK    = '[5m'
CBLINK2   = '[6m'
CSELECTED = '[7m'

CBLACK  = '[30m'
CRED    = '[31m'
CGREEN  = '[32m'
CYELLOW = '[33m'
CBLUE   = '[34m'
CVIOLET = '[35m'
CBEIGE  = '[36m'
CWHITE  = '[37m'

CBLACKBG  = '[40m'
CREDBG    = '[41m'
CGREENBG  = '[42m'
CYELLOWBG = '[43m'
CBLUEBG   = '[44m'
CVIOLETBG = '[45m'
CBEIGEBG  = '[46m'
CWHITEBG  = '[47m'

CGREY    = '[90m'
CRED2    = '[91m'
CGREEN2  = '[92m'
CYELLOW2 = '[93m'
CBLUE2   = '[94m'
CVIOLET2 = '[95m'
CBEIGE2  = '[96m'
CWHITE2  = '[97m'

CGREYBG    = '[100m'
CREDBG2    = '[101m'
CGREENBG2  = '[102m'
CYELLOWBG2 = '[103m'
CBLUEBG2   = '[104m'
CVIOLETBG2 = '[105m'
CBEIGEBG2  = '[106m'
CWHITEBG2  = '[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 + "[" + code + "m\33[" + code + "m3[0m "
  print(colors)
  x=x+5

vous voulez en savoir plus sur les séquences d'évasion ANSI. Voici un bref exemple:

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

pour plus d'information 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"

ma méthode préférée est la bibliothèque bénédictions (divulgation complète: je l'ai écrit). 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, la manière la plus fiable est d'imprimer des espaces avec des couleurs de fond. J'utilise cette technique pour dessiner la barre de progression dans nez-progressif :

print t.on_green(' ')

vous pouvez aussi imprimer dans des endroits spécifiques:

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

si vous devez muck avec d'autres terminaux capacités dans le cadre de votre jeu, vous pouvez le faire aussi bien. 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)

ce qu'il y a de bien avec les bénédictions, c'est qu'il fait de son mieux pour travailler sur toutes sortes de terminaux, pas seulement ceux (très communs) ANSI-Couleur. Il garde également les séquences d'échappement illisibles hors de votre code tout en restant concise à utiliser. Amusez-vous!

a généré une classe avec toutes les couleurs en utilisant une boucle for pour itérer chaque combinaison de couleur jusqu'à 100, puis a écrit une classe avec des couleurs python. Copier et Coller 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='3[0m'
    bold='3[01m'
    disable='3[02m'
    underline='3[04m'
    reverse='3[07m'
    strikethrough='3[09m'
    invisible='3[08m'
    class fg:
        black='3[30m'
        red='3[31m'
        green='3[32m'
        orange='3[33m'
        blue='3[34m'
        purple='3[35m'
        cyan='3[36m'
        lightgrey='3[37m'
        darkgrey='3[90m'
        lightred='3[91m'
        lightgreen='3[92m'
        yellow='3[93m'
        lightblue='3[94m'
        pink='3[95m'
        lightcyan='3[96m'
    class bg:
        black='3[40m'
        red='3[41m'
        green='3[42m'
        orange='3[43m'
        blue='3[44m'
        purple='3[45m'
        cyan='3[46m'
        lightgrey='3[47m'

essayez ce code simple

def prRed(prt): print("3[91m {}3[00m" .format(prt))
def prGreen(prt): print("3[92m {}3[00m" .format(prt))
def prYellow(prt): print("3[93m {}3[00m" .format(prt))
def prLightPurple(prt): print("3[94m {}3[00m" .format(prt))
def prPurple(prt): print("3[95m {}3[00m" .format(prt))
def prCyan(prt): print("3[96m {}3[00m" .format(prt))
def prLightGray(prt): print("3[97m {}3[00m" .format(prt))
def prBlack(prt): print("3[98m {}3[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 plus) pour accéder à L'API Win32.

pour voir le code complet qui supporte les deux sens, voir le code de rapport de console de couleur de Testoob .

ctypes exemple:

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)

stupidement simple basé sur la réponse de @joeld

class PrintInColor:
    RED = '3[91m'
    GREEN = '3[92m'
    YELLOW = '3[93m'
    LIGHT_PURPLE = '3[94m'
    PURPLE = '3[95m'
    END = '3[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)

puis juste

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

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

fichier: log.py

HEADER = '3[95m'
OKBLUE = '3[94m'
OKGREEN = '3[92m'
WARNING = '3[93m'
FAIL = '3[91m'
ENDC = '3[0m'
BOLD = "3[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")

en S'appuyant sur la réponse de @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_print avec de nouveaux formats, 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 blinking et strikethrough ne peuvent pas travailler sur tous les terminaux, ne fonctionne pas sur Mac / Ubuntu.

E. G.

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

Pour Windows, vous ne pouvez pas imprimer sur console avec des couleurs à moins d'utiliser le win32api.

Pour Linux c'est aussi simple que d'utiliser l'impression, 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 de La Livre fonctionne bien, mais il dépend de la police:

#

notez comment le mot-clé with 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")

j'ai fini par faire ceci, j'ai senti que c'était plus propre:

formatters = {             
    'RED': '3[91m',     
    'GREEN': '3[92m',   
    'END': '3[0m',      
}

print 'Master is currently {RED}red{END}!'.format(**formatters)
print 'Help make master {GREEN}green{END} again!'.format(**formatters)

sty est similaire à colorama, mais il est moins verbeux, soutient 8bit et 24bit (rgb) couleurs, vous permet d'enregistrer vos propres couleurs, est vraiment souple et bien documenté. Si vous ne vous souciez pas de la compatibilité avec les émulateurs de terminaux qui sont coincés dans le 90e et aiment à utiliser de nouvelles fonctionnalités, vous pourriez vouloir lui donner un essai.

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

imprime:

Démo:

vous pouvez utiliser CLINT:

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

Obtenir à partir de GitHub .

vous pouvez utiliser L'implémentation Python de la bibliothèque des malédictions: http://docs.python.org/library/curses.html

aussi, Lancez ceci et vous trouverez votre boîte:

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

si vous programmez un jeu peut-être que vous aimeriez changer la couleur de fond et n'utiliser que des espaces? Par exemple:

print " "+ "3[01;41m" + " " +"3[01;46m"  + "  " + "3[01;42m"

asciimatics fournit un support portable pour L'UI de texte de construction et les 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 enveloppe la fonction d'impression python 3:

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

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

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.

voici un exemple de malédiction:

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)

YAY! une autre version

alors que je trouve cette réponse utile, je l'ai un peu modifiée. ce Github Gist est le résultat

utilisation

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

en outre, vous pouvez envelopper les usages communs:

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 "3[%sm%s3[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')

si vous utilisez Windows, Alors voilà!

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

snapshot:

(j'utilise généralement la sortie colorée pour déboguer sur le terminal runserver donc je l'ai ajouté.)

<sub>Vous pouvez tester si elle est installée dans votre machine:

$ python -c "import django; print django.VERSION"

Pour l'installer, vérifier: comment installer Django</sub>

essayez!!

une option plus facile serait d'utiliser la fonction cprint du paquet termcolor .

il supporte aussi %s, %d format d'impression

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

fg = lambda text, color: "[38;5;" + str(color) + "m" + text + "[0m"
bg = lambda text, color: "[48;5;" + str(color) + "m" + text + "[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()

pour les caractères

votre terminal utilise très probablement des caractères Unicode (typiquement encodés UTF-8), il ne s'agit donc que de la sélection de police appropriée pour voir votre caractère préféré. Char Unicode U+2588, "pâté" est celle que je vous suggère de l'utiliser.

essayez ce qui suit:

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

examinez le fichier plus tard avec votre visionneuse préférée.

pour les couleurs

malédictions est le module que vous voulez utiliser. Cochez cette case tutoriel .