পাইথনের সেট টাইপের সাথে অপারেশন সেট করুন (যেমন, ইউনিয়ন সেট, পণ্য সেট এবং উপসেট নির্ধারণ)

ব্যবসায়

পাইথন একটি অন্তর্নির্মিত ডেটা টাইপ, সেট প্রদান করে, যা সেটগুলি পরিচালনা করে।

টাইপ সেট হল নন-ডুপ্লিকেট উপাদানগুলির একটি সংগ্রহ (এলিমেন্ট যা একই মান নয়, অনন্য উপাদান) এবং সেট অপারেশনগুলি যেমন ইউনিয়ন সেট, পণ্য সেট এবং পার্থক্য সেট করতে পারে।

এই বিভাগে, সেট-টাইপ সেট অপারেশনের মৌলিক ক্রিয়াকলাপগুলি নমুনা কোড সহ ব্যাখ্যা করা হয়েছে।

  • সেট অবজেক্টের সৃষ্টি:{},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 এবং float, তাদের মান সমতুল্য হলে সদৃশ হিসাবে বিবেচিত হয়।

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

সদৃশ উপাদান একটি তালিকা থেকে সরানো যেতে পারে বা set() ব্যবহার করে tuple করা যেতে পারে, কিন্তু মূল তালিকার ক্রম সংরক্ষিত হয় না।

একটি সেট টাইপকে তালিকা বা টিপলে রূপান্তর করতে, তালিকা(),টুপল() ব্যবহার করুন।

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

একটি সেট থেকে একটি উপাদান অপসারণ করতে, 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}

রিমুভ() পদ্ধতিটি আর্গুমেন্টে নির্দিষ্ট করা উপাদানটিকেও সরিয়ে দেয়, তবে সেটে বিদ্যমান নেই এমন একটি মান নির্দিষ্ট করা হলে একটি ত্রুটি 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()

^ অপারেটর বা 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()

একটি সেট অন্য সেটের সুপারসেট কিনা তা নির্ধারণ করতে, >= অপারেটর বা ইস্যুপারসেট() ব্যবহার করুন।

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