Программистика

Слили в телеграмм тонны инфы и отсортировали по каналам ☁️ Хакинг & ИБ — 756GB 🤒 OSINT — 315GB 🖥 Курсы & GitHub — 1579GB ⌨️ Python — 955GB 🙃 Linux & Bash — 459GB 😦 Работа в IT — 778GB 🖥 Общий архив — 2346GB ➡️ Практические инструкции, курсы, книги и инструменты.

СИМВОЛ. Квартиры для сдачи в аренду у центра Москвы ДОНСТРОЙ представляет новый инвестиционный продукт: доходный дом в квартале СИМВОЛ у центра Москвы. Это квартиры с отделкой, мебелью, управлением ""под ключ"" и постоянным доходом от сдачи в аренду. - Расположение у ЦАО, в 2 км от Садового кольца, рядом метро - Отельный сервис для арендаторов - Востребованные для аренды планировки: студии, 1- и 2-комнатные квартиры 28-60,8 м2. - Полная комплектация квартир: отделка, мебель, бытовая техника, кондиционеры - Постоянный поток арендаторов – рядом БЦ, вузы, туристические объекты - В квартале 150+ действующих объектов инфраструктуры, собственный парк 10 га Узнать больше #реклама simvol-kvartal.ru О рекламодателе

💻 Вопрос с собеседования: Что такое MRO (Method Resolution Order) в Python и как работает `super()`? Этот вопрос задают, когда хотят понять, насколько глубоко вы разбираетесь в ООП Python. Просто сказать "MRO — это порядок поиска методов" — недостаточно. Нужно объяснить, зачем это нужно и как избегать ловушек наследования. 📌 Базовый ответ (которого ждают от джуна): MRO (Method Resolution Order) — это порядок, в котором Python ищет методы в иерархии классов. super() позволяет вызывать метод родительского класса без явного указания его имени.

class A:
    def hello(self):
        print("A")

class B(A):
    def hello(self):
        super().hello()  # Вызовет A.hello()
        print("B")

obj = B()
obj.hello()
# Вывод:
# A
# B

🧱 Почему MRO важен при множественном наследовании: Без четкого порядка поиска методов возникли бы неоднозначности в "алмазе наследования":

class A:
    def method(self):
        print("A")

class B(A):
    def method(self):
        print("B")

class C(A):
    def method(self):
        print("C")

class D(B, C):
    pass

# В каком порядке искать method()?
# Старый стиль (до Python 2.3): D → B → A → C → A (дублирование A!)
# Новый стиль (C3 linearization): D → B → C → A

MRO по алгоритму C3 гарантирует: 1. Подкласс всегда проверяется раньше родительского 2. Порядок в списке родителей сохраняется 3. Все классы в иерархии уникальны

print(D.__mro__)  
# (<class '__main__.D'>, <class '__main__.B'>, 
#  <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

🧪 Как работает `super()` на самом деле: Важно: super() ищет метод не в "родительском классе", а в следующем классе по MRO.

class A:
    def process(self):
        print("A")

class B(A):
    def process(self):
        print("B - начало")
        super().process()  # Не всегда вызывает A!
        print("B - конец")

class C(A):
    def process(self):
        print("C - начало")
        super().process()
        print("C - конец")

class D(B, C):
    def process(self):
        print("D - начало")
        super().process()
        print("D - конец")

d = D()
d.process()
# Вывод:
# D - начало
# B - начало
# C - начало
# A
# C - конец
# B - конец
# D - конец

Порядок вызовов: D → B → C → A (согласно MRO класса D). ⚠️ Частые ошибки и ловушки: 1. Неправильный порядок родителей:

❌ Опасно:
class A: pass
class B(A): pass
class C(A, B): pass  
# TypeError: Cannot create a consistent method resolution order

✅ Правильно:
class A: pass
class B(A): pass
class C(B, A): pass  # B проверяется раньше A

2. `super()` с аргументами (старый стиль):

# Python 2 стиль (устарел)
class OldStyle:
    def __init__(self):
        super(OldStyle, self).__init__()

# Python 3 стиль
class NewStyle:
    def __init__(self):
        super().__init__()  # Автоматически определяет класс и self

3. Вызов `super()` не в том месте:

class Base:
    def __init__(self):
        self.setup()
    
    def setup(self):
        print("Base setup")

class Derived(Base):
    def __init__(self):
        self.value = 42  # Сначала инициализируем атрибуты
        super().__init__()  # Потом вызываем родителя
    
    def setup(self):
        print(f"Derived setup with value={self.value}")

d = Derived()
# Выведет: Derived setup with value=42

💡 Запомните: понимание MRO и super() критично для работы со сложными иерархиями классов. На собеседовании покажите, что вы понимаете не только синтаксис, но и логику работы Python с наследованием. Программистика || #jobs

🤔 ХОЧЕШЬ ДЕЛАТЬ ИГРЫ, НО НЕ ЗНАЕШЬ, С ЧЕГО НАЧАТЬ? Меня зовут Антон. Я 8 лет работал в найме в игровой индустрии - и в какой-то момент поставил всё на разработку собственной игры. Сегодня я делаю игру глазами продюсера и показываю этот путь открыто - без романтизации и иллюзий. ⚡️ В своём блоге я показываю закулисье геймдева: ➕ как на самом деле создаются игры в студиях ➕ как одиночки и маленькие команды доводят проекты до релиза ➕ как выглядит разработка игры с точки зрения продюсера ➕ какие ошибки совершают почти все новички и как их избежать 👉 Заходи в блог и забирай подробную инструкцию, как сделать свою первую игру - от идеи до первых билдов.

📜 Clean Imports: Автоматическая чистка неиспользуемых импортов в один клик Устал вручную удалять неиспользуемые импорты в каждом файле? Видишь from django.db import models, connection, transaction и понимаешь, что половина не нужна? Пора автоматизировать рутину. Этот скрипт найдет и удалит все неиспользуемые импорты в вашем Python-проекте, используя autoflake и isort для чистоты. 👉 Скрипт `clean_imports.py`:

#!/usr/bin/env python3
"""
Автоматическая очистка неиспользуемых импортов в Python-проекте
Использование: python clean_imports.py /путь/к/проекту
"""

import subprocess
import sys
from pathlib import Path

def clean_imports(project_path: str):
    """Рекурсивно очищает неиспользуемые импорты во всех .py файлах"""
    project = Path(project_path)
    
    if not project.exists():
        print(f"❌ Путь не найден: {project_path}")
        return
    
    # Находим все Python-файлы
    py_files = list(project.rglob("*.py"))
    
    print(f"🔍 Найдено {len(py_files)} Python-файлов")
    
    for file in py_files:
        print(f"🔄 Обработка: {file.relative_to(project)}")
        
        # 1. Удаляем неиспользуемые импорты с autoflake
        subprocess.run([
            "autoflake", 
            "--in-place", 
            "--remove-all-unused-imports",
            "--remove-unused-variables",
            str(file)
        ], check=False)
        
        # 2. Сортируем импорты с isort
        subprocess.run([
            "isort",
            str(file)
        ], check=False)
    
    print("✅ Готово! Все неиспользуемые импорты удалены.")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Использование: python clean_imports.py /путь/к/проекту")
        sys.exit(1)
clean_imports(sys.argv[1])

🛠 Как использовать: 1. Установите зависимости:

pip install autoflake isort

2. Создайте файл `clean_imports.py` с кодом выше 3. Запустите на проекте:

python clean_imports.py /путь/к/вашему/проекту

🧪 Пример работы: Было (файл `utils.py` с мусором):

import os
import sys
from typing import List, Dict, Tuple, Optional  # Optional не используется
import json
from datetime import datetime, timedelta  # timedelta не используется

def process_data(data: List[Dict]) -> str:
    """Обрабатывает данные и возвращает JSON строку"""
    return json.dumps(data)

Стало (после работы скрипта):

import json
from datetime import datetime
from typing import Dict, List


def process_data(data: List[Dict]) -> str:
    """Обрабатывает данные и возвращает JSON строку"""
    return json.dumps(data)

➕ Преимущества скрипта: 🟢 Автоматизация рутины: Больше не нужно вручную проверять каждый файл 🟢 Безопасность: Использует проверенные инструменты (autoflake, isort) 🟢 Рекурсивность: Обрабатывает все поддиректории проекта 🟢 Контроль: Видите прогресс и какие файлы обрабатываются ➖ Особенности: 🔴 Требует установки autoflake и isort 🔴 Может сломать код, если есть динамические импорты (но такое редко) 🔴 Всегда делайте коммит перед запуском на важном проекте Скачать скрипт https://gist.github.com/ваш-гист) (замените на реальную ссылку) Программистика|| #script

🤔 Кэширование в Python: От @lru_cache до Redis и обратно Когда приложение начинает тормозить, новички часто лезут в сложные оптимизации, хотя 80% проблем решаются грамотным кэшированием. Но какой инструмент выбрать: встроенный декоратор, внешнюю базу или ручное решение? Разбираемся без фанатизма. 🧱 Когда `@lru_cache` — это достаточно (быстро и просто): Встроенный декоратор @functools.lru_cache идеален для кэширования результатов тяжёлых функций, которые часто вызываются с одними и теми же аргументами. 1️⃣. Рекурсивные вычисления (числа Фибоначчи, факториалы):

from functools import lru_cache

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

# Без кэша: O(2^n), с кэшом: O(n)
print(fibonacci(100))  # Мгновенно!

2️⃣. Запросы к внешним API с ограниченным набором параметров:

@lru_cache(maxsize=256)
def get_weather(city, date):
    # Имитация тяжёлого запроса к API погоды
    time.sleep(1)
    return f"Погода в {city} на {date}: 25°C"

# Повторные вызовы с теми же аргументами — мгновенно
print(get_weather("Москва", "2024-01-01"))
print(get_weather("Москва", "2024-01-01"))  # Из кэша!

3️⃣. Сложные вычисления с детерминированным результатом:

@lru_cache(maxsize=None)  # Неограниченный кэш
def calculate_metrics(dataset_hash, params):
    # Тяжёлые вычисления над датасетом
    return processed_result

🧱 Когда `@lru_cache` — это ПЛОХО (опасные ограничения): 1. Функции с изменяемыми (mutable) аргументами:

❌ Опасно и не работает:
@lru_cache
def process_data(data_list):  # data_list — изменяемый список
    return sum(data_list)

process_data([1, 2, 3])
process_data([1, 2, 3, 4])  # Разные вызовы, но кэш может сломаться

2. Когда нужна инвалидация кэша по времени или событиям:

❌ @lru_cache не умеет "протухать":
@lru_cache
def get_live_scores(match_id):
    # Данные живые, обновляются каждую минуту
    # Но кэш будет хранить старый результат вечно!

3. Многопоточность и многопроцессность:

# Кэш в памяти процесса не доступен другим процессам
# При перезапуске приложения кэш теряется

🧱 Когда нужен `Redis` или `Memcached` (распределённое кэширование): 1️⃣. Многопроцессные приложения (Django, FastAPI в production):

# django.core.cache с Redis
from django.core.cache import cache

def get_user_data(user_id):
    data = cache.get(f"user_{user_id}")
    if not data:
        data = expensive_database_query(user_id)
        cache.set(f"user_{user_id}", data, timeout=3600)
    return data

2️⃣. Общий кэш между несколькими сервисами:

# Сервис A и Сервис B используют один Redis
import redis

cache = redis.Redis(host='localhost', port=6379, db=0)

# Сервис A записывает
cache.setex("api_response", 300, json.dumps(data))

# Сервис B читает
data = cache.get("api_response")

3️⃣. Сложная инвалидация и тегирование:

# Кэшируем с тегами, потом инвалидируем по тегу
cache.set("product_123", data, tags=["products", "category_5"])
# При обновлении категории
cache.delete_by_tag("category_5")  # Удалит все связанные кэши

🧱 Когда нужно ручное кэширование (полный контроль): 1. Кэширование с сложной логикой инвалидации:

class SmartCache:
    def __init__(self):
        self._cache = {}
        self._access_count = {}
    
    def get(self, key):
        if key in self._cache:
            self._access_count[key] += 1
            return self._cache[key]
        return None
    
    def set(self, key, value, *, max_accesses=100):
        self._cache[key] = value
        self._access_count[key] = 0
        
        # Автоочистка редко используемых ключей
        if len(self._cache) > 1000:
            self._cleanup(max_accesses)

2. Кэширование с зависимостями между данными:

# При обновлении пользователя нужно обновить все его заказы в кэше
def update_user(user_id, data):
    # Обновляем в БД
    db.update_user(user_id, data)
    
    # Инвалидируем связанные кэши
    cache.delete(f"user_{user_id}")
    cache.delete_by_pattern(f"orders_user_{user_id}_*")

🔗 Подробнее в статье Если хотите больше статьи ставьте 🔥 Программистика|| #doc

Колледж IThub. День Открытых Дверей 15 февраля! ✨9-11 классы — Поступление без экзаменов ✅Гос. диплом ✅Стажировки и трудоустройство ✅Свобода от сессий и отсрочка от армии ✅Отсутствие домашних заданий и 5-балльной системы оценивания Стань IT-профи и получи оффер от крупной компании. Востребованные профессии 2026! Наши выпускники работают в «Газпром», «Крок», «МТС», «Самолет», «Сбер» и др. Зарабатывай первые деньги в IT до 18 лет! Записаться онлайн #реклама 16+ ithub.ru О рекламодателе

Руководство по разработке безопасного программного обеспечения Почти треть российских компаний (28%) не проверяют свое ПО на уязвимости или только планируют внедрить практики безопасной разработки. Это означает, что ошибки в коде, небезопасные конфигурации и уязвимые зависимости нередко остаются незамеченными до самого релиза. Исправление таких проблем после выхода продукта обходится значительно дороже. Кроме того, это несет серьезные репутационные и операционные риски. Чтобы избежать уязвимостей и рисков, связанных с непроверенными зависимостями, принципы DevSecOps нужно закладывать с самого начала — еще до первой строки кода. В статье расскажем, что такое безопасная разработка программного обеспечения, как она устроена и как внедрить подход в реальные процессы команды. ➡️ Читать статью Программистика || #article

Хороший айтишник ≠ хороший руководитель И это причина, почему большинство застревают в своем развитии. 📊 Управление — это отдельный навык. В канале Апазиди АйТи показывают, как его развить в реальном IT. ▪️управленческие ошибки, которые тихо ломают карьеру ▪️почему созвоны — признак слабой системы ▪️как строить команды без постоянного контроля Читай тут: 👉 https://t.me/+F_6p7j93h8QxZWVi

👩‍💻 Шпаргалка по конвертированию CSV to JSON с помощью Python Программистика|| #doc

Ухватил ОФФЕР с ЗП более чем 500к🤑 Несколько раз в месяц Топовые IT компании выкладывают вакансии с огромной зарплатой даже у джунов, а я расскажу как попасть на ТимЛида‼️ Я — Артем и в своём телеграм канале рассказываю: 🔴 Как максимально быстро вырасти до Тим Лида в IT компаний с нуля — [Инструкция] 🔴 Как собрать лучшую команду на удалёнке — [Пояснение] 🔴Подсказки и фишечки от ТимЛида с 13 летним опытом — [Список] Подписаться можно тут: https://t.me/+dbAZSx8rR1swMTky

Сетевое программирование на Python

Книга посвящена разработке серверных приложений и клиент-серверных архитектур на Python. Рассказано о поддержке SSL в Python 3, представлены примеры работы с протоколами TCP, UDP, HTTP, SMTP, IMAP, FTP, RPC, взаимодействия c сервисами DNS. Освещена работа с электронной почтой в приложениях. Описаны цели протокола TLS и методы их достижения на Python. Подробно описаны возможности модуля asyncio, входящего в состав Python 3.4, даны рекомендации по разработке сетевых приложений с использованием веб-фреймворков Flask и Django. Для программистов.

Программистика|| #doc

👩‍💻 Ctypes Python – Огромная скорость и БЕЗОПАСНОСТЬ компонентов

🎥 Первоисточник

Программистика|| #video

Сеньор за полгода? 📈 Эта девушка получила оффер в IT-компанию, хотя весь её опыт — пара курсов с ютуба 😱 Она воспользовалась ИИ-помощником и легко скрыла все свои пробелы в знаниях. Теперь впереди: ⤵️ удалёнка, стартовое обучение и ставка 55$ в час. Проходи собеседования вместе с Interview Ninja 🥷 Проверь успех на себе — есть 100 бесплатных запросов на день. 👉 @interview_ninja

НАЧАЛО. Премиальные квартиры в Доме-Вселенной на Пресне НАЧАЛО - новый дом в центре столицы, рядом с Москва-Сити. Проект по-настоящему космического масштаба, где есть все, чтобы раскрыть себя и свои возможности. - Три двора: детский, спортивный, двор для медитаций - Террасный променад с зонами для спорта, отдыха, детских игр - Детский клуб, репетиторские, коворкинги, переговорные, библиотека, кинотеатр - Фитнес-центр с бассейном - Образовательный центр - «Улица ресторанов» Квартиры - от однокомнатных до просторных резиденций и пентхаусов. С потолками до 4 м и панорамными окнами в пол, за которыми - великолепные виды на Сити, центр Москвы, набережные, Воробьевы горы, Лужники. Сегодня вы можете купить квартиры в доме НАЧАЛО с рассрочкой 0% на 3 года. Узнать больше Проектная декларация на сайте https://наш.дом.рф/. Застройщик: "СЗ "НАЧАЛО". #реклама nachalo-na-presne.ru О рекламодателе

Простые способы сэкономить память в Python Если код разрастается, память летит в трубу. Вот как её прижать. 1️⃣ Что экономить в первую очередь? Данные. Именно они - главные пожиратели ОЗУ, а не сам код. 2️⃣ Пример: кортеж vs. класс

# Фигня, которая жрёт память
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# Более плотное хранение
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])

# Или просто кортеж (x, y)

3️⃣ Почему это работает? Структуры без __dict__ (кортежи, namedtuple, dataclass с frozen=True) занимают меньше места, чем обычные классы. Для миллиона объектов разница - десятки мегабайт. 4️⃣ Ещё один лайфхак: sys.intern() для строк

import sys
massive_list_of_names = [sys.intern(name) for name in raw_data]

Это чертовски полезно, если в данных много повторяющихся строк (теги, статусы, имена). Экономит кучу места. 5️⃣ А что насчет массивов? Используй array.array или numpy для чисел. Хранение миллиона int'ов в списке - это долго и дорого. В специальном массиве - в разы компактнее. Программистика ||#article

🤔 Asyncio 🆚 Threading vs Multiprocessing: Гонка за производительностью в Python Когда нужно ускорить код, новички часто создают потоки для всего подряд ("многопоточность же быстрее!"), а потом удивляются, почему Python с GIL не летает. Сеньоры спорят между asyncio, threading и multiprocessing, забывая, что у каждого инструмента своя работа. Разбираемся, когда что запускать. 🧱 Когда `asyncio` — это хорошо (I/O-bound задачи с многочисленными операциями): Asyncio идеален, когда программа много времени ждёт ввода-вывода: сетевые запросы, работа с базами данных, взаимодействие с API. 1️⃣. Веб-скрейпинг и API-запросы:

import aiohttp
import asyncio

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

async def main():
    async with aiohttp.ClientSession() as session:
        urls = ["http://site1.com", "http://site2.com"]
        tasks = [fetch_page(session, url) for url in urls]
        pages = await asyncio.gather(*tasks)  # Все запросы параллельно!

2️⃣. Веб-серверы (FastAPI, aiohttp):

# FastAPI сам использует asyncio
from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/")
async def read_root():
    await asyncio.sleep(0.1)  # Не блокирует другие запросы
    return {"Hello": "World"}

3️⃣. Работа с несколькими сокетами/соединениями:

# Чат-сервер, прокси, бот для мессенджера

🧱 Когда `asyncio` — это ПЛОХО (антипаттерны): 1. CPU-интенсивные задачи:

❌ Бесполезно:
async def calculate_primes(limit):
    primes = []
    for num in range(2, limit):
        # Тяжелые вычисления БЛОКИРУЮТ event loop!
        if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):
            primes.append(num)
    return primes

2. Блокирующие вызовы без специальной обёртки:

❌ Заблокирует весь event loop:
async def read_large_file():
    with open("huge.csv", "r") as f:
        data = f.read()  # Синхронный I/O!
    return data

🧱 Когда `threading` — это хорошо (I/O-bound с блокирующими библиотеками): Threading спасает, когда нужно работать с библиотеками, которые не поддерживают asyncio, но много ждут. 1️⃣. GUI-приложения (Tkinter, PyQt):

# Отдельный поток для долгой операции, чтобы интерфейс не зависал
import threading
import tkinter as tk

def long_operation():
    # Имитация долгой операции
    time.sleep(5)
    print("Готово!")

def start_in_thread():
    thread = threading.Thread(target=long_operation)
    thread.start()  # GUI остаётся отзывчивым

2️⃣. Параллельные HTTP-запросы с requests (синхронной):

import threading
import requests

def fetch_url(url):
    response = requests.get(url)  # Синхронная библиотека
    return response.text

threads = []
for url in urls:
    thread = threading.Thread(target=fetch_url, args=(url,))
    thread.start()
    threads.append(thread)

3️⃣. Чтение/запись файлов на медленных дисках:

# Пока один поток ждёт диск, другой может работать

🧱 Когда `threading` — это ПЛОХО (опасно и бесполезно): 1. CPU-задачи в Python (из-за GIL):

❌ Не ускорит, а замедлит:
def calculate():
    result = 0
    for i in range(10_000_000):
        result += i
    return result

# 4 потока будут работать МЕДЛЕННЕЕ, чем 1 поток из-за GIL и переключений

2. Общие изменяемые данные без блокировок:

❌ Состояние гонки (race condition):
counter = 0

def increment():
    global counter
    for _ in range(1000000):
        counter += 1  # Неатомарная операция!

# Результат непредсказуем, будет меньше 2_000_000

Скорость приходит не от слепого использования потоков, а от правильного сопоставления задачи и инструмента. 🔗 Подробнее в статье Программистика|| #doc

Программистика || #Мемы

Самые дорогие ошибки в IT выглядят так же, как обычный рабочий день. Один деплой — и минус прод. Вот как это было на самом деле: 🔥 GitLab — стерли базу 🔥 Knight Capital — минус 440 млн за 30 минут 🔥 Facebook — 6 часов тишины Если работаешь с продом — тебе сюда.