Словари Python: мощный инструмент для эффективного хранения данных

# Прямой доступ по ключу
user = {'name': 'John', 'age': 30}
print(user['name']) # John

# Безопасный доступ через get() с значением по умолчанию
print(user.get('email', 'not specified')) # not specified

# Добавление нового элемента
user['email'] = 'john@example.com'

# Изменение существующего элемента
user['age'] = 31

# Обновление нескольких элементов одновременно
user.update({'age': 32, 'city': 'New York'})

# Удаление по ключу с возвратом значения
age = user.pop('age') # age = 32, элемент удален из словаря

# Удаление и возврат произвольной пары
item = user.popitem() # Возвращает и удаляет последнюю добавленную пару

# Удаление по ключу без возврата значения
del user['email']

# Очистка всего словаря
user.clear()

# Проверка наличия ключа
if 'name' in user:
print("Name exists")

# Проверка отсутствия ключа
if 'phone' not in user:
user['phone'] = '+1234567890'

# Итерация по ключам (по умолчанию)
for key in user:
print(key)

# Явная итерация по ключам
for key in user.keys():
print(key)

# Итерация по значениям
for value in user.values():
print(value)

# Итерация по парам ключ-значение
for key, value in user.items():
print(f"{key}: {value}")

# Создание словаря квадратов чисел
squares = {x: x**2 for x in range(10)}

# Фильтрация с условием
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

# Преобразование существующего словаря
prices = {'apple': 0.5, 'orange': 0.8, 'pear': 0.4}
discount_prices = {fruit: price * 0.9 for fruit, price in prices.items()}

# Создание словаря из двух списков
keys = ['a', 'b', 'c']
values = [1, 2, 3]
mapped = {k: v for k, v in zip(keys, values)}

# Вложенные словари
employee = {
'name': 'Anna',
'position': 'Developer',
'skills': {
'languages': ['Python', 'JavaScript'],
'frameworks': {
'backend': ['Django', 'Flask'],
'frontend': ['React']
}
}
}

# Доступ к вложенным элементам
backend_skills = employee['skills']['frameworks']['backend'] # ['Django', 'Flask']

# Глубокое копирование вложенных структур
import copy
employee_copy = copy.deepcopy(employee)

from collections import defaultdict

# Словарь, автоматически создающий списки
word_counts = defaultdict(int)
for word in "how much wood would a woodchuck chuck".split():
word_counts[word] += 1
print(dict(word_counts)) # {'how': 1, 'much': 1, 'wood': 1, 'would': 1, 'a': 1, 'woodchuck': 1, 'chuck': 1}

# Создание вложенных структур с defaultdict
nested = defaultdict(lambda: defaultdict(list))
nested['users']['active'].append('user1')
nested['users']['active'].append('user2')

from collections import OrderedDict

# Создание упорядоченного словаря
od = OrderedDict([('first', 1), ('second', 2), ('third', 3)])

# Перемещение элемента в конец
od.move_to_end('first')
print(od) # OrderedDict([('second', 2), ('third', 3), ('first', 1)])

# Обратный порядок
od = OrderedDict(sorted(od.items(), reverse=True))

# Python 3.9+ синтаксис объединения
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = dict1 | dict2 # {'a': 1, 'b': 3, 'c': 4}

# Для более ранних версий Python
merged = {**dict1, **dict2}

# С помощью update (изменяет первый словарь)
result = dict1.copy()
result.update(dict2)

from collections import ChainMap

# Несколько источников конфигурации
defaults = {'theme': 'dark', 'language': 'en'}
user_settings = {'theme': 'light'}

# Создание цепи с приоритетом: сначала проверяются user_settings, затем defaults
settings = ChainMap(user_settings, defaults)
print(settings['theme']) # 'light' из user_settings
print(settings['language']) # 'en' из defaults

from collections import Counter

# Подсчет слов в тексте
words = "to be or not to be that is the question".split()
word_count = Counter(words)
print(word_count) # Counter({'to': 2, 'be': 2, 'or': 1, 'not': 1, 'that': 1, 'is': 1, 'the': 1, 'question': 1})

# Нахождение наиболее часто встречающихся элементов
most_common = word_count.most_common(2) # [('to', 2), ('be', 2)]

# Математические операции с счетчиками
counter1 = Counter(['a', 'b', 'c', 'a'])
counter2 = Counter(['a', 'd', 'e'])
print(counter1 + counter2) # Counter({'a': 3, 'b': 1, 'c': 1, 'd': 1, 'e': 1})
print(counter1 – counter2) # Counter({'b': 1, 'c': 1, 'a': 1})

# Трансформация словаря с map и lambda
prices = {'apple': 0.5, 'orange': 0.8, 'pear': 0.4}
dollar_to_euro = 0.85
euro_prices = dict(map(lambda item: (item[0], item[1] * dollar_to_euro), prices.items()))

# Фильтрация словаря с dict comprehension
expensive = {k: v for k, v in prices.items() if v > 0.6}

# Редукция (сложение всех значений)
total_price = sum(prices.values())

def count_words(text):
words = text.lower().split()
word_count = {}
for word in words:
# Удаляем пунктуацию
word = word.strip('.,!?:;()"\'')
if word:
word_count[word] = word_count.get(word, 0) + 1
return word_count

text = "To be, or not to be, that is the question."
frequencies = count_words(text)
print(frequencies)
# {'to': 2, 'be': 2, 'or': 1, 'not': 1, 'that': 1, 'is': 1, 'the': 1, 'question': 1}

def group_by_department(employees):
departments = {}
for employee in employees:
dept = employee['department']
if dept not in departments:
departments[dept] = []
departments[dept].append(employee['name'])
return departments

employees = [
{'name': 'Alice', 'department': 'Development'},
{'name': 'Bob', 'department': 'HR'},
{'name': 'Charlie', 'department': 'Development'},
{'name': 'Diana', 'department': 'Marketing'}
]

grouped = group_by_department(employees)
print(grouped)
# {'Development': ['Alice', 'Charlie'], 'HR': ['Bob'], 'Marketing': ['Diana']}

def memoize(func):
"""Декоратор для кэширования результатов функции"""
cache = {}
def wrapper(*args):
if args in cache:
return cache[args]
result = func(*args)
cache[args] = result
return result
return wrapper

@memoize
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)

# Без кэширования это заняло бы значительно больше времени
print(fibonacci(35)) # 9227465

from collections import deque

def build_graph(edges):
"""Построение графа из списка рёбер"""
graph = {}
for a, b in edges:
if a not in graph:
graph[a] = []
if b not in graph:
graph[b] = []
graph[a].append(b)
graph[b].append(a) # Для неориентированного графа
return graph

def bfs(graph, start):
"""Обход графа в ширину"""
visited = {start}
queue = deque([start])
result = []

while queue:
vertex = queue.popleft()
result.append(vertex)

for neighbor in graph[vertex]:
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)

return result

edges = [('A', 'B'), ('A', 'C'), ('B', 'D'), ('C', 'D'), ('C', 'E')]
graph = build_graph(edges)
print(bfs(graph, 'A')) # ['A', 'B', 'C', 'D', 'E']

class LRUCache:
def __init__(self, capacity):
self.capacity = capacity
self.cache = {}
self.order = []

def get(self, key):
if key in self.cache:
# Обновляем порядок использования
self.order.remove(key)
self.order.append(key)
return self.cache[key]
return -1

def put(self, key, value):
if key in self.cache:
self.order.remove(key)
elif len(self.cache) >= self.capacity:
# Удаляем наименее недавно использованный элемент
oldest = self.order.pop(0)
del self.cache[oldest]

self.cache[key] = value
self.order.append(key)

cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
print(cache.get(1)) # 1
cache.put(3, 3) # удаляет ключ 2
print(cache.get(2)) # -1 (не найден)

class JsonObject:
def __init__(self, data=None):
self._data = {} if data is None else data

def __getattr__(self, key):
if key in self._data:
value = self._data[key]
if isinstance(value, dict):
return JsonObject(value)
return value
raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")

def __setattr__(self, key, value):
if key == "_data":
super().__setattr__(key, value)
else:
self._data[key] = value

def to_dict(self):
return self._data

# Использование
user = JsonObject()
user.name = "John Doe"
user.contact = JsonObject()
user.contact.email = "john@example.com"
user.contact.phone = "123-456-7890"

print(user.name) # John Doe
print(user.contact.email) # john@example.com
print(user.to_dict()) # {'name': 'John Doe', 'contact': {'email': 'john@example.com', 'phone': '123-456-7890'}}

# Предварительное выделение размера (только для CPython)
# Предотвращает многократное изменение размера словаря
from collections import defaultdict

# Менее эффективно (много ресайзов)
slow_dict = {}
for i in range(10000000):
key = i % 1000
if key not in slow_dict:
slow_dict[key] = 0
slow_dict[key] += 1

# Более эффективно (избегаем проверок и ресайзов)
fast_dict = defaultdict(int)
for i in range(10000000):
fast_dict[i % 1000] += 1

# Используйте кортежи вместо списков для составных ключей
locations = {
('New York', 'USA'): {'population': 8.4e6, 'timezone': 'EST'},
('Tokyo', 'Japan'): {'population': 1.4e7, 'timezone': 'JST'}
}

# Для более сложных случаев используйте frozenset
# Когда порядок элементов не важен
tags1 = frozenset(['python', 'optimization'])
tags2 = frozenset(['optimization', 'python']) # Тот же хеш!

tag_stats = {
tags1: 24 # tags2 будет считаться тем же ключом
}

# Менее эффективно (два поиска ключа)
groups = {}
for name, group in [('Alice', 'admin'), ('Bob', 'user'), ('Charlie', 'admin')]:
if group not in groups:
groups[group] = []
groups[group].append(name)

# Более эффективно (один поиск ключа)
optimized = {}
for name, group in [('Alice', 'admin'), ('Bob', 'user'), ('Charlie', 'admin')]:
optimized.setdefault(group, []).append(name)

# Использование __slots__ для классов, хранящихся в словарях
class Point:
__slots__ = ('x', 'y') # Предотвращает создание __dict__
def __init__(self, x, y):
self.x = x
self.y = y

# Для очень больших наборов данных рассмотрите специализированные структуры
import array
coords = {'points': array.array('d', [1\.0, 2.0, 3.0, 4.0])} # Более эффективно, чем список

# Для очень больших словарей с целочисленными ключами рассмотрите array.array или numpy

# Паттерн "Стратегия" с использованием словаря функций
def add(x, y): return x + y
def subtract(x, y): return x – y
def multiply(x, y): return x * y
def divide(x, y): return x / y if y != 0 else float('inf')

operations = {
'+': add,
'-': subtract,
'*': multiply,
'/': divide
}

# Использование
def calculate(a, op, b):
return operations[op](a, b)

print(calculate(10, '+', 5)) # 15
print(calculate(10, '*', 5)) # 50

scores = {'Alice': 95, 'Bob': 87, 'Charlie': 92, 'David': 78}

# Сортировка по ключам
sorted_by_name = dict(sorted(scores.items()))

# Сортировка по значениям (по убыванию)
sorted_by_score = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))

# Для более сложных случаев, используйте operator.itemgetter
from operator import itemgetter
students = [
{'name': 'Alice', 'grade': 'A', 'score': 95},
{'name': 'Bob', 'grade': 'B', 'score': 87},
{'name': 'Charlie', 'grade': 'A', 'score': 92}
]

# Сортировка сначала по grade, затем по score
sorted_students = sorted(students, key=itemgetter('grade', 'score'), reverse=True)

import threading

# Проблема гонки данных
shared_dict = {}
def update_unsafe(key, value):
shared_dict[key] = value

# Решение с блокировкой
lock = threading.Lock()
def update_safe(key, value):
with lock:
shared_dict[key] = value

# Альтернативный подход — использование thread-safe структур данных
from queue import Queue
message_queue = Queue()

import timeit
import cProfile

# Сравнение скорости разных методов доступа
setup = "data = {'key': 'value'}"

print(timeit.timeit("x = data['key']", setup=setup, number=1000000))
print(timeit.timeit("x = data.get('key')", setup=setup, number=1000000))

# Для более сложных сценариев используйте cProfile
def process_large_dict():
large_dict = {i: i*i for i in range(100000)}
result = {}
for k, v in large_dict.items():
if v % 3 == 0:
result[k] = v
return result

cProfile.run('process_large_dict()')