Добро пожаловать в Python Шпильки! 🎯

Здесь делюсь острыми и точными приемами, которые:
• Экономят время
• Делают код изящнее
• Вызывают "Вау!" у коллег

📌 Сохраняйте полезные шпильки
💬 Обсуждаем в комментариях
🔔 Не пропустите новые фишки!

#визитка #python_шпильки

🐍 Почему я завел этот канал?

Знакомо чувство, когда смотрите на чужой код и думаете: "Боже, как элегантно! Почему я не додумался?"

Меня зовут Михаил, я python-разработчик. Я прошел путь от многострочных костылей до изящных решений.

В этом канале я буду делиться шпильками — теми самыми приемами, которые:

· Превращают 10 строк в 2
· Делают код читаемым как проза
· Вызывают уважение коллег

Завтра: первая техническая шпилька — "Как заменить 5 if-else одной строкой".

А пока напишите в комментах: какая тема по Python вызывает у вас больше всего вопросов?

#старт #манифест #python_шпильки

«Вот же Пайтон!»:
🎯 Избавляемся от множества if-else

Проблема:

if status == "new":
    handle_new()
elif status == "processing":
    handle_processing()
elif status == "completed":
    handle_completed()
# и так далее...

💡 Шпилька: Используем словарь как диспетчер функций!

handlers = {
    "new": handle_new,
    "processing": handle_processing, 
    "completed": handle_completed,
}

handler = handlers.get(status, handle_default)
handler()

🌟 Фишка: Код становится плоским, легко расширяемым и тестируемым.

#python_шпильки #паттерны

---

🚀 Что дальше?

Теперь вы знаете, как превратить громоздкие if-elif-else конструкции в изящный и масштабируемый код. Но это только начало пути к чистому Python!

В следующем выпуске «Python Шпилек»:
🎯 «Алгоритмы поиска в Python: от list.index() до бинарного поиска с примерами кода»

Мы разберем:

· Почему in и list.index() могут быть медленными на больших данных

· Как работает бинарный поиск и когда он ускоряет программу в 100+ раз

· Практические кейсы из реальных проектов

· Визуализацию сложности O(log n) vs O(n)

Не пропустите — будет так же понятно и практично!

---

💡 А какие алгоритмические задачи вызывают у вас наибольшие сложности? Пишите в комментариях — разберем в следующих выпусках!

📌 Чтобы не потерять:
Сохраните этот пост и подпишитесь на канал — завтра выйдет продолжение!

#алгоритмы_серия #python_шпильки #поиск_алгоритмы

🔍 Алгоритмы #1: Поиск в Python - от линейного до бинарного

Приветствую! В прошлом посте мы заменяли громоздкие if-else, а сегодня разберем алгоритмы поиска — основу основ в программировании.

📊 Линейный поиск: просто, но медленно

def linear_search(arr, target):
    for i, item in enumerate(arr):
        if item == target:
            return i
    return -1

# Сложность: O(n) - перебираем все элементы

Когда использовать: На небольших массивах или когда данные не отсортированы.

⚡️ Бинарный поиск: быстро, но с условием

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# Сложность: O(log n) - делим пополам на каждом шаге

Условие: Массив должен быть отсортирован!

🎯 Практический пример: поиск в списке сотрудников

employees = [
    {"id": 101, "name": "Анна", "salary": 50000},
    {"id": 102, "name": "Борис", "salary": 75000},
    {"id": 103, "name": "Виктор", "salary": 60000}
]

# Линейный поиск по имени
def find_employee_by_name(employees, name):
    for emp in employees:
        if emp["name"] == name:
            return emp
    return None

# Сначала сортируем, потом бинарный поиск
sorted_employees = sorted(employees, key=lambda x: x["name"])

📈 Сравнение производительности

Метод 1000 элементов 1 млн элементов

target in list 0.0001s 0.1s

Бинарный поиск 0.00001s 0.0001s

Вывод: На 1 млн элементов бинарный поиск в 1000 раз быстрее!

💡 Шпилька дня: встроенные инструменты Python

# Для списков (линейный поиск)
index = sorted_list.index(target)  # ValueError если нет

# Через bisect модуль (бинарный поиск)
import bisect
index = bisect.bisect_left(sorted_list, target)

🚀 Что в следующем выпуске?

«Алгоритмы #2: Сортировки — от пузырьковой до TimSort»
Разберем:

· Когда sorted() умнее ручной реализации

· Как выбрать алгоритм под вашу задачу

· Визуализацию работы разных сортировок

💬 Ваш опыт: Какой алгоритм поиска используете чаще всего? Сталкивались ли с ситуациями, где бинарный поиск спас проект?

📌 Сохраните пост, чтобы не потерять! Завтра — продолжение про сортировки.

#алгоритмы_серия #поиск #python_шпильки #сложность_алгоритмов

🚀 Важное объявление + бонус

Друзья, обнаружил технический момент: комментарии в канале работают только для новых постов (так устроен Telegram).

К сожалению, для уже опубликованных постов я не могу добавить кнопку комментариев 😔

Но чтобы исправить ситуацию, делаю два шага:

1. СЕЙЧАС: Открываю комментарии ко всем будущим постам
2. СЕЙЧАС ЖЕ: Выкладываю бонус — сборник 📊 «Шпаргалка по алгоритмической сложности Python»

Внутри Шпаргалки вы найдете:

• Наглядную таблицу O(1), O(log n), O(n), O(n²) с примерами
• Сравнение методов поиска — когда что использовать
• Производительность операций со списками, словарями, множествами
• Практические рекомендации по оптимизации кода
• Визуализацию роста сложности — чтобы понимать разницу наглядно

🔗 Скачать шпаргалку: [Яндекс. Диск]

Эта шпаргалка станет вашим надежным помощником при:

· Выборе структур данных для проекта

· Оптимизации медленного кода

· Подготовке к собеседованиям

· Объяснении алгоритмических решений команде

P.S. В следующем посте уже будет активная секция комментариев — жду ваши вопросы и мнения! 💪

#бонус #алгоритмы #python_шпильки #сложность

🎯 «Алгоритмы #2: Сортировки — от пузырьковой до TimSort»

Проблема:

# Ручная реализация сортировок = велосипеды
def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
# Сложно, медленно O(n²)

💡Шпилька: Используйте встроенную сортировку Python!

# Просто и эффективно
numbers = [5, 2, 8, 1, 9]
sorted_numbers = sorted(numbers)  # [1, 2, 5, 8, 9]

# Сортировка сложных структур
users = [{"name": "Анна", "age": 25}, {"name": "Борис", "age": 30}]
sorted_users = sorted(users, key=lambda x: x["age"])

💡 Когда sorted() умнее вас:

- Определяет тип данных и выбирает оптимальный алгоритм

- Адаптируется под частично отсортированные данные (O(n) вместо O(n log n))

- Использует TimSort — гибрид Merge Sort + Insertion Sort

- Оптимизирован под кэш процессора

🎯 Выбор алгоритма за 10 секунд:

sorted(data)                    # 99% случаев
sorted(data, key=lambda x: x)   # сложные объекты
data.sort()                     # когда можно менять исходник

📊 Визуализация работы:

Bubble Sort: 🐢 O(n²) - медленно, учебный
Quick Sort: 🚀 O(n log n) - быстро, но риск O(n²)
TimSort: 🏆 O(n) - O(n log n) - адаптивный чемпион

Бонус-шпилька: Сортировка обьектов и Сортировка по нескольким полям!

from operator import attrgetter, itemgetter

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Список объектов
users = [User("Анна", 25), User("Борис", 30), User("Виктор", 20)]

# Список словарей
users_dict = [
    {"name": "Анна", "age": 25},
    {"name": "Борис", "age": 30}, 
    {"name": "Виктор", "age": 20}
]

# Сортировка объектов по атрибуту
sorted_users = sorted(users, key=attrgetter('age'))

# Сортировка словарей по ключу
sorted_dicts = sorted(users_dict, key=itemgetter('age'))

# Сортировка словарей по нескольким полям (сначала по возрасту (age), затем по имени (name))
sorted_users_in_dict = sorted(users_dict, key=itemgetter('age', 'name'))

Фишка: Python использует TimSort — гибридный алгоритм, который адаптируется под ваши данные.

Финальная шпилька:

# Всегда ваш выбор:
result = sorted(your_data, key=your_criteria)

💡 В 99% случаев sorted() умнее ручной реализации!

#python_шпильки #сортировки #алгоритмы

🎪 Распаковка в Python: Ваш секретный инструмент для изящного кода

Приветствую! Сегодня отложим алгоритмы и разберем одну из самых красивых возможностей Python — распаковку. Это тот случай, когда синтаксический сахар делает код не только слаще, но и значительно читаемее.

🚀 Базовые суперспособности

Проблема:

# Громоздкое извлечение данных
data = ["Анна", "anna@mail.com", "25", "инженер"]
name = data[0]
email = data[1]
age = data[2]
job = data[3]

💡Шпилька: Используйте распаковку!

# Изящно и понятно
name, email, age, job = data

# Обмен значений без временной переменной
a, b = b, a

# Извлечение первого и последнего
first, *middle, last = [1, 2, 3, 4, 5] # first=1, middle=[2,3,4], last=5

# Игнорируем ненужные элементы
name, _, age, _ = ["Анна", "неважно", "25", "инженер"]  # name="Анна", age="25"

# Только первый элемент
first, *_ = [10, 20, 30, 40]  # first=10

Бонус-шпилька: Распаковка в функциях

# Распаковка списка в аргументы
connect_to_db(*db_config)

# Распаковка словаря в аргументы  
create_user(**user_data)

# Слияние словарей
settings = {**defaults, **user_settings}

Фишка: Распаковка работает с любыми итерируемыми объектами и делает код читаемее на 50%!

💡 Используйте распаковку везде, где нужно извлечь или передать данные!

🚀 Что дальше?
В следующем выпуске — Генераторы в Python! Узнаете, как создавать бесконечные последовательности, экономить память и писать более эффективный код.

💬 Практикуйтесь! Какую задачу Вы решали бы с помощью распаковки? Делитесь в комментариях!

📌 Сохраните пост — эти приемы используются в 90% Python-проектов.

#python_шпильки #распаковка #синтаксический_сахар

🎯 Генераторы в Python: шпаргалка на 1 минуту

Проблема:

# Создание огромного списка в памяти
def get_squares(n):
    result = []
    for i in range(n):
        result.append(i * i)
    return result  # Весь список в памяти!

squares = get_squares(1000000)  # Занимает много памяти

💡Шпилька: Используйте генераторы!

# Экономия памяти - генерируем значения на лету
def get_squares(n):
    for i in range(n):
        yield i * i  # Возвращаем по одному элементу

squares = get_squares(1000000)  # Почти не занимает памяти
for square in squares:
    print(square)  # Обрабатываем по одному

Бонус-шпилька: Генераторные выражения

# Вместо списка
squares_list = [x*x for x in range(10)]  # Список в памяти

# Используйте генератор
squares_gen = (x*x for x in range(10))  # Генератор (ленивые вычисления)

# Работа с файлами
lines = (line.strip() for line in open('file.txt'))  # Читаем по одной строке

Фишка: Генераторы экономят память и позволяют работать с бесконечными последовательностями!

🚀 Что дальше?
В следующем выпуске — Рекурсия в Python! Узнаете, как элегантно решать задачи со сложными вложенными структурами.

💬 Практикуйтесь! Для каких задач вы бы использовали генераторы? Делитесь идеями в комментариях!

📌 Сохраните пост — генераторы незаменимы при работе с большими данными!

#python_шпильки #генераторы #память

🎯Алгоритмы #3: Рекурсия в Python

Проблема:

# Поиск в сложной вложенной структуре без рекурсии
def find_value(data, key):
    # Придется писать много вложенных циклов для каждой глубины
    # Сложно, негибко, легко ошибиться

💡Шпилька: Используйте рекурсию!

def find_value(structure, key):
    if isinstance(structure, dict):
        if key in structure:
            return structure[key]  # Базовый случай - нашли!
        for value in structure.values():
            result = find_value(value, key)  # Рекурсивный вызов
            if result is not None:
                return result
    elif isinstance(structure, (list, tuple, set)):
        for item in structure:
            result = find_value(item, key)  # Рекурсивный вызов
            if result is not None:
                return result
    return None  # Базовый случай - не нашли

# Использование:
data = {"a": {"b": {"c": 1}}, "d": [{"e": 2}, {"f": 3}]}
find_value(data, "c")  # → 1

Бонус-шпилька: Всегда помните про базовый случай!

# Факториал через рекурсию
def factorial(n):
    if n == 0:  # Базовый случай!
        return 1
    return n * factorial(n - 1)  # Рекурсивный случай

# Обход дерева
def traverse_tree(node):
    if node is None:  # Базовый случай!
        return
    print(node.value)
    traverse_tree(node.left)
    traverse_tree(node.right)

Фишка: Рекурсия делает код чище для задач с вложенной структурой, но следите за глубиной рекурсии!

🚀 Что дальше?
В следующем выпуске — Декораторы в Python! Узнаете, как добавлять функциональность к функциям без изменения их кода.

💬 Практикуйтесь! Для каких задач вы используете рекурсию? Делитесь в комментариях!

📌 Сохраните пост — рекурсия незаменима для работы с деревьями и вложенными структурами!

#python_шпильки #рекурсия #алгоритмы

🎯 Декораторы в Python: шпаргалка на 1 минуту
Проблема:

# Добавляем логирование к каждой функции вручную
def process_data(data):
    print(f"Вызвана функция process_data")
    start_time = time.time()
    result = data * 2  # основная логика
    end_time = time.time()
    print(f"Функция выполнилась за {end_time - start_time:.2f} сек")
    return result

# Приходится дублировать код для каждой функции!

💡Шпилька: Используйте декораторы!

def timer(func):
    def wrapper(*args, **kwargs):
        print(f"Вызвана функция {func.__name__}")
        start_time = time.time()
        result = func(*args, **kwargs)  # вызываем исходную функцию
        end_time = time.time()
        print(f"Функция выполнилась за {end_time - start_time:.2f} сек")
        return result
    return wrapper

@timer  # просто добавили декоратор!
def process_data(data):
    return data * 2  # чистая логика без лишнего кода

Бонус-шпилька: Декорировать функцию можно и сразу несколькими декораторами!

@logger
@timer
def complex_calculation(x, y):
    """Сложные вычисления"""
    return x ** y
# Иерархия (вложенность) декораторов будет учитываться

Фишка: Декораторы позволяют добавлять функциональность без изменения исходного кода!

🚀 Что дальше?
В следующем выпуске — Декораторы. Продвинутый уровень! Узнаете, Узнаете, как создавать универсальные декораторы.

💬 Практикуйтесь! Какую функциональность вы бы добавили через декораторы? Делитесь идеями в комментариях!

📌 Сохраните пост — декораторы делают код чище и избавляют от дублирования!

#python_шпильки #декораторы #паттерны

🎯 Продвинутые декораторы в Python: шпаргалка на 1 минуту

Проблема:

# Хотим передавать аргументы в декоратор, но теряем гибкость
def simple_decorator(func):
    def wrapper():
        print("До функции")
        func()
        print("После функции")
    return wrapper

# Не можем кастомизировать поведение декоратора!

💡Шпилька: Используйте декораторы с аргументами!

from functools import wraps
from typing import Callable, Any

def decorator(_func: Callable = None, *decorator_args, **decorator_kwargs) -> Callable:

    def decor_type(func: Callable) -> Callable:

        @wraps(func)
        def wrapped(*f_args, **f_kwargs) -> Any:

            print(f'Аргументы декоратора: {decorator_args} {decorator_kwargs}')
            func(*f_args, **f_kwargs)

            return func

        return wrapped

    if _func is None:

        return decor_type

    else:

        return decor_type(_func)


# эта функция написана для показа варианта аргумента, передаваемого в декоратор
def dop_function(text_print):

    return (text_print)




@decorator(None,1, dop_function('Привет'), 'рублей', 200, dop_function('Привет'), 'друзей', key_valid = True) # None - обязателен, если аргументы не прописаны явно! при передаче даже 1 (одного) аргумента в декоратор!!!
def decorated_function(name: str, num: int) -> None:

    print('Привет', name, num)

decorated_function("Юзер", 10)

# Аргументы декоратора: (1, 'Привет', 'рублей', 200, 'Привет', 'друзей') {'key_valid': True}
# Привет Юзер 10

# Либо можно вызывать декоратор без аргументов, и код не сломается:

@decorator
def decorated_function(name: str, num: int) -> None:

    print('Привет', name, num)

decorated_function("Юзер", 20)

# Аргументы декоратора: () {}
# Привет Юзер 20

Бонус-шпилька: Декораторы для генерации HTML (Пример):

from functools import wraps
from typing import Callable, Any
from random import randint

def dop_text():
    text_print = ('На этой страничке вы можете просмотреть данные конкретного пользователя,'
                  'а также структуру и состав полей базы данных')
    return text_print




def decorator_html(_func: Callable = None, head = 'Привет!', text = 'Приветствую всех!', *decorator_args, **decorator_kwargs) -> Callable:

    def decor_type(func: Callable) -> Callable:

        @wraps(func)
        def wrapped(*f_args, **f_kwargs) -> Any:

            print(f'<h3>{head}</h3><p>{text}</p>')
            print('<table border=1><tr><td><strong>name</strong></td><td><strong>age</strong>'
                  '</td><td><strong>number</strong></td></tr>')
            name_user, age_user, id_user = func(*f_args, **f_kwargs)
            print(f'<tr><td>{name_user}</td><td>{age_user}</td><td>{id_user}</td>')

            return func

        return wrapped

    if _func is None:

        return decor_type

    else:

        return decor_type(_func)


# С прописанными именами аргументов
@decorator_html(head='Данные пользователя', text = dop_text())
def decorated_function(name: str, age: int) -> None:

    # Здесь, допустим извлекаем данные из БД или API
    id_user = randint(10000, 12345)
    return name, age, id_user

decorated_function("Юзер", 10)

# Нюанс (без прописанных имен аргументов)
@decorator_html(None, 'Данные пользователя', dop_text()) # None - обязателен, если вы явно не указываете именование аргументов! при передаче даже 1 (одного) аргумента в декоратор!!!
# при таком варианте аргументы попадают в *args (либо в **kwargs)!
def decorated_function(name: str, age: int) -> None:

    # Здесь, допустим извлекаем данные из БД или API
    id_user = randint(10000, 12345)
    return name, age, id_user

decorated_function("Юзер", 20)

# Либо без аргументов

@decorator_html
def decorated_function(name: str, age: int) -> None:

    # Здесь, допустим извлекаем данные из БД или API
    id_user = randint(10000, 12345)
    return name, age, id_user

decorated_function("Юзер", 30)

Более подробно в моей статье на Хабре

🚀 Что дальше?
В следующем выпуске — Контекстные менеджеры в Python! Узнаете, как элегантно работать с ресурсами.

💬 Практикуйтесь! Какие аргументы вы бы передали в декораторы? Делитесь в комментариях!

📌 Сохраните пост — такие декораторы становятся мощными инструментами для переиспользования кода!

#python_шпильки #декораторы #аргументы

🎯 Контекстные менеджеры в Python: шпаргалка на 1 минуту
Проблема:

# Ручное управление ресурсами - легко забыть закрыть
file = open('data.txt', 'r')
try:
    data = file.read()
    # работа с данными...
finally:
    file.close()  # Можно забыть!

connection = connect_to_db()
try:
    # работа с БД...
finally:
    connection.close()  # Лишний код!

💡 Шпилька: Используйте контекстные менеджеры с with!

# Автоматическое закрытие файла
with open('data.txt', 'r') as file:
    data = file.read()
    # файл закроется автоматически!

# Автоматическое закрытие соединения
with connect_to_db() as connection:
    results = connection.execute_query()
    # соединение закроется само!

💡 Бонус-шпилька: Создавайте свои контекстные менеджеры!

from contextlib import contextmanager

@contextmanager
def timer():
    import time
    start = time.time()
    try:
        yield  # выполняется код внутри with
    finally:
        end = time.time()
        print(f"Выполнено за {end-start:.2f} сек")

# Использование
with timer():
    # любой код здесь будет замерен по времени
    data = [x**2 for x in range(1000000)]

💡 Экстра-шпилька: Контекстные менеджеры через классы!

class DatabaseTransaction:
    def __init__(self, db_connection):
        self.connection = db_connection
    
    def __enter__(self):
        self.connection.begin_transaction()
        return self.connection
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.connection.commit()
        else:
            self.connection.rollback()
        return False  # не подавляем исключения

# Использование
with DatabaseTransaction(db) as tx:
    tx.execute("UPDATE users SET active = TRUE")
    # транзакция commit/rollback автоматически!

Фишка: Контекстные менеджеры гарантируют выполнение cleanup-кода даже при возникновении ошибок!
Теперь управление ресурсами стало элегантным и безопасным! 🚀

🚀 Что дальше?
В следующем выпуске — Асинхронное программирование в Python! Узнаете, как работать с async/await и повысить производительность приложений.

💬 Практикуйтесь! Для каких ресурсов вы бы создали контекстные менеджеры? Делитесь идеями в комментариях!

📌 Сохраните пост — контекстные менеджеры делают код безопаснее и чище!

#python_шпильки #контекстные_менеджеры #with

🎯 Асинхронное программирование в Python: шпаргалка на 1 минуту
Проблема:

# Синхронный код - ждём каждую операцию
import time

def fetch_data(url):
    time.sleep(2)  # Имитация долгого запроса
    return f"Данные с {url}"

# Медленно - 6 секунд на 3 запроса!
start = time.time()
result1 = fetch_data("https://api1.com")
result2 = fetch_data("https://api2.com") 
result3 = fetch_data("https://api3.com")
print(f"Затрачено времени: {time.time() - start:.1f} сек")

💡 Шпилька: Используйте async/await!

import asyncio

async def fetch_data_async(url):
    await asyncio.sleep(2)  # Имитация асинхронного ожидания
    return f"Данные с {url}"

async def main():
    # Запускаем все задачи параллельно!
    start = time.time()
    results = await asyncio.gather(
        fetch_data_async("https://api1.com"),
        fetch_data_async("https://api2.com"),
        fetch_data_async("https://api3.com")
    )
    print(f"Затрачено времени: {time.time() - start:.1f} сек")  # Всего ~2 секунды!

asyncio.run(main())

💡 Бонус-шпилька: Асинхронные HTTP-запросы!

import aiohttp
import asyncio

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [
            fetch_url(session, "https://api1.com"),
            fetch_url(session, "https://api2.com"),
            fetch_url(session, "https://api3.com")
        ]
        results = await asyncio.gather(*tasks)
        print(f"Получено {len(results)} результатов")

asyncio.run(main())

💡 Экстра-шпилька: Ограничение одновременных задач!

import asyncio
from asyncio import Semaphore

async def limited_fetch(semaphore, url):
    async with semaphore:  # Не больше 3 одновременных запросов
        await asyncio.sleep(1)
        return f"Данные с {url}"

async def main():
    semaphore = Semaphore(3)  # Максимум 3 одновременных задачи
    tasks = [limited_fetch(semaphore, f"https://api{i}.com") for i in range(10)]
    results = await asyncio.gather(*tasks)
    print(f"Выполнено {len(results)} задач")

asyncio.run(main())

Фишка: Асинхронность не ускоряет CPU-операции, но идеальна для I/O-bound задач!

🚀 Что дальше?
В следующем выпуске — Алгоритм Two Sum! Узнаете, как находить пары чисел за O(n) вместо O(n²) и решать одну из самых популярных задач на технических собеседованиях.

💬 Практикуйтесь! Какие задачи на алгоритмы вызывают у вас сложности? Делитесь в комментариях!

📌 Сохраните пост — Two Sum встречается в 80% технических собеседований в крупных компаниях!

#python_шпильки #алгоритмы #two_sum #собеседование

🎯 Алгоритм Two Sum в Python: шпаргалка на 1 минуту
Проблема:

# Поиск пар чисел в массиве данных, сумма которых равна target
# Наивное решение - O(n²) время
def two_sum_naive(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

nums = [2, 7, 11, 15, 3, 8, 14]
target = 17
result = two_sum_naive(nums, target)  # [0, 3] - 2 + 15 = 17

💡 Шпилька: Используйте хэш-таблицу для O(n) решения!

def two_sum_optimal(nums, target):
    num_map = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_map:
            return [num_map[complement], i]
        num_map[num] = i
    return []

nums = [2, 7, 11, 15, 3, 8, 14]
target = 17
result = two_sum_optimal(nums, target)  # [4, 6] - 3 + 14 = 17

💡 Бонус-шпилька: Two Sum для отсортированного массива!

def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        current_sum = nums[left] + nums[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

nums = [1, 2, 3, 4, 6, 8, 11]
target = 10
result = two_sum_sorted(nums, target)  # [3, 4] - 4 + 6 = 10

Фишка: Two Sum проверяет умение оптимизировать код с O(n²) до O(n)!

💬 Практикуйтесь! Какие алгоритмические задачи хотите разобрать? Делитесь в комментариях!

📌 Сохраните пост — Two Sum встречается в 80% технических собеседований!

#python_шпильки #алгоритмы #two_sum #собеседование

🔢 Решето Эратосфена в Python: шпаргалка на 1 минуту

Проблема:

# Медленная проверка каждого числа на простоту
def is_prime_naive(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

# Очень медленно для больших n!
primes = [i for i in range(2, 100) if is_prime_naive(i)]

💡 Шпилька: Используйте решето Эратосфена!

def sieve_of_eratosthenes(limit):
    is_prime = [True] * (limit + 1)
    is_prime[0] = is_prime[1] = False
    
    for i in range(2, int(limit**0.5) + 1):
        if is_prime[i]:
            for j in range(i*i, limit + 1, i):
                is_prime[j] = False
    
    return [i for i in range(2, limit + 1) if is_prime[i]]

# Быстро даже для больших пределов!
primes = sieve_of_eratosthenes(100)
print(primes)  # [2, 3, 5, 7, 11, 13, ..., 97]

💡 Бонус-шпилька: Генератор простых чисел!

def prime_generator(limit):
    sieve = [True] * (limit + 1)
    sieve[0] = sieve[1] = False
    
    for i in range(2, int(limit**0.5) + 1):
        if sieve[i]:
            for j in range(i*i, limit + 1, i):
                sieve[j] = False
    
    for i in range(2, limit + 1):
        if sieve[i]:
            yield i

# Использование генератора
for prime in prime_generator(50):
    print(prime, end=" ")
# 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47

💡 Экстра-шпилька: Оптимизированное решето с отсечением чётных чисел!

def optimized_sieve(limit):
    if limit < 2:
        return []
    
    sieve = [True] * (limit + 1)
    sieve[0] = sieve[1] = False
    
    # Обрабатываем отдельно чётные числа
    for i in range(4, limit + 1, 2):
        sieve[i] = False
    
    # Проверяем только нечётные
    for i in range(3, int(limit**0.5) + 1, 2):
        if sieve[i]:
            for j in range(i*i, limit + 1, i*2):
                sieve[j] = False
    
    return [2] + [i for i in range(3, limit + 1, 2) if sieve[i]]

# Ещё быстрее!
primes = optimized_sieve(100)

Фишка: Решето Эратосфена находит все простые числа до N за O(n log log n)!

---

💬 Практикуйтесь! Какие математические алгоритмы хотите разобрать? Делитесь в комментариях!

📌 Сохраните пост — этот алгоритм используется в криптографии и теории чисел!

#python_шпильки #алгоритмы #простые_числа #решето_эратосфена

🔀 Слияние (Merge) в Python: шпаргалка на 1 минуту

Проблема:

# Как объединить два отсортированных списка в один отсортированный?
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]

# Простое сложение и сортировка - неэффективно O(n log n)
result = sorted(list1 + list2)  # [1, 2, 3, 4, 5, 6, 7, 8]

💡 Шпилька: Используйте алгоритм слияния за O(n)!

def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    
    # Сравниваем элементы и добавляем меньший
    while i < len(list1) and j < len(list2):
        if list1[i] <= list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    
    # Добавляем оставшиеся элементы
    result.extend(list1[i:])
    result.extend(list2[j:])
    return result

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
merged = merge_sorted_lists(list1, list2)  # [1, 2, 3, 4, 5, 6, 7, 8]

💡 Бонус-шпилька: Слияние словарей (Python 3.5+)

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "b": 4}  # b перезаписывается

# Объединяем словари
merged_dict = {**dict1, **dict2}  # {'a': 1, 'b': 4, 'c': 3}

# Или через | (Python 3.9+)
merged_dict = dict1 | dict2  # {'a': 1, 'b': 4, 'c': 3}

💡 Экстра-шпилька: Merge Sort - сортировка слиянием

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge_sorted_lists(left, right)

numbers = [5, 2, 8, 1, 9, 3]
sorted_numbers = merge_sort(numbers)  # [1, 2, 3, 5, 8, 9]

Фишка: Слияние отсортированных списков работает за O(n) вместо O(n log n) при обычной сортировке!

---

💬 Практикуйтесь! Где ещё можно применить слияние в ваших проектах? Делитесь идеями в комментариях!

📌 Сохраните пост — алгоритм слияния основа многих Big Data технологий и баз данных!

#python_шпильки #алгоритмы #слияние #merge

---

Теперь объединение данных стало эффективным и изящным! 🚀