Множества и словари Python: оптимизация кода для быстрой разработки

# Создание пустого множества
empty_set = set() # НЕ используйте {} для создания пустого множества!

# Создание множества с элементами
colors = {'red', 'green', 'blue', 'red'} # 'red' появится только один раз
print(colors) # Вывод: {'blue', 'green', 'red'} (порядок может отличаться)

# Создание множества из последовательности
numbers = set([1, 2, 3, 2, 1])
print(numbers) # Вывод: {1, 2, 3}

# Создание пустого словаря
empty_dict = {} # или dict()

# Создание словаря с данными
person = {
'name': 'Alice',
'age': 30,
'skills': ['Python', 'SQL', 'JavaScript']
}

# Доступ к элементам словаря
print(person['name']) # Вывод: Alice

# Добавление или изменение элементов
person['email'] = 'alice@example.com'
person['age'] = 31

# Проверка наличия ключа
if 'name' in person:
print(f"Имя: {person['name']}")

# Определим два множества
developers = {'Alice', 'Bob', 'Charlie', 'David'}
designers = {'Charlie', 'Eve', 'Frank', 'David'}

# 1. Объединение множеств (union)
all_team = developers | designers # или developers.union(designers)
print(f"Вся команда: {all_team}")
# Результат: {'Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'}

# 2. Пересечение множеств (intersection)
multiskilled = developers & designers # или developers.intersection(designers)
print(f"Владеют и разработкой, и дизайном: {multiskilled}")
# Результат: {'Charlie', 'David'}

# 3. Разность множеств (difference)
only_developers = developers – designers # или developers.difference(designers)
print(f"Только разработчики: {only_developers}")
# Результат: {'Alice', 'Bob'}

# 4. Симметрическая разность (symmetric difference)
exclusive_roles = developers ^ designers # или developers.symmetric_difference(designers)
print(f"Специалисты только одного профиля: {exclusive_roles}")
# Результат: {'Alice', 'Bob', 'Eve', 'Frank'}

# Определим дополнительные множества для примера
senior_devs = {'Alice', 'David'}
python_devs = {'Alice', 'Bob', 'Charlie'}
js_devs = {'Bob', 'Charlie', 'David'}

# Проверка на подмножество (subset)
print(senior_devs.issubset(developers)) # True – все senior_devs содержатся в developers
print(developers.issubset(python_devs)) # False – не все developers содержатся в python_devs

# Проверка на надмножество (superset)
print(developers.issuperset(senior_devs)) # True – developers содержит все элементы senior_devs
print(python_devs.issuperset(developers)) # False – python_devs не содержит все элементы developers

# Проверка на отсутствие общих элементов (disjoint)
print(python_devs.isdisjoint(designers)) # False – есть общие элементы (Charlie)

# Создание новой команды и проверка пересечения
qa_team = {'Grace', 'Henry', 'Ivy'}
print(qa_team.isdisjoint(developers)) # True – нет общих элементов

# Создаем множество для модификации
technologies = {'Python', 'JavaScript', 'CSS', 'HTML'}
new_tech = {'React', 'Node.js', 'Python'}

# Обновление множества (добавление элементов из другого множества)
technologies.update(new_tech)
print(f"После update: {technologies}")
# Результат: {'Python', 'JavaScript', 'CSS', 'HTML', 'React', 'Node.js'}

# Пересечение с обновлением (оставляет только общие элементы)
technologies.intersection_update(new_tech)
print(f"После intersection_update: {technologies}")
# Результат: {'Python', 'React', 'Node.js'}

# Разность с обновлением (удаляет элементы, присутствующие в другом множестве)
frontend = {'React', 'JavaScript', 'CSS', 'HTML'}
backend = {'Python', 'Node.js', 'SQL'}
frontend.difference_update(backend)
print(f"Только frontend технологии: {frontend}")
# Результат: {'React', 'JavaScript', 'CSS', 'HTML'}

# Симметрическая разность с обновлением
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a.symmetric_difference_update(b)
print(f"После symmetric_difference_update: {a}")
# Результат: {1, 2, 5, 6}

# Создание словаря
user = {
'username': 'pythonista',
'email': 'python@example.com',
'active': True,
'access_level': 3,
'groups': ['developers', 'beta_testers']
}

# Доступ к значениям
print(user['username']) # pythonista

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

# Изменение существующего значения
user['active'] = False

# Добавление нового ключа-значения
user['last_login'] = '2023-05-15'

# Удаление ключа-значения
del user['access_level']

# Получение всех ключей, значений и пар
print(list(user.keys()))
print(list(user.values()))
print(list(user.items()))

# Объединение словарей (Python 3.5+)
user_preferences = {'theme': 'dark', 'notifications': True}
default_settings = {'language': 'en', 'theme': 'light', 'notifications': False}

# Обновление с приоритетом первого словаря
merged = {**default_settings, **user_preferences}
print(merged)
# Результат: {'language': 'en', 'theme': 'dark', 'notifications': True}

# Используем метод update() для обновления словаря
default_settings.update(user_preferences)
print(default_settings)
# Результат: {'language': 'en', 'theme': 'dark', 'notifications': True}

# Слияние словарей (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict1 | dict2 # {'a': 1, 'b': 3, 'c': 4}

# Безопасное удаление и возврат значения
removed_value = user.pop('groups', []) # Удаляет 'groups' и возвращает его значение
print(removed_value) # ['developers', 'beta_testers']

# Удаление и возврат произвольной пары (обычно последней добавленной в Python 3.7+)
last_item = user.popitem()
print(last_item) # Например: ('last_login', '2023-05-15')

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

# Создание словаря с значениями по умолчанию
from collections import defaultdict

# Словарь, возвращающий 0 для несуществующих ключей
word_count = defaultdict(int)
for word in "to be or not to be".split():
word_count[word] += 1

print(word_count)
# defaultdict(<class 'int'>, {'to': 2, 'be': 2, 'or': 1, 'not': 1})

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

# Фильтрация словаря (Python 3.7+ гарантирует сохранение порядка)
even_squares = {k: v for k, v in squares.items() if k % 2 == 0}
print(even_squares) # {2: 4, 4: 16}

# Трансформация словаря
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

# Создание словаря из двух списков
student_scores = dict(zip(names, scores))
print(student_scores) # {'Alice': 85, 'Bob': 92, 'Charlie': 78}

# Инвертирование словаря (ключи становятся значениями и наоборот)
# Осторожно: значения должны быть уникальными и хешируемыми!
inverted = {v: k for k, v in student_scores.items()}
print(inverted) # {85: 'Alice', 92: 'Bob', 78: 'Charlie'}

# Неоптимальный подход: использование циклов
def remove_duplicates_slow(items):
result = []
for item in items:
if item not in result: # O(n) операция для списка
result.append(item)
return result

# Оптимизированный подход: использование множества
def remove_duplicates_fast(items):
return list(set(items)) # O(n) общее время выполнения

# Сравнение производительности на большом списке с дубликатами
import time
import random

data = [random.randint(1, 1000) for _ in range(10000)]

start = time.time()
result1 = remove_duplicates_slow(data)
end = time.time()
print(f"Медленный способ: {end – start:.6f} сек")

start = time.time()
result2 = remove_duplicates_fast(data)
end = time.time()
print(f"Быстрый способ: {end – start:.6f} сек")
# Обычно быстрый способ в десятки раз быстрее

# Неоптимальный подход: использование списков
def count_elements_slow(items):
unique_items = []
counts = []
for item in items:
if item in unique_items:
index = unique_items.index(item) # O(n) операция
counts[index] += 1
else:
unique_items.append(item)
counts.append(1)
return list(zip(unique_items, counts))

# Оптимизированный подход: использование словаря
def count_elements_fast(items):
counter = {}
for item in items:
counter[item] = counter.get(item, 0) + 1 # O(1) операция
return list(counter.items())

# Ещё лучше: использование Counter из collections
from collections import Counter

def count_elements_fastest(items):
return list(Counter(items).items())

# Неоптимальный подход: вложенные циклы
def find_common_slow(list1, list2):
common = []
for item1 in list1:
for item2 in list2:
if item1 == item2 and item1 not in common:
common.append(item1)
return common

# Оптимизированный подход: использование множеств
def find_common_fast(list1, list2):
return list(set(list1) & set(list2))

# Аналогично для уникальных элементов
def find_unique_in_first_fast(list1, list2):
return list(set(list1) – set(list2))

# Использование словаря как кеша для вычислений
def fibonacci_cached(n, cache={}):
if n in cache: # O(1) поиск в словаре
return cache[n]
if n <= 1:
result = n
else:
result = fibonacci_cached(n-1, cache) + fibonacci_cached(n-2, cache)
cache[n] = result
return result

# Более элегантное решение с декоратором lru_cache
from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_lru(n):
if n <= 1:
return n
return fibonacci_lru(n-1) + fibonacci_lru(n-2)

# Допустим, у нас есть логи посещений сайта разными пользователями по дням
monday_visitors = {'user1', 'user2', 'user3', 'user4', 'user5'}
tuesday_visitors = {'user2', 'user5', 'user6', 'user7'}
wednesday_visitors = {'user1', 'user3', 'user5', 'user7', 'user8'}

# Пользователи, посетившие сайт во все три дня
loyal_visitors = monday_visitors & tuesday_visitors & wednesday_visitors
print(f"Постоянные посетители: {loyal_visitors}") # {'user5'}

# Пользователи, посетившие сайт хотя бы в один из дней
all_visitors = monday_visitors | tuesday_visitors | wednesday_visitors
print(f"Всего уникальных посетителей: {len(all_visitors)}") # 8

# Пользователи, посетившие сайт только в понедельник
monday_only = monday_visitors – (tuesday_visitors | wednesday_visitors)
print(f"Только в понедельник: {monday_only}") # {'user4'}

# Пользователи, посетившие ровно один день
one_time_visitors = (monday_visitors ^ tuesday_visitors ^ wednesday_visitors) – \
((monday_visitors & tuesday_visitors) | 
(monday_visitors & wednesday_visitors) | 
(tuesday_visitors & wednesday_visitors))
print(f"Одноразовые посетители: {one_time_visitors}")

text = """
Python is a programming language that lets you work quickly
and integrate systems more effectively. Python is powerful and fast;
plays well with others; runs everywhere; is friendly and easy to learn;
is Open Source; has a supportive community.
"""

# Подсчет частоты слов (с приведением к нижнему регистру и удалением знаков препинания)
import re
from collections import Counter

words = re.findall(r'\w+', text.lower())
word_counts = Counter(words)

# Топ-5 самых частых слов
print(word_counts.most_common(5))
# Пример вывода: [('is', 4), ('and', 3), ('python', 2), ('a', 2), ('to', 2)]

# Слова, встречающиеся ровно один раз
hapax_legomena = [word for word, count in word_counts.items() if count == 1]
print(f"Слова, встречающиеся один раз: {hapax_legomena}")

# Представим, что у нас есть список студентов с их оценками
students = [
{'id': 1, 'name': 'Alice', 'grade': 'A', 'course': 'Python'},
{'id': 2, 'name': 'Bob', 'grade': 'B', 'course': 'JavaScript'},
{'id': 3, 'name': 'Charlie', 'grade': 'A', 'course': 'Python'},
{'id': 4, 'name': 'Dave', 'grade': 'C', 'course': 'JavaScript'},
{'id': 5, 'name': 'Eve', 'grade': 'A', 'course': 'SQL'},
{'id': 6, 'name': 'Frank', 'grade': 'B', 'course': 'Python'}
]

# Создание индекса для быстрого доступа по ID
student_by_id = {student['id']: student for student in students}
print(student_by_id[3]) # Быстрый доступ к данным Charlie

# Группировка студентов по курсам
from collections import defaultdict

students_by_course = defaultdict(list)
for student in students:
students_by_course[student['course']].append(student)

print(f"Студенты курса Python: {len(students_by_course['Python'])}") # 3

# Подсчет количества студентов с каждой оценкой по курсам
grade_counts_by_course = {}
for course, course_students in students_by_course.items():
grade_counts = Counter(student['grade'] for student in course_students)
grade_counts_by_course[course] = dict(grade_counts)

print(grade_counts_by_course)
# {'Python': {'A': 2, 'B': 1}, 'JavaScript': {'B': 1, 'C': 1}, 'SQL': {'A': 1}}

# Допустим, у нас есть список продуктов, некоторые с разным написанием, но фактически одинаковые
products = [
"iPhone", "iphone", "IPHONE", "iPhone 13",
"Samsung Galaxy", "samsung galaxy", "Samsung galaxy",
"iPad", "ipad", "iPad Pro", "iPad PRO"
]

# Нормализация с использованием словаря для сопоставления вариантов написания
normalization_map = {
'iphone': 'iPhone',
'iphone 13': 'iPhone 13',
'samsung galaxy': 'Samsung Galaxy',
'ipad': 'iPad',
'ipad pro': 'iPad Pro'
}

def normalize_product(name):
key = name.lower()
for pattern, replacement in normalization_map.items():
if key == pattern or key.startswith(pattern + ' '):
return replacement
return name

# Применение нормализации и дедупликации
normalized_products = set(normalize_product(p) for p in products)
print(f"Нормализованные уникальные продукты: {normalized_products}")
# {'iPad Pro', 'Samsung Galaxy', 'iPhone 13', 'iPhone', 'iPad'}

# Пример мемоизации функции для вычисления чисел Фибоначчи
def fibonacci(n, cache={}):
if n in cache:
return cache[n]
if n <= 1:
result = n
else:
result = fibonacci(n-1) + fibonacci(n-2)
cache[n] = result
return result

# Измерение времени вычисления
import time

start = time.time()
result = fibonacci(35)
end = time.time()
print(f"Число Фибоначчи(35) = {result}, вычислено за {end-start:.6f} сек")
# Благодаря кешированию, вычисление занимает миллисекунды вместо секунд