निम्नलिखित सामग्री, नमूना कोड के साथ, पायथन में स्ट्रिंग्स (str) की सूचियों (सरणी) और संख्याओं की सूचियों (int, float) को एक दूसरे में बदलने का तरीका बताती है।
- संख्याओं की सूची को स्ट्रिंग्स की सूची में बदलें
- किसी संख्या को दशमलव स्ट्रिंग में बदलें
- संख्यात्मक मानों को बाइनरी, ऑक्टल और हेक्साडेसिमल स्ट्रिंग्स में कनवर्ट करता है
- एक संख्यात्मक मान को घातीय संकेतन में एक स्ट्रिंग में परिवर्तित करता है
- स्ट्रिंग्स की सूची को संख्याओं की सूची में बदलें
- दशमलव स्ट्रिंग को संख्यात्मक में बदलें
- बाइनरी, ऑक्टल और हेक्साडेसिमल स्ट्रिंग्स को संख्याओं में कनवर्ट करता है
- घातीय संकेतन में स्ट्रिंग्स को संख्यात्मक मानों में कनवर्ट करता है
- केवल उन स्ट्रिंग्स को कनवर्ट करें जिन्हें संख्याओं में परिवर्तित किया जा सकता है
सूची से एक नई सूची बनाते समय, लूप की तुलना में सूची की समझ को लिखना आसान होता है। इस आलेख में नमूना कोड सूची समझ का भी उपयोग करता है। सूची समझ के विवरण के लिए, निम्न आलेख देखें।
ध्यान दें कि सूचियां विभिन्न प्रकार के डेटा को स्टोर कर सकती हैं और सरणियों से बिल्कुल अलग हैं। निम्नलिखित मामलों में सरणी (मानक पुस्तकालय) या NumPy का प्रयोग करें।
- मैं उन प्रक्रियाओं को संभालना चाहता हूं जिनके लिए स्मृति आकार और स्मृति पते की आवश्यकता होती है।
- बड़े डेटा सेट आदि के संख्यात्मक प्रसंस्करण के लिए सरणियों को संभालना चाहते हैं।
संख्याओं की सूची को स्ट्रिंग्स की सूची में बदलें
किसी संख्या को दशमलव स्ट्रिंग में बदलें
संख्यात्मक से स्ट्रिंग में कनवर्ट करने के लिए str() का उपयोग करें।
पायथन में, संख्याओं को विभिन्न स्वरूपों में व्यक्त किया जा सकता है, जिसमें घातीय, हेक्साडेसिमल और बाइनरी (हेक्साडेसिमल और बाइनरी नोटेशन) शामिल हैं। str() रूपांतरण परिणाम सामान्य दशमलव संकेतन में एक स्ट्रिंग में होता है।
अंकों की संख्या के आधार पर, घातीय संकेतन स्वचालित रूप से उपयोग किया जा सकता है।
l_n = [-0.5, 0, 1.0, 100, 1.2e-2, 0xff, 0b11]
l_n_str = [str(n) for n in l_n]
print(l_n_str)
# ['-0.5', '0', '1.0', '100', '0.012', '255', '3']
संख्यात्मक मानों को बाइनरी, ऑक्टल और हेक्साडेसिमल स्ट्रिंग्स में कनवर्ट करता है
बाइनरी, ऑक्टल, या हेक्साडेसिमल (बाइनरी नोटेशन, ऑक्टल नोटेशन, या हेक्साडेसिमल नोटेशन) स्ट्रिंग्स में कनवर्ट करने के लिए, निम्नलिखित विधियाँ उपलब्ध हैं।
bin()oct()hex()format()str.format()
प्रारूप () फ़ंक्शन के साथ, शून्य को भरना और अंकों को समायोजित करना संभव है।
l_i = [0, 64, 128, 192, 256]
l_i_hex1 = [hex(i) for i in l_i]
print(l_i_hex1)
# ['0x0', '0x40', '0x80', '0xc0', '0x100']
l_i_hex2 = [format(i, '04x') for i in l_i]
print(l_i_hex2)
# ['0000', '0040', '0080', '00c0', '0100']
l_i_hex3 = [format(i, '#06x') for i in l_i]
print(l_i_hex3)
# ['0x0000', '0x0040', '0x0080', '0x00c0', '0x0100']
एक संख्यात्मक मान को घातीय संकेतन में एक स्ट्रिंग में परिवर्तित करता है
जैसा कि ऊपर उल्लेख किया गया है, कुछ मामले अंकों की संख्या के आधार पर स्वचालित रूप से घातीय संकेतन में हो सकते हैं। हालांकि, हमेशा घातीय संकेतन में एक स्ट्रिंग में कनवर्ट करने के लिए, निम्न में से किसी एक का उपयोग करें
format()str.format()
प्रारूप () फ़ंक्शन और स्ट्रिंग विधि str.format () के बारे में अधिक जानकारी के लिए, निम्न आलेख देखें।
मंटिसा भाग के अंकों की संख्या निर्दिष्ट की जा सकती है। यदि अपरकेस E का उपयोग तर्क के रूप में किया जाता है, तो आउटपुट स्ट्रिंग भी अपरकेस E है।
l_f = [0.0001, 123.456, 123400000]
l_f_e1 = [format(f, 'e') for f in l_f]
print(l_f_e1)
# ['1.000000e-04', '1.234560e+02', '1.234000e+08']
l_f_e2 = [format(f, '.3E') for f in l_f]
print(l_f_e2)
# ['1.000E-04', '1.235E+02', '1.234E+08']
स्ट्रिंग्स की सूची को संख्याओं की सूची में बदलें
दशमलव स्ट्रिंग को संख्यात्मक में बदलें
स्ट्रिंग से संख्या में कनवर्ट करने के लिए int() या float() का उपयोग करें।
int() एक पूर्णांक में रूपांतरण है, और फ्लोट() एक फ़्लोटिंग-पॉइंट संख्या में रूपांतरण है।
फ्लोट () में, छोड़े गए पूर्णांक भाग वाले तार पूर्णांक भाग के लिए 0 से पूरित होते हैं।
l_si = ['-10', '0', '100']
l_si_i = [int(s) for s in l_si]
print(l_si_i)
# [-10, 0, 100]
l_sf = ['.123', '1.23', '123']
l_sf_f = [float(s) for s in l_sf]
print(l_sf_f)
# [0.123, 1.23, 123.0]
बाइनरी, ऑक्टल और हेक्साडेसिमल स्ट्रिंग्स को संख्याओं में कनवर्ट करता है
इंट () का दूसरा तर्क एक मूलांक हो सकता है: 2 बाइनरी के लिए, 8 ऑक्टल के लिए, और 16 हेक्साडेसिमल के लिए, एक स्ट्रिंग को एक संख्या में परिवर्तित करना।
यदि 0 निर्दिष्ट है, तो निम्न में से प्रत्येक उपसर्ग स्ट्रिंग को एक पूर्णांक में बदल दिया जाता है।
0b- बाइनरी अंक
0o- अष्टभुजाकार
0x- हेक्साडेसिमल
l_sb = ['0011', '0101', '1111']
l_sb_i = [int(s, 2) for s in l_sb]
print(l_sb_i)
# [3, 5, 15]
l_sbox = ['100', '0b100', '0o77', '0xff']
l_sbox_i = [int(s, 0) for s in l_sbox]
print(l_sbox_i)
# [100, 4, 63, 255]
घातीय संकेतन में स्ट्रिंग्स को संख्यात्मक मानों में कनवर्ट करता है
घातीय संकेतन में स्ट्रिंग्स को विशेष विनिर्देश की आवश्यकता के बिना सीधे फ्लोट () के साथ परिवर्तित किया जा सकता है।
l_se = ['1.23e3', '0.123e-1', '123']
l_se_f = [float(s) for s in l_se]
print(l_se_f)
# [1230.0, 0.0123, 123.0]
केवल उन स्ट्रिंग्स को कनवर्ट करें जिन्हें संख्याओं में परिवर्तित किया जा सकता है
एक स्ट्रिंग को पास करना जिसे किसी संख्या में int() या float() में परिवर्तित नहीं किया जा सकता है, जिसके परिणामस्वरूप ValueError होगा।
यदि कोई नया फ़ंक्शन परिभाषित किया गया है जो त्रुटि पर झूठा रिटर्न देता है, तो केवल उन तत्वों को परिवर्तित किया जा सकता है जिन्हें परिवर्तित किया जा सकता है और सूची के तत्व बन सकते हैं।
def is_int(s):
try:
int(s)
except ValueError:
return False
else:
return True
def is_float(s):
try:
float(s)
except ValueError:
return False
else:
return True
l_multi = ['-100', '100', '1.23', '1.23e2', 'one']
l_multi_i = [int(s) for s in l_multi if is_int(s)]
print(l_multi_i)
# [-100, 100]
l_multi_f = [float(s) for s in l_multi if is_float(s)]
print(l_multi_f)
# [-100.0, 100.0, 1.23, 123.0]
