លុប និងស្រង់ធាតុស្ទួនចេញពីបញ្ជី (អារេ) នៅក្នុង Python

ផ្នែកនេះពិពណ៌នាអំពីរបៀបបង្កើតបញ្ជីថ្មីនៅក្នុង Python ដោយលុប ឬស្រង់ធាតុស្ទួនចេញពីបញ្ជី (អារេ)។

ព័ត៌មានលម្អិតខាងក្រោមត្រូវបានពិពណ៌នានៅទីនេះ។

• យកធាតុស្ទួនចេញ ហើយបង្កើតបញ្ជីថ្មី។
  • កុំរក្សាលំដាប់នៃការចុះបញ្ជីដើម:set()
  • រក្សាលំដាប់នៃការចុះបញ្ជីដើម:dict.fromkeys(),sorted()
  • អារេពីរវិមាត្រ (បញ្ជីរាយនាម)
• ស្រង់ធាតុស្ទួន និងបង្កើតបញ្ជីថ្មី។
  • កុំរក្សាលំដាប់នៃការចុះបញ្ជីដើម
  • រក្សាលំដាប់នៃការចុះបញ្ជីដើម
  • អារេពីរវិមាត្រ (បញ្ជីរាយនាម)

គំនិតដូចគ្នាអាចត្រូវបានអនុវត្តចំពោះ tuples ជំនួសឱ្យបញ្ជី។

សូមមើលអត្ថបទខាងក្រោមសម្រាប់

• ប្រសិនបើអ្នកចង់កំណត់ថាតើបញ្ជី ឬ tuple មានធាតុស្ទួនឬអត់
• ប្រសិនបើអ្នកចង់ស្រង់ធាតុដែលជារឿងធម្មតា ឬមិនទូទៅក្នុងចំណោមបញ្ជីច្រើន ជំនួសឱ្យការចុះបញ្ជីតែមួយ

• ពាក់ព័ន្ធ៖ការកំណត់ថាតើបញ្ជី (អារេ) មានធាតុស្ទួននៅក្នុង Python

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

យកធាតុស្ទួនចេញ ហើយបង្កើតបញ្ជីថ្មី។

កុំរក្សាលំដាប់នៃការចុះបញ្ជីដើម:set()

ប្រសិនបើមិនចាំបាច់រក្សាលំដាប់នៃបញ្ជីដើមទេ សូមប្រើ set() ដែលបង្កើត set type set ។

ប្រភេទសំណុំគឺជាប្រភេទទិន្នន័យដែលមិនមានធាតុស្ទួន។ នៅពេលដែលបញ្ជី ឬប្រភេទទិន្នន័យផ្សេងទៀតត្រូវបានបញ្ជូនទៅ set() តម្លៃស្ទួនត្រូវបានមិនអើពើ ហើយវត្ថុនៃសំណុំប្រភេទត្រូវបានបញ្ជូនមកវិញ ដែលមានតែតម្លៃតែមួយគត់គឺជាធាតុ។

ប្រសិនបើអ្នកចង់ធ្វើឱ្យវាក្លាយជា tuple សូមប្រើ tuple()។

l = [3, 3, 2, 1, 5, 1, 4, 2, 3]

print(set(l))
# {1, 2, 3, 4, 5}

print(list(set(l)))
# [1, 2, 3, 4, 5]

ជា​ការ​ពិត​ណាស់​វា​ក៏​អាច​ត្រូវ​បាន​ទុក​ជា​ការ​កំណត់​។ សូមមើលអត្ថបទខាងក្រោមសម្រាប់ព័ត៌មានបន្ថែមអំពីប្រភេទសំណុំ។

• ពាក់ព័ន្ធ៖កំណត់ប្រតិបត្តិការ (ឧ. កំណត់សំណុំសហជីព សំណុំផលិតផល និងសំណុំរង) ជាមួយនឹងប្រភេទសំណុំរបស់ Python

រក្សាលំដាប់នៃការចុះបញ្ជីដើម:dict.fromkeys(),sorted()

បើអ្នកចង់រក្សាលំដាប់នៃបញ្ជីដើម សូមប្រើ class method fromkeys() នៃប្រភេទវចនានុក្រម ឬមុខងារដែលភ្ជាប់មកជាមួយ sorted()។

dict.fromkeys() បង្កើត​វចនានុក្រម​ថ្មី​មួយ​ដែល​កូនសោ​របស់​វា​គឺ​ជា​បញ្ជី, tuples ជាដើម​ដែល​បាន​បញ្ជាក់​ក្នុង​អាគុយម៉ង់។ ប្រសិនបើអាគុយម៉ង់ទីពីរត្រូវបានលុបចោល តម្លៃគឺគ្មានទេ។

• classmethod fromkeys(iterable[, value]) — Built-in Types — Python 3.10.4 Documentation

ដោយសារគ្រាប់ចុចវចនានុក្រមមិនមានធាតុស្ទួន តម្លៃស្ទួនត្រូវបានមិនអើពើដូចនៅក្នុង set()។ លើសពីនេះ វត្ថុវចនានុក្រមមួយអាចត្រូវបានឆ្លងកាត់ជាអាគុយម៉ង់មួយទៅកាន់បញ្ជី () ដើម្បីទទួលបានបញ្ជីដែលធាតុរបស់វាជាសោវចនានុក្រម។

print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}

print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]

វាត្រូវបានធានាចាប់តាំងពី Python 3.7 (CPython គឺ 3.6) ថា dict.fromkeys() រក្សាលំដាប់នៃលំដាប់អាគុយម៉ង់។ កំណែមុនប្រើមុខងារដែលភ្ជាប់មកជាមួយ sorted() ដូចខាងក្រោម។

បញ្ជាក់បញ្ជីវិធីសាស្ត្រ tuple index() សម្រាប់ argument key នៃការតម្រៀប ដែលត្រឡប់បញ្ជីធាតុដែលបានតម្រៀប។

index() គឺជាវិធីសាស្រ្តដែលត្រឡប់លិបិក្រមនៃតម្លៃ (ចំនួននៃធាតុនៅក្នុងបញ្ជី) ដែលអាចត្រូវបានបញ្ជាក់ជាគន្លឹះនៃតម្រៀប() ដើម្បីតម្រៀបបញ្ជីដោយផ្អែកលើលំដាប់នៃបញ្ជីដើម។ គ្រាប់ចុចអាគុយម៉ង់ត្រូវបានបញ្ជាក់ជាវត្ថុដែលអាចហៅបាន (callable) ដូច្នេះកុំសរសេរ () ។

print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]

អារេពីរវិមាត្រ (បញ្ជីរាយនាម)

សម្រាប់អារេពីរវិមាត្រ (បញ្ជីបញ្ជី) វិធីសាស្ត្រដោយប្រើ set() ឬ dict.fromkeys() បណ្តាលឱ្យ TypeError ។

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'

# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'

នេះ​ដោយសារ​តែ​វត្ថុ​ដែល​មិន​អាច​ប្រើ​ប្រាស់​បាន​ដូច​ជា​បញ្ជី​មិន​អាច​ជា​ធាតុ​នៃ​ប្រភេទ​សំណុំ​ឬ​គ្រាប់ចុច​នៃ​ពាក្យ​បញ្ជា​ប្រភេទ។

កំណត់មុខងារខាងក្រោម លំដាប់នៃបញ្ជីដើមត្រូវបានរក្សាទុក និងដំណើរការសម្រាប់បញ្ជីមួយវិមាត្រ និង tuples ។

• python – How do you remove duplicates from a list whilst preserving order? – Stack Overflow

def get_unique_list(seq):
    seen = []
    return [x for x in seq if x not in seen and not seen.append(x)]

print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]

print(get_unique_list(l))
# [3, 2, 1, 5, 4]

កំណត់ចំណាំក្នុងបញ្ជីត្រូវបានប្រើ។

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

នៅទីនេះយើងប្រើដូចខាងក្រោម

• ប្រសិនបើ X នៅក្នុង “X និង Y” គឺមិនពិតនៅក្នុងការវាយតម្លៃសៀគ្វីខ្លីរបស់ប្រតិបត្តិករ នោះ Y មិនត្រូវបានវាយតម្លៃទេ (មិនត្រូវបានអនុវត្ត) ។
• វិធីសាស្ត្រ append() ត្រឡប់ គ្មាន។

ប្រសិនបើធាតុនៃបញ្ជីដើម seq មិនមាននៅក្នុងការមើលឃើញនោះ និងបន្ទាប់ត្រូវបានវាយតម្លៃ។
see.append(x) ត្រូវបានប្រតិបត្តិ ហើយធាតុត្រូវបានបន្ថែមទៅមើលឃើញ។
ដោយសារតែ append() method ត្រឡប់ None ហើយ None គឺ False, not saw.append(x) វាយតម្លៃទៅ True។
កន្សោម​តាម​លក្ខខណ្ឌ​ក្នុង​បញ្ជី​កំណត់​ការ​យល់​ដឹង​ក្លាយ​ជា​ពិត ហើយ​ត្រូវ​បាន​បន្ថែម​ជា​ធាតុ​នៃ​បញ្ជី​ដែល​បាន​បង្កើត​ចុងក្រោយ។

ប្រសិនបើធាតុនៃ seq បញ្ជីដើមមានវត្តមាននៅក្នុងការមើលឃើញ នោះ x ដែលមិននៅក្នុងការមើលឃើញគឺជា False ហើយកន្សោមតាមលក្ខខណ្ឌសម្រាប់កន្សោមការយល់បញ្ជីគឺ False ។
ដូច្នេះ ពួកវាមិនត្រូវបានបន្ថែមជាធាតុនៃបញ្ជីដែលបានបង្កើតចុងក្រោយនោះទេ។

វិធីសាស្ត្រមួយទៀតគឺកំណត់អ័ក្សអាគុយម៉ង់ក្នុងមុខងាររបស់ NumPy np.unique() ទោះបីជាលទ្ធផលនឹងត្រូវបានតម្រៀបក៏ដោយ។

ស្រង់ធាតុស្ទួន និងបង្កើតបញ្ជីថ្មី។

កុំរក្សាលំដាប់នៃការចុះបញ្ជីដើម

ដើម្បីទាញយកតែធាតុស្ទួនពីបញ្ជីដើម សូមប្រើ collections.Counter()។
ត្រឡប់​បណ្តុំ​មួយ​។ Counter (ថ្នាក់រង​នៃវចនានុក្រម) ដែលមាន​ធាតុ​ជា​សោ និង​ចំនួន​ធាតុ​ជា​តម្លៃ។

• ពាក់ព័ន្ធ៖ការរាប់ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗនៅក្នុងបញ្ជីជាមួយ Counter របស់ Python

import collections

l = [3, 3, 2, 1, 5, 1, 4, 2, 3]

print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})

ដោយសារវាជាប្រភេទរងនៃវចនានុក្រម ធាតុ() អាចត្រូវបានប្រើដើម្បីទាញយកសោ និងតម្លៃ។ វាគ្រប់គ្រាន់ក្នុងការទាញយកសោដែលមានលេខពីរ ឬច្រើនជាងនេះ។

• ពាក់ព័ន្ធ៖វចនានុក្រម Python (dict) សម្រាប់ដំណើរការរង្វិលជុំ (គ្រាប់ចុច តម្លៃ ធាតុ)

print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]

រក្សាលំដាប់នៃការចុះបញ្ជីដើម

ដូចដែលបានបង្ហាញក្នុងឧទាហរណ៍ខាងលើ ចាប់តាំងពី Python 3.7 កូនសោនៃ collections.Counter រក្សាលំដាប់នៃបញ្ជីដើម ហើយដូច្នេះនៅលើ។

នៅក្នុងកំណែមុន ការតម្រៀបជាមួយតម្រៀប () គឺគ្រប់គ្រាន់ហើយ ដូចជាការលុបធាតុស្ទួនដែរ។

print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]

ប្រសិនបើ​អ្នក​ចង់​ទាញ​យក​ស្ទួន​ដូច​ដែល​ពួកវា​មាន អ្នក​គ្រាន់​តែ​ទុក​ធាតុ​ពី​បញ្ជី​ដើម​ដោយ​មាន​ចំនួន​ពីរ ឬ​ច្រើន​ជាង​នេះ។ ការបញ្ជាទិញក៏ត្រូវបានរក្សាទុកផងដែរ។

cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]

អារេពីរវិមាត្រ (បញ្ជីរាយនាម)

សម្រាប់អារេពីរវិមាត្រ (បញ្ជីនៃបញ្ជី) មុខងារខាងក្រោមគឺអាចធ្វើទៅបាននៅពេលដែលលំដាប់នៃបញ្ជីដើមមិនត្រូវបានរក្សាទុក ហើយនៅពេលដែលវាត្រូវបានរក្សាទុករៀងៗខ្លួន។ វាក៏ដំណើរការសម្រាប់បញ្ជីមួយវិមាត្រ និង tuples ផងដែរ។

l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]

def get_duplicate_list(seq):
    seen = []
    return [x for x in seq if not seen.append(x) and seen.count(x) == 2]

def get_duplicate_list_order(seq):
    seen = []
    return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]

print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]

print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]

print(get_duplicate_list(l))
# [3, 1, 2]

print(get_duplicate_list_order(l))
# [3, 2, 1]

ប្រសិនបើអ្នកចង់ស្រង់ចេញដោយស្ទួន សូមទុកធាតុចេញពីបញ្ជីដើមដោយរាប់ពីរ ឬច្រើនជាងនេះ។

print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]

ចំណាំថាចាប់តាំងពីភាពស្មុគស្មាញនៃការគណនានៃ count() គឺ O(n) មុខងារដែលបានបង្ហាញខាងលើដែលប្រតិបត្តិម្តងហើយម្តងទៀត count() គឺគ្មានប្រសិទ្ធភាពខ្លាំង។ ប្រហែលជាមានវិធីដ៏ឆ្លាតវៃជាងនេះ។

Counter គឺជាប្រភេទរងនៃវចនានុក្រម ដូច្នេះប្រសិនបើអ្នកឆ្លងផុតបញ្ជី ឬ tuple ដែលធាតុរបស់វាជាបញ្ជី ឬវត្ថុដែលមិនអាចហាមបានផ្សេងទៀតទៅកាន់ collections.Counter() កំហុសនឹងកើតឡើង ហើយអ្នកនឹងមិនអាចប្រើវាបានទេ។

# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'