2123

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

— aboSamoor
स्रोत

6

बेहतर प्रतिक्रिया प्राप्त करने के लिए आपको कुछ अतिरिक्त जानकारी निर्दिष्ट करनी चाहिए: मल्टीप्लायर? क्या बाहरी मॉड्यूल स्वीकार किए जाते हैं?

— सोरिन

2

IPython इसे करता है, क्रॉस-प्लेटफ़ॉर्म। देखें कि वे क्या उपयोग करते हैं?

— एंडोलिथ

यह प्रतीक एक महान रंगीन ब्लॉक बना देगा: █ केवल समस्या यह है कि इसे ASCII बढ़ाया गया है, हो सकता है कि आप इसे काम में ला सकेंhttp://stackoverflow.com/questions/8465226/using-extended-ascii-codes-with-python

— Samy Bencherif

कुछ टर्मिनल यूनिकोड वर्ण भी प्रदर्शित कर सकते हैं। यदि आपके टर्मिनल के लिए यह सच है, तो संभव अक्षर लगभग असीमित हैं।

— 20

4

यह जवाब काफी देर से आया, लेकिन यह मुझे सबसे अच्छा लगता है ... ऊपर वाले ने वोट दिया, इसके लिए विंडोज के लिए विशेष हैक की आवश्यकता है जबकि यह सिर्फ काम करता है: stackoverflow.com/a/3332860/901641

— ArtOfWarfare

1829

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

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)

या, Python3.6 + के साथ:

print(f"{bcolors.WARNING}Warning: No active frommets remain. Continue?{bcolors.ENDC}")

यह OS X, linux और windows सहित यूनिक्स पर काम करेगा (बशर्ते कि आप ANSICON का उपयोग करें , या विंडोज 10 में आप वीटी 100 इम्यूलेशन सक्षम करें )। रंग सेट करने, कर्सर ले जाने, और बहुत कुछ करने के लिए एएनआई कोड हैं।

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

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

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

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

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

— joeld
स्रोत

लेकिन मान लीजिए कि मेरा डिफ़ॉल्ट प्रॉम्प्ट काला नहीं है - क्या आपको लगता है कि इन ट्रिक्स के बाद अजगर को फिर से बनाना संभव है?

— Adobe

4

लिनक्स पर, आप उपयोग करना चाह सकते हैं tput, जैसे कि चूंकि यह अधिक पोर्टेबल कोड में परिणाम करता है।

— मार्टिन यूडिंग

3

@ कावासा: disableजब आप किसी फ़ाइल में आउटपुट को पाइप करते हैं तो उसके लिए एक वास्तविक उपयोग का मामला होता है; जबकि उपकरण जैसे catरंग का समर्थन कर सकते हैं, आम तौर पर फ़ाइलों के लिए रंग जानकारी मुद्रित नहीं करना बेहतर होता है।

— सेबस्टियन मच

1

@AlexanderSimko, यहाँ विंडोज 10 में VT100 समर्थन को सक्षम करने के लिए ctypes कोड स्निपेट है import ctypes; kernel32 = ctypes.WinDLL('kernel32'); hStdOut = kernel32.GetStdHandle(-11); mode = ctypes.c_ulong(); kernel32.GetConsoleMode(hStdOut, ctypes.byref(mode)); mode.value |= 4; kernel32.SetConsoleMode(hStdOut, mode):।

— एरिक सन

1

उत्तर से पायथन उदाहरण कोड का उपयोग करने वाले किसी भी व्यक्ति के लिए: यह ध्यान दिया जाना चाहिए कि 90-97 और 100-107 की सीमा में रंग गैर-मानक हैं और, वास्तव में, मेरे टर्मिनल पर वे सभी रंगों को इंगित नहीं करते हैं। चर नाम। 30-37 और 40-47 मानक श्रेणियों का उपयोग करना बेहतर है। स्रोत: en.wikipedia.org/wiki/…

— बालू

803

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

from termcolor import colored

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

या पायथन 3 में:

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

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

— समत जैन
स्रोत

2

चूंकि यह एएनएसआई कोड उत्सर्जित कर रहा है, तो क्या यह विंडोज (डॉस कंसोल) पर काम करता है अगर asi.sys लोड है? support.microsoft.com/kb/101875

— फिल पी।

37

बस ध्यान दिया कि 13/01/2011 तक, यह अब MIT लाइसेंस के तहत है

— अलेक्जेंडर त्सेपकोव

12

2011 के बाद से

— यूनाईटेड कलरमा के

5

termcolor.COLORSआपको रंगों की सूची देता है

— akxlr

23

os.system('color')पहले विंडोज रन पर , फिर एएनएसआई एस्केप सीक्वेंस काम करना शुरू कर देते हैं।

— शेजाबल्स

717

जवाब है Colorama अजगर में रंग सब पार मंच के लिए।

एक अजगर 3.6 उदाहरण स्क्रीनशॉट:

— priestc
स्रोत

317

Colorama के लेखक के रूप में, @ nbv4 उल्लेख के लिए धन्यवाद। मैं कोशिश करूँगा और थोड़ा स्पष्ट करूँगा: Colorama का लक्ष्य है कि पायथन कार्यक्रमों को सभी प्लेटफार्मों पर रंगीन टर्मिनल पाठ को प्रिंट करने दिया जाए, इस पृष्ठ पर कई अन्य उत्तरों में वर्णित समान ANSI कोड का उपयोग करते हुए। विंडोज पर, Colorama इन ANSI वर्णों को स्टडआउट से निकालता है और रंगीन पाठ के लिए बराबर win32 कॉल में परिवर्तित करता है। अन्य प्लेटफार्मों पर, Colorama कुछ नहीं करता है। इसलिए आप एएनएसआई कोड, या टर्मकोलर जैसे मॉड्यूल का उपयोग कर सकते हैं, और Colorama के साथ, वे सभी प्लेटफार्मों पर 'बस काम करते हैं'। क्या वह विचार है, किसी भी तरह।

— जोनाथन हार्टले

2

@ जोनाथन, यह वास्तव में एक भयानक पुस्तकालय है! प्लेटफ़ॉर्म रंग पायथन आउटपुट को पार करने की क्षमता वास्तव में बहुत अच्छी और उपयोगी है। मैं एक पुस्तकालय के लिए उपकरण प्रदान कर रहा हूं जो अपने स्वयं के कंसोल को रंग देता है। मैं उस कंसोल के आउटपुट को टर्मिनल पर रीडायरेक्ट कर सकता हूं और आउटपुट को कलर कर सकता हूं। अब मैं लाइब्रेरी को भी एक कर सकता हूं और उपयोगकर्ता को रंगों का चयन करने दूंगा। यह रंग नेत्रहीन लोगों को काम करने के लिए चीजें सेट करने की अनुमति देगा ताकि वे वास्तव में आउटपुट को सही ढंग से देख सकें। धन्यवाद

— Demolishun

50

यह मानक पुस्तकालय में होना चाहिए ... क्रॉस प्लेटफॉर्म रंग समर्थन महत्वपूर्ण है, मुझे लगता है।

— डेविएल्स

5

रंगमा महान है! इसके अलावा ansimarkup पर एक नज़र डालें , जो कि colorama पर बनाया गया है और आपको <b>bold</b>टर्मिनल टेक्स्ट में शैली जोड़ने के लिए एक साधारण टैग-आधारित मार्कअप (उदा ) का उपयोग करने की अनुमति देता है

— gvalkov

30

यह colorama.init () को कॉल किए बिना काम नहीं करता है। पक्ष में मत देना!

— स्मिट जॉन्थ

427

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

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

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

उत्पादन का शीर्ष भाग

— राबिन यूताम
स्रोत

8

यह सबसे गोले के रूप में अच्छी तरह से ipython में काम करता है, सबसे अनुप्रयोगों के लिए काफी अच्छा है

— dashesy

4

क्या मैं पूछ सकता हूं, यह कौन सा टर्मिनल है?

— 17

4

यह कितना पोर्टेबल है?

— रग्गरो तुर्रा

2

लघु स्टैंडअलोन कार्यान्वयन: gist.github.com/Sheljohn/68ca3be74139f66dbc6127784f638920

— जोनाथन एच

203

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

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

इस में निम्नलिखित का उत्पादन bash, में urxvtएक Zenburn शैली रंग योजना के साथ:

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

नोट: \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

— Qubodup
स्रोत

2

आपने

— टिक्‍क

2

क्या शेल या टर्मिनल इसे झपकी देता है?

— Zypps987 12

1

(यू) उदाहरण के लिए

— rxvt

6

निमिष पाठ वास्तव में वास्तव में अच्छी तरह से काम करता है। हालांकि मैं इसे कैसे रोकूं? सभी लगातार प्रिंट किसी कारण से पलक झपकते हैं। मेरा टर्मिनल सोचता है कि यह पार्टी का समय है!

— कप्तान

3

स्ट्रिंग के अंत में ब्लिंकिंग, पुट \33[0mया CENDऊपर होना।

— स्टेफेन

94

आप ANSI एस्केप सीक्वेंस के बारे में सीखना चाहते हैं। यहाँ एक संक्षिप्त उदाहरण है:

CSI="\x1B["
print(CSI+"31;40m" + "Colored Text" + CSI + "0m")

अधिक जानकारी के लिए http://en.wikipedia.org/wiki/ANSI_escape_code देखें

एक ब्लॉक चरित्र के लिए, \ u2588 जैसे एक यूनिकोड वर्ण का प्रयास करें:

print(u"\u2588")

यह सब एक साथ डालें:

print(CSI+"31;40m" + u"\u2588" + CSI + "0m")

— ब्रायन ओकली
स्रोत

3

def d(*v): return '\x1B['+';'.join(map(str, v))+'m'फिर कोशिश करेंprint ' '.join([d(k,i)+str(i%10)+d(0) for i in range(30,38)+range(40,48) for k in range(2)])

— एवगेनी सर्गेव

यहाँ रीसेट का अर्थ क्या है?

— मोहितC

70

मैं जवाब दे रहा हूं क्योंकि मुझे विंडोज 10 पर एएनएसआई कोड का उपयोग करने का एक तरीका मिल गया है, ताकि आप बिना किसी मॉड्यूल के पाठ का रंग बदल सकें:

यह कार्य करने वाली रेखा os.system("")या कोई अन्य सिस्टम कॉल है, जो आपको टर्मिनल में ANSI कोड प्रिंट करने की अनुमति देता है:

import os

os.system("")

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

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

नोट: यद्यपि यह अन्य विंडोज विकल्पों के समान विकल्प देता है, विंडोज इस ट्रिक के साथ भी एएनएसआई कोड का पूर्ण समर्थन नहीं करता है। सभी पाठ सजावट रंग काम नहीं करते हैं और सभी 'उज्ज्वल' रंग (कोड 90-97 और 100-107) नियमित रंगों के समान होते हैं (कोड 30-37 और 40-47)

संपादित करें : एक भी छोटी विधि खोजने के लिए @jl के लिए धन्यवाद।

tl; dr : os.system("")अपनी फ़ाइल के शीर्ष के पास जोड़ें ।

पायथन संस्करण: 3.6.7

— SimpleBinary
स्रोत

2

यह काम करता है - मैं वास्तव में आश्चर्यचकित हूं कि रंग कमांड विंडोज टर्मिनल में एएनएसआई कोड को सक्षम करता है, मैं यह जानने के लिए वर्षों से चला गया कि यह संभव है - कमांड खुद कोई सुराग नहीं देता है कि यह ऐसा करता है।

— स्टुअर्ट एक्सॉन

1

सरलतम, और पूरी तरह से काम करता है। धन्यवाद।

— अरी

3

स्पष्ट होने के लिए, यह केवल विंडोज 10. पर काम करेगा

— एनाकसुमन

2

विंडोज 7 / 8.1 में काम नहीं करता है।

— निकोस

2

आपके उत्तर के लिए बहुत बहुत धन्यवाद, @SimpleBinary! अपने उत्तर के साथ खेलते हुए, मैंने पाया है कि आप इसे if sys.platform.lower() == "win32": os.system('color')और भी सरल बना सकते हैं os.system('')। कोई शर्त की आवश्यकता नहीं है, और कोड विंडोज 10 और लिनक्स (जब मैंने इसे परीक्षण किया है) दोनों में चलता है। जैसा कि आप देख सकते हैं, आपको सिस्टम कॉल करने की आवश्यकता नहीं है color। कॉल करने के लिए dir, cd, abcdef, और सिर्फ एक खाली स्ट्रिंग काम ठीक (हालांकि गैर रिक्त स्ट्रिंग की संभावना उत्पादन जैसा कि आप देख नहीं करना चाहती प्रिंट होगा)।

— जेएल

60

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

from blessings import Terminal

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

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

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)

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

— एरिक रोज़
स्रोत

65

रंग को एक फ़ंक्शन नाम के रूप में रखना और एक पैरामीटर के रूप में नहीं एक संदिग्ध अभ्यास है।

— लेटवॉर्फ

1

@LtWorf: getattrयदि आप इसे ज़रूरत है तो आप आसानी से इसे एक पैरामीटर बना सकते हैं । या अधिक संभावना है, बस प्रारूप स्ट्रिंग को गतिशील रूप से बनाएं।

— jfs

8

@ तथ्य यह है कि आप यह कर सकते हैं इसका मतलब यह नहीं है कि आपको यह करना चाहिए। यह अधिक सामान्य है अगर रंग एक पैरामीटर है जिसे आप बस पास कर सकते हैं।

— लेटवॉर्फ

2

आप can just passएक अजगर समारोह।

— मैक्सएनो

2

ध्यान दें कि आशीर्वाद आयात करना विंडोज़ पर काम नहीं करता है, इसलिए इसका उपयोग न करें यदि आपकी स्क्रिप्ट को क्रॉस-प्लेटफ़ॉर्म की आवश्यकता है।

— एडवर्सस

58

शूकरशाला colorama के समान है, लेकिन यह कम वर्बोज़, का समर्थन करता है 8bit और 24bit का समर्थन करता है म्यूट कर रहा है, वास्तव में लचीला, अच्छी तरह से प्रलेखित और अधिक है, (RGB) रंग, आप अपने खुद के शैलियों रजिस्टर करने के लिए अनुमति देता है।

उदाहरण:

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

from sty import Style, RgbFg

fg.orange = Style(RgbFg(255, 150, 50))

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

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

प्रिंट:

डेमो:

— Rotareti
स्रोत

7

यह बहुत उपयोगी होगा यदि आप इसे कलरमा से तुलना करने पर विचार करते हैं, तो मैं आपकी लाइब्रेरी पसंद करता हूं, लेकिन सिर्फ इसलिए कि बॉक्स से अधिक लघु एपी, और यह अधिक लोकप्रिय होगा, तो यह बहुत अच्छा होगा। धन्यवाद!

— विक्टर गैवरो

मुझे शैली पसंद है और मैं अपनी स्ट्रिंग को शैली के साथ प्रारूपित करने की कोशिश कर रहा हूं, एक मुद्दा यह है कि जब मैं कई रंगों को प्रिंट करता हूं, तो क्या मैं डिफ़ॉल्ट रंग के बजाय पिछले रंग पर रीसेट कर सकता हूं?

— इंटिजैक

@VictorGavro यह एक अच्छा विचार है! मैं प्रलेखन की तुलना जोड़ सकता हूं।

— रोटारिटी

@intijk आपका प्रश्न वास्तव में टिप्पणी अनुभाग में फिट नहीं है। इस तरह के प्रश्न के लिए कृपया एक नया SO प्रश्न बनाएं या जीथब इश्यू ट्रैकर का उपयोग करें।

— रोटारिटी

53

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

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'

— जीआई जैक
स्रोत

44

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

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

— dayitv89
स्रोत

19

सुझाव: लैम्बदास को परिभाषित करें जो उस रंगीन स्ट्रिंग को लौटाता है, बजाय उन्हें सीधे प्रिंट करने के, ताकि इसे कई तार के साथ संयोजन में इस्तेमाल किया जा सके।

— gustafbstrom

34

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

पूरा कोड देखने के लिए जो दोनों तरह से समर्थन करता है, टेस्टोबो से कलर कंसोल रिपोर्टिंग कोड देखें ।

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)

— orip
स्रोत

2

ईमानदारी से यह केवल समाधान है जो खिड़कियों के साथ काम करता है। अन्य सभी उत्तर प्रत्येक माताओं की कॉपी हैं।

— डैनिलो

एफडब्ल्यूआईडब्ल्यू, विंडोज पर यह कॉनमू का उपयोग करने के लिए कम दर्द हो सकता है जो एएनएसआई अनुक्रमों का समर्थन करता है (मूल टर्मिनल पर अन्य लाभों के एक मेजबान के अलावा)। हालांकि अभी भी देशी समाधान के लिए बहुत अच्छा है।

— दोनों को

मैं डैनिलो के साथ हूं।

— मुहम्मद अली

24

Stupidly @ 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)

फिर बस

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

— zahanm
स्रोत

2

यदि आप एक से अधिक स्थितीय तर्क या स्ट्रिंग प्रकार के अलावा कुछ भी पास करते हैं तो यह दुर्घटनाग्रस्त हो जाएगा

— रोमेन विंसेंट

@RomainVincent तो एक से अधिक स्थितीय तर्क या एक स्ट्रिंग ty- इंतजार के अलावा और कुछ उत्तीर्ण नहीं होते हैं, ये हैं print-replacements ? आपत्ति निराकृत।

— wizzwizz4

1

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

— रोमेन विन्सेंट

1

@RomainVincent मैं यह कहने जा रहा था कि आपकी आपत्ति गलत थी, लेकिन किसी फ़ंक्शन को बहुमुखी के रूप में बदलने के लिए, क्योंकि printइसकी कार्यक्षमता को ठीक से दोहराने के लिए सुनिश्चित करना चाहिए।

— wizzwizz4

1

अनंत तर्क का उपयोग करने के लिए @RomainVincent इम्प्लिमेंट्स: <code> def purple(cls, *args, **kwargs): print(cls.PURPLE, *args, cls.END, **kwargs)</ code>

— Emilien Baudet

23

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

— मोहम्मद समी
स्रोत

22

जब तक आप win32api का उपयोग नहीं कर रहे हों, विंडोज के लिए आप रंगों से सांत्वना नहीं दे सकते।

लिनक्स के लिए प्रिंट का उपयोग करना उतना ही सरल है, जितना कि यहां दिए गए पलायन क्रम के साथ:

रंग की

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

— UberJumper
स्रोत

21

# Pure Python 3.x demo, 256 colors
# Works with bash under Linux and MacOS

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)

# Simple usage: print(fg("text", 160))

— एंड्री मकुखा
स्रोत

20

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

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)

— Ben174
स्रोत

यह थर्ड पार्टी पैकेज के बिना करने के लिए वास्तव में अच्छा है।

— जेमी कॉन्सल

20

Https://pypi.python.org/pypi/lazyme का उपयोग करके @joeld उत्तर पर निर्माण 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

स्क्रीनशॉट:

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सभी टर्मिनलों पर काम न करे, मैक / Ubuntu पर काम नहीं करता है।

उदाहरण के लिए

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

स्क्रीनशॉट:

— alvas
स्रोत

20

def black(text):
    print('\033[30m', text, '\033[0m', sep='')

def red(text):
    print('\033[31m', text, '\033[0m', sep='')

def green(text):
    print('\033[32m', text, '\033[0m', sep='')

def yellow(text):
    print('\033[33m', text, '\033[0m', sep='')

def blue(text):
    print('\033[34m', text, '\033[0m', sep='')

def magenta(text):
    print('\033[35m', text, '\033[0m', sep='')

def cyan(text):
    print('\033[36m', text, '\033[0m', sep='')

def gray(text):
    print('\033[90m', text, '\033[0m', sep='')


black("BLACK")
red("RED")
green("GREEN")
yellow("YELLOW")
blue("BLACK")
magenta("MAGENTA")
cyan("CYAN")
gray("GRAY")

ऑनलाइन कोशिश करें

— विशाल
स्रोत

क्या यह केवल पायथन 3 के लिए है?

— python2 के

python3 ubuntu 18.04 में पूरी तरह से काम कर रहा है

— जूलियस

18

ध्यान दें कि withकीवर्ड इन जैसे संशोधक के साथ कितनी अच्छी तरह मेल खाता है जिसे रीसेट करने की आवश्यकता है (पायथन 3 और 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")

— जानूस ट्रॉल्सन
स्रोत

Colorama की कोशिश की, इस्तेमाल किया print(Style.BRIGHT + "Header Test")और print (Style.DIM + word)एक बहुत अच्छा संकेत बनाने के लिए।

— टॉम

यह contextlibPy3 के लिए उपयोग करने के लिए बदलने की आवश्यकता होगी ।

— बिल्ली

@ कोट: पायथन के किस संस्करण से यह आवश्यक होगा?

— Janus Troelsen

मेरा मानना है कि 3 और ऊपर - इस पर एक @contextlib.contextmanagerडेकोरेटर होना चाहिए , नहीं?

— बिल्ली

1

@ कोट: क्यों? बिना महान काम करता है।

— जानूस ट्रॉल्सन

17

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

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

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

— daharon
स्रोत

व्यक्तिगत रूप से मुझे लगता है कि 'शाप' पुस्तकालय को 'आशीर्वाद' से पूरी तरह ग्रहण किया गया है, उसी तरह 'अनुरोध' को 'यूरलिब' आदि के रूप में ग्रहण किया गया है

— जोनाथन हार्टले

17

आप CLINT का उपयोग कर सकते हैं:

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

GitHub से प्राप्त करें ।

— जियाकोमो लाकावा
स्रोत

1

पहला लिंक चला गया है इसलिए मैंने इसे हटा दिया; जीएच लिंक अभी भी अच्छा है (हालांकि परियोजना "संग्रहीत" है और मूल रूप से मुझे छोड़ दिया गया है, जो मैं इकट्ठा कर सकता हूं)।

— गियाकोमो लाकवा

14

यदि आप किसी गेम की प्रोग्रामिंग कर रहे हैं तो शायद आप बैकग्राउंड का रंग बदलना चाहते हैं और केवल स्पेस का उपयोग करना चाहते हैं? उदाहरण के लिए:

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

— suhib-alsisan
स्रोत

इसके बारे में और अधिक जानकारी यहाँ मिल सकती है- linux.byexamples.com/archives/184/…

— pragmatic

14

मुझे पता है कि मुझे देर हो गई है। लेकिन, मेरे पास ColorIt नामक एक पुस्तकालय है । यह सुपर सरल है।

यहाँ कुछ उदाहरण हैं:

from ColorIt import *

# Use this to ensure that ColorIt will be usable by certain command line interfaces
initColorIt()

# Foreground
print (color ('This text is red', colors.RED))
print (color ('This text is orange', colors.ORANGE))
print (color ('This text is yellow', colors.YELLOW))
print (color ('This text is green', colors.GREEN))
print (color ('This text is blue', colors.BLUE))
print (color ('This text is purple', colors.PURPLE))
print (color ('This text is white', colors.WHITE))

# Background
print (background ('This text has a background that is red', colors.RED))
print (background ('This text has a background that is orange', colors.ORANGE))
print (background ('This text has a background that is yellow', colors.YELLOW))
print (background ('This text has a background that is green', colors.GREEN))
print (background ('This text has a background that is blue', colors.BLUE))
print (background ('This text has a background that is purple', colors.PURPLE))
print (background ('This text has a background that is white', colors.WHITE))

# Custom
print (color ("This color has a custom grey text color", (150, 150, 150))
print (background ("This color has a custom grey background", (150, 150, 150))

# Combination
print (background (color ("This text is blue with a white background", colors.BLUE), colors.WHITE))

यह आपको देता है:

यह भी ध्यान देने योग्य है कि यह क्रॉस प्लेटफॉर्म है और इसे मैक, लिनक्स और विंडो पर टेस्ट किया गया है।

आप इसे आज़माना चाहते हैं: https://github.com/CodeForeverAndEver/ColorIt

नोट: कुछ ही दिनों में ब्लिंकिंग, इटैलिक्स, बोल्ड आदि जोड़ दिए जाएंगे।

— BeastCoder
स्रोत

11

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

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

— Navweb
स्रोत

यदि आप एक ही लाइन पर अलग-अलग रंग चाहते हैं, तो कॉल के बीच print("%X --> %s" % (color, "Have a fine day!"), end='', flush=True)

— स्टडआउट

11

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

कोशिश करो!!

— बृजेश चौहान
स्रोत

10

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

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)

— nosklo
स्रोत

इस त्रुटि के साथ आपका कोड Windows (x64) के अंतर्गत विफल हो जाता है: विशेषता: 'मॉड्यूल' ऑब्जेक्ट में कोई विशेषता नहीं है 'आवरण'

— sorin

1

@ सोरिन स्बनेया: तदनुसार अजगर आधिकारिक दस्तावेज़ docs.python.org/library/curses.html पर शाप देता है , शाप मॉड्यूल खिड़कियों पर समर्थित नहीं है। हो सकता है कि आपको "कोई ऐसा मॉड्यूल" या इस तरह की चीज़ के बजाय यह त्रुटि मिली हो, क्योंकि आपने संभवतः अपनी परीक्षण फ़ाइल का नाम "शापस्ट्रोक्स" रखा है, इसलिए यह स्वयं आयात कर रहा है।

— nosklo

10

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

— विशाल
स्रोत

10

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:

— JFS
स्रोत

10

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

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

यह अजगर में प्रयोग करने योग्य है 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'])

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

— drevicko
स्रोत

पायथन में टर्मिनल में रंगीन टेक्स्ट कैसे प्रिंट करें?

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

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