Словари Python: инструкция по использованию для разработчиков

# Пустой словарь
empty_dict = {}

# Словарь с данными
user = {'name': 'Анна', 'age': 28, 'profession': 'Дизайнер'}

# Пустой словарь
another_empty = dict()

# Из списка кортежей
items = [('a', 1), ('b', 2), ('c', 3)]
dict_from_items = dict(items) # {'a': 1, 'b': 2, 'c': 3}

# Из именованных аргументов
params = dict(x=100, y=200, z=300) # {'x': 100, 'y': 200, 'z': 300}

# Генерация словаря квадратов чисел
squares = {x: x**2 for x in range(6)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

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

# Создание словаря с одинаковыми значениями
keys = ['name', 'age', 'email']
user_template = dict.fromkeys(keys, None) # {'name': None, 'age': None, 'email': None}

# С использованием значения по умолчанию
default_settings = dict.fromkeys(['theme', 'language', 'notifications'], False)

# Используя распаковку
defaults = {'theme': 'dark', 'language': 'en'}
user_settings = {'language': 'fr', 'notifications': True}
merged = {**defaults, **user_settings} # {'theme': 'dark', 'language': 'fr', 'notifications': True}

# Python 3.9+: оператор |
final_settings = defaults | user_settings # Тот же результат, что и выше

# Вложенные словари
person = {
'name': 'Михаил',
'age': 34,
'address': {
'city': 'Москва',
'street': 'Ленина',
'building': 10
},
'skills': ['Python', 'SQL', 'Git']
}

user = {'name': 'Елена', 'age': 31, 'city': 'Казань'}

# Прямой доступ по ключу
print(user['name']) # Елена

# Безопасный доступ с методом get()
print(user.get('email')) # None
print(user.get('email', 'не указан')) # не указан

# Доступ с проверкой существования ключа
if 'age' in user:
print(f"Возраст: {user['age']}")

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

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

# Добавление нескольких элементов
user.update({'phone': '+7 123 456 78 90', 'role': 'manager'})

# Условное добавление (только если ключ отсутствует)
user.setdefault('status', 'active') # Добавит только если 'status' нет

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

# Удаление по ключу с обработкой отсутствующих ключей
deleted_value = user.pop('non_existent_key', 'ключ отсутствует') # Не вызовет ошибку

# Удаление и возврат произвольной пары (последней в Python 3.7+)
last_item = user.popitem() # Например, ('status', 'active')

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

# Очистка всего словаря
user.clear() # Словарь становится пустым: {}

product = {
'name': 'Ноутбук',
'price': 75000,
'brand': 'Lenovo',
'in_stock': True
}

# Итерация по ключам (наиболее эффективный способ)
for key in product:
print(key, product[key])

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

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

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

# Поверхностное копирование (shallow copy)
original = {'a': 1, 'b': [1, 2, 3]}
shallow_copy = original.copy() # или dict(original)

# Глубокое копирование (deep copy)
import copy
deep_copy = copy.deepcopy(original)

# Различие проявляется при изменении вложенных объектов
original['b'].append(4) 
print(shallow_copy['b']) # [1, 2, 3, 4] – изменилось!
print(deep_copy['b']) # [1, 2, 3] – не изменилось

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
dict3 = {'a': 1, 'b': 2, 'c': 3}

# Сравнение на равенство (порядок не имеет значения)
print(dict1 == dict2) # True
print(dict1 == dict3) # False

# Проверка наличия ключа
print('a' in dict1) # True
print('z' not in dict1) # True

# Проверка на пустоту
empty_dict = {}
if not empty_dict:
print("Словарь пуст")

# Преобразование в список
keys_list = list(dict1.keys())
values_list = list(dict1.values())
items_list = list(dict1.items())

# Объединение словарей (Python 3.9+)
combined = dict1 | dict3 # {'a': 1, 'b': 2, 'c': 3}

# Фильтрация элементов
filtered = {k: v for k, v in dict3.items() if v > 1} # {'b': 2, 'c': 3}

config = {'debug': True, 'port': 8080, 'host': 'localhost'}

# Безопасное получение с дефолтным значением
timeout = config.get('timeout', 30) # 30, так как 'timeout' отсутствует

# Работа с представлениями
print(list(config.keys())) # ['debug', 'port', 'host']
print(list(config.values())) # [True, 8080, 'localhost']

# Динамическая природа представлений
keys_view = config.keys()
config['protocol'] = 'http'
print(list(keys_view)) # ['debug', 'port', 'host', 'protocol']

user_prefs = {'theme': 'dark'}

# Обновление из другого словаря
user_prefs.update({'font_size': 14, 'theme': 'light'})
print(user_prefs) # {'theme': 'light', 'font_size': 14}

# Обновление из именованных аргументов
user_prefs.update(notifications=True, language='ru')
print(user_prefs) # {'theme': 'light', 'font_size': 14, 'notifications': True, 'language': 'ru'}

# Использование setdefault
cache = {}
value = cache.setdefault('key1', []) # Добавит 'key1': [] и вернёт []
value.append('data') # Изменит список по ссылке
print(cache) # {'key1': ['data']}

# Не изменит существующее значение
existing = cache.setdefault('key1', 'new_default') # Вернёт ['data'], не изменяя словарь

settings = {'volume': 80, 'brightness': 70, 'contrast': 50, 'gamma': 1.2}

# Удаление с возвратом значения
volume = settings.pop('volume') # volume = 80
print(settings) # {'brightness': 70, 'contrast': 50, 'gamma': 1.2}

# Обработка отсутствующих ключей
try:
settings.pop('non_existent') # KeyError
except KeyError:
pass

# Безопасное удаление с дефолтом
saturation = settings.pop('saturation', 'не найдено') # 'не найдено'

# Удаление последнего добавленного элемента
last_item = settings.popitem() # ('gamma', 1.2)
print(settings) # {'brightness': 70, 'contrast': 50}

# Очистка словаря
settings.clear()
print(settings) # {}

original = {'user': {'name': 'Алиса', 'id': 123}, 'active': True}
copied = original.copy()

# Демонстрация поверхностного копирования
copied['active'] = False # Не влияет на original
copied['user']['name'] = 'Боб' # Влияет на original!

print(original) # {'user': {'name': 'Боб', 'id': 123}, 'active': True}
print(copied) # {'user': {'name': 'Боб', 'id': 123}, 'active': False}

# Создание словаря с одинаковыми значениями
fields = ['username', 'email', 'password']
form = dict.fromkeys(fields, '')
print(form) # {'username': '', 'email': '', 'password': ''}

# Опасность при использовании изменяемых значений
dangerous = dict.fromkeys(['list1', 'list2'], [])
dangerous['list1'].append(1) # Изменит все списки!
print(dangerous) # {'list1': [1], 'list2': [1]}

# Правильный подход
safe = {key: [] for key in ['list1', 'list2']}
safe['list1'].append(1) # Изменит только список 'list1'
print(safe) # {'list1': [1], 'list2': []}

# Python 3.9+
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# Объединение (создает новый словарь)
combined = dict1 | dict2 # {'a': 1, 'b': 3, 'c': 4}

# Обновление на месте
dict1 |= dict2 # dict1 теперь {'a': 1, 'b': 3, 'c': 4}

# Подсчёт частоты слов в тексте
def word_frequency(text):
words = text.lower().split()
frequency = {}
for word in words:
# Элегантный способ инкрементировать счетчик
frequency[word] = frequency.get(word, 0) + 1
return frequency

text = "Программирование на Python – это просто просто просто"
print(word_frequency(text))
# {'программирование': 1, 'на': 1, 'python': 1, '-': 1, 'это': 1, 'просто': 3}

# Мемоизация вычисления чисел Фибоначчи
def fibonacci_memo(n, cache={}):
if n in cache:
return cache[n]
if n <= 1:
return n
result = fibonacci_memo(n-1) + fibonacci_memo(n-2)
cache[n] = result
return result

# Сравните время выполнения с обычной рекурсивной версией!
print(fibonacci_memo(100)) # Мгновенный результат для большого n

# Группировка студентов по курсам
students = [
{'name': 'Анна', 'course': 'Python', 'grade': 95},
{'name': 'Борис', 'course': 'Java', 'grade': 85},
{'name': 'Вера', 'course': 'Python', 'grade': 92},
{'name': 'Глеб', 'course': 'Java', 'grade': 88}
]

def group_by_course(students):
groups = {}
for student in students:
course = student['course']
if course not in groups:
groups[course] = []
groups[course].append(student)
return groups

print(group_by_course(students))
# {'Python': [{'name': 'Анна', ...}, {'name': 'Вера', ...}], 
# 'Java': [{'name': 'Борис', ...}, {'name': 'Глеб', ...}]}

# Граф как словарь смежности
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}

# Поиск в ширину (BFS) с использованием словаря графа
from collections import deque

def bfs(graph, start):
visited = set([start])
queue = deque([start])
while queue:
vertex = queue.popleft()
print(vertex, end=' ')
for neighbor in graph[vertex]:
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)

bfs(graph, 'A') # A B C D E F

# Базовая конфигурация и её обновление
default_config = {
'database': {
'host': 'localhost',
'port': 5432,
'user': 'admin',
'password': 'default',
'timeout': 30
},
'logging': {
'level': 'INFO',
'format': '%(asctime)s – %(name)s – %(levelname)s – %(message)s',
'file': 'app.log'
},
'web': {
'port': 8080,
'debug': False
}
}

# Обновление настроек для разных сред
production_overrides = {
'database': {
'host': 'db.production.example.com',
'password': 'prod_secure_password',
'pool_size': 100 # Новая настройка, отсутствующая в дефолтной конфигурации
},
'logging': {
'level': 'WARNING'
},
'web': {
'debug': False
}
}

# Глубокое обновление вложенных словарей
def deep_update(source, overrides):
for key, value in overrides.items():
if isinstance(value, dict) and key in source:
deep_update(source[key], value)
else:
source[key] = value
return source

config = deep_update(default_config.copy(), production_overrides)
print(config['database']['host']) # db.production.example.com
print(config['database']['port']) # 5432 (из дефолтных настроек)

# Диспетчеризация операций через словарь функций
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 "Error: division by zero"

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

def calculate(x, operation, y):
if operation in operations:
return operations[operation](x, y)
return "Unknown operation"

print(calculate(10, '+', 5)) # 15
print(calculate(10, '*', 5)) # 50
print(calculate(10, '/', 0)) # Error: division by zero

# Преобразование данных API
api_response = {
'user_id': 12345,
'user_name': 'john_doe',
'user_email': 'john@example.com',
'account_type': 'premium',
'is_active': True,
'last_login': '2023-05-15T14:30:45Z'
}

# Маппинг полей API на поля вашей системы
field_mapping = {
'user_id': 'id',
'user_name': 'username',
'user_email': 'email',
'account_type': 'subscription',
'is_active': 'active',
'last_login': 'last_seen'
}

# Преобразование данных
transformed_data = {field_mapping.get(k, k): v for k, v in api_response.items()}
print(transformed_data)
# {'id': 12345, 'username': 'john_doe', 'email': 'john@example.com', 
# 'subscription': 'premium', 'active': True, 'last_seen': '2023-05-15T14:30:45Z'}