न्यूलाइन के बिना मुद्रण (प्रिंट 'ए') एक स्थान को प्रिंट करता है, कैसे निकालें?

Question

मेरे पास यह कोड है:

>>> for i in xrange(20):
...     print 'a',
... 
a a a a a a a a a a a a a a a a a a a a

मैं इस तरह से 'a'बिना उत्पादन करना चाहता हूं ' ':

aaaaaaaaaaaaaaaaaaaa

क्या यह संभव है?

Comments

मुझे आश्चर्य है कि अभी तक किसी का उल्लेख नहीं किया गया है "".join("a" for i in xrange(20))। (यह सिर्फ करने की तुलना में बहुत अधिक लचीला है "a" * 20, जैसा कि मुझे लगता है कि यह एक सरल उदाहरण है)।

— थॉमस के 12

Answer 1

आपके परिणाम प्राप्त करने के कई तरीके हैं। यदि आप अपने मामले के लिए एक समाधान चाहते हैं, तो @ उल्लेख के रूप में स्ट्रिंग गुणन का उपयोग करें । यह केवल तभी काम करने वाला है जब आपका प्रत्येक स्टेटमेंट एक ही स्ट्रिंग को प्रिंट करता है। ध्यान दें कि यह किसी भी लंबाई स्ट्रिंग (जैसे काम करता है) के गुणन के लिए काम करता है।print'foo' * 20

>>> print 'a' * 20
aaaaaaaaaaaaaaaaaaaa

यदि आप इसे सामान्य रूप से करना चाहते हैं, तो एक स्ट्रिंग बनाएं और फिर इसे एक बार प्रिंट करें। यह स्ट्रिंग के लिए थोड़ी मेमोरी का उपभोग करेगा, लेकिन केवल एक ही कॉल करें print। ध्यान दें कि आप जिस स्ट्रिंग का उपयोग +=कर रहे हैं, उसके स्ट्रिंग स्ट्रिंग आकार में रेखीय है, इसलिए यह तेज होगा।

>>> for i in xrange(20):
...     s += 'a'
... 
>>> print s
aaaaaaaaaaaaaaaaaaaa

या आप इसे सीधे सीधे sys.stdout का उपयोग करके कर सकते हैं । लिखना () , जो printचारों ओर एक आवरण है। यह केवल कच्ची स्ट्रिंग लिखेगा जो आप इसे देते हैं, बिना किसी स्वरूपण के। ध्यान दें कि 20 aएस के अंत में भी कोई नई रेखा नहीं छपी है ।

>>> import sys
>>> for i in xrange(20):
...     sys.stdout.write('a')
... 
aaaaaaaaaaaaaaaaaaaa>>> 

पायथन 3 printस्टेटमेंट को प्रिंट () फ़ंक्शन में बदलता है , जो आपको एक endपैरामीटर सेट करने की अनुमति देता है । से आयात करके आप इसे> = 2.6 में उपयोग कर सकते हैं __future__। मैं किसी भी गंभीर 2.x कोड में इससे बचूंगा, हालांकि, यह उन लोगों के लिए थोड़ा भ्रमित करने वाला होगा जिन्होंने कभी 3.x का उपयोग नहीं किया है। हालांकि, यह आपको कुछ अच्छाई 3.x लाता है का स्वाद देना चाहिए।

>>> from __future__ import print_function
>>> for i in xrange(20):
...     print('a', end='')
... 
aaaaaaaaaaaaaaaaaaaa>>> 

Comments

@AAI ने उस प्रश्न को पढ़ा जब स्ट्रिंग गुणन उत्तर मौजूद था, और मुझे लगा कि मैं कई विकल्पों का अवलोकन करूँगा। जब मैं अपना उत्तर दे रहा था तो दूसरे लोग आ गए। इसके तुरंत बाद इसे स्वीकार कर लिया गया, अन्यथा मैं इसे हटा देता।

— मोइनुद्दीन 12

-1 संगति द्वारा तार का निर्माण न करें; यह O (n) के बजाय O (n ^ 2) है। "".join(...)इसके बजाय उपयोग करें ।

— कैटरील

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

— user225312

@katrielalex: क्या यह मायने रखता है? क्या ओपी ने अनुकूलन या जटिलता के लिए कहा है? और क्या यह 20 तार के लिए मायने रखेगा? चलो, आपको गंभीरता से मजाक करना चाहिए।

— user225312

@katrielalex गलत, +=पायथन में उपयोग करने वाले स्ट्रिंग समवर्ती एक एकल चरित्र के संघनन के लिए एक निरंतर समय ऑपरेशन है।

— मोइनुद्दीन

Answer 2

से पीईपी 3105: प्रिंट एक समारोह के रूप में नया क्या है अजगर 2.6 में दस्तावेज़:

>>> from __future__ import print_function
>>> print('a', end='')

जाहिर है कि केवल अजगर 3.0 या उच्चतर (या from __future__ import print_functionशुरुआत में 2.6+) के साथ काम करता है । printबयान हटा दिया और बन गया print()अजगर 3.0 में डिफ़ॉल्ट रूप से कार्य करते हैं।

Answer 3

आप printस्टेटमेंट के बीच खाली स्ट्रिंग को प्रिंट करके स्पेस को दबा सकते हैं ।

>>> import sys
>>> for i in range(20):
...   print 'a',
...   sys.stdout.write('')
... 
aaaaaaaaaaaaaaaaaaaa

हालाँकि, एक क्लीनर समाधान सबसे पहले उस संपूर्ण स्ट्रिंग का निर्माण करना है जिसे आप प्रिंट करना चाहते हैं और फिर इसे एक सिंगल printस्टेटमेंट के साथ आउटपुट करते हैं।

Comments

@ सूलीसेका: हाँ, sys.stdout.write()इस मामले में केवल उपयोग करना अधिक सुविधाजनक है। हालांकि, मैं यह दिखाना चाहता था कि स्टडआउट के लिए एक खाली स्ट्रिंग लिखने से उपयोग किए गए तत्वों के बीच की जगह दब जाती है print, जो समान स्थितियों में उपयोगी हो सकती है।

— पियर वेसलैंडर

Answer 4

आप एक बैकस्पेस वर्ण प्रिंट कर सकते हैं ( '\b'):

for i in xrange(20):
    print '\ba',

परिणाम:

aaaaaaaaaaaaaaaaaaaa

Answer 5

अजगर 3.x:

for i in range(20):
    print('a', end='')

पायथन 2.6 या 2.7:

from __future__ import print_function
for i in xrange(20):
    print('a', end='')

Answer 6

यदि आप चाहते हैं कि वे एक बार में एक प्रदर्शन करें, तो आप यह कर सकते हैं:

import time
import sys
for i in range(20):
    sys.stdout.write('a')
    sys.stdout.flush()
    time.sleep(0.5)

sys.stdout.flush() हर बार जब लूप चलाया जाता है, तो चरित्र को लिखने के लिए मजबूर करना आवश्यक है।

Answer 7

बस एक नोट के रूप में:

मुद्रण O (1) है लेकिन एक स्ट्रिंग का निर्माण और फिर मुद्रण O (n) है, जहां n स्ट्रिंग में कुल वर्ण हैं। तो हाँ, स्ट्रिंग बनाते समय "क्लीनर" है, यह ऐसा करने का सबसे कुशल तरीका नहीं है।

जिस तरह से मैं यह करूंगा वह इस प्रकार है:

from sys import stdout
printf = stdout.write

अब आपके पास एक "प्रिंट फंक्शन" है जो किसी भी स्ट्रिंग को प्रिंट करता है जिसे आप हर बार नई लाइन वर्ण को वापस किए बिना देते हैं।

printf("Hello,")
printf("World!")

आउटपुट होगा: हैलो, वर्ल्ड!

हालाँकि, यदि आप पूर्णांक, फ़्लोट्स या अन्य गैर-स्ट्रिंग मान मुद्रित करना चाहते हैं, तो आपको उन्हें स्ट्रिंग () फ़ंक्शन के साथ स्ट्रिंग में बदलना होगा।

printf(str(2) + " " + str(4))

आउटपुट होगा: 2 4

Comments

क्या आप कहते हैं कि मैं एक वर्ण के आउटपुट के रूप में एक ही समय में अनंत मात्रा में पाठ का उत्पादन कर सकता हूं?

— ctrl-alt-delor-

जब मैंने प्रिंटआउट को stdout.write पर फिर से परिभाषित किया, तो मेरा stdout.write चार्ट चार्टर्स की संख्या को स्ट्रिंग में प्रिंट करता प्रतीत होता है: "हेलो, 6" क्या देता है? क्या चल रहा है? और मैं इसे कैसे रोकूं?

— टॉम

इसके अलावा, क्या आप समझा सकते हैं कि O (1) O (n) से आपका क्या मतलब है? मुझे समझ नहीं आता क्या है कि को संदर्भित करता है

— टॉम

@ यह ऑपरेशन की लागत के प्रतिबिंब के रूप में जटिलता (बिग ओ नोटेशन) का उल्लेख है । O (1) निरंतर समय है - आदर्श - और O (n) रैखिक समय है - ठीक है लेकिन बहुत सरल कुछ के लिए बहुत महंगा है। हालाँकि, छोटी चीज़ों के लिए, इन चीजों के बारे में चिंता करने के लिए आप अपने दिमाग का उपयोग करने के लिए जो समय बिताते हैं, वह केवल स्ट्रिंग संयोजन का उपयोग करने की तुलना में अधिक कम्प्यूटेशनल रूप से बेकार है।

— बेंजामिन R

Answer 8

या तो चींटी क्या कहती है , या एक स्ट्रिंग में जमा होती है, फिर एक बार प्रिंट करें:

s = '';
for i in xrange(20):
    s += 'a'
print s

Answer 9

बिना क्या क्या मतलब है आपका

>>> print 'a' * 20
aaaaaaaaaaaaaaaaaaaa

?

Answer 10

यह वास्तव में सरल है

अजगर 3+ संस्करणों के लिए आपको केवल निम्नलिखित कोड लिखने होंगे

for i in range(20):
      print('a',end='')

बस लूप को निम्न कोड में परिवर्तित करें, आपको अन्य चीजों के बारे में चिंता करने की आवश्यकता नहीं है

Answer 11

वाह!!!

यह बहुत लंबा समय है पहले की बात है

अब, अजगर 3.x में यह बहुत आसान हो जाएगा

कोड:

for i in range(20):
      print('a',end='') # here end variable will clarify what you want in 
                        # end of the code

उत्पादन:

aaaaaaaaaaaaaaaaaaaa 

प्रिंट () फ़ंक्शन के बारे में अधिक

print(value1,value2,value3,sep='-',end='\n',file=sys.stdout,flush=False)

यहाँ :

value1,value2,value3

आप अल्पविराम का उपयोग करके कई मान मुद्रित कर सकते हैं

sep = '-'

3 मानों को '-' वर्ण से अलग किया जाएगा

आप इसके बजाय किसी भी वर्ण का उपयोग कर सकते हैं जैसे कि sep = '@' या sep = 'good'

end='\n'

डिफॉल्ट प्रिंट फंक्शन द्वारा आउटपुट के अंत में '\ n' चार्जर को रखा जाता है

लेकिन आप किसी भी वर्ण या स्ट्रिंग का उपयोग अंत वैरिएबल मान को बदलकर कर सकते हैं

जैसे अंत = '$' या अंत = '।' या अंत = 'हैलो'

file=sys.stdout

यह एक डिफ़ॉल्ट मान है, सिस्टम मानक आउटपुट

इस तर्क का उपयोग करके आप आउटपुट फ़ाइल स्ट्रीम बना सकते हैं जैसे

print("I am a Programmer", file=open("output.txt", "w"))

इस कोड के द्वारा आप output.txt नाम की एक फाइल बनाएंगे जहाँ आपका आउटपुट मैं एक प्रोग्रामर संग्रहीत किया जाएगा

flush = False

यह फ्लश का उपयोग करके एक डिफ़ॉल्ट मान है = सही आप स्ट्रीम को जबरन फ्लश कर सकते हैं

Answer 12

इतना सरल है

def printSleeping():
     sleep = "I'm sleeping"
     v = ""
     for i in sleep:
         v += i
         system('cls')
         print v
         time.sleep(0.02)