ändern - python3 print color




Im Terminal mit Farben drucken? (20)

Für die Charaktere

Ihr Terminal verwendet höchstwahrscheinlich Unicode-Zeichen (normalerweise UTF-8-codiert). Es ist also nur eine Frage der richtigen Schriftart, um Ihren Lieblingscharakter zu sehen. Unicode char U + 2588, "Voller Block" ist derjenige, den ich vorschlagen würde, den Sie verwenden.

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 .

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


YAY! Andere Version

Während ich this Antwort nützlich finde, habe ich sie ein wenig modifiziert. dieser Github Gist ist das Ergebnis

Verwendung

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

Darüber hinaus können Sie gängige Verwendungen verpacken:

print colors.error('sorry, ')

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


Aufbauend auf @joeld antwort mit 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 des color_print mit 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 blinking und strikethrough möglicherweise nicht auf allen Terminals, 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:


Beachten Sie, wie gut sich das Schlüsselwort with mit 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")

Die Antwort ist Colorama für alle plattformübergreifenden Kolorierungen in Python.

Ein Python 3.6 Beispiel Screenshot:


Dies hängt davon ab, auf welcher Plattform Sie sich befinden. Die gebräuchlichste Methode ist das Drucken von ANSI-Escape-Sequenzen. Für ein einfaches Beispiel, hier ist etwas Python-Code von 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 Code wie diesen zu verwenden, können Sie etwas wie tun

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

Dies funktioniert mit 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, Bewegen des Cursors und mehr.

Wenn Sie damit kompliziert werden (und es klingt wie Sie sind, wenn Sie ein Spiel schreiben), sollten Sie in das Modul "Flüche" schauen, das viele der komplizierten Teile davon für Sie behandelt. Die Python Curses HowTo ist eine gute Einführung.

Wenn Sie kein erweitertes ASCII verwenden (dh nicht auf einem PC), stecken Sie mit den ASCII-Zeichen unter 127 fest, und "#" oder "@" ist wahrscheinlich die beste Option für einen Block. Wenn Sie sicherstellen können, dass Ihr Terminal einen erweiterten ASCII-Zeichensatz von IBM 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. Sie können einige dieser Bitmaps finden, die Sie im Dwarf Fortress Wiki verwenden können ( benutzerdefinierte Tilesets ).

Der Textmodus- Demowettbewerb bietet mehr Ressourcen für Grafiken im Textmodus.

Hmm .. Ich glaube, diese Antwort hat mich ein wenig mitreißen lassen. Ich bin gerade dabei, ein episches textbasiertes Abenteuerspiel zu planen. Viel Glück mit Ihrem farbigen Text!


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

Ein weiteres 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 aus der Modulpypi-Seite:

from __future__ import print_function
from colorprint import *

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

Ausgaben "Hallo, Welt!" mit den Worten in blau und dem Ausrufezeichen fett rot und blinkend.


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

Für die Programmierung von Spielen und die "farbigen Blöcke", die Sie machen möchten, ist es jedoch nicht ausgereift ...


Ich habe @joeld answer in ein Modul mit globalen Funktionen eingepackt, 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

verwende wie folgt:

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

Ich schrieb ein einfaches Modul, verfügbar 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. Sie haben Farben, Cursorpositionierung und Tastatureingabe. Es ist kein Ersatz für Flüche, aber kann sehr nützlich sein, wenn Sie in einfachen Skripten oder ASCII-Spielen verwenden müssen.


Mein liebster Weg ist mit der Blessings Bibliothek (vollständige Offenlegung: Ich habe es geschrieben). Beispielsweise:

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 der zuverlässigste Weg, Räume mit Hintergrundfarben zu drucken. Ich benutze 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 Ihres Spiels mit anderen Terminalfähigkeiten herumspielen müssen, können Sie das auch tun. Sie können die Standardzeichenfolgenformatierung 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, an allen Arten von Terminals zu arbeiten, nicht nur an den (überwiegend üblichen) ANSI-Farben. Es hält auch unlesbare Escape-Sequenzen aus Ihrem Code heraus, während es übersichtlich bleibt. Habe Spaß!



Sie könnten CLINT :

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

Hol es dir von GitHub .


Unter Windows können Sie das Modul 'win32console' (verfügbar in einigen Python-Distributionen) 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)

Unter Windows können Sie nicht mit Farben in der Konsole drucken, es sei denn, Sie verwenden win32api.

Für Linux ist es so einfach wie das Drucken mit den hier beschriebenen Escape-Sequenzen:

Colors

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:

#

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

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

Wenn du Django

>>> 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 normalerweise farbige Ausgabe zum Debuggen auf dem Runserver-Terminal, also habe ich es hinzugefügt.)

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

Versuche es!!


asciimatics bietet eine portable Unterstützung für die asciimatics 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:


sty ist ähnlich wie colorama, aber es ist weniger verbose, unterstützt 8bit und 24bit (rgb) farben, ermöglicht es ihnen, ihre eigenen farben zu registrieren, ist wirklich flexibel und gut dokumentiert. Wenn Sie nicht auf die Kompatibilität mit Terminalemulatoren achten, die in den 90ern stecken bleiben und neue Funktionen nutzen möchten, sollten Sie es ausprobieren.

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

fg.orange = ('rgb', (255, 150, 50))

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


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

Drucke:

Demo:





ansi-colors