Wie kann ich in Python farbigen Text an das Terminal ausgeben? Was ist das beste Unicode-Symbol für einen Volumenblock?

Dies hängt etwas davon ab, auf welcher Plattform Sie sich befinden. Der häufigste Weg, dies zu tun, ist das Drucken von ANSI-Escape-Sequenzen. Als einfaches Beispiel finden Sie hier einige Python-Codes aus den Blender-Build-Skripten :

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

Um solchen Code zu verwenden, können Sie so etwas tun

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

oder mit Python3.6 +:

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

Dies funktioniert unter Unixen wie OS X, Linux und Windows (vorausgesetzt, Sie verwenden ANSICON oder in Windows 10, sofern Sie die VT100-Emulation aktivieren ). Es gibt Ansi-Codes zum Einstellen der Farbe, Bewegen des Cursors und mehr.

Wenn Sie damit kompliziert werden (und es klingt so, als ob Sie ein Spiel schreiben), sollten Sie sich das Modul "Flüche" ansehen, das viele der komplizierten Teile davon für Sie behandelt. Das Python Curses HowTO ist eine gute Einführung.

Wenn Sie kein erweitertes ASCII verwenden (dh nicht auf einem PC), bleiben Sie bei den ASCII-Zeichen unter 127 hängen, und '#' oder '@' ist wahrscheinlich die beste Wahl für einen Block. Wenn Sie sicherstellen können, dass Ihr Terminal einen erweiterten IBM ASCII-Zeichensatz verwendet , haben Sie viele weitere Optionen. Die Zeichen 176, 177, 178 und 219 sind die "Blockzeichen".

Einige moderne textbasierte Programme wie "Dwarf Fortress" emulieren den Textmodus in einem grafischen Modus und verwenden Bilder der klassischen PC-Schriftart. Einige dieser Bitmaps, die Sie verwenden können, finden Sie im Zwergenfestungs-Wiki ( benutzerdefinierte Kachelsätze ).

Der Demo-Wettbewerb im Textmodus bietet mehr Ressourcen für die Erstellung von Grafiken im Textmodus.

Hmm .. Ich denke, diese Antwort hat mich ein wenig mitgerissen. Ich bin jedoch gerade dabei, ein episches textbasiertes Abenteuerspiel zu planen. Viel Glück mit Ihrem farbigen Text!

Ich bin überrascht, dass niemand das Python-Termcolor-Modul erwähnt hat . Die Verwendung ist ziemlich einfach:

from termcolor import colored

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

Oder in Python 3:

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

Es ist jedoch möglicherweise nicht hoch genug für die Spielprogrammierung und die "farbigen Blöcke", die Sie ausführen möchten ...

Die Antwort lautet Colorama für alle plattformübergreifenden Farben in Python.

Ein Python 3.6-Beispiel-Screenshot:

Drucken Sie eine Zeichenfolge, die eine Farbe / einen Stil beginnt, dann die Zeichenfolge und beenden Sie die Farb- / Stiländerung mit '\x1b[0m':

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

Rufen Sie eine Tabelle mit Formatoptionen für Shell-Text mit folgendem Code ab:

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

Hell-Dunkel-Beispiel (vollständig)

Beispiel Dark-on-Light (teilweise)

Definieren Sie eine Zeichenfolge, die eine Farbe beginnt, und eine Zeichenfolge, die die Farbe beendet, und drucken Sie dann Ihren Text mit der Startzeichenfolge vorne und der Endzeichenfolge am Ende.

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

Dadurch ergibt sich die folgende in bash, in urxvtmit einem Farbschema Zenburn-style:

Durch Experimente können wir mehr Farben erhalten:

Hinweis: \33[5mund \33[6mblinken.

Auf diese Weise können wir eine vollständige Farbkollektion erstellen:

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'

Hier ist der Code zum Generieren des Tests:

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

Sie möchten mehr über ANSI-Escape-Sequenzen erfahren. Hier ist ein kurzes Beispiel:

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

Weitere Informationen finden Sie unter http://en.wikipedia.org/wiki/ANSI_escape_code

Versuchen Sie für ein Blockzeichen ein Unicode-Zeichen wie \ u2588:

print(u"\u2588")

Alles zusammen:

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

Ich antworte, weil ich eine Möglichkeit gefunden habe, ANSI-Codes unter Windows 10 zu verwenden, damit Sie die Farbe von Text ohne Module ändern können, die nicht integriert sind:

Die Zeile, mit der dies funktioniert, ist os.system("")oder ein anderer Systemaufruf, mit dem Sie ANSI-Codes im Terminal drucken können:

import os

os.system("")

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

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

Hinweis: Obwohl dies dieselben Optionen wie andere Windows-Optionen bietet, unterstützt Windows ANSI-Codes trotz dieses Tricks nicht vollständig. Nicht alle Textdekorationsfarben funktionieren und alle "hellen" Farben (Codes 90-97 und 100-107) zeigen die gleichen Farben wie die regulären Farben (Codes 30-37 und 40-47).

Edit : Danke an @jl für die Suche nach einer noch kürzeren Methode.

tl; dr : Fügen Sie os.system("")oben in Ihrer Datei hinzu.

Python-Version: 3.6.7

Mein Lieblingsweg ist die Blessings- Bibliothek (vollständige Offenlegung: Ich habe sie geschrieben). Zum Beispiel:

from blessings import Terminal

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

Um farbige Steine ​​zu drucken, ist es am zuverlässigsten, Räume mit Hintergrundfarben zu drucken. Ich benutze diese Technik, um den Fortschrittsbalken in nasenprogressiv zu zeichnen :

print t.on_green(' ')

Sie können auch an bestimmten Orten drucken:

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

Wenn Sie sich im Laufe Ihres Spiels mit anderen Terminalfunktionen herumschlagen müssen, können Sie dies auch tun. Sie können die Standard-Zeichenfolgenformatierung von Python verwenden, um die Lesbarkeit zu gewährleisten:

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

Das Schöne an Blessings ist, dass es sein Bestes tut, um an allen Arten von Terminals zu arbeiten, nicht nur an den (überwiegend üblichen) ANSI-Farbterminals. Außerdem werden unlesbare Escape-Sequenzen aus Ihrem Code herausgehalten, während die Verwendung präzise bleibt. Habe Spaß!

sty ähnelt colorama, ist jedoch weniger ausführlich, unterstützt 8- Bit- und 24- Bit- Farben (RGB), ermöglicht das Registrieren eigener Stile, unterstützt Muting, ist sehr flexibel, gut dokumentiert und bietet mehr.

Beispiele:

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

Drucke:

Demo:

Generierte eine Klasse mit allen Farben mithilfe einer for-Schleife, um jede Farbkombination bis zu 100 zu wiederholen, und schrieb dann eine Klasse mit Python-Farben. Kopieren Sie und fügen Sie ein, wie Sie wollen, GPLv2 von mir:

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'

Versuchen Sie diesen einfachen Code

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

Unter Windows können Sie das Modul 'win32console' (in einigen Python-Distributionen verfügbar) oder das Modul 'ctypes' (Python 2.5 und höher) verwenden, um auf die Win32-API zuzugreifen.

Informationen zum vollständigen Code, der beide Möglichkeiten unterstützt, finden Sie im Farbkonsolen-Berichtscode von Testoob .

ctypes Beispiel:

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)

Dumm einfach, basierend auf @ joelds Antwort

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)

Dann einfach

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

Ich habe die Antwort von @joeld in ein Modul mit globalen Funktionen eingeschlossen, die ich überall in meinem Code verwenden kann.

Datei: log.py.

HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = "\033[1m"

def disable():
    HEADER = ''
    OKBLUE = ''
    OKGREEN = ''
    WARNING = ''
    FAIL = ''
    ENDC = ''

def infog( msg):
    print OKGREEN + msg + ENDC

def info( msg):
    print OKBLUE + msg + ENDC

def warn( msg):
    print WARNING + msg + ENDC

def err( msg):
    print FAIL + msg + ENDC

Verwenden Sie wie folgt:

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

Unter Windows können Sie nur dann mit Farben auf der Konsole drucken, wenn Sie win32api verwenden.

Für Linux ist es so einfach wie das Verwenden von print. Die hier beschriebenen Escape-Sequenzen sind:

Farben

Damit das Zeichen wie eine Box gedruckt werden kann, hängt es wirklich davon ab, welche Schriftart Sie für das Konsolenfenster verwenden. Das Pfund-Symbol funktioniert gut, hängt jedoch von der Schriftart ab:

#

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

Am Ende tat ich das, ich fand es am saubersten:

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)

Aufbauend auf der Antwort von @joeld unter Verwendung von 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

Bildschirmfoto:

Einige Updates color_printmit neuen Formatierern, zB:

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

Hinweis: italic, fast blinkingund strikethroughkann auf allen Endgeräten nicht funktioniert, funktioniert nicht auf Mac / Ubuntu.

Z.B

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

Bildschirmfoto:

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

Versuchen Sie es online

Beachten Sie, wie gut sich das withSchlüsselwort mit solchen Modifikatoren mischt, die zurückgesetzt werden müssen (mit Python 3 und 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")

Sie können die Python-Implementierung der Curses-Bibliothek verwenden: http://docs.python.org/library/curses.html

Führen Sie dies auch aus und Sie finden Ihre Box:

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

Sie könnten CLINT verwenden:

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

Hol es dir von GitHub .

Ich weiß, dass ich zu spät komme. Aber ich habe eine Bibliothek namens ColorIt . Es ist super einfach.

Hier sind einige Beispiele:

from ColorIt import *

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

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

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

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

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

Dies gibt Ihnen:

Es ist auch erwähnenswert, dass dies plattformübergreifend ist und unter Mac, Linux und Windows getestet wurde.

Vielleicht möchten Sie es ausprobieren: https://github.com/CodeForeverAndEver/ColorIt

Hinweis: Blinken, Kursivschrift, Fettdruck usw. werden in wenigen Tagen hinzugefügt.

Wenn Sie ein Spiel programmieren, möchten Sie vielleicht die Hintergrundfarbe ändern und nur Leerzeichen verwenden? Zum Beispiel:

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

Wenn Sie Windows verwenden, können Sie loslegen!

# display text on a Windows console
# Windows XP with Python27 or Python32
from ctypes import windll
# needed for Python2/Python3 diff
try:
    input = raw_input
except:
    pass
STD_OUTPUT_HANDLE = -11
stdout_handle = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
# look at the output and select the color you want
# for instance hex E is yellow on black
# hex 1E is yellow on blue
# hex 2E is yellow on green and so on
for color in range(0, 75):
     windll.kernel32.SetConsoleTextAttribute(stdout_handle, color)
     print("%X --> %s" % (color, "Have a fine day!"))
     input("Press Enter to go on ... ")

Wenn Sie Django verwenden

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

Schnappschuss:

(Ich verwende im Allgemeinen eine farbige Ausgabe zum Debuggen auf dem Runserver-Terminal, also habe ich sie hinzugefügt.)

_{Sie können testen, ob es auf Ihrem Computer
$ python -c "import django; print django.VERSION"
installiert ist : Um es zu installieren, überprüfen Sie: So installieren Sie Django}

Versuche es!!

Hier ist ein Fluchbeispiel:

import curses

def main(stdscr):
    stdscr.clear()
    if curses.has_colors():
        for i in xrange(1, curses.COLORS):
            curses.init_pair(i, i, curses.COLOR_BLACK)
            stdscr.addstr("COLOR %d! " % i, curses.color_pair(i))
            stdscr.addstr("BOLD! ", curses.color_pair(i) | curses.A_BOLD)
            stdscr.addstr("STANDOUT! ", curses.color_pair(i) | curses.A_STANDOUT)
            stdscr.addstr("UNDERLINE! ", curses.color_pair(i) | curses.A_UNDERLINE)
            stdscr.addstr("BLINK! ", curses.color_pair(i) | curses.A_BLINK)
            stdscr.addstr("DIM! ", curses.color_pair(i) | curses.A_DIM)
            stdscr.addstr("REVERSE! ", curses.color_pair(i) | curses.A_REVERSE)
    stdscr.refresh()
    stdscr.getch()

if __name__ == '__main__':
    print "init..."
    curses.wrapper(main)

https://raw.github.com/fabric/fabric/master/fabric/colors.py

"""
.. versionadded:: 0.9.2

Functions for wrapping strings in ANSI color codes.

Each function within this module returns the input string ``text``, wrapped
with ANSI color codes for the appropriate color.

For example, to print some text as green on supporting terminals::

    from fabric.colors import green

    print(green("This text is green!"))

Because these functions simply return modified strings, you can nest them::

    from fabric.colors import red, green

    print(red("This sentence is red, except for " + \
          green("these words, which are green") + "."))

If ``bold`` is set to ``True``, the ANSI flag for bolding will be flipped on
for that particular invocation, which usually shows up as a bold or brighter
version of the original color on most terminals.
"""


def _wrap_with(code):

    def inner(text, bold=False):
        c = code
        if bold:
            c = "1;%s" % c
        return "\033[%sm%s\033[0m" % (c, text)
    return inner

red = _wrap_with('31')
green = _wrap_with('32')
yellow = _wrap_with('33')
blue = _wrap_with('34')
magenta = _wrap_with('35')
cyan = _wrap_with('36')
white = _wrap_with('37')

asciimatics bietet eine tragbare Unterstützung für das Erstellen von Textoberflächen und Animationen:

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

Noch ein Pypi-Modul, das die Python 3-Druckfunktion umschließt:

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

Es ist in Python 2.x verwendbar, wenn Sie auch from __future__ import print. Hier ist ein Python 2-Beispiel von der Modul-Pypi-Seite:

from __future__ import print_function
from colorprint import *

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

Ausgänge "Hallo Welt!" mit den Wörtern in blau und dem Ausrufezeichen fett rot und blinkend.