Множество в Python — это коллекция неупорядоченных элементов. Каждый элемент множества должен быть уникальным, неизменяемым, и множества не хранят дублирующиеся элементы. Множества являются изменяемыми, что означает, что мы можем изменять их после создания.

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

Создание множества в Python

Множество можно создать, заключив разделенные запятыми неизменяемые элементы в фигурные скобки {}. Python также предоставляет метод set(), который можно использовать для создания множества по переданной последовательности.

Пример 1: Использование фигурных скобок

Days = {«Monday», «Tuesday», «Wednesday», «Thursday», «Friday», «Saturday», «Sunday»}
print(Days)
print(type(Days))
print(«looping through the set elements … «)
for i in Days:
print(i)

Вывод:

{'Friday', 'Tuesday', 'Monday', 'Saturday', 'Thursday', 'Sunday', 'Wednesday'}

looping through the set elements …
Friday
Tuesday
Monday
Saturday
Thursday
Sunday
Wednesday

Пример 2: Использование метода set()

Days = set([«Monday», «Tuesday», «Wednesday», «Thursday», «Friday», «Saturday», «Sunday»])
print(Days)
print(type(Days))
print(«looping through the set elements … «)
for i in Days:
print(i)

Вывод:

{'Friday', 'Wednesday', 'Thursday', 'Saturday', 'Monday', 'Tuesday', 'Sunday'}

looping through the set elements …
Friday
Wednesday
Thursday
Saturday
Monday
Tuesday
Sunday

Он может содержать элементы любого типа, такие как целое число, число с плавающей точкой, кортеж и т.д. Но изменяемые элементы (список, словарь, множество) не могут быть членами набора. Рассмотрим следующий пример.

# Creating a set which have immutable elements
set1 = {1,2,3, «JavaTpoint», 20.5, 14}
print(type(set1))
#Creating a set which have mutable element
set2 = {1,2,3,[«Javatpoint»,4]}
print(type(set2))

Вывод:

Traceback (most recent call last)
in
4
5 #Creating a set which holds mutable elements
—-> 6 set2 = {1,2,3,[«Javatpoint»,4]}
7 print(type(set2))

TypeError: unhashable type: 'list'

В приведенном выше коде мы создали два множества, множество set1 содержит неизменяемые элементы, а set2 — один изменяемый элемент в виде списка. При проверке типа set2 возникла ошибка, что означает, что set может содержать только неизменяемые элементы.

Создание пустого множества немного отличается, потому что пустые фигурные скобки {} также используются для создания словаря. Поэтому Python предоставляет метод set(), используемый без аргумента для создания пустого множества.

# Empty curly braces will create dictionary
set3 = {}
print(type(set3))

# Empty set using set() function
set4 = set()
print(type(set4))

Вывод:

Давайте посмотрим, что произойдет, если мы предоставим дублирующий элемент в множество.

set5 = {1,2,4,4,5,8,9,9,10}
print(«Return set with unique elements:»,set5)

Вывод:

Return set with unique elements: {1, 2, 4, 5, 8, 9, 10}

В приведенном выше коде мы видим, что set5 состоял из нескольких дублирующихся элементов, когда мы напечатали его, мы удалили дубликаты из множества.

Добавление элементов в множество

Python предоставляет методы add() и update(), которые можно использовать для добавления определенного элемента в набор. Метод add() используется для добавления одного элемента, а метод update() — для добавления нескольких элементов в множество. Рассмотрим следующий пример.

Пример: 1 — Использование метода add()

Months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(months)
print(»
Adding other months to the set…»);
Months.add(«July»);
Months.add («August»);
print(»
Printing the modified set…»);
print(Months)
print(»
looping through the set elements … «)
for i in Months:
print(i)

Вывод:

printing the original set …
{'February', 'May', 'April', 'March', 'June', 'January'}

Adding other months to the set…

Printing the modified set…
{'February', 'July', 'May', 'April', 'March', 'August', 'June', 'January'}

looping through the set elements …
February
July
May
April
March
August
June
January

Чтобы добавить более одного элемента в набор, Python предоставляет метод update(). В качестве аргумента он принимает iterable.

Рассмотрим следующий пример.

Пример — 2 Использование функции update()

Months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(Months)
print(»
updating the original set … «)
Months.update([«July»,»August»,»September»,»October»]);
print(»
printing the modified set … «)
print(Months);

Вывод:

printing the original set …
{'January', 'February', 'April', 'May', 'June', 'March'}

updating the original set …
printing the modified set …
{'January', 'February', 'April', 'August', 'October', 'May', 'June', 'July', 'September', 'March'}

Удаление элементов из набора

Python предоставляет метод discard() и метод remove(), которые можно использовать для удаления элементов из множества. Разница между этими функциями заключается в том, что при использовании функции discard(), если элемент не существует в наборе, то множество останется неизменным, в то время как метод remove() выдаст ошибку.

Рассмотрим следующий пример.

Пример-1 Использование метода discard()

months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(months)
print(»
Removing some months from the set…»);
months.discard(«January»);
months.discard(«May»);
print(»
Printing the modified set…»);
print(months)
print(»
looping through the set elements … «)
for i in months:
print(i)

Вывод:

printing the original set …
{'February', 'January', 'March', 'April', 'June', 'May'}

Removing some months from the set…

Printing the modified set…
{'February', 'March', 'April', 'June'}

looping through the set elements …
February
March
April
June

Python также предоставляет метод remove() для удаления элемента из набора. Рассмотрим следующий пример удаления элементов с помощью метода remove().

Пример-2 Использование функции remove()

months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(months)
print(»
Removing some months from the set…»);
months.remove(«January»);
months.remove(«May»);
print(»
Printing the modified set…»);
print(months)

Вывод:

printing the original set …
{'February', 'June', 'April', 'May', 'January', 'March'}

Removing some months from the set…

Printing the modified set…
{'February', 'June', 'April', 'March'}

Мы также можем использовать метод pop() для удаления элемента. Как правило, метод pop() всегда удаляет последний элемент, но набор неупорядочен, и мы не можем определить, какой элемент будет удален из множества.

Рассмотрим следующий пример удаления элемента из множества с помощью метода pop().

Months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(Months)
print(»
Removing some months from the set…»);
Months.pop();
Months.pop();
print(»
Printing the modified set…»);
print(Months)

Вывод:

printing the original set …
{'June', 'January', 'May', 'April', 'February', 'March'}

Removing some months from the set…

Printing the modified set…
{'May', 'April', 'February', 'March'}

• В приведенном выше коде последним элементом множества Month является March, но метод pop() удалил June и January, потому что набор неупорядочен и метод pop() не смог определить последний элемент набора.
• Python предоставляет метод clear() для удаления всех элементов из набора.
• Рассмотрим следующий пример.

Months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(Months)
print(»
Removing all the items from the set…»);
Months.clear()
print(»
Printing the modified set…»)
print(Months)

Вывод:

printing the original set …
{'January', 'May', 'June', 'April', 'March', 'February'}

Removing all the items from the set…

Printing the modified set…
set()

Несмотря на то, что метод discard() и remove() выполняют одну и ту же задачу, между discard() и remove() есть одно основное различие.

Если ключ, который нужно удалить из множества с помощью метода discard(), не существует в множестве, Python не выдаст ошибку. Программа сохраняет свой поток управления.

С другой стороны, если элемент, который нужно удалить из множества с помощью remove(), не существует в наборе, Python выдаст ошибку.

Рассмотрим следующий пример.

Months = set([«January»,»February», «March», «April», «May», «June»])
print(»
printing the original set … «)
print(Months)
print(»
Removing items through discard() method…»);
Months.discard(«Feb»); #will not give an error although the key feb is not available in the set
print(»
printing the modified set…»)
print(Months)
print(»
Removing items through remove() method…»);
Months.remove(«Jan») #will give an error as the key jan is not available in the set.
print(»
Printing the modified set…»)
print(Months)

Вывод:

printing the original set …
{'March', 'January', 'April', 'June', 'February', 'May'}

Removing items through discard() method…

printing the modified set…
{'March', 'January', 'April', 'June', 'February', 'May'}

Removing items through remove() method…
Traceback (most recent call last):
File «set.py», line 9, in
Months.remove(«Jan»)
KeyError: 'Jan'

Операции с множествами в Python

С множеством можно выполнять такие математические операции, как объединение, пересечение, разность и симметричная разность. Python предоставляет возможность выполнять эти операции с помощью операторов или методов.

Объединение двух множеств в Python

Объединение двух множеств вычисляется с помощью оператора pipe (|). Объединение двух множеств содержит все элементы, которые присутствуют в обоих множествах.

Рассмотрим следующий пример для вычисления объединения двух множеств.

Пример 1: использование оператора union |

Days1 = {«Monday»,»Tuesday»,»Wednesday»,»Thursday», «Sunday»}
Days2 = {«Friday»,»Saturday»,»Sunday»}
print(Days1|Days2) #printing the union of the sets

Вывод:

{'Friday', 'Sunday', 'Saturday', 'Tuesday', 'Wednesday', 'Monday', 'Thursday'}

Python также предоставляет метод union(), который также можно использовать для вычисления объединения двух множеств. Рассмотрим следующий пример.

Пример 2: использование метода union()

Days1 = {«Monday»,»Tuesday»,»Wednesday»,»Thursday»}
Days2 = {«Friday»,»Saturday»,»Sunday»}
print(Days1.union(Days2)) #printing the union of the sets

Вывод:

{'Friday', 'Monday', 'Tuesday', 'Thursday', 'Wednesday', 'Sunday', 'Saturday'}

Пересечение двух множеств в Python

Пересечение двух множеств может быть выполнено с помощью оператора & или функции intersection(). Пересечение двух множеств задается как набор элементов, общих для обоих множеств.

Пример 1: Использование оператора &

Days1 = {«Monday»,»Tuesday», «Wednesday», «Thursday»}
Days2 = {«Monday»,»Tuesday»,»Sunday», «Friday»}
print(Days1&Days2) #prints the intersection of the two sets

Вывод:

{'Monday', 'Tuesday'}

Пример 2: Использование метода intersection()

set1 = {«Devansh»,»John», «David», «Martin»}
set2 = {«Steve», «Milan», «David», «Martin»}
print(set1.intersection(set2)) #prints the intersection of the two sets

Вывод:

{'Martin', 'David'}

Пример 3

set1 = {1,2,3,4,5,6,7}
set2 = {1,2,20,32,5,9}
set3 = set1.intersection(set2)
print(set3)

Вывод:

{1,2,5}

1. Метод intersection_update() удаляет из исходного множества элементы, которые не присутствуют в обоих множествах (во всех наборах, если задано несколько).
2. Метод intersection_update() отличается от метода intersection(), поскольку он изменяет исходное множество, удаляя ненужные элементы, с другой стороны, метод intersection() возвращает новое множество.
3. Рассмотрим следующий пример.

a = {«Devansh», «bob», «castle»}
b = {«castle», «dude», «emyway»}
c = {«fuson», «gaurav», «castle»}

a.intersection_update(b, c)

print(a)

Вывод:

{'castle'}

Нахождение разности двух множеств в Python

Разность двух множеств можно вычислить с помощью оператора вычитания (-) или метода intersection(). Допустим, есть два множества A и B, а разность равна A-B, что означает, что в результирующем множестве будет получен тот элемент из A, которого нет в множестве B.

Пример 1: Использование оператора вычитания (-)

Days1 = {«Monday», «Tuesday», «Wednesday», «Thursday»}
Days2 = {«Monday», «Tuesday», «Sunday»}
print(Days1-Days2) #{«Wednesday», «Thursday» will be printed}

Вывод:

{'Thursday', 'Wednesday'}

Пример 2 : Использование метода difference()

Вывод:

{'Thursday', 'Wednesday'}

Симметричная разность двух множеств в Python

Симметричная разность двух множеств вычисляется с помощью оператора ^ или метода symmetric_difference(). Симметричная разность множеств, удаляет тот элемент, который присутствует в обоих множествах. Рассмотрим следующий пример:

Пример — 1: Использование оператора ^

a = {1,2,3,4,5,6}
b = {1,2,9,8,10}
c = a^b
print(c)

Вывод:

{3, 4, 5, 6, 8, 9, 10}

Пример — 2: Использование метода symmetric_difference()

a = {1,2,3,4,5,6}
b = {1,2,9,8,10}
c = a.symmetric_difference(b)
print(c)

Вывод:

{3, 4, 5, 6, 8, 9, 10}

Сравнение множеств

Python позволяет нам использовать операторы сравнения, т.е. , =, == с множествами, с помощью которых мы можем проверить, является ли множество подмножеством, супермножеством или эквивалентным другому множеству. В зависимости от элементов, присутствующих внутри множества, возвращается булево значение true или false.

Рассмотрим следующий пример.

Days1 = {«Monday», «Tuesday», «Wednesday», «Thursday»}
Days2 = {«Monday», «Tuesday»}
Days3 = {«Monday», «Tuesday», «Friday»}

#Days1 is the superset of Days2 hence it will print true.
print (Days1>Days2)

#prints false since Days1 is not the subset of Days2
print (Days1= set2
print(issubset)
issuperset = set1

Как работать с множествами в Python

Множества в Python являются структурами данных, которые содержат неповторяющиеся элементы. Множества полезны для выполнения таких операций, как объединение, пересечение и разность между двумя или более множествами. В этой статье мы рассмотрим основные операции над множествами в Python и приведем примеры их использования.

Создание множества

Множество можно создать с помощью фигурных скобок {} или с помощью встроенной функции set().

# Создаем множество с помощью фигурных скобок
my_set = {1, 2, 3, 4, 5}
print(my_set) # Вывод: {1, 2, 3, 4, 5}

# Создаем множество с помощью функции set()
my_set = set([1, 2, 3, 4, 5])
print(my_set) # Вывод: {1, 2, 3, 4, 5}

Обратите внимание, что множества не содержат повторяющихся элементов:

duplicates_set = {1, 2, 2, 3, 3, 3}
print(duplicates_set) # Вывод: {1, 2, 3}

Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Получить программу

Операции над множествами

Добавление элементов

Для добавления элемента в множество используется метод add():

my_set = {1, 2, 3}
my_set.add(4)
print(my_set) # Вывод: {1, 2, 3, 4}

Удаление элементов

Для удаления элемента из множества используются методы remove() или discard(). Разница между ними заключается в том, что remove() вызовет ошибку, если элемент не найден, а discard() выполнится без ошибок.

my_set = {1, 2, 3, 4}
my_set.remove(4)
print(my_set) # Вывод: {1, 2, 3}

my_set.discard(3)
print(my_set) # Вывод: {1, 2}

Объединение множеств

Для объединения множеств используется метод union() или оператор |.

set_a = {1, 2, 3}
set_b = {4, 5, 6}

union_set = set_a.union(set_b)
# или
union_set = set_a | set_b

print(union_set) # Вывод: {1, 2, 3, 4, 5, 6}

Пересечение множеств

Для нахождения пересечения множеств используется метод intersection() или оператор &.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

intersection_set = set_a.intersection(set_b)
# или
intersection_set = set_a & set_b

print(intersection_set) # Вывод: {3, 4}

Разность множеств

Для нахождения разности множеств используется метод difference() или оператор -.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

difference_set = set_a.difference(set_b)
# или
difference_set = set_a — set_b

print(difference_set) # Вывод: {1, 2}

Заключение

Мы рассмотрели основные операции над множествами в Python. Теперь вы знаете, как создавать множества, добавлять и удалять элементы, а также выполнять такие операции, как объединение, пересечение и разность множеств. Используйте эти знания для улучшения своего кода и обработки наборов данных. Удачи вам в изучении Python! ????

Множества в Python

Множества (set) в Python — это встроенный тип, предлагающий широкий набор возможностей, которые повторяют теорию множеств из математики. Тем не менее интерпретация может отличаться от той, что принята в математике. Set импортировать не нужно. А в этом материале вы узнаете о нем все, что потребуется для работы.

Что это

Множества — это неупорядоченная коллекция уникальных элементов, сгруппированных под одним именем. Множество может быть неоднородным — включать элементы разных типов.

Множество всегда состоит только из уникальных элементов (дубли запрещены) в отличие от списков и кортежей в Python. Объект set — это также коллекция уникальных хэшируемых объектов. Объект называется хэшируемым в том случае, если его значение хэша не меняется.

Это используется в ключах словарей и элементах множеств, ведь значения хэшей применяются в их внутренних структурах.

https://www.youtube.com/watch?v=KMGRXDxUw18\u0026pp=ygUi0JzQvdC-0LbQtdGB0YLQstCwIChzZXQpINCyIFB5dGhvbg%3D%3D

Чаще всего множества в Python используются для проверки на принадлежность, удаления повторов из последовательности и выполнения математических операций, таких как пересечение, объединение, поиск разностей и симметрических разностей. Изображение ниже показывает два примера множеств (алфавит и цифры), каждый из которых включает уникальные неизменяемые объекты.

Создание множеств Python

Создать объект set в Python можно двумя путями:

1. Использовать фигурные скобки {}
2. Использовать встроенную функцию set()

Примечание: не используйте зарезервированные ключевые слова и названия встроенных классов в качестве имен для множеств. Это не поощряется в программировании на Python.

Множество создается при размещении всех элементов внутри фигурных скобок {}, как показано на примере ниже.

s1 = {} s2 = {1, 'pythonru', 20.67}

Еще один способ создать (или определить) множество Python — использовать функцию set(). Пример ниже.

s1 = set() s2 = set({1, 'pythonru', 20.67})

Первый способ (с использованием фигурных скобок {}) определенно проще.

Нет ограничений на количество элементов в объекте set, но запрещено добавлять элементы изменяемых типов, такие как список или словарь. Если попробовать добавить список (с набором элементов), интерпретатор выдаст ошибку.

s5 = { 1, 2, 3, [5, 6, 7, 8] }
Traceback (most recent call last): File «», line 1, in
TypeError: unhashable type: 'list'

Добавление элементов в множества Python

Объекты set в Python поддерживают добавление элементов двумя путями: по одному с помощью метода add() или группами с помощью update(). Оба описаны дальше.

Добавление одного элемента в множество Python

Один элемент можно добавить с помощью метода add(). Такой код выглядит следующим образом.

set1 = {1, 3, 4}
set1.add(2)
print(set1)
{1, 2, 3, 4}

Добавление нескольких элементов в множество Python

Больше одного элемента можно добавить с помощью update(). Код следующий.

set2 = {1, 2, 3}
set2.update([4, 5, 6])
print(set2)

Удаление элементов из множеств Python

Один или несколько элементов можно удалить из объекта set с помощью следующих методов. Их отличие в виде возвращаемого значения.

Метод remove() полезен в тех случаях, когда нужно удалить из множества конкретный элемент и вернуть ошибку в том случае, если его нет в объекте.

Следующий код показывает метод remove() в действии.

set1 = {1, 2, 3, 4, 'a', 'p'}
set1.remove(2)
print(set1) {1, 3, 4, 'a', 'p'} set1.remove(5)

discard()

Метод discard() полезен, потому что он удаляет конкретный элемент и не возвращает ошибку, если тот не был найден во множестве.

set1 = {1, 3, 4, 'a', 'p'} set1.discard('a')
print(set1) set1.discard(6)
print(set1)

pop()

Метод pop() удаляет по одному элементу за раз в случайном порядке. Set — это неупорядоченная коллекция, поэтому pop() не требует аргументов (индексов в этом случае). Метод pop() можно воспринимать как неконтролируемый способ удаления элементов по одному из множеств в Python.

set1 = {1, 3, 4, “p”} set1.pop()
3

Методы множеств Python

У объектов set есть несколько встроенных методов. Увидеть их все можно с помощью команды dir(). dir(object) в Python показывает самые важные атрибуты разных типов объектов.

Вот что выдаст функция для объекта set в Python.

set1 = { 1, 2, 3, 4} dir(set1)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

Часто используемые функции множеств Python

Из всех методов, перечисленных в dir(), только несколько из них используются постоянно. Вы уже знакомы с add, update, remove, pop и discard.

Вот на какие также стоит обратить внимание.

Функция принадлежности (членства)

Она проверяет на наличие конкретного элемента в множестве.

num_set = {1 ,3, 5, 7, 9, 10}
7 in num_set 2 in num_set 1 not in num_set

Разные функции

len(num_set) — вернет количество элементов в объекте set.

6

copy() — создает копию существующего множества и сохраняет ее в новом объекте.

new_set = num_set.copy()

clear() —очищает множество (удаляет все элементы за раз)

num_set.clear()

del — удаляет множество целиком

del num_set

Дальше речь пойдет об операциях union, issubset, issuperset, difference_update и других.

Операции множеств в Python

В этом разделе вы узнаете о разных операциях над множествами, которые являются частью теории множеств.

Объединение множеств

При использовании на двух множествах вы получаете новый объект, содержащий элементы обоих (без повторов). Операция объединения в Python выполняется двумя способам: с помощью символа | или метода union().

A = {1, 2, 3}
B = {2, 3, 4, 5}
C = A | B C = A.union(B) print(C)

Пересечение множеств

При использовании на двух множествах вы получаете новый объект, содержащий общие элементы обоих (без повторов). Операция пересечения выполняется двумя способами: с помощью символа & или метода intersection().

A = {1, 2, 3, 4}
B = {3,4,5,6}
C = A & B C = A.intersection(B) print(C)

Разность множеств

При использовании на двух множествах вы получаете новый объект, содержащий элементы, которые есть в первом, но не втором (в данном случае — в множестве “A”). Операция разности выполняется двумя способами: с помощью символа — или метода difference().

A = {1, 2, 3, 4} B = {3,4,5,6}
C = A — B C = A.difference(B) print(C)

Симметричная разность множеств

При использовании на двух множествах вы получаете новый объект, содержащий все элементы, кроме тех, что есть в обоих. Симметрическая разность выполняется двумя способами: с помощью символа ^ или метода symmetric_difference().

C = A ^ B C = A.symmetric_difference(B) print(C)

Подмножество и надмножество в Python

Множество B (SetB) называется подмножество A (SetA), если все элементы SetB есть в SetA. Проверить на подмножество в Python можно двумя способами: с помощью символа = B A.issuperset(B)

Бонус

А теперь бонус для тех, кто дочитал до этого места. Многие начинающие программисты задаются вопросом, как удалить повторяющиеся элементы из списка?

Ответ: просто передайте список функции set() и все дубли будут удалены автоматически. Результат потом можно снова передать в функцию list(), чтобы он снова стал списком.

List1 = [1, 2, 3, 5, 3, 2, 4, 7]
List_without_duplicate = set(List1)
print(List_without_duplicate) back_to_list = list(List_without_duplicate)

Выводы

Теперь вы знакомы с объектами set в Python и теорией множеств на практике. Знаете как создавать множества, менять их, добавляя или удаляя элементы. Вы также знаете, как использовать метод dir и другие методы для множеств в Python. Наконец, познакомились с операциями union, intersection, difference, symmetric difference, subset и superset.

Множество (set) в Python

Вы здесь:
Главная — Python — Основы Python — Множество (set) в Python

На этом уроке мы познакомимся с ещё одним типом данных в Python, множеством (по-английски — set). Множество — это неупорядоченный набор уникальных элементов. Этими двумя характеристиками множество и отличается от списков. Для освежения в памяти, можете заглянуть на урок Работа со списками в Python.

Создание множества в Python

Множества выводятся в фигурных скобках, через запятую.

a = {1, 3, 5, 7}
print(a)

{1, 3, 5, 7}

А если мы так запишем — продублируем все элементы. Поскольку множество не должно содержать повторяющиеся элементы, то все дубли были автоматически удалены.

# целые числа
b = {1, 3, 5, 7, 1, 3, 5, 7 }
print(b)
{1, 3, 5, 7} # строки
c = {'ok', 'no', 'yes', 'ok', 'no', 'yes'}
print(c)

{'ok', 'no', 'yes'}

Преобразование строки в множество

Функция set разбивает строку на символы, а из символов формирует множество. Мы видим, что символы на выходе расположились в случайном порядке и убрались дубли (буква о). Обратите внимание, что строка заключена в круглые скобки. Вспоминаем, что после функции всегда идут круглые скобки.

d = set('множество')
print(d)

{'о', 'ж', 'т', 'н', 'с', 'м', 'е', 'в'}

Преобразование списка в множество

f = set([11, 12, 13, 14, 12, 13])
print(f)
{11, 12, 13, 14} e = set(['list', 'set', 'and', 'set'])
print(e)

{'and', 'list', 'set'}

Создание пустого множества

q = set()
print(q)

set()

Добавление элемента в множество

Метод add добавит элемент в множество. При попытке добавить дублирующий элемент, ничего не изменится.

w = {3, 4, 9}
w.add(11)
print(w)

{11, 9, 3, 4}

Если нужно добавить в множество одновременно несколько элементов, то используют метод update.

t = {5, 6, 10}
t.update([12, 15, 17])
print(t)

{5, 6, 10, 12, 15, 17}

Удаление элемента из множества

Метод discard удаляет указанный элемент в скобках.

y = {20, 21, 22}
y.discard(21)
print(y)

{20, 22}

Метод remove делает тоже самое.

p = {27, 28, 29}
p.remove(27)
print(p)

{28, 29}

Но разница между двумя методами все же есть. При попытке удаления несуществующего элемента методом discard никакой ошибки не будет. А при удалении с помощью метода remove, возникнет ошибка.

u = {23, 24, 25}
u.discard(26)
print(u)
{24, 25, 23} s = {27, 28, 29}
s.remove(30)
print(s)

KeyError: 30

Метод pop удаляет случайный элемент, аргументы внутри скобок не передаются.

g = {27, 28, 29}
g.pop()
print(g)

{28, 29}

Метод clear очищает все элементы множества.

h = {31, 32, 33}
h.clear()
print(h)

set()

Найти длину множества в Python

Функция len подсчитает количество элементов в множестве.

k = {34, 35, 36, 37}
print(len(k))

4

Пересечение множеств в Python

Оператор амперсанд (&) ищет одинаковые элементы в нескольких множествах и формирует новое множество, состоящее из пересекаемых элементов. Если пересекаемых элементов нет, то выводится пустое множество.

l = {38, 39, 40, 41}
z = {42, 39, 40, 43}
print(l & z)
{40, 39} x = {44, 45, 46, 47}
c = {48, 49, 50, 51}
print(x & c)

set()

Объединение множеств в Python

Оператор вертикальная черта (|) объединяет элементы нескольких множеств в одно, удаляя дубли.

v = {52, 53, 54, 55}
b = {55, 56, 57, 58}
print(v | b)
{52, 53, 54, 55, 56, 57, 58}

Метод union является аналогичным способом объединения множеств.

n = {59, 60, 61}
m = {62, 63, 64}
print(n.union(m))

{64, 59, 60, 61, 62, 63}

Сравнение множеств в Python

Результат сравнения вернет True, если элементы одного множества,
идентичны элементам другого множества.

one = {71, 72, 73}
two = {71, 72, 73}
print(one == two)
True q = {65, 66, 67}
z = {68, 69, 70}
print(q == z)

False

В множестве нельзя к элементам обратиться по индексу, ведь коллекция неупорядоченная.

Предыдущая статья Следующая статья

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

1. Кнопка:

   Она выглядит вот так:

2. Текстовая ссылка:Как создать свой сайт

   Она выглядит вот так: Как создать свой сайт

3. BB-код ссылки для форумов (например, можете поставить её в подписи):
   [URL=»https://myrusakov.ru»]Как создать свой сайт[/URL]

Множества, словари — Основы Python

Рассмотрим ещё одну коллекцию Python — множество (set). Чтобы задать множество, можно перечислить его элементы внутри фигурных скобок. Например, создадим множество гласных букв русского алфавита:

vowels = {«а», «е», «ё», «и», «о», «у», «ы», «э», «ю», «я»}

Для создания пустого множества следует использовать функцию set() без аргументов, а для определения количества элементов используется уже известная нам функция len():

empty_set = set()
print(f»Длина пустого множества равна {len(empty_set)}.»)

Вывод программы:

Длина пустого множества равна 0.

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

word = «коллекция»
letters = set(word)
print(letters)

Выполнив программу два раза, получим следующий вывод программы:

{'е', 'о', 'и', 'я', 'к', 'л', 'ц'}
{'л', 'к', 'и', 'ц', 'я', 'е', 'о'}

Обратите внимание: порядок вывода элементов множества при выполнении примера может меняться произвольно из-за свойства неупорядоченности множества. Так, элементы множества не имеют индексов, и можно только проверить принадлежность элемента множеству.

• Другое свойство множества — уникальность его элементов: они не имеют дублей.
• В итоге в примере мы получили множество уникальных букв слова, потеряв при этом порядок.
• Проверить, принадлежит ли значение множеству, можно с помощью оператора in.
• Узнаем, принадлежит ли введённая буква русского алфавита к гласным:

vowels = {«а», «е», «ё», «и», «о», «у», «ы», «э», «ю», «я»}
letter = input(«Введите букву русского алфавита: «)
if letter.lower() in vowels: print(«Гласная буква»)
else: print(«Согласная буква»)

По элементам множества можно пройти в цикле:

vowels = {«а», «е», «ё», «и», «о», «у», «ы», «э», «ю», «я»}
for letter in vowels: print(letter)

Выполнив пример несколько раз, мы снова видим разную последовательность вывода букв.

Множества в Python позволяют выполнять следующие операции:

• Объединение множеств. Возвращает множество, состоящее из элементов всех объединяемых множеств. Обозначается union() или |. Графическое представление операции:Пример:s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_union = s_1 | s_2 print(s_union)
  Вывод программы:{1, 2, 3, 4, 5}
• Пересечение множеств. Возвращает множество, состоящее из общих элементов пересекаемых множеств. Обозначается intersection или &. Графическое представление операции:Пример:s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_intersection = s_1 & s_2 print(s_intersection)
  Вывод программы:{3}
• Разность множеств. Возвращает множество, где указаны элементы из первого множества, которых нет во втором — вычитаемом — множестве. Обозначается difference или -. Графическое представление операции:Пример:s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_dif = s_1 — s_2 print(s_dif)
  Вывод программы:{1, 2}
• Симметричная разность множеств. Возвращает множество, состоящее из элементов, встречающихся в первом или втором множестве, но не в обоих сразу. Обозначается symmetric_difference или ^.Пример:s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_sym_dif = s_1 ^ s_2 print(s_sym_dif)
  Вывод программы:{1, 2, 4, 5}

В качестве примера использования множеств и их операций определим, какие гласные буквы встречаются в слове «коллекция»:

vowels = {«а», «е», «ё», «и», «о», «у», «ы», «э», «ю», «я»}
letters = set(«коллекция»)
print(«, «.join(letters & vowels))

Вывод программы:

о, я, и, е

Для множеств Python доступны следующие операции сравнения:

• Совпадение двух множеств. Обозначается ==. Пример:

s_1 = {1, 2, 3}
s_2 = {3, 1, 2}
print(s_1 == s_2)

Вывод программы:

True

• Подмножество. Все элементы первого множества есть во втором. Обозначается = s_1)
  Вывод программы:TrueМножество является изменяемой коллекцией. Методы, изменяющие исходное множество, перечислены в следующей таблице.
  МетодОписаниеПримерВывод

  set.add(e)	Добавить элемент во множество	s = set()s.add(1)print(s)	{1}
  set.remove(e)	Удалить элемент множества. Возвращает исключение KeyError, если элемент не принадлежит множеству	s = {1, 2, 3}s.remove(2)print(s)	{1, 3}
  set.discard(e)	Удалить элемент, если он принадлежит множеству	s = {1, 2, 3}s.discard(2)print(s)	{1, 3}
  set.pop()	Вернуть и удалить произвольный элемент множества	s = {1, 2, 3}x = s.pop()print(x)print(s)	2{1, 3}
  set.clear()	Очистить множество, удалив все его элементы	s = {1, 2, 3}s.clear()print(s)	set()

  Чтобы перейти к ещё одной коллекции, рассмотрим пример: пусть в программе нужно хранить информацию о странах и их столицах. Эту задачу можно решить и с помощью известных нам коллекций. К примеру, списком, в котором элементами будут кортежи, содержащие пары значений — страну и её столицу:countries_and_capitals = [(«Россия», «Москва»), («США», «Вашингтон»), («Франция», «Париж»)]
  Представим, что в такой программе нам необходимо вывести столицу для какой-то страны, например для Франции. Тогда нам придётся пройти в цикле по списку кортежей, сравнивая нулевой элемент каждого кортежа со строкой «Франция». Когда такой кортеж будет найден, мы выведем первый элемент этого кортежа, содержащий строку с названием столицы:countries_and_capitals = [(«Россия», «Москва»), («США», «Вашингтон»), («Франция», «Париж»)]
  for country in countries_and_capitals: if country[0] == «Франция»: print(country[1]) break
  Было бы неплохо, если бы мы могли взять из коллекции значение (название столицы в нашем примере) по названию страны, то есть не по числовому индексу, а по строке. Такая коллекция есть в Python. Она называется «словарь» (dict). Словарь похож на список, но вместо индексов элементов в словаре используются ключи, а по ключам в словаре хранятся значения.Благодаря словарям нашу программу можно переписать, используя в качестве ключей словаря названия стран, а в качестве значений по ключам — названия столиц этих стран:countries_and_capitals = {«Россия»: «Москва», «США»: «Вашингтон», «Франция»: «Париж»}
  print(countries_and_capitals[«Франция»])
  Как видно из программы, для создания словаря можно перечислить в фигурных скобках пары: ключ и значение. Ключ и значение отделяются двоеточием и пробелами, а пары перечисляются через запятую.В качестве ключей можно использовать значения неизменяемого типа: числа, строки, кортежи. Значения по ключу могут быть любого типа данных.Чтобы взять значение по ключу, необходимо указать ключ в квадратных скобках после имени словаря.Если же нужно добавить новый ключ в словарь, то его указывают после имени словаря в левой части операции присваивания, а значение, которое будет храниться по этому ключу, — в правой части:countries_and_capitals = {«Россия»: «Москва», «США»: «Вашингтон», «Франция»: «Париж»}
  countries_and_capitals[«Сербия»] = «Белград»
  print(countries_and_capitals)
  Обратите внимание, при записи значения по уже существующему ключу он создаётся заново с новым значением, а прошлый стирается:d = {«key»: «old_value»}
  d[«key»] = «new_value»
  print(d[«key»])
  Вывод программы:new_valueПри попытке взять значение по несуществующему ключу происходит исключение KeyError:countries_and_capitals = {«Россия»: «Москва», «США»: «Вашингтон», «Франция»: «Париж»}
  print(countries_and_capitals[«Сербия»])
  Вывод программы:KeyError: 'Сербия'Для проверки существования ключа в словаре следует использовать уже известный нам оператор in:countries_and_capitals = {«Россия»: «Москва», «США»: «Вашингтон», «Франция»: «Париж»}
  if «Сербия» in countries_and_capitals: print(countries_and_capitals[«Сербия»])
  else: print(«Страна пока не добавлена в словарь»)
  По ключам в словаре можно пройти в цикле for:countries_and_capitals = {«Россия»: «Москва», «США»: «Вашингтон», «Франция»: «Париж»}
  for country in countries_and_capitals: print(f»У страны {country} столица — {countries_and_capitals[country]}.»)
  Вывод программы:У страны Россия столица — Москва.
  У страны США столица — Вашингтон.
  У страны Франция столица — Париж.Вспомним, что значением по ключу в словаре может быть значение любого типа. Рассмотрим пример, в котором значением по ключу будет список.Пусть с клавиатуры вводятся названия стран, каждая с новой строки. При вводе возможны повторы стран. Сигналом окончания ввода будет строка «СТОП». Необходимо вывести, в каких строках (начиная с 0) встречалась каждая из стран. Для решения задачи будем использовать словарь, в котором по ключам — названиям стран будем хранить список номеров строк, в которых эти страны встречались.
  countries = dict() country = input() str_number = 0 while country != «СТОП»: if country not in countries: countries[country] = [str_number] else: countries[country].append(str_number) str_number += 1 country = input() for country in countries: print(f»{country}: {countries[country]}»)
  Пример ввода:США
  США
  Россия
  Россия
  Россия
  Франция
  Сербия
  СТОПВывод программы:США: [0, 1]
  Россия: [2, 3, 4]
  Франция: [5]
  Сербия: [6]Основные операции для словарей перечислены в следующей таблице.

  ОперацияОписаниеПримерВывод

  len(d)	Возвращает количество ключей в словаре	d = {«a»: 1, «b»: 2, «c»: 3}print(len(d))	3
  del d[key]	Удалить ключ из словаря. Если ключа нет, то вызывается исключение KeyError	d = {«a»: 1, «b»: 2, «c»: 3}del d[«b»]print(d)	{«a»: 1, «c»: 3}
  dict.clear()	Удалить все ключи и значения в словаре	d = {«a»: 1, «b»: 2, «c»: 3}d.clear()print(d)	{}
  dict.copy()	Возвращает копию словаря	d = {«a»: 1, «b»: 2, «c»: 3}d_new = d.copy()print(d_new)	{«a»: 1, «b»: 2, «c»: 3}
  dict.get(key, default)	Возвращает значение по ключу key. Если ключа нет, то возвращает значение default	d = {«a»: 1, «b»: 2, «c»: 3}print(d.get(«e», «Ключа нет в словаре»))	Ключа нет в словаре
  dict.items()	Возвращает итерируемый объект, состоящий из кортежей (ключ, значение) словаря	d = {«a»: 1, «b»: 2, «c»: 3}for key, value in d.items():    print(key, value)	a 1b 2c 3
  dict.keys()	Возвращает итерируемый объект, состоящий из ключей словаря	d = {«a»: 1, «b»: 2, «c»: 3}for key in d.keys():    print(key)	abc
  d.pop(key, default)	Возвращает значение по ключу key и удаляет его из словаря. Если ключа нет, то возвращает default	d = {«a»: 1, «b»: 2, «c»: 3}x = d.pop(«a»)print(x)	1
  dict.values()	Возвращает итерируемый объект, состоящий из значений словаря	d = {«a»: 1, «b»: 2, «c»: 3}for value in d.values():    print(value)	123

  Перепишем код примера про страны с использованием метода get():
  countries = dict() country = input() str_number = 0 while country != «СТОП»: countries[country] = countries.get(country, []) + [str_number] str_number += 1 country = input() for country in countries: print(f»{country}: {countries[country]}»)
  Метод get() позволил заменить четыре строчки программы одной. Проверьте самостоятельно, что вывод программы не изменился для прежних входных данных.

Множества в Python

Множество — неупорядоченный набор элементов. Каждый элемент в множестве уникален (т. е. повторяющихся элементов нет) и неизменяем. 

Само по себе множество можно изменять, то есть удалять или добавлять элементы. 

Множества удобно использовать для выполнения математических операций: объединение, пересечение, симметрическая разность и т. д. 

Как создать множество

Множество объявляется так: элементы помещаются в фигурные скобки {} и разделяются запятыми. Сделать это можно и с помощью встроенной функции set().

Внутри множества может быть любое количество элементов любого типа (целые числа, числа с плавающей точкой, кортежи, строки и т. д.). Внутрь множества нельзя помещать элементы изменяемых типов: списки, другие множества или словари. 

# Разные виды множеств
# Множество с целыми числами
my_set = {1, 2, 3}
print(my_set)

# Множество с разными типами данных
my_set = {1.0, «Привет», (1, 2, 3)}
print(my_set)

Вывод:

{1, 2, 3}{1.0, (1, 2, 3), 'Привет'}
# Внутри множества не может быть одинаковых элементов
# Вывод: {1, 2, 3, 4}
my_set = {1, 2, 3, 4, 3, 2}
print(my_set)

# Аргументом функции set() может быть список
# Вывод: {1, 2, 3}
my_set = set([1, 2, 3, 2])
print(my_set)

# Внутри множества не может быть изменяемых объектов
# В этом множестве [3, 4] — изменяемый список
# Поэтому следующая строка вызовет ошибку

my_set = {1, 2, [3, 4]}

Вывод:

{1, 2, 3, 4}{1, 2, 3}Traceback (most recent call last):  File «», line 15, in    my_set = {1, 2, [3, 4]}

TypeError: unhashable type: 'list'

Создание пустого множество — дело хитрое. 

Пустые фигурные скобки {} — это словарь. Чтобы объявить пустое множество, нужно использовать функцию set() без аргументов. 

# Обратим внимание на объявление пустого множества

# Объявление с помощью {}
a = {}

# Проверка типа a
print(type(a))

# Объявление с помощью set()
a = set()

# Проверка типа a
print(type(a))

Вывод:

Как изменять множество

Множества изменяемы и не упорядочены. Поэтому в индексации нет никакого смысла. 

Так что получить доступ к элементам с помощью индексов или срезов не получится. Множества просто не поддерживают эти операции.

Чтобы добавить один элемент, нужно использовать метод add(). Если нужно добавить несколько элементов — метод update(). Метод update() принимает в качестве аргументов кортежи, списки или другие множества. Во всех случаях следует избегать одинаковых элементов. 

# создаем my_set
my_set = {1, 3}
print(my_set)

# вызов my_set[0] приведет к ошибке
# TypeError: 'set' object does not support indexing

# добавляем элемент
# Вывод: {1, 2, 3}
my_set.add(2)
print(my_set)

# добавляем несколько элементов
# Вывод: {1, 2, 3, 4}
my_set.update([2, 3, 4])
print(my_set)

# добавляем список и множество
# Вывод: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4, 5], {1, 6, 8})
print(my_set)

Вывод:

{1, 3}{1, 2, 3}{1, 2, 3, 4}

{1, 2, 3, 4, 5, 6, 8}

Как удалять элементы из множества 

Определенный элемент множества можно удалить с помощью методов discard() и remove().

Разница между ними вот в чем. Если элемент, который вы хотите удалить с помощью discard(), отсутствует в множестве — оно не изменится. А вот remove() вызовет ошибку, если элемента нет в множестве.

# разница между discard() и remove()

# создаем my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)

# удаление элемента
# с помощью discard
# Вывод: {1, 3, 5, 6}
my_set.discard(4)
print(my_set)

# удаление элемента
# с помощью remove

# Вывод: {1, 3, 5}
my_set.remove(6)
print(my_set)

# удаление элемента,
# отсутствующего в my_set,
# с помощью discard
# Вывод: {1, 3, 5}
my_set.discard(2)
print(my_set)

# При удалении элемента,
# отсутствующего в my_set,
# с помощью remove
# вы получите ошибку.

# Вывод: KeyError

my_set.remove(2)

Вывод:

{1, 3, 4, 5, 6}{1, 3, 5, 6}{1, 3, 5}{1, 3, 5}Traceback (most recent call last):  File «», line 28, in

KeyError: 2

Удалить и вернуть элемент мы можем с помощью метода pop().

Так как множество — неупорядоченный тип данных, невозможно определить, какой из элементов будет удален. Это произойдет случайным образом.

Удалить все элементы из множества можно с помощью метода clear().

# cоздаем my_set
# Вывод: множество уникальных элементов
my_set = set(«Приветмир»)
print(my_set)

# pop элемента
# Вывод: случайный элемент
print(my_set.pop())

# pop еще одного элемента
my_set.pop()
print(my_set)

# очищаем my_set
# Вывод: set()
my_set.clear()
print(my_set)

Вывод:

{'П', 'и', 'р', 'т', 'е', 'м', 'в'}П{'р', 'т', 'е', 'м', 'в'}

set()

Операции со множествами 

Множества можно использовать для выполнения математических операций вроде объединения, пересечения, симметрической разности и т. д. Сделать это можно с помощью операторов и методов. 

Рассмотрим два множества и проведем с ними разные операции.

A = {1, 2, 3, 4, 5}B = {4, 5, 6, 7, 8}

Объединение