Множества объединение: Пересечение и объединение множеств — урок. Алгебра, 9 класс.

Множества в программировании OTUS

Объединение множеств знакомо каждому человеку. Оно встречается в математике. Программирование тоже «знакомо» с ним. Зная это, удается создавать качественный софт. Особенно тогда, когда речь заходит о сортировке или соединении.

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

Определение

Рассматриваемый компонент – это некая неупорядоченная совокупность уникальных неупорядоченных значений. Компонентами выступают любые некорректируемые объекты:

• числа;
• строки;
• символы.

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

Как создать

Перед рассмотрением объединения множеств их необходимо сначала создать. Сделать это удается присвоением переменной последовательности значений. «Перечень» указывается в {}.

Вот – пример, позволяющий создать множество целых чисел a. После – вывод содержимого на дисплей задействованного устройства:

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

Результат обработки исходного кода: заполнение нового массива уникальными символами из первоначально заданной строчки.

Генератор

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

В Питоне для этого используется цикл for:

Сортировка

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

Сначала стоит рассмотреть ситуацию, при которой компоненты имеют разные типы данных в пределах «массива информации». Они не сортируются. При print появится следующая запись:

При повторном запуске порядок поменяется. Это требуется тогда, когда компоненты разного типа перемешаны. Если же вывести только числа, получится такая ситуация:

Произошло упорядочивание информации. Если преобразовать результат в список, на экране появится надпись:

Стоит обратить внимание на следующие особенности:

1. Элементы будут храниться в памяти в упорядоченном виде, если они относятся к одному типу.
2. Для того, чтобы получить отсортированный список, лучше применять функцию sort. После объединение множеств будет упрощено.
3. Sort позволяет стопроцентно упорядочить информацию. Эта функция сделает код более понятным.

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

Операции

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

Объединение

Объединение двух множеств является базовой манипуляцией. Это – самый простой вариант. Результат объединения множеств a и b – это «массив неупорядоченных данных», который содержит в себе все компоненты, входящие в a и b соответственно.

Объединение между двумя множествами осуществляется:

• через оператор |;
• при помощи метода union().

Объединение множеств на картинке будет выглядеть так:

А вот объединение в виде программного кода. Пользователь может воспользоваться | для реализации поставленной задачи:

В консоли при выводе результата, который «объединили», появится:

А вот объединение, которое реализовано через функцию под названием union:

Пересечение

Объединение и пересечение – операции в математике, с которыми знакомятся еще во время обучения в школе. При пересечении результатом будет выступать «массив данных», который включает в себя компоненты, находящиеся сразу в двух множествах.

Реализация осуществляется через:

• оператор &;
• метод intersection.

Визуальное отличие соответствующей манипуляции от объединения можно четко представить. На изображении ниже – результат пересечения:

А вот – представление в программировании:

Разность

Когда пересечение множеств и объединение позади, можно рассмотреть иные варианты операций. Пример – разность.

Результатом разности двух множеств выступает «массив», в котором содержатся элементы, относящиеся только к одному из них. А именно – к первому. Реализация осуществляется при помощи:

• оператора — ;
• метода difference.

А вот – наглядный графический пример и коды, которые помогут добиться желаемого результата:

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

При симметрической разности результатом называется «массив», которое включает в себя компоненты из обоих «массивов», но не те, что есть сразу в обоих. ;

через symmetric difference.

Наглядно ситуация выглядит так:

Добавление

Пересечение и объединение – это « только общее» или «сразу все». Есть еще и так называемое добавление. Оно помогает добавить все компоненты одного «массива» к другому. Для этого используется на первом объекте метод update.

Пустые «перечни»

Отдельное внимание стоит уделить пустым множествам. Это «массивы», которые «ничего не содержат». Для работы с ними лучше всего использовать set().

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

При объединении пустого множества a с b результатом будет служить последний «массив информации».

Отношения

Еще один момент, на который необходимо обратить внима ние – это отношения между «массивами». Для того, чтобы определять подмножества и надмножества, используются специальные функции. Они возвращают True или False. Итог зависит от результата обработки «команды».

Подмножество

Разбираясь я объединением множеств и иными операциями, нужно обратить внимание на подмножества. Для того, чтобы определить, является ли «массив» a подмножеством b, нужно вывести на экран результат обработки метода issubset.

Здесь не все компоненты из a присутствуют в b. Подобная ситуация вернет значение False.

Надмножество

При пересечении и объединении обычно не происходит вывод «истины» и «лжи» — только нового набора данных. Чтобы понять, является ли a надмножеством b, необходимо:

• вызвать метод под названием issuperset;
• отобразить на экране результат работы.

Здесь true будет из-за того, что все компоненты b присутствуют в a. Что-то схожее с пересечением (с пустым множеством и не только).

Frozen

Если корректировка «массива» не предусматривается, он будет иметь тип frozen. Значения тут нельзя удалить или добавить. Значит, объединение множеств фактически невозможно. Содержимое здесь остается статичным.

Пересечение и объединение, а также иные операции можно изучить в школьной программе. А лучше – закончить онлайн курсы по соответствующему направлению. Там объяснят, как называется «массив», который принадлежит хотя бы одному из заданных множеств и многое другое.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus!

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

Множества | Collections | Scala Documentation

Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

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

• Проверки contains, apply, subsetOf. Метод contains спрашивает, содержит ли множество данный элемент. Метод apply для множества работает также как и contains, поэтому set(elem) является тем же самым, что и set contains elem. Это означает, что множества могут использоваться в качестве тестовых функций, которые возвращают true при проверке элементов, которые они содержат.

Например:

scala> val fruit = Set("apple", "orange", "peach", "banana")
fruit: scala.collection.immutable.Set[java.lang.String] = Set(apple, orange, peach, banana)
scala> fruit("peach")
res0: Boolean = true
scala> fruit("potato")
res1: Boolean = false

• Сложения incl и concat (либо + и ++, соответственно), которые добавляют один или несколько элементов во множество, создавая новое множество.
• Удаления excl и removedAll (либо - и --, соответственно), которые удаляют один или несколько элементов из множества, образуя новое множество.
• Операции с множествами для объединения, пересечения и установления расхождений во множествах. Каждая из таких операций имеет две формы: словарную и символьную. Словарные версии —
  intersect, union, и diff, а символьные — &, | и &~. Фактически ++, которые Set унаследовали от Iterable, можно рассматривать как еще один псевдоним union или |, за исключением того, что ++ принимает IterableOnce в качестве аргумента, а union и | принимают множества.

Операции на Классе Set

ПРИМЕР	ЧТО ДЕЛАЕТ
Проверки:
xs contains x	Проверяет, является ли x элементом xs.
xs(x)	Тоже самое что и xs contains x.
xs subsetOf ys	Проверяет, является ли xs подмножеством ys.
Добавления:
xs concat ys или xs ++ ys	Множество, содержащее все элементы xs, а также все элементы ys.
Удаления:
xs.empty	Пустое множество того же класса, что и xs.
Двуместные Операции:
xs intersect ys или xs & ys	Множество содержащее пересечение xs и ys.
xs union ys или xs | ys	Множество содержащее объединение xs и ys.
xs diff ys или xs &~ ys	Множество содержащее расхождение между xs и ys.

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

Операции на Классе immutable.Set

ПРИМЕР	ЧТО ДЕЛАЕТ
Добавления:
xs incl x или xs + x	Множество содержащее все элементы xs а также элемент x.
Удаления:
xs excl x или xs - x	Множество содержащее все элементы xs кроме x.
xs removedAll ys или xs -- ys	Множество содержащее все элементы xs кроме элементов ys.

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

Операции на Классе mutable.Set

ПРИМЕР	ЧТО ДЕЛАЕТ
Добавления:
xs addOne x или xs += x	Добавляет элемент x во множество xs побочным эффектом и возвращает сам xs.
xs addAll ys или xs ++= ys	Добавляет все элементы ys во множество xs побочным эффектом и возвращает сам xs.
xs add x	Добавляет элемент x к xs и возвращает true, если x ранее не содержался в множестве, false если был.
Удаления:
xs subtractOne x или xs -= x	Удаляет элемент x из множества xs побочным эффектом и возвращает сам xs.
xs subtractAll ys или xs --= ys	Удаляет все элементы ys из множества xs побочным эффектом и возвращает сам xs.
xs remove x	Удаляет элемент x из xs и возвращает true, если x ранее не содержался в множестве, false если был.
xs filterInPlace p	Оставляет только те элементы в xs которые удовлетворяют условию p.
xs.clear()	Удаляет все элементы из xs.
Обновления:
xs(x) = b	(тоже самое что и xs.update(x, b)). Если логический аргумент b равен true, то добавляет x к xs, иначе удаляет x из xs.
Клонирования:
xs.clone	Создает новое мутабельное множество с такими же элементами как у xs.

Операции s += elem добавляют элемент elem к множеству s в качестве сайд эффекта, возвращая в качестве результата мутабельное множество. Точно так же, s -= elem удаляет elem из множества, и возвращает это множество в качестве результата. Помимо += и -= есть еще пакетные операции ++= и --= которые добавляют или удаляют все элементы итерируемой коллекции.

Выбор в качестве имен методов += и -= будет означать для вас, то что схожий код сможет работать как с изменяемыми, так и с неизменяемыми множествами. Сначала рассмотрим следующий пример в консоле, в котором используется неизменяемый набор параметров s:

scala> var s = Set(1, 2, 3)
s: scala.  collection.immutable.Set[Int] = Set(1, 2, 3)
scala> s += 4
scala> s -= 2
scala> s
res2: scala.collection.immutable.Set[Int] = Set(1, 3, 4)

Мы использовали += и -= на var типа immutable.Set. Выражение s += 4 является сокращение для s = s + 4. Тоесть вызов метода сложения + на множестве s, а затем присвоения результата обратно в переменную s . Рассмотрим теперь аналогичные действия с изменяемым множеством.

scala> val s = collection.mutable.Set(1, 2, 3)
s: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> s += 4
res3: s.type = Set(1, 4, 2, 3)
scala> s -= 2
res4: s.type = Set(1, 4, 3)

Конечный эффект очень похож на предыдущий результат; мы начали с Set(1, 2, 3) закончили с Set(1, 3, 4). Несмотря на то, что выражения выглядят так же, но работают они несколько иначе. s += 4 теперь вызывает метод

+= на изменяемом множестве s, измененяет свое собственное значение. По схожей схеме работает, s -= 2 вызывая метод -= на томже самом множестве.

Сравнение этих двух подходов демонстрирует важный принцип. Часто можно заменить изменяемую коллекцию, хранящуюся в val, неизменяемой коллекцией, хранящейся в var, и наоборот. Это работает, по крайней мере, до тех пор, пока нет прямых отсылок на коллекцию, используя которую можно было бы определить была ли коллекция обновлена или создана заново.

У изменяемых множеств также есть операции add и remove как эквиваленты для += и -=. Разница лишь в том, что команды add и remove возвращают логический результат, показывающий, повлияла ли операция на само множество или нет.

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

Пустое множество представлено объектом сингэлтоном. Множества размеров до четырех представлены одним объектом, в котором все элементы хранятся в виде полей. За пределами этого размера, неизменяемые множества реализованны в виде Сжатого Отображенния Префиксного Дерева на Ассоциативном Массиве.

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

Два дочерних трейта множеств SortedSet и BitSet.

Отсортированное Множество (SortedSet)

SortedSet это множество, которое отдает свои элементы (используя iterator или foreach) в заданном порядке (который можно свободно задать в момент создания множества). Стандартное представление SortedSet — это упорядоченное двоичное дерево, которое поддерживает свойство того, что все элементы левого поддерева меньше, чем все элементы правого поддерева. Таким образом, простой упорядоченный обход может вернуть все элементы дерева в возрастающем порядке. Scala класс immutable.TreeSet базируется на красно-черном дереве, в котором сохраняется тоже свойство но при этом само дерево является сбалансированным –, то есть все пути от корня дерева до листа имеют длину, которая может отличаться друг от друга максимум на еденицу.

При создании пустого TreeSet, можно сначала указать требуемый порядок:

scala> val myOrdering = Ordering.fromLessThan[String](_ > _)
myOrdering: scala.math.Ordering[String] = ...

Затем, чтоб создать пустой TreeSet с определенным порядком, используйте:

scala> TreeSet.empty(myOrdering)
res1: scala.collection.immutable.TreeSet[String] = TreeSet()

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

scala> TreeSet.empty[String]
res2: scala. collection.immutable.TreeSet[String] = TreeSet()

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

scala> res2 + "one" + "two" + "three" + "four"
res3: scala.collection.immutable.TreeSet[String] = TreeSet(four, one, three, two)

Упорядоченные множества также поддерживают запросы на диапазоны. Например, метод range возвращает все элементы от начального элемента до конечного, но исключая конечный элемент. Или же метод from возвращает все элементы от начального и далее все остальные элементы в порядке очередности. Результатом работы обоих методов также будет упорядоченное множество. Примеры:

scala> res3.range("one", "two")
res4: scala.collection.immutable.TreeSet[String] = TreeSet(one, three)
scala> res3 rangeFrom "three"
res5: scala.collection. immutable.TreeSet[String] = TreeSet(three, two)

Битовые Наборы (BitSet)

Битовые Наборы — это множество неотрицательных целочисленных элементов, которые упаковываются в пакеты. Внутреннее представление BitSet использует массив Longов. Первый Long охватывает элементы от 0 до 63, второй от 64 до 127 и так далее (Неизменяемые наборы элементов в диапазоне от 0 до 127 оптимизированны таким образом что хранят биты непосредственно в одном или двух полях типа Long без использования массива). Для каждого Long 64 бита каждого из них устанавливается значение 1, если соответствующий элемент содержится в наборе, и сбрасывается в 0 в противном случае. Отсюда следует, что размер битового набора зависит от размера самого большого числа, которое в нем хранится. Если N является самым большим размером числа, то размер набора будет составлять N/64 от размера Long, или N/8 байта плюс небольшое количество дополнительных байт для информации о состоянии.

Поэтому битовые наборы компактнее, чем другие множества, когда речь идет о хранении мелких элементов. Еще одним преимуществом битовых наборов является то, что такие операции, как проверка на наличие элемента contains, добавление либо удаление элементов с += и -= черезвычайно эффективны.

Python Set Union с кодами и примерами

Основной темой математики является теория множеств, которая влечет за собой хранение группы или набора связанных компонентов. Python решил сделать реализацию математических наборов внутренней структурой данных из-за ее важности. В этой статье мы узнаем, как найти объединение между двумя наборами с помощью метода set union() в python. Но сначала давайте рассмотрим, что такое множества и что мы имеем в виду, когда говорим «объединение двух множеств».

Что такое множество в Python?

Фигурные скобки используются для представления наборов, которые являются одной из четырех основных структур данных Python. Наборы, как и списки, могут хранить данные любого типа (строки, целые числа, числа с плавающей запятой), а также смесь типов данных. Однако имеет логичный смысл группировать в наборе только связанные вещи. Вам может быть интересно, в чем разница между структурами данных словаря и набора, поскольку они обе используют фигурные скобки для описания себя. Решение простое: словари хранят данные в виде пар ключ-значение, а наборы — нет.

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

Например:

 setA = { "a", "b", "c"}
печать (набор)
# Добавляем элемент в набор
setA.добавить ("д")
печать (набор)
 

 

Вывод:

 {'c', 'b', 'a'}
{'в', 'г', 'б', 'а'}
 

 

Что такое объединение множеств?

Объединение любых двух или более наборов дает совершенно новый набор, который включает смесь элементов из всех наборов . Другими словами, объединение двух или более множеств — это множество из все отдельные элементы присутствуют во всех наборах . Слово « или » используется для обозначения объединения наборов. Рассмотрим два множества A и B. Все элементы, которые присутствуют либо в A, либо в B, либо в обоих множествах, будут присутствовать в объединении A и B. Объединение множеств представлено символом «U». Операция над множествами, часто известная как объединение множеств, записывается как:

 A ∪ B = {x: x ∈ A или x ∈ B}. Здесь x — элемент, присутствующий в обоих множествах, A и B.
 

 

Давайте лучше поймем эту концепцию на примере:

 Если A = { 23, 453, 43, 66, 21} и B = { 43, 785, 12, 35, 23, 545}

Тогда A U B = {23, 453, 43, 66, 21, 43, 785, 12, 35, 545} 

 

Вы также можете визуализировать эту концепцию с помощью диаграммы Венна, как показано ниже:

Найти союз наборов в Python?

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

1) Использование метода Set. Union()

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

Например, предположим, что у нас есть два набора (A и B), и мы хотим найти AUB. Итак, синтаксис будет выглядеть примерно так:

 A.union(B) # Оператор 1
B.union(A) # Заявление 2
 

 

Обратите внимание, что оба оператора, а именно оператор 1 и оператор 2, дадут один и тот же результат. Давайте теперь посмотрим на код, чтобы лучше понять использование этой функции. Обратите внимание, как мы использовали его, чтобы найти объединение более чем двух множеств.

Код Python:

 A = {1, 2, 3, 4} #Set A
B = {2, 5, 6, 7} #Набор B
С = {7, 8, 9, 10} #Набор С
D = {11, 12, 13, 14} # Установить D

# Е = А У В
E = A.union(B) # Утверждение 1

# F = А У Б У С У Д
F = A.union(B, C, D) # Утверждение 2

print("A U B: " +str(E))
print("A U B U C U D: " +str(F))
 

 

Вывод:

 A U B: {1, 2, 3, 4, 5, 6, 7}
А У Б У Ц У Д: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
 

 

2) Использование | оператор

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

Код Python:

 A = {1, 2, 3, 4} #Set A
B = {2, 5, 6, 7} #Набор B
С = {7, 8, 9, 10} #Набор С
D = {11, 12, 13, 14} # Установить D

# Е = А У В
Е = А|В
# F = А У Б У С У Д
Ф = А|В|С|D

print("A U B: " +str(E))
print("A U B U C U D: " +str(F))
 

 

Вывод:

 A U B: {1, 2, 3, 4, 5, 6, 7}
А У Б У Ц У Д: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
 

 

Заключение

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

Функция Python set union() — Spark By {Examples}

Функция Python set union() используется для получения уникальных элементов из двух или нескольких наборов. Набор Python — это структура данных, которая не допускает повторяющихся значений. Таким образом, чтобы объединить два набора в один объект набора, используйте функцию объединения, которая объединяет несколько наборов и устраняет повторяющиеся значения. В этой статье мы обсудим, как выполнять операции объединения двух или нескольких наборов в Python.

1. Краткие примеры объединения Python Set

Ниже приведен краткий пример выполнения операции объединения над множествами объектов.

# выполнить объединение по идентификатору и стоимости
print("Стоимость id U - ",id.union(cost))
# выполнить объединение по идентификатору, стоимости и количеству
print("id U стоимость U количество - ",id.union(cost,quantity))
# выполнить объединение по идентификатору и стоимости
print("id | стоимость - ",id|стоимость)
# выполнить объединение по идентификатору, стоимости и количеству
print("id | стоимость | количество - ",id|стоимость | количество)
 

2. Python set union()

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

2.1 Синтаксис set union()

Ниже приведен синтаксис функции union().

# синтаксис объединения
setObj.union (setObj2, setObj3,.....)
 

Давайте рассмотрим несколько примеров, чтобы лучше понять эту концепцию.

3. set union() Пример

В этом примере мы создадим три набора с целочисленными элементами и с помощью Python union() объединим их в один объект набора. Чтобы создать набор в Python, используйте {}.

# Создаем три набора
идентификатор = {1,2,3,4,5}
стоимость = {10,20,34,56,1}
количество={45,6,1,2,3}
#Актуальные элементы в наборах.
print("Установить идентификатор:",id)
print("Установить стоимость:",стоимость)
print("Установить количество:",количество)
# Выход
# Установить идентификатор: {1, 2, 3, 4, 5}
#Установить cose : {1, 34, 10, 20, 56}
# Установить количество: {1, 2, 3, 6, 45}
 

Давайте выполним операцию объединения этих множества объектов.

# выполнить объединение по идентификатору и стоимости
print("Стоимость id U - ",id.union(cost))
# выполнить объединение по идентификатору и количеству
print("количество id U - ",id.union(количество))
# выполнить объединение по идентификатору, стоимости и количеству
print("id U стоимость U количество - ",id. union(cost,quantity))
# Выход
#id стоимость U - {1, 2, 3, 4, 5, 34, 10, 20, 56}
#id количество U - {1, 2, 3, 4, 5, 6, 45}
#id U стоимость U количество - {1, 2, 3, 4, 5, 34, 6, 10, 45, 20, 56}
 

Объяснение:

1. Мы вернули только уникальные элементы из наборов id и cost.
2. Мы вернули только уникальные элементы из наборов идентификаторов и количеств.
3. Наконец, мы также возвращаем уникальные элементы из всех трех наборов с помощью функции union().

4. set union() со строковыми значениями

В этом примере мы создадим три объекта набора Python со строковыми элементами и с помощью union() объединим все элементы из указанных наборов без дубликатов.

# Создадим четыре набора
Village1={"поля","растения","электричество","дома"}
village2={"поля","растения","электричество","дома","здания"}
деревня3={"Нет"}
# Фактические элементы в наборах.
print("Набор-1",деревня1)
print("Комплект-2",деревня2)
print("Комплект-3",деревня3)
# Выход
# Set-1 {'электричество', 'поля', 'дома', 'растения'}
# Set-2 {'электричество', 'поля', 'здания', 'дома', 'растения'}
# Set-3 {'Нет'}
 

Выполним объединение этого набора строк.

# выполнить объединение для Village1 и Village2
print("деревня1 U деревня2 - ",деревня1.союз(деревня2))
# выполнить объединение на Village2 и Village3
print("деревня2 U деревня3 - ",деревня2.союз(деревня3))
# Выход
#village1 U village2 - {'электричество', 'поля', 'здания', 'дома', 'растения'}
#village2 U village3 - {'здания', 'Нет', 'электричество', 'поля', 'дома', 'растения'}
 

Объяснение:

1. Мы вернули только уникальные элементы из наборов Village1 и Village2.
2. Мы вернули только уникальные элементы из наборов Village2 и Village3.

5. Python Set Union с помощью | оператор

Мы также можем выполнить объединение множеств, используя оператор | оператор в Python. Это мы можем назвать оператором «или».

Синтаксис:

# Синтаксис
набор1|набор2|набор3|.....
 

Давайте рассмотрим несколько примеров, чтобы лучше понять эту концепцию.

5.1 Использование | с примерами

В этом примере мы создадим три набора с целочисленными элементами и вернем общие элементы.

# Создаем три набора
идентификатор = {1,2,3,4,5}
стоимость = {10,20,34,56,1}
количество={45,6,1,2,3}
# Фактические элементы в наборах.
печать("Набор-1",идентификатор)
print("Комплект-2",стоимость)
печать("Набор-3",количество)
# Выход
#Set-1 {1, 2, 3, 4, 5}
#Set-2 {1, 34, 10, 20, 56}
#Set-3 {1, 2, 3, 6, 45}
 

Вывод:

# выполнить объединение по идентификатору и стоимости
print("id | стоимость - ",id|стоимость)
# выполнить объединение по идентификатору и количеству
print("id | количество - ",id|количество)
# выполнить объединение по идентификатору, стоимости и количеству
print("id | стоимость | количество - ",id|стоимость | количество)
# Выход
#идентификатор | стоимость - {1, 2, 3, 4, 5, 34, 10, 20, 56}
#идентификатор | количество - {1, 2, 3, 4, 5, 6, 45}
#идентификатор | стоимость | количество - {1, 2, 3, 4, 5, 34, 6, 10, 45, 20, 56}
 

Объяснение:

1. Мы вернули только уникальные элементы из наборов id и cost.
2. Мы вернули только уникальные элементы из наборов идентификаторов и количеств.
3. Наконец, мы также возвращаем уникальные элементы из всех трех наборов с символом «|». оператор.

5.2 Использование | с набором строк

В этом примере мы создадим три набора со строковыми элементами и вернем общие элементы.

# Создадим четыре набора
Village1={"поля","растения","электричество","дома"}
village2={"поля","растения","электричество","дома","здания"}
деревня3={"Нет"}
# Фактические элементы в наборах.
print("Набор-1",деревня1)
print("Комплект-2",деревня2)
print("Комплект-3",деревня3)
# Выход
#Set-1 {'электричество', 'поля', 'дома', 'растения'}
#Set-2 {'электричество', 'поля', 'здания', 'дома', 'растения'}
#Set-4 {'Нет'}
 

Вывод:

# выполнить объединение для Village1 и Village2
print("деревня1 | деревня2 - ",деревня1|деревня2)
# выполнить объединение на Village2 и Village3
print("деревня2 | деревня3 - ",деревня2|деревня3)
# Выход
#деревня1 | деревня2 - {'электричество', 'поля', 'здания', 'дома', 'растения'}
#деревня2 | деревня3 - {'здания', 'Нет', 'электричество', 'поля', 'дома', 'растения'}
 

Объяснение:

1. Мы вернули только уникальные элементы из наборов Village1 и Village2.
2. Мы вернули только уникальные элементы из наборов Village1 и Village2.
3. Мы вернули только уникальные элементы из наборов Village2, Village3 и Village4.
4. Наконец, мы также возвращаем уникальные элементы из всех четырех наборов с символом «|». оператор.

6. Различия между union() и | оператор

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

союз()	| Оператор
union() является методом	| является оператором
метод union() явно фиксирует приоритет наборов	| оператор будет иметь определенный приоритет оператора наборов
union() используется только с наборами	| оператор может использоваться с другими структурами данных

Дополнительные примеры наборов см.