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

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

Цвета

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

#

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

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

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

Вы хотите узнать о 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")

Это в некоторой степени зависит от того, на какой платформе вы находитесь. Наиболее распространенный способ сделать это - распечатать 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 (при условии, что вы используете АНСИКОН, или в Windows 10, если вы включили Эмуляция VT100). Существуют коды ANSI для установки цвета, перемещения курсора и т. д.

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

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

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

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

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

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

Для персонажей

Ваш терминал, скорее всего, использует символы 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()

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

Для цветов

проклятия - это модуль, который вы хотите использовать. Отметьте это руководство.

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

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

from termcolor import colored

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

Или в Python 3:

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

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

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

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.

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

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

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

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

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

Мой любимый способ - с библиотекой Благословения (полное раскрытие: я ее написал). Например:

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-последовательности из вашего кода, оставаясь при этом кратким для использования. Веселиться!

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

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

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

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

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

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

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

Мои два цента (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!')

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

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

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

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

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

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

https://github.com/Robpol86/colorclass

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

Например, чтобы вывести в терминал красную строку "Привет мир!":

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

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

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

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

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

Пример:

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

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

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

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

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

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

print colors.error('sorry, ')

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

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

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

Если вы используете Джанго:

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

Снимок:

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

_{You can test if it is installed in your machine: $ python -c "import django; print django.VERSION". To install it, check: How to install Django}

Дайте ему пытаться !!

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

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

Он выводит "Hello, world!" со словами, выделенными синим цветом, и мигающим красным жирным шрифтом восклицательного знака.

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

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

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

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

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

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)

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

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

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

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

свинарник похож на 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')

печатает:

Демо:

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

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

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

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

Я новичок в 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')

Вот решение, которое изначально работает в 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("")

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

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

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

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

Вот простая функция, которую я использую для цветной печати текстового сообщения без запоминания кодов 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))

Я предлагаю эту новую библиотеку 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")

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

Я создал проект (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'. Какие-то вещи.

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

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

Эмодзи

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

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

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

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

? Бонус:

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

_{But some operating systems (including some Linux distributions in some version with some window managers) default emoji font is not colorful by default and you may want to make them colorful, first.}

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

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

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

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

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

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 в Терминале, которые окрашивают ваш вывод в соответствии с вашим выбором (но могут быть и другие системные функции, которые вам может потребоваться вызвать, чтобы иметь возможность печатать цветной текст в терминале).

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

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

Фактически, я улучшил ответ Мохамед Сами, который теперь отвечает за несколько входов, а также за числа. Кроме того, он поддерживает другие аргументы 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")

Из: