Jak mogę wydrukować kolorowy tekst na terminalu w Pythonie? Jaki jest najlepszy symbol Unicode reprezentujący bryłę?

To nieco zależy od tego, na jakiej platformie jesteś. Najczęstszym sposobem na to jest wydrukowanie sekwencji ucieczki ANSI. Dla prostego przykładu oto kod Pythona ze skryptów kompilacji blendera :

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'

Aby użyć takiego kodu, możesz zrobić coś takiego

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

lub z Python3.6 +:

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

Będzie to działać na systemach uniksowych, w tym OS X, Linux i Windows (pod warunkiem, że używasz ANSICON lub w Windows 10, pod warunkiem, że włączysz emulację VT100 ). Istnieją kody ansi do ustawiania koloru, przesuwania kursora i nie tylko.

Jeśli zamierzasz się z tym komplikować (i brzmi to tak, jakbyś pisał grę), powinieneś zajrzeć do modułu „przekleństwa”, który obsługuje dla ciebie wiele skomplikowanych części. Python Przekleństwa HOWTO jest dobrym wstępem.

Jeśli nie używasz rozszerzonego ASCII (tj. Nie na PC), utkniesz z postaciami ascii poniżej 127, a „#” lub „@” jest prawdopodobnie najlepszym wyborem dla bloku. Jeśli możesz upewnić się, że twój terminal używa rozszerzonego zestawu znaków ascii IBM , masz o wiele więcej opcji. Znaki 176, 177, 178 i 219 są „znakami blokowymi”.

Niektóre nowoczesne programy tekstowe, takie jak „Dwarf Fortress”, emulują tryb tekstowy w trybie graficznym i wykorzystują obrazy klasycznej czcionki PC. Niektóre z tych bitmap, których możesz użyć na Dwarf Fortress Wiki, patrz ( zestawy klocków wykonane przez użytkownika ).

Tekst Tryb Demo Konkurs ma więcej środków na ten grafiki w trybie tekstowym.

Hmm .. Myślę, że trochę poniosło mnie to pytanie. Jestem jednak w trakcie planowania epickiej gry przygodowej opartej na tekście. Powodzenia z kolorowym tekstem!

Dziwię się, że nikt nie wspomniał o module termcolor Pythona . Użycie jest dość proste:

from termcolor import colored

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

Lub w Python 3:

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

Jednak może nie być wystarczająco wyrafinowany do programowania gier i „kolorowych bloków”, które chcesz zrobić ...

Odpowiedzią jest Colorama na wszystkie kolorowanki międzyplatformowe w Pythonie.

Przykładowy zrzut ekranu w języku Python 3.6:

Wydrukuj ciąg, który rozpoczyna kolor / styl, następnie ciąg, a następnie zakończ zmianę koloru / stylu za pomocą '\x1b[0m':

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

Uzyskaj tabelę opcji formatowania tekstu powłoki z następującym kodem:

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

Przykład jasności na ciemności (kompletny)

Przykład ciemnego światła (częściowy)

Zdefiniuj ciąg rozpoczynający kolor i ciąg kończący kolor, a następnie wydrukuj tekst z ciągiem początkowym na początku i końcowym na końcu.

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

Powoduje to bash, że w urxvtschemacie kolorów w stylu Zenburn:

Dzięki eksperymentom możemy uzyskać więcej kolorów:

Uwaga: \33[5mi \33[6mmigają.

W ten sposób możemy stworzyć pełną kolekcję kolorów:

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'

Oto kod do wygenerowania testu:

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

Chcesz poznać sekwencje specjalne ANSI. Oto krótki przykład:

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

Aby uzyskać więcej informacji, zobacz http://en.wikipedia.org/wiki/ANSI_escape_code

W przypadku znaku bloku wypróbuj znak Unicode, taki jak \ u2588:

print(u"\u2588")

Kładąc wszystko razem:

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

Odpowiadam, ponieważ znalazłem sposób korzystania z kodów ANSI w systemie Windows 10, dzięki czemu możesz zmienić kolor tekstu bez żadnych modułów, które nie są wbudowane:

Linia, która sprawia, że ​​to działa os.system(""), lub dowolne inne wywołanie systemowe, które pozwala wydrukować kody ANSI w terminalu:

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

Uwaga: Chociaż daje to te same opcje, co inne opcje systemu Windows, system Windows nie obsługuje w pełni kodów ANSI, nawet przy tej sztuczce. Nie wszystkie kolory dekoracji tekstu działają, a wszystkie „jasne” kolory (kody 90–97 i 100–107) wyświetlają się tak samo jak zwykłe kolory (kody 30–37 i 40–47)

Edycja : Dzięki @jl za znalezienie jeszcze krótszej metody.

tl; dr : Dodaj os.system("")w górnej części pliku.

Wersja Python: 3.6.7

Moim ulubionym sposobem jest biblioteka Blessings (pełne ujawnienie: napisałem to). Na przykład:

from blessings import Terminal

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

Aby wydrukować kolorowe cegły, najbardziej niezawodnym sposobem jest wydrukowanie przestrzeni w kolorach tła. Używam tej techniki do rysowania paska postępu progresywnie :

print t.on_green(' ')

Możesz również drukować w określonych lokalizacjach:

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

Jeśli w trakcie gry będziesz musiał zmarnować inne możliwości terminalu, możesz to zrobić. Możesz użyć standardowego formatowania napisów w Pythonie, aby zachować jego czytelność:

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

Zaletą Blessings jest to, że najlepiej działa na wszelkiego rodzaju terminalach, nie tylko na (przeważnie powszechnych) kolorach ANSI. Utrzymuje również nieczytelne sekwencje specjalne poza twoim kodem, pozostając jednocześnie zwięzłym w użyciu. Baw się dobrze!

sty jest podobny do colorama, ale jest mniej gadatliwy, obsługuje kolory 8bit i 24bit (rgb), pozwala zarejestrować własne style, obsługuje wyciszanie, jest naprawdę elastyczny, dobrze udokumentowany i więcej.

Przykłady:

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

drukuje:

Próbny:

wygenerował klasę ze wszystkimi kolorami za pomocą pętli for, aby iterować każdą kombinację kolorów do 100, a następnie napisał klasę z kolorami python. Skopiuj i wklej, jak chcesz, GPLv2 przeze mnie:

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'

Wypróbuj ten prosty kod

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

W systemie Windows można użyć modułu „win32console” (dostępnego w niektórych dystrybucjach Pythona) lub modułu „ctypes” (Python 2.5 i nowsze), aby uzyskać dostęp do Win32 API.

Aby zobaczyć pełny kod, który obsługuje oba sposoby, zobacz kod raportowania konsoli kolorów od Testoob .

przykład 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)

Głupio prosta w oparciu o odpowiedź @ joeld

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)

Więc po prostu

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

Zawarłem @joeld odpowiedź w module z funkcjami globalnymi, których mogę używać w dowolnym miejscu w kodzie.

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

użyj w następujący sposób:

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

W systemie Windows nie można drukować na konsoli za pomocą kolorów, chyba że używasz win32api.

W przypadku Linuksa jest to tak proste, jak użycie print, z sekwencjami ucieczki opisanymi tutaj:

Zabarwienie

Aby postać drukowała się jak pudełko, tak naprawdę zależy od tego, jakiej czcionki używasz w oknie konsoli. Symbol funta działa dobrze, ale zależy to od czcionki:

#

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

Skończyło się na tym, czułem, że to było najczystsze:

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)

Opierając się na odpowiedzi @joeld, używając 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

Zrzut ekranu:

Niektóre aktualizacje color_printnowych formatów, np .:

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

Uwaga: italic, fast blinkinga strikethroughmoże nie działać na wszystkich terminalach, nie działa na Mac / Ubuntu.

Na przykład

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

Zrzut ekranu:

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

Wypróbuj online

zwróć uwagę, jak dobrze withsłowo kluczowe miesza się z takimi modyfikatorami, które muszą zostać zresetowane (przy użyciu Python 3 i 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")

Możesz użyć implementacji biblioteki curses w języku Python: http://docs.python.org/library/curses.html

Uruchom także, a znajdziesz swoje pudełko:

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

Możesz użyć CLINT:

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

Pobierz z GitHub .

Wiem, że się spóźniłem. Ale mam bibliotekę o nazwie ColorIt . To jest bardzo proste.

Oto kilka przykładów:

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

To daje ci:

Warto również zauważyć, że jest to platforma wieloplatformowa i została przetestowana na systemach Mac, Linux i Windows.

Możesz spróbować: https://github.com/CodeForeverAndEver/ColorIt

Uwaga: miganie, kursywa, pogrubienie itp. Zostaną dodane za kilka dni.

Jeśli programujesz grę, być może chciałbyś zmienić kolor tła i używać tylko spacji? Na przykład:

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

Jeśli korzystasz z systemu Windows, proszę bardzo!

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

Jeśli używasz Django

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

migawka:

(Generalnie używam kolorowych wyników do debugowania na terminalu runserver, więc go dodałem).

_{Możesz przetestować, czy jest zainstalowany na twoim komputerze:
$ python -c "import django; print django.VERSION"
Aby zainstalować, sprawdź: Jak zainstalować Django}

Spróbuj!!

Oto przykład przekleństwa:

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 zapewnia przenośne wsparcie dla tworzenia tekstowego interfejsu użytkownika i animacji:

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

Jeszcze inny moduł pypi, który otacza funkcję drukowania Python 3:

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

Jest użyteczny w Pythonie 2.x, jeśli Ty również from __future__ import print. Oto przykład python 2 ze strony pypi modułów:

from __future__ import print_function
from colorprint import *

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

Wyjścia „Witaj, świecie!” ze słowami w kolorze niebieskim i wykrzyknikiem pogrubionym czerwonym i migającym.