பைத்தானில் உள்ள சரங்களின் பட்டியலின் (வரிசை) நிபந்தனைகளை பூர்த்தி செய்யும் கூறுகளை பிரித்தெடுத்தல் மற்றும் மாற்றுதல்

ஒரு பட்டியலிலிருந்து (வரிசை) புதிய பட்டியலை உருவாக்க, அதன் கூறுகள் சரங்களாக இருக்கும், சில நிபந்தனைகளை பூர்த்தி செய்யும் சரங்களின் கூறுகளை மட்டும் பிரித்தெடுப்பதன் மூலம் அல்லது மாற்றீடுகள், மாற்றங்கள் போன்றவற்றைச் செய்வதன் மூலம், பட்டியல் புரிதல்களைப் பயன்படுத்தவும்.

பட்டியல் புரிதல்களின் சுருக்கமான விளக்கத்திற்குப் பிறகு, பின்வரும் உள்ளடக்கங்கள் மாதிரிக் குறியீட்டுடன் விளக்கப்பட்டுள்ளன.

• குறிப்பிட்ட சரம் சேர்க்கப்பட்டுள்ளதா இல்லையா என்பதன் அடிப்படையில் பிரித்தெடுத்தல் (பகுதி பொருத்தம்)
• குறிப்பிட்ட சரத்தை மாற்றவும்
• ஒரு குறிப்பிட்ட சரத்துடன் தொடங்குவதன் மூலம் அல்லது தொடங்காமல் பிரித்தெடுக்கவும்
• ஒரு குறிப்பிட்ட சரத்துடன் முடிவடைவதன் மூலம் அல்லது முடிவடையாமல் பிரித்தெடுக்கவும்
• வழக்கு மூலம் தீர்ப்பளிக்கப்பட்டு பிரித்தெடுக்கப்பட்டது
• பெரிய எழுத்து மற்றும் சிறிய எழுத்துக்களை மாற்றவும்
• அகரவரிசை அல்லது எண் எழுத்துக்கள் பயன்படுத்தப்படுகிறதா என்பதைத் தீர்மானித்து அவற்றைப் பிரித்தெடுக்கிறது
• பல நிபந்தனைகள்
• (கணினி) வழக்கமான வெளிப்பாடு

பட்டியல்கள் வெவ்வேறு வகையான தரவைச் சேமிக்கலாம் மற்றும் வரிசைகளிலிருந்து கண்டிப்பாக வேறுபட்டவை என்பதை நினைவில் கொள்ளவும். நினைவக அளவு மற்றும் நினைவக முகவரிகள் அல்லது பெரிய தரவுகளின் எண்ணியல் செயலாக்கம் தேவைப்படும் செயல்முறைகளில் அணிவரிசைகளைக் கையாள விரும்பினால், வரிசை (நிலையான நூலகம்) அல்லது NumPy ஐப் பயன்படுத்தவும்.

பட்டியல் சேர்த்தல் குறியீடு

பட்டியலிலிருந்து புதிய பட்டியலை உருவாக்கும் போது, ​​லூப்களை விட பட்டியல் புரிதல்கள் எழுதுவது எளிது.

• தொடர்புடையது:பைதான் பட்டியல் புரிதல்களை எவ்வாறு பயன்படுத்துவது

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

உறுப்பு ஒரு நிபந்தனை வெளிப்பாடு மூலம் மட்டுமே தேர்ந்தெடுக்கப்பட வேண்டும் என்றால், அது ஒரு வெளிப்பாடு மூலம் செயலாக்கப்படாது, எனவே அது பின்வரும் படிவத்தை எடுக்கும்

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

if நிபந்தனை வெளிப்பாடு நிபந்தனையற்ற வெளிப்பாடாக மாற்றப்பட்டால், அது ஒரு மறுப்பாக மாறும், மேலும் நிபந்தனை வெளிப்பாட்டைத் திருப்திப்படுத்தாத கூறுகளைப் பிரித்தெடுக்க முடியும்.

ஒரு குறிப்பிட்ட சரம் உள்ளது (பகுதி பொருத்தம்) \ இல்லை:in

“அசல் சரத்தில் குறிப்பிட்ட சரம்” என்பதில், அசல் சரத்தில் குறிப்பிட்ட சரம் இருந்தால் True என வழங்கும். இது ஒரு நிபந்தனை வெளிப்பாடு.

in இன் மறுப்பு, not 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']

குறிப்பிட்ட சரத்தை மாற்றவும்

பட்டியல் உறுப்புகளின் சரத்தை நீங்கள் மாற்ற விரும்பினால், பட்டியல் புரிதல் குறியீட்டில் உள்ள ஒவ்வொரு உறுப்புக்கும் string method replace()ஐப் பயன்படுத்தவும்.

மாற்றுவதற்கு எந்த சரமும் இல்லை என்றால், if நிபந்தனை வெளிப்பாட்டில் உள்ள உறுப்பைத் தேர்ந்தெடுக்க வேண்டிய அவசியமில்லை, ஏனெனில் இது மாற்று()ஐப் பயன்படுத்துவதன் மூலம் மாற்றப்படாது.

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()

வாதத்தில் குறிப்பிடப்பட்ட சரத்துடன் சரம் தொடங்கினால், சரம் முறையானது () உண்மையாகத் தொடங்குகிறது.

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

பெரிய எழுத்து மற்றும் சிறிய எழுத்துக்களை மாற்றவும்

நீங்கள் எல்லா எழுத்துக்களையும் மேல் அல்லது சிறிய எழுத்துக்கு மாற்ற விரும்பினால், மேல்() மற்றும் கீழ்() என்ற சரம் முறைகளைப் பயன்படுத்தவும். மற்ற முறைகளில், முதல் எழுத்தை மட்டும் பெரிய எழுத்தாக மாற்றும் பெரிய எழுத்து(), மற்றும் ஸ்வாப்கேஸ்(), இது பெரிய மற்றும் சிறிய எழுத்துக்களை மாற்றும்.

மேலே உள்ள மாற்று எடுத்துக்காட்டில் உள்ளதைப் போல, நிபந்தனையைப் பூர்த்தி செய்யும் கூறுகளை மட்டுமே செயல்படுத்த விரும்பினால், மும்மை ஆபரேட்டரைப் பயன்படுத்தவும்.

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