Nagbibigay ang Python ng built-in na uri ng data, set, na humahawak ng mga set.
Ang hanay ng uri ay isang koleksyon ng mga hindi duplicate na elemento (mga elementong hindi magkapareho ang halaga, mga natatanging elemento) at maaaring magsagawa ng mga hanay ng operasyon gaya ng hanay ng unyon, hanay ng produkto, at hanay ng pagkakaiba.
Sa seksyong ito, ang mga pangunahing operasyon sa set-type set operations ay ipinaliwanag kasama ng sample code.
- Paglikha ng mga set na bagay:
{}
,set()
- itakda ang inclusion notation
- Bilang ng mga elemento sa set:
len()
- Pagdaragdag ng Elemento sa isang Set:
add()
- Alisin ang isang elemento mula sa isang set:
discard()
,remove()
,pop()
,clear()
- Wasset (pagsama-sama, unyon):|operator,
union()
- Mga hanay ng produkto (mga karaniwang bahagi, intersection, intersection):& operator,
intersection()
- kamag-anak na pandagdag:-operator,
difference()
- set ng pagkakaiba ng symmetry:^ operator,
symmetric_difference()
- subset o hindi:<= operator,
issubset()
- Upper set o hindi:>= operator,
issuperset()
- Pagpapasiya kung sila ay mutually prime o hindi:
isdisjoint()
Ang uri ng hanay ay isang uri ng nababago na maaaring magdagdag at magtanggal ng mga elemento, at mayroon ding uri ng frozenset na may parehong hanay ng operasyon at iba pang mga pamamaraan tulad ng uri ng hanay ngunit hindi nababago (hindi maaaring baguhin sa pamamagitan ng pagdaragdag, pagtanggal, o kung hindi man ay pagbabago ng mga elemento ).
- Paglikha ng set object::{},set()
- itakda ang inclusion notation
- Bilang ng mga elemento sa set:len()
- Pagdaragdag ng Elemento sa isang Set:add()
- Alisin ang isang elemento mula sa isang set:discard(),remove(),pop(),clear()
- Wasset (pagsama-sama, unyon):|operator,union()
- Mga hanay ng produkto (mga karaniwang bahagi, intersection, intersection):& operator,intersection()
- kamag-anak na pandagdag:-operator,difference()
- set ng pagkakaiba ng symmetry:^ operator,symmetric_difference()
- subset o hindi:<= operator,issubset()
- Upper set o hindi:>= operator,issuperset()
- Pagpapasiya kung sila ay mutually prime o hindi:isdisjoint()
Paglikha ng set object::{},set()
Binuo ng mga wave bracket {}
Ang mga bagay na may uri ng set ay maaaring gawin sa pamamagitan ng paglalagay ng mga elemento sa mga braces {}.
Kung may mga duplicate na value, hindi papansinin ang mga ito at tanging mga natatanging value lang ang nananatili bilang mga elemento.
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
Posibleng magkaroon ng iba’t ibang uri bilang mga elemento. Gayunpaman, ang mga naa-update na bagay tulad ng mga uri ng listahan ay hindi maaaring mairehistro. Pinapayagan ang mga tuple.
Gayundin, dahil ang mga uri ng hanay ay hindi nakaayos, ang pagkakasunud-sunod kung saan nabuo ang mga ito ay hindi iniimbak.
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
Ang iba’t ibang uri, tulad ng int at float, ay itinuturing na mga duplicate kung ang kanilang mga halaga ay katumbas.
s = {100, 100.0}
print(s)
# {100}
Dahil ang isang walang laman na brace {} ay itinuturing na isang uri ng diksyunaryo, isang walang laman na bagay na uri ng hanay (empty set) ay maaaring gawin gamit ang constructor na inilarawan sa susunod.
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
Binuo ng constructor set()
Ang mga bagay na may uri ng set ay maaari ding malikha gamit ang constructor set().
Ang pagtukoy ng isang iterable na bagay gaya ng isang listahan o tuple bilang isang argument ay bumubuo ng isang set object na ang mga elemento ay mga natatanging halaga lamang, na may mga duplicate na elemento na hindi kasama.
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'>
Ang mga hindi nababagong uri ng frozenset ay nilikha gamit ang constructor frozenset().
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
Kung ang argumento ay tinanggal, isang walang laman na set-type object (empty set) ay gagawin.
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
Maaaring alisin ang mga duplicate na elemento mula sa isang listahan o tuple gamit ang set(), ngunit ang pagkakasunud-sunod ng orihinal na listahan ay hindi napanatili.
Upang i-convert ang isang set na uri sa isang listahan o tuple, gamitin ang list(),tuple().
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
Tingnan ang sumusunod na artikulo para sa impormasyon sa pag-alis ng mga duplicate na elemento habang pinapanatili ang kaayusan, pagkuha lamang ng mga duplicate na elemento, at pagproseso ng mga duplicate na elemento sa isang two-dimensional na array (listahan ng mga listahan).
itakda ang inclusion notation
Pati na rin ang listahan ng mga pag-unawa, may mga nakatakdang pag-unawa. Palitan lang ang mga square bracket [] ng mga brace {} sa mga pag-unawa sa listahan.
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Tingnan ang sumusunod na artikulo para sa higit pang impormasyon sa notasyon ng pag-unawa sa listahan.
Bilang ng mga elemento sa set:len()
Ang bilang ng mga elemento sa isang set ay maaaring makuha gamit ang built-in na function na len().
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
Kung gusto mong bilangin ang bilang ng mga elemento sa bawat listahan na may mga elementong may mga duplicate na halaga, atbp., tingnan ang sumusunod na artikulo.
- KAUGNAY:Binibilang ang bilang ng mga paglitaw ng bawat elemento sa isang listahan gamit ang Python’s Counter
Pagdaragdag ng Elemento sa isang Set:add()
Upang magdagdag ng elemento sa isang set, gamitin ang paraan ng add().
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
Alisin ang isang elemento mula sa isang set:discard(),remove(),pop(),clear()
Upang alisin ang isang elemento mula sa isang set, gamitin ang discard(), remove(), pop(), at clear() na mga pamamaraan.
Tinatanggal ng discard() method ang elementong tinukoy sa argument. Kung ang isang halaga na wala sa set ay tinukoy, walang gagawin.
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
Ang paraan ng remove() ay nag-aalis din ng elementong tinukoy sa argument, ngunit ang isang error na KeyError ay ibinalik kung ang isang halaga na wala sa set ay tinukoy.
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
Ang paraan ng pop() ay nag-aalis ng mga elemento mula sa isang set at ibinabalik ang kanilang mga halaga. Hindi posibleng piliin kung aling mga value ang aalisin. Ang isang walang laman na set ay magreresulta sa isang KeyError error.
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'
Tinatanggal ng clear() na paraan ang lahat ng elemento at ginagawang walang laman ang set.
s = {0, 1, 2}
s.clear()
print(s)
# set()
Wasset (pagsama-sama, unyon):|operator,union()
Ang hanay ng unyon (merger, unyon) ay maaaring makuha gamit ang | operator o ang paraan ng unyon().
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}
Maaaring tukuyin ang maramihang mga argumento para sa isang pamamaraan. Bilang karagdagan sa set na uri, ang mga listahan at tuple na maaaring i-convert sa set na uri sa pamamagitan ng set() ay maaari ding tukuyin bilang mga argumento. Ang parehong naaangkop sa kasunod na mga operator at pamamaraan.
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}
Mga hanay ng produkto (mga karaniwang bahagi, intersection, intersection):& operator,intersection()
Ang set ng produkto (karaniwang bahagi, intersection, at intersection) ay maaaring makuha gamit ang & operator o ang intersection() na pamamaraan.
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}
kamag-anak na pandagdag:-operator,difference()
Ang hanay ng pagkakaiba ay maaaring makuha gamit ang – operator o ang difference() na pamamaraan.
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}
set ng pagkakaiba ng symmetry:^ operator,symmetric_difference()
Ang symmetric difference set (ang hanay ng mga elementong nakapaloob lamang sa isa sa dalawa) ay maaaring makuha gamit ang ^ operator o symmetric_difference().
Katumbas ng eksklusibong disjunction (XOR) sa mga lohikal na operasyon.
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
subset o hindi:<= operator,issubset()
Upang matukoy kung ang isang set ay isang subset ng isa pang set, gamitin ang <= operator o ang issubset() na paraan.
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
Parehong nagbabalik ng true ang <= operator at ang issubset() para sa mga katumbas na set.
Upang matukoy kung ito ay isang tunay na subset, gamitin ang <= operator, na nagbabalik ng false para sa mga katumbas na hanay.
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
Upper set o hindi:>= operator,issuperset()
Upang matukoy kung ang isang set ay superset ng isa pa, gamitin ang >= operator o issuperset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
Parehong nagbabalik ng true ang >= operator at ang issuperset() para sa mga katumbas na set.
Upang matukoy kung ito ay isang tunay na superset, gamitin ang >= operator, na nagbabalik ng false para sa mga katumbas na hanay.
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
Pagpapasiya kung sila ay mutually prime o hindi:isdisjoint()
Upang matukoy kung ang dalawang set ay prime sa isa’t isa, gamitin ang isdisjoint() method.
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True