This somewhat depends on what platform you are on. The most common way to do this is by printing ANSI escape sequences. For a simple example, here’s some Python code from the Blender build scripts:

class bcolors:
    HEADER = '33[95m'
    OKBLUE = '33[94m'
    OKCYAN = '33[96m'
    OKGREEN = '33[92m'
    WARNING = '33[93m'
    FAIL = '33[91m'
    ENDC = '33[0m'
    BOLD = '33[1m'
    UNDERLINE = '33[4m'

To use code like this, you can do something like:

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

Or, with Python 3.6+:

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

This will work on unixes including OS X, Linux and Windows (provided you use ANSICON, or in Windows 10 provided you enable VT100 emulation). There are ANSI codes for setting the color, moving the cursor, and more.

If you are going to get complicated with this (and it sounds like you are if you are writing a game), you should look into the “curses” module, which handles a lot of the complicated parts of this for you. The Python Curses HowTO is a good introduction.

If you are not using extended ASCII (i.e., not on a PC), you are stuck with the ASCII characters below 127, and ‘#’ or ‘@’ is probably your best bet for a block. If you can ensure your terminal is using a IBM extended ASCII character set, you have many more options. Characters 176, 177, 178 and 219 are the “block characters”.

Some modern text-based programs, such as “Dwarf Fortress”, emulate text mode in a graphical mode, and use images of the classic PC font. You can find some of these bitmaps that you can use on the Dwarf Fortress Wiki see (user-made tilesets).

The Text Mode Demo Contest has more resources for doing graphics in text mode.

There is also the Python termcolor module. Usage is pretty simple:

from termcolor import colored

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

It may not be sophisticated enough, however, for game programming and the “colored blocks” that you want to do…

To get the ANSI codes working on windows, first run

os.system('color')

The answer is Colorama for all cross-platform coloring in Python.

It supports Python 3.5+ as well as Python 2.7.

And as of January 2023, it is maintained.

Example Code:

from colorama import init as colorama_init
from colorama import Fore
from colorama import Style

colorama_init()

print(f"This is {Fore.GREEN}color{Style.RESET_ALL}!")

Example Screenshot:

Print a string that starts a color/style, then the string, and then end the color/style change with 'x1b[0m':

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

Get a table of format options for shell text with the following code:

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

Light-on-dark example (complete)

Dark-on-light example (partial)

Reference: https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

Define a string that starts a color and a string that ends the color. Then print your text with the start string at the front and the end string at the end.

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

This produces the following in Bash, in urxvt with a Zenburn-style color scheme:

Through experimentation, we can get more colors:

Note: 33[5m and 33[6m are blinking.

This way we can create a full color collection:

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'

Here is the code to generate the test:

x = 0
for i in range(24):
  colors = ""
  for j in range(5):
    code = str(x+j)
    colors = colors + "33[" + code + "m\33[" + code + "m33[0m "
  print(colors)
  x = x + 5

Here’s a solution that works on Windows 10 natively.

Using a system call, such as os.system(""), allows colours to be printed in Command Prompt and Powershell natively:

import os

# System call
os.system("")

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

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

Note: Windows does not fully support ANSI codes, whether through system calls or modules. Not all text decoration is supported, and although the bright colours display, they are identical to the regular colours.

Thanks to @j-l for finding an even shorter method.

tl;dr: Add os.system("")

You want to learn about ANSI escape sequences. Here’s a brief example:

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

For more information, see ANSI escape code.

For a block character, try a Unicode character like u2588:

print(u"u2588")

Putting it all together:

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

sty is similar to colorama, but it’s less verbose, supports 8-bit and 24-bit (RGB) colors, supports all effects (bold, underline, etc.), allows you to register your own styles, is fully typed and high performant, supports muting, is not messing with globals such as sys.stdout, is really flexible, well documented and more…

Examples:

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

prints:

Demo:

Rich is a relatively new Python library for working with color in the terminal.

There are a few ways of working with color in Rich. The quickest way to get started would be the rich print method which renders a BBCode-like syntax in to ANSI control codes:

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

There are other ways of applying color with Rich (regex, syntax) and related formatting features.

This is, in my opinion, the easiest method. As long as you have the RGB values of the color you want, this should work:

def colored(r, g, b, text):
    return f"33[38;2;{r};{g};{b}m{text}33[0m"

An example of printing red text:

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

#or

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

Multi-colored text

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

My favorite way is with the Blessings library (full disclosure: I wrote it). For example:

from blessings import Terminal

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

To print colored bricks, the most reliable way is to print spaces with background colors. I use this technique to draw the progress bar in nose-progressive:

print t.on_green(' ')

You can print in specific locations as well:

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

If you have to muck with other terminal capabilities in the course of your game, you can do that as well. You can use Python’s standard string formatting to keep it readable:

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

The nice thing about Blessings is that it does its best to work on all sorts of terminals, not just the (overwhelmingly common) ANSI-color ones. It also keeps unreadable escape sequences out of your code while remaining concise to use. Have fun!

I generated a class with all the colors using a for loop to iterate every combination of color up to 100, and then wrote a class with Python colors. Copy and paste as you will, GPLv2 by me:

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='33[0m'
    bold='33[01m'
    disable='33[02m'
    underline='33[04m'
    reverse='33[07m'
    strikethrough='33[09m'
    invisible='33[08m'
    class fg:
        black='33[30m'
        red='33[31m'
        green='33[32m'
        orange='33[33m'
        blue='33[34m'
        purple='33[35m'
        cyan='33[36m'
        lightgrey='33[37m'
        darkgrey='33[90m'
        lightred='33[91m'
        lightgreen='33[92m'
        yellow='33[93m'
        lightblue='33[94m'
        pink='33[95m'
        lightcyan='33[96m'
    class bg:
        black='33[40m'
        red='33[41m'
        green='33[42m'
        orange='33[43m'
        blue='33[44m'
        purple='33[45m'
        cyan='33[46m'
        lightgrey='33[47m'

Try this simple code

def prRed(prt):
    print(f"33[91m{prt}33[00m")

def prGreen(prt):
    print(f"33[92m{prt}33[00m")

def prYellow(prt):
    print(f"33[93m{prt}33[00m")

def prLightPurple(prt):
    print(f"33[94m{prt}33[00m")

def prPurple(prt):
    print(f"33[95m{prt}33[00m")

def prCyan(prt):
    print(f"33[96m{prt}33[00m")

def prLightGray(prt):
    print(f"33[97m{prt}33[00m")

def prBlack(prt):
    print(f"33[98m{prt}33[00m")

def prReset(prt):
    print(f"33[0m{prt}33[00m")

prGreen("Hello, Green World!")
prBlack("Hello, Black World!")
prCyan("Hello, Cyan World!")
prGreen("Hello, Green World!")
prLightGray("Hello, Light Grey World!")
prLightPurple("Hello, Light Purple World!")
prPurple("Hello, Purple World!")
prRed("Hello, Red World!")
prYellow("Hello, Yellow World!")
prReset("Hello, Reset World!")

Python 3 Example

# python2
    def prRed(prt): print("33[91m {}33[00m" .format(prt))
    def prGreen(prt): print("33[92m {}33[00m" .format(prt))
    def prYellow(prt): print("33[93m {}33[00m" .format(prt))
    def prLightPurple(prt): print("33[94m {}33[00m" .format(prt))
    def prPurple(prt): print("33[95m {}33[00m" .format(prt))
    def prCyan(prt): print("33[96m {}33[00m" .format(prt))
    def prLightGray(prt): print("33[97m {}33[00m" .format(prt))
    def prBlack(prt): print("33[98m {}33[00m" .format(prt))

    prGreen("Hello, World!")

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

Try it online

I have a library called colorit. It is super simple.

Here are some examples:

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

This gives you:

It’s also worth noting that this is cross platform and has been tested on Mac, Linux, and Windows.

You might want to try it out: https://github.com/SuperMaZingCoder/colorit

colorit is now available to be installed with PyPi! You can install it with pip install color-it on Windows and pip3 install color-it on macOS and Linux.

On Windows you can use module ‘win32console’ (available in some Python distributions) or module ‘ctypes’ (Python 2.5 and up) to access the Win32 API.

To see complete code that supports both ways, see the color console reporting code from Testoob.

ctypes example:

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)

I have wrapped joeld’s answer into a module with global functions that I can use anywhere in my code.

File: log.py

def enable():
    HEADER = '33[95m'
    OKBLUE = '33[94m'
    OKGREEN = '33[92m'
    WARNING = '33[93m'
    FAIL = '33[91m'
    ENDC = '33[0m'
    BOLD = "33[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()

Use as follows:

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

Here is my modern (2021) solution: yachalk

It is one of the few libraries that properly supports nested styles:

Apart from that yachalk is auto-complete-friendly, has 256/truecolor support, comes with terminal-capability detection, and is fully typed.

Here are some design decision you may consider for choosing your solution.

High-level libraries vs low-level libraries / manual style handling?

Many answers to this question demonstrate how to ANSI escape codes directly, or suggest low-level libraries that require manual style enabling/disabling.

These approaches have subtle issues: Inserting on/off styles manually is

• more verbose syntactically, because resets have to be specified explicitly,
• more error prone, because you can accidentally forget to reset a style,
• fails to get edge cases right: For instance in some terminals it is necessary to reset styles before newlines, and re-activate them after the line break. Also, some terminal have problems with simply overriding mutually exclusive styles, and require inserting “unnecessary” reset codes. If a developer’s local terminal doesn’t have these quirks, the developer will not discover these quirks immediately. The issue will only be reported later by others or cause problems e.g. on CI terminals.

Therefore if compatibility with many terminals is a goal, it’s best to use a high-level library that offers automatic handling of style resets. This allows the library to take care of all edge cases by inserting the “spurious” ANSI escape codes where needed.

Why yet another library?

In JavaScript the de-facto standard library for the task is chalk, and after using it for a while in JS projects, the solutions available in the Python world were lacking in comparison. Not only is the chalk API more convenient to use (fully auto-complete compatible), it also gets all the edge cases right.

The idea of yachalk is to bring the same convenience to the Python ecosystem. If you’re interested in a comparison to other libraries I’ve started feature comparison on the projects page. In addition, here is a long (but still incomplete) list of alternatives that came up during my research — a lot to choose from 🙂

• colored
• ansicolors
• termcolor
• colorama
• colorist
• sty
• blessings
• rich
• colorit
• colorprint
• console-color
• pyfance
• couleur
• style (formerly known as clr)
• pychalk
• simple-chalk
• chlk
• chalky
• constyle

def black(text):
    print('33[30m', text, '33[0m', sep='')

def red(text):
    print('33[31m', text, '33[0m', sep='')

def green(text):
    print('33[32m', text, '33[0m', sep='')

def yellow(text):
    print('33[33m', text, '33[0m', sep='')

def blue(text):
    print('33[34m', text, '33[0m', sep='')

def magenta(text):
    print('33[35m', text, '33[0m', sep='')

def cyan(text):
    print('33[36m', text, '33[0m', sep='')

def gray(text):
    print('33[90m', text, '33[0m', sep='')


black("BLACK")
red("RED")
green("GREEN")
yellow("YELLOW")
blue("BLACK")
magenta("MAGENTA")
cyan("CYAN")
gray("GRAY")

Try online

I ended up doing this, and I felt it was cleanest:

formatters = {
    'RED': '33[91m',
    'GREEN': '33[92m',
    'END': '33[0m',
}

print 'Master is currently {RED}red{END}!'.format(**formatters)
print 'Help make master {GREEN}green{END} again!'.format(**formatters)

For Windows you cannot print to console with colors unless you’re using the Win32 API.

For Linux it’s as simple as using print, with the escape sequences outlined here:

Colors

For the character to print like a box, it really depends on what font you are using for the console window. The pound symbol works well, but it depends on the font:

#

Stupidly simple, based on joeld’s answer:

class PrintInColor:
    RED = '33[91m'
    GREEN = '33[92m'
    YELLOW = '33[93m'
    LIGHT_PURPLE = '33[94m'
    PURPLE = '33[95m'
    END = '33[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)

Then just

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

Building on joeld’s answer, using 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

Screenshot:

Some updates to the color_print with new formatters, e.g.:

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

Note: italic, fast blinking, and strikethrough may not work on all terminals, and they don’t work on Mac and Ubuntu.

E.g.,

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

Screenshot:

Note how well the with keyword mixes with modifiers like these that need to be reset (using Python 3 and 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")

You could use Clint:

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

You can use the Python implementation of the curses library:
curses — Terminal handling for character-cell displays

Also, run this and you’ll find your box:

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

Emoji

You can use colors for text as others mentioned in their answers to have colorful text with a background or foreground color.

But you can use emojis instead! for example, you can use⚠️ for warning messages and ???? for error messages.

Or simply use these notebooks as a color:

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

???? Bonus:

This method also helps you to quickly scan and find logs directly in the source code.

_{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.}

How to open emoji picker?

mac os: control + command + space

windows: win + .

linux: control + . or control + ;

If you are programming a game perhaps you would like to change the background color and use only spaces? For example:

print " "+ "33[01;41m" + " " +"33[01;46m"  + "  " + "33[01;42m"

An easier option would be to use the cprint function from the termcolor package.

It also supports %s, %d format of printing:

Results can be terminal dependant, so review the Terminal Properties section of the package documentation.

• Windows Command Prompt and Python IDLE don’t work

• JupyterLab notebook does work

The simplest and convenient way of doing this, considering if you’re writing a command-line tool.
This method will work anywhere on all consoles, without installing any fancy packages.

To get the ANSI codes working on Windows, first, run os.system('color')

import os
os.system('color')

COLOR = '33[91m'  # change it, according to the color need

END = '33[0m'

print(COLOR + "Hello World" + END) #print a message


exit=input() #to avoid closing the terminal windows

For more colours :

Note: 33[5m and 33[6m are blinking.

Thanks to @qubodup