python बिना किसी लाइन या स्पेस के प्रिंट कैसे करें?




newline (21)

सवाल शीर्षक में है।

मैं इसे python में करना चाहता हूं। मैं इस उदाहरण में c में क्या करना चाहता हूं:

#include <stdio.h>

int main() {
    int i;
    for (i=0; i<10; i++) printf(".");
    return 0;
}

आउटपुट:

..........

पायथन में:

>>> for i in xrange(0,10): print '.'
.
.
.
.
.
.
.
.
.
.
>>> for i in xrange(0,10): print '.',
. . . . . . . . . .

पायथन print एक \n या एक स्पेस जोड़ देगा, मैं इससे कैसे बच सकता हूं? अब, यह सिर्फ एक उदाहरण है। मुझे मत बताओ मैं पहले एक स्ट्रिंग बना सकता हूं और फिर इसे प्रिंट कर सकता हूं। मैं जानना चाहता हूं कि स्ट्रिंग को तारों को "संलग्न" कैसे करें।


नोट: इस प्रश्न का शीर्षक "पायथन में प्रिंट कैसे करें?" जैसा कुछ होता था?

चूंकि लोग यहां शीर्षक के आधार पर इसकी तलाश कर सकते हैं, इसलिए पाइथन प्रिंटफ-स्टाइल प्रतिस्थापन का भी समर्थन करता है:

>>> strings = [ "one", "two", "three" ]
>>>
>>> for i in xrange(3):
...     print "Item %d: %s" % (i, strings[i])
...
Item 0: one
Item 1: two
Item 2: three

और, आप स्ट्रिंग मानों को आसानी से गुणा कर सकते हैं:

>>> print "." * 10
..........

आप देखेंगे कि उपरोक्त सभी उत्तर सही हैं। लेकिन मैं हमेशा अंत में "end = '' पैरामीटर लिखने के लिए शॉर्टकट बनाना चाहता था।

आप एक समारोह को परिभाषित कर सकते हैं

def Print(*args,sep='',end='',file=None,flush=False):
    print(*args,sep=sep,end=end,file=file,flush=flush)

यह सभी मानकों को स्वीकार करेगा। यहां तक ​​कि यह सभी अन्य पैरामीटर जैसे फ़ाइल, फ्लश इत्यादि और उसी नाम से स्वीकार करेगा।


... आपको किसी पुस्तकालय को आयात करने की आवश्यकता नहीं है। बस हटाए गए चरित्र का उपयोग करें:

BS=u'\0008' # the unicode for "delete" character
for i in range(10):print(BS+"."),

यह नई लाइन और अंतरिक्ष को हटा देता है (^ _ ^) *


@lenooh मेरी क्वेरी संतुष्ट। 'पायथन दबाने वाली नई लाइन' की खोज करते समय मैंने इस लेख की खोज की। मैं PUTTY के लिए पायथन 3.2 विकसित करने के लिए रास्पबेरी पीआई पर IDLE3 का उपयोग कर रहा हूं। मैं पुटी कमांड लाइन पर प्रगति पट्टी बनाना चाहता था। मैं पेज स्क्रॉलिंग नहीं चाहता था। मैं एक क्षैतिज रेखा चाहता था कि उपयोगकर्ता को यह पता लगाने से आश्वस्त किया जाए कि कार्यक्रम को रोक दिया गया है और न ही एक आकर्षक अनंत लूप पर दोपहर के भोजन के लिए भेजा गया है - 'मुझे छोड़ने के लिए एक याचिका के रूप में, मैं ठीक कर रहा हूं, लेकिन इसमें कुछ समय लग सकता है। ' इंटरैक्टिव संदेश - पाठ में प्रगति पट्टी की तरह।

print('Skimming for', search_string, '\b! .001', end='') अगले स्क्रीन-लिखने की तैयारी करके संदेश को प्रारंभ करता है, जो तीन बैकस्पेस को ⌫⌫⌫ रूबआउट और फिर एक अवधि के रूप में प्रिंट करेगा, '001' को मिटाकर और अवधि की रेखा को विस्तारित करना। search_string तोते उपयोगकर्ता इनपुट के बाद, \b! मेरे search_string टेक्स्ट के विस्मयादिबोधक बिंदु को उस स्थान पर वापस करने के लिए ट्रिम करता है जो print() अन्यथा बलपूर्वक विराम चिह्न को व्यवस्थित करता है। इसके बाद एक स्पेस और 'प्रोग्रेस बार' का पहला 'डॉट' है जिसे मैं अनुकरण कर रहा हूं। अनावश्यक रूप से, संदेश को फिर भी पृष्ठ संख्या (प्रमुख शून्य के साथ तीन की लंबाई तक स्वरूपित) के साथ प्राथमिकता दी जाती है ताकि उपयोगकर्ता से नोटिस लिया जा सके कि प्रगति संसाधित की जा रही है और जो बाद में हम उस अवधि की गिनती को भी प्रतिबिंबित करेंगे जो हम बाद में तैयार करेंगे सही।

import sys

page=1
search_string=input('Search for?',)
print('Skimming for', search_string, '\b! .001', end='')
sys.stdout.flush() # the print function with an end='' won't print unless forced
while page:
    # some stuff…
    # search, scrub, and build bulk output list[], count items,
    # set done flag True
    page=page+1 #done flag set in 'some_stuff'
    sys.stdout.write('\b\b\b.'+format(page, '03')) #<-- here's the progress bar meat
    sys.stdout.flush()
    if done: #( flag alternative to break, exit or quit)
        print('\nSorting', item_count, 'items')
        page=0 # exits the 'while page' loop
list.sort()
for item_count in range(0, items)
    print(list[item_count])
#print footers here
 if not (len(list)==items):
    print('#error_handler')

प्रगति बार मांस sys.stdout.write('\b\b\b.'+format(page, '03')) लाइन में है। सबसे पहले, बाईं ओर मिटाने के लिए, यह कर्सर को तीन अंकीय वर्णों पर '\ b \ b \ b' के साथ ⌫⌫⌫ rubout के रूप में बैक अप करता है और प्रगति पट्टी की लंबाई में जोड़ने के लिए एक नई अवधि छोड़ देता है। फिर यह पृष्ठ के तीन अंक लिखता है जो अब तक प्रगति कर चुके हैं। क्योंकि sys.stdout.write() एक पूर्ण बफर या आउटपुट चैनल को बंद करने की sys.stdout.flush() , sys.stdout.flush() तत्काल लिखने को मजबूर करता है। sys.stdout.flush() print() के अंत में बनाया गया है जो print(txt, end='' ) से बाईपास है। फिर कोड अपने सांसारिक समय गहन संचालन के माध्यम से लूप करता है, जबकि यह तीन अंकों को वापस करने के लिए यहां वापस आने तक कुछ और प्रिंट नहीं करता है, एक अवधि जोड़ें और तीन अंक फिर से लिखें, वृद्धि हुई।

तीन अंक मिटाए गए और फिर से लिखे गए किसी भी माध्यम से जरूरी नहीं है - यह सिर्फ एक समृद्ध है जो sys.stdout.write() बनाम print() उदाहरण sys.stdout.write() । आप एक अवधि के साथ आसानी से प्राइम कर सकते हैं और तीन फैंसी बैकस्लैश-बी ⌫ बैकस्पेस (निश्चित रूप से फॉर्मेटेड पेज की गणना भी नहीं लिख रहे हैं) को भूल जाते हैं, केवल एक बार के दौरान अवधि बार को प्रिंट करके - केवल रिक्त स्थान या न्यूलाइन के बिना sys.stdout.write('.'); sys.stdout.flush() sys.stdout.write('.'); sys.stdout.flush() जोड़ी।

कृपया ध्यान दें कि रास्पबेरी पीआई आईडीई 3 पायथन शेल बैकस्पेस को ⌫ रूबआउट के रूप में सम्मानित नहीं करता है बल्कि इसके बजाय एक स्थान प्रिंट करता है, इसके बजाय भिन्नताओं की एक स्पष्ट सूची बना देता है।

- (ओ = 8> wiz


आप इसे प्रिंट के end तर्क के साथ कर सकते हैं। पायथन 3 रेंज () रिटर्न इटेटर और xrange () में मौजूद नहीं है।

for i in range(10): print('.', end='')

आप निम्नानुसार Python3 में ऐसा कर सकते हैं:

#!usr/bin/python

i = 0
while i<10 :
    print('.',end='')
    i = i+1

और इसे python filename.py या python3 filename.py साथ निष्पादित करें


सामान्य तरीका

import sys
sys.stdout.write('.')

आपको कॉल करने की भी आवश्यकता हो सकती है

sys.stdout.flush()

यह सुनिश्चित करने के लिए कि stdout तुरंत flushed है।

पायथन 2.6+

पायथन 2.6 से आप पाइथन 3 से print फ़ंक्शन आयात कर सकते हैं:

from __future__ import print_function

यह आपको नीचे पाइथन 3 समाधान का उपयोग करने की अनुमति देता है।

पायथन 3

पायथन 3 में, print स्टेटमेंट को एक फ़ंक्शन में बदल दिया गया है। पायथन 3 में, आप इसके बजाय कर सकते हैं:

print('.', end='')

यह पायथन 2 में भी काम करता है, बशर्ते आपने from __future__ import print_function उपयोग किया from __future__ import print_function

यदि आपको बफरिंग में समस्या हो रही है, तो आप flush=True कीवर्ड तर्क जोड़कर आउटपुट फ्लश कर सकते हैं:

print('.', end='', flush=True)

यह Guido वैन Rossum द्वारा इस लिंक पर वर्णित के रूप में सरल होना चाहिए:

पुन :: एसी / आर के बिना एक प्रिंट कैसे करता है?

http://legacy.python.org/search/hypermail/python-1992/0115.html

क्या कुछ प्रिंट करना संभव है लेकिन स्वचालित रूप से इसमें कैरिज रिटर्न शामिल नहीं है?

हां, मुद्रित करने के अंतिम तर्क के बाद एक अल्पविराम संलग्न करें। उदाहरण के लिए, यह लूप रिक्त स्थान से अलग लाइन पर संख्या 0..9 प्रिंट करता है। पैरामीटर रहित "प्रिंट" पर ध्यान दें जो अंतिम नई लाइन जोड़ता है:

>>> for i in range(10):
...     print i,
... else:
...     print
...
0 1 2 3 4 5 6 7 8 9
>>> 

नया (पायथन 3.0 के रूप में) print फ़ंक्शन में एक वैकल्पिक end पैरामीटर है जो आपको अंतिम वर्ण को संशोधित करने देता है। विभाजक के लिए sep भी है।


पायथन 3.6.1 के लिए कोड

for i in range(0,10): print('.' , end="")

उत्पादन

..........
>>>

इनमें से कई उत्तर थोड़ा जटिल लगते हैं। पायथन 3.X में आप बस यह करते हैं,

print(<expr>, <expr>, ..., <expr>, end=" ")

अंत का डिफ़ॉल्ट मान "\ n" है। हम इसे किसी स्थान पर बदल रहे हैं या आप अंत = "" का भी उपयोग कर सकते हैं।


for i in xrange(0,10): print '\b.',

यह 2.7.8 और 2.5.2 (क्रमशः चंदवा और ओएसएक्स टर्मिनल) दोनों में काम करता था - कोई मॉड्यूल आयात या समय यात्रा की आवश्यकता नहीं थी।


Python2.6 + के लिए python3-style प्रिंट फ़ंक्शन का उपयोग करें (उसी फ़ाइल में मौजूद किसी भी मौजूदा कीवर्ड मुद्रित बयान भी तोड़ देगा।)

# for python2 to use the print() function, removing the print keyword
from __future__ import print_function
for x in xrange(10):
    print('.', end='')

अपने सभी printf.py प्रिंट कीवर्ड को बर्बाद न करने के लिए, एक अलग printf.py फ़ाइल बनाएं

# printf.py

from __future__ import print_function

def printf(str, *args):
    print(str % args, end='')

फिर, इसे अपनी फाइल में इस्तेमाल करें

from printf import printf
for x in xrange(10):
    printf('.')
print 'done'
#..........done

Printf शैली दिखा रहे अधिक उदाहरण

printf('hello %s', 'world')
printf('%i %f', 10, 3.14)
#hello world10 3.140000

मुझे हाल ही में एक ही समस्या थी ..

मैंने इसे हल करके हल किया:

import sys, os

# reopen stdout with "newline=None".
# in this mode,
# input:  accepts any newline character, outputs as '\n'
# output: '\n' converts to os.linesep

sys.stdout = os.fdopen(sys.stdout.fileno(), "w", newline=None)

for i in range(1,10):
        print(i)

यह यूनिक्स और विंडोज दोनों पर काम करता है ... मैकोक्स पर इसका परीक्षण नहीं किया है ...

hth


हैलो फर्स्टनाम अंतिम नाम! प्रिंटिंग करते समय यह एक मुट्ठी नाम है और बी अंतिम नाम है, लेकिन आखिरी नाम प्रिंट करते समय एक जगह अंततः जोड़ दी जाती है

a="Firstname"
b="Lastname"
print("Hello",a,b+"!")

पायथन 2.6+ :

from __future__ import print_function # needs to be first statement in file
print('.', end='')

पायथन 3 :

print('.', end='')

पायथन <= 2.5 :

import sys
sys.stdout.write('.')

यदि प्रत्येक प्रिंट के बाद पाइथन 2 में अतिरिक्त स्थान ठीक है

print '.',

अजगर 2 में भ्रामक - से बचें :

print('.'), # avoid this if you want to remain sane
# this makes it look like print is a function but it is not
# this is the `,` creating a tuple and the parentheses enclose an expression
# to see the problem, try:
print('.', 'x'), # this will print `('.', 'x') `

तुम कोशिश कर सकते हो:

import sys
import time
# Keeps the initial message in buffer.
sys.stdout.write("\rfoobar bar black sheep")
sys.stdout.flush()
# Wait 2 seconds
time.sleep(2)
# Replace the message with a new one.
sys.stdout.write("\r"+'hahahahaaa             ')
sys.stdout.flush()
# Finalize the new message by printing a return carriage.
sys.stdout.write('\n')

आप लूप के लिए कुछ प्रिंट करना चाहते हैं, लेकिन आप इसे हर बार नई लाइन में प्रिंट नहीं करना चाहते हैं .. उदाहरण के लिए:

 for i in range (0,5):
   print "hi"

 OUTPUT:
    hi
    hi
    hi
    hi
    hi

लेकिन आप इसे इस तरह प्रिंट करना चाहते हैं: हाय नमस्ते हाय हाय हाय हाय ???? प्रिंट "हाय" के बाद बस एक अल्पविराम जोड़ें

उदाहरण:

for i in range (0,5): print "hi", OUTPUT: hi hi hi hi hi



Printf नामक एक नया फ़ंक्शन बनाने के लिए functools.partial का उपयोग करना

>>> import functools

>>> printf = functools.partial(print, end="")

>>> printf("Hello world\n")
Hello world

डिफ़ॉल्ट पैरामीटर के साथ एक फ़ंक्शन को लपेटने का आसान तरीका।


पायथन में print फ़ंक्शन स्वचालित रूप से एक नई लाइन उत्पन्न करता है। तुम कोशिश कर सकते हो:

print("Hello World", end="")





newline