🛡 Безопасность веба на 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 — это «рабочие руки» для твоего кода.Ты пишешь только задачу, а кто, где и когда её выполнит — решают воркеры и брокер.

🚀 SQL + ORM: от ручного SQL к магии Python

SQL — это язык запросов к базе.
ORM (Object–Relational Mapping) — это прослойка: вместо "писать руками SQL" ты работаешь с объектами.
Python делает это через SQLAlchemy или Django ORM.

📊 Шаг 1 — без ORM, чистый SQL

import sqlite3

conn = sqlite3.connect("app.db")
cur = conn.cursor()

cur.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
cur.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))
conn.commit()

cur.execute("SELECT * FROM users")
print(cur.fetchall())

➡️ Всё честно: таблица, insert, select. Но руками писать SQL = боль и дублирование.

🧩 Шаг 2 — ORM превращает таблицу в класс

SQLAlchemy (пример на SQLite):

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, Session

engine = create_engine("sqlite:///app.db")
Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)

# работа через объекты
with Session(engine) as session:
    session.add(User(name="Alice"))
    session.commit()

    users = session.query(User).all()
    print([u.name for u in users])

➡️ Таблица = класс. Строка = объект. Запрос = метод ORM.

🛠 Шаг 3 — Django ORM (уже встроен в фреймворк)

models.py в Django-проекте:

from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)

➡️ Django сам создаст таблицу app_user.

Создание и запросы:

User.objects.create(name="Alice")
users = User.objects.all()
print([u.name for u in users])

➡️ Всё без SQL — только объекты и методы.

📦 Шаг 4 — фильтрация и условия

SQLAlchemy:

users = session.query(User).filter(User.name == "Alice").all()

Django ORM:

users = User.objects.filter(name="Alice")

➡️ В коде ты пишешь Python, под капотом генерируется SQL:
SELECT * FROM users WHERE name='Alice'

🔗 Шаг 5 — связи (one-to-many)

SQLAlchemy:

from sqlalchemy.orm import relationship, Mapped, mapped_column, DeclarativeBase

class Post(Base):
    __tablename__ = "posts"
    id = Column(Integer, primary_key=True)
    title = Column(String)
    user_id = Column(Integer, ForeignKey("users.id"))
    user = relationship("User", back_populates="posts")

User.posts = relationship("Post", back_populates="user")

➡️ Теперь user.posts даст список постов, а post.user вернёт автора.

Django:

class Post(models.Model):
    title = models.CharField(max_length=100)
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")

➡️ user.posts.all() и post.user работают как магия.

🧪 Шаг 6 — миграции

🟢 SQLAlchemy: через Alembic (alembic revision --autogenerate)
🟢 Django: встроенные миграции (python manage.py makemigrations && migrate)

➡️ Ты меняешь класс → ORM меняет схему в базе.


🗣️ Запомни:ORM не отменяет знание SQL: фильтры, JOIN-ы и транзакции остаются под капотом.

🔠 Type Hints: код говорит за тебя

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

📛 Пример: аннотации в функции

def add(a: int, b: int) -> int:
    return a + b

➡️ В рантайме работает так же.
Но теперь IDE и mypy понимают: на входе и выходе только числа.

🧪 Комбинации типов

from typing import List, Dict

def users_to_dict(users: List[str]) -> Dict[str, int]:
    return {u: len(u) for u in users}

➡️ Python по-прежнему не строгий.
Но твой код стал декларативным: видно, что ждёт функция.

📦 Опциональные значения

from typing import Optional

def find_user(id: int) -> Optional[str]:
    if id == 0:
        return None
    return "admin"

➡️ Без if value is None не разберёшься.
А с Optional всё ясно из сигнатуры.

🔐 Собственные типы

from typing import NewType

UserId = NewType("UserId", int)

def get_user(id: UserId) -> str:
    return f"user-{id}"

➡️ UserId и int одинаковы в рантайме,
но для анализатора — это разные сущности.

🪄 Магия PEP 604 (Python 3.10+)

def foo(x: int | str) -> None:
    ...

➡️ Больше не нужно Union.
Теперь типы можно писать через |.


🗣️ Запомни: type hints — это декларация смысла, а не ограничение.

👩‍💻 Цикл while, Операторы break и continue

В этом видео автор подробно объясняет, как работает цикл while в Python.
Разбираются операторы break и continue, показано, как с их помощью управлять выполнением цикла. Всё демонстрируется на простых примерах, что помогает легко понять и применить эти конструкции на практике.

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

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