पायथन में स्ट्रिंग्स की सूची (सरणी) की शर्तों को पूरा करने वाले तत्वों को निकालना और बदलना

एक सूची (सरणी) से एक नई सूची उत्पन्न करने के लिए, जिसके तत्व तार हैं, केवल कुछ शर्तों को पूरा करने वाले तारों के तत्वों को निकालकर, या प्रतिस्थापन, रूपांतरण आदि करके, सूची समझ का उपयोग करें।

सूची की समझ के संक्षिप्त विवरण के बाद, निम्नलिखित सामग्री को नमूना कोड के साथ समझाया गया है।

• एक विशिष्ट स्ट्रिंग शामिल है या नहीं, इस पर आधारित निष्कर्षण (आंशिक मिलान)
• विशिष्ट स्ट्रिंग बदलें
• किसी विशिष्ट स्ट्रिंग से प्रारंभ या प्रारंभ न करके निकालें
• एक विशिष्ट स्ट्रिंग के साथ समाप्त या समाप्त नहीं करके निकालें
• मामले से न्याय और निकाला गया
• अपरकेस और लोअरकेस कनवर्ट करें
• निर्धारित करता है कि वर्णमाला या संख्यात्मक वर्णों का उपयोग किया जाता है और उन्हें निकालता है
• एकाधिक शर्तें
• (कंप्यूटर) रेगुलर एक्सप्रेशन

ध्यान दें कि सूचियां विभिन्न प्रकार के डेटा को स्टोर कर सकती हैं और सरणियों से बिल्कुल अलग हैं। यदि आप उन प्रक्रियाओं में सरणियों को संभालना चाहते हैं जिनके लिए स्मृति आकार और स्मृति पते या बड़े डेटा की संख्यात्मक प्रसंस्करण की आवश्यकता होती है, तो सरणी (मानक पुस्तकालय) या NumPy का उपयोग करें।

सूची समावेशन संकेतन

सूची से एक नई सूची बनाते समय, लूप की तुलना में सूची की समझ को लिखना आसान होता है।

• संबंधित:पायथन सूची समझ का उपयोग कैसे करें

[expression for any variable name in iterable object if conditional expression]

यदि तत्व को केवल सशर्त अभिव्यक्ति द्वारा चुना जाना है, तो इसे अभिव्यक्ति द्वारा संसाधित नहीं किया जाता है, इसलिए यह निम्न रूप लेता है

[variable name for variable name in original list if conditional expression]

यदि सशर्त अभिव्यक्ति को सशर्त अभिव्यक्ति में नहीं बनाया जाता है, तो यह एक निषेध बन जाता है, और जो तत्व सशर्त अभिव्यक्ति को संतुष्ट नहीं करते हैं उन्हें निकाला जा सकता है।

एक विशिष्ट स्ट्रिंग शामिल है (आंशिक मिलान) \ इसमें शामिल नहीं है:in

“मूल स्ट्रिंग में विशिष्ट स्ट्रिंग” में, सही है यदि मूल स्ट्रिंग में विशिष्ट स्ट्रिंग है। यह एक सशर्त अभिव्यक्ति है।

in का निषेध in in के साथ किया जाता है।

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']

l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']

विशिष्ट स्ट्रिंग बदलें

यदि आप सूची तत्वों की एक स्ट्रिंग को बदलना चाहते हैं, तो सूची बोध संकेतन में प्रत्येक तत्व के लिए स्ट्रिंग विधि प्रतिस्थापन () का उपयोग करें।

यदि प्रतिस्थापित करने के लिए कोई स्ट्रिंग नहीं है, तो सशर्त अभिव्यक्ति में तत्व का चयन करने की कोई आवश्यकता नहीं है क्योंकि इसे प्रतिस्थापित () लागू करने से नहीं बदला जाएगा।

l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']

यदि आप एक संपूर्ण तत्व को बदलना चाहते हैं जिसमें एक विशिष्ट स्ट्रिंग है, तो इसे इन के साथ निकालें और इसे टर्नरी ऑपरेटर के साथ संसाधित करें। टर्नरी ऑपरेटर निम्नलिखित रूप में लिखा गया है।
True Value if Conditional Expression else False Value

यह ठीक है अगर सूची समझ नोटेशन का अभिव्यक्ति हिस्सा एक टर्नरी ऑपरेटर है।

l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']

निम्नलिखित कोष्ठकों में संलग्न परिणामों का सारांश है। यदि आप कोष्ठक का उपयोग करने के अभ्यस्त नहीं हैं, तो इसे समझना और गलतियों से बचना आसान हो सकता है। व्याकरण की दृष्टि से, कोष्ठक लिखने पर भी कोई समस्या नहीं है।

[('ZZZ' if ('XXX' in s) else s) for s in l]

एक शर्त के रूप में का उपयोग सूची समझ संकेतन के साथ भ्रमित कर रहा है, लेकिन यह मुश्किल नहीं है यदि आप सूची समझ संकेतन और टर्नरी ऑपरेटरों के वाक्यात्मक रूप से अवगत हैं।

एक विशिष्ट स्ट्रिंग से शुरू होता है \ शुरू नहीं होता है:startswith()

यदि स्ट्रिंग तर्क में निर्दिष्ट स्ट्रिंग से शुरू होती है, तो स्ट्रिंग विधि startwith () सही हो जाती है।

l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']

l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']

एक विशिष्ट वर्ण स्ट्रिंग के साथ समाप्त होता है \ not end:endswith()

यदि स्ट्रिंग तर्क में निर्दिष्ट स्ट्रिंग के साथ समाप्त होती है, तो स्ट्रिंग विधि समाप्त होती है () सही होती है।

l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']

l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']

मामले से न्याय और निकाला गया

स्ट्रिंग विधियों isupper (), islower () का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि कोई स्ट्रिंग सभी ऊपरी या सभी निचले मामले में है या नहीं।

l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']

अपरकेस और लोअरकेस कनवर्ट करें

यदि आप सभी वर्णों को अपर या लोअर केस में बदलना चाहते हैं, तो स्ट्रिंग विधियों का उपयोग करें ऊपरी () और निचला ()। अन्य विधियों में कैपिटलाइज़ (), जो केवल पहले अक्षर को कैपिटलाइज़ करता है, और स्वैपकेस (), जो अपर और लोअर केस लेटर्स को स्वैप करता है।

जैसा कि ऊपर दिए गए प्रतिस्थापन उदाहरण में, टर्नरी ऑपरेटर का उपयोग करें यदि आप केवल उन तत्वों को संसाधित करना चाहते हैं जो शर्त को पूरा करते हैं।

l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']

l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']

निर्धारित करता है कि वर्णमाला या संख्यात्मक वर्णों का उपयोग किया जाता है और उन्हें निकालता है

स्ट्रिंग विधियों isalpha() और isnumeric() का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि एक स्ट्रिंग सभी वर्णमाला, संख्यात्मक, आदि है या नहीं।

l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']

l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']

एकाधिक शर्तें

सूची की समझ का सशर्त अभिव्यक्ति हिस्सा कई शर्तें हो सकता है। नकारात्मक “नहीं” शर्तों का भी उपयोग किया जा सकता है।

तीन या अधिक सशर्त अभिव्यक्तियों का उपयोग करते समय, प्रत्येक समूह को कोष्ठक () में संलग्न करना सुरक्षित होता है क्योंकि परिणाम क्रम के आधार पर अलग-अलग होंगे।

l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']

l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']

(कंप्यूटर) रेगुलर एक्सप्रेशन

नियमित अभिव्यक्ति अत्यधिक लचीली प्रसंस्करण की अनुमति देती है।

मैच ऑब्जेक्ट re.match() द्वारा लौटाया जाता है जब यह मिलान करता है तो सशर्त अभिव्यक्ति के साथ मूल्यांकन करते समय हमेशा सत्य होने के लिए निर्धारित किया जाता है। यदि यह मेल नहीं खाता है, तो यह कोई नहीं लौटाता है, जो कि सशर्त अभिव्यक्ति में गलत है। इसलिए, यदि आप केवल रेगुलर एक्सप्रेशन से मेल खाने वाले तत्वों को निकालना चाहते हैं, तो बस पहले की तरह सूची बोध अभिव्यक्ति के सशर्त अभिव्यक्ति भाग में re.match() लागू करें।

import re

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']

re.sub(), जो रेगुलर एक्सप्रेशन के मिलान वाले हिस्से को बदल देता है, भी उपयोगी है। केवल मिलान किए गए तत्वों को निकालने और बदलने के लिए, बस “अगर सशर्त अभिव्यक्ति” जोड़ें।

l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']

l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']