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




newline (18)

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

मैं इसे 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 या एक स्पेस जोड़ देगा, मैं इससे कैसे बच सकता हूं? अब, यह सिर्फ एक उदाहरण है। मुझे मत बताओ मैं पहले एक स्ट्रिंग बना सकता हूं और फिर इसे प्रिंट कर सकता हूं। मैं जानना चाहता हूं कि स्ट्रिंग को तारों को "संलग्न" कैसे करें।


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

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)

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

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

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


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

>>> import functools

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

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

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


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

आप केवल print फ़ंक्शन के अंत में जोड़ सकते हैं , इसलिए यह नई लाइन पर प्रिंट नहीं करेगा।


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

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

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

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


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

 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


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

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

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


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

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

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


पायथन 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') `

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

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


मेरी समझ यह है कि अल्पविराम ने अंतरिक्ष को दबा दिया 3 डॉट्स दुभाषिया के अवशेष हैं

मैं रेंज में (0,10): प्रिंट "। \ n", ...। । । । । । । । । ।


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

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

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

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

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

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


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

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





newline