print letra con como colores colored color codigo change cambiar python unicode terminal ansi-colors

python - letra - ¿Imprimir en terminal con colores?



print color python windows (30)

¡HURRA! otra version

Si bien this respuesta me parece útil, la modifiqué un poco. Este Github Gist es el resultado.

uso

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

Además puedes envolver usos comunes:

print colors.error(''sorry, '')

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

¿Cómo puedo enviar texto coloreado al terminal, en Python? ¿Cuál es el mejor símbolo Unicode para representar un bloque sólido?

Para los personajes

Lo más probable es que su terminal utilice caracteres Unicode (generalmente codificados en UTF-8), por lo que es solo una cuestión de la selección de fuente apropiada para ver su carácter favorito. Unicode char U + 2588, "Bloque completo" es el que te sugiero que uses.

Intenta lo siguiente:

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

Examine el archivo más tarde con su visor favorito.

Por los colores

curses es el modulo que quieres usar. Revisa este tutorial .

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

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

Aquí hay un ejemplo de maldiciones:

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)

Defina una cadena que comience con un color y una cadena que termine con el color, luego imprima el texto con la cadena inicial al principio 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 , en urxvt con una combinación de colores de estilo Zenburn:

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

Nota: /33[5m y /33[6m están parpadeando.

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

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

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

HEADER = ''/033[95m'' OKBLUE = ''/033[94m'' OKGREEN = ''/033[92m'' WARNING = ''/033[93m'' FAIL = ''/033[91m'' ENDC = ''/033[0m'' BOLD = "/033[1m" def disable(): HEADER = '''' OKBLUE = '''' OKGREEN = '''' WARNING = '''' FAIL = '''' ENDC = '''' def infog( msg): print OKGREEN + msg + ENDC def info( msg): print OKBLUE + msg + ENDC def warn( msg): print WARNING + msg + ENDC def err( msg): print FAIL + msg + ENDC

utilizar de la siguiente manera:

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

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

Esto depende un poco de la plataforma en la que estés. La forma más común de hacerlo es mediante la impresión de secuencias de escape ANSI. Para un ejemplo simple, aquí hay algo de código python de los scripts de compilación 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''

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

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

Esto funcionará en Unixes, incluyendo 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 estás si estás escribiendo un juego), deberías mirar en el módulo "curses", que maneja muchas de las partes complicadas de esto para ti. 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 está utilizando un conjunto 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 de PC clásica. Puede encontrar algunos de estos mapas de bits que puede utilizar en la wiki de Dwarf Fortress (conjuntos de datos hechos por el usuario ).

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

Hmm ... creo que me dejé llevar por esta respuesta. Sin embargo, estoy en medio de la planificación de un épico juego de aventuras basado en texto. Buena suerte con tu texto en color!

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

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

Obtenga una tabla de opciones de formato para texto de 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 en la oscuridad (completo)

Ejemplo de oscuridad en la luz (parcial)

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

Una captura de pantalla de ejemplo de Python 3.6:

Me sorprende que nadie haya mencionado 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 desea hacer ...

Mi forma favorita es con la biblioteca de Blessings (divulgación completa: la 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. Utilizo 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 muck con otras capacidades de terminal en el curso de su juego, puede hacerlo también. 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 por funcionar en todo tipo de terminales, no solo en los de color ANSI (abrumadoramente comunes). También mantiene secuencias de escape ilegibles fuera de su código y al mismo tiempo es conciso de usar. ¡Que te diviertas!

Otro módulo pypi que envuelve la función de impresión de python 3:

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

Se puede usar en Python 2.x si también from __future__ import print . Aquí hay un ejemplo de python 2 de la página de módulos pypi:

from __future__ import print_function from colorprint import * print(''Hello'', ''world'', color=''blue'', end='''', sep='', '') print(''!'', color=''red'', format=[''bold'', ''blink''])

Salidas "¡Hola mundo!" con las palabras en azul y el signo de exclamación en rojo y parpadeante.

Para Windows, no puede imprimir en la consola con colores a menos que esté usando win32api.

Para Linux es tan simple como usar la impresión, con las secuencias de escape descritas aquí:

Colors

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:

#

Podrías usar CLINT:

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

Obtenlo de GitHub .

Prueba este código 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")

Quieres aprender acerca de las secuencias de escape ANSI. Aquí hay un breve ejemplo:

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

Para obtener más información, visite http://en.wikipedia.org/wiki/ANSI_escape_code

Para un carácter de bloque, intente un carácter Unicode como / u2588:

print u"/u2588"

Poniendolo todo junto:

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

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

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

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

instantánea:

(Por lo general, uso la salida de color para la depuración en el terminal de servidor de ejecución, así que la agregué).

Puedes probar si está instalado en tu máquina:
$ python -c "import django; print django.VERSION"
Para instalarlo compruebe: Cómo instalar Django.

¡¡Darle una oportunidad!!

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:

Algunas actualizaciones de color_print con 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: la italic , fast blinking y el strikethrough pueden no funcionar en todos los terminales, no funciona en Mac / 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:

Terminé haciendo esto, sentí que estaba 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)

Una opción más fácil sería usar la función termcolor paquete termcolor .

También soporta %s, %d formato de impresión.

generó una clase con todos los colores usando un bucle for para iterar cada combinación de color hasta 100, luego escribió una clase con colores de pitón. Copia y pega como quieras, GPLv2 por mi:

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

observe qué tan bien se combinan las palabras 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")

asciimatics proporciona un soporte portátil para crear IU de texto y animaciones:

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

sty es similar a colorama, pero es menos detallado, admite colores de 8 24bit y 24bit (rgb), le permite registrar sus propios colores, es realmente flexible y está bien documentado. Si no le importa la compatibilidad con los emuladores de terminal que se atascan en la 90 y le gustaría usar nuevas funciones, puede intentarlo.

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

huellas dactilares:

Manifestación:

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

# Pure Python 3.x demo, 256 colors # Works with bash under Linux fg = lambda text, color: "/33[38;5;" + str(color) + "m" + text + "/33[0m" bg = lambda text, color: "/33[48;5;" + str(color) + "m" + text + "/33[0m" def print_six(row, format): for col in range(6): color = row*6 + col + 4 if color>=0: text = "{:3d}".format(color) print (format(text,color), end=" ") else: print(" ", end=" ") for row in range(-1,42): print_six(row, fg) print("",end=" ") print_six(row, bg) print()