Операции с множества (например определяне на обединение на множества, произведение на множества и подмножества) с типа множества на Python

Бизнес

Python предлага вграден тип данни set, който обработва множества.

Типът множество е колекция от недублиращи се елементи (елементи, които нямат една и съща стойност, уникални елементи) и може да изпълнява операции с множества, като например обединение на множества, произведение на множества и разлика на множества.

В този раздел с примерен код са обяснени основните операции при операциите с множества от типа set.

  • Създаване на обекти от комплекта: {},set()
  • запис за включване на набор
  • Брой елементи в множеството:len()
  • Добавяне на елемент към набор:add()
  • Премахване на елемент от дадено множество: discard(),remove(),pop(),clear()
  • Wasset (сливане, съюз):|оператор,union()
  • Продуктови набори (общи части, пресечни точки, кръстовища):& оператор,intersection()
  • относително допълнение:-оператор,difference()
  • набор от разлики в симетрията:^ оператор,symmetric_difference()
  • подмножество или не:<= оператор,issubset()
  • Горен набор или не:>= оператор,issuperset()
  • Определяне дали те са взаимно прости или не:isdisjoint()

Типът set е променлив тип, който може да добавя и изтрива елементи, а също така има и тип frozenset, който има същата операция set и други методи като типа set, но е непроменлив (не може да бъде променян чрез добавяне, изтриване или друга модификация на елементи).

Създаване на обект set:: {}, set()

Генерирано от вълнови скоби {}

Обекти от тип set могат да се създават чрез ограждане на елементите в скоби {}.

Ако има дублиращи се стойности, те се пренебрегват и като елементи остават само уникалните стойности.

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

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

Възможно е да имате различни типове като елементи. Въпреки това не могат да се регистрират актуализируеми обекти, като например типове списъци. Позволени са кортежи.

Освен това, тъй като типовете множества не са подредени, редът, в който са генерирани, не се съхранява.

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}

Тъй като празната скоба {} се счита за тип речник, обект от типа празно множество (empty set) може да бъде създаден с помощта на конструктора, описан по-нататък.

s = {}

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

Генерира се от конструктора set()

Обекти от тип set могат да се създават и с конструктора set().

Посочването на итерабилен обект, например списък или кортеж, като аргумент генерира обект множество, чиито елементи са само уникални стойности, като дублиращите се елементи са изключени.

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

Неизменните типове frozenset се създават с конструктора frozenset().

fs_l = frozenset(l)

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

Ако аргументът е пропуснат, се създава празен обект от тип set (празно множество).

s = set()

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

Дублиращите се елементи могат да бъдат премахнати от списък или кортеж с помощта на set(), но редът на оригиналния списък не се запазва.

За да преобразувате тип множество в списък или кортеж, използвайте функциите list(),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}

Методът 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()

Множеството за обединяване (merger, 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}

За един метод могат да бъдат зададени няколко аргумента. В допълнение към типа set като аргументи могат да бъдат зададени списъци и кортежи, които могат да бъдат преобразувани в тип set чрез 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()

Множеството на продуктите (обща част, пресичане и пресичане) може да се получи с оператора & или с метода 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()

Множеството на разликите може да се получи с оператора – или с метода 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() връщат true за еквивалентни множества.

За да определите дали е вярно подмножество, използвайте оператора <=, който връща false за еквивалентни множества.

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() връщат true за еквивалентни множества.

За да определите дали е вярно супермножество, използвайте оператора >=, който връща false за еквивалентни множества.

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
Copied title and URL