Please support if you like my work by payment through upi: sinhamit@icici or payment by bank
account name: Amit Kumar Sinha,
account number: 2646728782
IFSC code: KKBK0005660
SWIFT: KKBKINBB
Inserting Variables into Strings in Category: पाइथन by amit
🕙 Posted on 2023-07-28 at 19:39:54
फ़ॉर्मेटिंग शैलियाँ: स्ट्रिंग्स को जोड़ने के अन्य तरीके
%, format(), f-स्ट्रिंग
वेरिएबल को स्ट्रिंग में डालने और फ़ॉर्मेट करने के इन तीन तरीकों में से % ऑपरेटर सबसे पुराना है। f"{variableName} OtherTexts" (f-स्ट्रिंग के रूप में जाना जाता है) को पायथन 3.6 में पेश किया गया था, और यह % प्लेसहोल्डर और format() स्ट्रिंग विधि (जिसे पायथन 2.6 में पेश किया गया था) की तुलना में अधिक पठनीय और लागू / उपयोग करने में आसान है। गति/प्रदर्शन के मामले में, % प्लेसहोल्डर सबसे तेज़ है, और .format() स्ट्रिंग विधि अन्य दो फ़ॉर्मेटिंग (स्वरूपण) शैलियों की तुलना में धीमी है।
% ऑपरेटर/
निम्नलिखित उदाहरण में, तीन चर (variables) अर्थात् my_str (स्ट्रिंग डेटा-प्रकार), my_int (पूर्णांक डेटा-प्रकार), और my_float (फ्लोट डेटा-प्रकार) का उपयोग मूल स्ट्रिंग के अंदर वांछित स्थान पर रखने के लिए किया जाता है। स्ट्रिंग शाब्दिक और % ऑपरेटर के बाद टुपल में उतने ही आइटम/() कोष्ठक के भीतर संलग्न किया जाना चाहिए। डाला जाने वाला % प्लेसहोल्डर तीन प्रकार का होता है:
(1) %d विशेष रूप से पूर्णांक डालने/
(2) %f विशेष रूप से, फ़्लोट (दशमलव/
(3) %s स्ट्रिंग और अन्य सभी डेटा-प्रकार सम्मिलित करता है।
% प्लेसहोल्डर ऑब्जेक्ट और विशेषताओं (attributes) को मूल स्ट्रिंग में सम्मिलित नहीं कर सकता है। आप निम्नलिखित उदाहरण में देख सकते हैं, कि जब वेरिएबल my_float (फ्लोट डेटा-प्रकार) को जानबूझकर %d (पूर्णांक) प्लेसहोल्डर में डाला जाता है, तो आउटपुट को पूर्णांक मान में छोटा कर (छांट) दिया जाता है। आप यह भी देख सकते हैं कि सिंगल/
आपको ध्यान देना चाहिए कि आप %d (पूर्णांक) या %f (फ़्लोट) प्लेसहोल्डर्स के लिए स्ट्रिंग मान नहीं पास कर (डाल) सकते। साथ ही, आप % ऑपरेटर के बाद सूची (अर्थात् list या वर्गाकार कोष्ठक) नहीं रख सकते। इन दोनों मामलों में, पायथन इन्टरप्रेटर TypeError आउटपुट करेगा, जैसा कि नीचे दिखाया गया है।
my_str = "hello"
my_int = 32
my_float = 32.3
print( " %s %d %f " % (my_str, my_int, my_float) ) # आउटपुट hello 32 32.300000 है।
print( " %s %f %d " % (my_str, my_int, my_float) ) # आउटपुट hello 32.000000 32
print( " %s %s %s " % (my_str, my_int, my_float) ) # आउटपुट hello 32 32.3 है।
print( " %d %s %s " % (my_str, my_int, my_float) ) # जैसा कि नीचे दिखाया गया, आउटपुट TypeError है। %d (वास्तविक real संख्या) प्लेसहोल्डर पर स्ट्रिंग डेटा-प्रकार प्रदान किया गया है।
File "C:\xampp\
print( " %d %s %s " % (my_str, my_int, my_float) )
~~~~~~~~~~~^
TypeError: %d format: a real number is required, not str
print( " %s %s %s " % [my_str, my_int, my_float] ) # आउटपुट TypeError जैसा कि नीचे दिखाया गया है, लेकिन जब आप वर्गाकार कोष्ठकों को () कोष्ठक से बदलते हैं, तो कोई त्रुटि प्रदर्शित नहीं होगी।
File "C:\xampp\
print( " %s %s %s " % [my_str, my_int, my_float] )
~~~~~~~~~~~^
TypeError: not enough arguments for format string
%s (स्ट्रिंग) प्लेसहोल्डर
%s (स्ट्रिंग) प्लेसहोल्डर स्ट्रिंग, पूर्णांक, फ्लोट, बूलियन डेटा-प्रकार रख सकता है, और टपल में जितने आइटम/% प्लेसहोल्डर 1990 के दशक से स्टाइल फ़ॉर्मेटिंग का पुराना तरीका है, जब प्रोग्रामर ब्लैक स्क्रीन कमांड लाइन कंसोल में फैंसी आउटपुट प्रदर्शित करने के लिए संघर्ष करते थे। इस प्रकार, रिक्त स्थान छोड़ने और टेक्स्ट फ़ॉर्मेटिंग को स्टाइल करने के विकल्प मौजूद हैं:
print( " %s %s %s " % ( (True, None, 3) ) ) # आउटपुट True None 3 (Noneअन्य प्रोग्रामिंग भाषाओं में है null- विशेष डेटा-प्रकार।)
print( help( None ) ) # आउटपुट नीचे दिखाया गया है:
class NoneType(object)
| Methods defined here:
|
| __bool__(self, /)
| True if self else False
|
| __repr__(self, /)
| Return repr(self).
|
| -----------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
None
एक डॉकस्ट्रिंग का उपयोग इसके अंदर वेरिएबल प्रदर्शित करने के लिए किया गया है। पायथन इन-बिल्ट फ़ंक्शन, vars() (बिना किसी तर्क के), या locals() का उपयोग स्ट्रिंग शाब्दिक के अंदर वेरिएबल नाम (greeting, x, y, a, b, c) डालने के लिए किया जा सकता है, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:
greeting = "Hello World"
x = 10
y = 20
print ( """Greeting = %(greeting)s
x, y = ( %(x)s, %(y)s )""" % vars() )
print ( "Greeting = %(greeting)s x, y = ( %(x)s, %(y)s )" % locals() )
# आप डिक्शनरी शाब्दिक के मानों (values) को वेरिएबल्स में सीधे पास कर सकते हैं:
print( '%(a)s %(c)s %(b)s' % {'a': 10, 'b': 50, 'c': 30} )
x, y = ( 10, 20 )
Greeting = Hello World x, y = ( 10, 20 )
10 30 50
vars() एक पायथन अंतर्निर्हित (built-in) फ़ंक्शन है, जो locals() के जैसा व्यवहार करता है, जब कोष्ठक के अंदर कोई तर्क पारित नहीं किया जाता है। vars() एक डिक्शनरी लौटाता है:
(i) वर्तमान नामस्थान (namespace यदि बिना किसी तर्क के कॉल किया जाता है), या
(ii) कोष्ठक के भीतर पारित तर्क।
print( help( vars ) ) # आउटपुट नीचे दिखाया गया है:
vars(...)
vars([object]) -> dictionary
Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
None
print( help( locals ) ) # आउटपुट नीचे दिखाया गया है:
locals()
Return a dictionary containing the current scope's local variables.
NOTE: Whether or not updates to this dictionary will affect name lookups in
the local scope and vice-versa is *implementation dependent* and not
covered by any backwards compatibility guarantees.
None
%d और %f प्लेसहोल्डर
इन दो प्लेसहोल्डर्स का मुख्य उपयोग पूर्णांक और फ़्लोट को विशेष रूप से सम्मिलित करने के लिए किया जाता है। इन दोनों को प्रोग्रामर द्वारा अपने कोड में आवश्यकतानुसार स्वरूपित (फ़ॉर्मेट) किया जा सकता है। निम्नलिखित उदाहरण में, वेरिएबल my_num को निर्दिष्ट फ्लोटिंग पॉइंट नंबर (पाइ PI का अनुमानित मान) को दशमलव बिंदु के बाद पांचवें स्थान पर छोटा कर दिया गया है। ये फ़्लोटिंग पॉइंट संख्याएँ अपरिमेय (irrational) संख्याएँ हैं (अनंत infinite दशमलव मान तक, उदाहरण के लिए, 22/7)। सम्मिश्र (complex) संख्याएँ अपरिमेय संख्याओं से भिन्न होती हैं। परिमेय (rational) संख्याएँ निश्चित (finite) भिन्नात्मक (fractional फ़्लोटिंग पॉइंट) मान हैं (अर्थात, दशमलव बिंदु के बाद परिमित अंक)।
my_num = 3.141592653589793
print("%.5f" % my_num) # आउटपुट 3.14159 है। (% प्लेसहोल्डर के बाद . डॉट चिन्ह महत्वपूर्ण है।)
%d (0 से 9 तक) संख्याएं डालने के लिए, %o (शून्य नहीं, बल्कि अंग्रेजी अक्षर 'o') ऑक्टल (0 से 7 तक) और, %e फ्लोटिंग पॉइंट (घातीय exponential में) मान प्रदर्शित करने के लिए प्लेसहोल्डर हैं।
print( " %d " % 456 ) # आउटपुट 456
print( " %o " % 456 ) # आउटपुट 710 है। (यह संख्यात्मक दशमलव नहीं है, बल्कि 456 का अष्टक प्रतिनिधित्व है।)
print( " %e " % 456 ) # आउटपुट 4.560000e+02 (e+2 का अर्थ 102 जो कि 10×10 है)।
format() विधि
आप print( help( str.format ) ) कथन निष्पादित करके सहायता दस्तावेज़ प्राप्त कर सकते हैं। format() विधि मूल स्ट्रिंग के अंदर प्लेसहोल्डर के रूप में घुंघराले ब्रेसिज़ का उपयोग करती है, और .format के ठीक बाद () कोष्ठक के भीतर चर (variables) प्रदान किए जाते हैं। इन चर नामों को 0 (शून्य) से शुरू करके सूचकांक किया जाता है, और जब ये सूचकांक संख्याएं घुंघराले ब्रेसिज़ के भीतर प्रदान नहीं की जाती हैं, तो चर को संबंधित क्रम में रखा जाता है।
print( "1. name is {}.".format( 'Amit' ) )
print( '2. name is {} and age is {}.'.format( 'Amit', '42' ) )
print( "3. name is {1} and age is {0}.".format( 'Amit', 42 ) )
print( "4. name is {x} and age is {y}.".format( x='Amit', y='42' ) )
print( "5. name is {y} and age is {x}.".format( x='Amit', y='42' ) )
print( "6. name is {y} and age is {y}.".format( x='Amit', y='42' ) )
2. name is Amit and age is 42.
3. name is 42 and age is Amit.
4. name is Amit and age is 42.
5. name is 42 and age is Amit.
6. name is 42 and age is 42.
उपरोक्त उदाहरण के आउटपुट में, आप देख सकते हैं कि पंक्ति 3 में, जहां 1 (एक) घुंघराले ब्रेसिज़ की पहली जोड़ी में प्रदान किया गया है, और 0 (शून्य) घुंघराले ब्रेसिज़ की दूसरी जोड़ी में प्रदान किया गया है, परिणाम जैसा पंक्ति 2 में दिखाया गया है, उसके विपरीत है। इसी प्रकार, चर नाम, x और y पंक्ति 4 और 5 में उलटे हैं। इन पंक्ति संख्या 4 और 5 के आउटपुट भी उलटा है। पंक्ति 6 में, घुंघराले ब्रेसिज़ की दोनों जोड़ी में केवल वेरिएबल y प्रदान किया गया है, और इसलिए केवल इसे सौंपा गया मान आउटपुट में प्रदर्शित होता है।
format() विधि में कई उन्नत (advanced) सुविधाएँ (features) प्रदान की गई हैं, जिनके बारे में आपको बाद में बताया जाएगा। सिंगल/
num = int( input( "Enter an integer value: " ) )
binary_num = "{0:b}".format(num)
print( "Binary representation of ", num, " is ", binary_num)
num = int( input( "Enter an integer value: " ) )
octal_num = "{0:o}".format(num) # before colon, digit is zero; and after colon, it is letter 'o'
print( "Octal representation of ", num, " is ", octal_num)
f -स्ट्रिंग
f स्ट्रिंग नवीनतम स्वरूपण (फ़ॉर्मेटिंग) शैली है, जिसमें आप घुंघराले ब्रेसिज़ के भीतर अभिव्यक्तियों का उपयोग कर सकते हैं (अर्थात, आप चर नामों या शाब्दिक पर उचित अंतर्निहित फ़ंक्शन या विधियों को लागू कर सकते हैं)। अन्य प्रोग्रामिंग भाषाओं (जैसे PHP और JavaScript) के विपरीत, आप पायथन में फ़ॉर्मेटिंग के तीनों तरीकों में या तो सिंगल कोट्स की एक जोड़ी या डबल कोट्स की एक जोड़ी का उपयोग कर सकते हैं।
name = "Amit"
age = 42
# % ऑपरेटर के साथ फ़ॉर्मेटिंग
print( 'Dear %s, you are %d years old.' % (name, age) )
print( "Dear %s, you are %d years old." % (name, age) )
# format() विधि के साथ फ़ॉर्मेटिंग
print( 'Dear {}, you are {} years old.'.format(name, age) )
print( "Dear {}, you are {} years old.".format(name, age) )
# f स्ट्रिंग के साथ फ़ॉर्मेटिंग
print( f'Dear {name}, you are {age} years old.' )
print( f"Dear {name}, you are {age} years old." )
print( f"Dear {name.upper()}, you are {abs( age )} years old." )
रिक्त स्थान (टैब) बनाने के लिए expandtabs(), टेक्स्ट को तदनुसार केंद्र, बाएं या दाएं में संरेखित (align) करने के लिए center(), ljust(), rjust() आदि, जैसे अन्य स्ट्रिंग विधियां हैं। हालाँकि, इन विधियों का उपयोग आमतौर पर पुराने दिनों में (काली स्क्रीन) कमांड प्रॉम्प्ट/format_map() विधि format() के समान है, लेकिन यह मैपिंग को तर्क के रूप में उपयोग करता है। स्ट्रिंग्स को फ़ॉर्मेट करने और संयोजित करने और उनमें वेरिएबल डालने के और भी तरीके हैं। आप बाद के अध्यायों में string मॉड्यूल, io मॉड्यूल के StringIO क्लास, आदि के बारे में भी जानेंगे।
Leave a Comment:
Amit Sinha March 2nd, 2023 at 9:30 PM
😃 😄 😁 😆 😅 😂 😉 😊 😇 😍 😘 😚 😋 😜 😝 😶 😏 😒 😌 😔 😪 😷 😵 😎 😲 😳 😨 😰 😥 😢 😭 😱 😖 😣 😞 😓 😩 😫 😤
Ribhu March 3rd, 2023 at 9:30 PM
🐵 🐒 🐶 🐩 🐺 🐱 🐯 🐅 🐆 🐴 🐎 🐮 🐂 🐃 🐄 🐷 🐖 🐗 🐽 🐏 🐑 🐐 🐪 🐫 🐘 🐭 🐁 🐀 🐹 🐰 🐇
