¿Cómo puedo enviar texto en color a la terminal en Python?

respuesta

Esto depende un poco de la plataforma en la que se encuentre. La forma más común de hacer esto es imprimiendo secuencias de escape ANSI. Para un ejemplo simple, aquí hay algo de código de Python de los scripts de compilación de Blender :

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

Para usar un código como este, puedes hacer algo como:

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

O, con Python 3.6+:

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

Esto funcionará en Unixes, incluidos OS X, Linux y Windows (siempre que use ANSICON , o en Windows 10, siempre que habilite la emulación VT100 ). Hay códigos ANSI para configurar el color, mover el cursor y más.

Si te vas a complicar con esto (y parece que lo vas a hacer si estás escribiendo un juego), deberías buscar en el módulo " curses ", que maneja muchas de las partes complicadas de esto por ti. El Python Curses HowTO es una buena introducción.

Si no está utilizando ASCII extendido (es decir, no en una PC), está atascado con los caracteres ASCII por debajo de 127, y '#' o '@' es probablemente su mejor apuesta para un bloque. Si puede asegurarse de que su terminal utiliza un juego de caracteres ASCII extendido de IBM , tiene muchas más opciones. Los caracteres 176, 177, 178 y 219 son los "caracteres de bloque".

Algunos programas modernos basados ​​en texto, como "Dwarf Fortress", emulan el modo de texto en un modo gráfico y usan imágenes de la fuente clásica de PC. Puede encontrar algunos de estos mapas de bits que puede usar en Dwarf Fortress Wiki ver ( conjuntos de mosaicos hechos por el usuario ).

El concurso de demostración en modo texto tiene más recursos para hacer gráficos en modo texto.

También está el módulo termcolor de Python . El uso es bastante simple:

from termcolor import colored

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

O en Python 3:

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

Sin embargo, puede que no sea lo suficientemente sofisticado para la programación de juegos y los "bloques de colores" que quieres hacer...

Para que los códigos ANSI funcionen en Windows, primero ejecute

os.system('color')

La respuesta es Colorama para todos los colores multiplataforma en Python.

Es compatible con Python 3.5+, así como con Python 2.7.

Y a partir de enero de 2021 se mantiene.

Captura de pantalla de ejemplo: captura de pantalla de ejemplo

Imprima una cadena que comience con un color/estilo, luego la cadena y luego finalice el cambio de color/estilo con '\x1b[0m':

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

Ejemplo de éxito con fondo verde

Obtenga una tabla de opciones de formato para el texto del shell con el siguiente 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()

Ejemplo de luz sobre oscuridad (completo)

Ingrese la descripción de la imagen aquí

Ejemplo de oscuridad sobre luz (parcial)

Parte superior de la salida

Defina una cadena que comience con un color y una cadena que termine con el color. Luego imprima su texto con la cadena inicial al frente y la cadena final al final.

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

Esto produce lo siguiente en Bash, urxvtcon un esquema de color estilo Zenburn:

Colores de salida

A través de la experimentación, podemos obtener más colores:

Matriz de colores

Nota: \33[5my \33[6mparpadean.

De esta manera podemos crear una colección a todo color:

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'

Aquí está el código para generar la prueba:

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

Aquí hay una solución que funciona en Windows 10 de forma nativa.

El uso de una llamada al sistema, como os.system(""), permite que los colores se impriman en el Símbolo del sistema y Powershell de forma nativa:

import os

# System call
os.system("")

# Class of 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: Windows no es totalmente compatible con los códigos ANSI, ya sea a través de llamadas al sistema o módulos. No se admite toda la decoración de texto y, aunque se muestran colores brillantes, son idénticos a los colores normales.

Gracias a @jl por encontrar un método aún más corto.

tl;dr : Añadiros.system("")

Quiere aprender sobre las secuencias de escape ANSI. He aquí un breve ejemplo:

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

Para obtener más información, consulte Código de escape ANSI .

Para un carácter de bloque, pruebe con un carácter Unicode como \u2588:

print(u"\u2588")

Poniendolo todo junto:

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

sty es similar a colorama, pero es menos detallado, admite colores de 8 y 24 bits (RGB), admite todos los efectos (negrita, subrayado, etc.), le permite registrar sus propios estilos , está completamente escrito y tiene un alto rendimiento , admite silenciar , no interfiere con globales como sys.stdout, es realmente flexible, está bien documentado y más...

Ejemplos:

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

huellas dactilares:

Ingrese la descripción de la imagen aquí

Manifestación:

Ingrese la descripción de la imagen aquí

Rich es una biblioteca de Python relativamente nueva para trabajar con color en la terminal.

Hay algunas formas de trabajar con color en Rich. La forma más rápida de comenzar sería el método de impresión enriquecido que representa una sintaxis similar a BBCode en códigos de control ANSI:

from rich import print
print("[red]Color[/] in the [bold magenta]Terminal[/]!")

Hay otras formas de aplicar color con Rich (regex, sintaxis) y funciones de formato relacionadas.

Captura de pantalla de Rich

Mi forma favorita es con la biblioteca Bendiciones (divulgación completa: lo escribí). Por ejemplo:

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 ladrillos de colores, la forma más confiable es imprimir espacios con colores de fondo. Uso esta técnica para dibujar la barra de progreso en nose-progressive :

print t.on_green(' ')

También puede imprimir en ubicaciones específicas:

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

Si tiene que jugar con otras capacidades de la terminal en el transcurso de su juego, también puede hacerlo. Puede usar el formato de cadena estándar de Python para mantenerlo legible:

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

Lo bueno de Blessings es que hace todo lo posible para funcionar en todo tipo de terminales, no solo en los (abrumadoramente comunes) de color ANSI. También mantiene las secuencias de escape ilegibles fuera de su código sin dejar de ser conciso de usar. ¡Diviértete!

Generé una clase con todos los colores usando un forciclo para iterar cada combinación de color hasta 100 y luego escribí una clase con colores de Python. Copia y pega como quieras, GPLv2 por mí:

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'

Prueba este sencillo código

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

Tengo una biblioteca llamada colorit . Es súper simple.

Aquí hay unos ejemplos:

from colorit import *

# Use this to ensure that ColorIt will be usable by certain command line interfaces
# Note: This clears the terminal
init_colorit()

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

# If you are using Windows Command Line, this is so that it doesn't close immediately
input()

Esto te da:

Imagen de ColorIt

También vale la pena señalar que esto es multiplataforma y ha sido probado en Mac, Linux y Windows.

Es posible que desee probarlo: https://github.com/SuperMaZingCoder/colorit

coloritya está disponible para ser instalado con PyPi! Puede instalarlo pip install color-iten Windows y pip3 install color-iten macOS y Linux.

Este es, en mi opinión, el método más fácil. Siempre que tenga los valores RGB del color que desea, esto debería funcionar:

def colored(r, g, b, text):
    return f"\033[38;2;{r};{g};{b}m{text}\033[38;2;255;255;255m"

Un ejemplo de impresión de texto rojo:

text = 'Hello, World!'
colored_text = colored(255, 0, 0, text)
print(colored_text)

#or

print(colored(255, 0, 0, 'Hello, World!'))

Texto multicolor

text = colored(255, 0, 0, 'Hello, ') + colored(0, 255, 0, 'World')
print(text)

En Windows, puede usar el módulo 'win32console' (disponible en algunas distribuciones de Python) o el módulo 'ctypes' (Python 2.5 y superior) para acceder a la API de Win32.

Para ver el código completo que admite ambas formas, consulte el código de informe de la consola de color de Testoob .

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

Texto con cambio de primer plano y fondo, colores 0..141 Texto con cambio de primer plano y fondo, colores 142..255

Pruébelo en línea

Envolví la respuesta de joeld en un módulo con funciones globales que puedo usar en cualquier parte de mi código.

Archivo: log.py

def enable():
    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)

enable()

Utilizar de la siguiente manera:

import log
log.info("Hello, World!")
log.err("System Error")
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")

Prueba en línea

Para Windows, no puede imprimir en la consola con colores a menos que esté utilizando la API de Win32 .

Para Linux es tan simple como imprimir, con las secuencias de escape descritas aquí:

Colores

Para que el carácter se imprima como un cuadro, realmente depende de la fuente que esté utilizando para la ventana de la consola. El símbolo de libra funciona bien, pero depende de la fuente:

#

Terminé haciendo esto, y sentí que era lo más limpio:

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)

Estúpidamente simple, basado en la respuesta 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)

entonces solo

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

Aquí está mi solución moderna (2021): yachalk

Es una de las pocas bibliotecas que admite correctamente estilos anidados:

ingrese la descripción de la imagen aquí

Aparte de eso, yachalk es fácil de completar automáticamente, tiene soporte para 256/truecolor, viene con detección de capacidad de terminal y está completamente tipeado.

Aquí hay algunas decisiones de diseño que puede considerar para elegir su solución.

¿Bibliotecas de alto nivel frente a bibliotecas de bajo nivel/manejo manual de estilos?

Muchas respuestas a esta pregunta demuestran cómo escapar códigos ANSI directamente, o sugieren bibliotecas de bajo nivel que requieren activación/desactivación de estilo manual.

Estos enfoques tienen problemas sutiles: Insertar estilos activados/desactivados manualmente es

  • más detallado sintácticamente, porque los restablecimientos deben especificarse explícitamente,
  • más propenso a errores, porque puede olvidar accidentalmente restablecer un estilo,
  • no logra corregir los casos extremos: por ejemplo, en algunos terminales es necesario restablecer los estilos antes de las nuevas líneas y reactivarlos después del salto de línea. Además, algunos terminales tienen problemas con la simple anulación de estilos mutuamente excluyentes y requieren la inserción de códigos de reinicio "innecesarios". Si la terminal local de un desarrollador no tiene estas peculiaridades, el desarrollador no las descubrirá de inmediato. El problema solo será informado más tarde por otros o causará problemas, por ejemplo, en terminales CI.

Por lo tanto, si la compatibilidad con muchos terminales es un objetivo, es mejor usar una biblioteca de alto nivel que ofrezca un manejo automático de restablecimientos de estilo. Esto permite que la biblioteca se ocupe de todos los casos extremos al insertar los códigos de escape ANSI "falsos" donde sea necesario.

¿Por qué otra biblioteca más?

En JavaScript, la biblioteca estándar de facto para la tarea es chalk , y después de usarla durante un tiempo en proyectos de JS, las soluciones disponibles en el mundo de Python carecían de comparación. La API de chalk no solo es más conveniente de usar (totalmente compatible con autocompletar), sino que también acierta en todos los casos extremos.

La idea de yachalk es brindar la misma comodidad al ecosistema de Python. Si está interesado en una comparación con otras bibliotecas, comencé la comparación de características en la página de proyectos. Además, aquí hay una lista larga (pero aún incompleta) de alternativas que surgieron durante mi investigación, muchas para elegir :)

Sobre la base de la respuesta 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

Captura de pantalla:

Ingrese la descripción de la imagen aquí


Algunas actualizaciones color_printcon nuevos formateadores, por ejemplo:

>>> 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: es posible que italic, fast blinkingy strikethroughno funcionen en todos los terminales, y no funcionan en Mac y Ubuntu.

P.ej,

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

Ingrese la descripción de la imagen aquí

Tenga en cuenta lo bien que withse mezcla la palabra clave con modificadores como estos que deben restablecerse (usando Python 3 y 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")

Podrías usar a Clint :

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

Puede usar la implementación de Python de la biblioteca curses : curses — Manejo de terminales para visualizaciones de celdas de caracteres

Además, ejecuta esto y encontrarás tu caja:

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

Si estás programando un juego, ¿quizás te gustaría cambiar el color de fondo y usar solo espacios? Por ejemplo:

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

Una opción más fácil sería usar la cprintfunción del termcolorpaquete.

color-print-python

También admite %s, %dformato de impresión:

Ingrese la descripción de la imagen aquí

Los resultados pueden depender del terminal, así que revise la sección Propiedades del terminal de la documentación del paquete.

  • El símbolo del sistema de Windows y Python IDLE no funcionan

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

  • El cuaderno JupyterLab funciona

ingrese la descripción de la imagen aquí

Si estás usando Windows, ¡aquí tienes!

# Display text on a Windows console
# Windows XP with Python 2.7 or Python 3.2
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 ... ")

¡HURRA! Otra version

Si bien encuentro útil esta respuesta , la modifiqué un poco. Este GitHub Gist es el resultado

Uso

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

Ingrese la descripción de la imagen aquí

Además, puede envolver usos comunes:

print colors.error('sorry, ')

asd

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