Операције скупа (нпр. одређивање скупова синдиката, скупова производа и подскупова) са типом скупа Питхон-а

Питхон обезбеђује уграђени тип података, сет, који рукује скуповима.

Скуп типова је колекција елемената који се не дуплирају (елементи који нису исте вредности, јединствени елементи) и може да обавља операције скупа као што су скуп уједињења, скуп производа и скуп разлика.

• Set Types — set, frozenset — Python 3.10.4 Documentation

У овом одељку, основне операције у операцијама скупа типа скупа су објашњене са примером кода.

• Креирање постављених објеката:{},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'>

Могуће је имати различите типове као елементе. Међутим, не могу се регистровати објекти који се могу ажурирати као што су типови листа. Корке су дозвољене.

Такође, пошто типови скупова нису уређени, редослед којим су генерисани се не чува.

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

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

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

Различити типови, као што су инт и флоат, сматрају се дупликатима ако су њихове вредности еквивалентне.

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

Број елемената у скупу се може добити помоћу уграђене функције лен().

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

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

Ако желите да пребројите број елемената на свакој листи која има елементе са дуплираним вредностима итд., погледајте следећи чланак.

• ПОВЕЗАН:Бројање броја појављивања сваког елемента на листи помоћу Питхон-овог бројача

Додавање елемента скупу: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}

Метода ремове() такође уклања елемент наведен у аргументу, али се враћа грешка КеиЕррор ако је наведена вредност која не постоји у скупу.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Метода поп() уклања елементе из скупа и враћа њихове вредности. Није могуће изабрати које вредности треба уклонити. Празан скуп ће резултирати грешком КеиЕррор.

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'

Метода цлеар() уклања све елементе и чини скуп празним.

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

Скуп симетричних разлика (скуп елемената садржаних у само једном од та два) може се добити помоћу ^ оператора или симметриц_дифференце().

Еквивалентно искључивој дисјунцији (КСОР) у логичким операцијама.

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

Да бисте утврдили да ли је скуп подскуп другог скупа, користите оператор &лт;= или метод иссубсет().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

И оператор &лт;= и метод иссубсет() враћају тачно за еквивалентне скупове.

Да бисте утврдили да ли је тачан подскуп, користите оператор &лт;=, који враћа нетачно за еквивалентне скупове.

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

И оператор &гт;= и метод иссуперсет() враћају тачно за еквивалентне скупове.

Да бисте утврдили да ли је то прави суперскуп, користите оператор &гт;=, који враћа нетачно за еквивалентне скупове.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Одређивање да ли су међусобно прости или не:isdisjoint()

Да бисте утврдили да ли су два скупа прости један према другом, користите метод исдисјоинт().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True