Разработка приложений для автоматизации задач с помощью pyautogui

Привет, друзья! С вами Иван.

Сегодня я хочу рассказать о весьма интересной библиотеке в Python — pyautogui. Это настоящая палочка-выручалочка, если вы задумали автоматизировать скучные, однообразные операции за компьютером: клики, прокрутки, нажатия клавиш. Звучит как магия? В каком-то смысле — да. Но магия здесь вполне осязаемая и практичная.

Библиотека pyautogui позволяет управлять мышью и клавиатурой так, будто это делает человек. Она отлично подойдёт для создания мини-утилит, которые автоматизируют, например, повторяющиеся шаги в рабочем процессе: заполнение форм, открытие и сохранение файлов, сортировка электронных писем… список можно продолжать.

Установить pyautogui можно так:

pip install pyautogui

⚙️ Пример 1 — Автоматическое открытие калькулятора и ввод операций:

Представим, что у вас Windows, и вы хотите запустить калькулятор и выполнить в нём простую операцию: ввести «123 + 456». Вот как это можно реализовать (пример под Windows):

import pyautogui
import time
import subprocess

subprocess.Popen("calc.exe")  # Запускаем калькулятор
time.sleep(2)  # Ждём, пока откроется окно

pyautogui.write('123')
pyautogui.press('+')
pyautogui.write('456')
pyautogui.press('enter')

Удивительно просто, правда? Вы будто нажимаете клавиши сами, но делает это скрипт.

🖱️ Пример 2 — Автокликер:

Вы играете или регулярно работаете с интерфейсом, где нужно часто кликать по определённой области экрана? Не проблема:

import pyautogui
import time

time.sleep(3)  # У вас есть 3 секунды, чтобы навести курсор
for i in range(10):
    pyautogui.click()
    time.sleep(0.5)

Этот скрипт делает 10 кликов мышью с полсекундной задержкой. Особенно удобно, если вам нужно 100 раз подтвердить однотипное действие (например, в старой ERP-системе).

📸 Пример 3 — Поиск элемента на экране:

pyautogui умеет искать изображения на экране — это значит, что вы можете не просто “тыкать в координаты”, а находить кнопки и управлять GUI умно:

import pyautogui
import time

location = pyautogui.locateOnScreen('submit_button.png', confidence=0.8)
if location:
    pyautogui.click(location)
else:
    print("Button not found!")

Функция locateOnScreen ищет фрагмент изображения на экране. Это даёт гибкость: автоматизация не привязана к жёстким координатам и будет работать даже при сдвиге окон.

🛑 Немного предосторожностей:

- pyautogui не знает, что делает ваша система. Он просто нажимает и кликает.
- Будьте осторожны с автоматическим вводом: можно случайно отправить ненужную почту или удалить файл.
- Хотите резко остановить выполнение? Используйте сочетание клавиш Ctrl + C или установите failsafe:

pyautogui.FAILSAFE = True

Если курсор мыши резко увести в верхний левый угол экрана — выполнение остановится.

⏹️ Заключение

pyautogui — простой путь в мир автоматизации пользовательского интерфейса. Он особенно полезен для начинающих, чтобы понять, «как думает компьютер», и почувствовать силу Python в реальных задачах. Подходит для мелких рутин, ежедневных кликов и даже базового тестирования GUI.

Желаю вам меньше рутинных задач и больше интересных скриптов!

Как подключаться к REST API и обрабатывать JSON-ответы

Как подключаться к REST API и обрабатывать JSON-ответы

REST API и Python: работаем с JSON как профи

Привет! Сегодня мы окунемся в одну из самых востребованных тем — как с помощью Python подключаться к REST API и работать с JSON-ответами.

В мире, где всё общается со всем через интернет, умение "разговаривать" с другими сервисами через их API — почти что суперсила. Показываю, как включить эту суперсилу.

Начнем с самого популярного инструмента для HTTP-запросов в Python — библиотеки requests.

Установи её, если ещё не установлена:

pip install requests

Теперь — практика. Допустим, ты хочешь получить список фактов о котах (почему бы и нет?). Есть открытое API: https://catfact.ninja

Пример простого GET-запроса:

import requests

url = 'https://catfact.ninja/fact'
response = requests.get(url)

if response.status_code == 200:
    data = response.json()
    print(f"Random cat fact: {data['fact']}")
else:
    print(f"Error: {response.status_code}")

Здесь мы:

1. Отправляем GET-запрос.
2. Получаем результат в формате JSON.
3. Извлекаем нужное поле (fact) и выводим его.

А теперь давай усложним задачу. Есть API, которое возвращает список пользователей: https://jsonplaceholder.typicode.com/users

Получим их и выведем имена:

import requests

url = 'https://jsonplaceholder.typicode.com/users'
response = requests.get(url)

if response.ok:
    users = response.json()
    for user in users:
        print(f"{user['name']} - {user['email']}")
else:
    print("Failed to fetch users.")

Как видишь, response.json() — это просто Python-словарь или список. Не нужно парсить вручную, всё уже удобно преобразовано.

Иногда API требует параметры. Пример — получить 5 случайных фактов о котах:

import requests

url = 'https://catfact.ninja/facts'
params = {'limit': 5}
response = requests.get(url, params=params)

if response.ok:
    facts = response.json()['data']
    for fact in facts:
        print(f"- {fact['fact']}")
else:
    print("Something went wrong...")

Обращай внимание: параметр params добавляет query string к URL автоматически.

📌 Несколько полезных советов:

- Проверяй response.status_code или response.ok, чтобы понимать, всё ли прошло хорошо.
- Используй try-except вокруг response.json(), если не уверен, что ответ в формате JSON.
- Заголовки (headers) можно передавать через параметр headers, если API требует авторизации или определённого контента.

В следующий раз разберем, как отправлять POST-запросы и авторизовываться через токены. А пока — подключайся к миру REST API, и пусть JSON будет с тобой!

Введение в модуль collections: где и как использовать deque

Привет! Меня зовут Иван, и сегодня мы заглянем в один из скрытых уголков стандартной библиотеки Python — модуль collections, а точнее, познакомимся с универсальным инструментом deque. Если вы до сих пор используете list там, где нужна очередь или стек — самое время изменить подход!

🔁 Что такое deque?

deque расшифровывается как “double-ended queue” — двусторонняя очередь. Это структура данных, в которую можно эффективно добавлять и удалять элементы как с начала, так и с конца. На практике deque особенно полезна в тех случаях, где list начинает “тормозить”.

Создается просто:

from collections import deque

dq = deque()

По умолчанию deque бесконечен, но можно установить максимальную длину:

dq = deque(maxlen=5)

📌 В чем преимущество deque?

Добавление и удаление с концов deque выполняется за O(1). Для сравнения, у list это O(n) при удалении с начала списка. Почувствуйте разницу, когда работаете с большими объёмами данных.

🧪 Пример 1: реализация очереди

Представим, что мы моделируем очередь из пользователей. С list это будет невыгодно, а вот deque идеально подходит:

from collections import deque

queue = deque()

queue.append("user1")
queue.append("user2")
queue.append("user3")

# Первый зашёл, первый вышел
first_in_line = queue.popleft()
print(first_in_line)  # user1

append() — добавить в конец, popleft() — забрать с начала. Идеальная очередь!

🌀 Пример 2: реализация стека

Хочешь стек вместо очереди? Пожалуйста!

stack = deque()

stack.append("task1")
stack.append("task2")

# Последний зашёл, первый вышел
last_task = stack.pop()
print(last_task)  # task2

Всё как в классике. append + pop для работы как со стеком.

🔄 Пример 3: ограниченная история (максимальная длина)

Представим историю последних действий пользователя:

history = deque(maxlen=3)

history.append("login")
history.append("view_page")
history.append("edit_profile")
history.append("logout")  # login будет удален

print(history)  # deque(['view_page', 'edit_profile', 'logout'])

Это очень удобно — не нужно вручную следить за перерасходом памяти.

🚀 Немного магии: вращение

deque умеет вращаться:

items = deque([1, 2, 3, 4])
items.rotate(1)
print(items)  # deque([4, 1, 2, 3])

items.rotate(-2)
print(items)  # deque([2, 3, 4, 1])

Раз — и вы переместили данные вперед или назад. Применимо, например, к круглым буферам или игровым очередям.

🎯 Когда использовать deque?

- Если нужна очередь или стек — берите deque.
- Если часто работаете с началом списка — deque сэкономит много времени.
- Если нужно ограничить размер структуры — maxlen вам в помощь.

Ну и бонус — deque поддерживает почти все методы list’а: count(), remove(), extend(), но всё работает быстрее за счёт оптимизированного внутреннего устройства.

На этом всё! Надеюсь, deque стал для вас чуть ближе. Он не так популярен, как list, но в своём деле вне конкуренции. Попробуйте его в деле — и не захочется возвращаться.

Советы по структурированию и организации Python-кода

🧱 Делим и властвуем: как организовать код на Python, чтобы не расползся по углам

Каждому новичку рано или поздно приходится столкнуться с "монстром" — огромным скриптом на 500 строк, в котором логика размазана по всему файлу как масло по бутерброду. Чтобы не оказаться его автором, нужно с самого начала прививать себе привычку писать чисто, читаемо и — главное — структурировано.

🎯 Разделяй задачи

Золотое правило: одна функция — одна задача. Если функция делает и запрос, и обработку, и вывод — бей тревогу. Раздели её на части.

Пример нехорошего подхода:

def process_user_data():
    data = get_data_from_api()
    cleaned = clean_data(data)
    save_to_db(cleaned)

Лучше так:

def fetch_data():
    # запрос к API
    pass

def clean_data(data):
    # обработка данных
    pass

def store_data(data):
    # сохранение в БД
    pass

def main():
    data = fetch_data()
    cleaned = clean_data(data)
    store_data(cleaned)

Такой подход упрощает тестирование, переиспользование и понимание логики.

📦 Разбивай на модули

Если в проекте больше одного файла, используй модули. Группируй код по смыслу: один файл отвечает за работу с базой, другой — за API, третий — за бизнес-логику.

Например:

/project
    main.py
    db_handler.py
    api_client.py
    utils.py

В db_handler.py храним функции работы с БД:

def save_user(user_obj):
    pass

def get_user_by_id(user_id):
    pass

А в api_client.py — всё, что касается внешнего API:

def fetch_posts():
    pass

def fetch_comments():
    pass

🧰 Не забывай про __init__.py

Если ты оформляешь папку как пакет, добавляй файл __init__.py. Он говорит Python: "это модуль, здесь всё по-взрослому". Даже если он пустой.

📚 Создавай README

Это не шутка. Если даже в небольшом проекте ты сам спустя 2 недели забудешь, как оно работает, представь, каково будет другим. Краткий README.md с описанием структуры проекта и запуском — спасение.

🚨 Защищай точку входа

Магическая конструкция if __name__ == "__main__": спасает от автоматического запуска кода при импорте модуля.

def main():
    ...

if __name__ == "__main__":
    main()

👏 И напоследок

Структура — это скелет проекта. Чем крепче и логичнее он выстроен, тем проще развивать код и находить в нем ошибки. Даже если ты пока пишешь скрипты на 100 строк — начни делать это по-взрослому. И увидишь, как Python перестанет казаться хаотичным — он станет инструментом, где порядок рождает мощь.

На связи,
Иван — программист, который когда-то тоже писал один файл на 800 строк.

Как получить и обработать данные о погоде с помощью OpenWeatherMap API

🎯 Python + Погода: как получить данные с OpenWeatherMap API

Когда на улице пасмурно, дождливо, и хочется остаться дома с Python — самое время научиться получать метеоданные из реального мира. Сегодня разберем, как добыть и обработать погоду с помощью API OpenWeatherMap. Следить за капризами атмосферы мы будем с помощью библиотеки requests.

📌 Что нам понадобится?
- Аккаунт на https://openweathermap.org/
- API-ключ (его можно получить бесплатно после регистрации)
- Библиотека requests (если не установлена — pip install requests)

🚀 Стартуем!

Допустим, мы хотим узнать текущую погоду в Москве. OpenWeatherMap предоставляет различные API — мы воспользуемся самым простым, Current Weather Data.

Пример запроса:

import requests

API_KEY = 'your_api_key_here'
CITY = 'Moscow'
URL = f'https://api.openweathermap.org/data/2.5/weather?q={CITY}&appid={API_KEY}&units=metric&lang=en'

response = requests.get(URL)
data = response.json()

print(data)

Обратите внимание: параметр units=metric отвечает за метрическую систему (°C вместо °K), а lang=en — за язык описания погоды. Можно попробовать lang=ru, если хочется интернациональности :)

🎯 Теперь — извлечем нужную информацию:

if response.status_code == 200:
    weather = data['weather'][0]['description']
    temp = data['main']['temp']
    feels = data['main']['feels_like']
    humidity = data['main']['humidity']
    wind = data['wind']['speed']

    print(f"Погода в {CITY}: {weather}")
    print(f"Температура: {temp}°C (ощущается как {feels}°C)")
    print(f"Влажность: {humidity}%")
    print(f"Скорость ветра: {wind} м/с")
else:
    print(f"Ошибка получения данных: {response.status_code}")

💡 Что дальше?

- Преобразовать это в функцию: удобно использовать в разных частях программы.
- Добавить ввод города от пользователя.
- Расширить: подключить прогноз погоды на неделю (One Call API).

📦 Функция для повторного использования:

def get_current_weather(city, api_key):
    url = f'https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric&lang=ru'
    response = requests.get(url)

    if response.status_code != 200:
        return f"Ошибка: {response.status_code}"

    data = response.json()
    weather_info = {
        'city': city,
        'description': data['weather'][0]['description'],
        'temp': data['main']['temp'],
        'feels_like': data['main']['feels_like'],
        'humidity': data['main']['humidity'],
        'wind_speed': data['wind']['speed']
    }
    return weather_info

Затем можно красиво оформить вывод:

report = get_current_weather('Kazan', API_KEY)
if isinstance(report, dict):
    print(f"{report['city']}: {report['description'].capitalize()}, {report['temp']}°C, ощущается как {report['feels_like']}°C")
else:
    print(report)

🌤 Заключение

Работа с реальными API — отличный способ оживить свои знания Python. OpenWeatherMap позволяет не только вытягивать погодные данные, но и анализировать их, строить приложения прогнозов, отправлять уведомления. Все начинается с простого запроса. Следующий шаг — автоматизация или визуализация этих данных.

Пусть код всегда будет тёплым, а погода за окном — предсказуемой 😎
— Иван, программист

Работа с парами ключ-значение: оптимизация словарей с использованием defaultdict

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

Обычный словарь в Python хорош, но порой слишком суров. Попробуйте обратиться к несуществующему ключу — получите KeyError. Конечно, можно делать проверки или использовать get(), но есть и более изящный путь.

Знакомьтесь: defaultdict.

defaultdict — это подкласс стандартного dict, в который нужно передать функцию, возвращающую значение по умолчанию для новых ключей. Больше никаких проверок на наличие ключа — вы просто используете его, и если такого ключа не было, он автоматически создается с нужным значением.

Начнем с простого примера: подсчет частоты символов в строке.

from collections import defaultdict

def count_characters(text):
    char_count = defaultdict(int)
    for char in text:
        char_count[char] += 1
    return char_count

text = "hello world"
print(count_characters(text))

Пара строк, и у нас мощный инструмент для статистики. Без get(), без if-ов — всё автоматически.

Теперь чуть интереснее. Группировка элементов по признаку. Например, сгруппируем слова по их первой букве:

from collections import defaultdict

words = ['apple', 'banana', 'avocado', 'blueberry', 'apricot', 'blackberry']

grouped = defaultdict(list)

for word in words:
    grouped[word[0]].append(word)

print(dict(grouped))

Здесь defaultdict(list) творит магию: новые ключи создаются с пустым списком, и мы можем сразу .append() к ним.

Вы можете использовать любую callable в качестве фабрики значений. Например, создадим словарь словарей:

from collections import defaultdict

nested = defaultdict(lambda: defaultdict(int))

nested['user1']['clicks'] += 1
nested['user2']['views'] += 5

print(dict(nested))

Без defaultdict такой код превращается в бой с инициализацией: проверяй ключи, создавай промежуточные словари вручную. А тут — элегантно и понятно.

Когда использовать defaultdict?

- Подсчет чего-либо (символов, слов, чисел, объектов)
- Группировка по ключам
- Вложенные структуры
- Кэширование и маппинг с дефолтными значениями

Когда не стоит:

- Если нужно понимание, существует ли ключ (defaultdict может скрыть ошибки)
- Если значения по умолчанию не универсальны

В целом, defaultdict — это шикарный способ сделать код компактнее, читаемее и устойчивее. Он буквально отключает необходимость думать о ключах — и даёт возможность сосредоточиться на сути задачи.

До встречи в следующем посте!
— Иван.

Создание и настройка конфигурационных файлов с помощью configparser

💾 Конфигурационные файлы с configparser: сохраняем настройки по-взрослому

Когда ваш Python-скрипт перестаёт быть одноразовой поделкой, в нём быстро появляется необходимость в настройках: база данных, логгирование, параметры подключения, пути, флаги… Всё это хочется вынести из кода и спрятать где-нибудь в конфиге, чтобы не пересобирать всё при каждом изменении одного IP-адреса. И тут на сцену выходит модуль configparser.

Встроенный в стандартную библиотеку, configparser позволяет удобно работать с INI-файлами — старым, но до сих пор живым форматом конфигураций. И это потрясающе удобно.

🌟 Пример 1: создаём конфиг

Начнём с сохранения простой конфигурации:

import configparser

config = configparser.ConfigParser()

config['DEFAULT'] = {
    'Server': 'localhost',
    'Port': '8080',
    'UseSSL': 'yes'
}

config['database'] = {
    'User': 'admin',
    'Password': 'secret',
    'Host': '127.0.0.1'
}

with open('config.ini', 'w') as configfile:
    config.write(configfile)

После выполнения этого кода появится файл config.ini примерно с таким содержимым:

[DEFAULT]
Server = localhost
Port = 8080
UseSSL = yes

[database]
User = admin
Password = secret
Host = 127.0.0.1

👌 Просто, наглядно – и читается как человеком, так и машиной.

🔎 Пример 2: читаем конфиг

Теперь прочитаем его и используем настройки в коде:

import configparser

config = configparser.ConfigParser()
config.read('config.ini')

server = config['DEFAULT']['Server']
port = int(config['DEFAULT']['Port'])
use_ssl = config.getboolean('DEFAULT', 'UseSSL')

db_user = config['database']['User']
db_pass = config['database']['Password']

print(f"Connecting to {server}:{port} (SSL: {use_ssl}) as {db_user}")

Бонус: методы вроде getboolean() автоматически приводят значения к нужному типу. Вам не нужно вручную проверять 'yes' или 'no' — всё уже предусмотрено.

🎯 Несколько полезных штук:

- Значения в секции [DEFAULT] наследуются всеми другими секциями.
- Можно использовать .get(section, option, fallback=value) — если нет значения, вернёт значение по умолчанию вместо того, чтобы бросать исключение.
- Интуитивный синтаксис: если вы знакомы с INI-файлами — вы уже наполовину освоили configparser.

💡 А когда не стоит использовать configparser?

Если вы работаете со структурой, где важен порядок ключей, вложенность или поддержка сложных типов данных (например, список в списке) — возможно, лучше подойдёт JSON, YAML или TOML. Но для простых и среднесложных проектов configparser — лёгкий и надёжный выбор.

Вместо того чтобы хардкодить параметры в скрипте или передавать их через кучу аргументов, дайте своим скриптам читать из конфигов — и жить станет проще. Настройки вне кода — это шаг к более гибкому и поддерживаемому софту.

👨‍💻 С вами был Иван, до встречи в следующих постах по Python!

Использование bleach для очистки HTML и предотвращения XSS

Привет! Сегодня поговорим о безопасности — потому что никакой "Hello, World!" не стоит XSS-уязвимости. Если ты работаешь с пользовательским контентом, особенно HTML, будь готов встретиться с потенциальными атаками. Но к счастью, в Python есть модуль, который позволяет легко и эффективно очистить HTML от всего лишнего. Знакомься, bleach.

Модуль bleach — это простая, но мощная библиотека, которая позволяет фильтровать HTML-контент, оставляя только безопасные и разрешённые теги, атрибуты и стили. Под капотом bleach использует html5lib и поддерживает белый список (whitelist) — ты сам указываешь, какие HTML-элементы допустимы.

Зачем это нужно? Представь, что твое приложение отображает текст, введённый пользователем. Без фильтрации туда можно внедрить вредоносный скрипт, например:

<script>alert('Hacked!');</script>

Даже если ты любишь острые ощущения, пользователь твоего чата — вряд ли. Посмотрим, как bleach спасает положение.

Начнем с простого:

import bleach

raw_html = '<h1>Hello</h1><script>alert("XSS")</script><p>Welcome!</p>'
clean_html = bleach.clean(raw_html)

print(clean_html)

Результат:

<h1>Hello</h1>&lt;script&gt;alert("XSS")&lt;/script&gt;<p>Welcome!</p>

Как видно, опасный тег <script> был автоматически экранирован.

Теперь допустим, ты хочешь разрешить пользователю использовать только ограниченный набор тегов, скажем, <p>, <strong> и <a>. На помощь приходит параметр tags:

allowed_tags = ['p', 'strong', 'a']
clean_html = bleach.clean(raw_html, tags=allowed_tags)

print(clean_html)

Все убойные <script>, <style> и прочий "ядерный арсенал" будут выброшены. Bleach также заботится об атрибутах. По умолчанию разрешены только безопасные, но ты можешь настроить список разрешенных атрибутов:

raw_html = '<a href="javascript:alert(1)">Click me</a>'
clean_html = bleach.clean(raw_html, tags=['a'], attributes={'a': ['href']})
print(clean_html)

Страшно? Не бойся, bleach срежет опасные протоколы. Выход будет чист:

<a>Click me</a>

Want to allow safe links only? Используй bleach.sanitizer.ALLOWED_PROTOCOLS — он фильтрует небезопасные схемы вроде javascript:.

Наконец, можно “отбеливать” не просто строки, а делать это правильно в потоке данных. Bleach поддерживает linkify() — магию для превращения URL в ссылки:

text = "Visit https://python.org!"
linked_text = bleach.linkify(text)
print(linked_text)

И ты получишь:

Visit <a href="https://python.org">https://python.org</a>!

Вот так легко защитить свои Python-приложения от XSS и порадовать пользователей безопасным интерфейсом. Bleach — небольшой, но мощный инструмент, без которого сложно представить обработку HTML в веб-приложениях.

Оставайтесь чистыми 😉
— Иван

Как измерять и оптимизировать использование памяти в Python-программах

Когда Python пишет в память: как измерять и оптимизировать использование памяти

Представьте, что у вас в рюкзаке лежат книги. Если у вас всего пара книжек — проблем нет. Но если вы случайно запихнули туда энциклопедию в 10 томах, да ещё на каждой странице – картинка, быть беде: рюкзак рвётся. Так же и с памятью в Python — можно писать лёгкий код, а можно незаметно нагрузить память до отказа. Сегодня поговорим о том, как следить за объёмом используемой памяти и как её оптимизировать.

📏 Измеряем: кто сколько ест?

Python по умолчанию не показывает, сколько памяти занял тот или иной объект. К счастью, у нас есть модуль sys и отличная библиотека pympler.

Начнём с простого:

import sys

data = [i for i in range(10000)]
print(sys.getsizeof(data))  # Размер самого списка
print(sys.getsizeof(data[0]))  # Размер одного элемента

Но sys.getsizeof() возвращает только «голый» размер объекта, без вложенных данных. Например, список из 10 000 строк займёт гораздо больше, чем просто «список». Для глубокого анализа лучше использовать pympler.

from pympler import asizeof

data = [str(i) for i in range(10000)]
print(asizeof.asizeof(data))

Заметка: установите pympler через pip install pympler, если он ещё не установлен.

☝️ Проверь себя: строки и множества

Некоторые стандартные структуры данных в Python могут неожиданно потреблять много памяти. Например, множества set занимают больше памяти, чем списки, а строки — иногда ведут себя не так, как ожидаешь:

a = 'hello' * 1000
b = ['hello'] * 1000

print(sys.getsizeof(a), 'vs', sys.getsizeof(b))

📉 Оптимизируем: меньше, но лучше

- Используйте генераторы вместо списков там, где это возможно. Они не хранят все элементы в памяти одновременно:

sum_gen = sum(i for i in range(10**7))  # Генератор
sum_list = sum([i for i in range(10**7)])  # Список, занимает в разы больше памяти

- Замените большие словари с повторяющимися значениями на collections.defaultdict или array/struct, особенно в случае числовых данных.

- Не держите в памяти то, что уже не нужно. Иногда достаточно просто удалить переменные:

import gc

del large_data
gc.collect()

- Используйте __slots__ в ваших классах, если количество атрибутов фиксировано. Это сокращает накладные расходы на хранение объектов:

class Lightweight:
    __slots__ = ['name', 'value']
    def __init__(self, name, value):
        self.name = name
        self.value = value

🚀 Вывод

Python — не самый «худенький» язык, когда речь заходит о памяти. Но понимание того, как и где расходуются ресурсы, творит чудеса. Используя простые приёмы и правильные инструменты, даже «тяжёлый» код можно привести в форму. А значит — приложение работает быстрее, а сервер не падает при каждом запуске анализа данных.

Создание простых текстовых игр с помощью модуля curses