पाइथनमा स्ट्रिङहरूको सूची (एरे) को सर्तहरू पूरा गर्ने तत्वहरू निकाल्दै र प्रतिस्थापन गर्दै

केही सर्तहरू पूरा गर्ने स्ट्रिङका तत्वहरू मात्र निकालेर, वा प्रतिस्थापन, रूपान्तरण, इत्यादि प्रदर्शन गरेर, स्ट्रिङहरू भएका तत्वहरू सूची (एरे) बाट नयाँ सूची उत्पन्न गर्न, सूची बुझाइ प्रयोग गर्नुहोस्।

सूची बुझाइको संक्षिप्त व्याख्या पछि, निम्न सामग्रीहरूलाई नमूना कोडको साथ व्याख्या गरिएको छ।

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

नोट गर्नुहोस् कि सूचीहरूले विभिन्न प्रकारका डेटा भण्डारण गर्न सक्छ र एरेहरू भन्दा कडा रूपमा फरक छन्। यदि तपाइँ प्रक्रियाहरूमा एरेहरू ह्यान्डल गर्न चाहनुहुन्छ जुन मेमोरी साइज र मेमोरी ठेगानाहरू वा ठूलो डाटाको संख्यात्मक प्रशोधन आवश्यक पर्दछ, एरे (मानक पुस्तकालय) वा NumPy प्रयोग गर्नुहोस्।

सूची समावेश नोटेशन

सूचीबाट नयाँ सूची उत्पन्न गर्दा, लूपहरूको लागि भन्दा लेख्नको लागि सूची बुझाइ सजिलो हुन्छ।

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

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

यदि तत्व केवल सशर्त अभिव्यक्ति द्वारा चयन गर्न को लागी हो, यो एक अभिव्यक्ति द्वारा प्रशोधन गरिएको छैन, त्यसैले यो निम्न फारम लिन्छ

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

यदि सशर्त अभिव्यक्तिलाई यदि सशर्त अभिव्यक्तिमा बनाइन्छ भने, यो एक निषेध बन्छ, र सशर्त अभिव्यक्तिलाई पूरा नगर्ने तत्वहरू निकाल्न सकिन्छ।

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

“मूल स्ट्रिङमा विशिष्ट स्ट्रिङ” मा, यदि मूल स्ट्रिङमा विशिष्ट स्ट्रिङ समावेश छ भने True फर्काउँछ। यो सशर्त अभिव्यक्ति हो।

in को नकारना in not बाट गरिन्छ।

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

विशिष्ट स्ट्रिङ बदल्नुहोस्

यदि तपाइँ सूची तत्वहरूको स्ट्रिङ प्रतिस्थापन गर्न चाहनुहुन्छ भने, स्ट्रिङ विधि प्रयोग गर्नुहोस् बदल्नुहोस्() सूचीको बुझाइ सङ्केतमा प्रत्येक तत्वको लागि।

यदि प्रतिस्थापन गर्न कुनै स्ट्रिङ छैन भने, यदि सशर्त अभिव्यक्तिमा तत्व चयन गर्न आवश्यक छैन ’cause यसलाई बदल्न () लागू गरेर परिवर्तन हुनेछैन।

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

यो ठीक छ यदि सूची बुझाइ सङ्केतको अभिव्यक्ति भाग एक ternary अपरेटर हो।

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]

सर्तको रूपमा in को प्रयोगले सूचीको बुझाइ सङ्केतसँग भ्रममा पार्छ, तर यदि तपाइँ सूची बुझाइ सङ्केत र टर्नरी अपरेटरहरूको सिन्ट्याक्टिक रूप ’bout सचेत हुनुहुन्छ भने यो गाह्रो छैन।

विशिष्ट स्ट्रिङबाट सुरु हुन्छ \ सुरु हुँदैन:startswith()

स्ट्रिङ विधि startswith() सही फर्काउँछ यदि स्ट्रिङ तर्कमा निर्दिष्ट गरिएको स्ट्रिङबाट सुरु हुन्छ।

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

निश्चित क्यारेक्टर स्ट्रिङसँग समाप्त हुन्छ \ अन्त्य हुँदैन:endswith()

स्ट्रिङ विधि 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']

अपरकेस र लोअरकेसमा रूपान्तरण गर्नुहोस्

यदि तपाइँ सबै क्यारेक्टरहरूलाई अपर वा लोअर केसमा रूपान्तरण गर्न चाहनुहुन्छ भने, स्ट्रिङ विधिहरू upper() र Lower() प्रयोग गर्नुहोस्। अन्य विधिहरूमा ठूला र सानो अक्षरहरू स्वैप गर्ने क्यापिटलाइज (), जसले पहिलो अक्षरलाई मात्रै ठूलो बनाउँछ र swapcase(), समावेश गर्दछ।

माथिको प्रतिस्थापन उदाहरणमा जस्तै, यदि तपाइँ सर्त पूरा गर्ने तत्वहरू मात्र प्रशोधन गर्न चाहनुहुन्छ भने, टर्नरी अपरेटर प्रयोग गर्नुहोस्।

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

धेरै सर्तहरू

सूची समझको सशर्त अभिव्यक्ति भाग धेरै सर्तहरू हुन सक्छ। नकारात्मक “होइन” सर्तहरू पनि प्रयोग गर्न सकिन्छ।

तीन वा बढी सशर्त अभिव्यक्तिहरू प्रयोग गर्दा, प्रत्येक समूहलाई कोष्ठक () मा संलग्न गर्न सुरक्षित छ ’cause परिणाम क्रम अनुसार फरक हुनेछ।

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