python रंगों के साथ टर्मिनल में प्रिंट करें?




unicode terminal (24)

मैं पाइथन में टर्मिनल पर रंगीन पाठ कैसे आउटपुट कर सकता हूं? एक ठोस ब्लॉक का प्रतिनिधित्व करने के लिए सबसे अच्छा यूनिकोड प्रतीक क्या है?


यदि आप एक गेम प्रोग्रामिंग कर रहे हैं तो शायद आप पृष्ठभूमि रंग बदलना चाहते हैं और केवल रिक्त स्थान का उपयोग करना चाहते हैं? उदाहरण के लिए:

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


वाह! एक और संस्करण

जबकि मुझे this जवाब उपयोगी लगता है, मैंने इसे थोड़ा सा संशोधित किया। यह गीथब गिस्ट परिणाम है

प्रयोग

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

इसके अलावा आप सामान्य उपयोग लपेट सकते हैं:

print colors.error('sorry, ')

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


मैंने ऐसा करने का अंत किया, मुझे लगा कि यह सबसे साफ था:

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)

पाइथन में सभी क्रॉस-प्लेटफार्म रंगों के लिए रंग कॉलमामा है।

एक पायथन 3.6 उदाहरण स्क्रीनशॉट:


यह कुछ हद तक निर्भर करता है कि आप किस प्लेटफॉर्म पर हैं। ऐसा करने का सबसे आम तरीका एएनएसआई एस्केप अनुक्रमों को प्रिंट करना है। एक साधारण उदाहरण के लिए, ब्लेंडर बिल्ड स्क्रिप्ट से कुछ पायथन कोड यहां दिया गया है:

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'

इस तरह के कोड का उपयोग करने के लिए, आप कुछ ऐसा कर सकते हैं

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

यह ओएस एक्स, लिनक्स और विंडोज़ सहित यूनिक्स पर काम करेगा (बशर्ते आप ANSICON उपयोग ANSICON , या विंडोज 10 में बशर्ते आप वीटी 100 अनुकरण सक्षम करें)। रंग सेट करने, कर्सर को स्थानांतरित करने, आदि के लिए ansi कोड हैं।

यदि आप इसके साथ जटिल होने जा रहे हैं (और ऐसा लगता है जैसे आप एक गेम लिख रहे हैं), तो आपको "शाप" मॉड्यूल को देखना चाहिए, जो आपके लिए इसके जटिल भागों को संभालता है। पाइथन शापित हाउटो एक अच्छा परिचय है।

यदि आप विस्तारित ASCII (यानी पीसी पर नहीं) का उपयोग नहीं कर रहे हैं, तो आप 127 से नीचे एसीआईआई अक्षरों से फंस गए हैं, और '#' या '@' शायद ब्लॉक के लिए आपकी सबसे अच्छी शर्त है। यदि आप यह सुनिश्चित कर सकते हैं कि आपका टर्मिनल आईबीएम विस्तारित एसीआईआई चरित्र सेट का उपयोग कर रहा है, तो आपके पास कई और विकल्प हैं। अक्षर 176, 177, 178 और 21 9 "ब्लॉक वर्ण" हैं।

कुछ आधुनिक पाठ-आधारित कार्यक्रम, जैसे कि "बौने किले", ग्राफिकल मोड में टेक्स्ट मोड का अनुकरण करते हैं, और क्लासिक पीसी फ़ॉन्ट की छवियों का उपयोग करते हैं। आप इनमें से कुछ बिटमैप्स पा सकते हैं जिन्हें आप बौने किले विकी ( उपयोगकर्ता द्वारा बनाए गए टाइल्स ) पर उपयोग कर सकते हैं।

पाठ मोड डेमो प्रतियोगिता में टेक्स्ट मोड में ग्राफिक्स करने के लिए अधिक संसाधन हैं।

हम्म .. मुझे लगता है कि इस जवाब पर थोड़ा दूर ले गया। हालांकि, मैं एक महाकाव्य पाठ-आधारित साहसिक खेल की योजना बनाने के बीच में हूं। अपने रंगीन पाठ के साथ शुभकामनाएँ!


मैंने एक मॉड्यूल लिखा जो लिनक्स / ओएसएक्स / विंडोज़ में रंगों को संभालता है। यह सभी प्लेटफार्मों पर सभी 16 रंगों का समर्थन करता है, आप अलग-अलग समय पर अग्रभूमि और पृष्ठभूमि रंग सेट कर सकते हैं, और स्ट्रिंग ऑब्जेक्ट्स लेन () और .capitalize () जैसी चीजों के लिए सैन परिणाम देते हैं।

https://github.com/Robpol86/colorclass


https://pypi.python.org/pypi/lazyme pip install -U lazyme का उपयोग करके @joeld उत्तर पर बिल्डिंग:

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

स्क्रीनशॉट:

नए color_print साथ color_print कुछ अपडेट, उदाहरण के लिए:

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

नोट: italic , fast blinking और strikethrough सभी टर्मिनलों पर काम नहीं कर सकता है, मैक / उबंटू पर काम नहीं करता है।

उदाहरण के लिए

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

स्क्रीनशॉट:


विंडोज़ पर आप Win32 एपीआई तक पहुंचने के लिए मॉड्यूल 'win32console' (कुछ पायथन वितरण में उपलब्ध) या मॉड्यूल 'ctypes' (पायथन 2.5 और ऊपर) का उपयोग कर सकते हैं।

दोनों तरीकों का समर्थन करने वाले पूर्ण कोड को देखने के लिए, Testoob से रंग कंसोल रिपोर्टिंग कोड देखें

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)

मेरा पसंदीदा तरीका Blessings पुस्तकालय के साथ है (पूर्ण प्रकटीकरण: मैंने इसे लिखा है)। उदाहरण के लिए:

from blessings import Terminal

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

रंगीन ईंटों को मुद्रित करने के लिए, पृष्ठभूमि रंगों के साथ रिक्त स्थान मुद्रित करने का सबसे विश्वसनीय तरीका है। मैं इस तकनीक का उपयोग nose-progressive में प्रगति पट्टी को आकर्षित करने के लिए करता हूं:

print t.on_green(' ')

आप विशिष्ट स्थानों में भी प्रिंट कर सकते हैं:

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

यदि आपको अपने गेम के दौरान अन्य टर्मिनल क्षमताओं के साथ मिलना है, तो आप भी ऐसा कर सकते हैं। आप इसे पठनीय रखने के लिए पायथन के मानक स्ट्रिंग स्वरूपण का उपयोग कर सकते हैं:

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

आशीर्वाद के बारे में अच्छी बात यह है कि यह सभी प्रकार के टर्मिनल पर काम करने के लिए सबसे अच्छा है, न कि केवल (भारी आम) एएनएसआई-रंग वाले। उपयोग करने के लिए संक्षेप में रहते हुए यह आपके कोड से अपठनीय भागने के दृश्य भी रखता है। मज़े करो!


asciimatics पाठ यूआई और एनिमेशन बनाने के लिए एक पोर्टेबल समर्थन प्रदान करता है:

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


यदि आप Django का उपयोग कर रहे हैं

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

स्नैपशॉट:

(मैं आमतौर पर रनरवर टर्मिनल पर डिबगिंग के लिए रंगीन आउटपुट का उपयोग करता हूं इसलिए मैंने इसे जोड़ा।)

आप जांच सकते हैं कि यह आपकी मशीन में स्थापित है या नहीं:
$ python -c "import django; print django.VERSION"
इसे स्थापित करने के लिए जांचें: Django कैसे स्थापित करें

कोशिश करो!!


मैंने वैश्विक कार्यों के साथ एक मॉड्यूल में @joeld उत्तर लपेट लिया है जिसे मैं अपने कोड में कहीं भी उपयोग कर सकता हूं।

फ़ाइल: 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

निम्नानुसार उपयोग करें:

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

@ जोल्ड के जवाब के आधार पर बेवकूफ सरल

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)

फिर बस

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

एक स्ट्रिंग मुद्रित करें जो एक रंग / शैली शुरू करता है, फिर स्ट्रिंग, फिर रंग / शैली परिवर्तन '\x1b[0m' साथ समाप्त करें:

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

निम्नलिखित कोड के साथ खोल पाठ के लिए प्रारूप विकल्पों की एक तालिका प्राप्त करें:

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

लाइट-ऑन-डार्क उदाहरण (पूर्ण)

डार्क-ऑन-लाइट उदाहरण (आंशिक)


फिर भी एक और पाइप मॉड्यूल जो पायथन 3 प्रिंट फ़ंक्शन को लपेटता है:

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

यह python 2.x में प्रयोग योग्य है यदि आप from __future__ import print भी हैं। मॉड्यूल pypi पृष्ठ से एक पायथन 2 उदाहरण यहां दिया गया है:

from __future__ import print_function
from colorprint import *

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

आउटपुट "हैलो, दुनिया!" नीले रंग के शब्दों और विस्मयादिबोधक चिह्न बोल्ड लाल और चमकते हैं।


ध्यान दें कि कीवर्ड के साथ संशोधक के with कितना अच्छा मिश्रण होता है, जिन्हें रीसेट करने की आवश्यकता होती है (पायथन 3 और कोलोरामा का उपयोग करके):

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

विंडोज़ के लिए आप रंगों के साथ कंसोल पर प्रिंट नहीं कर सकते हैं जब तक कि आप Win32api का उपयोग नहीं कर रहे हों।

लिनक्स के लिए यह प्रिंट का उपयोग करने जितना आसान है, यहां वर्णित दृश्य दृश्यों के साथ:

Colors

चरित्र के लिए एक बॉक्स की तरह प्रिंट करने के लिए, यह वास्तव में इस बात पर निर्भर करता है कि आप कंसोल विंडो के लिए किस फ़ॉन्ट का उपयोग कर रहे हैं। पाउंड प्रतीक अच्छी तरह से काम करता है, लेकिन यह फ़ॉन्ट पर निर्भर करता है:

#

यहां एक शाप उदाहरण है:

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)

यदि आप विंडोज का उपयोग कर रहे हैं, तो आप यहां जाएं!

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

एक स्ट्रिंग को परिभाषित करें जो एक रंग और एक स्ट्रिंग जो रंग को समाप्त करता है, फिर अंत में स्टार्ट स्ट्रिंग के साथ अपने पाठ को प्रिंट करें और अंत में अंत स्ट्रिंग को प्रिंट करें।

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

यह ज़ेनबर्न-शैली रंग योजना के साथ urxvt में, bash में निम्न का उत्पादन करता है:

Experemintation के माध्यम से, हम और अधिक रंग प्राप्त कर सकते हैं:

नोट: \33[5m और \33[6m रहे हैं।

इस तरह हम एक पूर्ण रंग संग्रह बना सकते हैं:

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'

परीक्षा उत्पन्न करने के लिए कोड यहां दिया गया है:

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

100 के रंग के हर संयोजन को फिर से चलाने के लिए लूप के लिए सभी रंगों के साथ एक वर्ग उत्पन्न किया, फिर अजगर रंगों के साथ एक वर्ग लिखा। जैसा कि आप करेंगे, कॉपी और पेस्ट करें, मेरे द्वारा जीपीएलवी 2:

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'

sty के समान है, लेकिन यह कम वर्बोज़ है, 8bit और 24bit (आरजीबी) रंगों का समर्थन करता है, आपको अपने रंगों को पंजीकृत करने की अनुमति देता है, वास्तव में लचीला और अच्छी तरह से प्रलेखित है। यदि आपको 90 वें में फंस गए टर्मिनल अनुकरणकर्ताओं के साथ संगतता की परवाह नहीं है और नई सुविधाओं का उपयोग करना चाहते हैं, तो आप इसे आज़मा सकते हैं।

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

प्रिंट:

डेमो:


मैंने एक साधारण मॉड्यूल लिखा, यहां उपलब्ध है: http://pypi.python.org/pypi/colorconsole

यह विंडोज, मैक ओएस एक्स और लिनक्स के साथ काम करता है। यह लिनक्स और मैक के लिए एएनएसआई का उपयोग करता है, लेकिन मूलभूत विंडोज़ पर कंसोल फ़ंक्शंस को कॉल करता है। आपके पास रंग, कर्सर पोजीशनिंग और कीबोर्ड इनपुट हैं। यह शाप के प्रतिस्थापन नहीं है, लेकिन यदि आपको सरल स्क्रिप्ट या ASCII गेम में उपयोग करने की आवश्यकता है तो बहुत उपयोगी हो सकता है।







ansi-colors