🖥 Срезы (slices) в Python позволяют удобно извлекать части последовательностей (списки, строки, кортежи) с помощью синтаксиса:

sequence[start:stop:step]

🔹start – начальный индекс (по умолчанию 0).
🔹stop – конечный индекс (не включается!).
🔹step – шаг (по умолчанию 1).

📌 Примеры:

lst = [0, 1, 2, 3, 4, 5]

print(lst[1:4])   # [1, 2, 3]  (элементы с индекса 1 по 3)
print(lst[:3])    # [0, 1, 2]  (с начала до индекса 2)
print(lst[::2])   # [0, 2, 4]  (каждый второй элемент)
print(lst[::-1])  # [5, 4, 3, 2, 1, 0]  (разворот списка)

⚡ Итог: срезы позволяют легко работать с последовательностями без циклов и лишнего кода!

👩‍💻 Python в кластере: Dask и Modin без боли

Когда pandas начинает задыхаться на гигабайтах данных — не надо переписывать код.
Просто меняешь библиотеку — и Python начинает считать на всех ядрах и даже на кластере.

💀 Один процесс — узкое горлышко

import pandas as pd
df = pd.read_csv("data.csv")
df.groupby("city").sum()

➡️ Работает на одном ядре. CPU простаивает.

🧩 Dask подключает все ядра

import dask.dataframe as dd
df = dd.read_csv("data.csv")
df.groupby("city").sum().compute()

✅ Тот же код, но задачи делятся на чанки.
Всё летит параллельно.

⚙️ Масштаб до кластера

from dask.distributed import Client
client = Client("tcp://scheduler:8786")

✅ Один клиент — и расчёты пошли по сети.
Каждая нода тянет свой кусок данных.

💡 Modin — как pandas, только быстрее

import modin.pandas as pd
df = pd.read_csv("data.csv")
df.groupby("city").sum()

✅ Ничего не меняешь. Под капотом — Dask или Ray.
Многоядерность включается автоматически.

🧠 Dask + ML = масштаб

from dask_ml.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X, y)

✅ Обучение параллельно на кластере.
Больше данных — та же логика.

🧰 Мониторинг в реальном времени

dask-scheduler &
dask-worker tcp://localhost:8786

➡️ Переходи на localhost:8787 — видишь граф задач, загрузку CPU, память.

🚀 Инфраструктура

dask-ctl deploy kubernetes --replicas 8

✅ Dask легко развернуть в облаке.
Kubernetes, AWS, GCP — всё поддерживается.

🗣 Запомни:Pandas — для ноутбука, Dask и Modin — для продакшена. Меняешь импорт — получаешь распределённые вычисления без боли.

⚙️ unpacking-магия: * и ** в Python👩‍💻

В Python можно распаковывать коллекции в аргументы или структуры — это мощно.

👍 *args и **kwargs — собирают аргументы:

def f(*args, **kwargs):
    print(args, kwargs)

f(1, 2, x=10)  # (1, 2), {'x': 10}

👍 * и ** — распаковывают:

nums = [1, 2, 3]
print(*nums)  # 1 2 3

params = {"sep": " | "}
print(1, 2, 3, **params)  # 1 | 2 | 3

👍 Распаковка в переменные:

a, *middle, b = [1, 2, 3, 4, 5]
print(middle)  # [2, 3, 4]

🗣 Где применять: передача параметров, адаптация API, читаемый код

🚀 Python встречает блокчейн: автоматизация через Web3.py

Когда тебе нужно не просто «читать» блокчейн, а управлять смарт-контрактами — Web3.py становится твоим ключом. Ни лишней магии, просто Python и прямой доступ к Ethereum (или совместимым сетям).

📡 Подключение к сети

from web3 import Web3
w3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/<token>"))
print(w3.is_connected())

✅ Проверяешь соединение — и готов читать блоки, аккаунты, балансы.

💰 Проверка баланса

balance = w3.eth.get_balance("0x742d35Cc6634C0532925a3b844Bc454e4438f44e")
print(w3.from_wei(balance, 'ether'))

➡️ Узнаешь баланс любого адреса в ETH.

📦 Отправка транзакции

tx = {
    'to': '0xRecipientAddress',
    'value': w3.to_wei(0.01, 'ether'),
    'gas': 21000,
    'gasPrice': w3.to_wei('50', 'gwei'),
    'nonce': w3.eth.get_transaction_count(sender),
}
signed = w3.eth.account.sign_transaction(tx, private_key)
w3.eth.send_raw_transaction(signed.rawTransaction)

✅ Отправляешь эфир — Python делает всё сам.

🌐 Подключение к смарт-контракту

abi = json.load(open("contract.abi"))
address = "0xContractAddress"
contract = w3.eth.contract(address=address, abi=abi)

➡️ ABI — это интерфейс. Теперь можно дергать функции контракта.

⚙️ Чтение данных из контракта

value = contract.functions.getData().call()
print(value)

✅ Без газа, без транзакций — просто чтение.

🔥 Вызов функции контракта

tx = contract.functions.setData(42).build_transaction({
    'from': sender,
    'nonce': w3.eth.get_transaction_count(sender),
    'gas': 200000,
    'gasPrice': w3.to_wei('40', 'gwei')
})
signed_tx = w3.eth.account.sign_transaction(tx, private_key)
w3.eth.send_raw_transaction(signed_tx.rawTransaction)

➡️ Запускаешь изменение прямо из Python.

🧠 События контракта

events = contract.events.DataChanged.create_filter(fromBlock='latest')
for e in events.get_all_entries():
    print(e.args)

✅ Отлавливаешь события, реагируешь на апдейты.

⛓️ Работа с блоками

block = w3.eth.get_block('latest')
print(block['number'], block['miner'])

➡️ Мгновенно узнаешь, что происходит в сети.

🔐 Подписание сообщений

msg = "Verify ownership"
signed_msg = w3.eth.account.sign_message(encode_defunct(text=msg), private_key)
print(signed_msg.signature.hex())

✅ Подтверждение владения — без транзакций, без комиссий.

🧰 Проверка подписи

from eth_account.messages import encode_defunct
signer = w3.eth.account.recover_message(encode_defunct(text=msg), signature=signed_msg.signature)
print(signer)

➡️ Узнаешь, кто именно подписал сообщение.

⚡️ Интеграция с Python-сервисом

Комбинируешь Web3.py с FastAPI:

@app.get("/balance/{addr}")
def get_balance(addr):
    return {"balance": w3.from_wei(w3.eth.get_balance(addr), 'ether')}

✅ Получаешь блокчейн API на Python в пару строк.

🧱 Логика на уровне DevOps

Поднимаешь Ethereum-ноду в Docker и подключаешь к Web3.py.
Инфраструктура, тесты, деплой — всё автоматизируется питоновским кодом.

🗣️ Запомни: Web3.py — это не про крипту, а про контроль. Один импорт — и Python начинает разговаривать с блокчейном напрямую.

👩‍💻 Python: где применять и какие задачи решает язык

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

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

🗣️Запомни: Python — универсальный инструмент, и всё зависит от того, как ты его применишь.

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

⚡️ Python + Rust: когда скорость наконец встречает простоту

Когда Python начинает тормозить на тяжёлых вычислениях — не надо бросаться в C. Rust решает проблему безопасно и быстро, а PyO3 делает мост между ними почти без боли.

🐍 Python-код

import rustlib

print(rustlib.sum_numbers([1, 2, 3, 4, 5]))

✅ Просто импортируешь Rust-модуль — и Python получает turbo-ускорение.

🦀Rust-библиотека

use pyo3::prelude::*;

#[pyfunction]
fn sum_numbers(nums: Vec<i64>) -> i64 {
    nums.iter().sum()
}

#[pymodule]
fn rustlib(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(sum_numbers, m)?)?;
    Ok(())
}

➡️ Rust-код превращается в питоновский модуль. Без unsafe, без лишней боли.

⚙️Сборка

maturin develop

✅ PyO3 и maturin делают сборку и установку Rust-модулей под Python за секунды.

🚀CPU-нагрузка? Rust справится

#[pyfunction]
fn fib(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fib(n-1) + fib(n-2),
    }
}

➡️ Python-функция, написанная на Rust, летает в десятки раз быстрее.

🧩 Типы — общие, память — безопасна

PyO3 сам управляет ссылками, не нужно мучиться с GIL и утечками.
Rust-функции безопасно возвращают значения прямо в Python.

💡Асинхронность тоже работает

#[pyfunction]
async fn download(url: String) -> PyResult<String> {
    Ok(reqwest::get(&url).await?.text().await?)
}

✅Rust async + Python asyncio = реальный параллелизм.

🛠 Интеграция с NumPy

use numpy::{PyArray1, IntoPyArray};

#[pyfunction]
fn double(arr: &PyArray1<f64>) -> Py<PyArray1<f64>> {
    let data = arr.as_slice().unwrap();
    let doubled: Vec<f64> = data.iter().map(|x| x * 2.0).collect();
    Python::with_gil(|py| doubled.into_pyarray(py).to_owned())
}

➡️ Rust обрабатывает массивы быстрее любого pandas.

🧠 Используй Rust для тяжёлых блоков

Парсинг, криптография, машинное обучение, обработка JSON — всё, где Python не справляется, Rust добивает.

🛠 DevOps-сборка

Cargo + maturin интегрируются в CI/CD.
Сборка Rust-модулей в .whl пакеты — нативно, быстро, кроссплатформенно.

🔥 Пример использования

from rustlib import fib
print(fib(35))

➡️ Python-код не меняется, а скорость — как у нативного C++.

🗣️ Запомни: Rust не заменяет Python — он его ускоряет. Пиши логику на Python, а критичные куски на Rust — и получай максимум без компромиссов.

⚡️ Терминал как арт: создаём CLI-инструменты на Python красиво и умно

Когда скрипт превращается в утилиту — ты становишься ближе к DevOps-богу.
Больше никаких print("enter value:"). Теперь у тебя интерактив, цвет, автодополнение и команды как в Git.

💀 Боль джуна — всё через input()

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

➡️ Скучно, без стиля, без подсказок.

🎨 Rich — CLI с цветом и табличками

from rich.console import Console
from rich.table import Table

console = Console()
table = Table(title="Users")
table.add_column("ID", style="cyan")
table.add_column("Name", style="green")
table.add_row("1", "Alice")
table.add_row("2", "Bob")

console.print(table)

✅Цвет, выравнивание, таблицы, панели. Консоль превращается в интерфейс.

🧩 Панель статуса — прогресс как у профи

from rich.progress import track
import time

for _ in track(range(5), description="Processing..."):
    time.sleep(0.5)

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

🧠 prompt_toolkit — ввод как в IDE

from prompt_toolkit import prompt
from prompt_toolkit.completion import WordCompleter

langs = WordCompleter(["Python", "Go", "Rust", "Java"])
lang = prompt("Выбери язык: ", completer=langs)
print(f"Твой выбор: {lang}")

✅ Автодополнение, история команд, hotkeys — прямо в терминале.

⚙️ Валидация ввода

from prompt_toolkit.validation import Validator, ValidationError

validator = Validator.from_callable(
    lambda t: t.isdigit(),
    error_message="Нужно число!",
)

age = prompt("Возраст: ", validator=validator)

✅ Ошибки без try/except и костылей.

🚀 Typer — CLI с командами как у Git

import typer

app = typer.Typer()

@app.command()
def greet(name: str):
    print(f"Привет, {name}!")

@app.command()
def add(x: int, y: int):
    print(x + y)

if __name__ == "__main__":
    app()

✅ python app.py greet Alice или python app.py add 2 3 — чисто и понятно.

🧰 Аргументы и автодокументация

python app.py --help

✅ Typer сам создаёт --help, --version, и описание аргументов.

💬 Комбинируем всё

from rich.console import Console
import typer

console = Console()
app = typer.Typer()

@app.command()
def fancy(name: str):
    console.print(f"[bold green]Привет, {name}![/bold green]")

if __name__ == "__main__":
    app()

✅ Красивый CLI с цветом и командами.

🔄 CLI с интерактивом

@app.command()
def choose():
    from prompt_toolkit import prompt
    color = prompt("Твой любимый цвет: ")
    console.print(f"[{color}]Вот как выглядит твой цвет![/]")

✅ Объединил Typer, Rich и Prompt — получил терминальный UX.

📦 Упаковка

poetry build
pip install dist/mycli-0.1.0-py3-none-any.whl
mycli fancy Alice

✅ Утилита ставится как системная команда.

🗣️ Запомни: CLI — это не просто print. Это интерфейс для инженеров. Добавь цвет, интерактив и команды — и твой скрипт перестаёт быть скучным.

🐍 Python: плюсы и минусы языка

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

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

🗣️Запомни: выбор языка — это не про моду, а про задачи, которые ты хочешь решать.

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

⚡️ Python, который пишет сам себя: метапрограммирование и AST

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

🧩 Динамическое создание функций

def make_adder(x):
    return lambda y: x + y
add5 = make_adder(5)
print(add5(10))

➡️ Функция создаёт другую функцию на лету. Код не дублируется, поведение зависит от параметров.

🛠 Изменение классов после определения

class A: pass
A.new_attr = 42
print(A.new_attr)

➡️ Python позволяет дополнять класс динамически, без наследования.

📜 Использование type для создания классов

MyClass = type("MyClass", (object,), {"x": 10})
print(MyClass().x)

➡️ Класс создаётся прямо в коде. Можно строить DSL или API на лету.

🧠 AST: разбор и модификация кода

import ast
tree = ast.parse("a = 1 + 2")
print(ast.dump(tree))

➡️ Можно анализировать или трансформировать код перед выполнением.

⚙️ Компиляция AST в исполняемый код

code = compile(tree, filename="<ast>", mode="exec")
exec(code)
print(a)

➡️ AST превращается в реально выполняемый код. Полная динамика без eval строк.

🔍 Декораторы для генерации поведения

def log_calls(fn):
    def wrapper(*args, **kwargs):
        print(f"Calling {fn.__name__}")
        return fn(*args, **kwargs)
    return wrapper
@log_calls
def foo(): pass
foo()

➡️ Декоратор изменяет функцию «на лету», без изменения исходного тела.

💡 Метаклассы: контроль создания классов

class Meta(type):
    def __new__(cls, name, bases, dct):
        dct["hello"] = lambda self: print("Hello")
        return super().__new__(cls, name, bases, dct)
class A(metaclass=Meta): pass
A().hello()

➡️ Метакласс вмешивается в процесс создания класса и добавляет методы или атрибуты.

📦 Генерация кода для API

for i in range(3):
    exec(f"def func{i}(): print('Function {i}')")
func1()

➡️ Много похожих функций создаётся одной конструкцией, без дублирования.

🧰 AST + метапрограммирование для тестов

def make_test(n):
    code = f"def test_{n}(): return {n} * 2"
    exec(code)
make_test(5)
print(test_5())

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

🗣 Запомни: Python сам по себе — конструктор кода. AST и метапрограммирование превращают идеи в функции и классы на лету, без ручного повторения.

👩‍💻 Python, который говорит по делу: создаём свой DSL

Когда код начинает напоминать магические заклинания, а бизнес хочет «писать на языке предметной области» — пора сделать DSL.
Domain-Specific Language в Python — это не парсер, не компилятор, а читаемый API, который звучит как человеческий язык.

💀 1. Боль обычного кода

create_user("alice", "admin", True, "2025-10-27")

➡️ Через месяц никто не вспомнит, что означают эти аргументы.

🧩 2. Первый шаг — читаемость через Fluent API

user = (UserBuilder()
    .named("alice")
    .with_role("admin")
    .active(True)
    .created_today())

✔️ Код читается как предложение. Python не парсит язык — ты создаёшь его.

⚙️ 3. Реализация Fluent API

class UserBuilder:
    def __init__(self):
        self.user = {}

    def named(self, name):
        self.user["name"] = name; return self
    def with_role(self, role):
        self.user["role"] = role; return self
    def active(self, flag):
        self.user["active"] = flag; return self
    def created_today(self):
        self.user["created"] = "2025-10-27"; return self

➡️ Каждый метод возвращает self — и цепочка становится мини-языком.

📌 4. DSL для инфраструктуры

infra = (Server("app")
    .runs("nginx")
    .exposes(80)
    .depends_on("db"))

✔️ Понятно даже без комментариев.
Ни YAML, ни JSON — только Python, но читается как Terraform.

🚀 5. Декларативный DSL с функциями

def pipeline():
    source("data.csv")
    filter("age > 18")
    transform("normalize")
    output("report.json")

➡️ Здесь функции сами строят дерево операций. Python как язык описания, не исполнения.

💡 6. Внутренние DSL для ML pipeline’ов

model = (train()
    .on("dataset.csv")
    .using("RandomForest")
    .tune(max_depth=10)
    .evaluate("accuracy"))

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

⚡️ 7. Реализация DSL через контекст

class DSL:
    def __enter__(self): print("start")
    def __exit__(self, *a): print("end")

with DSL():
    do("something")

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

📦 8. Мета-программирование = синтаксис DSL

class Rule:
    def __getitem__(self, key):
        return f"IF {key} THEN alert"

rule = Rule()
print(rule["cpu > 90%"])

✔️ DSL с синтаксисом как у конфигов или YAML, но в Python.

🧩 9. Декораторы как ключевые слова DSL

@task("extract")
def extract_data(): ...

@task("transform")
def transform_data(): ...

➡️ Код становится декларацией — Python превращается в язык оркестрации.

🧠 10. Мини-язык для SQL на Python

q = SELECT("name", "age").FROM("users").WHERE("age > 18").ORDER_BY("name")

✔️ Пишешь SQL как код, но читается как запрос. PyPika, SQLAlchemy — готовые примеры DSL.

💬 11. DSL для тестов

given(user="admin").when(login).then(see_dashboard)

➡️ Поведение читается как английский. Это BDD в чистом виде.

🧩 12. Генерация собственного синтаксиса

from textx import metamodel_from_str

grammar = '''
Model: statements*=Statement;
Statement: name=ID '=' value=INT;
'''
meta = metamodel_from_str(grammar)
model = meta.model_from_str("x = 5\ny = 10")

✔️ Теперь ты создаёшь собственный язык с синтаксисом, не ограниченным Python.


🗣️ Запомни: хороший DSL не делает Python сложнее — он делает бизнес-логику читаемой. Чем меньше кода, тем ближе он к человеческой речи.

🚦 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!")

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