Какво представлява набор в Python и как да го създадете

Наборът на Python е уникален литерал за филтриране на различни стойности в списък или масив от елементи. За разлика от списък, речник или кортеж на Python, той не приема дубликати. Така че може да бъде ценен инструмент за почистване на данни.

Но как можете да създадете набор и да го използвате в Python? Ще обясним това в този пост.

Характеристики на Python комплекти

Освен че не приема дубликати, набор от литерали има и други характеристики, които го отличават от другите типове данни. Ето някои от неговите характеристики:

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

Как да създадем и използваме набор от Python

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

Използвате фигурни скоби, за да създадете набор в Python. Така че набор е списък на елементи в къдрави скоби, разделени със запетаи:

mySet = {1, 2, "MUO", "Google"}
печат (mySet)
Изход: {1, 2, "MUO", "Google"}

Можете също да конвертирате всеки друг тип данни в набор. Например, кодът по-долу преобразува списък в набор:

myList = [1, 2, "MUO", "Google"]
mySet = set (myList)
печат (mySet)
Изход: {1, 2, "MUO", "Google"}

За да сте сигурни, можете да проверите типа данни на mySet:

myList = [1, 2, "MUO", "Google"]
mySet = set (myList)
печат (тип (mySet))
Изход: 

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

Кодът по-долу премахва дубликатите в списък и представя изхода като набор от Python:

myList = [1, 2, 2 „MUO“, „MUO“, „Google“, „Google“]
mySet = set (myList)
печат (mySet)
Изход: {1, 2, 'MUO', 'Google'}

За да демонстрира по-нататък функцията за филтриране на набор, когато отпечатвате дължината на набор, той не отчита дублиращи се стойности:

mySet = {1, 2, 2, "MUO", "MUO", "Google", "Google"}
печат (len (mySet))
Изход: 4

За да видим по-добър случай на използване на набор, нека премахнем дубликатите в следващия масив. Това е като да запитвате уникалните ключове в масив.

За да направите това, конвертирайте речник в набор:

myDiction = {
"Mango": 2, "Orange": 2, "морков": 2, "MUO": "tech",
"MUO": "уеб", "Google": "търсене", "Google": "двигател"
}
uniqueSet = set (myDiction)
print ("Това са уникалните ключове: {}". format (uniqueSet))
Резултат: Това са уникалните ключове: {'Google', 'Mango', 'MUO', 'Orange', 'carrot'}

Преобразуването по-горе автоматично премахва дублирани елементи от масива.

Можете да промените кода по-горе използвайки цикъл for за да стане по-ясно:

за уникати в uniqueSet:
печат (уникати)

Можете също да се присъедините към два комплекта с съюз () метод:

setA = {1, 3, 5}
setB = {1, 4, 6}
newSet = setA.union (setB)
печат (newSet)
Изход: {1, 3, 4, 5, 6}

Кодът по-горе обаче обединява двата набора и премахва дублиращи се стойности.

Като алтернатива можете да използвате тръбата | функция за присъединяване на набори в Python:

setA = {1, 3, 5}
setB = {1, 4, 6}
newSet = setA | setB
печат (newSet)
Изход: {1, 3, 4, 5, 6}

Можете също да намерите разликата между два набора в Python:

setA = {1, 3, 5}
setB = {2, 4, 5,}
печат (setA.difference (setB))
Изход: {1, 3}

Можете да намерите симетричната разлика между множества A и B. Този метод връща елементите от който и да е набор, но изключва техните пресичания. Нека да видим как работи това:

setA = {1, 3, 5}
setB = {2, 4, 5,}
печат (setA ^ setB)
Изход: {1, 2, 3, 4}

Като алтернатива можете да използвате symmetric_difference () метод:

setA = {1, 3, 5}
setB = {2, 4, 5,}
печат (setA.symmetric_difference (setB))
Изход: {1, 2, 3, 4}

Нека също да видим как можете да намерите пресечната точка на множествата по-долу:

setA = {1, 3, 5}
setB = {1, 4, 6}
setC = {1, 5, 4}
newSet = setA. intersection (setB, setC)
печат (newSet)
Изход: {1}

Докато можете добавяне към списък в Python, не можете да направите същото нещо за набор от Python. Можете обаче да добавите елемент в края на набор с помощта на добавете функция.

Но Python добавете функция приема един аргумент, така че можете да добавите само кортеж към набор. Това връща вложен набор:

setA = {1, 3, 5} setC = {1, 3}
newSet = 1, 6
setC.add (newSet)
печат (setC)
Изход: {1, (1, 6), 3}

Наборът на Python използва isdisjoint () метод, за да се провери дали два набора не са свързани. След това връща булева стойност:

setA = {1, 3, 5}
setB = {1, 4, 6}
findDisjoint = setA.isdisjoint (setB)
print ("Това {} е, че setA е пресечна точка от B" .format (findDisjoint))
Резултат: Невярно е, че setA е пресечна точка от B

За да проверите дали даден набор е подмножество на друг, заменете isdisjoint () с issubset ():

findSubset = setA.issubset (setB)

Можете да премахнете елемент от набор:

setA = {1, 3, 5}
setA.remove (5)
печат (setA)
Изход: {1, 3}

The изчисти () метод изчиства елементите в набор и връща празен набор:

setA = {1, 3, 5}
setA.clear ()
печат (setA)
Изход: set ()

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

setA = {1, 3, 5}
печат (setA.pop ())

Можете също така да актуализирате набор от Python с метода update ():

setA = {1, 'b'}
setB = {2, 4, 5,}
печат (setA.update (setB))
печат (setA)
Изход: {1, 2, 4, 5, 'b'} 

Играйте наоколо с набори от Python

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

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

Как работят масивите и списъците в Python

Масивите и списъците са едни от най-полезните структури от данни при програмирането - въпреки че малко хора ги използват с пълния си потенциал.

Прочетете Напред

За автора