Como imprimir texto colorido no terminal em Python?

2130

Como posso produzir texto colorido para o terminal, em Python? Qual é o melhor símbolo Unicode para representar um bloco sólido?

aboSamoor
fonte
6
Você deve especificar algumas informações adicionais para obter melhores respostas: multiplataforma? são aceitos módulos externos?
Sorin
2
IPython faz isso, multiplataforma. Vê o que eles usam?
endolith
Este símbolo faria um grande bloco colorido: O único problema é que ele é ASCII estendida, talvez você poderia fazê-lo funcionar usandohttp://stackoverflow.com/questions/8465226/using-extended-ascii-codes-with-python
Samy Bencherif
Alguns terminais também podem exibir caracteres Unicode. Se isso é verdade para o seu terminal, os caracteres possíveis são quase ilimitados.
ayke
4
Esta resposta chegou bastante tarde, mas parece ser a melhor para mim ... as votadas acima exigem hacks especiais para Windows, enquanto essa funciona: stackoverflow.com/a/3332860/901641
ArtOfWarfare

Respostas:

1835

Isso depende um pouco da plataforma em que você está. A maneira mais comum de fazer isso é imprimindo seqüências de escape ANSI. Para um exemplo simples, aqui está um código python dos scripts de compilação do 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, você pode fazer algo como

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

ou, com Python3.6 +:

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

Isso funcionará em unixes, incluindo OS X, linux e windows (desde que você use o ANSICON ou no Windows 10, desde que você ative a emulação VT100 ). Existem códigos ansi para definir a cor, mover o cursor e muito mais.

Se você vai se complicar com isso (e parece que você está escrevendo um jogo), deve procurar o módulo "maldições", que lida com muitas das partes complicadas disso para você. O Python Curses HowTO é uma boa introdução.

Se você não estiver usando ASCII estendido (ou seja, não estiver em um PC), ficará com os caracteres ascii abaixo de 127 e '#' ou '@' provavelmente é sua melhor aposta para um bloco. Se você pode garantir que seu terminal esteja usando um conjunto de caracteres estendidos ascii da IBM , você terá muito mais opções. Os caracteres 176, 177, 178 e 219 são os "caracteres de bloco".

Alguns programas modernos baseados em texto, como o "Dwarf Fortress", emulam o modo de texto em modo gráfico e usam imagens da fonte clássica do PC. Você pode encontrar alguns desses bitmaps que podem ser usados ​​no Wiki do Dwarf Fortress (veja conjuntos de peças feitas pelo usuário ).

O Concurso de demonstração do modo de texto tem mais recursos para criar gráficos no modo de texto.

Hum ... acho que fiquei um pouco empolgado com essa resposta. No entanto, estou planejando um jogo épico de aventura baseado em texto. Boa sorte com o seu texto colorido!

joeld
fonte
Mas suponha que meu prompt padrão não seja preto - você acha que é possível fazer o python voltar a funcionar após esses truques?
Adobe
4
No Linux, você pode querer usar tput, como assim , uma vez que resulta em código mais portátil.
Martin Ueding 03/11/12
3
@Cawas: Um caso de uso real disableé quando você canaliza a saída para um arquivo; embora ferramentas como catpossam suportar cores, geralmente é melhor não imprimir informações sobre cores em arquivos.
Sebastian Mach
1
@AlexanderSimko, aqui está um trecho de código ctypes para ativar o suporte VT100 no Windows 10: import ctypes; kernel32 = ctypes.WinDLL('kernel32'); hStdOut = kernel32.GetStdHandle(-11); mode = ctypes.c_ulong(); kernel32.GetConsoleMode(hStdOut, ctypes.byref(mode)); mode.value |= 4; kernel32.SetConsoleMode(hStdOut, mode).
Eryk Sun
1
Para qualquer pessoa que use o código de exemplo Python da resposta: Note-se que as cores no intervalo 90-97 e 100-107 não são padrão e, de fato, no meu terminal, nem todas fornecem as cores indicadas pelo nomes de variáveis. É melhor usar os intervalos padrão 30-37 e 40-47. Fonte: en.wikipedia.org/wiki/…
balu
807

Estou surpreso que ninguém tenha mencionado o módulo termcolor do Python . O uso é bem simples:

from termcolor import colored

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

Ou no Python 3:

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

No entanto, pode não ser sofisticado o suficiente para a programação de jogos e os "blocos coloridos" que você deseja executar ...

Samat Jain
fonte
2
Como está emitindo códigos ANSI, ele funciona no Windows (consoles DOS) se o ansi.sys estiver carregado? support.microsoft.com/kb/101875
Phil P
37
Acabei de notar que a partir de 13/01/2011, agora está sob licença do MIT
Alexander Tsepkov 28/10
12
não tem UnitTests (Colorama ao contrário) e não atualizado desde 2011
Janus Troelsen
5
termcolor.COLORSfornece uma lista de cores
akxlr 14/11/2015
23
No Windows, execute os.system('color')primeiro, as seqüências de escape ANSI começarão a funcionar.
Szabolcs
717

A resposta é Colorama para todas as cores de plataforma cruzada no Python.

Uma captura de tela de exemplo do Python 3.6: captura de tela de exemplo

padre
fonte
317
Como autor do Colorama, obrigado pela menção @ nbv4. Vou tentar esclarecer um pouco: o Colorama visa permitir que os programas Python imprimam texto colorido do terminal em todas as plataformas, usando os mesmos códigos ANSI descritos em muitas outras respostas nesta página. No Windows, o Colorama retira esses caracteres ANSI do stdout e os converte em chamadas win32 equivalentes para texto colorido. Em outras plataformas, o Colorama não faz nada. Portanto, você pode usar códigos ANSI, ou módulos como o Termcolor, e com o Colorama, eles 'funcionam' em todas as plataformas. De qualquer maneira, é essa ideia.
Jonathan Hartley
2
@ Jonathan, esta é realmente uma biblioteca incrível! A capacidade de cruzar a saída Python em cores da plataforma é realmente muito boa e útil. Estou fornecendo ferramentas para uma biblioteca que colore seu próprio console. Posso redirecionar a saída desse console para o terminal e colorir a saída. Agora eu posso até criar uma biblioteca e deixar o usuário selecionar cores. Isso permitirá que as pessoas daltônicas definam as coisas para que funcionem, para que possam realmente ver a saída corretamente. Obrigado
Demolishun
50
Isso deve estar na biblioteca padrão ... O suporte a cores entre plataformas é importante, eu acho.
daviewales
5
Colorama é ótimo! Também ter um olhar para ansimarkup , que é construído sobre Colorama e permite que você use uma marcação baseada em tag simples (por exemplo <b>bold</b>) para adicionar estilo ao terminal de texto
gvalkov
30
Isso não funciona sem chamar colorama.init (). Vote!
amigos estão dizendo sobre sth johnth
428

Imprima uma sequência que inicie uma cor / estilo, depois a sequência e termine a alteração de cor / estilo com '\x1b[0m':

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

Sucesso com exemplo de fundo verde

Obtenha uma tabela de opções de formato para o texto do shell com o seguinte 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()

Exemplo claro-escuro (completo)

insira a descrição da imagem aqui

Exemplo de luz escura (parcial)

parte superior da saída

rabin utam
fonte
8
isso funciona na maioria das conchas, bem como ipython, bom o suficiente para a maioria das aplicações
dashesy
4
posso perguntar, qual terminal é esse?
FlipTack
4
quão portátil é?
Ruggero Turra 11/01
2
Implementação autônoma curta: gist.github.com/Sheljohn/68ca3be74139f66dbc6127784f638920
Jonathan H #
203

Defina uma sequência que inicia uma cor e uma sequência que termina a cor e imprima o texto com a sequência inicial na frente e a sequência final no final.

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

Isso produz o seguinte em bash, urxvtcom um esquema de cores no estilo Zenburn:

cores de saída

Através da experimentação, podemos obter mais cores:

matriz de cores

Nota: \33[5me \33[6mestão piscando.

Dessa forma, podemos criar uma coleção de cores:

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'

Aqui está o código para gerar o teste:

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
qubodup
fonte
2
como você fez o txt piscar
WiLL_K 7/17/17
2
Qual shell ou terminal o faz piscar?
precisa saber é o seguinte
1
(u) rxvt por exemplo
qubodup 12/06
6
O texto piscando funciona muito bem. Como eu paro isso? Todas as impressões consecutivas estão piscando por algum motivo. Meu terminal acha que é hora da festa!
capitão
3
No final da string, deve estar piscando, colocado \33[0mou CENDacima.
Stiffy2000
94

Você deseja aprender sobre seqüências de escape ANSI. Aqui está um breve exemplo:

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

Para mais informações, consulte http://en.wikipedia.org/wiki/ANSI_escape_code

Para um caractere de bloco, tente um caractere unicode como \ u2588:

print(u"\u2588")

Juntando tudo:

print(CSI+"31;40m" + u"\u2588" + CSI + "0m")
Bryan Oakley
fonte
3
Tente def d(*v): return '\x1B['+';'.join(map(str, v))+'m'entãoprint ' '.join([d(k,i)+str(i%10)+d(0) for i in range(30,38)+range(40,48) for k in range(2)])
Evgeni Sergeev
qual é o significado de redefinir aqui?
MohitC
72

Estou respondendo porque descobri uma maneira de usar códigos ANSI no Windows 10, para que você possa alterar a cor do texto sem nenhum módulo que não esteja incorporado:

A linha que faz esse trabalho é os.system("")ou qualquer outra chamada do sistema, que permite imprimir códigos ANSI no Terminal:

import os

os.system("")

# Group of Different functions for different styles
class style():
    BLACK = '\033[30m'
    RED = '\033[31m'
    GREEN = '\033[32m'
    YELLOW = '\033[33m'
    BLUE = '\033[34m'
    MAGENTA = '\033[35m'
    CYAN = '\033[36m'
    WHITE = '\033[37m'
    UNDERLINE = '\033[4m'
    RESET = '\033[0m'

print(style.YELLOW + "Hello, World!")

Nota: Embora isso ofereça as mesmas opções que outras opções do Windows, o Windows não oferece suporte completo a códigos ANSI, mesmo com esse truque. Nem todas as cores da decoração do texto funcionam e todas as cores 'brilhantes' (códigos 90-97 e 100-107) exibem as mesmas cores normais (códigos 30-37 e 40-47)

Edit : Obrigado a @jl por encontrar um método ainda mais curto.

tl; dr : adicione os.system("")próximo ao topo do seu arquivo.

Versão Python: 3.6.7

SimpleBinary
fonte
2
Isso funciona - estou realmente surpreso que o comando color habilite códigos ANSI no terminal do Windows, fiquei anos sem saber que isso era possível - o comando em si não dá nenhuma pista de que ele faz isso.
Stuart Axon
1
Mais simples e funciona perfeitamente. Obrigado.
Ari
3
Para ser claro, isso só funcionará no Windows 10.
Anaksunaman
2
Não funciona no Windows 7 / 8.1.
Nikos
2
Muito obrigado pela sua resposta, @SimpleBinary! Brincando com sua resposta, descobri que você pode simplificar if sys.platform.lower() == "win32": os.system('color')ainda mais, simplesmente substituindo-a por just os.system(''). Nenhuma condição é necessária e o código é executado no Windows 10 e no Linux (quando eu testei). Como você pode ver, você não precisa fazer uma chamada de sistema color. Chamadas para dir, cd, abcdef, e apenas uma multa de trabalho string vazia (embora as cordas não vazias provavelmente vai imprimir saída que você não quer ver).
JL
60

Minha maneira favorita é com a biblioteca Bênçãos (divulgação completa: eu escrevi). Por exemplo:

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 tijolos coloridos, a maneira mais confiável é imprimir espaços com cores de fundo. Eu uso essa técnica para desenhar a barra de progresso no nariz progressivo :

print t.on_green(' ')

Você também pode imprimir em locais específicos:

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

Se você precisar mexer com outros recursos do terminal durante o jogo, também poderá fazer isso. Você pode usar a formatação de string padrão do Python para mantê-lo legível:

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

O bom de Blessings é que ele faz o possível para trabalhar em todos os tipos de terminais, e não apenas nos (em grande parte comuns) de cores ANSI. Ele também mantém seqüências de escape ilegíveis fora do seu código, permanecendo conciso para uso. Diverta-se!

Erik Rose
fonte
65
Colocar a cor como um nome de função e não como um parâmetro é uma prática questionável.
LtWorf
1
@LtWorf: você pode facilmente torná-lo um parâmetro usando, getattrse necessário. Ou, mais provavelmente, basta criar a string de formato dinamicamente.
JFS
8
@progo o fato de que você pode fazer isso não significa que você deve fazê-lo. É mais genérico se a cor é um parâmetro que você pode simplesmente passar.
LtWorf
2
Você é can just passuma função python.
MaxNoe #
2
Observe que a importação de bênçãos não funciona no Windows; portanto, não use-o se o seu script precisar ser multiplataforma.
Adversus
58

sty é semelhante ao colorama, mas é menos detalhado, suporta 8 bits e 24 bits cores de (rgb), permite registrar seus próprios estilos, suporta muting, é realmente flexível, bem documentado e muito mais.

Exemplos:

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

impressões:

insira a descrição da imagem aqui

Demo: insira a descrição da imagem aqui

Rotareti
fonte
7
Seria muito útil se você considerar compará-lo com o colorama, eu prefiro sua biblioteca, mas apenas porque há uma API mais curta da caixa e seria ótimo se fosse mais popular. Obrigado!
Victor Gavro
Eu gosto de chiqueiro e estou tentando formatar minha string com chiqueiro, um problema é que, quando imprimo várias cores, posso redefinir a cor anterior em vez da cor padrão?
intijk
@VictorGavro Essa é uma boa ideia! Eu posso adicionar uma comparação à documentação.
Rotareti
@intijk Sua pergunta realmente não se encaixa na seção de comentários. Para esse tipo de pergunta, crie uma nova pergunta SO ou use o rastreador de problemas do github.
Rotareti
53

gerou uma classe com todas as cores usando um loop for para iterar todas as combinações de cores até 100, depois escreveu uma classe com cores python. Copie e cole como quiser, GPLv2 por mim:

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'
GI Jack
fonte
44

Experimente este código simples

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")
dayitv89
fonte
19
Sugestão: defina lambdas que retornam essa sequência colorida, em vez de imprimi-las diretamente, para que possam ser usadas em conjunto com outras sequências.
precisa saber é o seguinte
34

No Windows, você pode usar o módulo 'win32console' (disponível em algumas distribuições Python) ou o módulo 'ctypes' (Python 2.5 e superior) para acessar a API do Win32.

Para ver o código completo compatível com os dois lados, consulte o código de relatório do console de cores do Testoob .

exemplo 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)
orip
fonte
2
Honestamente, esta é a única solução que funciona com o Windows. Todas as outras respostas são apenas uma cópia do outro.
Danilo
FWIW, no Windows, pode ser menos complicado usar o ConEmu, que suporta sequências ANSI (além de uma série de outras vantagens sobre o terminal nativo). Ainda é ótimo ter uma solução nativa.
Endre Both
Eu estou com Danilo.
Muhammad Ali
24

Estupidamente simples com base na resposta 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)

Então apenas

PrintInColor.red('hello', end=' ')
PrintInColor.green('world')
zahanm
fonte
2
Isso falhará se você passar mais de um argumento posicional ou qualquer coisa que não seja um tipo de cadeia de caracteres
Romain Vincent
@RomainVincent Então, não passe mais de um argumento posicional ou qualquer outra coisa que não seja um tipo de string - espere, essas são printsubstituições ? Objeção revogada.
Wizzwizz4
1
@ wizzwizz4 Não sei ao certo o que você quis dizer com este comentário, não entendo o motivo. Se você pretende propor uma classe ..., para substituir um método tão simples quanto o de impressão, evite torná-lo tão facilmente quebrável. Apenas minha opinião.
Romain Vincent
1
@RomainVincent Eu diria que sua objeção estava errada, mas por substituir uma função tão versátil quanto printse deve ter certeza de replicar adequadamente sua funcionalidade.
wizzwizz4
1
@RomainVincent Implementos usar infinitos argumentos: <code> def purple(cls, *args, **kwargs): print(cls.PURPLE, *args, cls.END, **kwargs)</ code>
Emilien Baudet
23

Coloquei a resposta @joeld em um módulo com funções globais que posso usar em qualquer lugar do meu código.

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

use da seguinte maneira:

 import log
    log.info("Hello World")
    log.err("System Error")
Mohamed Samy
fonte
22

No Windows, você não pode imprimir no console com cores, a menos que esteja usando o win32api.

Para Linux, é tão simples quanto usar print, com as seqüências de escape descritas aqui:

Cores

Para que o personagem seja impresso como uma caixa, isso realmente depende da fonte que você está usando na janela do console. O símbolo da libra funciona bem, mas depende da fonte:

#
UberJumper
fonte
21
# 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 com alteração de primeiro plano e plano de fundo, cores 0..141 Texto com alteração de primeiro plano e plano de fundo, cores 142..255

Andriy Makukha
fonte
20

Acabei fazendo isso, achei que era mais limpo:

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)
Ben174
fonte
Isso é muito bom para fazer isso sem um pacote de terceiros.
Jamie Counsell
20

Com base na resposta @joeld, use 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 tela:

insira a descrição da imagem aqui


Algumas atualizações para os color_printnovos formatadores, por exemplo:

>>> 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: italic, fast blinkinge strikethroughpode não funcionar em todos os terminais, não funciona em Mac / Ubuntu.

Por exemplo

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

insira a descrição da imagem aqui

alvas
fonte
20
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")

Experimente on-line

Vishal
fonte
Isso é apenas para python3? Tenho um erro em set = '' com python2
ScipioAfricanus
funcionando perfeitamente em python3 ubuntu 18.04
Julius Prayogo
18

observe como a withpalavra - chave combina com modificadores como esses que precisam ser redefinidos (usando Python 3 e 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")
Janus Troelsen
fonte
Tentei colorama, usado print(Style.BRIGHT + "Header Test")e print (Style.DIM + word)para criar um prompt muito bom.
Tom
Isso precisará mudar contextlibpara o Py3.
gato
@cat: De que versão do Python será necessária?
Janus Troelsen
Eu acredito que 3 e acima - deve ter um @contextlib.contextmanagerdecorador, não?
cat
1
@cat: Por quê? Funciona muito bem sem.
Janus Troelsen
17

Você pode usar a implementação Python da biblioteca de maldições: http://docs.python.org/library/curses.html

Além disso, execute isso e você encontrará sua caixa:

for i in range(255):
    print i, chr(i)
daharon
fonte
Pessoalmente, penso que a biblioteca 'maldições' foi totalmente eclipsado por 'bênçãos', da mesma forma 'Pedidos' eclipsou 'urllib', etc.
Jonathan Hartley
17

Você poderia usar o CLINT:

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

Obtê-lo no GitHub .

Giacomo Lacava
fonte
1
O primeiro link foi removido, então eu o removi; o link GH ainda é bom (embora o projeto seja "arquivado" e basicamente abandonado, pelo que pude entender).
Giacomo Lacava
15

Eu sei que estou atrasado. Mas, eu tenho uma biblioteca chamada ColorIt . É super simples.

aqui estão alguns exemplos:

from ColorIt import *

# Use this to ensure that ColorIt will be usable by certain command line interfaces
initColorIt()

# Foreground
print (color ('This text is red', colors.RED))
print (color ('This text is orange', colors.ORANGE))
print (color ('This text is yellow', colors.YELLOW))
print (color ('This text is green', colors.GREEN))
print (color ('This text is blue', colors.BLUE))
print (color ('This text is purple', colors.PURPLE))
print (color ('This text is white', colors.WHITE))

# Background
print (background ('This text has a background that is red', colors.RED))
print (background ('This text has a background that is orange', colors.ORANGE))
print (background ('This text has a background that is yellow', colors.YELLOW))
print (background ('This text has a background that is green', colors.GREEN))
print (background ('This text has a background that is blue', colors.BLUE))
print (background ('This text has a background that is purple', colors.PURPLE))
print (background ('This text has a background that is white', colors.WHITE))

# Custom
print (color ("This color has a custom grey text color", (150, 150, 150))
print (background ("This color has a custom grey background", (150, 150, 150))

# Combination
print (background (color ("This text is blue with a white background", colors.BLUE), colors.WHITE))

Isso lhe dá:

Imagem de ColorIt

Também é importante notar que esta é uma plataforma cruzada e foi testada em mac, linux e windows.

Você pode tentar: https://github.com/CodeForeverAndEver/ColorIt

Nota: Piscando, itálico, negrito etc. serão adicionados em alguns dias.

BeastCoder
fonte
14

Se você está programando um jogo, talvez queira mudar a cor de fundo e usar apenas espaços? Por exemplo:

print " "+ "\033[01;41m" + " " +"\033[01;46m"  + "  " + "\033[01;42m"
suhib-alsisan
fonte
Mais sobre isso pode ser encontrado aqui- linux.byexamples.com/archives/184/…
pragmatic
11

Se você estiver usando o Windows, aqui está você!

# 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 ... ")
Navweb
fonte
Se você quiser cores diferentes na mesma linha, lave o fluxo stdout entre as chamadas:print("%X --> %s" % (color, "Have a fine day!"), end='', flush=True)
user2023861
11

Se você estiver 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âneo:

imagem

(Eu geralmente uso saída colorida para depuração no terminal runserver, então a adicionei.)

Você pode testar se está instalado em sua máquina:
$ python -c "import django; print django.VERSION"
Para instalá-lo, verifique: Como instalar o Django

De uma chance!!

Grijesh Chauhan
fonte
10

Aqui está um exemplo de maldições:

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)
nosklo
fonte
Seu código faz falhar no Windows (x64) com este erro: AttributeError: objeto 'módulo' tem nenhum atributo 'capa'
Sorin
1
@Sorin Sbarnea: De acordo com a documentação oficial do python curses em docs.python.org/library/curses.html , o módulo curses não é suportado no Windows. Talvez você tenha recebido esse erro em vez de "No Such Module" ou algo assim, porque provavelmente nomeou seu arquivo de teste "curses.py" para que ele se importe.
Nosklo 25/08/09
10

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')
Vishal
fonte
10

o asciimatics fornece um suporte portátil para criar UI de texto e animações:

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

texto em arco-íris entre ruído ascii

jfs
fonte
10

Ainda outro módulo pypi que envolve a função de impressão python 3:

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

É utilizável no python 2.x se você também from __future__ import print. Aqui está um exemplo do python 2 da página modules pypi:

from __future__ import print_function
from colorprint import *

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

Resultados "Olá, mundo!" com as palavras em azul e o ponto de exclamação em negrito vermelho e piscando.

drevicko
fonte