Усъвършенствайте уменията си за кодиране на Python: Комплекти

Част 2: Представяне на някои от най-популярните и използвани методи, които могат да бъдат приложени за набор от обекти в Python.

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

Добавяне на елемент към набор

Това наистина е много просто и ясно нещо:

# create initial set
my_set = {1, 2, 3, 4}
print(f"{id(my_set)}: {my_set}")
# add an element to the set
my_set.add(5)
print(f"{id(my_set)}: {my_set}")
Output:
140148778101664: {1, 2, 3, 4}
140148778101664: {1, 2, 3, 4, 5}

Резултатът е предвидим: нашата променлива сочи към същия обект, въпреки че съдържанието на набора е променено; това е така, защото множествата са променливи.

Изпразване (изчистване) на набор

Както беше предложено, това е начинът, по който ефективно изчистваме набора от всички елементи:

# create initial set
my_set = {1, 2, 3, 4}
print(f"{id(my_set)}: {my_set}")
# empty the set
my_set.clear()
print(f"{id(my_set)}: {my_set}")
Output:
140136966093728: {1, 2, 3, 4}
140136966093728: set()

Копиране на набор

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

Задайте разлика

Методът set.difference(another_set) ще изведе набор, който ще съдържа елементи, намерени в първия набор, но не и във втория. Както подсказва името му, това е разлика в комплектите:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4}
# print out the original sets
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
# first set minus the second
a_minus_b = my_first_set.difference(my_second_set)
# vice-versa: second set minus the first
b_minus_a = my_second_set.difference(my_first_set)
# print out the original sets once more
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
# print the resulting 'difference' sets
print(f"{id(a_minus_b)}: {a_minus_b}")
print(f"{id(b_minus_a)}: {b_minus_a}")
Output:
140449652075424: {1, 2, 3, 4}
140449650999072: {3, 4}
140449652075424: {1, 2, 3, 4}
140449650999072: {3, 4}
140449651032128: {1, 2}
140449651032352: set()

Оригиналните набори са непроменени след прилагането на метода difference към тях. Едно нещо, което трябва да се отбележи обаче е, че редът се брои тук, тъй като a.difference(b) няма да бъде същото като b.difference(a), освен ако a не съдържа същите елементи като b. В този конкретен случай разликата, независимо от реда на двата набора ( a.difference(b) или b.difference(a)), очевидно ще бъде празен набор.

Задайте актуализация на разликата

Донякъде подобен на разликата в набора, този гарантира, че елементите, намерени в двата набора, се елиминират от първия набор. Числен пример ще докаже много повече прозрение, отколкото думите могат да постигнат:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
# common elements will be eliminated from the first set
my_first_set.difference_update(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
Output:
140531133254560: {1, 2, 3, 4}
140531132176192: {3, 4, 5}
140531133254560: {1, 2}
140531132176192: {3, 4, 5}

Това, което се случи, беше, както ни показва изходът, че елементите 3 и 4 на първия набор бяха елиминирани, тъй като те присъстваха и във втория набор. Нека опитаме по обратния начин и да видим какво ще се случи:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
# common elements will be eliminated from the second set
my_second_set.difference_update(my_first_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
139629253205792: {1, 2, 3, 4}
139629254282144: {3, 4, 5}
139629253205792: {1, 2, 3, 4}
139629254282144: {5}

Този път вторият комплект беше лишен от елементите, открити и в първия комплект.

Отхвърляне на елемент

Ето как да премахнете конкретен елемент от набор. Методът set.discard() се използва ефективно за постигане на тази цел. Едно важно нещо, което трябва да вземете под внимание: не предизвиква изключение, ако елементът, който трябва да бъде изхвърлен, не присъства в набора. Нито връща стойността на отхвърления елемент, ако операцията е успешна.

# define the set
my_set = {1, 2, 3, 4}
print(f"{id(my_set)}: {my_set}")
# discard an existing element
my_set.discard(3)
print(f"{id(my_set)}: {my_set}")
# now, discard a non-existing element
my_set.discard(33)
print(f"{id(my_set)}: {my_set}")
Output:
140415925709728: {1, 2, 3, 4}
140415925709728: {1, 2, 4}
140415925709728: {1, 2, 4}

Резултатът разказва цялата история, наистина.

Задава пресичане

Ако в определени моменти трябва да уловим общи елементи от два набора в друг трети набор, set.intersection() е методът, към който трябва да отидем.

# define the sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
# intersect the two
my_third_set = my_first_set.intersection(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
print(f"{id(my_third_set)}: {my_third_set}")
Output:
140320506070400: {1, 2, 3, 4}
140320506070176: {3, 4, 5}
140320506071520: {3, 4}

Актуализация на кръстовището

За разлика от difference_update(), използван, когато имаме нужда, например, set_1 да бъде лишен от елементи, намерени в set_2, този intersection_update() метод, приложен към set_1, гарантира, че set_1 няма да съдържа нищо друго освен елементите, които има общи с set_2:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
print(f"{id(my_first_set)}: {my_first_set}")print(f"{id(my_second_set)}: {my_second_set}")
# strip the first set of elements not in the second set
my_first_set.intersection_update(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
Output:
139856151455104: {1, 2, 3, 4}
139856151454880: {3, 4, 5}
139856151455104: {3, 4}
139856151454880: {3, 4, 5}

Както се очакваше, нашият първи набор сега съдържа само елементи, които бяха намерени както в него, така и във втория набор. Нещо като кръстовище на място.

Тест за нулево пресичане

Докато сме на темата за пресичането, има метод, наречен isdisjoint(), който определя дали две групи нямат общ елемент:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
# these sets do share a couple of elements
print(my_first_set.isdisjoint(my_second_set))
# redefine the second set
my_second_set = {5, 6, 7}
# now the pair of sets shares no element
print(my_first_set.isdisjoint(my_second_set))
Output:
False
True

Тествайте дали наборът е подмножество на друг

Това е полезно, когато трябва да определим дали един набор се съдържа изцяло в друг набор:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
# second set is not a subset of the first (it also contains 5)
print(my_second_set.issubset(my_first_set))
# redefine the second set
my_second_set = {3, 4}
# this one is indeed a subset of the first
print(my_second_set.issubset(my_first_set))
Output:
False
True

Тествайте дали наборът е надмножество на друг

Същият принцип, противоположен ъгъл. Това определя дали един набор съдържа напълно друг набор:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
# first set isn't a superset (second set contains 5)
print(my_first_set.issuperset(my_second_set))
# redefine the second set
my_second_set = {3, 4}
# first set is now a superset of the second set
print(my_first_set.issuperset(my_second_set))
Output:
False
True

Пускане на елемент от комплекта

Методът set.pop() премахва (и също връща) елемент от набора. Внимавайте обаче, тъй като наборите не са подредени и виждайки, че set.pop() не приема аргументи, следователно изважда привидно случаен елемент от набора:

# define our set
my_set = {1, 2, 3, 4}
print(f"{id(my_set)}: {my_set}")
# pop an element from the set and then print it out
popped_element = my_set.pop()
print(popped_element)
print(f"{id(my_set)}: {my_set}")
Output:
140309932172672: {1, 2, 3, 4}
1
140309932172672: {2, 3, 4}

Премахнете елемент от набора

Подобно на set.discard(), този също премахва елемент от набора. Въпреки това, за разлика от set.discard(), set.remove() също предизвиква изключение, ако посоченият елемент не се съдържа в набора:

# define our set
my_set = {1, 2, 3, 4}
print(f"{id(my_set)}: {my_set}")
# remove 1 from the set
my_set.remove(1)
print(f"{id(my_set)}: {my_set}")
# remove 5 from the set
my_set.remove(5)
Output:
140485046752640: {1, 2, 3, 4}
140485046752640: {2, 3, 4}
Traceback (most recent call last):
  ...
    my_set.remove(5)
KeyError: 5

Симетрична разлика

Това връща набор, съдържащ елементите, които съществуват само в един от двата набора:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
# calculate symmetric difference of first and second set
my_third_set = my_first_set.symmetric_difference(my_second_set)
# calculate symmetric difference of second and first set
my_fourth_set = my_second_set.symmetric_difference(my_first_set)
# print out the results
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
print(f"{id(my_third_set)}: {my_third_set}")
print(f"{id(my_fourth_set)}: {my_fourth_set}")
Output:
140226603695008: {1, 2, 3, 4}
140226602616640: {3, 4, 5}
140226602618656: {1, 2, 5}
140226602651712: {1, 2, 5}

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

Актуализация на симетрична разлика

Това е много подобно на представения по-рано symmetric_difference(), с единственото изключение, че този е in-place symmetric_difference(), което означава, че не връща нищо, но изпълнява операцията върху един от двата въпросни комплекта:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {3, 4, 5}
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
# perform symmetric difference and store it in the first set
my_first_set.symmetric_difference_update(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
Output:
140468212136864: {1, 2, 3, 4}
140468211058496: {3, 4, 5}
140468212136864: {1, 2, 5}
140468211058496: {3, 4, 5}

Задайте съюз

Това прави точно това, което подсказва името му: извършва обединението на два набора (или на набор и друг итерируем, било то списък или кортеж, например):

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {5, 6, 7}
# perform the union
my_third_set = my_first_set.union(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
print(f"{id(my_third_set)}: {my_third_set}")
Output:
140592551660448: {1, 2, 3, 4}
140592550582080: {5, 6, 7}
140592550584096: {1, 2, 3, 4, 5, 6, 7}

Задайте актуализация

Като union(), но този не връща нищо. Това е съюз на място:

# define our sets
my_first_set = {1, 2, 3, 4}
my_second_set = {5, 6, 7}
# perform the union of the first set and the second set
my_first_set.update(my_second_set)
print(f"{id(my_first_set)}: {my_first_set}")
print(f"{id(my_second_set)}: {my_second_set}")
Output:
140048657238944: {1, 2, 3, 4, 5, 6, 7}
140048656160576: {5, 6, 7}

Това беше доста дълго пътуване в територията на наборите на Python. Но ние се върнахме малко по-осведомени в този аспект. Което е и целта на тази статия. Ще се видим на следващия. Дотогава бъдете в безопасност и щастливо кодиране!

Повече съдържание в PlainEnglish.io. Регистрирайте се за нашия безплатен седмичен бюлетин. Следвайте ни в Twitter и LinkedIn. Присъединете се към нашата общност Discord.