🤖 TensorFlow: кастомный слой в Keras

Когда стандартных слоёв не хватает — пиши свой. Это просто, если знаешь, как устроен Keras. Вот как по шагам создать кастомный слой на Python ⬇️

👍 1. Наследуем класс Layer
В Keras любой слой — это класс. Мы наследуемся от tf.keras.layers.Layer.

import tensorflow as tf

class MyDenseLayer(tf.keras.layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.units = units

➡️ Здесь сохраняем параметры, но веса ещё не создаём.

👍 2. Создаём веса в build()
Метод build() вызывается автоматически при первом входе данных. Тут инициализируем веса.

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer='random_normal',
            trainable=True
        )
        self.b = self.add_weight(
            shape=(self.units,),
            initializer='zeros',
            trainable=True
        )

🟢 Веса создаются через self.add_weight(), и они участвуют в обучении.

👍 3. Логика прямого прохода (call)
Здесь описываем, что происходит с входом.

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

➡️ Можно использовать любые TensorFlow-операции: условные, активации, нормализацию и т.д.

👍 4. Используем слой в модели

layer = MyDenseLayer(units=10)
output = layer(tf.ones((3, 5)))
print(output.shape)  # (3, 10)

🟢 Keras сам вызывает build() при первом вызове слоя.

💡 Запомни
👍 __init__() — инициализация параметров
👍 build() — создание весов на основе входа
👍 call() — что реально делает слой
👍 Можно комбинировать слои внутри кастомного слоя — создавай любую архитектуру

🗣️ Хочешь пост по продвинутой Keras-архитектуре или трюкам с callback'ами? Предложи тему — разнесём.

📱 Генерируем QR‑коды в Python: просто, гибко, наглядно

Иногда нужно быстро создать QR‑код: для ссылки, текста, визитки или даже Wi‑Fi‑пароля. Python справляется с этим буквально за пару строк.
Давай разберём, как это делается и что внутри происходит.

pip install qrcode[pil]

➡️ Устанавливаем библиотеку qrcode. В скобках [pil] — сразу тянет Pillow для работы с изображениями.

import qrcode

img = qrcode.make("https://example.com")
img.save("qrcode.png")

➡️ Базовый случай: генерация QR‑кода для любой строки. Метод make сразу создаёт изображение, которое можно сохранить или отдать пользователю.

Обычно хочется чуть больше контроля: размер, плотность, уровень защиты от ошибок, цвета.
Для этого создаём QR‑код «вручную»:

qr = qrcode.QRCode(
    version=1,
    error_correction=qrcode.constants.ERROR_CORRECT_L,
    box_size=10,
    border=4,
)
qr.add_data("Hello, QR!")
qr.make(fit=True)

img = qr.make_image(fill_color="black", back_color="white")
img.save("custom_qr.png")

➡️ Здесь мы задаём:

🟢 version — размер сетки (1 — минимальный);
🟢 error_correction — сколько данных можно потерять и всё ещё прочитать код;
🟢 box_size и border — масштаб и рамку.

А если хочется добавить логотип или иконку — тоже просто:

Создаём QR‑код с высоким уровнем коррекции ошибок и «вклеиваем» логотип по центру:

from PIL import Image

logo = Image.open("logo.png")
qr = qrcode.QRCode(error_correction=qrcode.constants.ERROR_CORRECT_H)
qr.add_data("https://mysite.com")
qr.make(fit=True)

qr_img = qr.make_image(fill_color="black", back_color="white").convert("RGB")

pos = (
    (qr_img.size[0] - logo.size[0]) // 2,
    (qr_img.size[1] - logo.size[1]) // 2,
)
qr_img.paste(logo, pos)
qr_img.save("qr_with_logo.png")

➡️ Логотип уменьшай так, чтобы не закрывал слишком много ячеек.
Высокий уровень коррекции (ERROR_CORRECT_H) позволяет восстанавливать данные даже при частичном перекрытии.


🗣️ Запомни: QR‑код — это обычное изображение, а Python — отличная среда, чтобы сгенерировать их сотнями или добавить фирменный стиль прямо в коде.
Просто текст → картинка → готово.

👩‍💻 Discord-бот на Python — без фреймворков, но с магией

Если ты думаешь, что писать бота — это боль, забудь.
С Discord API и библиотекой discord.py ты за 5 минут запускаешь своего ИИ-друга, модератора, или даже антикапчу.

📦 Установка:

pip install -U discord.py  

🧠 Минимальный бот, который отвечает на команды:

import discord
from discord.ext import commands

bot = commands.Bot(command_prefix='!')

@bot.event
async def on_ready():
    print(f'✅ Бот запущен как {bot.user}')

@bot.command()
async def ping(ctx):
    await ctx.send('🏓 Pong!')

bot.run("ТОКЕН_БОТА")

➡️ Всё просто: !ping вызывает функцию ping.

📛 Добавим логику: калькулятор

@bot.command()
async def add(ctx, a: int, b: int):
    await ctx.send(f'🔢 {a} + {b} = {a + b}')

➡️ Автоматический парсинг аргументов прямо в сигнатуре.
!add 3 5 → 8

🔒 Роли и доступ

@commands.has_role("Admin")
@bot.command()
async def secret(ctx):
    await ctx.send("🔐 Доступ только для админов")

➡️ Защита без if'ов — всё через декоратор.

📂 Ответы на события

@bot.event
async def on_message(message):
    if message.author == bot.user:
        return
    if "hello" in message.content.lower():
        await message.channel.send("👋 Привет!")
    await bot.process_commands(message)  # не забывай это!

➡️ Слушай сообщения напрямую и реагируй, как хочешь.

🧱 Расширения и cogs
Когда бота становится много — делим по модулям.

# cogs/admin.py
from discord.ext import commands

class AdminCog(commands.Cog):
    @commands.command()
    async def kick(self, ctx, user: discord.Member):
        await user.kick()
        await ctx.send(f"👢 {user} кикнут")

def setup(bot):
    bot.add_cog(AdminCog())

А в main.py:

bot.load_extension("cogs.admin")

➡️ Архитектура бота сразу становится читаемой и поддерживаемой.

🎯 Полезные фишки:

🟢discord.Member — авто-парсинг упоминаний
🟢ctx.author — кто вызвал команду
🟢ctx.guild — сервер
🟢ctx.send(file=discord.File(...)) — отправка файлов
🟢commands.cooldown() — ограничения на вызов команд

📚 Документация для помощи.

🗣️ Запомни: Discord-бот — это не сайт, не CLI и не каша из if'ов. Это реактивная система на события, и ты — дирижёр. Пиши бота как ассистента, не как Frankenstein.

🛡 Безопасность веба на Python: как не стать уязвимым к SQLi, XSS и взлому авторизации

Когда ты пишешь backend на Python (особенно на Flask или FastAPI), легко забыть, что твой код — это дверь, которую кто-то обязательно попробует выбить. Ниже — конкретные уязвимости и как их не допустить. Всё на Python, всё по делу.

🧨 SQL Injection — когда пользователь пишет SQL вместо имени

Наивный код:

def login(username, password):
    query = f"SELECT * FROM users WHERE name = '{username}' AND password = '{password}'"
    db.execute(query)

➡️ А теперь представь, что кто-то ввёл username = ' OR 1=1 --
Твоя БД отдаст всех.

🛡 Делай так:

def login(username, password):
    query = "SELECT * FROM users WHERE name = %s AND password = %s"
    db.execute(query, (username, password))

🟢 Никогда не вставляй данные в SQL напрямую. Используй параметризацию.

💀 XSS — когда тебе "отвечают" скриптом

Ты рендеришь HTML и вставляешь туда пользовательский ввод:

@app.route("/comment")
def show_comment():
    comment = request.args.get("text")
    return f"<p>{comment}</p>"

➡️ Ввод: <script>alert('XSS')</script>
Теперь у тебя всплывающее окно, завтра — украденные куки.

🛡 Используй шаблонизаторы (Jinja2), они экранируют HTML по умолчанию:

return render_template("comment.html", comment=comment)

🟢 Никогда не вставляй данные в HTML руками. Никогда.

🔓 Аутентификация — не доверяй "своей" сессии

Наивный подход:

@app.route("/admin")
def admin():
    if request.cookies.get("is_admin") == "1":
        return "Welcome, admin"
    return "Access denied"

➡️ Знаешь, что делает злоумышленник?
document.cookie = "is_admin=1" — и здравствуй, root-доступ.

🛡 Используй нормальную систему логина + подписанные сессии:

from flask_login import login_required

@app.route("/admin")
@login_required
def admin():
    ...

🟢 Никогда не полагайся на значения из cookie без подписи. Flask, FastAPI и Django умеют делать это за тебя.

🚧 Пароли: не храни в базе как есть

❌Плохо:

db.save({"username": u, "password": p})

✔️ Надо так:

import bcrypt

hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
db.save({"username": u, "password": hashed})

И при логине:

bcrypt.checkpw(input_password.encode(), saved_hashed)

🟢 Всегда хешируй пароли. Никогда не сравнивай строки напрямую.

📬 Ещё советы:

👍 Используй @app.before_request для централизованной валидации
👍 Всегда проверяй Content-Type, Origin, Referer на важных роутов
👍 Делай CSRF-защиту, если у тебя формы и сессии
👍 И никогда не доверяй никаким входным данным. Ни JSON, ни headers, ни cookies

🗣️ Запомни: все уязвимости — это не "где-то в теории", а у тебя в коде, если ты не думаешь о безопасности. Ты либо проверяешь всё, либо однажды проверяешь, почему твоя база утекла.

🔠 Установка и настройка Python, PyCharm на Windows

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

➡️ Ссылка на первоисточник

🤩 Pytstart || #Видеокурс

🌐 Веб-сокеты в Python — когда HTTP уже не тянет

Обычный HTTP живёт по принципу: клиент стучит — сервер отвечает. Всё.
Никакой постоянной связи, никакой реакции по факту.
Но что делать, если тебе нужно мгновенное обновление? Например:

🟢 💬 чат
🟢 📈 графики в реальном времени
🟢 🎮 онлайн-игра
🟢 📡 пуши и статус трекеры

Здесь на сцену выходят WebSocket'ы — двусторонний канал между клиентом и сервером, который остаётся открытым. То есть:

➡️ сервер может отправлять данные сам, без запроса
➡️ клиент может отправлять хоть каждую секунду
➡️ соединение живёт, пока кто-то не закроет

🛠 Как реализовать WebSocket в Python?

📦 Ставим библиотеку:

pip install websockets

⚙️ Минимальный сервер на websockets:

import asyncio
import websockets

async def echo(ws):
    async for message in ws:
        await ws.send(f"🔁 Ты сказал: {message}")

async def main():
    async with websockets.serve(echo, "localhost", 8765):
        await asyncio.Future()  # бесконечно

asyncio.run(main())

➡️ Сервер слушает на ws://localhost:8765
Клиент пишет → сервер отвечает тем же.

📟 Простой клиент на Python:

import asyncio
import websockets

async def talk():
    async with websockets.connect("ws://localhost:8765") as ws:
        await ws.send("Привет, сервер!")
        reply = await ws.recv()
        print(f"📨 Ответ: {reply}")

asyncio.run(talk())

➡️ Получилось: отправили сообщение — получили ответ.
Но без HTTP-запросов. Это живое соединение.

🧠 А где это реально нужно?

👍 Онлайн-чат: сервер сам рассылает сообщения всем
👍 Таблицы в реальном времени: графики обновляются мгновенно
👍 Игра: клиент и сервер держат постоянную связь
👍 Мониторинг: ты не ждёшь refresh — данные приходят сами

🧱 А если хочешь встроить это в веб-приложение?

Используй FastAPI + WebSocketRoute:

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(ws: WebSocket):
    await ws.accept()
    while True:
        msg = await ws.receive_text()
        await ws.send_text(f"🎯 Получено: {msg}")

➡️ Клиент подключается к /ws и общается как по каналу.

🧑‍💻 А как подключиться из браузера?

let ws = new WebSocket("ws://localhost:8000/ws");
ws.onmessage = (e) => console.log("🔔", e.data);
ws.send("Привет от клиента!");

🟢Теперь твой браузер общается с Python в реальном времени.


🗣️ Запомни: WebSocket — это не замена HTTP, а его суперспособность.
Когда тебе нужна живая, немедленная связь — бери сокеты.А всё остальное — просто ждёт request.

🔧Как работать в команде на Python — Git, код-ревью, таски

Работаешь один — ты король и бог. Но в команде один без Git и нормальных привычек быстро превращается в проблему. Ниже — как реально выжить и не бесить коллег.

🔧 1. Всегда работай в ветках

Никогда не пиши код прямо в main или dev.
Получил таску #42 — создавай ветку под неё:

git checkout -b feature/42-add-login

🟢 Название должно быть понятно всем → feature/42-add-login, а не tryfixx_final_final7.

🧠 2. Код должен быть читаемым, а не крутым

Забей на «магические» трюки. В команде лучше писать просто и понятно:

# 🟢 Хорошо:
def send_email(user_email: str, subject: str) -> None:
    ...

# 🔴 Плохо:
def s(e, s): pass

🗣 Пиши, будто завтра ты уйдёшь, а читать будет стажёр.


🧪 3. Делай тесты на важное — никто не любит сюрпризы

Если у тебя логика — оберни её в тест. Даже простые вещи:

def add(x: int, y: int) -> int:
    return x + y

def test_add():
    assert add(2, 3) == 5

🟢 Если код легко протестировать — ты всё сделал правильно.


👀 4. Ревью — не оскорбление, а проверка на адекватность

Сделал фичу — открой Pull Request.
Коллеги посмотрят: есть ли баги, понятен ли код.

# GitHub или GitLab
PR: "Добавил логин-форму (таска #42), проверена в dev"

🗣 Не дуйся на замечания. Даже лучший код можно сделать лучше.


5. Коммить по смыслу, а не по настроению

Вместо тупого fix или upd — пиши, что реально сделал:

git commit -m "Добавлен хендлер ошибок при логине"

🟢 Так будет проще откатиться, если кто-то накосячит. А это случается.

🔁 6. Перед мержем — подтяни `dev` и проверь

git checkout dev
git pull
git checkout feature/42-add-login
git merge dev

➡️Проверь руками, что всё работает. Потом — заливай.

🔐 7. Git-конфликты — не конец света

Конфликт? Разрули его в IDE или руками:

<<<<<<< HEAD
old_code()
=======
new_code()
>>>>>>> dev

🟢 Главное — не паникуй. Почти всегда видно, что оставить.

💡 Запомни:

👍 Git — не формальность, а спасение
👍 Код-ревью — не допрос, а помощь
👍 Хорошая таска — как GPS: понятно, куда ехать

🗣️ Запомни: Работа в команде — это как игра в футбол. Если каждый будет играть сам за себя, даже Пеле не спасёт проект.

🤖 Телеграм-бот на Python: читает и отвечает сам — без магии, но с кайфом

Ты хочешь, чтобы бот читал входящие и отвечал? Не проблема.
Сейчас покажу, как создать минимального Telegram-бота на python-telegram-bot, который будет:

🟢 📥 читать входящие сообщения
🟢 📤 отправлять ответы
🟢 🧠 иметь логику

📦 Установка библиотеки

pip install python-telegram-bot --upgrade

🔧 Шаг 1 — Получи токен у @BotFather

1. Найди @BotFather в Telegram
2. Напиши /newbot
3. Дай имя и username (должен заканчиваться на bot)
4. Получишь токен — сохрани его!

💬 Шаг 2 — Простейший бот, который отвечает на всё

from telegram import Update
from telegram.ext import ApplicationBuilder, MessageHandler, filters, ContextTypes

TOKEN = "твой_токен_сюда"

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = update.message.text
    await update.message.reply_text(f"📨 Ты сказал: {text}")

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

app.run_polling()

➡️ Всё! Бот читает каждое сообщение и повторяет его.


⚙️ Что тут происходит?

🟢 ApplicationBuilder() — создаёт бота
🟢 MessageHandler() — реагирует на текст
🟢 handle_message() — твоя логика
🟢 run_polling() — запускает цикл обновлений

🗣 Бот работает по принципу событий:
Каждое сообщение — это вызов твоей функции.

🧠 Добавим ум: реагируем по-разному

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = update.message.text.lower()

    if "привет" in text:
        await update.message.reply_text("👋 Приветик!")
    elif "пока" in text:
        await update.message.reply_text("👋 До встречи!")
    else:
        await update.message.reply_text("❓ Я тебя не понял...")

➡️ Логика — обычный Python. Хочешь regex? Хочешь ML? — вперёд.

🔘 Обработка команд /start и т.п.

from telegram.ext import CommandHandler

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("🤖 Я готов к работе!")

app.add_handler(CommandHandler("start", start))

➡️ Теперь /start даёт тебе приветствие.

📂 Хочешь архитектуру? — делай как взрослые

# handlers/messages.py
async def respond(update, context):
    text = update.message.text
    await update.message.reply_text(f"💬 Ты написал: {text}")

# main.py
from telegram.ext import ApplicationBuilder, MessageHandler, filters
from handlers.messages import respond

app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, respond))
app.run_polling()

➡️ У тебя теперь структура и порядок.

🚀 Запуск 24/7

🟢🖥 Используй PythonAnywhere или VPS
🟢🧰 Или переводи на вебхуки через setWebhook()
🟢🔁 Или просто держи run_polling() — и не парься

📚 Документация для помощи.

🗣️ Запомни: телеграм-бот — это не просто "ответчик".Он — живой, асинхронный, событийный зверь.Ты пишешь не скрипт — ты пишешь мозг.

👩‍💻 Python с нуля: Типы данных (int, float, str, bool)

В этом видео автор простым языком объясняет базовые типы данных в Python: int, float, str и bool.Показано, как они работают, чем отличаются и как их применять. Подойдёт тем, кто только начинает изучение языка и хочет разобраться в основах.

➡️ Ссылка на первоисточник

🤩 Pytstart || #Видеокурс

👩‍💻 Углублённое ООП в Python — property, classmethod, staticmethod

В Python методы — это не всегда просто def. Есть специальные декораторы, которые меняют то, как ты работаешь с логикой класса. С ними код чище, а интерфейс удобнее.


🏷 `@property` — метод как атрибут
Нужен, когда хочешь, чтобы метод выглядел как обычное поле, но с вычислением «на лету».

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

    @property
    def name(self):
        print("📡 Получаем имя...")
        return self._name.title()

u = User("ivan")
print(u.name)  # 📡 Получаем имя... → Ivan

➡️ Пользователь думает, что это поле, а внутри может быть хоть сложная логика или обращение к API.

📛 Можно ещё добавить setter:

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("❌ Имя не может быть пустым")
        self._name = value

➡️ Теперь u.name = "Petr" вызовет логику проверки, а не просто присвоение.


🏭 `@classmethod` — метод уровня класса
Передаёт в первый аргумент cls — сам класс. Отлично подходит для альтернативных конструкторов.

class Product:
    def __init__(self, name):
        self.name = name

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"])

p = Product.from_dict({"name": "Laptop"})
print(p.name)  # Laptop

➡️ Не надо вручную дергать __init__, всё скрыто за понятным методом.

🧠 Ещё приём: методы-фабрики с преднастроенными значениями.

    @classmethod
    def default(cls):
        return cls("Default Product")

⚡️ `@staticmethod` — метод без привязки
Обычная функция внутри класса, не знающая про self и cls.

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

print(MathUtils.add(2, 3))  # 5

➡️ Лежит в классе для логической группировки, но работает автономно.

📛 Пример с валидацией:

class Temperature:
    @staticmethod
    def is_valid(value):
        return -273.15 <= value

➡️ Это не про объект и не про класс, просто утилита по теме.

🔗 Комбо на практике

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @property
    def fahrenheit(self):
        return (self.celsius * 9 / 5) + 32

    @classmethod
    def from_fahrenheit(cls, f):
        return cls((f - 32) * 5 / 9)

    @staticmethod
    def is_valid(value):
        return -273.15 <= value

➡️ Здесь всё вместе:

👍 property — вычисляет по формуле
👍 classmethod — создаёт объект из другой шкалы
👍 staticmethod — проверяет, что температура физически возможна

🗣️ Запомни: property — прячь логику за «атрибутом», classmethod — делай фабрики, staticmethod — держи утилиты рядом с классом. Эти три — твои кирпичи для чистого ООП в Python.

⚡️ Асинхронность в Python — asyncio и aiohttp

Когда код ждёт — ты теряешь время. Асинхронность позволяет работать с тысячами задач одновременно, не создавая кучу потоков. Это особенно круто в сетевых приложениях: боты, API, парсеры, чаты.

🌀 `asyncio` — асинхронный движок Python
Вместо того чтобы блокироваться на ожидании, Python "прыгает" между задачами.

import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    print(f"✅ Задача {name} выполнена")

async def main():
    await asyncio.gather(
        task("A", 2),
        task("B", 1),
        task("C", 3)
    )

asyncio.run(main())

➡️ Все задачи стартуют вместе. Пока одна «спит» — выполняются другие.

📛 Основные приёмы:

🟢 async def — объявление асинхронной функции
🟢 await — «подожди» и уступи управление
🟢 asyncio.gather() — запусти несколько задач параллельно

🌍 `aiohttp` — асинхронные запросы
Отличается от requests тем, что не блокирует поток.

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()

async def main():
    urls = [
        "https://example.com",
        "https://httpbin.org/get",
        "https://python.org"
    ]
    results = await asyncio.gather(*(fetch(u) for u in urls))
    for i, html in enumerate(results, 1):
        print(f"📄 Страница {i}: {len(html)} символов")

asyncio.run(main())

➡️ Все запросы идут одновременно, а не по одному.

🛠 Асинхронный сервер на `aiohttp`

from aiohttp import web

async def handle(request):
    return web.Response(text="👋 Привет, async!")

app = web.Application()
app.router.add_get("/", handle)

web.run_app(app, port=8080)

➡️ Лёгкий веб-сервер, который можно масштабировать без потоков.

💡 Где асинхронность особенно нужна:

🟢 Чат-серверы и мессенджеры
🟢 Парсинг тысяч страниц
🟢 API с большим количеством одновременных клиентов
🟢 Боты, которые делают много запросов

🗣️ Запомни: asyncio — это переключение задач без ожидания, aiohttp — быстрые асинхронные запросы. Вместе они дают реактивный, лёгкий и масштабируемый Python.

👩‍💻 Работа с логами в Python: как писать, чтобы потом понять, что произошло

Если в коде нет логов — ты как пилот без приборов. Ошибка случилась, баг вылез, сервер упал — и ты гадаешь на кофейной гуще. logging в Python — это встроенный инструмент, который позволяет фиксировать всё важное и разбирать полёты, когда что-то идёт не так.


🖋 Простой старт — замена print()

Наивно:

print("Starting app...")

➡️ Всё выводится в stdout, без уровня важности и без даты.

Правильно:

import logging

logging.basicConfig(level=logging.INFO)
logging.info("Starting app...")

🟢 Теперь у каждой записи есть уровень (INFO) и метка времени.

🎯 Уровни логов — фильтруй шум

В logging есть 5 уровней:

🟢 DEBUG — подробности для разработчика
🟢 INFO — обычные события
🟢 WARNING — что-то подозрительное
🟢 ERROR — ошибка, но программа ещё жива
🟢 CRITICAL — всё очень плохо

logging.debug("Запрос к API")
logging.warning("Медленный ответ от сервера")
logging.error("База данных недоступна")

➡️ Фильтруешь по уровню и получаешь только нужное.


📂 Логи в файл — чтобы не потерять

logging.basicConfig(
    filename="app.log",
    filemode="a",
    format="%(asctime)s %(levelname)s:%(message)s",
    level=logging.INFO
)
logging.info("Сервер запущен")

🟢 Теперь всё пишется в app.log с датой, временем и уровнем.

⚙️ Разные форматы для разных задач

FORMAT = "%(levelname)s | %(name)s | %(message)s"
logging.basicConfig(format=FORMAT, level=logging.DEBUG)

log = logging.getLogger("billing")
log.info("Начало операции")
log.error("Ошибка списания средств")

➡️ Можно отделять логи по модулям (billing, auth, db) и видеть источник.

🚨 Логи ошибок с трейсами

try:
    1 / 0
except ZeroDivisionError:
    logging.exception("Деление на ноль!")

🟢 logging.exception сам добавит traceback, не надо руками печатать traceback.print_exc().

📬 Ещё советы:

✔️ Для больших проектов делай конфиг через logging.config или YAML
✔️ Разделяй логи по файлам: error.log, access.log, debug.log
✔️ Не логируй пароли и токены — логи часто попадают в чужие руки
✔️ Логи с ротацией (RotatingFileHandler) спасут диск от забивания

🗣️ Запомни: логи — это твоя машина времени. Пиши их так, чтобы в любой момент вернуться в прошлое и понять, что произошло. Сегодня ты тратишь 5 минут на настройку, завтра экономишь часы на отладке.

👩‍💻 Python. Условные операторы: if, elif, else

Это видео объясняет, как использовать условные операторы в Python для принятия решений в коде. Вы узнаете, как проверять условия с помощью if, обрабатывать альтернативные варианты с elif и задавать действия по умолчанию с else.

Пример:

age = int(input("Введите ваш возраст: "))
if age < 18:
    print("Вы молоды!")
elif age < 60:
    print("Вы в расцвете сил!")
else:
    print("Вы мудры и опытны!")

👉 Ссылка на первоисточник

🤩 Pytstart || #Видеокурс

🔗 Интеграция со сторонними сервисами в Python: быстро, надёжно, по API

Когда нужно подтянуть данные из стороннего сервиса или автоматизировать работу с платформой, Python и HTTP-запросы — идеальный инструмент.
Отправляем запрос → получаем JSON → используем в коде.

📦 Установка:

pip install requests

➡️ requests — самая популярная библиотека для работы с HTTP в Python. Простая и надёжная.

📨GET-запрос — забираем данные

import requests

url = "https://api.github.com/repos/psf/requests"
response = requests.get(url)
data = response.json()

print(data["full_name"], data["stargazers_count"])

➡️ Получаем JSON от GitHub API и сразу вытаскиваем нужные поля.


📤 POST-запрос — отправляем данные

payload = {"name": "test_repo", "private": True}
headers = {"Authorization": "token YOUR_GITHUB_TOKEN"}

r = requests.post("https://api.github.com/user/repos", json=payload, headers=headers)
print(r.status_code)

🟢 Так создаём репозиторий прямо из Python. Авторизация через токен в заголовках.

🔒 OAuth 2.0 — авторизация в сервисах

from requests_oauthlib import OAuth2Session

oauth = OAuth2Session(client_id="...", redirect_uri="https://mysite.com/callback")
authorization_url, state = oauth.authorization_url("https://service.com/oauth/authorize")

print("Открой:", authorization_url)

➡️ Механизм для безопасного входа через сторонние аккаунты (Google, GitHub, Spotify и др.).

📡 Обработка ошибок и таймаутов

try:
    r = requests.get(url, timeout=5)
    r.raise_for_status()
except requests.exceptions.RequestException as e:
    print("Ошибка:", e)

🟢 Таймаут защищает от зависания, raise_for_status() ловит ошибки HTTP.

⚡️ Асинхронная интеграция — быстрее при множестве запросов

import aiohttp, asyncio

async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.json()

async def main():
    async with aiohttp.ClientSession() as session:
        data = await fetch(session, "https://api.github.com")
        print(data)

asyncio.run(main())

➡️ aiohttp позволяет стучаться к API в десятки раз быстрее при большом количестве запросов.


🗣️ Запомни: любая интеграция — это просто обмен данными по HTTP.

👩‍💻 Асинхронность в Python — asyncio 🆚 aiohttp: кто за что отвечает

Python умеет работать без блокировок — и это не только про скорость, а про масштабируемость.
asyncio — движок планирования задач.
aiohttp — асинхронный HTTP-инструмент, построенный на asyncio.

🌀 Пример: чистый asyncio

import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    print(f"✅ {name} завершена")

async def main():
    await asyncio.gather(
        task("A", 2),
        task("B", 1)
    )

asyncio.run(main())

➡️ Все задачи стартуют сразу, без потоков и блокировок.

🌍 Пример: aiohttp для загрузки страниц

import aiohttp, asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as s:
        async with s.get(url) as r:
            return await r.text()

async def main():
    urls = ["https://example.com", "https://python.org"]
    html_list = await asyncio.gather(*(fetch(u) for u in urls))
    print(f"📄 Загружено {len(html_list)} страниц")

asyncio.run(main())

➡️ Все запросы идут одновременно, а не по одному.

🛠 Применение на практике: быстрый API-клиент

async def get_data():
    async with aiohttp.ClientSession() as s:
        async with s.get("https://api.github.com") as r:
            return await r.json()

print(asyncio.run(get_data()))

➡️ Отлично подходит для ботов, парсеров и сервисов, где много запросов.

💾 Пример сервера на aiohttp

from aiohttp import web

async def handle(req):
    return web.Response(text="👋 Привет, async!")

app = web.Application()
app.router.add_get("/", handle)
web.run_app(app, port=8080)

➡️ Лёгкий, неблокирующий веб-сервер без потоков.

📦 Как работают вместе

👍 asyncio — отвечает за переключение задач.
👍 aiohttp — берёт это переключение и добавляет HTTP-клиент + сервер.

🗣️ Запомни: asyncio — это фундамент, aiohttp — инструмент на нём. Первое даёт параллелизм, второе — готовые HTTP-решения. Вместе — реактивный, быстрый и масштабируемый Python.

👩‍💻 Ввод и вывод данных: print() и input()

Это видео объясняет, как работать с базовым вводом и выводом в Python. Рассказывается, как вывести текст через print(), получить данные от пользователя с помощью input(), и как преобразовать строки в числа.

Подойдёт новичкам, которые только начинают писать интерактивные скрипты и хотят понять, как общаться с пользователем в консоли.

👉 Ссылка на первоисточник

🤩 Pytstart || #Видеокурс

👩‍💻 enumerate(): когда нужен индекс и значение

Часто надо итерироваться по списку, но при этом иметь доступ и к индексу, и к элементу?
Забудь про range(len(...)) — используй enumerate().

🟢 Базовый пример

names = ["Alice", "Bob", "Charlie"]

for i, name in enumerate(names):
    print(f"{i}: {name}")

➡️ enumerate возвращает кортеж (индекс, значение) — и читаемо, и безопасно.

🟢 Индекс не с нуля?

for i, item in enumerate(items, start=1):
    print(f"{i}. {item}")

➡️ Удобно для нумерации в интерфейсах, CLI и выводах.

🟢 Работает с любыми итерируемыми объектами

for i, line in enumerate(file):
    if "TODO" in line:
        print(f"{i}: {line.strip()}")

➡️ Полезно при парсинге файлов, логов, API-ответов.

🟢 Сравнение с range(len(...))

# ❌ Не питонично:
for i in range(len(data)):
    print(data[i])

# ✅ Лучше:
for i, value in enumerate(data):
    print(value)

➡️ enumerate исключает ошибки с индексами, повышает читаемость.


🗣️ Запомни: enumerate() — лучший способ, если тебе одновременно нужен индекс и значение. Код получается чище, безопаснее и читаемее.

📍Где применяется:
Парсинг, UI-выводы, CLI-меню, обработка строк, файлов и логов, генерация таблиц, аналитика, отладка, фильтрация по позиции.

📝 Docstrings: строка, которая живёт в коде

В Python можно оставить комментарий — и он исчезнет при запуске.
Но если ты напишешь строку в """кавычках""" под def или class, она останется.
Это не текст для людей. Это часть объекта.

📛 Пример: функция с docstring

def add(a, b):
    """➕ Складывает два числа."""
    return a + b

➡️ Теперь у функции есть свой атрибут:

print(add.__doc__)
# ➕ Складывает два числа.

Docstring — встроенная документация, доступная прямо из кода.

🔍 Магия в help()

help(add)

➡️ Python сам вытаскивает docstring и показывает как документацию.

🧪 Тест прямо внутри описания

def square(x):
    """
    Возвращает квадрат числа.

    >>> square(3)
    9
    """
    return x * x

➡️ python -m doctest file.py — и пример из docstring превратится в тест.

📦 Не только для функций

"""📜 Этот модуль работает с пользователями."""

class User:
    """👤 Представляет юзера."""

    def greet(self):
        """💬 Возвращает приветствие."""
        return "Hello!"

➡️ Модуль, класс и метод — у каждого своя встроенная документация.

🗣️ Запомни: docstring — это не комментарий. Они живут вместе с кодом и делают его самодокументируемым.

👟 pip + venv: ставим библиотеки изолированно — и это работает

venv делает песочницу для проекта.
pip ставит пакеты внутрь неё.
Активировал окружение — и весь мир пакетов идёт в твою папку, а не в систему.

📦 Шаг 1 — создай окружение в корне проекта

# Windows
py -m venv .venv
# macOS / Linux
python3 -m venv .venv

➡️ Появится папка .venv — там свой Python и свой pip.

🔑 Шаг 2 — активируй окружение

# PowerShell
.\.venv\Scripts\Activate.ps1
# cmd
.\.venv\Scripts\activate.bat
# macOS / Linux
source .venv/bin/activate

➡️ Подсказка терминала сменится на (.venv) — ты внутри.

⚙️ Шаг 3 — обнови pip (сначала всегда так)

python -m pip install --upgrade pip

➡️Берёшь свежую версию установщика, меньше странных ошибок.

📥 Шаг 4 — ставь библиотеки

pip install requests
pip install "uvicorn[standard]" fastapi

➡️ Всё уезжает в .venv. Глобальная система не трогается.

🔎 Шаг 5 — смотри, что внутри

pip list
pip show requests

➡️ Видишь только пакеты твоего окружения, не всей машины.

🧾 Шаг 6 — фиксируй зависимости

pip freeze > requirements.txt

➡️ Снимок версий. Его же можно отдать коллегам или CI.

🚚 Шаг 7 — восстановление на другой машине

# в новом клоне проекта
python -m venv .venv
# активируй (как в Шаге 2)
pip install -r requirements.txt

➡️ Получишь те же версии пакетов, что и у автора.

🧪 Проверка — пакет реально в venv

python -c "import requests, sys; print(sys.prefix)"

➡️ Должен увидеть путь к твоему .venv. Значит всё изолировано.

🧹 Шаг 8 — удаление/выход

pip uninstall requests
deactivate

➡️ deactivate возвращает тебя в глобальную среду.

🛠 Быстрые фишки (когда что-то идёт не так)

# pip "не находится" — запускай через интерпретатор
python -m pip --version

# несколько Python — выбери конкретный
# Windows:
py -3.11 -m venv .venv
# macOS / Linux:
python3.11 -m venv .venv

# PowerShell ругается на Activate.ps1:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

➡️ Унификация через python -m pip и явный выбор версии решают 90% проблем.

🗂 Бонус — не коммить venv

echo .venv/ >> .gitignore

➡️ Окружение — локальное. В репо нужен только requirements.txt.

🗣️ Запомни: venv — граница проекта, pip — грузовик с пакетами.

👩‍💻 Списки, кортежи, множества и словари

В этом видео автор объясняет, как в Python работают основные структуры данных: списки (lists), кортежи (tuples), множества (sets) и словари (dictionaries).
Пошагово показано, как создавать каждую структуру, в чём их отличие и в каких случаях стоит использовать именно их — удобно хранить, повторять или быстро искать данные.

➡️ Ссылка на первоисточник

🤩 Pytstart || #Видеокурс

👩‍💻 Celery + Redis/RabbitMQ — таски и очереди без боли

Если у тебя Python-сервис начинает «тормозить» из-за тяжёлых операций (отправка почты, обработка файлов, запросы к API) — не надо делать time.sleep(999). Всё это можно вынести в фон через Celery.

Celery = таски + брокер сообщений (Redis или RabbitMQ) + воркеры, которые жрут эти таски.

📦 Установка:

pip install celery[redis]
pip install redis
# или если брокер RabbitMQ:
# pip install celery[rabbitmq]

🧠 Минимальный пример — таска с Redis:

# tasks.py
from celery import Celery

app = Celery(
    "my_app",
    broker="redis://localhost:6379/0",     # Redis
    backend="redis://localhost:6379/0"     # для хранения результата
)

@app.task
def add(x, y):
    return x + y

Запускаем воркера:

celery -A tasks worker --loglevel=info

В другом файле:

from tasks import add
result = add.delay(4, 6)   # отправляем в очередь
print(result.get())        # ждем выполнения → 10

➡️ Всё: воркер получил таску, посчитал, вернул результат.

📛 RabbitMQ вместо Redis
RabbitMQ — более надёжный брокер, с очередями и персистентностью.

Просто меняем конфиг:

app = Celery("my_app", broker="pyamqp://guest@localhost//")

➡️ Дальше код остаётся тем же.


🔒 Ретраи и устойчивость

Celery умеет сам повторять таску при сбое:

@app.task(bind=True, max_retries=3, default_retry_delay=5)
def fragile_task(self, url):
    try:
        # какая-то логика
        return "ok"
    except Exception as exc:
        raise self.retry(exc=exc)  # автоматический retry

➡️ Если упало — повторим через 5 секунд, максимум 3 раза.

📂 Планировщик задач (Celery Beat)

Можно запускать таски по расписанию:

from celery.schedules import crontab

app.conf.beat_schedule = {
    "clear-cache-every-night": {
        "task": "tasks.clear_cache",
        "schedule": crontab(hour=3, minute=0),  # каждый день в 03:00
    },
}

Запускаем:

celery -A tasks beat

➡️ Всё, у тебя свой cron прямо в Celery.

🧱 Масштабирование

🟢 Redis — проще, быстрее поднять, но хуже с очень тяжёлой нагрузкой.
🟢 RabbitMQ — надёжнее, умнее с очередями (ack, приоритеты, персистентность).
🟢 Celery умеет параллельные воркеры, пулы процессов/потоков.

🎯 Полезные фишки:

🟢 .delay() — отправка таски асинхронно

🟢 .apply_async(countdown=10) — отложить на 10 секунд

🟢 .get(timeout=5) — дождаться результата с таймаутом

🟢 Результаты можно хранить не только в Redis, но и в SQL, Mongo, S3

🗣️ Запомни: Celery — это «рабочие руки» для твоего кода.Ты пишешь только задачу, а кто, где и когда её выполнит — решают воркеры и брокер.