Imprimer en terminal avec des couleurs?
Comment puis-je envoyer du texte coloré au terminal, en Python? Quel est le meilleur symbole Unicode pour représenter un bloc solide?
Cela dépend un peu de la plateforme sur laquelle vous vous trouvez. La méthode la plus courante consiste à imprimer des séquences d'échappement ANSI. Pour un exemple simple, voici un code python des scripts de compilation 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
Cela fonctionnera sur les unix, y compris OS X, Linux et Windows (à condition que vous utilisiez ANSICON , ou sous Windows 10 à condition que vous activiez émulation VT100 ). Il existe des codes ansi pour définir la couleur, déplacer le curseur, etc.
Si vous devenez compliqué avec cela (et vous avez l’impression de le faire si vous écrivez un jeu), vous devriez vous pencher sur le module «malédictions», qui gère pour vous de nombreuses parties compliquées. Le Python Curses HowTO est une bonne introduction.
Si vous n’utilisez pas ASCII étendu (c’est-à-dire pas sur un PC), vous êtes bloqué avec les caractères ascii inférieurs à 127, et "#" ou "@" est probablement votre meilleur choix pour un bloc. Si vous pouvez vous assurer que votre terminal utilise un IBM jeu de caractères étendu , vous disposez de beaucoup plus d'options. Les caractères 176, 177, 178 et 219 sont les "caractères de bloc".
Certains programmes modernes à base de texte, tels que "Dwarf Fortress", émulent le mode texte en mode graphique et utilisent des images de la police de caractères classique pour PC. Vous pouvez trouver certaines de ces bitmaps que vous pouvez utiliser sur le Wiki de la Forteresse naine voir ( ensembles de carreaux créés par l'utilisateur ).
Le concours de démonstration en mode texte dispose de plus de ressources pour créer des graphiques en mode texte.
Hmm .. Je pense me suis un peu emporté sur cette réponse. Je suis cependant en train de planifier un jeu d'aventure épique à base de texte. Bonne chance avec votre 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 multi-plateformes en Python.
Un exemple de capture d’écran Python 3.6: 
Imprimez une chaîne qui commence une couleur/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 l'obscurité (complet)
Dark-on-light exemple (partielle)
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, dans urxvt avec un jeu de couleurs de style Zenburn:
Grâce à experemintation, nous pouvons obtenir plus de couleurs:
Remarque: \33[5m et \33[6m clignotent.
De cette façon, nous pouvons créer une collection de couleurs:
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"
Ma méthode préférée est 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 de couleur, 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 dans nez-progressif :
print t.on_green(' ')
Vous pouvez également imprimer dans des endroits spécifiques:
with t.location(0, 5):
print t.on_yellow(' ')
Si vous devez utiliser d'autres capacités de terminal au cours de votre partie, 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)
Le truc sympa à propos de Blessings est qu’il fait de son mieux pour travailler sur toutes sortes de terminaux, pas seulement ceux (d’une manière très répandue) couleur ANSI. Il conserve également les séquences d'échappement illisibles hors de votre code tout en restant concis à utiliser. S'amuser!
généré une classe avec toutes les couleurs en utilisant une boucle for pour itérer chaque combinaison de couleur jusqu'à 100, puis é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")
sty est similaire à colorama, mais il est moins bavard, prend en charge les couleurs 8 bits et 24 bits (rgb), vous permet d’enregistrer vos propres couleurs, est vraiment flexible et bien documenté.
from sty import fg, bg, ef, rs, RgbFg
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.set_style('orange', RgbFg(255, 150, 50))
buf = fg.orange + 'Yay, Im orange.' + fg.rs
print(foo, bar, baz, qux, qui, buf, sep='\n')
impressions:
Démo: 
Sous Windows, vous pouvez utiliser le module 'win32console' (disponible dans certaines distributions Python) ou le module 'ctypes' (Python 2.5 et versions supérieures) pour accéder à l'API Win32.
Pour voir le code complet qui prend en charge les deux méthodes, voir le code de rapport de la console color Console de Testoob .
exemple de types:
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 d'après 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 intégré @joeld answer 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")
En s'appuyant sur @joeld answer, utilisez https://pypi.python.org/pypi/lazymepip 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:
Certaines mises à jour du color_print avec 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']
Remarque: italic, fast blinking et strikethrough peuvent ne pas fonctionner sur tous les terminaux, ne fonctionnent 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:
Pour Windows, vous ne pouvez pas imprimer sur la 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:
Pour que le personnage 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:
#
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)
Vous pouvez utiliser l'implémentation Python de la bibliothèque curses: http://docs.python.org/library/curses.html
En outre, lancez 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!')
notez à quel point le mot clé with se mélange avec des modificateurs tels que ceux-ci qui doivent être réinitialisés (à l'aide de 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")
Si vous programmez un jeu, vous voudrez peut-être changer la couleur de fond et utiliser uniquement des espaces? Par exemple:
print " "+ "\033[01;41m" + " " +"\033[01;46m" + " " + "\033[01;42m"
asciimatics fournit un support portable pour la création d’UI et d’animations de texte:
#!/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:
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 __== '__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')
Encore un autre module pypi qui englobe la fonction d’impression de python 3:
https://pypi.python.org/pypi/colorprint
Il est utilisable dans Python 2.x si vous aussi from __future__ import print. Voici un exemple de python 2 tiré de la page de 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, le monde!" avec les mots en bleu et le point d'exclamation rouge vif et clignotant.
Si vous utilisez Windows, alors vous y êtes!
# 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 ... ")
YAY! une autre version
bien que je trouve ce réponse utile, je l'ai modifié un peu. this Github Gist est le résultat
usage
print colors.draw("i'm yellow", bold=True, fg_yellow=True)
en plus, vous pouvez envelopper les usages courants:
print colors.error('sorry, ')
https://Gist.github.com/Jossef/0ee20314577925b4027f
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 serveur d'exécution, alors je l'ai ajouté.)
Vous pouvez tester s’il est installé sur votre ordinateur: $ python -c "import Django; print Django.VERSION"
Pour l’installer, vérifiez: Comment installer Django
Essaie!!
Une option plus simple consisterait à utiliser la fonction cprint du package termcolor.
Il supporte également le format d'impression %s, %d
Je réponds parce que j'ai trouvé un moyen d'utiliser des codes ANSI sur Windows pour pouvoir changer la couleur du texte sans aucun module:
La ligne qui rend ce travail est os.system('color'), mais pour vous assurer de ne pas générer d'erreurs si la personne n'est pas sous Windows, utilisez ce script:
import os, sys
if sys.platform.lower() == "win32":
os.system('color')
# Group of Different functions for different styles
class style():
BLACK = lambda x: '\033[30m' + str(x)
RED = lambda x: '\033[31m' + str(x)
GREEN = lambda x: '\033[32m' + str(x)
YELLOW = lambda x: '\033[33m' + str(x)
BLUE = lambda x: '\033[34m' + str(x)
Magenta = lambda x: '\033[35m' + str(x)
CYAN = lambda x: '\033[36m' + str(x)
WHITE = lambda x: '\033[37m' + str(x)
UNDERLINE = lambda x: '\033[4m' + str(x)
RESET = lambda x: '\033[0m' + str(x)
print(style.YELLOW("Hello, ") + style.RESET("World!"))
Version Python: 3.6.7 (32 bits)
# 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()
J'ai écrit un module qui gère les couleurs sous Linux/OSX/Windows. Il prend en charge les 16 couleurs sur toutes les plates-formes. Vous pouvez définir des couleurs d’avant-plan et d’arrière-plan à des moments différents. Les objets chaîne donnent des résultats sains pour des éléments tels que len () et .capitalize ().
https://github.com/Robpol86/colorclass
Pour les personnages
Votre terminal utilise très probablement des caractères Unicode (généralement codés en UTF-8), il ne vous reste donc plus qu'à choisir la police appropriée pour voir votre personnage préféré. Le caractère Unicode U + 2588, "Bloc complet" est celui que je vous suggère d'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 ultérieurement avec votre lecteur préféré.
Pour les couleurs
curses est le module que vous souhaitez utiliser. Vérifiez ce tutorial .
Utilisez pyfancy c'est un moyen simple de faire de la couleur dans le terminal!
Exemple:
print(pyfancy.RED + "Hello Red" + pyfancy.END)
J'ai écrit un module simple, disponible à l'adresse suivante: http://pypi.python.org/pypi/colorconsole
Il fonctionne avec Windows, Mac OS X et Linux . Il utilise ANSI pour Linux et Mac, mais les appels natifs aux fonctions de console sous Windows . Vous avez les couleurs, le positionnement du curseur et l'entrée au clavier. Il ne remplace pas les malédictions, mais peut s'avérer très utile si vous devez utiliser des scripts simples ou des jeux ASCII.
Vous pouvez utiliser des caractères d'échappement Shell, disponibles dans n'importe quelle langue . Ces caractères d'échappement commencent par le caractère ESC suivi d'un certain nombre d'arguments.
Par exemple, pour générer une chaîne Hello world rouge dans votre terminal:
echo "\e[31m Hello world \e[0m"
Ou à partir d'un script python:
print("\e[31m Hello world \e[0m")
De plus, j’ai écrit un article sur Séquences d’échappement qui peut probablement vous aider à mieux comprendre ce mécanisme. J'espère que cela vous aidera.
Pour résoudre ce problème, j'ai créé un paquet simple et impressionnant pour imprimer des chaînes avec des codes de couleurs interpolés, appelé icolor .
icolor inclut deux fonctions: cformat et cprint, chacune d’elles prenant une chaîne avec des sous-chaînes interpolées pour correspondre à des séquences d’échappement ANSI, par ex.
from icolor import cformat # there is also cprint
cformat("This is #RED;a red string, partially with a #xBLUE;blue background")
'This is \x1b[31ma red string, partially with a \x1b[44mblue background\x1b[0m'
Toutes les couleurs ANSI sont incluses (par exemple, #RED;, #BLUE;, etc.), ainsi que #RESET;, #BOLD; et autres.
Les couleurs de fond ont un préfixe x, ainsi un fond vert serait #xGREEN;.
On peut échapper à # avec ##.
Compte tenu de sa simplicité, la meilleure documentation est probablement le code lui-même .
C'est sur PYPI , donc on peut Sudo easy_install icolor.
Je suis noob en python et je suis excité à chaque fois que je découvre des sujets comme celui-ci. Mais cette fois (soudainement), j'ai l'impression d'avoir quoi dire. Surtout parce qu'il y a quelques minutes, j'ai découvert un truc WOW en python (du moins pour moi maintenant):
from contextlib import contextmanager
# FORECOLOR
BLACKFC,REDFC,GREENFC,YELLOWFC,BLUEFC = '38;30m','38;31m','38;32m','38;33m','38;34m'
# BACKGOUND
BLACKBG,REDBG,GREENBG,YELLOWBG,BLUEBG = '48;40m','48;41m','48;42m','48;43m','48;44m'
@contextmanager
def printESC(prefix, color, text):
print("{prefix}{color}{text}".format(prefix=prefix, color=color, text=text), end='')
yield
print("{prefix}0m".format(prefix=prefix))
with printESC('\x1B[', REDFC, 'Colored Text'):
pass
ou juste comme ça:
# FORECOLOR
BLACKFC,REDFC,GREENFC,YELLOWFC,BLUEFC = '38;30m','38;31m','38;32m','38;33m','38;34m'
# BACKGOUND
BLACKBG,REDBG,GREENBG,YELLOWBG,BLUEBG = '48;40m','48;41m','48;42m','48;43m','48;44m'
def printESC(prefix, color, text):
print("{prefix}{color}{text}".format(prefix=prefix, color=color, text=text), end='')
print("{prefix}0m".format(prefix=prefix))
printESC('\x1B[', REDFC, 'Colored Text')
Mes deux cents ( PyColorTerm ):
Installation:
Sudo apt-get install python-pip
pip install pycolorterm
Script Python:
from pycolorterm import pycolorterm
with pycolorterm.pretty_output(pycolorterm.FG_GREEN) as out:
out.write('Works OK!')
"fonctionne bien!" montre en vert.