В windows 10 вы можете попробовать этот крошечный скрипт, который работает как микшер цветов со значениями от 0 до 255 для красного, зеленого и синего:

import os

os.system('')


def RGB(red=None, green=None, blue=None,bg=False):
    if(bg==False and red!=None and green!=None and blue!=None):
        return f'\u001b[38;2;{red};{green};{blue}m'
    elif(bg==True and red!=None and green!=None and blue!=None):
        return f'\u001b[48;2;{red};{green};{blue}m'
    elif(red==None and green==None and blue==None):
        return '\u001b[0m'

и вызовите функцию RGB, чтобы сделать любую комбинацию цветов как:

g0 = RGB()
g1 = RGB(0,255,0)
g2 = RGB(0,100,0,True)+""+RGB(100,255,100)
g3 = RGB(0,255,0,True)+""+RGB(0,50,0)

print(f"{g1}green1{g0}")
print(f"{g2}green2{g0}")
print(f"{g3}green3{g0}")

RGB() без параметров очистит и установит цвет переднего плана/фона на по умолчанию. Если вам нужен черный, вы должны называть его RGB(0,0,0), а для белый RGB(255,255,255). В то время как RGB(0,255,0) создает абсолютно-зеленый RGB(150,255,150) создает светло-зеленый.

Это поддерживает Фон и передний план , чтобы установить цвет как Фоновый цвет .

Например: для установки RED Как Фоновый цвет его следует назвать RGB(255,0,0,True) Но выбирать <93633333232332332336333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333611936119361119323 33 > просто назовите его как RGB(255,0,0,False), так как bg по умолчанию False это упрощает вызов его как RGB(255,0,0)

Для этого вы можете использовать модуль pygments. Например:

from pygments import console
print(pygments.console.colorize("red", "This text is red."))

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

Google переместил меня туда, когда я искал, как раскрашивать журналы так:

цветные журналы

Установка

pip install coloredlogs

Использование

Минимальное использование:

import logging
import coloredlogs

coloredlogs.install()  # install a handler on the root logger

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

Результаты с:

Начать с отладки на уровне сообщения:

import logging
import coloredlogs

coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

Результаты с:

Скрыть сообщения из библиотек:

import logging
import coloredlogs

logger = logging.getLogger(__name__)  # get a specific logger object
coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug
coloredlogs.install(level='DEBUG', logger=logger)  # pass a specific logger object

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

Результаты с:

Форматировать сообщения журнала:

import logging
import coloredlogs

logger = logging.getLogger(__name__)  # get a specific logger object
coloredlogs.install(level='DEBUG')  # install a handler on the root logger with level debug
coloredlogs.install(level='DEBUG', logger=logger)  # pass a specific logger object
coloredlogs.install(
    level='DEBUG', logger=logger,
    fmt='%(asctime)s.%(msecs)03d %(filename)s:%(lineno)d %(levelname)s %(message)s'
)

logging.debug('message with level debug')
logging.info('message with level info')
logging.warning('message with level warning')
logging.error('message with level error')
logging.critical('message with level critical')

Результаты с:

Доступные атрибуты формата:

• %(asctime)s - Время в виде удобочитаемой строки, когда был выполнен вызов журнала
• %(created)f - Время в виде числа с плавающей запятой при выдаче вызова журнала
• %(filename)s - Имя файла
• %(funcName)s - Имя функции, содержащей вызов журнала
• %(hostname)s - Имя хоста системы
• %(levelname)s - Уровень записи текста
• %(levelno)s - Целочисленный уровень ведения журнала
• %(lineno)d - номер линии, по которой поступил вызов журнала
• %(message)s - сообщение передано вызову журнала (то же, что и %(msg)s)
• %(module)s - имя файла без расширения, в котором был выполнен вызов журнала
• %(msecs)d - Миллисекундная часть времени, когда был выдан вызов регистрации
• %(msg)s - сообщение передано вызову журнала (то же, что и %(message)s)
• %(name)s - Имя регистратора
• %(pathname)s - полный путь к файлу, содержащему вызов журнала
• %(process)d - Идентификатор процесса
• %(processName)s - Имя процесса
• %(programname)s - системное имя программы
• %(relativeCreated)d - Время как целое число в миллисекундах, когда был инициирован вызов регистрации, относительно времени, когда модуль регистрации был загружен
• %(thread)d - ID потока
• %(threadName)s - Имя потока
• %(username)s - системное имя пользователя

Источники:

Пакет цветных журналов

Библиотека журналов

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

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

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

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

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

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

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

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

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

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

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

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

• цветный
• ansicolors
• termcolor
• колорама
• sty
• блыги
• богатый
• colorit
• цветной отпечаток
• цвет консоли
• pyfance
• couleur
• стиль (ранее известный как clr)
• pychalk
• простой мел
• chlk
• мелкий

В этом ответе предпринимается попытка расширить концепцию записи раскрашенного текста на терминал с помощью регулярного выражения для раскрашивания ключевых слов в блоке текста.

В этом ответе также используется библиотека Python Rich, которая была кратко рассмотрена в предыдущем ответе на этот вопрос. В этом ответе я использую функцию rich.color.ANSI_COLOR_NAMES , чтобы получить случайный список цветов, которые будут использоваться для выделения предопределенных условий поиска.

import random
import re as regex
from rich import color
from rich import print


def create_dynamic_regex(search_words):
    """
    This function is used to create a dynamic regular expression
    string and a list of random colors. Both these elements will
    be used in the function colorize_text()

    :param search_words: list of search terms
    :return: regular expression search string and a list of colors
    :rtype: string, list
    """
    colors_required = create_list_of_colors(len(search_words))
    number_of_search_words = len(search_words)
    combined_string = ''
    for search_word in search_words:
        number_of_search_words -= 1
        if number_of_search_words != 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)|')
            combined_string = (combined_string + current_string)
        elif number_of_search_words == 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)')
            combined_string = (combined_string + current_string)
    return combined_string, colors_required


def random_color():
    """
    This function is used to create a random color using the
    Python package rich.
    :return: color name
    :rtype: string
    """
    selected_color = random.choice(list(color.ANSI_COLOR_NAMES.keys()))
    return selected_color


def create_list_of_colors(number_of_colors):
    """
    This function is used to generate a list of colors,
    which will be used in the function colorize_text()
    :param number_of_colors:
    :return: list of colors
    :rtype: list
    """
    list_of_colors = [random_color() for _ in range(number_of_colors)]
    return list_of_colors


def colorize_text(text, regex_string, array_of_colors):
    """
    This function is used to colorize specific words in a text string.
    :param text: text string potentially containing specific words to colorize.
    :param regex_string: regular expression search string
    :param array_of_colors: list of colors
    :return: colorized text
    :rtype: string
    """
    available_colors = array_of_colors
    word_regex = regex.compile(f"{regex_string}", regex.IGNORECASE)
    i = 0
    output = ""
    for word in word_regex.finditer(text):
        get_color = available_colors[word.lastindex - 1]
        output += "".join([text[i:word.start()],
                           "[%s]" % available_colors[word.lastindex - 1],
                           text[word.start():word.end()], "[/%s]" % available_colors[word.lastindex - 1]])
        i = word.end()
    return ''.join([output, text[word.end():]])


def generate_console_output(text_to_search, words_to_find):
    """
    This function is used generate colorized text that will
    be outputting to the console.

    :param text_to_search: text string potentially containing specific words to colorize.
    :param words_to_find: list of search terms.
    :return: A string containing colorized words.
    :rtype: string
    """
    search_terms, colors = create_dynamic_regex(words_to_find)
    colorize_html = colorize_text(text_to_search, search_terms, colors)
    print(colorize_html)


text = "The dog chased the cat that was looking for the mouse that the dog was playing with."
words = ['dog', 'cat', 'mouse']
generate_console_output(text, words)

Вот результат печати из приведенного выше кода:

Я создал два GIST для раскрашивания текста.

• цветной текстовый вывод терминала
• цветной текст для вывода HTML

Если вы хотите использовать только встроенные пакеты, следуйте этой структуре:

На самом деле, я улучшил ответ Мохамеда Сами, который теперь отвечает за несколько вводов, а также за числа. Кроме того, он поддерживает другие аргументы print(), такие как end=. Кроме того, я добавил метод .store() для записи журналов в файл.

Вы можете создать утилиту, чтобы использовать это в любом месте вашего кода:

# utility.py

from datetime import datetime

class ColoredPrint:
    def __init__(self):
        self.PINK = '\033[95m'
        self.OKBLUE = '\033[94m'
        self.OKGREEN = '\033[92m'
        self.WARNING = '\033[93m'
        self.FAIL = '\033[91m'
        self.ENDC = '\033[0m'

    def disable(self):
        self.PINK = ''
        self.OKBLUE = ''
        self.OKGREEN = ''
        self.WARNING = ''
        self.FAIL = ''
        self.ENDC = ''

    def store(self):
        date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        with open('logfile.log', mode='a') as file_:
            file_.write(f"{self.msg} -- {date}")
            file_.write("\n")

    def success(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.OKGREEN + self.msg + self.ENDC, **kwargs)
        return self

    def info(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.OKBLUE + self.msg + self.ENDC, **kwargs)
        return self

    def warn(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.WARNING + self.msg + self.ENDC, **kwargs)
        return self

    def err(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.FAIL + self.msg + self.ENDC, **kwargs)
        return self

    def pink(self, *args, **kwargs):
        self.msg = ' '.join(map(str, args))
        print(self.PINK + self.msg + self.ENDC, **kwargs)
        return self

например,

from utility import ColoredPrint

log = ColoredPrint()

log.success("Hello" , 123, "Bye").store()
log.info("Hello" , 123, "Bye")
log.warn("Hello" , 123, "Bye")
log.err("Hello" , 123, "Bye").store()
log.pink("Hello" , 123, "Bye")

Вышел:

[ОБНОВЛЕНИЕ]:

Теперь доступен его пакет PyPI ????:

pip install python-colored-print

print("\033[1;32;40m Bright Green  \n")

Некоторые из решений, например:

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)

print(fg("text", 160))

ИЛИ

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)

ИЛИ

class Color:
    COLOR = [f"\33[{i}m" for i in range(44)]

for i in range(44):
    print(Color.COLOR[i] + 'text')

может не работать на терминалах Windows 10 или Windows PowerShell, или могут быть другие случаи, когда они могут не работать напрямую.

Но при вставке эти две маленькие строчки в начале программы могут помочь:

import os
os.system('')

os.system('') позволяет печатать коды ANSI в Терминале, которые окрашивают ваш вывод в соответствии с вашим выбором (но могут быть и другие системные функции, которые вам может потребоваться вызвать, чтобы иметь возможность печатать цветной текст в терминале).

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

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

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

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

Emoji

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

Но вместо этого вы можете использовать смайлики ! например, вы можете использовать ⚠️ для предупреждений и ???? для сообщений об ошибках.

Или просто используйте эти записные книжки как цвет:

????: error message
????: warning message
????: ok status message
????: action message
????: canceled status message
????: Or anything you like and want to recognize immediately by color

???? Бонус:

Этот метод также помогает быстро сканировать и находить журналы непосредственно в исходном коде .

_{Но в некоторых операционных системах (включая некоторые дистрибутивы Linux в некоторых версиях с некоторыми оконными менеджерами) шрифт эмодзи по умолчанию не является цветным по умолчанию, и вы можете сначала сделать их цветными.}

import click

click.secho('Hello, World!', fg='green')
click.secho('Some more text', bg='blue', fg='white')
click.secho('ATTENTION', blink=True, bold=True)

click (библиотека CLI) имеет очень удобный способ сделать это, и в любом случае стоит подумать, если вы пишете инструмент командной строки.

Я создал проект (console-color) и уже опубликовал его в PyPI.

Вы можете бросить pip install console-color, чтобы установить его.

И я пишу документ с помощью Sphinx-read-the-doc, см. здесь.

Дополнительные примеры можно найти в google-colab.

Я все еще публикую пример, чтобы привлечь пользователя, щелкнув по указанной выше ссылке:

# cprint is something like below
# cprint(text: str, fore: T_RGB = None, bg: T_RGB = None, style: Style = '')
# where T_RGB = Union[Tuple[int, int, int], str] for example. You can input (255, 0, 0) or '#ff0000' or 'ff0000'. They are OK.
# The Style you can input the ``Style.`` (the IDE will help you to choose what you wanted)

# from console_color import RGB, Fore, Style, cprint, create_print
from console_color import *

cprint("Hello, World!", RGB.RED, RGB.YELLOW, Style.BOLD+Style.URL+Style.STRIKE)
cprint("Hello, World!", fore=(255, 0, 0), bg="ffff00", style=Style.BOLD+Style.URL+Style.STRIKE)

Конечно, вводить все параметры необязательно. Вы можете просто добавить нужные атрибуты.

Если честно, этот проект не особенный. Он просто использует f"\033[{target};2;{r};{g};{b}m{text}{style}" где цель - 38 или 48, текст - ваша строка ввода, а стиль - '\ 33 [0m', '\ 33 [1m' ... '\ 033 [9m'. Какие-то вещи.

И я просто делаю его простым в использовании (по крайней мере, для меня).

Это, на мой взгляд, самый простой способ. Пока у вас есть значения 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)

Я предлагаю эту новую библиотеку Printy . Они только что выпустили версию 1.2.0 как кроссплатформенную библиотеку.

Проверить это: Печать на GitHub

Он основан на флагах, поэтому вы можете делать такие вещи, как

from printy import printy

# With global flags, this will apply a bold (B) red (r) color and an underline (U) to the whole text
printy("Hello, World!", "rBU")

# With inline formats, this will apply a dim (D)
#blue (b) to the word 'Hello' and a stroken (S)
#yellow (y) to the word 'world', and the rest will remain as the predefined format
printy("this is a [bD]Hello@ [yS]world@ text")

Вот простая функция, которую я использую для печати текстового сообщения в цвете без запоминания кодов ANSI, а с использованием стандартных кортежей RGB для определения цветов переднего плана и фона.

def print_in_color(txt_msg, fore_tuple, back_tuple, ):
    # Prints the text_msg in the foreground color specified by fore_tuple with the background specified by back_tuple
    # text_msg is the text, fore_tuple is foreground color tuple (r,g,b), back_tuple is background tuple (r,g,b)
    rf,bf,gf = fore_tuple
    rb,gb,bb = back_tuple
    msg = '{0}' + txt_msg
    mat = '\33[38;2;' + str(rf) + ';' + str(gf) + ';' + str(bf) + ';48;2;' + str(rb) + ';' +str(gb) + ';' + str(bb) + 'm'
    print(msg .format(mat))
    print('\33[0m') # Returns default print color to back to black

# Example of use using a message with variables
fore_color = 'cyan'
back_color = 'dark green'
msg = 'foreground color is {0} and the background color is {1}'.format(fore_color, back_color)
print_in_color(msg, (0,255,255), (0,127,127))

У меня есть библиотека под названием 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.

Самый простой способ, который я могу найти, - это не использовать escape-коды ANSI, а использовать Fore из модуля импорта colorama. Взгляните на код ниже:

from colorama import Fore, Style

print(Fore.MAGENTA + "IZZ MAGENTA BRUH.")

print(Style.RESET_ALL + "IZZ BACK TO NORMALZ.")

по сравнению с escape-кодом ANSI:

print("\u001b[31m IZZ RED (NO MAGENTA ON ANSI CODES).\u001b[0m")

print("BACK TO NORMALZ.")

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

Я новичок в Python, и я взволнован каждый раз, когда открываю для себя такие темы, как эта. Но на этот раз (внезапно) я чувствую, что мне есть что сказать. Особенно потому, что несколько минут назад я обнаружил вау в Python (по крайней мере, для меня сейчас):

Контекстные менеджеры

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

Пример

Или просто так:

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

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

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

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

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

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

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

Демо :

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

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

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

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

В итоге я сделал это, и я чувствовал, что это было наиболее чисто:

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)

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:

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

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

Еще один модуль PyPI, который включает функцию Python 3 print :

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

Его можно использовать в Python 2.x, если вы также from __future__ import print. Вот пример Python 2 со страницы модулей PyPI:

from __future__ import print_function
from colorprint import *

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

Выводится «Привет, мир!» со словами синего цвета и мигающим красным жирным шрифтом восклицательного знака.

Если вы используете Django:

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

Снимок:

(Обычно я использую цветной вывод для отладки на терминале runserver, поэтому добавил его.)

_{Вы можете проверить, установлен ли он на вашем компьютере: $ python -c "import django; print django.VERSION". Чтобы установить его, проверьте: Как установить Django}

Попробуйте попробуйте !!

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

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

Используйте pyfancy. Это простой способ сделать цвет в терминале!

Пример:

print(pyfancy.RED + "Hello Red" + pyfancy.END)

Вы можете использовать escape-символы оболочки, которые доступны на любом языке. Эти escape-символы начинаются с символа ESC, за которым следует ряд аргументов.

Например, для вывода красной «Hello, World!» строки в вашем терминале:

echo "\e[31m Hello, World! \e[0m"

Или из скрипта Python:

print("\e[31m Hello world \e[0m")

Кроме того, я написал статью о escape-последовательностях, которые, вероятно, помогут вам лучше понять этот механизм.

Я написал модуль, который обрабатывает цвета в Linux, OS X и Windows. Он поддерживает все 16 цветов на всех платформах, вы можете устанавливать цвета переднего плана и фона в разное время, а строковые объекты дают нормальные результаты для таких вещей, как len () и .capitalize ().

https://github.com/Robpol86/colorclass

Я создал класс со всеми цветами, используя цикл 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'

Распечатайте строку, которая начинает цвет / стиль, затем строку, а затем завершает изменение цвета / стиля с помощью '\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()

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

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

Мои два цента (PyColorTerm):

Установка:

sudo apt-get install python-pip
pip install pycolorterm

Скрипт Python:

from pycolorterm import pycolorterm

with pycolorterm.pretty_output(pycolorterm.FG_GREEN) as out:
    out.write('Works OK!')

"работает нормально!" отображается зеленым цветом.

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

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

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

Обратите внимание, насколько хорошо ключевое слово 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")

Если вы используете 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 ... ")

Чтобы решить эту проблему, я создал умопомрачительно простой пакет для печати строк с интерполированными цветовыми кодами, названный icolor.

icolor включает две функции: cformat и cprint, каждая из которых принимает строку с подстроками, которые интерполируются для сопоставления с escape-последовательностями ANSI, например,

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'

Включены все цвета ANSI (например, #RED;, #BLUE; и т. Д.), А также #RESET;, #BOLD; и другие.

Цвета фона имеют префикс x, поэтому зеленый фон будет #xGREEN;.

От # можно уйти с помощью ##.

Учитывая его простоту, лучшая документация, вероятно, - это сам код.

Это на PYPI, поэтому можно sudo easy_install icolor.

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

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

Мой любимый способ - использовать библиотеку 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-последовательности из вашего кода, оставаясь при этом кратким для использования. Удачи!

Я написал простой модуль, доступный по адресу: http://pypi.python.org/pypi/colorconsole

Работает с Windows, Mac OS X и Linux. Он использует ANSI для Linux и Mac, но нативные вызовы консольных функций в Windows. У вас есть цвета, положение курсора и ввод с клавиатуры. Это не замена проклятиям, но может быть очень полезным, если вам нужно использовать в простых скриптах или играх ASCII.

Ответ: Colorama для всей кроссплатформенной раскраски в Python.

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

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

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

Вот пример curses:

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)

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

from termcolor import colored

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

Или в Python 3:

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

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

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

Для символов

Ваш терминал, скорее всего, использует символы Unicode (обычно в кодировке UTF-8), поэтому для просмотра вашего любимого символа достаточно выбрать соответствующий шрифт. Unicode char U + 2588, я бы посоветовал вам использовать "Полный блок".

Попробуйте следующее:

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

Просмотрите файл позже с помощью любимой программы просмотра.

Для цветов

curses - это модуль, который вы хотите использовать. Посмотрите этот учебник.

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

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

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

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

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

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

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

Для символа блока попробуйте использовать символ Юникода, например \ u2588:

print(u"\u2588")

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

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

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

Также запустите это, и вы найдете свой ящик:

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

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

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

Цвета

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

#