ਪਾਈਥਨ ਦੀ ਸੈੱਟ ਕਿਸਮ ਦੇ ਨਾਲ ਓਪਰੇਸ਼ਨ ਸੈੱਟ ਕਰੋ (ਉਦਾਹਰਨ ਲਈ, ਯੂਨੀਅਨ ਸੈੱਟ, ਉਤਪਾਦ ਸੈੱਟ, ਅਤੇ ਉਪ-ਸੈੱਟਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ)

ਕਾਰੋਬਾਰ

ਪਾਈਥਨ ਇੱਕ ਬਿਲਟ-ਇਨ ਡਾਟਾ ਕਿਸਮ, ਸੈੱਟ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਸੈੱਟਾਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ।

ਕਿਸਮ ਸੈੱਟ ਗੈਰ-ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ (ਐਲੀਮੈਂਟਸ ਜੋ ਸਮਾਨ ਮੁੱਲ ਨਹੀਂ ਹਨ, ਵਿਲੱਖਣ ਤੱਤ) ਦਾ ਸੰਗ੍ਰਹਿ ਹੈ ਅਤੇ ਸੈੱਟ ਓਪਰੇਸ਼ਨ ਕਰ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਯੂਨੀਅਨ ਸੈੱਟ, ਉਤਪਾਦ ਸੈੱਟ, ਅਤੇ ਅੰਤਰ ਸੈੱਟ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਸੈੱਟ-ਟਾਈਪ ਸੈੱਟ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਬੁਨਿਆਦੀ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਨਮੂਨਾ ਕੋਡ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

  • ਸੈੱਟ ਆਬਜੈਕਟ ਦੀ ਰਚਨਾ:{},set()
  • ਸ਼ਾਮਿਲ ਸੰਕੇਤ ਸੈੱਟ ਕਰੋ
  • ਸੈੱਟ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ:len()
  • ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਇੱਕ ਤੱਤ ਜੋੜਨਾ:add()
  • ਇੱਕ ਸਮੂਹ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਹਟਾਓ:discard(),remove(),pop(),clear()
  • ਵਸੇਟ (ਅਭੇਦ, ਯੂਨੀਅਨ):| ਆਪਰੇਟਰ,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 ਅਤੇ ਫਲੋਟ, ਨੂੰ ਡੁਪਲੀਕੇਟ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਬਰਾਬਰ ਹਨ।

s = {100, 100.0}

print(s)
# {100}

ਕਿਉਂਕਿ ਇੱਕ ਖਾਲੀ ਬਰੇਸ {} ਨੂੰ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਕਿਸਮ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਖਾਲੀ ਸੈੱਟ ਕਿਸਮ ਆਬਜੈਕਟ (ਖਾਲੀ ਸੈੱਟ) ਅੱਗੇ ਦੱਸੇ ਗਏ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

s = {}

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

ਕੰਸਟਰਕਟਰ ਸੈੱਟ() ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ

ਕੰਸਟਰਕਟਰ ਸੈੱਟ() ਨਾਲ ਟਾਈਪ ਸੈੱਟ ਦੀਆਂ ਵਸਤੂਆਂ ਵੀ ਬਣਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।

ਇੱਕ ਦੁਹਰਾਉਣਯੋਗ ਵਸਤੂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨਾ ਜਿਵੇਂ ਕਿ ਇੱਕ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਸੈੱਟ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸਦੇ ਤੱਤ ਕੇਵਲ ਵਿਲੱਖਣ ਮੁੱਲ ਹੁੰਦੇ ਹਨ, ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ ਨੂੰ ਬਾਹਰ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

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

ਕੰਸਟਰਕਟਰ ਫ਼੍ਰੋਜ਼ਨਸੈੱਟ () ਨਾਲ ਅਟੱਲ ਫ਼੍ਰੋਜ਼ਨਸੈੱਟ ਕਿਸਮਾਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।

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

ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਸੂਚੀ ਵਿੱਚੋਂ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਸੈੱਟ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੂਪਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਅਸਲ ਸੂਚੀ ਦਾ ਕ੍ਰਮ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਹੈ।

ਇੱਕ ਸੈੱਟ ਕਿਸਮ ਨੂੰ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਸੂਚੀ(), ਟੂਪਲ() ਦੀ ਵਰਤੋਂ ਕਰੋ।

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

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

ਆਰਡਰ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਹਟਾਉਣ, ਸਿਰਫ ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ, ਅਤੇ ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ) ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

ਸ਼ਾਮਿਲ ਸੰਕੇਤ ਸੈੱਟ ਕਰੋ

ਸੂਚੀ ਦੀਆਂ ਸਮਝਾਂ ਦੇ ਨਾਲ-ਨਾਲ, ਇੱਥੇ ਸਮਝੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਸੂਚੀ ਦੀ ਸਮਝ ਵਿੱਚ ਬਸ ਵਰਗ ਬਰੈਕਟ [] ਨੂੰ ਬਰੇਸ {} ਨਾਲ ਬਦਲੋ।

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

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

ਸੂਚੀ ਸਮਝ ਦੇ ਸੰਕੇਤ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

ਸੈੱਟ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ:len()

ਇੱਕ ਸੈੱਟ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ len() ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

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

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

ਜੇਕਰ ਤੁਸੀਂ ਹਰੇਕ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਗਿਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਆਦਿ ਵਾਲੇ ਤੱਤ ਹਨ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਇੱਕ ਤੱਤ ਜੋੜਨਾ:add()

ਇੱਕ ਸੈੱਟ ਵਿੱਚ ਇੱਕ ਤੱਤ ਜੋੜਨ ਲਈ, add() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

s = {0, 1, 2}

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

ਇੱਕ ਸਮੂਹ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਹਟਾਓ:discard(),remove(),pop(),clear()

ਇੱਕ ਸਮੂਹ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਡਿਸਕਾਰਡ(), ਹਟਾਓ(), ਪੌਪ(), ਅਤੇ ਸਾਫ਼() ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਡਿਸਕਾਰਡ() ਵਿਧੀ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਦਰਸਾਏ ਤੱਤ ਨੂੰ ਮਿਟਾ ਦਿੰਦੀ ਹੈ। ਜੇ ਇੱਕ ਮੁੱਲ ਜੋ ਸੈੱਟ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਕੁਝ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

s = {0, 1, 2}

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

s = {0, 1, 2}

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

ਰਿਮੂਵ() ਵਿਧੀ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਦਰਸਾਏ ਤੱਤ ਨੂੰ ਵੀ ਹਟਾਉਂਦੀ ਹੈ, ਪਰ ਇੱਕ ਗਲਤੀ KeyError ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੇਕਰ ਇੱਕ ਮੁੱਲ ਜੋ ਸੈੱਟ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ।

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

ਪੌਪ() ਵਿਧੀ ਇੱਕ ਸੈੱਟ ਤੋਂ ਤੱਤ ਹਟਾਉਂਦੀ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਇਹ ਚੁਣਨਾ ਸੰਭਵ ਨਹੀਂ ਹੈ ਕਿ ਕਿਹੜੇ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣਾ ਹੈ। ਇੱਕ ਖਾਲੀ ਸੈੱਟ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ 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()

ਵਸੇਟ (ਅਭੇਦ, ਯੂਨੀਅਨ):| ਆਪਰੇਟਰ,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}

ਇੱਕ ਵਿਧੀ ਲਈ ਕਈ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਸੈੱਟ ਕਿਸਮ ਤੋਂ ਇਲਾਵਾ, ਸੂਚੀਆਂ ਅਤੇ ਟੂਪਲਾਂ ਨੂੰ ਸੈੱਟ () ਦੁਆਰਾ ਸੈੱਟ ਕਿਸਮ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਨੂੰ ਵੀ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹੀ ਬਾਅਦ ਦੇ ਓਪਰੇਟਰਾਂ ਅਤੇ ਤਰੀਕਿਆਂ ‘ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।

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

ਉਤਪਾਦ ਸੈੱਟ (ਆਮ ਭਾਗ, ਇੰਟਰਸੈਕਸ਼ਨ, ਅਤੇ ਇੰਟਰਸੈਕਸ਼ਨ) & ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਆਪਰੇਟਰ ਜਾਂ ਇੰਟਰਸੈਕਸ਼ਨ() ਵਿਧੀ।

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

ਅੰਤਰ ਸੈੱਟ – ਓਪਰੇਟਰ ਜਾਂ ਫਰਕ() ਵਿਧੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

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

ਸਮਮਿਤੀ ਅੰਤਰ ਸੈੱਟ (ਦੋਵਾਂ ਵਿੱਚੋਂ ਸਿਰਫ਼ ਇੱਕ ਵਿੱਚ ਮੌਜੂਦ ਤੱਤਾਂ ਦਾ ਸੈੱਟ) ਨੂੰ ^ ਆਪਰੇਟਰ ਜਾਂ ਸਿਮਟ੍ਰਿਕ_ਡਿਫਰੈਂਸ() ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਲਾਜ਼ੀਕਲ ਕਾਰਵਾਈਆਂ ਵਿੱਚ ਨਿਵੇਕਲੇ ਡਿਸਜੰਕਸ਼ਨ (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()

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਇੱਕ ਸੈੱਟ ਦੂਜੇ ਸੈੱਟ ਦਾ ਸਬਸੈੱਟ ਹੈ, <= ਆਪਰੇਟਰ ਜਾਂ issubset() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

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

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਇੱਕ ਸੈੱਟ ਦੂਜੇ ਦਾ ਸੁਪਰਸੈੱਟ ਹੈ, >= ਆਪਰੇਟਰ ਜਾਂ issuperset() ਦੀ ਵਰਤੋਂ ਕਰੋ।

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

ਬਰਾਬਰ ਸੈੱਟਾਂ ਲਈ >= ਆਪਰੇਟਰ ਅਤੇ issuperset() ਵਿਧੀ ਦੋਵੇਂ ਸਹੀ ਵਾਪਸ ਆਉਂਦੇ ਹਨ।

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਇਹ ਇੱਕ ਸੱਚਾ ਸੁਪਰਸੈੱਟ ਹੈ, >= ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਬਰਾਬਰ ਦੇ ਸੈੱਟਾਂ ਲਈ ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ।

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