Что такое множество в python
Множество (set) представляют еще один вид набора, который хранит только уникальные элементы. Для определения множества используются фигурные скобки, в которых перечисляются элементы:
users = print(users) #
Обратите внимание, что несмотря на то, что функция print вывела один раз элемент «Tom», хотя в определении множества этот элемент содержится два раза. Все потому что множество содержит только уникальные значения.
Также для определения множества может применяться функция set() , в которую передается список или кортеж элементов:
people = [«Mike», «Bill», «Ted»] users = set(people) print(users) #
Функцию set удобно применять для создания пустого множества:
users = set()
Для получения длины множества применяется встроенная функция len() :
users = print(len(users)) # 3
Добавление элементов
Для добавления одиночного элемента вызывается метод add() :
users = set() users.add("Sam") print(users)
Удаление элементов
Для удаления одного элемента вызывается метод remove() , в который передается удаляемый элемент. Но следует учитывать, что если такого элемента не окажется в множестве, то будет сгенерирована ошибка. Поэтому перед удалением следует проверять на наличие элемента с помощью оператора in :
users = user = «Tom» if user in users: users.remove(user) print(users) #
Также для удаления можно использовать метод discard() , который не будет генерировать исключения при отсутствии элемента:
users = users.discard(«Tim») # элемент «Tim» отсутствует, и метод ничего не делает print(users) # users.discard(«Tom») # элемент «Tom» есть, и метод удаляет элемент print(users) #
Для удаления всех элементов вызывается метод clear() :
users.clear()
Перебор множества
Для перебора элементов можно использовать цикл for:
users = for user in users: print(user)
При переборе каждый элемент помещается в переменную user.
Операции с множествами
С помощью метода copy() можно скопировать содержимое одного множества в другую переменную:
users = students = users.copy() print(students) #
Объединение множеств
Метод union() объединяет два множества и возвращает новое множество:
users = users2 = users3 = users.union(users2) print(users3) #
Пересечение множеств
Пересечение множеств позволяет получить только те элементы, которые есть одновременно в обоих множествах. Метод intersection() производит операцию пересечения множеств и возвращает новое множество:
users = users2 = users3 = users.intersection(users2) print(users3) #
Вместо метода intersection мы могли бы использовать операцию логического умножения:
users = users2 = print(users & users2) #
В этом случае мы получили бы тот же результат.
Модификация метода — intersection_update() заменяет пересеченными элементами первое множество:
users = users2 = users.intersection_update(users2) print(users) #
Разность множеств
Еще одна операция — разность множеств возвращает те элементы, которые есть в первом множестве, но отсутствуют во втором. Для получения разности множеств можно использовать метод difference или операцию вычитания:
users = users2 = users3 = users.difference(users2) print(users3) # print(users — users2) #
Отдельная разновидность разности множеств — симметрическая разность производится с помощью метода symmetric_difference() или с помощью операции ^ . Она возвращает все элементы обоих множеств за исключением общих:
users = users2 = users3 = users.symmetric_difference(users2) print(users3) # users4 = users ^ users2 print(users4) #
Отношения между множествами
Метод issubset позволяет выяснить, является ли текущее множество подмножеством (то есть частью) другого множества:
users = superusers = print(users.issubset(superusers)) # True print(superusers.issubset(users)) # False
Метод issuperset , наоборот, возвращает True, если текущее множество является надмножеством (то есть содержит) для другого множества:
users = superusers = print(users.issuperset(superusers)) # False print(superusers.issuperset(users)) # True
frozen set
Тип frozen set является видом множеств, которое не может быть изменено. Для его создания используется функция frozenset :
users = frozenset()
В функцию frozenset передается набор элементов — список, кортеж, другое множество.
В такое множество мы не можем добавить новые элементы, как и удалить из него уже имеющиеся. Собственно поэтому frozen set поддерживает ограниченный набор операций:
- len(s) : возвращает длину множества
- x in s : возвращает True, если элемент x присутствует в множестве s
- x not in s : возвращает True, если элемент x отсутствует в множестве s
- s.issubset(t) : возвращает True, если t содержит множество s
- s.issuperset(t) : возвращает True, если t содержится в множестве s
- s.union(t) : возвращает объединение множеств s и t
- s.intersection(t) : возвращает пересечение множеств s и t
- s.difference(t) : возвращает разность множеств s и t
- s.copy() : возвращает копию множества s
- Вопросы для самопроверки
- Упражнения для самопроверки
Множества и словари в Python
Множество ( set ) — встроенная структура данных языка Python, имеющая следующие свойства:
- множество — это коллекция Множество содержит элементы
- множество неупорядоченно Множество не записывает (не хранит) позиции или порядок добавления его элементов. Таким образом, множество не имеет свойств последовательности (например, массива): у элементов множества нет индексов, невозможно взять срез множества.
- элементы множества уникальны Множество не может содержать два одинаковых элемента.
- элементы множества — хешируемые объекты (hashable objects) В Python множество set реализовано с использованием хеш-таблицы. Это приводит к тому, что элементы множества должны быть неизменяемыми объектами. Например, элементом множества может быть строка, число, кортеж tuple , но не может быть список list , другое множество set .
Эти свойства множеств часто используются, чтобы проверять вхождение элементов, удаление дубликатов из последовательностей, а также для математических операций пересечения, объединения, разности.
Создание и изменение множества
Запустите в терминале Python в интерпретируемом режиме и проработайте примеры ниже.
Пустое множество создаётся с помощью функции set
>>> A = set() >>> type(A) >>> len(A) 0 >>> A set()
Обратите внимание, что размер множества множества можно получить с помощью функции len .
Добавим несколько элементов
>>> A.add(1) >>> A >>> A.add(2) >>> A >>> A.add(2) >>> A
Заметьте, что повторное добавление не имеет никакого эффекта на множество.
Также, из вывода видно, что литералом множества являются фигурные скобки <>, в которых через запятую указаны элементы. Так, ещё один способ создать непустое множество — воспользоваться литералом
>>> B = 1, 2> >>> B
При попытке добавления изменяемого объекта возникнет ошибка
>>> B.add([3,4,5]) Traceback (most recent call last): File "", line 1, in TypeError: unhashable type: 'list'
Здесь произошла попытка добавить массив в множество B.
У операции добавления set.add существует обратная — операция удаления set.remove
>>> B >>> B.remove(1) >>> B >>> B.remove(3) Traceback (most recent call last): File "", line 1, in KeyError: 3
При попытке удаления элемента, не входящего в множество, возникает ошибка KeyError .
Однако, существует метод set.discard , который удаляет элемент из множества, только в том случае, если этот элемент присутствовал в нём.
Математические операции
Множества Python поддерживают привычные математические операции
Проверки
Чтобы проверить вхождение элемента в множество используйте логический оператор in
>>> B = 1, 2> >>> B >>> 3 in B False
Асимптотика x in set — O(1).
Стоит отметить, что оператор in работает и с другими коллекциями. Например, можно проверять вхождение подстроки в строку ‘AA’ in ‘bbAAcc’ или вхождение элемента в массив 5 in [1, 2, 5, 6] . Асимптотики в данном случае нужно уточнять в документации.
>>> A = 1, 2, 3> >>> B = 1, 2, 3> >>> A == B True >>> B.add(4) >>> A >>> B >>> A == B False
Проверка на нестрогое подмножество set.issubset
>>> A >>> B >>> A.issubset(B) True >>> B.issubset(A) False >>> A.issubset(A) True
Проверка на нестрогое надмножество set.issuperset
>>> A >>> B >>> A.issuperset(B) False >>> B.issuperset(A) True >>> B.issuperset(B) True
Операции получения новых множеств
>>> A = 1, 2, 4> >>> B = 1, 2, 3> >>> A.union(B) # union — объединение множеств >>> A.intersection(B) # intersection — пересечение >>> A.difference(B) # difference — разность множеств >>> B.difference(A) >>> A.symmetric_difference(B) # symmetric_difference — симметрическая разность >>> B.symmetric_difference(A)
Сводная таблица по множествам (cheatsheet)
- elem — Python-объект
- A — множество set
- B, C. 1. В случае использования в методахA.method_name(B, C. ) : B, C. являются любыми итерируемыми объектами. Методы допускают такие аргументы, например, .union(range(2)) == вернёт True . 2. В случае использования c операторами, например, A > B или A & B & C & . : B, C. являются множествами. Дело в том, что эти операторы определены для операндов типа set (и также frozenset , о которых речь позже).
| Операция | Синтаксис | Тип результата |
|---|---|---|
| Вхождение элемента | elem in A | bool |
| Равенство | A == B | bool |
| Является нестрогим подмножеством | A.issubset(B) или A | bool |
| Является строгим подмножеством | A < B | bool |
| Является нестрогим надмножеством | A.issuperset(B) или A >= B | bool |
| Явяляется строгим надмножеством | A > B | bool |
| Объединение множеств | A.union(B, C. ) | set |
| A | B | C | . | set | |
| Пересечение множеств | A.intersection(B, C. ) | set |
| A & B & C & . | set | |
| Разность множеств | A.difference(B, C. ) | set |
| A - B - C - . | set | |
| Симметрическая разность множеств | A.symmetric_difference(B, C. ) | set |
| A ^ B ^ C ^ . | set |
Кроме того, у операций, порождающих новые множества, существует inplace варианты. Для методов это те же названия, только с префиксом _update, а для соответствующих операторов добавляется знак равенства =. Ниже показан вариант для операции разности множеств
>>> A = 1, 2, 3, 4> >>> B = 2, 4> >>> A.difference_update(B) >>> A >>> A = 1, 2, 3, 4> >>> B = 2, 4> >>> A -= B >>> A
Неизменяемые множества
В Python существует неизменяемая версия множества - frozenset . Этот тип объектов поддерживает все операции обычного множества set , за исключением тех, которые его меняют.
Неизменяемые множества являются хешируемыми объектами, поэтому они могут быть элементами множества set . Так можно реализовать, например, множество множеств, где множество set состоит из множеств типа frozenset .
Для создания frozenset используется функция frozenset(iterable) , в качестве аргумента принимающая итерирумый объект.
>>> FS = frozenset(1, 2, 3>) >>> FS frozenset() >>> A = 1, 2, 4> >>> FS & A frozenset() >>> A & FS
В этом примере показано создание frozenset из обычного множества . Обратите внимание на тип возвращаемого объекта для операции пересечения & . Возвращаемый объект имеет тип, соответствующий типу первого аргумента. Такое же поведение будет и с другими операциями над множествами.
Словари Python
Словарь (dictionary) в Python -- это ассоциативный массив, реализовать который вы пробовали на прошлом занятии. Ассоциативный массив это структура данных, содержащая пары вида ключ:значение. Ключи в ассоциативном массиве уникальны.
В Python есть встроенный ассоциативный массив - dict . Его реализация основана на хеш-таблицах. Поэтому
- ключом может быть только хешируемый объект
- значением может быть любой объект
Создание и изменение словаря
Пустой словарь можно создать двумя способами:
>>> d1 = dict() >>> d2 = <> >>> d1 <> >>> d2 <> >>> type(d1) >>> type(d2)
Добавить элемент в словарь можно с помощью квадратных скобок:
>>> domains = <> >>> domains['ru'] = 'Russia' >>> domains['com'] = 'commercial' >>> domains['org'] = 'organizations' >>> domains
Из этого примера видно, что литералом словаря являются фигурные скобки, в которых через запятую перечислены пары в формате ключ:значение . Например, словарь domains можно было создать так domains = .
Доступ к элементу осуществляется по ключу:
>>> domains['com'] 'commercial' >>> domains['de'] Traceback (most recent call last): File "", line 1, in KeyError: 'de'
Удалить элемент можно с помощью оператора del . Если ключа в словаре нет, произойдет ошибка KeyError
>>> domains >>> del domains['de'] Traceback (most recent call last): File "", line 1, in KeyError: 'de' >>> del domains['ru'] >>> domains
Кроме того, для добавления, получения и удаления элементов есть методы dict.setdefault , dict.get , dict.pop , которые задействует дополнительный аргумент на случай, если ключа в словаре нет
>>> d1 = <> >>> d1.setdefault('a', 10) 10 >>> d1.setdefault('b', 20) 20 >>> d1 >>> d1.setdefault('c') >>> d1 >>> d1.setdefault('a', 123) 10 >>> d1 >>> d1.get('a') 10 >>> d1.get('d') # вернул None >>> d1.get('d', 'NoKey') 'NoKey' >>> d1.pop('d') Traceback (most recent call last): File "", line 1, in KeyError: 'd' >>> d1.pop('d', 255) 255 >>> d1 >>> d1.pop('a', 255) 10 >>> d1
Примечание о числовых ключах
Ключом может являться и число: int или float . Однако при работе со словарями в Python помните, что два ключа разные, если для них верно k1 != k2 # True .
>>> d = 0: 10> >>> d >>> d[0] = 22 >>> d >>> d[0.0] = 33 >>> d >>> 0.0 != 0 False
Поэтому при возможности избегайте в качестве ключей float -объектов.
Использование DictView: циклы и множественные операции
Если попробовать пройтись в цикле по словарю, то это будет проход по ключам
>>> d = 'a': 10, 'c': 30, 'b': 20> >>> for k in d: . print(k) . a c b
Зачастую необходимо пройтись в цикле по ключам, значениям или парам ключ:значение, содержащиеся в словаре. Для этого существуют методы dict.keys() , dict.values() , dict.items() . Они возвращают специальные DictView объекты, которые можно использовать в циклах:
>>> d = 'a': 10, 'c': 30, 'b': 20> >>> for k in d.keys(): . print(k) . a c b >>> for v in d.values(): . print(v) . 10 30 20 >>> for k, v in d.items(): . print(k, v) . a 10 c 30 b 20
Объекты DictView , содержащие только ключи, ведут себя подобно множествам. Кроме того, если DictView объекты для значений или пар содержат неизменяемые объекты, тогда они тоже ведут себя подобно множествам. Это означает, что привычные для множеств операции пересечения, вхождения и другие также работают с DictView .
>>> d >>> dkeys = d.keys() >>> 'abc' in dkeys False >>> 'c' in dkeys True >>> 'a', 'b', 'c'> == dkeys True >>> dkeys & 'b', 'c', 'd'>
Словарь с упорядоченными ключами OrderedDict
Это может понадобится для отправки задач на ejudge.
Если внимательно просмотреть примеры на циклы выше, то видно, что порядок итерирования в циклах совпадает с порядком добавления элементов в словарь.
Однако, такое поведение у стандартных словарей dict гарантируется, начиная с версии 3.7 (лабораторные примеры были сделаны из-под версии 3.7.4). Узнать свою версию Python можно, например, из терминала python3 --version или зайдя в интерпретируемый режим (версия будет написана сверху).
Если для вашей программы важно упорядочивание элементов, но вы не знаете, какой версии интерпретатор будет исполнять ваш скрипт, то вам нужно воспользоваться упорядоченной версией словарей OrderedDict .
Она находится в стандартной библиотеке collections .
Упорядоченный словарь поддерживает все операции, что и обычный словарь.
>>> import collections >>> od = collections.OrderedDict() >>> od OrderedDict() >>> od['a'] = 10 >>> od['c'] = 30 >>> od['b'] = 20 >>> od OrderedDict([('a', 10), ('c', 30), ('b', 20)])
Сайт построен с использованием Pelican. За основу оформления взята тема от Smashing Magazine. Исходные тексты программ, приведённые на этом сайте, распространяются под лицензией GPLv3, все остальные материалы сайта распространяются под лицензией CC-BY.
Что такое множество в python
Множество в языке Питон — это структура данных, эквивалентная множествам в математике. Множество может состоять из различных элементов, порядок элементов в множестве неопределен. В множество можно добавлять и удалять элементы, можно перебирать элементы множества, можно выполнять операции над множествами (объединение, пересечение, разность). Можно проверять принадлежность элемента множеству.
В отличие от массивов, где элементы хранятся в виде последовательного списка, в множествах порядок хранения элементов неопределен (более того, элементы множества хранятся не подряд, как в списке, а при помощи хитрых алгоритмов). Это позволяет выполнять операции типа “проверить принадлежность элемента множеству” быстрее, чем просто перебирая все элементы множества.
Элементами множества может быть любой неизменяемый тип данных: числа, строки, кортежи. Изменяемые типы данных не могут быть элементами множества, в частности, нельзя сделать элементом множества список (но можно сделать кортеж) или другое множество. Требование неизменяемости элементов множества накладывается особенностями представления множества в памяти компьютера.
Задание множеств
Множество задается перечислением всех его элементов в фигурных скобках. Исключением явлеется пустое множество, которое можно создать при помощи функции set() . Если функции set передать в качестве параметра список, строку или кортеж, то она вернёт множество, составленное из элементов списка, строки, кортежа. Например:
A = A = set('qwerty') print(A)
Каждый элемент может входить в множество только один раз, порядок задания элементов неважен. Например, программа:
A = B = print(A == B)
выведет True , так как A и B — равные множества.
Каждый элемент может входить в множество только один раз. set('Hello') вернет множество из четырех элементов: .
Работа с элементами множеств
Узнать число элементов в множестве можно при помощи функции len .
Перебрать все элементы множества (в неопределенном порядке!) можно при помощи цикла for :
primes = for num in primes: print(num)
Проверить, принадлежит ли элемент множеству можно при помощи операции in , возвращающей значение типа bool . Аналогично есть противоположная операция not in . Для добавления элемента в множество есть метод add :
A = print(1 in A, 4 not in A) A.add(4)
Для удаления элемента x из множества есть два метода: discard и remove . Их поведение различается только в случае, когда удаляемый элемент отсутствует в множестве. В этом случае метод discard не делает ничего, а метод remove генерирует исключение KeyError .
Наконец, метод pop удаляет из множества один случайный элемент и возвращает его значение. Если же множество пусто, то генерируется исключение KeyError .
Из множества можно сделать список при помощи функции list .
Операции с множествами
С множествами в питоне можно выполнять обычные для математики операции над множествами.
Множества — Python: Cловари и множества
Ключи словаря хранятся в нем в единственном экземпляре. Добавление нового значения по существующему ключу заменяет старое значение. Хранение в единственном экземпляре полезно и в тех случаях, когда нам нужно хранить не столько значения по ключам, сколько именно сами ключи.
Например, нужно хранить список городов, которые посетил каждый пользователь. При повторном посещении города дублировать запись не требуется. Это позволяет сэкономить память и упростить поиск информации. Также нам может понадобиться узнать, какие города посетили и Вася и Маша, а какие — только Маша или только Вася.
По сути, это хранения перечня элементов в неких наборах и сопоставления этих наборов между собой. В математике для решения такого рода задач служат множества. В свою очередь, Python предоставляет одноименную структуру данных — set .
Итак, множества в Python — это неупорядоченные последовательности элементов, каждый из которых в множестве представлен ровно один раз. С ними мы подробнее познакомимся в этом уроке.
Создание множеств и манипуляции над ними
Множество можно создать с помощью соответствующего литерала:
s = 1, 2, 3, 2, 1> s # type(s) # Литералы множеств записываются в фигурных скобках, как и литералы словарей. Однако внутри скобок через запятую перечисляются только элементы множества. Литерал <> уже занят словарями, поэтому пустое множество создается вызовом функции set без аргументов:
set() # <> type(set()) # Эту же функцию можно использовать, чтобы создать множество из элементов произвольного количества итераторов или итерируемых элементов:
set('abracadabra') # set([1, 2, 3, 2, 1]) # set('a': 42, 'b': 'foo'>) # Заметьте, что в множестве каждый уникальный элемент представлен ровно один раз, даже если в коллекции-источнике были повторы.
Проверка на вхождение
Для некоторых задач нужно проверять, является ли некое значение элементом множества — другими словами, «входит ли оно в множество» или «принадлежит ли оно множеству». В таких случаях нужно использовать оператор in :
42 in set() # False 42 in set([42]) # True 'a' in set('abracadabra') # True Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: