Словарь и set в Python: ключевые различия и сценарии использования
Словарь и множество: основы работы
Основные операции с dict и set
Словарь (dict) и множество (set) - это коллекции, основанные на хеш-таблицах. Они обеспечивают среднее время доступа O(1). Dict хранит пары ключ-значение, set - только уникальные элементы. Пример создания:
d = {'apple': 5, 'banana': 3}
s = {1, 2, 3, 2}значения списка числа python (итерация по значениям списка чисел в python)
Доступ к элементу словаря: d['apple'] - возвращает 5. Если ключа нет, возникает KeyError. Безопаснее использовать d.get('orange', 0).
Добавление элемента в set: s.add(4). Проверка вхождения: 3 in s.
Важно: ключи dict и элементы set должны быть хешируемыми (числа, строки, кортежи, frozenset). Изменяемые типы (list, dict) недопустимы.
Как проверить, есть ли ключ в словаре?
if 'apple' in d:
print(d['apple'])словарь set python (словарь и set в python)
Оператор in выполняет проверку за O(1). В старых версиях Python использовался метод has_key(), который считается устаревшим.
d.has_key('apple') в Python 3 вызовет AttributeError.Как объединить два словаря?
d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
# Способ 1: update()
d1.update(d2) # d1 изменяется, {'a':1, 'b':3, 'c':4}
# Способ 2: оператор | (Python 3.9+)
merged = d1 | d2
# Способ 3: распаковка
merged = {**d1, **d2}Python dict set (словарь и множество в python)
При совпадении ключей значение берется из второго словаря. Порядок сохраняется (начиная с Python 3.7).
update() изменяет исходный словарь, что может быть неожиданно. Оператор | создает новый.Как создать словарь с одинаковыми значениями для нескольких ключей?
keys = ['a', 'b', 'c']
d = dict.fromkeys(keys, 0)
# {'a':0, 'b':0, 'c':0}типы структур python (типы структур данных в python)
fromkeys - классовый метод, принимает итерируемый объект с ключами и значение по умолчанию. Если значением является изменяемый объект, все ключи будут ссылаться на один и тот же экземпляр, что может привести к побочным эффектам.
d = {k: [] for k in keys} - корректно, а dict.fromkeys(keys, []) - все ключи указывают на один список.Как удалить дубликаты из списка, сохранив порядок?
lst = [3, 1, 2, 3, 2, 4]
unique = list(dict.fromkeys(lst)) # или OrderedDict.fromkeys в старых версиях
# [3, 1, 2, 4]вложенные структуры данных в python (вложенные структуры данных в python)
Использование set(lst) не гарантирует порядок. dict.fromkeys использует словарь для дедупликации (ключи уникальны) и сохраняет порядок вставки (Python 3.7+).
OrderedDict.Как найти элементы, присутствующие в обоих множествах?
a = {1, 2, 3}
b = {2, 3, 4}
intersection = a & b # {2, 3}кортеж чисел python (кортеж чисел в python)
Оператор & и метод intersection() возвращают новое множество. Также есть union (|), difference (-), symmetric_difference (^).
Как получить уникальные значения из словаря?
d = {'x': 1, 'y': 2, 'z': 1}
unique_vals = set(d.values()) # {1, 2}язык программирования python массивы (массивы (списки) в python)
Преобразуем итератор значений в множество. Проблема, если значения нехешируемые - будет TypeError.
Как отсортировать словарь по ключам?
d = {'banana': 3, 'apple': 5, 'cherry': 2}
sorted_items = sorted(d.items()) # [('apple',5), ('banana',3), ('cherry',2)]
new_dict = dict(sorted_items) # {'apple':5, 'banana':3, 'cherry':2}массивы данных python 3 (массивы данных в python)
Сортировка возвращает список кортежей, затем можно создать новый словарь (порядок сохранится). Похожим образом сортируют по значениям, используя key=lambda x: x[1].
Как проверить, что одно множество является подмножеством другого?
a = {1, 2}
b = {1, 2, 3}
print(a <= b) # True
print(a.issubset(b))Также есть >= для надмножества.
Типичные ошибки при работе с dict и set
- Использование списка как ключа:
d[[1,2]] = 3вызывает TypeError: unhashable type: 'list'. Решение - преобразовать в кортеж или frozenset. - Попытка добавить изменяемый объект в set:
s.add([1,2])также вызывает TypeError. - Предположение, что set сохраняет порядок: множество неупорядочено, хотя в современных версиях порядок может случайно сохраняться для маленьких чисел, полагаться нельзя.
- Изменение словаря во время итерации:
for k in d: del d[k]вызывает RuntimeError. Решение - итерировать по копии ключей:for k in list(d):
Пример 1: подсчет частоты элементов с Counter
from collections import Counter
lst = ['a', 'b', 'a', 'c', 'b', 'a', 'a']
cnt = Counter(lst)
print(cnt)
print(cnt.most_common(2))Counter({'a': 4, 'b': 2, 'c': 1})
[('a', 4), ('b', 2)]
Counter - это подкласс dict, автоматически подсчитывает количество вхождений. Метод most_common возвращает список кортежей с частотами.
Пример 2: инвертирование словаря (значения -> список ключей)
original = {'apple': 'fruit', 'carrot': 'vegetable', 'banana': 'fruit'}
inverted = {}
for k, v in original.items():
inverted.setdefault(v, []).append(k)
print(inverted){'fruit': ['apple', 'banana'], 'vegetable': ['carrot']}
Метод setdefault создает пустой список, если ключа нет, и присоединяет к нему текущий ключ. Такой подход позволяет группировать значения.
Пример 3: использование frozenset в качестве ключа словаря
fs1 = frozenset([1,2])
fs2 = frozenset([2,3])
d = {fs1: 'A', fs2: 'B'}
print(d[frozenset([3,2])]) # 'B' (так как frozenset нечувствителен к порядку)B
frozenset - неизменяемая версия set, поэтому может быть ключом dict или элементом другого set. Полезно для хранения неупорядоченных наборов данных.
Пример 4: слияние словарей с помощью оператора | (Python 3.9+)
d1 = {'x': 1, 'y': 2}
d2 = {'y': 3, 'z': 4}
merged = d1 | d2
merged |= {'w': 5} # оператор |= изменяет merged на месте
print(merged){'x': 1, 'y': 3, 'z': 4, 'w': 5}
Операторы | и |= появились в Python 3.9. Они создают новый словарь (или обновляют) с объединенными ключами. Значения из правого операнда перезаписывают левый.
Пример 5: поиск общих друзей с использованием set
user1_friends = {'Alice', 'Bob', 'Charlie'}
user2_friends = {'Bob', 'David', 'Eve'}
common = user1_friends & user2_friends
all_friends = user1_friends | user2_friends
unique_to_user1 = user1_friends - user2_friends
print(f'Общие: {common}')
print(f'Все уникальные: {all_friends}')
print(f'Только у первого: {unique_to_user1}')Общие: {'Bob'}
Все уникальные: {'Alice', 'Bob', 'Charlie', 'David', 'Eve'}
Только у первого: {'Alice', 'Charlie'}
Множества удобны для операций над множествами без циклов.
Пример 6: сравнение производительности поиска в list и set
import timeit
lst = list(range(100000))
st = set(lst)
print(timeit.timeit('99999 in lst', globals=globals(), number=1000))
print(timeit.timeit('99999 in st', globals=globals(), number=1000))0.0745 (время в секундах для list) 0.0003 (время в seconds для set)
Поиск в set происходит значительно быстрее за счет хеш-таблицы. Это особенно заметно на больших данных.
Пример 7: работа с defaultdict для автозаполнения
from collections import defaultdict
dd = defaultdict(list)
dd['group'].append('item1')
dd['group'].append('item2')
print(dd)defaultdict(<class 'list'>, {'group': ['item1', 'item2']})
defaultdict использует фабричную функцию для создания значений по умолчанию при обращении к отсутствующему ключу. Это избавляет от проверок на существование.