Wie drucke ich farbigen Text auf dem Terminal in Python?

Question

Wie kann ich in Python farbigen Text auf dem Terminal ausgeben?

Answer 1

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.

Um zum Beispiel eine rote Farbe auszugeben "Hallo, Welt!" Zeichenfolge in Ihrem Terminal:

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

Oder über ein Python-Skript:

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

Außerdem habe ich einen Artikel über Fluchtsequenzen die Ihnen wahrscheinlich helfen kann, diesen Mechanismus besser zu verstehen.

Answer 2

Einige der Lösungen wie:

fg = lambda text, color: "\33[38;5;" + str(color) + "m" + text + "\33[0m"
bg = lambda text, color: "\33[48;5;" + str(color) + "m" + text + "\33[0m"

def print_six(row, format, end="\n"):
    for col in range(6):
        color = row*6 + col - 2
        if color>=0:
            text = "{:3d}".format(color)
            print (format(text,color), end=" ")
        else:
            print(end="    ")   # Four spaces
    print(end=end)

for row in range(0, 43):
    print_six(row, fg, " ")
    print_six(row, bg)

print(fg("text", 160))

O

def colored(r, g, b, text):
    return "\033[38;2;{};{};{}m{} \033[38;2;255;255;255m".format(r, g, b, text)

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

O

class Color:
    COLOR = [f"\33[{i}m" for i in range(44)]

for i in range(44):
    print(Color.COLOR[i] + 'text')

könnte nicht funktionieren auf Windows 10-Terminals oder PowerShell-Windows oder es gibt andere Fälle, in denen diese nicht direkt funktionieren.

Aber beim Einfügen könnten diese beiden kleinen Zeilen am Anfang des Programms helfen:

import os
os.system('')

os.system('') ermöglicht es Ihnen, ANSI-Codes im Terminal auszudrucken, die Ihre Ausgabe entsprechend Ihrer Wahl einfärben (es kann aber auch andere systemspezifische Funktionen geben, die Sie aufrufen müssen, um farbigen Text im Terminal ausgeben zu können).

Answer 3

Um dieses Problem zu lösen, habe ich ein verblüffend einfaches Paket erstellt, das Zeichenketten mit interpolierten Farbcodes ausgibt, genannt icolor .

icolor umfasst zwei Funktionen: cformat y cprint , die jeweils eine Zeichenkette mit Teilstrings aufnehmen, die interpoliert werden, um ANSI-Escape-Sequenzen zu entsprechen, z. B.

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.), als auch #RESET; , #BOLD; und andere.

Hintergrundfarben haben einen x Präfix, so dass ein grüner Hintergrund wie folgt aussehen würde #xGREEN; .

Man kann entkommen # con ## .

Angesichts ihrer Einfachheit ist die beste Dokumentation wahrscheinlich der Code selbst .

Sie ist über PYPI so kann man sudo easy_install icolor .

Answer 4

Sie könnten die pygments Modul, um dies zu tun. Zum Beispiel:

from pygments import console
print(pygments.console.colorize("red", "This text is red."))

Dies erlaubt es Ihnen nicht, eine hexadezimale Farbe für das Terminal anzugeben, aber es gibt viele eingebaute Farben, die Sie ausprobieren können, wie "blau", "dunkelgrün", "gelb", usw.

Answer 5

In dieser Antwort wird versucht, das Konzept des Schreibens von eingefärbtem Text auf das Terminal auszuweiten, indem ein regulärer Ausdruck um Schlüsselwörter in einem Textblock einzufärben.

Diese Antwort verwendet auch die Python Bibliothek Reich die in einer früheren Antwort auf diese Frage kurz behandelt wurde. In dieser Antwort verwende ich die Funktion rich.color.ANSI_COLOR_NAMES um eine zufällige Liste von Farben zu erhalten, die zur Hervorhebung vordefinierter Suchbegriffe verwendet werden.

import random
import re as regex
from rich import color
from rich import print

def create_dynamic_regex(search_words):
    """
    This function is used to create a dynamic regular expression
    string and a list of random colors. Both these elements will
    be used in the function colorize_text()

    :param search_words: list of search terms
    :return: regular expression search string and a list of colors
    :rtype: string, list
    """
    colors_required = create_list_of_colors(len(search_words))
    number_of_search_words = len(search_words)
    combined_string = ''
    for search_word in search_words:
        number_of_search_words -= 1
        if number_of_search_words != 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)|')
            combined_string = (combined_string + current_string)
        elif number_of_search_words == 0:
            current_string = ''.join(r'(\b' + search_word + r'\b)')
            combined_string = (combined_string + current_string)
    return combined_string, colors_required

def random_color():
    """
    This function is used to create a random color using the
    Python package rich.
    :return: color name
    :rtype: string
    """
    selected_color = random.choice(list(color.ANSI_COLOR_NAMES.keys()))
    return selected_color

def create_list_of_colors(number_of_colors):
    """
    This function is used to generate a list of colors,
    which will be used in the function colorize_text()
    :param number_of_colors:
    :return: list of colors
    :rtype: list
    """
    list_of_colors = [random_color() for _ in range(number_of_colors)]
    return list_of_colors

def colorize_text(text, regex_string, array_of_colors):
    """
    This function is used to colorize specific words in a text string.
    :param text: text string potentially containing specific words to colorize.
    :param regex_string: regular expression search string
    :param array_of_colors: list of colors
    :return: colorized text
    :rtype: string
    """
    available_colors = array_of_colors
    word_regex = regex.compile(f"{regex_string}", regex.IGNORECASE)
    i = 0
    output = ""
    for word in word_regex.finditer(text):
        get_color = available_colors[word.lastindex - 1]
        output += "".join([text[i:word.start()],
                           "[%s]" % available_colors[word.lastindex - 1],
                           text[word.start():word.end()], "[/%s]" % available_colors[word.lastindex - 1]])
        i = word.end()
    return ''.join([output, text[word.end():]])

def generate_console_output(text_to_search, words_to_find):
    """
    This function is used generate colorized text that will
    be outputting to the console.

    :param text_to_search: text string potentially containing specific words to colorize.
    :param words_to_find: list of search terms.
    :return: A string containing colorized words.
    :rtype: string
    """
    search_terms, colors = create_dynamic_regex(words_to_find)
    colorize_html = colorize_text(text_to_search, search_terms, colors)
    print(colorize_html)

text = "The dog chased the cat that was looking for the mouse that the dog was playing with."
words = ['dog', 'cat', 'mouse']
generate_console_output(text, words)

Hier ist die Druckausgabe des obigen Codes:

Ich habe zwei GISTs zum Einfärben von Text erstellt.

• farbige Textterminalausgabe
• eingefärbter Text HTML-Ausgabe