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

Python ផ្តល់នូវប្រភេទទិន្នន័យដែលភ្ជាប់មកជាមួយ សំណុំ ដែលគ្រប់គ្រងសំណុំ។

សំណុំ​ប្រភេទ​គឺ​ជា​បណ្តុំ​នៃ​ធាតុ​មិន​ស្ទួន (ធាតុ​ដែល​មិន​មាន​តម្លៃ​ដូចគ្នា ធាតុ​តែ​មួយ) ហើយ​អាច​ធ្វើ​ប្រតិបត្តិការ​សំណុំ​ដូច​ជា​សំណុំ​សហជីព សំណុំ​ផលិតផល និង​សំណុំ​ភាពខុសគ្នា។

• Set Types — set, frozenset — Python 3.10.4 Documentation

នៅក្នុងផ្នែកនេះ ប្រតិបត្តិការជាមូលដ្ឋានក្នុងប្រតិបត្តិការសំណុំប្រភេទត្រូវបានពន្យល់ជាមួយកូដគំរូ។

• ការបង្កើតវត្ថុដែលបានកំណត់:{},set()
• កំណត់ការរួមបញ្ចូល
• ចំនួនធាតុនៅក្នុងសំណុំ:len()
• ការបន្ថែមធាតុទៅសំណុំ:add()
• យកធាតុចេញពីសំណុំ:discard(),remove(),pop(),clear()

• Wasset (ការរួមបញ្ចូលគ្នា, សហជីព):| ប្រតិបត្តិករ,union()
• សំណុំផលិតផល (ផ្នែកទូទៅ ប្រសព្វ ប្រសព្វ):& ប្រតិបត្តិករ,intersection()
• ការបំពេញបន្ថែមដែលទាក់ទង:– ប្រតិបត្តិករ,difference()
• សំណុំភាពខុសគ្នានៃស៊ីមេទ្រី:^ ប្រតិបត្តិករ,symmetric_difference()
• សំណុំរងឬអត់:<= ប្រតិបត្តិករ,issubset()
• ឈុតខាងលើឬអត់:>= ប្រតិបត្តិករ,issuperset()
• ការ​កំណត់​ថា​តើ​ពួក​គេ​ត្រូវ​បាន​គ្នា​ទៅ​វិញ​ទៅ​មក​ឬ​អត់​:isdisjoint()

ប្រភេទសំណុំគឺជាប្រភេទដែលអាចផ្លាស់ប្តូរបាន ដែលអាចបន្ថែម និងលុបធាតុ ហើយក៏មានប្រភេទសំណុំកកដែលមានប្រតិបត្តិការសំណុំដូចគ្នា និងវិធីសាស្រ្តផ្សេងទៀតដូចជាប្រភេទសំណុំ ប៉ុន្តែមិនអាចផ្លាស់ប្តូរបាន (មិនអាចកែប្រែដោយការបន្ថែម លុប ឬកែប្រែធាតុផ្សេងទៀត )

ការបង្កើតវត្ថុកំណត់៖:{},set()

បង្កើត​ដោយ​តង្កៀប​រលក {}

វត្ថុ​នៃ​សំណុំ​ប្រភេទ​អាច​ត្រូវ​បាន​បង្កើត​ដោយ​ការ​ភ្ជាប់​ធាតុ​ក្នុង​ដង្កៀប {} ។

ប្រសិនបើមានតម្លៃស្ទួន ពួកវាមិនត្រូវបានអើពើ ហើយតម្លៃតែមួយគត់នៅតែជាធាតុ។

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

វាអាចទៅរួចដែលមានប្រភេទផ្សេងៗគ្នាជាធាតុ។ ទោះយ៉ាងណាក៏ដោយ វត្ថុដែលអាចធ្វើបច្ចុប្បន្នភាពបាន ដូចជាប្រភេទបញ្ជីមិនអាចចុះឈ្មោះបានទេ។ Tuples ត្រូវបានអនុញ្ញាត។

ផងដែរ ដោយសារប្រភេទសំណុំមិនត្រូវបានតម្រៀបតាមលំដាប់លំដោយ លំដាប់ដែលពួកវាត្រូវបានបង្កើតមិនត្រូវបានរក្សាទុកទេ។

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

ប្រភេទផ្សេងៗគ្នា ដូចជា int និង float ត្រូវបានចាត់ទុកថាស្ទួន ប្រសិនបើតម្លៃរបស់វាស្មើ។

s = {100, 100.0}

print(s)
# {100}

ដោយសារខ្សែដៃទទេ {} ត្រូវបានគេចាត់ទុកថាជាប្រភេទវចនានុក្រម វត្ថុប្រភេទសំណុំទទេ (សំណុំទទេ) អាចត្រូវបានបង្កើតដោយប្រើ constructor ដែលបានពិពណ៌នាបន្ទាប់។

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

បង្កើតដោយ constructor set()

Objects of type set ក៏អាចត្រូវបានបង្កើតជាមួយនឹង constructor set()។

ការបញ្ជាក់វត្ថុដែលអាចធ្វើឡើងវិញបាន ដូចជាបញ្ជី ឬ tuple ជាអាគុយម៉ង់បង្កើតវត្ថុសំណុំដែលធាតុរបស់វាមានតម្លៃតែមួយគត់ ដោយធាតុស្ទួនត្រូវបានដកចេញ។

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

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

ប្រភេទនៃការបង្កកដែលមិនអាចផ្លាស់ប្តូរបានត្រូវបានបង្កើតជាមួយ constructor frozenset()។

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

ប្រសិនបើអាគុយម៉ង់ត្រូវបានលុបចោល វត្ថុប្រភេទសំណុំទទេ (សំណុំទទេ) ត្រូវបានបង្កើត។

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

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

ដើម្បីបំប្លែងប្រភេទសំណុំទៅជាបញ្ជី ឬ tuple សូមប្រើ list(),tuple()។

• ពាក់ព័ន្ធ៖list(), tuple() ដើម្បីបំប្លែង list និង tuple ទៅគ្នាទៅវិញទៅមកក្នុង Python

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

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

សូមមើលអត្ថបទខាងក្រោមសម្រាប់ព័ត៌មានស្តីពីការដកធាតុស្ទួនចេញ ខណៈពេលដែលរក្សាសណ្តាប់ធ្នាប់ ស្រង់ចេញតែធាតុស្ទួន និងដំណើរការធាតុស្ទួនក្នុងអារេពីរវិមាត្រ (បញ្ជីបញ្ជី)។

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

កំណត់ការរួមបញ្ចូល

ក៏ដូចជាការយល់ក្នុងបញ្ជី មានការយល់ច្បាស់ដែលបានកំណត់។ គ្រាន់តែជំនួសតង្កៀបការ៉េ [] ជាមួយតង្កៀប {} ក្នុងបញ្ជីការយល់ដឹង។

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

សូមមើលអត្ថបទខាងក្រោមសម្រាប់ព័ត៌មានបន្ថែមអំពីបញ្ជីកំណត់ចំណាំ។

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

ចំនួនធាតុនៅក្នុងសំណុំ:len()

ចំនួនធាតុនៅក្នុងសំណុំមួយអាចទទួលបានជាមួយនឹងមុខងារដែលភ្ជាប់មកជាមួយ len()។

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

ប្រសិនបើអ្នកចង់រាប់ចំនួនធាតុនៅក្នុងបញ្ជីនីមួយៗដែលមានធាតុដែលមានតម្លៃស្ទួន។ល។ សូមមើលអត្ថបទខាងក្រោម។

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

ការបន្ថែមធាតុទៅសំណុំ:add()

ដើម្បីបន្ថែមធាតុមួយទៅសំណុំ ប្រើវិធី add()។

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

យកធាតុចេញពីសំណុំ:discard(),remove(),pop(),clear()

ដើម្បីលុបធាតុចេញពីសំណុំ សូមប្រើវិធីសាស្រ្ត discard() remove() pop() និង clear()។

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

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

វិធីសាស្ត្រ remove() ក៏ដកធាតុដែលបានបញ្ជាក់នៅក្នុងអាគុយម៉ង់ផងដែរ ប៉ុន្តែកំហុស KeyError ត្រូវបានបញ្ជូនមកវិញ ប្រសិនបើតម្លៃដែលមិនមាននៅក្នុងសំណុំត្រូវបានបញ្ជាក់។

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

វិធីសាស្ត្រ pop() ដកធាតុចេញពីសំណុំ ហើយត្រឡប់តម្លៃរបស់វា។ វា​មិន​អាច​ជ្រើសរើស​តម្លៃ​មួយ​ណា​ដែល​ត្រូវ​លុប​ចេញ។ សំណុំទទេនឹងបណ្តាលឱ្យមានកំហុស KeyError ។

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

វិធីសាស្ត្រ clear() លុបធាតុទាំងអស់ ហើយធ្វើឱ្យសំណុំទទេ។

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (ការរួមបញ្ចូលគ្នា, សហជីព):| ប្រតិបត្តិករ,union()

សំណុំសហជីព (ការរួមបញ្ចូលគ្នា, សហជីព) អាចទទួលបានជាមួយ | ប្រតិបត្តិករ ឬវិធីសាស្រ្ត union() ។

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

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

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

សំណុំផលិតផល (ផ្នែកទូទៅ ប្រសព្វ ប្រសព្វ):& ប្រតិបត្តិករ,intersection()

សំណុំផលិតផល (ផ្នែកទូទៅ ប្រសព្វ និងប្រសព្វ) អាចទទួលបានជាមួយ & operator ឬវិធីប្រសព្វ()។

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

ការបំពេញបន្ថែមដែលទាក់ទង:– ប្រតិបត្តិករ,difference()

សំណុំភាពខុសគ្នាអាចទទួលបានជាមួយ – operator ឬវិធីផ្សេងគ្នា()។

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

សំណុំភាពខុសគ្នានៃស៊ីមេទ្រី:^ ប្រតិបត្តិករ,symmetric_difference()

សំណុំភាពខុសគ្នាស៊ីមេទ្រី (សំណុំនៃធាតុដែលមានតែមួយក្នុងចំណោមពីរ) អាចទទួលបានជាមួយ ^ operator ឬ symmetric_difference()។

ស្មើនឹងការផ្តាច់ផ្តាច់មុខ (XOR) នៅក្នុងប្រតិបត្តិការឡូជីខល។

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

សំណុំរងឬអត់:<= ប្រតិបត្តិករ,issubset()

ដើម្បី​កំណត់​ថា​តើ​សំណុំ​មួយ​ជា​សំណុំ​រង​នៃ​សំណុំ​មួយ​ផ្សេង​ទៀត​ឬ​អត់​ សូម​ប្រើ​វិធីសាស្ត្រ <= operator ឬ issubset() method ។

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

ទាំង​ប្រតិបត្តិករ <= និង​វិធីសាស្ត្រ issubset() ត្រឡប់​ពិត​សម្រាប់​សំណុំ​សមមូល។

ដើម្បី​កំណត់​ថា​តើ​វា​ជា​សំណុំ​រង​ពិត​ឬ​អត់ សូម​ប្រើ​ប្រតិបត្តិករ <= ដែល​ត្រឡប់​មិន​ពិត​សម្រាប់​សំណុំ​សមមូល។

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

ឈុតខាងលើឬអត់:>= ប្រតិបត្តិករ,issuperset()

ដើម្បីកំណត់ថាតើសំណុំមួយគឺជា superset នៃមួយផ្សេងទៀត ប្រើ >= operator ឬ issuperset()។

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

ទាំង​ប្រតិបត្តិករ >= និង​វិធីសាស្ត្រ issuperset() ត្រឡប់​ពិត​សម្រាប់​សំណុំ​សមមូល។

ដើម្បី​កំណត់​ថា​តើ​វា​ជា​ superset ពិត​ឬ​អត់​ សូម​ប្រើ​ប្រតិបត្តិករ >= ដែល​ត្រឡប់​មិន​ពិត​សម្រាប់​សំណុំ​សមមូល។

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

ការ​កំណត់​ថា​តើ​ពួក​គេ​ត្រូវ​បាន​គ្នា​ទៅ​វិញ​ទៅ​មក​ឬ​អត់​:isdisjoint()

ដើម្បី​កំណត់​ថាតើ​សំណុំ​ពីរ​ត្រូវ​គ្នា​ទៅ​វិញ​ទៅ​មក​ឬ​អត់ សូម​ប្រើ​វិធីសាស្ត្រ isdisjoint() ។

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True