У овом водичу ћете научити основе Питхон скупова и различите методе скупова које можете користити за модификацију Питхон скупова.
Скупови су једна од уграђених структура података у Питхон-у. Када треба да радите са колекцијом елемената која се не понавља, скуп ћете користити као структуру података за приступ.
У следећих неколико одељака, прећи ћемо на основе Питхон скупова и методе скупова које можете користити за рад са њима. Затим ћемо научити како да изводимо уобичајене операције скупа у Питхон-у.
Почнимо!
Преглед садржаја
Основе Питхон скупова
У Питхон-у, скуп је неуређена колекција непонављајућих елемената. То значи да сви елементи у скупу треба да буду различити.
Можете додавати и уклањати елементе из скупа; дакле, скуп је променљива колекција. Може да садржи елементе различитих типова података. Међутим, појединачни елементи у сету би требало да буду хасхабле.
У Питхон-у се за објекат каже да може хеширати ако се његова хеш вредност никада не мења. Већина непроменљивих објеката као што су Питхон стрингови, тупле и речници су хеширани.
Научићемо детаљно о креирању комплета. За сада, размотрите следећа два скупа:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Први скуп садржи три броја, тупле и стринг. Постављена иницијализација ради без грешке. Док други скуп садржи листу уместо тупле. Листа је променљива колекција, не може се хеширати, а иницијализација баца ТипеЕррор.
📑 Стављајући све заједно, можемо дефинисати Питхон скуп као променљиву колекцију различитих елемената који се могу хеширати.
Како направити Питхон сет
Почећемо тако што ћемо научити како да креирамо скуп у Питхон-у.
#1. Коришћење експлицитне иницијализације
Можете да креирате скуп у Питхон-у тако што ћете навести елементе скупа, одвојене зарезима (,) и затворене у пар витичастих заграда {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Ако сте раније радили са Питхон листама, то знате [] иницијализује празну листу. Иако је Питхон скуп затворен у пар витичастих заграда {}, не можете користити пар {} за иницијализацију скупа. То је зато што {} иницијализује Питхон речник, а не Питхон скуп.
py_set2 = {}
type(py_set2)
# Output
dict
Можете поново позвати функцију типе() да бисте проверили да ли је пи_сет речник (дицт).
#2. Коришћење функције сет().
Ако желите да иницијализујете празан скуп и затим му додате елементе, то можете учинити помоћу функције сет().
py_set3 = set() type(py_set3) # Output set
#3. Пребацивање других итерабле у скуп
Други начин за креирање скупова је пребацивање других итерабле-а, као што су листе и торке, у скупове, користећи сет(итерабле).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
У горњем примеру, пи_лист садржи ‘Ц’ два пута. Али у пи_сет4, ‘Ц’ се појављује само једном, пошто је скуп скуп различитих елемената. Ова техника убацивања у скуп се често користи за уклањање дупликата са Питхон листа.
Како додати елементе у Питхон скуп
Почнимо тако што ћемо креирати празан скуп пи_сет и радити са њим до краја овог упутства.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Коришћењем методе .адд().
Да бисте додали елементе скупу, можете користити метод .адд(). сет.адд(елемент) додаје елемент у скуп.
Ради јасноће, додаћемо елементе у Питхон скуп и одштампати скуп у сваком кораку.
▶ Хајде да додамо стринг ‘Питхон’ као елемент у пи_сет.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Затим ћемо додати још један елемент.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Важно је разумети да метода .адд() само додаје елемент у скуп ако већ није присутан. Ако скуп већ садржи елемент који желите да додате, операција додавања нема ефекта.
Да бисмо ово потврдили, покушајмо да додамо ‘Ц++’ у пи_сет.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Скуп садржи ‘Ц++’, тако да операција додавања нема ефекта.
▶ Хајде да додамо још неколико елемената у сет.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Коришћењем методе .упдате().
До сада смо видели како да додате елементе постојећем скупу – један по један елемент.
Шта ако желите да додате више од једног елемента у низ елемената?
То можете учинити помоћу методе .упдате() са синтаксом: сет.упдате(цоллецтион) да додате елементе из колекције у скуп. Колекција може бити листа, тупле, речник и тако даље.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Овај метод је од помоћи када желите да додате колекцију елемената скупу без креирања другог објекта у меморији.
У следећем одељку, хајде да научимо како да уклонимо елементе из скупа.
Како уклонити елементе из Питхон скупа
Хајде да размотримо следећи скуп (пи_сет пре операције ажурирања).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Коришћење .поп() методе
сет.поп() насумично уклања елемент из скупа и враћа га. Позовимо метод поп на пи_сет и видимо шта враћа.
py_set.pop() # Output 'Rust'
Овог пута, позив методе .поп() вратио је стринг ‘Руст’.
Напомена: Пошто метода .поп() насумично враћа елемент, када покренете код на свом крају, можда ћете добити и други елемент.
Када прегледамо комплет, ‘Руст’ више није присутан у сету.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Коришћење метода .ремове() и дисцард().
У пракси, можда ћете желети да уклоните одређене елементе из скупа. Да бисте то урадили, можете користити методе .ремове() и .дисцард().
сет.ремове(елемент) уклања елементе из скупа.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Ако покушамо да уклонимо елемент који није присутан у скупу, наићи ћемо на КеиЕррор.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Хајде да га поново погледамо пи_сет. Сада имамо три елемента.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Са синтаксом сет.дисцард(елемент), метода .дисцард() такође уклања елементе из скупа.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Међутим, разликује се од методе .ремове() по томе што не покреће КеиЕррор када покушамо да уклонимо елемент који није присутан.
Ако покушамо да уклонимо ‘Сцала’ (која не постоји) са листе користећи методу .дисцард(), нећемо видети грешку.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Како приступити елементима Питхон скупа
До сада смо научили како да додајемо и уклањамо елементе из Питхон скупова. Међутим, још нисмо видели како да приступимо појединачним елементима у скупу.
Пошто је скуп неуређена колекција, не може се индексирати. Стога, ако покушате да приступите елементима скупа помоћу индекса, наићи ћете на грешку, као што је приказано.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Дакле, како приступити елементима у скупу?
Постоје два уобичајена начина да то урадите:
- Прођите кроз скуп и приступите сваком елементу
- Проверите да ли је одређени елемент члан скупа
▶ Прођите кроз скуп и приступите елементима користећи фор петљу.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
У пракси, можда ћете желети да проверите да ли је дати елемент присутан у скупу користећи ин оператор.
Напомена: елемент у скупу враћа Тачно ако је елемент присутан у скупу; иначе враћа Фалсе.
У овом примеру, пи_сет садржи ‘Ц++’ и не садржи ‘Јулија’, а ин оператор враћа Тачно и Нетачно, респективно.
'C++' in py_set # True 'Julia' in py_set # False
Како пронаћи дужину Питхон скупа
Као што смо раније видели, можете користити функцију лен() да бисте добили број елемената присутних у скупу.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Како избрисати Питхон сет
Да бисте обрисали скуп уклањањем свих елемената, можете користити метод .цлеар().
Позовимо метод .цлеар() на пи_сет.
py_set.clear()
Ако покушате да га одштампате, добићете сет() – што указује да је скуп празан. Такође можете позвати функцију лен() да бисте проверили да ли је дужина скупа нула.
print(py_set) # set() print(len(py_set)) # 0
До сада смо научили како да изводимо основне ЦРУД операције на Питхон скуповима:
- Креирајте: Коришћење функције сет(), пребацивање типа и иницијализацију
- Прочитајте: Приступите елементима скупа користећи петље и ин оператор за тестирање чланства
- Ажурирање: Додајте, уклоните елементе из скупова и ажурирајте скупове
- Избриши: Обришите скуп уклањањем свих елемената из њега
Операције уобичајеног скупа, објашњене са Питхон кодом
Питхон скупови нам такође омогућавају да извршимо основне операције скупа. Научићемо о њима у овом одељку.
#1. Унија скупова у Питхон-у
У теорији скупова, унија два скупа је скуп свих елемената у најмање једном од два скупа. Ако постоје два скупа, А и Б, онда унија садржи елементе који су присутни само у А, само у Б, и елементе присутне у А и Б.
Да бисте пронашли унију скупова, можете користити | оператор или .унион() метод са синтаксом: сетА.унион(сетБ).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Унија скупова је комутативна операција; тако да је АУБ исто што и БУ А. Хајде да то проверимо заменом позиција сетА и сетБ у позиву методе .унион().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Пресек скупова у Питхон-у
Друга операција заједничког скупа је овај пресек два скупа, А и Б. Операција пресека скупова враћа скуп који садржи све елементе присутне у А и Б.
Да бисте израчунали пресек, можете користити & оператор или метод .интерсецтион(), као што је објашњено у исечку кода испод.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
У овом примеру, елемент 9 је присутан и у скупу А и у скупу Б; па скуп пресека садржи само овај елемент.
Као и унија скупова, пресек скупова је такође комутативна операција.
setB.intersection(setA)
# Output
{9}
#3. Поставите разлику у Питхон-у
С обзиром на било која два скупа, унија и пресек нам помажу да пронађемо елементе присутне у оба, односно у најмање једном скупу. С друге стране, разлика скупова нам помаже да пронађемо елементе присутне у једном скупу, али не и у другом.
– сетА.дифференце(сетБ) даје скуп елемената који су присутни само у скупу А а не у скупуБ.
– сетБ.дифференце(сетА) даје скуп елемената који су присутни само у скупуБ а не у скупуА.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Јасно је да АБ није исто што и БА, тако да разлика скупа није комутативна операција.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Разлика симетричног скупа у Питхон-у
Док нам пресек скупа даје елементе присутне у оба скупа, симетрична разлика скупова враћа скуп елемената присутних у тачно једном од скупова.
Размотрите следећи пример.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Да бисте израчунали скуп симетричних разлика, можете користити ^ оператор или метод .симметриц_дифференце().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Елементи 10 и 12 су присутни и у скупу А и у скупу Б. Дакле, они нису присутни у скупу симетричних разлика.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Пошто операција разлике симетричног скупа прикупља све елементе који се појављују у тачно једном од два скупа, резултујући скуп је исти без обзира на редослед у коме су елементи прикупљени. Према томе, разлика симетричног скупа је комутативна операција.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Подскупови и суперскупови у Питхон-у
У теорији скупова, подскупови и суперскупови помажу у разумевању односа између два скупа.
С обзиром на два скупа А и Б, скуп Б је подскуп скупа А ако су сви елементи у скупу Б такође присутни у скупу А. А скуп А је надскуп скупа Б.
Размотримо пример два скупа: лангуагес и лангуагес_ектендед.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
У Питхон-у можете користити методу .иссубсет() да проверите да ли је дати скуп подскуп другог скупа.
сетА.иссубсет(сетБ) враћа Тачно ако је сетА подскуп скупаБ; у супротном, враћа Фалсе.
У овом примеру, језици су подскуп лангуагес_ектендед.
languages.issubset(languages_extended) # Output True
Слично, можете користити методу .иссуперсет() да проверите да ли је дати скуп надскуп другог скупа.
сетА.иссуперсет(сетБ) враћа Труе ако је сетА надскуп скупаБ; у супротном, враћа Фалсе.
languages_extended.issuperset(languages) # Output True
Пошто је лангуагес_ектендед надскуп језика, лангуагес_ектендед.иссуперсет(лангуагес) враћа Труе, као што се види изнад.
Закључак
Надам се да вам је овај водич помогао да разумете рад Питхон скупова, методе скупова за ЦРУД операције и уобичајене операције скупова. Као следећи корак, можете покушати да их користите у својим Питхон пројектима.
Можете погледати друге детаљне Питхон водиче. Срећно учење!