it-swarm.com.de

In Terminal mit Farben drucken?

Wie kann ich in Python farbigen Text an das Terminal ausgeben? Was ist das beste Unicode-Symbol, das einen festen Block darstellt?

1683
aboSamoor

Dies hängt etwas von der Plattform ab, auf der Sie sich befinden. Dies geschieht am häufigsten durch Drucken von ANSI-Escape-Sequenzen. Hier ein paar Beispiele für Python-Code aus den blender-Build-Skripts :

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 Code wie diesen zu verwenden, können Sie so etwas tun 

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

Dies funktioniert auf Unixen einschließlich 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, zum Bewegen des Cursors und mehr.

Wenn Sie damit kompliziert werden (und es sich anhört, als würden Sie ein Spiel schreiben), sollten Sie in das Modul "curses" schauen, das viele der komplizierten Teile für Sie erledigt. Das Python Curses HowTO ist eine gute Einführung.

Wenn Sie kein erweitertes ASCII verwenden (d. H. Nicht auf einem PC), bleiben Sie mit den ASCII-Zeichen unter 127 stehen, und '#' oder '@' ist wahrscheinlich die beste Wahl für einen Block. Wenn Sie sicherstellen können, dass Ihr Terminal einen IBM extended 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 Dwarf Fortress Wiki unter ( von Benutzern erstellte Tilesets ).

Der Text Mode Demo Contest enthält mehr Ressourcen, um Grafiken im Textmodus auszuführen.

Hmm .. Ich glaube, ich habe diese Antwort ein wenig mitgenommen. Ich bin jedoch gerade dabei, ein episches textbasiertes Abenteuerspiel zu planen. Viel Glück mit Ihrem farbigen Text!

1473
joeld

Ich bin überrascht, dass niemand das Python Termcolor-Modul erwähnt hat. Die Nutzung 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'))

Für die Programmierung von Spielen und die "farbigen Blöcke", die Sie machen möchten, ist dies möglicherweise nicht ausreichend.

630
Samat Jain

Die Antwort lautet Colorama für alle plattformübergreifenden Einfärbungen in Python.

Ein Beispiel für einen Python 3.6-Screenshot:  example screenshot

545
priestc

Drucken Sie einen String, der eine Farbe/einen Stil beginnt, dann den String und beenden Sie die Änderung der Farbe/des Stils mit '\x1b[0m':

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

 Success with green background example

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)

 enter image description here

Dark-on-Light-Beispiel (teilweise)

top part of output

329
rabin utam

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

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

Dies erzeugt in bash, in urxvt mit einem Farbschema im Zenburn-Stil Folgendes:

 output colors

Durch Experimentieren können wir mehr Farben erhalten:

 color matrix

Hinweis: \33[5m und \33[6m blinken.

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

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

print CSI+"31;40m" + u"\u2588" + CSI + "0m"
76
Bryan Oakley

Mein Lieblingsweg ist mit der Blessings library (vollständige Offenlegung: Ich habe es 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 Ziegel zu drucken, drucken Sie Bereiche mit Hintergrundfarben am zuverlässigsten. Ich verwende diese Technik, um den Fortschrittsbalken in nose-progressive 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 im Laufe des Spiels mit anderen Terminalfunktionen arbeiten müssen, können Sie dies auch tun. Sie können die Standard-String-Formatierung von Python verwenden, um sie lesbar zu halten:

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 gibt, um an allen Arten von Terminals zu arbeiten, nicht nur an den (überwältigend üblichen) ANSI-Farben. Es hält auch unlesbare Escape-Sequenzen aus Ihrem Code und bleibt dabei übersichtlich. Habe Spaß!

58
Erik Rose

eine Klasse mit allen Farben mithilfe einer for-Schleife generiert, um jede Farbkombination bis zu 100 zu durchlaufen, und dann eine Klasse mit Python-Farben geschrieben. Kopieren und einfügen, 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'
46
GI Jack

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

sty ähnelt Colorama, ist aber weniger wortreich, unterstützt 8bit und 24bit (rgb) -Farben, ermöglicht das Registrieren eigener Farben, ist wirklich flexibel und gut dokumentiert.

from sty import fg, bg, ef, rs, RgbFg

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 new colors:

fg.set_style('orange', RgbFg(255, 150, 50))

buf = fg.orange + 'Yay, Im orange.' + fg.rs

print(foo, bar, baz, qux, qui, buf, sep='\n')

druckt:

 enter image description here

Demo: enter image description here

29
Rotareti

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.

Den vollständigen Code, der beide Möglichkeiten unterstützt, finden Sie unter Berichtscode der Konsole color from 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)
26
orip

Dumm einfach basierend auf der Antwort von @ 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)

Dann einfach

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

Ich habe @joeld answer in ein Modul mit globalen Funktionen verpackt, das 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")
20
Mohamed Samy

Aufbauend auf der Antwort von @joeld, verwenden Sie https://pypi.python.org/pypi/lazymepip 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:

 enter image description here


Einige Aktualisierungen des color_print mit neuen Formatierern, z.

>>> 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 blinking und strikethrough funktionieren möglicherweise nicht auf allen Terminals, 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:

 enter image description here

18
alvas

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

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

Farben

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

#
18
UberJumper

Am Ende habe ich das getan, ich hatte das Gefühl, dass es am saubersten war: 

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

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

Führe das auch aus und du findest deine Box:

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

Sie könnten CLINT verwenden:

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

Holen Sie es von GitHub .

15
Giacomo Lacava

beachten Sie, wie gut sich das Schlüsselwort with mit solchen Modifizierern 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")
15
Janus Troelsen

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"
11
suhib-alsisan

asciimatics bietet eine tragbare Unterstützung für die Erstellung von Textbenutzeroberflä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:

 Rainbow-colored text among ascii noise

10
jfs

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 __== '__main__':
    print "init..."
    curses.wrapper(main)
9
nosklo

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

Noch ein weiteres Pypi-Modul, das die Python 3-Druckfunktion einschließ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 rot und blinkend.

9
drevicko

Wenn Sie Windows verwenden, dann los!

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

YAY! Andere Version

während ich diese antwort nützlich finde, habe ich es ein wenig geändert. dies Github Gist ist das Ergebnis

Verwendungszweck

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

enter image description here

außerdem können Sie die üblichen Verwendungen einpacken:

print colors.error('sorry, ')

asd

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

9
Jossef Harush

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:

image

(Ich benutze normalerweise eine farbige Ausgabe zum Debuggen auf dem Runserver-Terminal, daher habe ich sie hinzugefügt.)

Sie können testen, ob es auf Ihrem Computer installiert ist:
$ python -c "import Django; print Django.VERSION"
Zur Installation prüfen Sie: So installieren Sie Django

Versuche es!!

7
Grijesh Chauhan

Eine einfachere Option wäre die Verwendung der cprint-Funktion aus dem termcolor-Paket.

 color-print-python

Es unterstützt auch das %s, %d-Format des Druckens

 enter image description here

7
kmario23

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

Die Zeile, in der dies funktioniert, lautet os.system('color'), aber um sicherzustellen, dass Sie keine Fehler auslösen, wenn sich die Person nicht unter Windows befindet, können Sie das folgende Skript verwenden:

import os, sys

if sys.platform.lower() == "win32":
    os.system('color')

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

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

Python-Version: 3.6.7 (32 Bit)

7
SimpleBinary
# Pure Python 3.x demo, 256 colors
# Works with bash under Linux

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):
    for col in range(6):
        color = row*6 + col + 4
        if color>=0:
            text = "{:3d}".format(color)
            print (format(text,color), end=" ")
        else:
            print("   ", end=" ")

for row in range(-1,42):
    print_six(row, fg)
    print("",end=" ")
    print_six(row, bg)
    print()

 Text with altering foreground and background, colors 0..141  Text with altering foreground and background, colors 142..255

6
Andriy Makukha

Ich habe ein Modul geschrieben, das Farben in Linux/OSX/Windows verarbeitet. Es unterstützt alle 16 Farben auf allen Plattformen. Sie können Vorder- und Hintergrundfarben zu unterschiedlichen Zeitpunkten einstellen. Die String-Objekte liefern vernünftige Ergebnisse für Dinge wie len () und .capitalize ().

https://github.com/Robpol86/colorclass

example on Windows cmd.exe

3
Robpol86

Für die Charaktere

Ihr Terminal verwendet höchstwahrscheinlich Unicode-Zeichen (normalerweise UTF-8-codiert). Es ist also nur eine Frage der geeigneten Schriftart, um Ihren Lieblingscharakter zu sehen. Unicode-Zeichen U + 2588, "Vollblock" ist das, das ich Ihnen vorschlagen würde.

Versuche Folgendes:

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

Untersuchen Sie die Datei später mit Ihrem bevorzugten Viewer.

Für die Farben

curses ist das Modul, das Sie verwenden möchten. Überprüfen Sie dieses Tutorial .

3
tzot

Verwenden Sie pyfancy es ist eine einfache Möglichkeit, Farbe im Terminal zu erstellen!

Beispiel:

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

Ich habe ein einfaches Modul geschrieben, das verfügbar ist unter: http://pypi.python.org/pypi/colorconsole

Es funktioniert mit Windows, Mac OS X und Linux . Es verwendet ANSI für Linux und Mac, aber native Aufrufe von Konsolenfunktionen unter Windows . Es ist kein Ersatz für Flüche, kann jedoch sehr nützlich sein, wenn Sie in einfachen Skripts oder ASCII -Spielen verwendet werden müssen.

2
nmenezes

Sie können Shell-Escape-Zeichen verwenden, die in jeder Sprache verfügbar sind. Diese Escape-Zeichen beginnen mit dem ESC-Zeichen, gefolgt von einer Reihe von Argumenten.

So geben Sie beispielsweise einen roten Hello world-String in Ihr Terminal ein:

echo "\e[31m Hello world \e[0m"

Oder aus einem Python-Skript:

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

Ich habe auch einen Artikel über Escape-Sequenzen geschrieben, der Ihnen wahrscheinlich dabei helfen wird, diesen Mechanismus besser zu verstehen. Ich hoffe es hilft dir.

1

Um dieses Problem zu lösen, habe ich ein erstaunlich einfaches Paket zum Drucken von Zeichenfolgen mit interpolierten Farbcodes erstellt, die als icolor bezeichnet werden.

icolor umfasst zwei Funktionen: cformat und cprint, von denen jede eine Zeichenfolge mit Teilstrings übernimmt, die interpoliert werden, um sie auf ANSI-Escape-Sequenzen abzubilden, z.

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'

Alle ANSI-Farben sind enthalten (z. B. #RED;, #BLUE; usw.) sowie #RESET;, #BOLD; und andere.

Hintergrundfarben haben ein x-Präfix, ein grüner Hintergrund wäre also #xGREEN;.

Man kann # mit ## umgehen.

Aufgrund der Einfachheit ist die beste Dokumentation wahrscheinlich der Code selbst .

Es ist auf PYPI , also kann man Sudo easy_install icolor.

0
Brian M. Hunt

Ich bin Noob im Python und bin jedes Mal aufgeregt, wenn ich Themen wie dieses entdecke. Aber diesmal (plötzlich) habe ich das Gefühl, was ich sagen soll. Vor allem, weil ich vor wenigen Minuten ein WOW-Ding in Python entdeckt habe (zumindest für mich jetzt):

Kontextmanager

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

BEISPIEL

oder einfach so:

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

Meine zwei Cents ( PyColorTerm ):

Installation:

Sudo apt-get install python-pip
pip install pycolorterm

Python-Skript:

from pycolorterm import pycolorterm

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

"funktioniert OK!" zeigt in grün.

0
Diego Navarro