🚦 Feature Flags и Canary: как Python выпускает код без боли

Никто не хочет падений после деплоя. Feature Flags и Canary-развёртывания позволяют включать фичи по частям: сначала 1%, потом 10%, потом всем. Без ручных выкатываний и откатов.

💀 Старый путь — “всё или ничего”

if new_feature_enabled:
    process_new_logic()
else:
    process_old_logic()

➡️ Фича включается для всех сразу. Если падает — падает всё.

⚙️ Добавляем флаг

from featureflags import FeatureFlags

flags = FeatureFlags({
    "new_ui": False,
    "smart_sort": True
})

if flags.is_enabled("smart_sort"):
    sort_items_ml()
else:
    sort_items_old()

➡️Теперь можно включать фичи точечно, без релиза.

🧩 Храним флаги в Redis

import redis, json

r = redis.Redis()
r.set("feature_flags", json.dumps({"beta_chat": True}))
flags = json.loads(r.get("feature_flags"))

if flags.get("beta_chat"):
    launch_beta_chat()

➡️ Изменил флаг в Redis — поведение поменялось в реальном времени.

🧠 Canary rollout

import random

def canary(percent: int):
    return random.randint(1, 100) <= percent

if canary(10):
    serve_new_api()
else:
    serve_old_api()

➡️ Только 10% пользователей получают новую версию. Остальные — стабильный код.

📊 Метрики на фичу

def process():
    if flags["smart_sort"]:
        metrics.increment("sort.smart.active")
    else:
        metrics.increment("sort.old.active")

➡️ Мгновенно видишь, как влияет новая логика.

⚡️ Canary через прокси
NGINX split-трафик по cookie или hash:

if ($cookie_user_group = "canary") {
    proxy_pass http://new-version;
}

➡️ Управляешь выкаткой без касания Python-кода.

🧰 Комбинация с CI/CD

# .github/workflows/deploy.yml
- name: Toggle feature flag
  run: curl -X POST http://flags/api/enable?flag=smart_sort

➡️ Новая фича включается автоматически после деплоя.

🔥 Canary + Celery

if canary(5):
    queue = "tasks_beta"
else:
    queue = "tasks_prod"
send_task(queue, "process_data")

➡️ Даже фоновые задачи можно тестировать на части нагрузки.

🔍 Rollback за секунды

r.set("feature_flags", json.dumps({"smart_sort": False}))

➡️ Фича отключается без перезапуска.

🚀 Full rollout

flags["new_ui"] = True

➡️ Всё прошло — включаем всем. Без deploy, без боли.


🗣 Запомни: флаги — это не костыль, а ремни безопасности. Python с Feature Flags и Canary учит выкатывать код медленно, зато без катастроф.

💻 Терминал, который живёт: Python + rich + prompt_toolkit

CLI уже давно не должен быть серым текстом на чёрном фоне.
rich и prompt_toolkit превращают Python-консоль в полноценный интерфейс: цвет, подсветка, ввод, меню — всё живое и интерактивное.

💀 Старый CLI — мёртвый текст

name = input("Введите имя: ")
print("Привет,", name)

➡️ Работает, но скучно. Ни цвета, ни подсказок.

⚙️ Красота через rich

from rich import print
from rich.console import Console

console = Console()
console.print("[bold green]Hello, world![/bold green]")

➡️ Цвет, стили и форматирование прямо в терминале.

🧩 Прогресс-бары и таблицы

from rich.progress import track
for step in track(range(5), description="Processing..."):
    time.sleep(0.5)

➡️ Визуальный прогресс без GUI.

🧠 Форматированные таблицы

from rich.table import Table
table = Table(title="Users")
table.add_column("Name")
table.add_column("Age")
table.add_row("Alice", "24")
table.add_row("Bob", "30")
console.print(table)

➡️ CLI как dashboard — всё наглядно.

🪄 prompt_toolkit: интерактивный ввод

from prompt_toolkit import prompt
from prompt_toolkit.completion import WordCompleter

langs = WordCompleter(["Python", "Go", "Rust"])
name = prompt("Язык? ", completer=langs)
print("Вы выбрали:", name)

➡️ Автодополнение прямо в консоли.

🎨 История и подсветка синтаксиса

from prompt_toolkit.lexers import PygmentsLexer
from prompt_toolkit.styles import Style
from pygments.lexers.python import PythonLexer

prompt(">>> ", lexer=PygmentsLexer(PythonLexer), style=Style.from_dict({"": "#00ff00"}))

➡️ Консоль как мини-IDE: подсветка кода и цветные темы.

⚡️ Меню и навигация

from prompt_toolkit.shortcuts import checkboxlist_dialog

result = checkboxlist_dialog(
    title="Выбор модулей",
    text="Отметьте нужные:",
    values=[("auth", "Auth"), ("db", "Database"), ("api", "API")]
).run()
print(result)

➡️ Диалоги и чекбоксы прямо в терминале.

🧰 rich + prompt_toolkit = power combo

from rich.console import Console
from prompt_toolkit import PromptSession

console = Console()
session = PromptSession()
while True:
    cmd = session.prompt(">>> ")
    console.print(f"[cyan]Выполняю:[/cyan] {cmd}")

➡️ Цветной ввод, история, мгновенный отклик.

🚀 Добавь hotkeys и асинхронность

from prompt_toolkit import Application
from prompt_toolkit.key_binding import KeyBindings

kb = KeyBindings()
@kb.add("c-c")
def _(event): event.app.exit()

app = Application(full_screen=True, key_bindings=kb)
app.run()

➡️ Обрабатывай клавиши и управляй интерфейсом как в TUI.

🧩 Раскрась логи

from rich.logging import RichHandler
import logging

logging.basicConfig(level="INFO", handlers=[RichHandler()])
logging.info("Система запущена")

➡️ Красивые логи прямо в консоли, без JSON и мусора.

🗣 Запомни: CLI — это тоже интерфейс. С rich и prompt_toolkit Python перестаёт быть скучным в терминале.

👩‍💻 Python + WebAssembly: когда скорость решает

Python — удобный, но медленный. WebAssembly (WASM) даёт шанс выжать из него максимум: код работает в браузере или sandbox-среде со скоростью C, при этом безопасно и кроссплатформенно.

💀 Обычный Python — узкое место

def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

print(fib(35))

➡️ Удобно, но на 35-м числе ноутбук уже греется.

⚙️ Компиляция в WebAssembly

pip install pyodide-build
pyodide build

➡️Собираешь Python-код в wasm-модуль, который можно запускать прямо в браузере.

🌐 Запуск Python в браузере

<script type="module">
  import { loadPyodide } from "https://cdn.jsdelivr.net/pyodide/v0.26.0/full/pyodide.mjs";
  const pyodide = await loadPyodide();
  await pyodide.runPythonAsync("print('Hello from WebAssembly!')");
</script>

➡️ Python выполняется внутри WebAssembly — без сервера, без интерпретатора.

⚡️ Ускоряем вычисления через Rust

#[no_mangle]
pub extern "C" fn square(x: i32) -> i32 {
    x * x
}

➡️ Rust-компонент собирается в .wasm, а Python вызывает его как обычную функцию.

🔗 Подключаем WASM в Python

import wasmtime

store = wasmtime.Store()
module = wasmtime.Module.from_file(store.engine, "math.wasm")
instance = wasmtime.Instance(store, module, [])
square = instance.exports(store)["square"]
print(square(store, 12))

➡️Python вызывает wasm-код напрямую — без C-расширений и лишних зависимостей.

🧩 Лёгкая изоляция

WebAssembly — песочница:

🟢 нельзя обращаться к файлам,
🟢 нельзя падать с segfault,
🟢 код полностью детерминирован.

➡️ Отличный вариант для выполнения непроверенных Python-скриптов.

🧠 Чистый backend в wasm

wasmer run app.wasm

➡️ Python-приложение можно запускать как wasm-бинарь — быстро, безопасно, одинаково на Linux, Windows, macOS.

📊 Pyodide + NumPy

import numpy as np
a = np.arange(1e6)
print(a.sum())

➡️ NumPy под Pyodide работает почти с нативной скоростью — браузер считает как сервер.

🚀 Deployment без Docker

Просто кидаешь .wasm в CDN, и Python-код выполняется где угодно.

➡️ Без зависимостей, без виртуалок — всё в одном бинаре.

🧰 Серверная интеграция

from flask import Flask
from wasmtime import Store, Module, Instance

app = Flask(__name__)
store = Store()
module = Module.from_file(store.engine, "math.wasm")
instance = Instance(store, module, [])
square = instance.exports(store)["square"]

@app.route("/square/<int:x>")
def api_square(x):
    return {"result": square(store, x)}

➡️ Python-API, внутри которого WASM считает как C-код.

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

👩‍💻 Мини-проекты на Python: Калькулятор и "Угадай число"

В этом видео автор показывает, как с нуля создать два практических проекта на Python: простой калькулятор и игру "Угадай число".Разбирается, как реализовать основные операции (сложение, вычитание, умножение, деление), обработать ошибки вроде деления на ноль, и как организовать логику игры с подсказками и проверками.

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

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

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

👩‍💻 Работа с CSV файлами в Python

В этом видео автор показывает, как записывать данные в CSV файлы с помощью модуля csv. Разбирается, как работать с кодировками (особенно проблемы в Windows), управлять разделителями и избегать пустых строк при записи.

Это практический навык, который пригодится при работе с данными, экспортом информации и автоматизации обработки файлов.

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

🗣Запомни: умение работать с CSV — необходимо для любого, кто работает с данными и автоматизацией.

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

🖥 Python-фишка: else работает не только с if!

Многие новички (и даже опытные разработчики) забывают, что в Python блок else можно использовать вместе с циклами for и while.

🧪 Как это работает?
Блок else выполняется только в том случае, если цикл завершился естественным образом (то есть полностью прошел все итерации и не был прерван оператором break).

➡️ Зачем это нужно?
Это позволяет избавиться от лишних переменных-флагов (вроде found = False) при поиске элементов.

📌 Пример:
Ищем число в списке. Если нашли — прерываем цикл. Если перебрали всё и не нашли — срабатывает else.

items = [1, 3, 5, 7]
target = 4

for item in items:
    if item == target:
        print("Нашел!")
        break
else:
    # Сработает, только если break НЕ был вызван
    print("Элемента нет в списке")

💡 Итог: Используйте for-else, чтобы сделать код поиска чище и понятнее, убирая лишние проверки после цикла.

🖥 Python-фишка: Умная распаковка списков

Забудьте про громоздкие срезы вроде list[1:-1]. В Python можно использовать оператор * (asterisk), чтобы гибко распаковывать итерируемые объекты.

✅ Задача:
Нужно взять первый и последний элементы списка, а всё, что посередине, сохранить отдельно.

➡️ Как это сделать красиво:

data = [10, 20, 30, 40, 50, 60]

# first — первый элемент
# last — последний
# *middle — всё остальное (соберется в список)
first, *middle, last = data

print(first)   # 10
print(last)    # 60
print(middle)  # [20, 30, 40, 50]

📌 Где это работает?
Везде! Списки, кортежи, строки. Звездочка может стоять в начале, в конце или посередине (но только одна в выражении).

💡 Это делает код гораздо читабельнее, чем манипуляции с индексами.

🖥 Ленивый дебаг с f-строками

Если вы часто пишете print("var =", var), чтобы проверить значение переменной, то этот трюк сэкономит вам кучу времени.

Начиная с Python 3.8, в f-строках можно использовать знак равно =.

➡️Как это было раньше:

user = "Alex"
age = 25
print(f"user = {user}, age = {age}")
# Вывод: user = Alex, age = 25

📌Как делают профи:
Просто добавьте = в конце переменной внутри фигурных скобок. Python сам подставит имя переменной и её значение.

user = "Alex"
age = 25

print(f"{user=}, {age=}")
# Вывод: user='Alex', age=25

Это работает даже с выражениями:

print(f"{2 + 2 = }") 
# Вывод: 2 + 2 = 4

Мелочь, а код для отладки пишется в два раза быстрее! 🚀

🖥 Словарь, который не ломается

Сталкивались с ошибкой KeyError или писали громоздкие проверки if key not in my_dict, просто чтобы добавить элемент в список внутри словаря?

В модуле collections есть спаситель — defaultdict.

💡 В чем суть?
Если вы обращаетесь к ключу, которого нет, defaultdict не выдаст ошибку, а создаст значение по умолчанию сам.

Пример: Группируем имена по длине.

⛔ Обычный способ:

names = ["Ana", "Bob", "Alex", "John"]
groups = {}

for name in names:
    length = len(name)
    if length not in groups:
        groups[length] = []  # Создаем список, если ключа нет
    groups[length].append(name)

✅ С defaultdict:

from collections import defaultdict

names = ["Ana", "Bob", "Alex", "John"]
# Указываем list как фабрику значений по умолчанию
groups = defaultdict(list) 

for name in names:
    # Не нужно проверять наличие ключа!
    groups[len(name)].append(name) 

print(dict(groups))
# {3: ['Ana', 'Bob'], 4: ['Alex', 'John']}

Меньше кода — меньше багов. Идеально для подсчета статистики и группировки данных.

🖥 Забудьте про os.path

Если вы всё еще склеиваете пути к файлам через строки или os.path.join, пора переходить на pathlib. Это встроенная библиотека, которая превращает пути в удобные объекты.

➡️ Киллер-фича:
Пути можно соединять через оператор деления /! Это выглядит очень чисто и интуитивно.

📌 Пример:
Создадим путь к файлу data/report.txt в текущей директории.

from pathlib import Path

# Получаем текущую папку
current_dir = Path.cwd()

# Магия слешей! Никаких запятых и скобок
file_path = current_dir / "data" / "report.txt"

# Проверяем, существует ли файл
if file_path.exists():
    # Читаем текст сразу методом объекта
    print(file_path.read_text())
else:
    print("Файл не найден")

💡 Это работает кроссплатформенно (и на Windows, и на Linux слэши будут правильными). Код становится объектно-ориентированным и читаемым.

🖥 Проверка условий одной строкой

Как проверить, что все элементы в списке положительные? Писать цикл? Нет!

Используйте встроенные функции all() и any().

numbers = [1, 5, 10, 20]

# all вернет True, только если ВСЕ условия верны
if all(n > 0 for n in numbers):
    print("Все числа положительные!")

# any вернет True, если ХОТЯ БЫ ОДНО условие верно
if any(n > 15 for n in numbers):
    print("Есть число больше 15!")

Это читается почти как обычный английский текст. Пишите выразительно! ✍️

👩‍💻 Python + Redis Streams: real-time пайплайны, которые работают сразу

Real-time — это не обязательно Kafka, ZooKeeper и зоопарк сервисов.
Redis Streams даёт очередь, автодоставку и группировку воркеров в одном бинарнике.Python делает остальное. Ниже — рабочая схема, которая живёт в проде годами.👇

⚙️ 1. Создаём поток событий

import redis
r = redis.Redis()

r.xadd("events:log", {
    "level": "info",
    "msg": "service started"
})

➡️ Redis сам присваивает ID и держит упорядоченность.
С этого момента у тебя есть real-time поток.

🚀 2. Читаем только новые записи

events = r.xread({"events:log": "$"}, block=0)

for stream, items in events:
    for event_id, data in items:
        print(event_id, data)

➡️ $ = читать только новые сообщения.
Идеально для live-обработчиков: телеметрия, алертинг, IoT.

👥 3. Consumer group (несколько воркеров — одна очередь)

try:
    r.xgroup_create("events:log", "log_workers", "$")
except:
    pass

events = r.xreadgroup(
    "log_workers", "worker-1",
    {"events:log": ">"},
    block=5000
)

➡️ > — бери только необработанные записи для группы.
Каждое сообщение попадёт ровно одному воркеру.

📌 4. Подтверждаем обработку

for event_id, data in events[0][1]:
    handle(data)
    r.xack("events:log", "log_workers", event_id)

➡️ Без XACK Redis будет думать, что воркер завис.
ACK — обязательный шаг любого real-time пайплайна.

🧹 5. Держим только последние N событий

r.xadd("events:log",
       {"msg": "slow request"},
       maxlen=1000)

➡️ Redis сам обрежет стрим до последних 1000 записей.
Идеально для журналов и сенсорных потоков.

🔄 6. Полный рабочий пайплайн (минимальная схема)

producer.py

r.xadd("sensor:data", {
    "temp": "22.1",
    "humidity": "44"
})

worker.py

while True:
    events = r.xreadgroup(
        "sensors", "worker-3",
        {"sensor:data": ">"},
        block=3000
    )

    if not events:
        continue

    for event_id, data in events[0][1]:
        store(data)      # запись в БД
        r.xack("sensor:data", "sensors", event_id)

➡️ Получилось: «сенсор → Redis → воркеры → база».
Работает быстро, стабильно и без лишних сервисов.

🧰 7. Backpressure и контроль скорости

length = r.xlen("sensor:data")
if length > 50000:
    throttle()  # временно уменьшаем частоту отправки

➡️ XLEN помогает вовремя ловить переполнения пайплайна.

🛰 8. Репликация для отказоустойчивости

Redis Streams прекрасно работает на Redis-кластерe:

replica-of host port

➡️ При падении ноды поток не теряется — сообщения успевают попасть на реплику.

📈 9. Мониторинг live-нагрузки

redis-cli xinfo stream sensor:data
redis-cli xinfo groups sensor:data
redis-cli xinfo consumers sensor:data group

➡️ Видишь задержку, размер лагов, состояние воркеров, pending list.
Без этого real-time не существует.

🗣 Запомни: Redis Streams — лучший способ собрать real-time пайплайн, когда Kafka — это слишком, а Python — идеальный клей между сенсорами, сервисами и обработчиками данных

👀 Числа, от которых не рябит в глазах

Сколько здесь нулей: 1000000000? Миллиард? Сто миллионов? Приходится считать пальцем по экрану.

Python позволяет использовать знак подчеркивания _ прямо внутри чисел для разделения разрядов. Интерпретатор просто игнорирует эти знаки.

➡️Пример:

# Обычная запись
salary = 5000000 

# Читаемая запись
salary = 5_000_000  # Сразу видно — 5 миллионов

# Работает и с float, и в hex
pi = 3.141_592_653
color = 0xFF_FF_FF

💡 На логику программы это никак не влияет, но читать такой код (и конфиги) в разы приятнее.

🖥 Самый простой способ слить два словаря

Раньше, чтобы объединить два словаря, мы использовали метод .update() (который меняет исходный словарь) или сложную распаковку {**dict1, **dict2}.

Начиная с Python 3.9, появился красивый оператор слияния | (pipe).

📌 Как это работает:

settings_default = {"theme": "light", "notifications": True}
user_settings = {"theme": "dark"}

# Объединяем! Значения из второго словаря перезапишут первые
config = settings_default | user_settings

print(config)
# {'theme': 'dark', 'notifications': True}

💡 Это создает новый словарь, не ломая старые. Просто, понятно и очень похоже на математическое объединение множеств.

🖥 Python-фишка: Красивые сравнения без лишних and

В большинстве языков (C++, Java, JS), чтобы проверить, находится ли число в диапазоне, нужно писать два условия. В Python всё гораздо изящнее.

❌ Как пишут обычно:

age = 25
if age > 18 and age < 60:
    print("Трудоспособный возраст")

✅ Как можно в Python:

age = 25
# Прямо как в математике!
if 18 < age < 60:
    print("Трудоспособный возраст")

Это работает с любым количеством операторов:

x = 5
y = 10
z = 15

if x < y < z:
    print("Порядок возрастания соблюден!")

💡 Код читается быстрее, а вероятность опечататься (забыть and) — меньше.

🖥 Python-фишка: Проходим по двум спискам одновременно

Допустим, у вас есть список имен и список зарплат. Вам нужно вывести их парами. Не нужно использовать индексы!

В Python есть встроенная функция zip(), которая "сшивает" списки как молнию на куртке.

📌 Пример:

names = ["Alice", "Bob", "Charlie"]
salaries = [50000, 60000, 70000]

# name берется из names, salary из salaries
for name, salary in zip(names, salaries):
    print(f"{name} зарабатывает {salary}")

💡 Бонус-трюк:
С помощью zip можно мгновенно создать словарь из двух списков:

data_dict = dict(zip(names, salaries))
# {'Alice': 50000, 'Bob': 60000, ...}

Минимум кода — максимум пользы.

🖥 Как посчитать элементы "за 1 секунду"

Вам нужно узнать, сколько раз каждый символ встречается в строке или сколько раз слово встречается в списке? Не пишите циклы и словари вручную!

В модуле collections есть идеальный инструмент — Counter.

📌 Пример:

from collections import Counter

text = "abracadabra"
stats = Counter(text)

print(stats)
# Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

Он работает как словарь, но умеет больше. Например, метод .most_common() сразу покажет топ элементов:

# Вывести 2 самых частых символа
print(stats.most_common(2)) 
# [('a', 5), ('b', 2)]

🗣️ Идеально для аналитики текстов, логов и простой статистики.

🖥 Моржовый оператор :=

Странное название, но очень полезная суть. Оператор := (он похож на глаза и клыки моржа) позволяет присвоить значение переменной прямо внутри выражения (например, внутри if или while).

Задача:
Получить данные от функции (или пользователя) и проверить, не пустые ли они.

❌ Без моржа (3 строки):

text = input("Введите слово: ")
if len(text) > 5:
    print(f"Длинное слово: {text}")

✅ С моржом (2 строки):

# Мы и присваиваем text, и сразу проверяем его длину
if len(text := input("Введите слово: ")) > 5:
    print(f"Длинное слово: {text}")

Переменная text останется доступной и внутри блока if, и после него. Это отлично экономит место и делает код компактнее.

💻 Асинхронный код без блокировок

Как запускать десятки сетевых запросов одновременно, не тормозя программу? Писать многопоточный код? ❌ Нет!

Используйте async и await с библиотекой asyncio.

import asyncio

async def fetch_data(n):
    print(f"Запрос {n} стартовал")
    await asyncio.sleep(1)  # имитация сетевого запроса
    print(f"Запрос {n} завершён")
    return n * 2

async def main():
    # запускаем все задачи одновременно
    results = await asyncio.gather(*(fetch_data(i) for i in range(5)))
    print("Результаты:", results)

asyncio.run(main())

✅ Что важно:

👍asyncio.gather запускает все задачи параллельно

👍Программа ждёт только по факту завершения задач

👍Код остаётся читаемым и безопасным

😀 Это читается почти как обычный английский текст. Пишите эффективный и современный Python! ✍️

📊Векторизация с NumPy: быстрый и чистый код

Как выполнять математические операции над большими массивами без циклов Python? Писать for и append? ❌ Нет!

Используйте векторизацию NumPy.

import numpy as np

# создаём массив чисел
a = np.arange(1, 6)
b = np.arange(10, 15)

# сложение массивов поэлементно
c = a + b
print("Сумма массивов:", c)

# умножение каждого элемента на 2
d = a * 2
print("Умножение на 2:", d)

✅ Что важно:

👍Все операции выполняются в памяти, быстро и эффективно

👍Не нужны циклы Python — код остаётся чистым и читаемым

👍Подходит для машинного обучения, статистики и научных вычислений

💡 Это читается почти как обычный английский текст. Пишите быстрый и современный Python с NumPy! ✍️

📈 Pandas: группировка и агрегация данных

Как быстро подсчитать суммы, средние и максимум по категориям без цикла? Писать for и if? ❌ Нет!

Используйте groupby и агрегации.

import pandas as pd

# создаём DataFrame
data = pd.DataFrame({
    "Компания": ["A", "B", "A", "B", "C"],
    "Доход": [100, 200, 150, 120, 300],
    "Расход": [50, 80, 60, 70, 150]
})

# группируем по компании и считаем суммарный доход и средний расход
summary = data.groupby("Компания").agg({
    "Доход": "sum",
    "Расход": "mean"
})

print(summary)

✅ Что важно:

👍groupby позволяет группировать данные по ключу

👍agg выполняет несколько операций сразу

👍Код остаётся коротким, читаемым и эффективным

💡 Это читается почти как обычный английский текст. Пишите чистый и быстрый Python для аналитики данных! ✍️