Питон множества: Множества (set и frozenset) | Python 3 для начинающих и чайников

урок по работе с множествами для начинающих ~ PythonRu

Предыдущий урок: Кортежи (tuple)

Множества — неупорядоченная и не индексируемая последовательность. В Python множества пишутся в фигурных скобках.
Создание множества:

thisset = {"set", "list", "tuple"}
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

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

Множество хранит только уникальные элементы:

thisset = {"set", "list", "tuple", "list"}
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

Доступ к элементам

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

thisset = {"set", "list", "tuple"}
for x in thisset:  
    print(x)

Вывод:

set
list
tuple

Проверим присутствует ли "dict" этой последовательности:

thisset = {"set", "list", "tuple"}
print("dict" in thisset)

Вывод:

False

Изменение элементов

Вы не можете менять элементы set, но можете добавлять новые.

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

Чтобы добавить один элемент в set используйте метод add().
Чтобы добавить больше одного — метод update().

thisset = {"set", "list", "tuple"}
thisset.add("dict")  
print(thisset)

Вывод:

{'tuple', 'set', 'list', 'dict'}

Добавьте несколько элементов в thisset, используя метод update():

thisset = {"set", "list", "tuple"}
thisset.update(["dict",  "class",  "int"])
print(thisset)

Вывод:

{'dict', 'tuple', 'set', 'list', 'class', 'int'}

Получите длину set

Чтобы определить сколько элементов есть в наборе, воспользуйтесь методом len().

thisset = {"set", "list", "tuple"}
print(len(thisset))

Вывод:

3

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

thisset = {"set", "list", "tuple"}
thisset. remove("list")  
print(thisset)

Вывод:

{'tuple', 'set'}

Примечание: Если элемент, который нужно удалить не существует, remove() вызовет ошибку.
Убрать “list” используя метод discard():

thisset = {"set", "list", "tuple"}
thisset.discard("list")  
print(thisset)

Вывод:

{'tuple', 'set'}

Примечание. Если элемент для удаления не существует, discard() не будет вызывать ошибку.

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

Возвращаемое значение метода pop () — это удаленный элемент.

thisset = {"set", "list", "tuple"}
x =  thisset.pop()  
print(x)  
print(thisset)

Вывод:

list
{'tuple', 'set'}

Метод clear() очистит множество:

thisset = {"set", "list", "tuple"}
thisset. clear()  
print(thisset)

Вывод:

set()

Ключевое слово del полностью удалит множество:

thisset = {"set", "list", "tuple"}
del thisset
print(thisset) # эта команда вызовет ошибку, так как thisset больше не существует

Конструктор set()

Есть так же возможность использовать конструктор set() для создания множества.

thisset = set(("set", "list", "tuple"))  # Используем двойные скобки
print(thisset)

Вывод:

{'set', 'tuple', 'list'}

Методы Set

В Python есть встроенные методы, с помощью которых вы можете работать с sets.

Метод	Значение
add(x)	Добавляет элементы x в set
clear()	Удаляет элементы из set
copy()	Возвращает копию set
x.difference(y)	Возвращает множество элементов, которые есть в х, но нет в y
x.difference_update(y)	Удаляет элементы, которые есть в x и y
discard(x)	Удаляет указанный элемент
x. intersection(y)	Возвращает множество, являющийся пересечением x и y
intersection_update(y)	Удаляет элементы в множестве, которых нет в других заданных y
x.isdisjoint(y)	True, если x и y не имеют общих элементов
x.issubset(y)	True, если все элементы из x есть в y
issuperset()	True, если все элементы из y есть в x
pop()	Удаляет и возвращает последний элемент
remove()	Удаляет указанный элемент
x.symmetric_difference(y)	Возвращает множество элементов, которые не пересекаются в х и y
symmetric_difference_update()	Добавляет элементы, которых нет в другом множестве
union()	Объединяет несколько множеств
x.update(y, z)	Объединяет несколько множеств, перезаписывая x

Далее: Словарь (dict)

• ТЕГИ
• Уроки Python для начинающих

Максим

Я создал этот блог в 2018 году, чтобы распространять полезные учебные материалы, документации и уроки на русском. На сайте опубликовано множество статей по основам python и библиотекам, уроков для начинающих и примеров написания программ.

Python Q https://yandex.ru/q/loves/python Online

Множества, словари — Основы 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
  # s_union = s_1.union(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
  # s_intersection = s_1.  s_2
  # s_sym_dif = s_1.symmetric_difference(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 = {1, 2, 3}
s_2 = {1, 2, 3, 4}
print(s_1 <= s_2)

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

True

• Надмножество. Первое множество содержит все элементы второго. Обозначается >=. Пример:

s_1 = {1, 2, 3}
s_2 = {1, 2, 3, 4}
print(s_2 >= 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 1 b 2 c 3
dict.keys()	Возвращает итерируемый объект, состоящий из ключей словаря	d = {«a»: 1, «b»: 2, «c»: 3} for key in d.keys():     print(key)	a b c
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)	1 2 3

Перепишем код примера про страны с использованием метода get():

# создаём пустой словарь
countries = dict()
# вводим первую строку до цикла (можно заменить, использовав оператор-морж)
country = input()
# создаём счётчик номеров строк
str_number = 0
# продолжаем цикл, пока не введена строка «СТОП»
while country != "СТОП":
    # Если страна country есть среди ключей, то get() возвращает список, 
    # хранящийся по этому ключу, иначе get() возвращает пустой список. 
    # Добавляем в список значение str_number.
    countries[country] = countries.get(country, []) + [str_number]
    # увеличиваем счётчик
    str_number += 1
    # вводим следующую строку
    country = input()
# выводим название страны и полученные списки с новой строки
for country in countries:
    print(f"{country}: {countries[country]}")

Метод get() позволил заменить четыре строчки программы одной. Проверьте самостоятельно, что вывод программы не изменился для прежних входных данных.

Python Set

Предыдущий

Следующий

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

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

Объект набора содержит один или несколько элементов, не обязательно одного типа, разделенных запятой и заключенных в фигурные скобки {}. Следующее определяет объект набора с четными номерами.

 even_nums = {2, 4, 6, 8, 10} # набор четных чисел
emp = {1, 'Стив', 10. 5, True} # набор различных объектов
 

Набор не хранит повторяющиеся объекты. Даже если объект добавляется в фигурные скобки более одного раза, в заданном объекте сохраняется только одна копия. Следовательно, операции индексации и нарезки не могут выполняться для заданного объекта.

 >>> числа = {1, 2, 2, 3, 4, 4, 5, 5}
>>> числа
{1, 2, 3, 4, 5}
 

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

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

 >>> myset = {(10,10), 10, 20} # допустимо
>>> мойсет
{10, 20, (10, 10)}
>>> myset = {[10, 10], 10, 20} # не могу добавить список
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    набор = {[10, 10], 10, 20}
TypeError: unhashable type: 'list'
>>> myset = {{10, 10}, 10, 20} # нельзя добавить набор
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    набор = {{10, 10}, 10, 20}
TypeError: unhashable type: 'set'
 

В приведенном выше примере (10,10) — это кортеж, поэтому он становится частью набора. Однако [10,10] — это список, поэтому отображается сообщение об ошибке, в котором говорится, что список нельзя хэшировать. (Хеширование — это механизм в информатике, который позволяет быстрее искать объекты в памяти компьютера.)

Несмотря на то, что изменяемые объекты не хранятся в наборе, сам набор является изменяемым объектом.

Используйте функцию set() для создания пустого набора. Пустые фигурные скобки создадут пустой словарь вместо пустого множества.

 >>> emp = {} # создает пустой словарь
>>> тип (эмп)
<класс 'дикт'>
>>> s = set() # создает пустой набор
>>> тип(ы)
<класс 'набор'>
 

Функция set() также используется для преобразования объекта строки, кортежа или словаря в объект набора, как показано ниже.

 >>> s = set('Hello') # преобразует строку в набор
>>> с
{'л', 'ч', 'о', 'е'}
>>> s = set((1,2,3,4,5)) # преобразует кортеж в набор
>>> с
{1, 2, 3, 4, 5}
>>> d = {1: "Один", 2: "Два"}
>>> s = set(d) # преобразует dict в set
>>> с
{1, 2}
 

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

Используйте встроенные функции набора методов add(), remove() или update() для изменения набора наборов.

 >>> s = set() # создает пустой набор
>>> s.add(10) # добавить элемент
>>> с.доп(20)
>>> с.доп(30)
>>> с
{10, 20, 30}
>>> PrimeNums = {2, 3, 5, 7}
>>> s.update(primeNums) # обновить набор другим набором
>>> с
{2, 3, 20, 5, 7, 10, 30}
>>> s.remove(2) # удалить элемент
>>> с
{3, 20, 5, 7, 10, 30}
 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> с1|с2
{1, 2, 3, 4, 5, 6, 7, 8} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> s1. union(s2)
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s2.union(s1)
{1, 2, 3, 4, 5, 6, 7, 8} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> с1 и с2
{4, 5}
>>> с2 и с1
{4, 5} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> s1.intersection(s2)
{4, 5}
>>> s2.intersection(s1)
{4, 5} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> с1-с2
{1, 2, 3}
>>> с2-с1
{8, 6, 7} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> s1. difference(s2)
{1, 2, 3}
>>> s2.difference(s1)
{8, 6, 7} 9с1
{1, 2, 3, 6, 7, 8} 

 >>> с1={1,2,3,4,5}
>>> с2={4,5,6,7,8}
>>> s1.symmetric_difference(s2)
{1, 2, 3, 6, 7, 8}
>>> s2.symmetric_difference(s1)
{1, 2, 3, 6, 7, 8} 

Установить методы

В следующей таблице перечислены встроенные методы установки:

Метод	Описание
установить.добавить()	Добавляет элемент в набор. Если элемент уже существует в наборе, он не добавляет этот элемент.
установить. очистить()	Удаляет все элементы из набора.
set.copy()	Возвращает поверхностную копию набора.
set.difference()	Возвращает новый набор с уникальными элементами, которых нет в другом наборе, переданном в качестве параметра.
set.difference_update()	Обновляет набор, для которого вызывается метод, элементами, общими для другого набора, переданного в качестве аргумента.
set.discard()	Удаляет определенный элемент из набора.
set.intersection()	Возвращает новый набор с элементами, общими для заданных наборов.
set.intersection_update()	Обновляет набор, для которого вызывается метод instersection_update(), с общими элементами среди указанных наборов.
set.isdisjoint()	Возвращает true, если заданные множества не имеют общих элементов. Множества не пересекаются тогда и только тогда, когда их пересечение является пустым множеством.
set.issubset()	Возвращает true, если набор (для которого вызывается issubset()) содержит все элементы другого набора, переданного в качестве аргумента.
set.pop()	Удаляет и возвращает случайный элемент из набора.
установить.удалить()	Удаляет указанный элемент из набора. Если указанный элемент не найден, возникает ошибка.
набор.симметричная_разность()	Возвращает новый набор с различными элементами, найденными в обоих наборах.
set.symmetric_difference_update()	Обновляет набор, для которого был вызван метод instersection_update(), элементами, общими для указанных наборов.
set.union()	Возвращает новый набор с различными элементами из всех заданных наборов.
установить.обновление()	Обновляет набор, добавляя отдельные элементы из переданных одной или нескольких итераций.

Python вопросы и ответы

Начать тест на знание Python

• Удалить повторяющиеся элементы из списка в Python
• Удаление элементов из списка в Python
• Как отсортировать словарь по значению в Python?
• Преобразование пользовательского ввода в число
• Преобразование строки в дату и время в Python
• Как подсчитать количество вхождений элемента списка?
• Как сгладить список в Python?
• Как объединить словари в Python?
• Сравнение строк в Python
• Другие статьи о Python

Предыдущий

Следующий

Python Set — узнайте на примере

Что такое Python Set?

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

Важными свойствами наборов Python являются следующие:

• Наборы неупорядочены — Элементы, хранящиеся в наборе, не хранятся в каком-либо определенном порядке.
• Предметы набора уникальны – Дублирование предметов не допускается.
• Наборы не индексируются — Вы не можете получить доступ к элементам набора, ссылаясь на индекс.
• Наборы сменные (мутабельные) – Меняются на месте, могут увеличиваться и уменьшаться по требованию.

Создать набор

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

 # Набор струн
S = {'красный', 'зеленый', 'синий'}
# Набор смешанных типов данных
S = {1, 'abc', 1.23, (3+4j), True} 

Наборы не допускают дублирования. Они автоматически удаляются при создании набора.

 S = {'красный', 'зеленый', 'синий', 'красный'}
печать (S)
# Выводит {'синий', 'зеленый', 'красный'} 

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

 S = {1, 'abc', ('a', 'b'), True} 

 S = {[1, 2], {'a':1, 'b':2}}
# Триггеры TypeError: unhashable type: 'list' 

Конструктор набора

Вы также можете создать набор с помощью конструктора типа, называемого set().

 # Набор элементов в итерируемом
S = установить ('abc')
печать (S)
# Выводит {'а', 'б', 'с'}
# Набор последовательных целых чисел
S = набор (диапазон (0, 4))
печать (S)
# Печатает {0, 1, 2, 3}
# Преобразовать список в набор
S = установить ([1, 2, 3])
печать (S)
# Выводит {1, 2, 3} 

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

Вы можете добавить один элемент в набор, используя метод add().

 S = {'красный', 'зеленый', 'синий'}
S.добавить('желтый')
печать (S)
# Выводит {'синий', 'зеленый', 'желтый', 'красный'} 

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

 S = {'красный', 'зеленый', 'синий'}
S.update(['желтый', 'оранжевый'])
печать (S)
# Выводит {'синий', 'оранжевый', 'зеленый', 'желтый', 'красный'} 

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

Чтобы удалить один элемент из набора, используйте метод remove() или discard() .

 # с методом remove()
S = {'красный', 'зеленый', 'синий'}
S.удалить('красный')
печать (S)
# Печатает {'синий', 'зеленый'}
# с методом discard()
S = {'красный', 'зеленый', 'синий'}
S.discard('красный')
печать (S)
# Выводит {'синий', 'зеленый'} 

 S = {'красный', 'зеленый', 'синий'}
х = С.поп()
печать (S)
# Печатает {'зеленый', 'красный'}
# удаленный элемент
печать (х)
# Выводит синий цвет 

 S = {'красный', 'зеленый', 'синий'}
С.очистить()
печать (S)
# Выводит set() 

 S = {'красный', 'зеленый', 'синий'}
печать (длина (S))
# Отпечатков 3 

 S = {'красный', 'зеленый', 'синий'}
для элемента в S:
    печать (элемент)
# Выводит синий зеленый красный 

 # Проверить наличие
S = {'красный', 'зеленый', 'синий'}
если «красный» в S:
    распечатать('да')
# Проверить отсутствие
S = {'красный', 'зеленый', 'синий'}
если «желтый» не в S:
    напечатать('да') 

 A = {'красный', 'зеленый', 'синий'}
B = {'желтый', 'красный', 'оранжевый'}
# по оператору
печать (А | В)
# Выводит {'синий', 'зеленый', 'желтый', 'оранжевый', 'красный'}
# по методу
печать (A.союз (B))
# Выводит {'синий', 'зеленый', 'желтый', 'оранжевый', 'красный'} 

 A = {'красный', 'зеленый', 'синий'}
B = {'желтый', 'красный', 'оранжевый'}
# по оператору
печать (А и Б)
# Печатает {'красный'}
# по методу
печать (A.пересечение (B))
# Выводит {'red'} 

 S = заморозка ({'красный', 'зеленый', 'синий'})
печать (S)
# Выводит замороженный набор({'зеленый', 'красный', 'синий'}) 

 # поиск размера
S = заморозка({'красный', 'зеленый', 'синий'})
печать (длина (S))
# Печатает 3
# исполняющий союз
S = заморозка({'красный', 'зеленый', 'синий'})
печать (S | {'желтый'})
# Выводит замороженный набор({'синий', 'зеленый', 'желтый', 'красный'}) 

 # удаление элемента
S = заморозка({'красный', 'зеленый', 'синий'})
С.поп()
# Вызывает AttributeError: объект 'frozenset' не имеет атрибута 'pop'
# добавление элемента
S = заморозка({'красный', 'зеленый', 'синий'})
S.