दुभाषिया कंसोल को कैसे साफ़ करें?

Question

अधिकांश पायथन डेवलपर्स की तरह, मैं आमतौर पर पायथन इंटरप्रेटर के साथ कमांड, dir()सामान help() stuffआदि का परीक्षण करने के लिए एक कंसोल विंडो खुली रखता हूं ।

किसी भी कंसोल की तरह, थोड़ी देर के बाद पिछले कमांड्स और प्रिंट्स का दृश्य बैकलॉग बंद हो जाता है, और कभी-कभी भ्रमित होने पर उसी कमांड को कई बार री-रन करते हैं। मैं सोच रहा था कि, और कैसे, पायथन दुभाषिया कंसोल को खाली करने के लिए।

मैंने एक सिस्टम कॉल करने और या तो clsविंडोज पर या clearलिनक्स पर कॉल करने के बारे में सुना है , लेकिन मैं उम्मीद कर रहा था कि कुछ ऐसा है जो मैं खुद को करने के लिए दुभाषिया को कमांड कर सकता हूं।

नोट: मैं विंडोज पर चल रहा हूं, इसलिए Ctrl+Lकाम नहीं कर रहा है।

Comments

यहाँ IPython समाधान: stackoverflow.com/questions/6892191/…

— onewhaleid

मुझे आश्चर्य है कि किसी ने भी इसका उल्लेख नहीं किया। लेकिन जब आप Ipython खोल का उपयोग कर रहे हैं तो आप Ctrl + L को विंडोज़ में भी कर सकते हैं

— user93

Answer 1

जैसा कि आपने बताया, आप एक सिस्टम कॉल कर सकते हैं:

विंडोज के लिए

>>> import os
>>> clear = lambda: os.system('cls')
>>> clear()

लिनक्स के लिए लैम्बडा बन जाता है

>>> clear = lambda: os.system('clear')

Comments

यह उत्तर 'आत्मा' के सबसे करीब है जो मैं पूछ रहा था, धन्यवाद।

— सोवियुत

+1, अच्छा जवाब। क्या वापसी के मूल्य का उपभोग करने का कोई तरीका है ताकि यह प्रदर्शित न हो? मुझे स्पष्ट चलने के बाद एक '0' मिलता है।

— तकनीकी असंबद्ध

इसे एक नियमित कार्य में परिभाषित करें लंबोदर के बजाय '0' नहीं दिखाना चाहिए क्योंकि रिटर्न वैल्यू कोई नहीं होगी।

— अकबर इब्राहिम

उपयोग करने में क्या गलत है def? का उपयोग क्यों एक lambdaजब एक defस्पष्ट है?

— एस.लूट।

@ अकबरब्राहिम के रूप में कोई भी मुद्रित नहीं किया जाएगा यह कोशिश करें:clear = lambda: os.system('cls') or None

— एनपेनैक्स

Answer 2

यहाँ कुछ है जो थोड़ा और अधिक पार मंच है

import os

def cls():
    os.system('cls' if os.name=='nt' else 'clear')

# now, to clear the screen
cls()

Comments

चीजों के बारे में जाने का शानदार तरीका, कोड की एक पंक्ति को बचाने के लिए ऊपर दिए गए लंबोदर सुझाव के साथ इसे मिलाएं, नरक के रूप में काम करें! धन्यवाद! :)

— टॉर्क्सड

import os os.system('cls')

— Do Nhu Vy

अवधि पर्यावरण चर सेट नहीं है।

— जोनाथन

Answer 3

खैर, यहाँ एक त्वरित हैक है:

>>> clear = "\n" * 100
>>> print clear
>>> ...do some other stuff...
>>> print clear

या कुछ टाइपिंग को बचाने के लिए, इस फ़ाइल को अपने अजगर खोज पथ में रखें:

# wiper.py
class Wipe(object):
    def __repr__(self):
        return '\n'*1000

wipe = Wipe()

तो आप दुभाषिया से यह सब आप की तरह कर सकते हैं :)

>>> from wiper import wipe
>>> wipe
>>> wipe
>>> wipe

Comments

हाहा, यह बहुत मज़ेदार है। ठीक वैसा नहीं जैसा मैं देख रहा था, लेकिन अच्छी कोशिश।

— सोवियुत

@ ट्रीपिक: c = "\ n" * इसके लिए 100 उपयोगी, +1। एक छोटी सी टिप्पणी यह ​​साफ करती है और खोल के नीचे तक ले जाती है, मैं शेल शीर्ष से शुरू करना पसंद करता हूं।

— पायथनबिजिनर

या, यदि आपका टर्मिनल एमुलेटर एएनएसआई की व्याख्या करता है, तो बेहतर है:"\x1B[H\x1B[J"

— अल्बा मेंडेज

लोगों को हँसाने के बावजूद, बहुत सारी नई-नई चीज़ों को छापना बाहरी प्रक्रियाओं clearऔर कामों को पूरा clsकरता है। यह इसे करने का तरीका है। (सिर्फ एक प्रिंट, या प्रिंट कॉल के साथ एक फ़ंक्शन, "स्पष्ट" स्ट्रिंग के लिए नहीं, बेशक)

— jsbueno

@jsbueno नहीं यह नहीं है। खैर शायद खिड़कियों पर (हालांकि मुझे संदेह है, इसमें कंसोल को खाली करने के लिए एपीआई हैं)। अन्य सभी प्रणालियों में, clearस्क्रीन को साफ़ करने वाले एक निर्देश को आउटपुट करता है। स्क्रॉलबैक बफर को ट्रैश किए बिना। मेरे सिस्टम पर, यह इस नियंत्रण अनुक्रम को आउटपुट करता है \33[3J\33[H\33[2J:। वह है [erase scrollback] [reset cursor position] [erase screen]:। का [erase scrollback]उपयोग कर छोड़ा जा सकता है clear -x।

— स्पेक्ट्रा

Answer 4

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

यहाँ कुछ लेख मिले हैं जो बताते हैं कि विंडोज़ पर पर्यावरण चर कैसे सेट करें:
    sys.path.append का उपयोग कब करें और% PYTHONPATH% को संशोधित करते समय पर्याप्त है
    कैसे Windows XP में पर्यावरण चर को प्रबंधित करने के लिए
    विन्यास प्रणाली और उपयोगकर्ता पर्यावरण चर
    को वैश्विक प्रणाली का उपयोग कैसे करें विंडोज में पर्यावरण चर

BTW, भले ही इसमें रिक्त स्थान हों, फ़ाइल के पथ के चारों ओर उद्धरण न रखें।

वैसे भी, यहाँ मेरे कोड को पायथन स्टार्टअप स्क्रिप्ट में डालने (या अपने मौजूदा में जोड़ने) के लिए है:

# ==== pythonstartup.py ====

# add something to clear the screen
class cls(object):
    def __repr__(self):
        import os
        os.system('cls' if os.name == 'nt' else 'clear')
        return ''

cls = cls()

# ==== end pythonstartup.py ====

BTW, आप सिर्फ (और अपने उपनाम के लिए डिट्टो ) में बदलने के लिए @ ट्राइप्टिक की__repr__ चाल का उपयोग कर सकते हैं :exit()exitquit

class exit(object):
    exit = exit # original object
    def __repr__(self):
        self.exit() # call original
        return ''

quit = exit = exit()

अंत में, यहाँ कुछ और है जो प्राथमिक दुभाषिया प्रॉम्प्ट >>>को cwd + से बदलता है>>> :

class Prompt:
    def __str__(self):
        import os
        return '%s >>> ' % os.getcwd()

import sys
sys.ps1 = Prompt()
del sys
del Prompt

Comments

यह शायद सबसे अच्छा जवाब है - अन्य उत्तरों से तकनीकों का संयोजन। PYTHONSTARTUP + repr + os.system ('cls')। बहुत अच्छा।

— त्रिपिटक

@ ट्रीप्टिक: उपयोग करने __repr__और / या __str__इस तरह से एक दिलचस्प पक्ष यह है कि यदि आप >>> vars()दुभाषिया कंसोल पर टाइप करते हैं, तो यह सभी कमांडों को इसी तरह परिभाषित करेगा। मेरे सिस्टम पर, उदाहरण के लिए, इसने स्क्रीन को साफ किया और फिर कंसोल को बाहर कर दिया। मुझे यह जानने में

— थोड़ा

दिलचस्प। मैं देख रहा हूँ इस समस्या को भी लागू होता है locals()और globals()। इन कार्यों के आसपास एक साधारण डेकोरेटर जो नाम को हटाता है और फ़ंक्शन के आह्वान के बाद इसे पुन: सौंपता है एक संभावित समाधान है ...

— ट्रिप्टाइक

@ ट्रीपिक: डेकोरेटर का विचार काम करने का नहीं लगता, कम से कम मेरे खुद के प्रयासों से। एक व्यवहार्य विकल्प के साथ आना आश्चर्यजनक रूप से कठिन साबित हो रहा है।

— मार्टीन्यू

मेरे पास एक उम्मीदवार समाधान है जो बस vars () ग्लोबल्स () और स्थानीय लोगों () को अस्थायी रूप से कॉल करता है: gist.github.com/4172781

— ट्रिप्टिक

Answer 5

आपके पास इसे विंडोज पर करने के कई तरीके हैं:

1. कीबोर्ड शॉर्टकट का उपयोग करना:

Press CTRL + L

2. सिस्टम आह्वान विधि का उपयोग करना:

import os
cls = lambda: os.system('cls')
cls()

3. 100 बार नई लाइन प्रिंट का उपयोग करना:

cls = lambda: print('\n'*100)
cls()

Comments

इन सभी तरीकों सुंदर हैं ... naff। clsकेवल खिड़कियों पर काम करेगा और अपने प्रोग्राम को क्रास प्लेटफॉर्म बनाने के लिए कठिन बना देगा, 100 मुद्रण newlinesकरना सिर्फ ईवा है? और कार्यक्रम में कीबोर्ड शॉर्टकट का उपयोग नहीं किया जाता है।

— ल्यूक

Answer 6

एक शक के बिना सबसे तेज और आसान तरीका Ctrl+ हैL ।

यह टर्मिनल पर ओएस एक्स के लिए समान है।

Comments

मैंने इस समाधान को विंडोज़ 8.1 पर ctrl कुंजी के साथ ऊपरी या निचले "L" का उपयोग करके आज़माया। यह मेरे लिए काम नहीं करता है। मैं इसे खोलने के लिए शेल विंडो को सिर्फ खोलता और बंद करता हूं।

— क्रिस 22

OS X पर, Ctrl + L टर्मिनल को तब तक पैड करेगा जब तक डिस्प्ले क्लियर न हो जाए। आप अभी भी इतिहास देखने के लिए स्क्रॉल कर सकते हैं। प्रदर्शन और प्रिंटआउट इतिहास साफ़ करने के लिए Cmd + K का उपयोग करें। ओएस एक्स टर्मिनल हॉटकीज़ की एक और पूरी सूची

— एंड्रयू फ्रैंकलिन

उबंटू डेस्कटॉप 16 में मेरे लिए खूबसूरती से काम करें

— Nam G VU

Answer 7

ऐसा करने का मेरा तरीका एक फ़ंक्शन लिखना है जैसे:

import os
import subprocess

def clear():
    if os.name in ('nt','dos'):
        subprocess.call("cls")
    elif os.name in ('linux','osx','posix'):
        subprocess.call("clear")
    else:
        print("\n") * 120

फिर clear()स्क्रीन को साफ़ करने के लिए कॉल करें । यह विंडोज़ पर काम करता है, osx, linux, bsd ... सभी OSes।

Comments

आप मतलब हो सकता है os.name in ('linux','osx'), और भी जोड़ना चाह सकते हैं 'posix'।

— rsanden

@rsanden 'linux' और 'osx' OS के सभी लोगों को बहुत ज्यादा कवर करता है।

— मार्टिनयूबंटु

मैं Ubuntu 15.04 चला रहा हूं, और os.name == 'posix'दोनों अजगर 2.7.9 और 3.4.3 में

— rsanden

@rsanden ने पॉज़िक्स जोड़ा।

— मार्टिनयून्तु

Answer 8

यहाँ एक क्रॉस प्लेटफ़ॉर्म है (विंडोज़ / लिनक्स / मैक / संभवतः अन्य जिसे आप (अगर चेक में जोड़ सकते हैं) संस्करण स्निपेट मैंने इस प्रश्न में मिली जानकारी के संयोजन से बनाया है:

import os
clear = lambda: os.system('cls' if os.name=='nt' else 'clear')
clear()

एक ही विचार लेकिन एक चम्मच चीनी के साथ:

import subprocess   
clear = lambda: subprocess.call('cls||clear', shell=True)
clear()

Answer 9

वाइपर शांत है, इसके बारे में अच्छी बात यह है कि मुझे इसके चारों ओर '(') टाइप नहीं करना है। यहां इसकी थोड़ी विविधता है

# wiper.py
import os
class Cls(object):
    def __repr__(self):
        os.system('cls')
        return ''

उपयोग काफी सरल है:

>>> cls = Cls()
>>> cls # this will clear console.

Comments

मैं इसका नाम लूंगा class cls।

— मार्टीन्यू

मैं उदाहरण के class Clsलिए होना चाहिए cls। cls = Cls()

— अमोल

सिवाय इसके कि प्रारंभिक नाम स्थान को एक के बजाय दो चीजों से प्रदूषित करता है ... दो बार जितना।

— मार्टीन्यू

@ अमोल मैंने आपके और दूसरों की तकनीकों का उपयोग अपने समाधान में किया है । आप कर सकते हैं class clsऔर फिर cls=cls()।

— अल्बा मेंडेज

Answer 10

यह सबसे आसान काम है जिसे आप कर सकते हैं और इसके लिए किसी अतिरिक्त लाइब्रेरी की आवश्यकता नहीं है। यह स्क्रीन को साफ़ करेगा और >>>ऊपरी बाएँ कोने में वापस आएगा ।

print("\033[H\033[J")

Comments

इसका यह फायदा है कि यह स्पाइडर में भी काम करता है।

— ग्राहम जी

Answer 11

अजगर कंसोल प्रकार के अंदर मैक उपयोगकर्ता के लिए

import os
os.system('clear')

विंडोज के लिए

os.system('cls')

Answer 12

यहाँ निश्चित समाधान है जो अन्य सभी उत्तरों को मिलाता है । विशेषताएं:

1. आप अपने शेल या स्क्रिप्ट में कोड को कॉपी-पेस्ट कर सकते हैं ।

2. आप इसे अपनी इच्छानुसार उपयोग कर सकते हैं :

   >>> clear()
   >>> -clear
   >>> clear  # <- but this will only work on a shell

3. आप इसे मॉड्यूल के रूप में आयात कर सकते हैं :

   >>> from clear import clear
   >>> -clear

4. आप इसे स्क्रिप्ट कह सकते हैं :

   $ python clear.py

5. यह वास्तव में गुणक है ; यदि यह आपके सिस्टम
   ( ceऔर nt, dosया posix) को नहीं पहचान सकता है, तो यह खाली लाइनों को प्रिंट करने के लिए वापस आ जाएगा।

---

आप यहाँ [पूर्ण] फ़ाइल डाउनलोड कर सकते हैं: https://gist.github.com/3130325
या यदि आप कोड की तलाश में हैं:

class clear:
 def __call__(self):
  import os
  if os.name==('ce','nt','dos'): os.system('cls')
  elif os.name=='posix': os.system('clear')
  else: print('\n'*120)
 def __neg__(self): self()
 def __repr__(self):
  self();return ''

clear=clear()

Answer 13

मैं iTerm का उपयोग करता हूं मैक ओएस के लिए और देशी टर्मिनल ऐप का ।

मैं बस ⌘ + k दबाता हूं

Answer 14

बेकार का उपयोग करें। इसमें कई उपयोगी विशेषताएं हैं। Ctrl+F6, उदाहरण के लिए, कंसोल को रीसेट करता है। कंसोल को बंद करना और खोलना इसे साफ़ करने के अच्छे तरीके हैं।

Comments

तुम बेकार में कैसे करते हो? बस पास और फिर से खोलना?

— एंड्रिया अंबू

नहीं, F6हालांकि आइडल कंसोल को रीसेट नहीं करता है, हालांकि CTRL+F6करता है। दुर्भाग्य से यह स्क्रीन को साफ नहीं करता है । डी 'ओह! (पायथन विन 32 आइडल संस्करण 2.6.2, 2.7.1, 3.2)।

— १४

Answer 15

मुझे यकीन नहीं है कि अगर विंडोज "शेल" इसका समर्थन करता है, लेकिन लिनक्स पर:

print "\033[2J"

https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes

मेरी राय बुला में clsसाथ osएक बुरा विचार आम तौर पर है। कल्पना करें कि क्या मैं आपके सिस्टम पर cls या स्पष्ट कमांड को बदलने का प्रबंधन करता हूं, और आप अपनी स्क्रिप्ट को व्यवस्थापक या रूट के रूप में चलाते हैं।

Comments

मैं मानता हूं कि इस मामले में cls आदर्श नहीं है, और एक ANSI एस्केप अनुक्रम बेहतर है। विशेष रूप से एक नई प्रक्रिया को लागू करने के लिए ओएस का उपयोग करते हुए, कुछ बाइट्स को स्टडआउट करने के लिए धक्का देने की तुलना में एक नई प्रक्रिया काफी महत्वपूर्ण है।

— सिल्वोट

Answer 16

मैं Windows XP, SP3 पर MINGW / BASH का उपयोग कर रहा हूं।

(इसे .pythonstartup में चिपकाएँ)
# मेरा ctrl-l पहले से ही तरह का काम कर रहा है, लेकिन इससे किसी और को
# खिड़की से नीचे जाने में मदद मिल सकती है ... हालांकि
आयात पठन
रेखा पर जाएं।

# यह BASH में काम करता है क्योंकि मेरे पास यह .inputrc में है, लेकिन किसी
# कारण से यह तब गिरा जब मैं पायथन
रीडलाइन पर जाता हूं ।parse_and_bind ('\ Cy: किल-पूरी-लाइन')

---

मैं अब 'बाहर निकलने' (') टाइप नहीं कर सका और मार्टीन्यू / ट्रिप्टिक की चाल से खुश था:

मैंने इसे थोड़ा सा सिद्धांत दिया है (इसे .pythstartup में अटका दिया है)

class exxxit():
    """Shortcut for exit() function, use 'x' now"""
    quit_now = exit # original object
    def __repr__(self):
        self.quit_now() # call original
x = exxxit()

---

Py2.7.1>help(x)
Help on instance of exxxit in module __main__:

class exxxit
 |  Shortcut for exit() function, use 'x' now
 |
 |  Methods defined here:
 |
 |  __repr__(self)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  quit_now = Use exit() or Ctrl-Z plus Return to exit

Answer 17

clearलिनक्स में और clsविंडोज में ओएस कमांड एक "मैजिक स्ट्रिंग" आउटपुट करता है जिसे आप बस प्रिंट कर सकते हैं। स्ट्रिंग प्राप्त करने के लिए, पोपेन के साथ कमांड निष्पादित करें और इसे बाद के उपयोग के लिए एक चर में सहेजें:

from os import popen
with popen('clear') as f:
    clear = f.read()

print clear

मेरी मशीन पर स्ट्रिंग है '\x1b[H\x1b[2J'।

Comments

1) वह जादुई स्ट्रिंग एक ANSI अनुक्रम है । \x1b[Hका अर्थ है "कर्सर को ऊपरी-बाएं कोने में ले जाएं", \x1b[2Jजिसका अर्थ है "सभी स्क्रीन को साफ़ करें"। 2) खिड़कियों में, एएनएसआई मान्यता प्राप्त नहीं है, इसलिए शायद कोई जादुई स्ट्रिंग नहीं है।

— अल्बा मेंडेज़

ठंडा! इसके अलावा, python3 प्रिंट ('\ X1b [H \ X1b [2J', अंत = '') के लिए; सामने नई लाइन से बचने में मदद कर सकता है।

— डेनमार्क

मैजिक स्ट्रिंग ने मेरे लिए पायथन 3.6 के साथ माइक्रोसॉफ्ट विंडोज 10 कंसोल पर काम किया। मैं स्ट्रिंग अनुक्रम के लिए खुला के साथ का उपयोग नहीं किया।

— DevPlayer

Answer 18

ये करने के दो अच्छे तरीके हैं:

1।

import os

# Clear Windows command prompt.
if (os.name in ('ce', 'nt', 'dos')):
    os.system('cls')

# Clear the Linux terminal.
elif ('posix' in os.name):
    os.system('clear')

2।

import os

def clear():
    if os.name == 'posix':
        os.system('clear')

    elif os.name in ('ce', 'nt', 'dos'):
        os.system('cls')


clear()

Comments

यदि os.name इनमें से कुछ भी नहीं है, तो खाली लाइनों को मुद्रित करने के लिए वापस क्यों नहीं?

— अल्बा मेंडेज़

अगर यह जाइथन है तो मैं आपको जानना चाहता हूं कि

— os.name

अच्छा लग रहा है, क्या इसका मतलब यह है कि कार्यक्रम क्रॉस प्लेटफॉर्म बन सकता है?

— ल्यूक

Answer 19

यदि यह मैक पर है, तो एक सरल cmd + kचाल करना चाहिए।

Answer 20

सबसे आसान तरीका है ओएस मॉड्यूल का उपयोग करना

>>> import os
>>> clear = lambda: os.system('clear')
>>> clear()

Answer 21

यह पार मंच होना चाहिए, और यह भी पसंद किया जाता का उपयोग करता है subprocess.callके बजाय os.systemअनुसार डॉक्स । पायथन में काम करना चाहिए> = 2.4।os.system

import subprocess
import os

if os.name == 'nt':
    def clearscreen():
        subprocess.call("cls", shell=True)
        return
else:
    def clearscreen():
        subprocess.call("clear", shell=True)
        return

Answer 22

कैसे एक स्पष्ट के लिए इस बारे में

- os.system('cls')

के बारे में है कि जितना कम हो सकता है!

Comments

हां, लेकिन मल्टीप्लेट रिकॉर्डर नहीं और आपको स्क्रीन को खाली करने के लिए हर बार इसे फिर से लिखना होगा।

— अल्बा मेंडेज़

Answer 23

मैं अजगर के लिए नया हूं (वास्तव में नया हूं) और उन पुस्तकों में से एक में मैं उस भाषा से परिचित होने के लिए पढ़ रहा हूं जिसमें वे सिखाते हैं कि दृश्य बैकलॉग और पिछले कमांड और प्रिंट के कंसोल को खाली करने के लिए इस छोटे से फ़ंक्शन को कैसे बनाया जाए:

शेल खोलना / नया दस्तावेज़ बनाना / फ़ंक्शन निम्नानुसार बनाएँ:

def clear():
    print('\n' * 50)

जब आप अपने पीरॉन डायरेक्टरी में काम कर रहे हों तो इसे सेव करें

clear()

बस। पुनश्च: आप वैसे भी आप चाहते हैं आप कार्य कर सकते हैं। Iv ने "वाइपर" "वाइप" और विविधताओं का उपयोग करते हुए लोगों को देखा।

Answer 24

मैं स्पाइडर (पायथन 2.7) का उपयोग कर रहा हूं और इंटरप्रिटर कंसोल को मैं या तो उपयोग करता हूं

%स्पष्ट

वह कमांड लाइन को शीर्ष पर जाने के लिए मजबूर करता है और मैं पिछले पुराने कमांड को नहीं देखूंगा।

या मैं कंसोल वातावरण पर "विकल्प" पर क्लिक करता हूं और "रीस्टार्ट कर्नेल" का चयन करता हूं जो सब कुछ हटा देता है।

Answer 25

मुझे इस भाग में आने में देर हो सकती है लेकिन यह करने का एक बहुत आसान तरीका है

प्रकार:

def cls():
    os.system("cls")

तो क्या आप कभी भी स्क्रीन साफ़ करना चाहते हैं बस अपने कोड में टाइप करें

cls()

सबसे अच्छा तरीका संभव है! (साभार: https://www.youtube.com/watch?annotation_id=annotation_3770292585&feature=iv&src_vid=bguKhMnvmb8&v=LtGEp9cnZZ-U )

Answer 26

बस दर्ज करें

import os
os.system('cls') # Windows
os.system('clear') # Linux, Unix, Mac OS X

Answer 27

यदि आपको इसे कोड के माध्यम से करने की आवश्यकता नहीं है, तो बस CTRL + L दबाएं

Comments

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

— मदालडेन

Answer 28

आर्क लिनक्स ( xfce4-terminalपायथन 3 के साथ परीक्षण किया गया ):

# Clear or wipe console (terminal):
# Use: clear() or wipe()

import os

def clear():
    os.system('clear')

def wipe():
    os.system("clear && printf '\e[3J'")

... में जोड़ा ~/.pythonrc

• clear() स्क्रीन को साफ करता है
• wipe() पूरे टर्मिनल बफर मिटा देता है

Answer 29

संपादित करें: मैंने सिर्फ "विंडोज़" पढ़ा है, यह लिनक्स उपयोगकर्ताओं के लिए है, क्षमा करें।

---

बैश में:

#!/bin/bash

while [ "0" == "0" ]; do
    clear
    $@
    while [ "$input" == "" ]; do
        read -p "Do you want to quit? (y/n): " -n 1 -e input
        if [ "$input" == "y" ]; then
            exit 1
        elif [ "$input" == "n" ]; then
            echo "Ok, keep working ;)"
        fi
    done
    input=""
done

इसे "whatyouwant.sh" के रूप में सहेजें, chmod + x इसे फिर चलाएँ:

./whatyouwant.sh python

या अजगर के अलावा कुछ और (निष्क्रिय, जो भी हो)। यह आपसे पूछेगा कि क्या आप वास्तव में बाहर निकलना चाहते हैं, यदि यह पुनर्मिलन नहीं है (या पैरामीटर के रूप में आपने जो आदेश दिया है)।

यह सभी, स्क्रीन और सभी वैरिएबल / ऑब्जेक्ट / कुछ भी जो आपने बनाया / आयात किया है, अजगर में स्पष्ट हो जाएगा।

जब आप बाहर निकलना चाहते हैं तो अजगर में बस बाहर निकलें () टाइप करें।

Answer 30

ठीक है, इसलिए यह बहुत कम तकनीकी उत्तर है, लेकिन मैं नोटपैड ++ के लिए पायथन प्लगइन का उपयोग कर रहा हूं और यह पता चला है कि आप बस कंसोल को मैन्युअल रूप से राइट-क्लिक करके और "स्पष्ट" पर क्लिक करके साफ कर सकते हैं। उम्मीद है कि इससे वहां किसी को मदद मिलेगी!