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




unicode terminal (20)

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


पात्रों के लिए

आपका टर्मिनल शायद यूनिकोड (आमतौर पर यूटीएफ -8 एन्कोडेड) वर्णों का उपयोग करता है, इसलिए यह केवल आपके पसंदीदा चरित्र को देखने के लिए उचित फ़ॉन्ट चयन का मामला है। यूनिकोड चार यू +2588, "पूर्ण ब्लॉक" वह है जिसे मैं आपको सुझाव दूंगा।

निम्नलिखित आज़माएं:

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

बाद में फ़ाइल को अपने पसंदीदा दर्शक के साथ जांचें।

रंगों के लिए

curses वह मॉड्यूल है जिसका आप उपयोग करना चाहते हैं। इस ट्यूटोरियल की जांच करें।


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

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

प्रयोग

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

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

print colors.error('sorry, ')

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


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

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


आप शाप पुस्तकालय के पायथन कार्यान्वयन का उपयोग कर सकते हैं: http://docs.python.org/library/curses.html

साथ ही, इसे चलाएं और आपको अपना बॉक्स मिल जाएगा:

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

इस सरल कोड का प्रयास करें

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

एक स्ट्रिंग मुद्रित करें जो एक रंग / शैली शुरू करता है, फिर स्ट्रिंग, फिर रंग / शैली परिवर्तन '\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()

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

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


ध्यान दें कि कीवर्ड के साथ संशोधक के 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")

फिर भी एक और पाइप मॉड्यूल जो पायथन 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'])

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


मुझे आश्चर्य है कि किसी ने पाइथन टर्मकलर मॉड्यूल का उल्लेख नहीं किया है। उपयोग बहुत आसान है:

from termcolor import colored

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

यह पर्याप्त परिष्कृत नहीं हो सकता है, हालांकि, गेम प्रोग्रामिंग और "रंगीन ब्लॉक" के लिए जो आप करना चाहते हैं ...


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

https://github.com/Robpol86/colorclass


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

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


मैंने वैश्विक कार्यों के साथ एक मॉड्यूल में @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")

यदि आप 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 कैसे स्थापित करें

कोशिश करो!!


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

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

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

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 "ब्लॉक वर्ण" हैं।

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

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

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


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

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

Colors

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

#

विंडोज़ पर आप 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)

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

प्रिंट:

डेमो:


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

स्क्रीनशॉट:





ansi-colors