Это в некоторой степени зависит от того, на какой платформе вы находитесь. Наиболее распространенный способ сделать это - распечатать escape-последовательности ANSI. В качестве простого примера приведем код Python из Скрипты сборки 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'

Чтобы использовать такой код, вы можете сделать что-то вроде:

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

Или с Python 3.6+:

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

Это будет работать в Unix, включая OS X, Linux и Windows (при условии, что вы используете ANSICON, или в Windows 10, предоставленной вы включаете эмуляцию VT100). Существуют коды ANSI для настройки цвета, перемещения курсора и т. Д.

Если вы собираетесь усложнить это (а это похоже на то, что вы пишете игру), вам следует заглянуть в "curses", который выполняет множество сложных задач за вас. Python Curses HowTO - хорошее введение.

Если вы не используете расширенный ASCII (то есть не на ПК), вы застряли с символами ASCII ниже 127, и '#' или '@', вероятно, лучший выбор для блока. Если вы можете убедиться, что ваш терминал использует расширенный набор символов ASCII IBM, у вас есть гораздо больше опции. Символы 176, 177, 178 и 219 являются «символами блока».

Некоторые современные текстовые программы, такие как "Dwarf Fortress", имитируют текстовый режим в графическом режиме и используют изображения классического шрифта для ПК. Вы можете найти некоторые из этих растровых изображений, которые можно использовать на Dwarf Fortress Wiki см. ( пользовательские наборы фрагментов ).

Демо-конкурс текстового режима содержит больше ресурсов для создания графики в тексте. режим.

Также существует модуль Python termcolor. Использование довольно простое:

from termcolor import colored

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

Или в Python 3:

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

Однако он может быть недостаточно сложным для программирования игр и «цветных блоков», которые вы хотите сделать ...

Ответ - Colorama для всех кроссплатформенных раскрасок в Python.

Он поддерживает Python 3.5+, а также Python 2.7.

И по состоянию на январь 2021 года он сохраняется.

Пример снимка экрана:

Распечатайте строку, с которой начинается цвет / стиль, затем строку, а затем завершите изменение цвета / стиля с помощью '\x1b[0m':

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

Получите таблицу параметров формата для текста оболочки с помощью следующего кода:

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

Пример "свет на темноте" (полный)

Пример темного на светлом (частичный)

Вот решение, которое изначально работает в Windows 10.

Использование системного вызова, такого как os.system(""), позволяет печатать цвета непосредственно в командной строке и Powershell:

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

Примечание. Windows не полностью поддерживает коды ANSI, будь то системные вызовы или модули. Не все оформление текста поддерживается, и хотя отображаются яркие цвета, они идентичны обычным цветам.

Спасибо @ j-l за поиск еще более короткого метода.

tl; dr : добавить os.system("")

Вы хотите узнать о escape-последовательностях ANSI. Вот краткий пример:

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

Для получения дополнительной информации см. escape-код ANSI .

Для блочного символа попробуйте использовать Unicode-символ, например \ u2588:

print(u"\u2588")

Собираем все вместе:

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

sty похож на colorama, но менее подробен, поддерживает 8-битный и 24-битные (RGB) цвета, поддерживает все эффекты (жирный, подчеркнутый и т. д.) позволяют зарегистрируйте свои собственные стили, полностью типизирован, поддерживает приглушение, действительно гибкий, ну задокументировано и многое другое ...

Примеры:

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

Печатает :

<Сильные> Демо:

Rich - это относительно новая библиотека Python для работы с цветом в терминале.

В Rich есть несколько способов работы с цветом. Самый быстрый способ начать - это использовать расширенный метод печати, который отображает синтаксис, подобный BBCode, в Контрольные коды ANSI:

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

Есть и другие способы применения цвета с помощью Rich (регулярное выражение, синтаксис) и связанных функций форматирования.

Мой любимый способ - использовать библиотеку Blessings (полное раскрытие: это я написал). Например:

from blessings import Terminal

t = Terminal()
print t.red('This is red.')
print t.bold_bright_red_on_black('Bright red on black')

Самый надежный способ печатать цветные кирпичи - это печатать пространства с фоновыми цветами. Я использую эту технику, чтобы нарисовать полосу выполнения в прогрессивном носу:

print t.on_green(' ')

Вы также можете печатать в определенных местах:

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

Если в ходе игры вам придется возиться с другими возможностями терминала, вы тоже можете это сделать. Вы можете использовать стандартное форматирование строк Python, чтобы оно было читаемым:

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

Хорошая вещь в Blessings заключается в том, что он делает все возможное, чтобы работать на всех типах терминалов, а не только на (в большинстве своем) цветных ANSI. Он также сохраняет нечитаемые escape-последовательности из вашего кода, оставаясь при этом кратким для использования. Повеселись!

Я создал класс со всеми цветами, используя цикл for для перебора всех комбинаций цветов до 100, а затем написал класс с цветами Python. Скопируйте и вставьте, как хотите, GPLv2, сделанную мной:

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'

Попробуйте этот простой код

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

У меня есть библиотека под названием colorit. Это очень просто.

Вот некоторые примеры:

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

Это дает вам:

Также стоит отметить, что это кроссплатформенный продукт, который был протестирован на Mac, Linux и Windows.

Возможно, вы захотите попробовать: https://github.com/SuperMaZingCoder/colorit

colorit теперь доступен для установки с PyPi! Вы можете установить его с помощью pip install color-it в Windows и pip3 install color-it в macOS и Linux.

В Windows вы можете использовать модуль win32console (доступен в некоторых дистрибутивах Python) или модуль ctypes (Python 2.5 и выше) для доступа к Win32 API.

Чтобы увидеть полный код, поддерживающий оба способа, см. цветовую консоль. код сообщения из Testoob.

Пример 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)

Я заключил ответ Джоэлда в модуль с глобальным функции, которые я могу использовать в любом месте своего кода.

Файл: 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()

Используйте следующим образом:

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

Это, на мой взгляд, самый простой способ. Пока у вас есть значения RGB желаемого цвета, это должно работать:

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

Пример печати красного текста:

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

#or

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

Разноцветный текст

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

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

Попробуй онлайн

В Windows нельзя печатать на консоли с цветами, если вы не используете Win32 API.

Для Linux это так же просто, как использовать print с escape-последовательностями, описанными здесь:

Цвета

Чтобы символ печатался как поле, это действительно зависит от того, какой шрифт вы используете для окна консоли. Символ фунта работает хорошо, но это зависит от шрифта:

#

Обратите внимание, насколько хорошо ключевое слово with сочетается с подобными модификаторами, которые необходимо сбросить (с использованием Python 3 и 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")

Основываясь на ответе Джоэлда с использованием 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

Снимок экрана:

Некоторые обновления color_print с новыми средствами форматирования, например:

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

Примечание: italic, fast blinking и strikethrough могут работать не на всех терминалах, и они не работают на Mac и Ubuntu.

Например.,

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

Снимок экрана:

Вы можете использовать Clint:

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

Вы можете использовать Python-реализацию библиотеки curses: curses - обработка терминала для отображения символьных ячеек

Кроме того, запустите это, и вы найдете свой ящик:

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

Если вы программируете игру, возможно, вы хотели бы изменить цвет фона и использовать только пробелы? Например:

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

Вот мое современное решение (2021 г.): yachalk

Это одна из немногих библиотек, которая должным образом поддерживает вложенные стили:

Кроме того, yachalk поддерживает автозаполнение, поддерживает 256 цветов, поддерживает определение терминала и полностью типизирован.

Вот некоторые дизайнерские решения, которые вы можете принять во внимание при выборе своего решения.

Библиотеки высокого уровня против библиотек низкого уровня / ручная обработка стилей?

Многие ответы на этот вопрос демонстрируют, как напрямую использовать escape-коды ANSI, или предлагают низкоуровневые библиотеки, которые требуют включения / отключения ручного стиля.

У этих подходов есть тонкие проблемы: вставка стилей включения / выключения вручную

• более подробный синтаксически, потому что сбросы должны быть указаны явно,
• больше подвержено ошибкам, потому что вы можете случайно забыть сбросить стиль,
• не может правильно понять крайние случаи: например, в некоторых терминалах необходимо сбрасывать стили перед новой строкой и повторно активировать их после разрыва строки. Кроме того, некоторые терминалы имеют проблемы с простым переопределением взаимоисключающих стилей и требуют вставки «ненужных» кодов сброса. Если локальный терминал разработчика не имеет этих причуд, разработчик не сразу обнаружит эти причуды. О проблеме будут сообщать только другие люди позже, или она вызовет проблемы, например, на терминалах CI.

Поэтому, если целью является совместимость со многими терминалами, лучше всего использовать высокоуровневую библиотеку, которая предлагает автоматическую обработку сброса стилей. Это позволяет библиотеке позаботиться обо всех крайних случаях, вставляя «ложные» escape-коды ANSI там, где это необходимо.

Зачем нужна еще одна библиотека?

В JavaScript де-факто стандартной библиотекой для этой задачи является chalk, и после ее использования в течение некоторого времени в JS проектов, решений, доступных в мире Python, по сравнению с этим не хватало. Chalk API не только более удобен в использовании (полностью совместим с автозаполнением), но и позволяет правильно использовать все граничные случаи.

Идея yachalk состоит в том, чтобы обеспечить такое же удобство экосистемы Python. Если вас интересует сравнение с другими библиотеками, которые я начал, сравнение функций на странице проектов. Кроме того, вот длинный (но все еще неполный) список альтернатив, которые возникли во время моего исследования - есть из чего выбирать :)

• цветной
• ansicolors
• termcolor
• колорама
• свинарник
• благословения
• богатые
• цвет
• ColorPrint
• цвет консоли
• Pyfance
• couleur
• style (ранее известный как clr)
• Пычалк
• простой мел
• члк
• меловой

Более простой вариант - использовать функцию cprint из termcolor упаковка.

Он также поддерживает формат печати %s, %d:

Результаты могут зависеть от терминала, поэтому просмотрите раздел Свойства терминала документации пакета.

• Командная строка Windows и Python IDLE не работают

• Ноутбук JupyterLab работает

Если вы используете Windows, то готово!

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

Вот пример проклятия:

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)

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

asciimatics предоставляет переносимую поддержку для создания текстового пользовательского интерфейса и анимации:

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

Определите строку, с которой начинается цвет, и строку, заканчивающую цвет. Затем распечатайте текст, указав начальную строку впереди и конечную строку в конце.

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

Это дает следующее в Bash, в urxvt с цветовой схемой в стиле Zenburn:

Экспериментируя, мы можем получить больше цветов:

Примечание: \33[5m и \33[6m мигают.

Таким образом мы можем создать полноцветную коллекцию:

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'

Вот код для генерации теста:

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

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

Попробуйте онлайн

В конце концов, я сделал это, и я почувствовал, что это самое чистое:

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)

Глупо просто, основываясь на ответе Джоэлда:

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)

Тогда просто

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

УРА! Другая версия

Хотя я считаю этот ответ полезным, я немного его изменил. Этот GitHub Gist является результатом

Применение

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

Кроме того, вы можете обернуть распространенные обычаи:

print colors.error('sorry, ')

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