पाइथन में कार्यक्षमता की तरह स्प्रिंटफ

Question

मैं बहुत सारी प्रोसेसिंग, फॉर्मेट करने के लिए एक स्ट्रिंग बफर बनाना चाहता हूं और अंत sprintfमें पायथन में सी-स्टाइल की कार्यक्षमता का उपयोग करके टेक्स्ट फाइल में बफर को लिखता हूं । सशर्त बयानों के कारण, मैं उन्हें सीधे फाइल में नहीं लिख सकता।

जैसे छद्म कोड:

sprintf(buf,"A = %d\n , B= %s\n",A,B)
/* some processing */
sprint(buf,"C=%d\n",c)
....
...
fprintf(file,buf)

इसलिए आउटपुट फ़ाइल में हमारे पास इस तरह का ओ / पी है:

A= foo B= bar
C= ded
etc...

संपादित करें, मेरे प्रश्न को स्पष्ट करने के लिए:
buf एक बड़ा बफर है जिसमें ये सभी तार हैं जो स्प्रिंट का उपयोग करके स्वरूपित हैं। अपने उदाहरणों के आधार पर, bufकेवल वर्तमान मूल्य शामिल होंगे, पुराने नहीं। जैसे bufमैंने पहले लिखा था A= something ,B= somethingबाद C= somethingमें उसी में जोड़ा गया था buf, लेकिन आपके पायथन के जवाबों bufमें केवल अंतिम मूल्य होता है, जो मैं नहीं चाहता - मैं शुरू से अब तक किए bufगए सभी printfएस करना चाहता हूं, जैसे कि C।

Comments

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

— यम ६५५

@dividebyzero यह पायथन में तुच्छ नहीं है क्योंकि यह एक सामान्य प्रोग्रामिंग भाषा है? उदाहरण के लिए, माइकल जे। बार्बर का समाधान (अपनी टिप्पणी के बाद पोस्ट किया गया) देखें। def sprintf(buf, fmt, *args): ...

— jdk1.0

@ jdk1.0 मुझे नहीं पता कि मेरा क्या मतलब है, मैं युवा था और भोले पायथन प्रोग्रामर ... यह सवाल वास्तव में अजीब है क्योंकि यह बफर पुन: उपयोग की चीज इतनी सरल नहीं है, आपको इसके आउटपुट के साथ एक पॉइंटर को बढ़ाना होगा प्रत्येक स्प्रिंटफ कॉल, और इस तरह की बात कुछ ऐसी नहीं है जिसके बारे में आपको चिंता होनी चाहिए अगर आप पायथन कर रहे हैं। वैसे भी, मुझे खुशी है कि मैं स्काला और अब जूलिया में चला गया!

— dividebyzero

Answer 1

अजगर के पास इसके लिए एक %ऑपरेटर है।

>>> a = 5
>>> b = "hello"
>>> buf = "A = %d\n , B = %s\n" % (a, b)
>>> print buf
A = 5
 , B = hello

>>> c = 10
>>> buf = "C = %d\n" % c
>>> print buf
C = 10

सभी समर्थित प्रारूप निर्दिष्टकर्ताओं के लिए यह संदर्भ देखें ।

आप भी उपयोग कर सकते हैं format:

>>> print "This is the {}th tome of {}".format(5, "knowledge")
This is the 5th tome of knowledge

Answer 2

यदि मैं आपके प्रश्न को सही ढंग से समझता हूं, तो प्रारूप () वही है जो आप देख रहे हैं, साथ ही इसकी लघु-भाषा भी ।

अजगर 2.7 और ऊपर के लिए मूर्खतापूर्ण उदाहरण:

>>> print "{} ...\r\n {}!".format("Hello", "world")
Hello ...
 world!

पहले के अजगर संस्करणों के लिए: (2.6.2 के साथ परीक्षण किया गया)

>>> print "{0} ...\r\n {1}!".format("Hello", "world")
Hello ...
 world!

Comments

आपको शायद ध्यान देना चाहिए कि यह संस्करण केवल पायथन 3 में काम करता है। पायथन 2.6 में, उदाहरण के लिए, आपको करने की आवश्यकता है:"{0} ...\r\n {1}!".format("Hello", "world")

— मार्क लॉन्गेयर

इसमें शामिल करने के लिए मेरे उत्तर का संपादन; ऐसा नहीं है कि यह भी अजगर 2.7 के लिए काम करता है, हालांकि!

— निकोलस लेफेबव्रे

Answer 3

मैं पूरी तरह से निश्चित नहीं हूं कि मैं आपके लक्ष्य को समझता हूं, लेकिन आप एक StringIOउदाहरण को बफर के रूप में उपयोग कर सकते हैं :

>>> import StringIO 
>>> buf = StringIO.StringIO()
>>> buf.write("A = %d, B = %s\n" % (3, "bar"))
>>> buf.write("C=%d\n" % 5)
>>> print(buf.getvalue())
A = 3, B = bar
C=5

इसके विपरीत sprintf, आप बस एक स्ट्रिंग पास करते हैं buf.write, इसे %ऑपरेटर या के साथ स्वरूपित करते हैंformat स्ट्रिंग्स विधि के हैं।

आप निश्चित रूप से उस फ़ंक्शन को परिभाषित कर सकते हैं जिसे sprintfआप जिस इंटरफ़ेस के लिए उम्मीद कर रहे हैं:

def sprintf(buf, fmt, *args):
    buf.write(fmt % args)

जिसका उपयोग इस तरह किया जाएगा:

>>> buf = StringIO.StringIO()
>>> sprintf(buf, "A = %d, B = %s\n", 3, "foo")
>>> sprintf(buf, "C = %d\n", 5)
>>> print(buf.getvalue())
A = 3, B = foo
C = 5

Comments

+1 यह दिखाने के लिए कि स्ट्रिंग फ़ॉर्मेटिंग ऑपरेटर (%) के साथ * args का उपयोग कैसे करें।

— कर्टिस येलोप

io.StringIO()इसके बजाय पायथन 3 उपयोग के लिए

— वुल्फ

Answer 4

स्वरूपण ऑपरेटर का% उपयोग करें :

buf = "A = %d\n , B= %s\n" % (a, b)
print >>f, buf

Answer 5

आप स्ट्रिंग स्वरूपण का उपयोग कर सकते हैं:

>>> a=42
>>> b="bar"
>>> "The number is %d and the word is %s" % (a,b)
'The number is 42 and the word is bar'

लेकिन यह पायथन 3 में हटा दिया गया है, आपको "str.format ()" का उपयोग करना चाहिए:

>>> a=42
>>> b="bar"
>>> "The number is {0} and the word is {1}".format(a,b)
'The number is 42 and the word is bar'

Comments

गलत, यह पायथन 3 में नहीं हटाया गया है। पायथन 3.0 ने कहा कि यह 3.1 में पदावनत किया जाएगा, लेकिन मेरा मानना ​​है कि ऐसा कभी नहीं हुआ। उपयोग करना format()बेहतर हो सकता है लेकिन %स्वरूपण अभी भी मौजूद है। ( मेल्कथॉन डॉट ओआर / पीपरमेल / पीथॉन -देव-सीसैट -३ ९९ २३-०९९ में से कुछ के लिए यह तर्क क्यों नहीं निकाला गया था)

— डंकन

@Duncan; धन्यवाद, मुझे नहीं पता था कि मैंने पढ़ा कहीं यह पदावनत और फिर कभी कोशिश नहीं की :)।

— उदिमिर

Answer 6

बहुत लंबी स्ट्रिंग में सम्मिलित होने के लिए विभिन्न तर्कों के लिए नामों का उपयोग करना अच्छा होता है, बजाय इसके कि वे सही स्थिति में हैं। इससे कई पुनरावृत्ति को प्रतिस्थापित करना आसान हो जाता है।

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'

प्रारूप के उदाहरणों से लिया गया , जहां अन्य सभी Formatसंबंधित उत्तर भी दिखाए गए हैं।

Answer 7

यह संभवतः आपके C कोड से पायथन कोड में निकटतम अनुवाद है।

A = 1
B = "hello"
buf = "A = %d\n , B= %s\n" % (A, B)

c = 2
buf += "C=%d\n" % c

f = open('output.txt', 'w')
print >> f, c
f.close()

%अजगर में ऑपरेटर सी के रूप में लगभग बिल्कुल वही बात करता है sprintf। आप स्ट्रिंग को सीधे फ़ाइल में भी प्रिंट कर सकते हैं। यदि इनमें से बहुत सारे स्ट्रिंग स्वरूपित स्ट्रिंग शामिल हैं, तो इसका उपयोग करना बुद्धिमानी हो सकता हैStringIO प्रसंस्करण समय को गति वस्तु का ।

इसलिए करने के बजाय +=, यह करें:

import cStringIO
buf = cStringIO.StringIO()

...

print >> buf, "A = %d\n , B= %s\n" % (A, B)

...

print >> buf, "C=%d\n" % c

...

print >> f, buf.getvalue()

Answer 8

यदि आप python3 प्रिंट फ़ंक्शन की तरह कुछ चाहते हैं लेकिन एक स्ट्रिंग के लिए:

def sprint(*args, **kwargs):
    sio = io.StringIO()
    print(*args, **kwargs, file=sio)
    return sio.getvalue()

>>> x = sprint('abc', 10, ['one', 'two'], {'a': 1, 'b': 2}, {1, 2, 3})
>>> x
"abc 10 ['one', 'two'] {'a': 1, 'b': 2} {1, 2, 3}\n"

या '\n'अंत में बिना :

def sprint(*args, end='', **kwargs):
    sio = io.StringIO()
    print(*args, **kwargs, end=end, file=sio)
    return sio.getvalue()

>>> x = sprint('abc', 10, ['one', 'two'], {'a': 1, 'b': 2}, {1, 2, 3})
>>> x
"abc 10 ['one', 'two'] {'a': 1, 'b': 2} {1, 2, 3}"

Answer 9

कुछ इस तरह...

greetings = 'Hello {name}'.format(name = 'John')

Hello John

Comments

यह एक स्ट्रिंग को कंसोल पर भेजता है, एक स्ट्रिंग के लिए नहीं, जो कि ओपी चाहता था।

— तेमु लेइस्टी

इसने स्क्रीन पर% s भी छापा, जिसकी उम्मीद नहीं थी; लेकिन मुझे यह पसंद है कि मैं अल्पविराम के साथ कई चर जोड़ सकता हूं।

— b01

Answer 10

"लिटरल स्ट्रिंग इंटरप्रेशन" https://www.python.org/dev/peps/pep-0498/ पर एक नज़र डालें

मैंने इसे http://www.malemburg.com/ के माध्यम से पाया

Answer 11

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

from io import StringIO

with StringIO() as s:
   print("Hello", file=s)
   print("Goodbye", file=s)
   # And later...
   with open('myfile', 'w') as f:
       f.write(s.getvalue())

आप इनका उपयोग बिना ContextMananger( s = StringIO()) के भी कर सकते हैं । वर्तमान में, मैं एक printफ़ंक्शन के साथ एक संदर्भ प्रबंधक वर्ग का उपयोग कर रहा हूं । डिबगिंग या विषम पेजिंग आवश्यकताओं को सम्मिलित करने में सक्षम होने के लिए यह टुकड़ा उपयोगी हो सकता है:

class Report:
    ... usual init/enter/exit
    def print(self, *args, **kwargs):
        with StringIO() as s:
            print(*args, **kwargs, file=s)
            out = s.getvalue()
        ... stuff with out

with Report() as r:
   r.print(f"This is {datetime.date.today()}!", 'Yikes!', end=':')