सूची (अॅरे) मधून नवीन सूची तयार करण्यासाठी ज्याचे घटक स्ट्रिंग आहेत, केवळ विशिष्ट अटी पूर्ण करणार्‍या स्ट्रिंगचे घटक काढून किंवा प्रतिस्थापन, रूपांतरणे इत्यादी करून, सूची आकलन वापरा.
सूचीच्या आकलनाच्या थोडक्यात स्पष्टीकरणानंतर, खालील सामग्री नमुना कोडसह स्पष्ट केली आहे.
- विशिष्ट स्ट्रिंग समाविष्ट आहे की नाही यावर आधारित निष्कर्षण (आंशिक जुळणी)
- विशिष्ट स्ट्रिंग पुनर्स्थित करा
- विशिष्ट स्ट्रिंगसह प्रारंभ करून किंवा न सुरू करून काढा
- विशिष्ट स्ट्रिंगसह समाप्त करून किंवा न संपवून काढा
- केस द्वारे न्याय आणि काढले
- अपरकेस आणि लोअरकेसमध्ये रूपांतरित करा
- वर्णमाला किंवा अंकीय वर्ण वापरले आहेत की नाही हे निर्धारित करते आणि ते काढते
- अनेक अटी
- (संगणक) नियमित अभिव्यक्ती
लक्षात ठेवा की याद्या विविध प्रकारचे डेटा संचयित करू शकतात आणि अॅरेपेक्षा काटेकोरपणे भिन्न आहेत. मेमरी आकार आणि मेमरी पत्ते किंवा मोठ्या डेटाची संख्यात्मक प्रक्रिया आवश्यक असलेल्या प्रक्रियांमध्ये तुम्हाला अॅरे हाताळायचे असल्यास, अॅरे (मानक लायब्ररी) किंवा NumPy वापरा.
- सूची समावेश नोटेशन
- विशिष्ट स्ट्रिंग समाविष्टीत आहे (आंशिक जुळणी) \ समाविष्ट नाही:in
- विशिष्ट स्ट्रिंग पुनर्स्थित करा
- विशिष्ट स्ट्रिंगने सुरू होते \ सुरू होत नाही:startswith()
- विशिष्ट वर्ण स्ट्रिंगसह समाप्त होतो \ समाप्त नाही:endswith()
- केस द्वारे न्याय आणि काढले
- अपरकेस आणि लोअरकेसमध्ये रूपांतरित करा
- वर्णमाला किंवा अंकीय वर्ण वापरले आहेत की नाही हे निर्धारित करते आणि ते काढते
- अनेक अटी
- (संगणक) नियमित अभिव्यक्ती
सूची समावेश नोटेशन
सूचीमधून नवीन सूची तयार करताना, लूपपेक्षा यादीचे आकलन लिहिणे सोपे असते.
- संबंधित:पायथन सूची आकलन कसे वापरावे
[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 चे नकार नॉट इन सह केले जाते.
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]
in चा कंडिशन म्हणून वापर करण्‍यामुळे मधील सूची आकलन नोटेशन गोंधळात टाकणारे आहे, परंतु जर तुम्हाला सूची आकलन नोटेशन आणि टर्नरी ऑपरेटर्सच्‍या सिंटॅक्टिक फॉर्मची माहिती असेल तर ते अवघड नाही.
विशिष्ट स्ट्रिंगने सुरू होते \ सुरू होत नाही: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']
अपरकेस आणि लोअरकेसमध्ये रूपांतरित करा
तुम्हाला सर्व अक्षरे अप्पर किंवा लोअर केसमध्ये रूपांतरित करायची असल्यास, अप्पर() आणि लोअर() या स्ट्रिंग पद्धती वापरा. इतर पद्धतींमध्ये कॅपिटलाइझ(), जे फक्त पहिले अक्षर कॅपिटल करते आणि 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']
अनेक अटी
सूची आकलनाचा सशर्त अभिव्यक्ती भाग अनेक अटी असू शकतो. नकारात्मक “नाही” परिस्थिती देखील वापरली जाऊ शकते.
तीन किंवा अधिक सशर्त अभिव्यक्ती वापरताना, प्रत्येक गटाला कंस () मध्ये बंद करणे अधिक सुरक्षित आहे कारण निकाल क्रमानुसार बदलू शकतो.
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() द्वारे परत केलेला मॅच ऑब्जेक्ट सशर्त अभिव्यक्तीसह मूल्यमापन केल्यावर नेहमी सत्य असल्याचे निर्धारित केले जाते. जर ते जुळत नसेल, तर ते None परत करते, जे सशर्त अभिव्यक्तीमध्ये असत्य आहे. त्यामुळे, जर तुम्हाला रेग्युलर एक्स्प्रेशनशी जुळणारे घटक काढायचे असतील, तर आधीप्रमाणेच यादी आकलन अभिव्यक्तीच्या कंडिशनल एक्सप्रेशन भागावर 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']
