ការស្រង់ចេញ និងជំនួសធាតុដែលបំពេញលក្ខខណ្ឌនៃបញ្ជី (អារេ) នៃខ្សែអក្សរនៅក្នុង Python

ដើម្បីបង្កើតបញ្ជីថ្មីពីបញ្ជី (អារេ) ដែលធាតុរបស់វាជាខ្សែអក្សរ ដោយទាញយកតែធាតុនៃខ្សែអក្សរដែលបំពេញលក្ខខណ្ឌជាក់លាក់ ឬដោយការជំនួស ការបំប្លែង។

បន្ទាប់ពីការពន្យល់ខ្លីៗអំពីបញ្ជីរាយនាម ខ្លឹមសារខាងក្រោមត្រូវបានពន្យល់ដោយប្រើកូដគំរូ។

• ការស្រង់ចេញដោយផ្អែកលើថាតើខ្សែជាក់លាក់មួយត្រូវបានរួមបញ្ចូល (ការផ្គូផ្គងផ្នែក)
• ជំនួសខ្សែជាក់លាក់
• ស្រង់ចេញដោយចាប់ផ្តើម ឬមិនចាប់ផ្តើមដោយខ្សែអក្សរជាក់លាក់មួយ។
• ស្រង់ចេញដោយបញ្ចប់ ឬមិនបញ្ចប់ដោយខ្សែអក្សរជាក់លាក់
• វិនិច្ឆ័យ និង​ស្រង់​តាម​សំណុំរឿង
• បំលែងអក្សរធំ និងអក្សរតូច
• កំណត់ថាតើតួអក្សរអក្ខរក្រម ឬលេខត្រូវបានប្រើ ហើយដកវាចេញ
• លក្ខខណ្ឌជាច្រើន។
• (កុំព្យូទ័រ) កន្សោមធម្មតា។

ចំណាំថាបញ្ជីអាចរក្សាទុកប្រភេទទិន្នន័យផ្សេងៗគ្នា ហើយខុសគ្នាយ៉ាងតឹងរ៉ឹងពីអារេ។ ប្រសិនបើអ្នកចង់គ្រប់គ្រងអារេនៅក្នុងដំណើរការដែលទាមទារទំហំអង្គចងចាំ និងអាសយដ្ឋានអង្គចងចាំ ឬដំណើរការជាលេខនៃទិន្នន័យធំ សូមប្រើអារេ (បណ្ណាល័យស្តង់ដារ) ឬ NumPy ។

បញ្ជីរាយនាមការរួមបញ្ចូល

នៅពេលបង្កើតបញ្ជីថ្មីពីបញ្ជីមួយ ការយល់ក្នុងបញ្ជីគឺងាយស្រួលសរសេរជាងសម្រាប់រង្វិលជុំ។

• ពាក់ព័ន្ធ៖របៀបប្រើការយល់បញ្ជី Python

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

ប្រសិនបើធាតុត្រូវបានជ្រើសរើសដោយកន្សោមតាមលក្ខខណ្ឌ នោះវាមិនត្រូវបានដំណើរការដោយកន្សោមទេ ដូច្នេះវាត្រូវការទម្រង់ដូចខាងក្រោម

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

ប្រសិនបើកន្សោម if conditional ត្រូវបានបង្កើតទៅជា if not conditional expression នោះវាក្លាយជា negation ហើយធាតុដែលមិនពេញចិត្តតាម conditional expression អាចត្រូវបានស្រង់ចេញ។

មានខ្សែអក្សរជាក់លាក់មួយ (ការផ្គូផ្គងផ្នែក) \ មិនមាន: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']

ជំនួសខ្សែជាក់លាក់

ប្រសិនបើ​អ្នក​ចង់​ជំនួស​ខ្សែអក្សរ​នៃ​ធាតុ​បញ្ជី សូម​ប្រើ​វិធី​ខ្សែអក្សរជំនួស () សម្រាប់​ធាតុ​នីមួយៗ​ក្នុង​កំណត់ចំណាំ​នៃ​បញ្ជី។

ប្រសិនបើមិនមានខ្សែអក្សរដែលត្រូវជំនួសទេ មិនចាំបាច់ជ្រើសរើសធាតុនៅក្នុងកន្សោម if conditional ទេព្រោះវានឹងមិនត្រូវបានផ្លាស់ប្តូរដោយអនុវត្តជំនួស()។

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

ប្រសិនបើ​អ្នក​ចង់​ជំនួស​ធាតុ​ទាំងមូល​ដែល​មាន​ខ្សែអក្សរ​ជាក់លាក់ សូម​ស្រង់​វា​ចេញ​ជា​មួយ​និង​ដំណើរការ​វា​ជាមួយ​ប្រតិបត្តិករ ternary ។ ប្រតិបត្តិករ ternary ត្រូវបានសរសេរក្នុងទម្រង់ខាងក្រោម។
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 as a condition មានការភ័ន្តច្រឡំជាមួយ list comprehension notation នៅក្នុង ប៉ុន្តែវាមិនពិបាកទេ ប្រសិនបើអ្នកដឹងពីទម្រង់ syntactic នៃ list comprehension notation និង ternary operators ។

ចាប់ផ្តើមដោយខ្សែអក្សរជាក់លាក់ \ មិនចាប់ផ្តើមទេ។: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()

string method endswith() ត្រឡប់ true ប្រសិនបើ string បញ្ចប់ដោយ string ដែលបានបញ្ជាក់ក្នុង argument។

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() ដែលប្តូរអក្សរធំ និងអក្សរតូច។

ដូចក្នុងឧទាហរណ៍ជំនួសខាងលើ សូមប្រើប្រតិបត្តិករ ternary ប្រសិនបើអ្នកចង់ដំណើរការតែធាតុដែលបំពេញលក្ខខណ្ឌ។

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