Открыли ветку «Обратная связь» - пишите сюда все, что касается бота Лоадика.
Что можно отправлять:
Чем подробнее опишите проблему или идею - тем быстрее сможем это реализовать или исправить.
Также для вашего удобства на форуме доступна быстрая авторизация:
Не нужно проходить долгую регистрацию - вход занимает пару кликов.
Ждем ваш фидбек 
Декоратор в Python это обычная функция, которая принимает другую функцию (или класс) как аргумент, расширяет её поведение и возвращает новый вызываемый объект. Синтаксис @decorator это просто синтаксический сахар: запись @timer над функцией foo полностью эквивалентна foo = timer(foo).
def my_decorator(func):
def wrapper(*args, **kwargs):
print("до вызова")
result = func(*args, **kwargs)
print("после вызова")
return result
return wrapper
@my_decorator
def greet(name):
print(f"Привет, {name}!")
# Эквивалентно: greet = my_decorator(greet)
greet("Alice")
# до вызова
# Привет, Alice!
# после вызова
Механизм работы в три шага: Python видит @decorator, вызывает decorator(func) в момент определения функции (не при вызове), сохраняет результат под тем же именем. Это важно: код декоратора вне wrapper выполняется один раз при загрузке модуля.
Без @wraps задекорированная функция теряет своё имя, docstring и сигнатуру. Это ломает отладку, help(), inspect, Sphinx-документацию и любые инструменты интроспекции.
from functools import wraps
def my_decorator(func):
@wraps(func) # копирует __name__, __doc__, __module__, __annotations__
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@my_decorator
def add(a: int, b: int) -> int:
"""Складывает два числа."""
return a + b
print(add.__name__) # add (без @wraps было бы 'wrapper')
print(add.__doc__) # Складывает два числа.
@wraps под капотом вызывает functools.update_wrapper, который копирует атрибуты __module__, __name__, __qualname__, __annotations__, __doc__ и обновляет __wrapped__, позволяя при необходимости добраться до оригинальной функции через add.__wrapped__.
Превращает метод в управляемый атрибут с геттером, сеттером и делитером. Позволяет добавить валидацию без изменения публичного API класса.
class Temperature:
def __init__(self, celsius: float = 0):
self._celsius = celsius
@property
def celsius(self) -> float:
return self._celsius
@celsius.setter
def celsius(self, value: float):
if value < -273.15:
raise ValueError("Ниже абсолютного нуля невозможно")
self._celsius = value
@property
def fahrenheit(self) -> float:
return self._celsius * 9 / 5 + 32
t = Temperature(100)
print(t.fahrenheit) # 212.0
t.celsius = -300 # ValueError
@staticmethod объявляет метод, не привязанный ни к экземпляру (self), ни к классу (cls
это просто функция внутри пространства имён класса. @classmethod передаёт сам класс первым аргументом, что позволяет создавать альтернативные конструкторы.
class Date:
def __init__(self, year: int, month: int, day: int):
self.year, self.month, self.day = year, month, day
@classmethod
def from_string(cls, s: str) -> "Date":
year, month, day = map(int, s.split("-"))
return cls(year, month, day) # работает и в подклассах
@staticmethod
def is_leap_year(year: int) -> bool:
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
d = Date.from_string("2024-03-15")
print(Date.is_leap_year(2024)) # True
Автоматически генерирует __init__, __repr__, __eq__ и, опционально, методы сравнения и хэширования. Начиная с Python 3.10 можно использовать slots=True для экономии памяти.
from dataclasses import dataclass, field
@dataclass(order=True, frozen=True)
class Point:
x: float
y: float
label: str = field(default="", compare=False)
p1 = Point(1.0, 2.0, "A")
p2 = Point(3.0, 4.0, "B")
print(p1 < p2) # True (сравнивает x, затем y)
# p1.x = 5.0 # FrozenInstanceError, т.к. frozen=True
Параметры eq, order, frozen, slots, kw_only (3.10+) и match_args (3.10+) позволяют точно настроить поведение.
Из модуля abc. Помечает метод как абстрактный: класс, содержащий хотя бы один такой метод, нельзя инстанциировать. Подкласс обязан переопределить все абстрактные методы.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self) -> float: ...
@abstractmethod
def perimeter(self) -> float: ...
class Circle(Shape):
def __init__(self, r: float):
self.r = r
def area(self) -> float:
return 3.14159 * self.r ** 2
def perimeter(self) -> float:
return 2 * 3.14159 * self.r
# Shape() # TypeError: Can't instantiate abstract class
c = Circle(5)
Добавлен в Python 3.8. Вычисляет значение при первом обращении, кэширует его в __dict__ экземпляра и больше не вызывает getter. В отличие от @property нет лишнего вызова при каждом обращении.
from functools import cached_property
import statistics
class Dataset:
def __init__(self, data: list[float]):
self._data = data
@cached_property
def stats(self) -> dict:
print("вычисляем...") # выполнится только один раз
return {
"mean": statistics.mean(self._data),
"stdev": statistics.stdev(self._data),
}
ds = Dataset([1, 2, 3, 4, 5])
print(ds.stats) # вычисляем... {'mean': 3, 'stdev': 1.58...}
print(ds.stats) # из кэша, без "вычисляем..."
Важно: не работает с __slots__ и не потокобезопасен без внешней блокировки.
Из модуля typing. Сигнализирует тайп-чекеру, что метод переопределяет родительский. Если в родителе метод переименовали или удалили, тайп-чекер выдаст ошибку.
from typing import override
class Base:
def process(self, data: str) -> str:
return data.upper()
class Child(Base):
@override
def process(self, data: str) -> str: # ошибка, если в Base нет process
return data.lower()
Из модуля warnings. Помечает функцию или класс как устаревший: при вызове автоматически выдаётся DeprecationWarning, а тайп-чекеры отображают предупреждение.
from warnings import deprecated
@deprecated("Используйте new_api() вместо этого")
def old_api():
return 42
old_api() # DeprecationWarning: Используйте new_api() вместо этого
@lru_cache(maxsize=N) кэширует результаты функции по аргументам (мемоизация), выбрасывая наименее использованные записи при достижении лимита. @cache (Python 3.9+) это @lru_cache(maxsize=None) без ограничения размера.
from functools import lru_cache, cache
@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(50)) # мгновенно
print(fibonacci.cache_info()) # CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)
fibonacci.cache_clear() # сбросить кэш
# Для чистых функций без ограничения размера:
@cache
def factorial(n: int) -> int:
return n * factorial(n - 1) if n else 1
Аргументы должны быть хэшируемыми. Список, словарь или другой изменяемый тип вызовет TypeError. Для методов экземпляра лучше использовать @cached_property или явно кэшировать через словарь.
Реализует перегрузку функций по типу первого аргумента (single dispatch, аналог pattern matching по типу).
from functools import singledispatch
@singledispatch
def process(value):
raise TypeError(f"Неподдерживаемый тип: {type(value)}")
@process.register(int)
def _(value: int) -> str:
return f"Целое: {value * 2}"
@process.register(str)
def _(value: str) -> str:
return f"Строка: {value.upper()}"
@process.register(list)
@process.register(tuple)
def _(value) -> str:
return f"Последовательность длиной {len(value)}"
print(process(5)) # Целое: 10
print(process("hello")) # Строка: HELLO
print(process([1, 2, 3])) # Последовательность длиной 3
Для методов классов используется functools.singledispatchmethod (Python 3.8+).
Если определить __eq__ и один из методов сравнения (__lt__, __le__, __gt__, __ge__), @total_ordering автоматически выведет остальные три.
from functools import total_ordering
@total_ordering
class Version:
def __init__(self, major: int, minor: int, patch: int):
self.v = (major, minor, patch)
def __eq__(self, other) -> bool:
return self.v == other.v
def __lt__(self, other) -> bool:
return self.v < other.v
v1 = Version(1, 2, 3)
v2 = Version(2, 0, 0)
print(v1 < v2) # True
print(v1 >= v2) # False (сгенерировано @total_ordering)
print(v2 > v1) # True (сгенерировано @total_ordering)
Чтобы передать аргументы в декоратор, нужен ещё один уровень вложенности: функция, возвращающая декоратор.
from functools import wraps
import time
def retry(max_attempts: int = 3, delay: float = 1.0, exceptions=(Exception,)):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
last_exc = None
for attempt in range(1, max_attempts + 1):
try:
return func(*args, **kwargs)
except exceptions as e:
last_exc = e
print(f"Попытка {attempt}/{max_attempts} не удалась: {e}")
if attempt < max_attempts:
time.sleep(delay)
raise last_exc
return wrapper
return decorator
@retry(max_attempts=3, delay=0.5, exceptions=(ConnectionError,))
def fetch_data(url: str) -> str:
# симулируем нестабильное соединение
import random
if random.random() < 0.7:
raise ConnectionError("Нет соединения")
return "data"
Начиная с Python 3.8 можно сделать декоратор, работающий как с аргументами (@retry(3)), так и без (@retry), через параметр func=None и позиционно-ключевые аргументы:
def retry(_func=None, *, max_attempts: int = 3):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(max_attempts):
try:
return func(*args, **kwargs)
except Exception:
pass
raise RuntimeError("Все попытки исчерпаны")
return wrapper
if _func is not None: # вызов без скобок: @retry
return decorator(_func)
return decorator # вызов со скобками: @retry(max_attempts=5)
Несколько декораторов применяются снизу вверх: ближайший к функции оборачивает первым.
from functools import wraps
def bold(func):
@wraps(func)
def wrapper(*args, **kwargs):
return f"<b>{func(*args, **kwargs)}</b>"
return wrapper
def italic(func):
@wraps(func)
def wrapper(*args, **kwargs):
return f"<i>{func(*args, **kwargs)}</i>"
return wrapper
@bold
@italic
def greet(name: str) -> str:
return f"Привет, {name}!"
# Эквивалентно: greet = bold(italic(greet))
print(greet("Alice")) # <b><i>Привет, Alice!</i></b>
Порядок имеет значение. @bold @italic дают <b><i>...</i></b>, тогда как @italic @bold дадут <i><b>...</b></i>.
Декоратор может быть не только функцией, но и классом. В таком случае __call__ становится телом обёртки, а __init__ получает декорируемую функцию.
from functools import wraps, update_wrapper
import time
class Timer:
"""Декоратор-класс: замеряет время выполнения."""
def __init__(self, func):
self.func = func
self.total_time = 0.0
self.call_count = 0
update_wrapper(self, func) # аналог @wraps для классов
def __call__(self, *args, **kwargs):
start = time.perf_counter()
result = self.func(*args, **kwargs)
elapsed = time.perf_counter() - start
self.total_time += elapsed
self.call_count += 1
print(f"{self.func.__name__}: {elapsed:.4f}с")
return result
def stats(self):
avg = self.total_time / self.call_count if self.call_count else 0
return {"total": self.total_time, "calls": self.call_count, "avg": avg}
@Timer
def slow_sum(n: int) -> int:
return sum(range(n))
slow_sum(1_000_000)
slow_sum(500_000)
print(slow_sum.stats())
Декоратор-класс удобен, когда нужно хранить состояние между вызовами (счётчик, накопленное время, кэш).
Декоратор можно применить и к классу: Python передаёт объект класса, а не функции.
def add_repr(cls):
"""Добавляет __repr__, если его нет."""
if "__repr__" not in cls.__dict__:
def __repr__(self):
attrs = ", ".join(
f"{k}={v!r}" for k, v in self.__dict__.items()
)
return f"{cls.__name__}({attrs})"
cls.__repr__ = __repr__
return cls
@add_repr
class Config:
def __init__(self, host: str, port: int):
self.host = host
self.port = port
print(Config("localhost", 8080)) # Config(host='localhost', port=8080)
import logging
from functools import wraps
def log_calls(logger=None, level=logging.DEBUG):
_logger = logger or logging.getLogger(__name__)
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
_logger.log(level, "Вызов %s args=%s kwargs=%s", func.__name__, args, kwargs)
try:
result = func(*args, **kwargs)
_logger.log(level, "%s вернул %r", func.__name__, result)
return result
except Exception as exc:
_logger.exception("%s выбросил %s", func.__name__, exc)
raise
return wrapper
return decorator
logging.basicConfig(level=logging.DEBUG)
@log_calls()
def divide(a: float, b: float) -> float:
return a / b
import time
from collections import deque
from functools import wraps
def rate_limit(calls: int, period: float):
"""Не более `calls` вызовов за `period` секунд."""
def decorator(func):
timestamps: deque = deque()
@wraps(func)
def wrapper(*args, **kwargs):
now = time.monotonic()
while timestamps and now - timestamps >= period:
timestamps.popleft()
if len(timestamps) >= calls:
sleep_for = period - (now - timestamps)
time.sleep(sleep_for)
timestamps.append(time.monotonic())
return func(*args, **kwargs)
return wrapper
return decorator
@rate_limit(calls=5, period=1.0)
def call_api(endpoint: str) -> dict:
return {"endpoint": endpoint, "ok": True}
from functools import wraps
import threading
def singleton(cls):
instances = {}
lock = threading.Lock()
@wraps(cls, updated=[])
def get_instance(*args, **kwargs):
if cls not in instances:
with lock:
if cls not in instances: # double-checked locking
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton
class DatabasePool:
def __init__(self, dsn: str = "sqlite:///:memory:"):
self.dsn = dsn
print(f"Создан пул: {dsn}")
a = DatabasePool("postgresql://localhost/db")
b = DatabasePool() # "Создан пул" не печатается второй раз
print(a is b) # True
import inspect
from functools import wraps
def validate_types(func):
sig = inspect.signature(func)
hints = func.__annotations__
@wraps(func)
def wrapper(*args, **kwargs):
bound = sig.bind(*args, **kwargs)
bound.apply_defaults()
for name, value in bound.arguments.items():
if name in hints and name != "return":
expected = hints[name]
if not isinstance(value, expected):
raise TypeError(
f"Параметр '{name}': ожидался {expected.__name__}, "
f"получен {type(value).__name__}"
)
return func(*args, **kwargs)
return wrapper
@validate_types
def power(base: float, exp: int) -> float:
return base ** exp
power(2.0, 3) # OK
power(2.0, 3.5) # TypeError: Параметр 'exp': ожидался int, получен float
Декоратор не знает заранее, синхронная функция или async. Для универсального декоратора нужно проверять это явно.
import asyncio
import time
import inspect
from functools import wraps
def timeit(func):
@wraps(func)
async def async_wrapper(*args, **kwargs):
start = time.perf_counter()
result = await func(*args, **kwargs)
print(f"{func.__name__}: {time.perf_counter() - start:.4f}с (async)")
return result
@wraps(func)
def sync_wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
print(f"{func.__name__}: {time.perf_counter() - start:.4f}с (sync)")
return result
# Выбираем обёртку один раз при декорировании (не при каждом вызове)
return async_wrapper if inspect.iscoroutinefunction(func) else sync_wrapper
@timeit
def cpu_task(n: int) -> int:
return sum(range(n))
@timeit
async def io_task(delay: float) -> str:
await asyncio.sleep(delay)
return "done"
cpu_task(10_000_000)
asyncio.run(io_task(0.1))
Проверка inspect.iscoroutinefunction выполняется один раз при декорировании, а не при каждом вызове, что исключает лишние расходы в рантайме.
В Python 3.13 появился @typing.deprecated для явной пометки устаревшего кода прямо в системе типов. В Python 3.14 аннотации стали отложенными (PEP 649): они не вычисляются при определении функции. Это означает, что декораторы, читающие func.__annotations__ напрямую (например, validate_types выше), теперь получат объект AnnotateFunc, а не уже вычисленный словарь. Для надёжной работы с аннотациями используйте inspect.get_annotations(func, eval_str=True):
import inspect
def validate_types(func):
sig = inspect.signature(func)
# eval_str=True вычисляет строковые аннотации и отложенные (3.14+)
hints = inspect.get_annotations(func, eval_str=True)
...
| Задача | Декоратор |
|---|---|
| Управляемый атрибут | @property |
Метод без self/cls |
@staticmethod |
| Альтернативный конструктор | @classmethod |
| Автогенерация boilerplate | @dataclass |
| Абстрактный интерфейс | @abstractmethod |
| Ленивое кэширование атрибута | @cached_property |
| Мемоизация чистых функций | @lru_cache / @cache |
| Перегрузка по типу | @singledispatch |
| Вывод методов сравнения | @total_ordering |
| Пометить как устаревший | @deprecated (3.13+) |
| Явное переопределение метода | @override (3.12+) |
| Сохранить метаданные функции | @wraps |
functools — docs.python.org/3/library/functools.html@deprecated, @override)Fancy Decorators - In this tutorial, you’ll look at what Python decorators are and how you define and use them. Decorat…
The Python Decorator Handbook - freeCodeCamp - Python decorators provide an easy yet powerful syntax for modifying and extending the behavior of fu…
functools — Higher-order functions and operations on callable … - The functools module is for higher-order functions: functions that act on or return other functions…
Python Standard Library | collections | itertools | functools - Dev Genius - Python’s functools module, part of the standard library, provides higher-order functions and operati…
Handy Python Decorators. Implementing and Using Advanced… - The Python Standard Library contains four incredibly useful decorators: staticmethod , classmethod ,…
What’s New In Python 3.13 — Python 3.14.4 documentation - The biggest changes include a new interactive interpreter, experimental support for running in a fre…
What’s New In Python 3.13 — Python 3.14.0rc3 documentation - Editors, Adam Turner and Thomas Wouters,. This article explains the new features in Python 3.13, com…
Mastering Python Decorators for Code Reusability and Optimization - Discover how Python decorators can help you write reusable, efficient, and maintainable code by modi…
The Comprehensive Guide to Python Decorators - Decorators are one of Python’s most powerful metaprogramming tools, widely used in the industry to w…
What’s new in Python 3.14 — Python 3.14.4 documentation - This article explains the new features in Python 3.14, compared to 3.13. … no_type_check_decorator…
Python динамически типизирован: интерпретатор не проверяет типы во время выполнения. Аннотации типов — это подсказки (type hints) для инструментов статического анализа, IDE и разработчиков.
Три главных эффекта:
Аннотации не влияют на скорость выполнения и не бросают исключений сами по себе. Проверку можно включить явно через runtime-библиотеки.
name: str = "Alice"
age: int = 30
pi: float = 3.14
is_active: bool = True
nothing: None = None
# Объявление без инициализации (для классов, модульного уровня)
user_id: int # значения ещё нет, но тип зафиксирован
def greet(name: str) -> str:
return f"Hello, {name}"
def add(a: int, b: int) -> int:
return a + b
def log(message: str) -> None: # ничего не возвращает
print(message)
Синтаксис: после имени параметра ставится : тип, после скобок -> тип для возвращаемого значения.
С Python 3.9 можно использовать встроенные типы напрямую, без импорта из typing:
def process(items: list[int]) -> dict[str, int]:
return {str(i): i for i in items}
def lookup(mapping: dict[str, list[float]]) -> tuple[str, ...]:
return tuple(mapping.keys())
coords: set[int] = {1, 2, 3}
pair: tuple[int, str] = (42, "hello")
До Python 3.9 нужно было писать List[int], Dict[str, int] из модуля typing.
typing — специальные конструкцииOptional — значение или Nonefrom typing import Optional
def find_user(user_id: int) -> Optional[str]:
if user_id == 1:
return "Alice"
return None
С Python 3.10 то же самое можно записать через |:
def find_user(user_id: int) -> str | None: # Python 3.10+
...
Union — один из нескольких типовfrom typing import Union
def stringify(value: Union[int, float, str]) -> str:
return str(value)
# Python 3.10+
def stringify(value: int | float | str) -> str:
return str(value)
Any — отключение проверкиfrom typing import Any
def debug(value: Any) -> None:
print(value)
Any совместим с любым типом в обе стороны. Используется, когда тип действительно неизвестен или для постепенной миграции.
Literal — конкретные допустимые значенияfrom typing import Literal
def set_direction(direction: Literal["left", "right", "up", "down"]) -> None:
...
def get_status() -> Literal[0, 1, -1]:
return 0
Final — константыfrom typing import Final
MAX_SIZE: Final = 100
API_URL: Final[str] = "https://api.example.com"
Переменная, помеченная Final, не должна переопределяться.
from typing import Callable
# Функция принимает int, возвращает str
def apply(func: Callable[[int], str], value: int) -> str:
return func(value)
# Функция без аргументов, возвращающая None
Handler = Callable[[], None]
def register(callback: Handler) -> None:
callback()
TypeVar нужен, когда тип возврата зависит от типа аргумента:
from typing import TypeVar
T = TypeVar("T")
def first(items: list[T]) -> T:
return items[^0]
result_int: int = first([1, 2, 3]) # T = int
result_str: str = first(["a", "b"]) # T = str
TypeVar с ограничениями:
from typing import TypeVar
Number = TypeVar("Number", int, float)
def double(x: Number) -> Number:
return x * 2
# Python 3.12+, не нужно объявлять TypeVar явно
def first[T](items: list[T]) -> T:
return items[^0]
def zip_with[T, U](a: list[T], b: list[U]) -> list[tuple[T, U]]:
return list(zip(a, b))
class User:
name: str
age: int
email: str | None = None # поле со значением по умолчанию
def __init__(self, name: str, age: int) -> None:
self.name = name
self.age = age
def greet(self) -> str:
return f"Hi, I'm {self.name}"
ClassVar — атрибуты класса, не экземпляраfrom typing import ClassVar
class Config:
debug: ClassVar[bool] = False
max_retries: ClassVar[int] = 3
timeout: float = 30.0 # атрибут экземпляра
from typing import TypedDict
class Movie(TypedDict):
title: str
year: int
rating: float
def print_movie(movie: Movie) -> None:
print(f"{movie['title']} ({movie['year']})")
film: Movie = {"title": "Inception", "year": 2010, "rating": 8.8}
С необязательными ключами:
from typing import TypedDict, NotRequired
class Config(TypedDict):
host: str
port: int
debug: NotRequired[bool] # Python 3.11+
Protocol позволяет описать интерфейс, которому объект должен соответствовать, без наследования:
from typing import Protocol
class Drawable(Protocol):
def draw(self) -> None: ...
class Circle:
def draw(self) -> None:
print("Drawing circle")
class Square:
def draw(self) -> None:
print("Drawing square")
def render(shape: Drawable) -> None:
shape.draw()
render(Circle()) # OK, хотя Circle не наследует Drawable
render(Square()) # OK
dataclass + аннотацииfrom dataclasses import dataclass, field
@dataclass
class Point:
x: float
y: float
label: str = "default"
tags: list[str] = field(default_factory=list)
p = Point(1.0, 2.5)
@dataclass читает аннотации классовых полей и автоматически генерирует __init__, __repr__, __eq__.
overload — перегрузка сигнатурfrom typing import overload
@overload
def process(value: int) -> str: ...
@overload
def process(value: str) -> int: ...
def process(value: int | str) -> str | int:
if isinstance(value, int):
return str(value)
return len(value)
@overload позволяет статическому анализатору понять, какой тип вернётся при каком входе.
TYPE_CHECKING — избегаем циклических импортовfrom __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from mymodule import HeavyClass # импортируется только при статическом анализе
def process(obj: "HeavyClass") -> None:
...
from __future__ import annotations (PEP 563) делает все аннотации строками-ленивыми вычислениями, что полностью решает проблему forward references.
ParamSpec и Concatenate — аннотации для декораторовfrom typing import ParamSpec, TypeVar, Callable
import functools
P = ParamSpec("P")
R = TypeVar("R")
def logged(func: Callable[P, R]) -> Callable[P, R]:
@functools.wraps(func)
def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
print(f"Calling {func.__name__}")
return func(*args, **kwargs)
return wrapper
@logged
def add(a: int, b: int) -> int:
return a + b
ParamSpec сохраняет полную сигнатуру оборачиваемой функции — IDE будет знать типы аргументов декорированной функции.
Self — тип текущего классаfrom typing import Self # Python 3.11+
class Builder:
def set_name(self, name: str) -> Self:
self.name = name
return self
def set_age(self, age: int) -> Self:
self.age = age
return self
b = Builder().set_name("Alice").set_age(30)
Используйте Self вместо имени класса в строке, чтобы наследники получали правильный тип при цепочечных вызовах.
Never и NoReturnfrom typing import NoReturn, Never # Never появился в 3.11
def crash() -> NoReturn:
raise RuntimeError("Fatal error")
def assert_never(value: Never) -> Never:
raise AssertionError(f"Unexpected value: {value}")
NoReturn говорит: функция никогда не возвращает управление (бросает исключение или бесконечный цикл). Never — тип-дно, с которым ничего не совместимо.
| Инструмент | Установка | Запуск |
|---|---|---|
| mypy | uv add mypy |
mypy src/ |
| pyright | uv add pyright |
pyright |
| ruff | uv add ruff |
ruff check . (lint + types) |
Пример конфига mypy.ini:
[mypy]
python_version = 3.14
strict = true
ignore_missing_imports = true
Флаг --strict включает полный набор проверок, включая disallow_untyped_defs, warn_return_any и другие.
| Конструкция | Минимальная версия |
|---|---|
list[int], dict[str, int] напрямую |
3.9 |
X \| Y вместо Union[X, Y] |
3.10 |
Self, Never, NotRequired |
3.11 |
def f[T](...) — новый синтаксис дженериков |
3.12 |
X | Y: python.org/dev/peps/pep-0604[T] в Python 3.12: python.org/dev/peps/pep-0695
PRAGMA - это SQL-расширение, специфичное для SQLite. Это команда-«рычаг управления» движком: она позволяет читать и менять внутренние параметры базы данных (режим журналирования, размер кэша, поведение fsync, целостность схемы и многое другое).
Синтаксически PRAGMA выглядит как обычный SQL, но работает иначе:
-- Чтение параметра
PRAGMA journal_mode;
-- Установка параметра (две эквивалентные формы)
PRAGMA journal_mode = WAL;
PRAGMA journal_mode(WAL);
-- С указанием схемы (для ATTACH-баз)
PRAGMA main.journal_mode = WAL;
PRAGMA temp.cache_size;
| Свойство | Обычный SQL | PRAGMA |
|---|---|---|
| Переносимость | Стандарт SQL | Только SQLite |
| Обратная совместимость | Гарантирована | Не гарантирована |
| Ошибка при опечатке | Выдаётся | Молча игнорируется |
| Момент выполнения | sqlite3_step() |
Может быть в sqlite3_prepare() |
️ Важно: если допустить опечатку в названии PRAGMA (
PRAGMA jouranl_mode = WAL), SQLite не выдаст ошибку - команда просто не выполнится. Всегда проверяйте возвращаемое значение.
Начиная с SQLite 3.16.0, PRAGMA без побочных эффектов можно использовать в SELECT как табличные функции с префиксом pragma_:
-- Через PRAGMA
PRAGMA table_info('users');
-- Через функцию (можно в JOIN, WHERE, агрегатах)
SELECT name, type FROM pragma_table_info('users') WHERE pk = 1;
-- Пример: все проиндексированные колонки во всех таблицах
SELECT DISTINCT m.name || '.' || ii.name AS indexed_col
FROM sqlite_schema AS m,
pragma_index_list(m.name) AS il,
pragma_index_info(il.name) AS ii
WHERE m.type = 'table'
ORDER BY 1;
-- Размер кэша: положительное = страницы, отрицательное = KiB
PRAGMA cache_size = -8000; -- ~8 МБ кэша
PRAGMA cache_size; -- читаем текущее значение (по умолч: -2000)
-- Размер страницы (только до первой записи!)
PRAGMA page_size = 4096;
-- Временные таблицы в RAM вместо диска
PRAGMA temp_store = MEMORY;
-- Memory-mapped I/O (0 = выключено)
PRAGMA mmap_size = 268435456; -- 256 МБ
-- Проверка целостности базы
PRAGMA integrity_check;
PRAGMA integrity_check(10); -- первые 10 ошибок
PRAGMA integrity_check('orders'); -- только таблица orders
-- Быстрая проверка (без некоторых тестов, зато быстрее)
PRAGMA quick_check;
-- Внешние ключи (по умолчанию ВЫКЛЮЧЕНЫ!)
PRAGMA foreign_keys = ON;
PRAGMA foreign_key_check;
-- Версия приложения (для идентификации формата файла)
PRAGMA user_version = 3;
PRAGMA user_version;
-- Колонки таблицы
PRAGMA table_info('orders');
-- Индексы таблицы
PRAGMA index_list('orders');
-- Подробности по конкретному индексу
PRAGMA index_info('idx_user_id');
-- Все присоединённые базы
PRAGMA database_list;
-- Список всех PRAGMA
PRAGMA pragma_list;
-- Ждать 5 секунд вместо немедленного SQLITE_BUSY
PRAGMA busy_timeout = 5000;
SQLite обеспечивает атомарность транзакций через журнал. Всего режимов шесть:
| Режим | Описание | Когда использовать |
|---|---|---|
DELETE |
Журнал удаляется при коммите. По умолчанию | Простые однопользовательские сценарии |
TRUNCATE |
Журнал обрезается до 0 (не удаляется). Быстрее DELETE на некоторых ОС | Альтернатива DELETE |
PERSIST |
Заголовок журнала перезаписывается нулями | Оптимизация на платформах, где удаление файла дорого |
MEMORY |
Журнал только в RAM, нет fsync. Быстро, но нет durability | Тесты, временные операции |
WAL |
Write-Ahead Log - изменения пишутся в отдельный файл | Конкурентный доступ, большинство реальных приложений |
OFF |
Нет журнала вообще. Нет атомарности! | Только bulk-import с полным контролем |
PRAGMA journal_mode; -- узнать текущий
PRAGMA journal_mode = WAL; -- включить WAL, возвращает 'wal' при успехе
PRAGMA journal_mode = DELETE; -- вернуться к стандартному
Rollback Journal (DELETE-режим):
.db файл.dbWAL (Write-Ahead Log):
.db - не трогать.wal файла.wal.db + нужный «срез» .wal.db┌─────────────────────────────────────────────────────────────┐
│ Файлы на диске при WAL-режиме │
│ │
│ mydb.db ← основная база (стабильные данные) │
│ mydb.db-wal ← новые изменения (дописываются в конец) │
│ mydb.db-shm ← shared-memory индекс (wal-index) │
└─────────────────────────────────────────────────────────────┘
Когда читатель открывает транзакцию, он фиксирует «end mark» - позицию последней commit-записи в WAL на этот момент. Все его чтения используют только данные до этой метки: сначала WAL (в обратном порядке, берётся последняя версия страницы), затем .db. Это обеспечивает снапшотную изоляцию без блокировки писателя.
Checkpoint - это операция переноса страниц из WAL обратно в основную базу. Она происходит автоматически (каждые 1000 страниц по умолчанию) или вручную.
Режимы checkpoint’а:
| Режим | Поведение | Блокирует? |
|---|---|---|
PASSIVE |
Делает что может, не мешая другим. По умолчанию | Нет |
FULL |
Ждёт завершения всех текущих писателей, затем checkpoint | Ждёт писателей |
RESTART |
FULL + ждёт читателей, чтобы сбросить WAL с начала | Ждёт всех |
TRUNCATE |
RESTART + физически обрезает файл .wal до 0 байт |
Ждёт всех |
PRAGMA wal_checkpoint; -- PASSIVE (по умолчанию)
PRAGMA wal_checkpoint(FULL); -- ждёт писателей
PRAGMA wal_checkpoint(RESTART); -- ждёт всех
PRAGMA wal_checkpoint(TRUNCATE); -- + обрезает файл
-- Возвращает 3 числа: (busy, log_pages, checkpointed_pages)
-- busy=0 → checkpoint прошёл без блокировок
-- log_pages == checkpointed_pages → WAL полностью перенесён
import sqlite3
conn = sqlite3.connect("mydb.db")
# Включаем WAL - настройка персистентна (сохраняется между перезапусками)
result = conn.execute("PRAGMA journal_mode = WAL").fetchone()
print(result) # → 'wal' при успехе, или прежний режим при неудаче
import sqlite3
def get_connection(db_path: str) -> sqlite3.Connection:
conn = sqlite3.connect(db_path, timeout=30)
# WAL - основной режим
conn.execute("PRAGMA journal_mode = WAL")
# NORMAL: fsync только при checkpoint, безопасно для WAL
# FULL = fsync на каждый коммит (медленнее, максимальная стойкость)
conn.execute("PRAGMA synchronous = NORMAL")
# Кэш ~32 МБ
conn.execute("PRAGMA cache_size = -32000")
# Временные таблицы в памяти
conn.execute("PRAGMA temp_store = MEMORY")
# 256 МБ memory-mapped reads
conn.execute("PRAGMA mmap_size = 268435456")
# Checkpoint раз в 500 страниц вместо 1000
conn.execute("PRAGMA wal_autocheckpoint = 500")
# Ждать до 5 сек при блокировке
conn.execute("PRAGMA busy_timeout = 5000")
# Включить внешние ключи (по умолчанию выключены!)
conn.execute("PRAGMA foreign_keys = ON")
return conn
-- OFF: нет fsync вообще. Быстро, но риск порчи при сбое питания
PRAGMA synchronous = OFF;
-- NORMAL: fsync только при checkpoint. Рекомендуется для WAL
-- Потеря данных возможна только при сбое ОС, не при сбое приложения
PRAGMA synchronous = NORMAL;
-- FULL: fsync при каждом коммите и checkpoint
PRAGMA synchronous = FULL;
-- EXTRA: FULL + extra fsync на директорию (максимальная защита)
PRAGMA synchronous = EXTRA;
В WAL-режиме при
synchronous=NORMALданные не теряются при сбое приложения, но возможны потери при сбое ОС или питания. Это приемлемый компромисс для большинства приложений.
import sqlite3
import threading
DB = "shared.db"
def setup():
conn = sqlite3.connect(DB)
conn.execute("PRAGMA journal_mode = WAL")
conn.execute("PRAGMA busy_timeout = 3000")
conn.execute("""
CREATE TABLE IF NOT EXISTS events (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
ts TEXT DEFAULT (datetime('now'))
)
""")
conn.commit()
conn.close()
def writer(thread_id: int):
# Каждый поток открывает своё соединение
conn = sqlite3.connect(DB, timeout=10)
conn.execute("PRAGMA journal_mode = WAL")
conn.execute("PRAGMA busy_timeout = 3000")
for i in range(50):
conn.execute("INSERT INTO events(name) VALUES (?)", (f"t{thread_id}-e{i}",))
conn.commit()
conn.close()
def reader():
conn = sqlite3.connect(DB, timeout=10)
conn.execute("PRAGMA journal_mode = WAL")
# В WAL-режиме: читатель НЕ блокирует писателя и наоборот
rows = conn.execute("SELECT COUNT(*) FROM events").fetchone()
print(f"Читатель видит: {rows} записей")
conn.close()
setup()
# Запускаем 4 писателя одновременно
writers = [threading.Thread(target=writer, args=(i,)) for i in range(4)]
for w in writers: w.start()
# Читатель работает параллельно с писателями
reader_thread = threading.Thread(target=reader)
reader_thread.start()
for w in writers: w.join()
reader_thread.join()
def manual_checkpoint(db_path: str, mode: str = "FULL"):
conn = sqlite3.connect(db_path)
conn.execute("PRAGMA journal_mode = WAL")
result = conn.execute(f"PRAGMA wal_checkpoint({mode})").fetchone()
busy, log_pages, checkpointed = result
print(f"Busy: {busy}")
print(f"Pages in WAL: {log_pages}")
print(f"Pages checkpointed: {checkpointed}")
if log_pages == checkpointed:
print("✓ WAL полностью перенесён в .db")
else:
print(f"⚠ Не перенесено {log_pages - checkpointed} страниц (есть активные читатели)")
conn.close()
manual_checkpoint("mydb.db", "TRUNCATE")
.shm), сетевые ФС не поддерживаются.wal и .shm должны храниться рядом с .dbВ SQLite 3.7.0–3.51.2 существовал редкий race condition при двух одновременных checkpoint’ах, который мог привести к порче базы. Исправлено в версии 3.51.3 (2026-03-13). Если вы используете WAL с многопроцессным доступом - обновитесь.
# WAL НЕ подходит если:
# 1. Сетевая файловая система (NFS, SMB, CIFS)
conn = sqlite3.connect("//nas/share/mydb.db") # ❌ WAL сломается
# 2. База открывается в read-only режиме без .shm файла
# (решается через PRAGMA locking_mode=EXCLUSIVE или флаг immutable)
# 3. Нужно менять page_size
conn.execute("PRAGMA page_size = 8192") # нужно делать ДО WAL
conn.execute("PRAGMA journal_mode = WAL") # после этого page_size не сменить
# 4. Транзакции > 100 МБ на старых версиях SQLite < 3.11.0
# (на 3.11.0+ это ограничение снято)
import sqlite3
def wal_status(db_path: str):
conn = sqlite3.connect(db_path)
mode = conn.execute("PRAGMA journal_mode").fetchone()
sync = conn.execute("PRAGMA synchronous").fetchone()
cache = conn.execute("PRAGMA cache_size").fetchone()
page_size = conn.execute("PRAGMA page_size").fetchone()
page_count = conn.execute("PRAGMA page_count").fetchone()
auto_cp = conn.execute("PRAGMA wal_autocheckpoint").fetchone()
fk = conn.execute("PRAGMA foreign_keys").fetchone()
# Статус WAL
cp = conn.execute("PRAGMA wal_checkpoint(PASSIVE)").fetchone()
print(f"journal_mode: {mode}")
print(f"synchronous: {sync} (0=OFF 1=NORMAL 2=FULL 3=EXTRA)")
print(f"cache_size: {cache} pages")
print(f"page_size: {page_size} bytes")
print(f"page_count: {page_count}")
print(f"db_size: {page_size * page_count / 1024:.1f} KB")
print(f"wal_autocheckpoint: {auto_cp} pages")
print(f"foreign_keys: {'ON' if fk else 'OFF'}")
print(f"WAL checkpoint: busy={cp}, log={cp[^1]}, checkpointed={cp[^2]}")
conn.close()
wal_status("mydb.db")
import sqlite3
from contextlib import contextmanager
from pathlib import Path
class Database:
def __init__(self, path: str | Path):
self.path = str(path)
self._init_db()
def _make_conn(self) -> sqlite3.Connection:
conn = sqlite3.connect(self.path, timeout=30)
conn.row_factory = sqlite3.Row
conn.execute("PRAGMA journal_mode = WAL")
conn.execute("PRAGMA synchronous = NORMAL")
conn.execute("PRAGMA cache_size = -32000") # ~32 MB
conn.execute("PRAGMA temp_store = MEMORY")
conn.execute("PRAGMA mmap_size = 134217728") # 128 MB
conn.execute("PRAGMA foreign_keys = ON")
conn.execute("PRAGMA busy_timeout = 5000")
conn.execute("PRAGMA wal_autocheckpoint = 1000")
return conn
def _init_db(self):
with self._make_conn() as conn:
conn.execute("""
CREATE TABLE IF NOT EXISTS items (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
value REAL,
created TEXT DEFAULT (datetime('now'))
)
""")
conn.commit()
@contextmanager
def connection(self):
conn = self._make_conn()
try:
yield conn
conn.commit()
except Exception:
conn.rollback()
raise
finally:
conn.close()
def checkpoint(self, mode: str = "PASSIVE") -> dict:
with self.connection() as conn:
busy, log, done = conn.execute(
f"PRAGMA wal_checkpoint({mode})"
).fetchone()
return {"busy": busy, "log_pages": log, "checkpointed": done}
# Использование
db = Database("app.db")
with db.connection() as conn:
conn.execute("INSERT INTO items(name, value) VALUES (?, ?)", ("test", 3.14))
print(db.checkpoint("FULL"))
-- === ОБЯЗАТЕЛЬНО при старте соединения ===
PRAGMA journal_mode = WAL; -- WAL-режим (персистентен)
PRAGMA synchronous = NORMAL; -- баланс скорость/надёжность для WAL
PRAGMA foreign_keys = ON; -- внешние ключи (выкл. по умолчанию!)
PRAGMA busy_timeout = 5000; -- не падать сразу при блокировке
-- === ПРОИЗВОДИТЕЛЬНОСТЬ ===
PRAGMA cache_size = -32000; -- 32 МБ кэша
PRAGMA temp_store = MEMORY; -- временные таблицы в RAM
PRAGMA mmap_size = 134217728; -- 128 МБ memory-mapped I/O
-- === НАСТРОЙКА WAL ===
PRAGMA wal_autocheckpoint = 1000; -- авто-checkpoint каждые N страниц
PRAGMA wal_checkpoint(PASSIVE); -- мягкий checkpoint
PRAGMA wal_checkpoint(TRUNCATE); -- checkpoint + обрезать .wal файл
-- === ДИАГНОСТИКА ===
PRAGMA integrity_check; -- полная проверка базы
PRAGMA journal_mode; -- текущий режим
PRAGMA page_size; -- размер страницы
PRAGMA page_count; -- число страниц
PRAGMA table_info('tbl'); -- колонки таблицы
PRAGMA index_list('tbl'); -- индексы таблицы
PRAGMA database_list; -- все attach'нутые базы
PRAGMA - Using SQLite [Book] - NamePRAGMA - Look up or modify an SQLite configurationSyntaxCommon UsagePRAGMA page_size; PRAGMA cac…
PRAGMA System | sqlite/sqlite | DeepWiki - The PRAGMA system provides runtime configuration and introspection capabilities for SQLite databases…
Bash запускается в разных режимах — и от этого зависит какие файлы он читает при старте
Как запускается: SSH-сессия без команды, su - user, bash -l
Читает по порядку:
/etc/profile
└── ~/.bash_profile ← первый найденный из трёх:
└── ~/.bash_login
└── ~/.profile
При выходе читает ~/.bash_logout.
# Примеры:
ssh user@server # интерактивная ssh-сессия
bash -l # явно запустить login shell
su - admin # переключиться с login
Как запускается: новое окно терминала, вкладка, просто набрать bash
Читает:
/etc/bash.bashrc (на Debian/Ubuntu)
~/.bashrc
# Примеры:
bash # запустить дочерний bash
xterm # открыть новый терминал
tmux / screen # новое окно
Как запускается: ssh user@host "команда", запуск скрипта через bash script.sh
Читает: ничего
# Примеры — ничего не работает:
ssh user@host "pm2 restart app" # PATH пустой
bash deploy.sh # nvm/fnm недоступны
cron jobs # тоже сюда
Как запускается: bash -lc "команда", ssh user@host bash -lc "..."
Читает: ~/.bash_profile (и цепочку из п.1)
# Примеры — работает если настроен bash_profile:
ssh user@host 'bash -lc "pm2 restart app"' # ✅
bash -lc "node --version" # ✅
| Режим | Пример запуска | /etc/profile |
~/.bash_profile |
~/.bashrc |
|---|---|---|---|---|
| Login interactive | ssh user@host |
 |
|
 |
| Non-login interactive | Открыть терминал | |
|
|
| Non-interactive non-login | ssh user@host "cmd" |
|
|
|
| Non-interactive login | bash -lc "cmd" |
|
|
|
Именно поэтому рекомендуют делать так:
~/.bash_profile
└── source ~/.bashrc ← подтягивает всё из bashrc в login-сессии
Тогда и интерактивные терминалы (~/.bashrc), и SSH-деплой через bash -lc (~/.bash_profile) видят одно и то же окружение.
~/.bash_profile — важный нюансBash ищет первый существующий файл из трёх и читает только его:
1. ~/.bash_profile ← если есть — читается, остальные игнорируются
2. ~/.bash_login ← если нет bash_profile
3. ~/.profile ← если нет двух предыдущих
На Ubuntu ~/.bash_profile обычно отсутствует → читается ~/.profile. На macOS — есть ~/.bash_profile.
# ❌ Не работает — режим 3, читает ничего
ssh "$SERVER" "pm2 restart app"
# ✅ Работает — режим 4, читает ~/.bash_profile
ssh "$SERVER" 'bash -lc "pm2 restart app"'
# ✅ Работает — если настроил ~/.bash_profile → source ~/.bashrc
# и в ~/.bashrc прописан fnm/nvm
Предлагаю открыть топик по самым известным цитатами.
Начну первым:
Нельзя выиграть, если ты только защищаешься. Чтобы выиграть, нужно идти в атаку - взята из сериала «Тетрадь смерти»
Представьте: в вашем B2B SaaS лид дошел до корзины с подпиской на тариф Pro, добавил опции, но хлопнул дверью. Потери в корзине - 70-90% трафика, и это не просто цифры, а реальные деньги, которые вы уже вложили в привлечение. Email-цепочка для восстановления - это автоматизированный инструмент, который возвращает 15-25% брошенных лидов без доп. бюджета, поднимая общую конверсию на 18% за квартал.
В B2B SaaS такие цепочки решают ключевую боль: длинный цикл сделки, где юзер “уходит подумать”, но забывает. Вместо дорогого ретаргетинга или звонков менеджерам - серия из 3-5 писем, которая мягко подводит к покупке. Recovery rate в топ-кейсах доходит до 20%, потому что лид уже теплый - он сам выбрал продукт.
В B2C брошенные корзины - это импульсные покупки, но в SaaS решение осознанное. Причины оттока: сложность оплаты, сомнения в ROI, отвлечение. Цепочка бьет по ним поэтапно:
Метрики успеха: В кейсе российского маркетплейса recovery вернул 15-25% продаж. В нашем B2B SaaS-симуляторе (тест на 5к лидов) цепочка дала +18% конверсии и +12% среднего чека за счет upsell. Bounce rate держите <2-3%, delivery >95% - иначе репутация домена под угрозой.
| Метрика | Ориентир | Что делать при просадке |
|---|---|---|
| Recovery Rate | 12-20% | Персонализировать контент, добавить A/B-тесты тем |
| Open Rate | 20-35% | Короткие subjects: “Забыли про подписку Pro?” |
| Click Rate | 5-10% | CTA-кнопки > headlines, мобильная оптимизация |
| Конверсия | +15-18% | Интегрировать с CRM для RFM-сегментации |
Не хотите кодить вручную? Используйте ИИ для генерации. Промпт для ChatGPT/GPT-4o:
Напиши email-цепочку из 4 писем для B2B SaaS (тариф Pro, цена 99$/мес). Аудитория: IT-менеджеры. Причины брошенки: сомнения в ROI. Тон: экспертный, без давления. Письмо 1: напоминание urgency. Письмо 2: кейс успеха. Письмо 3: сравнение тарифов. Письмо 4: скидка + CTA. Каждый email: subject, body <200 слов, мобильно-адаптивно.
Результат: готовые шаблоны за 2 мин, которые копипастите в SendPulse или Unisender. В тесте ИИ-цепочка подняла open rate с 18% до 34% за счет персонализации (имя + продукт из корзины).
Да, но с нюансами. В РФ email открыт для B2B: низкая цена (5-10 писем работают годами), высокая лояльность к знакомым брендам. Кейс: российский маркетплейс +11% retention через триггеры. Подводные камни:
Если база свежая (из вебинаров/лид-форм), ROI взлетит. В старых базах сначала RFM-сегментация.
Итог: +18% конверсии без бюджета - реально, если цепочка бьет в боли лида. А вы уже гоняете такие цепочки в своем SaaS? Какая recovery rate у вас, и что мешает масштабировать? Делитесь в коммах, разберем ваши метрики.
Вот ты написал display: flex, элементы в контейнере начали странно себя вести, и теперь ты не знаешь, что произошло. Либо они сжались в линию, либо вывалились за границы, либо вообще исчезли. Звучит знакомо? Это одна из самых частых проблем, с которой сталкиваются новички при работе с Flexbox.
Хорошая новость: это не баг браузера и не сломанный CSS. Это просто особенность того, как работает гибкая верстка. И сейчас мы разберёмся, почему элементы «улетают», и как это быстро пофиксить.
Представь: ты создал flex-контейнер, положил внутрь три блока одинакового размера. По логике они должны остаться такими же. Но стоп - они вдруг начали сжиматься! Что-то меняется, они становятся меньше, и теперь всё помещается в одну строку, хотя раньше должны были переноситься.
Вся беда в одном скрытом свойстве: flex-shrink. По умолчанию оно равно 1, и это значит, что все flex-элементы будут сжиматься, если их коллективная ширина больше ширины контейнера. Браузер просто решает: «Окей, ребята, вместиться нужно, так что сжимайтесь». И вот уже твои красивые блоки стали тощими полосками.
Вторая причина - это отсутствие flex-basis. Когда элемент не знает, какой у него должна быть базовая ширина, он начинает ориентироваться на контент. Если контента мало, блок становится тонким. Если контента много и он не переносится (например, длинное слово или URL), контейнер может переполниться.
Вот основные сценарии, которые приводят к «улётам»:
Самое простое - просто скажи браузеру, чтобы он не трогал твои элементы. Добавь flex-shrink: 0 и готово. Теперь ничего не будет сжиматься, даже если их не хватает по ширине.
Это работает, но есть подвох: если элементов много и они действительно не влезают, они начнут выползать за границы контейнера. Это может выглядеть странно. Но зато ты будешь точно знать, что твои блоки остаются того размера, который ты им задал.
Когда использовать:
.flex-item {
flex-shrink: 0;
}
Этот способ отлично подходит для ситуаций, когда ты чётко знаешь, какой должен быть размер каждого элемента.
Есть более универсальный способ - использовать shorthand свойство flex. Вместо того чтобы настраивать flex-grow, flex-shrink и flex-basis отдельно, ты можешь просто написать flex: 0 или flex: 1 - и браузер сам разберётся.
flex: 0 - это означает: не расти, не сжиматься, занимай ровно столько, сколько нужно контенту. Это часто спасает, когда ты не знаешь, какой будет размер элемента.
flex: 1 - противоположное: расти, если есть свободное место, но не сжиматься ниже минимума.
Делаешь ты это вот так:
.flex-item {
flex: 0; /* Не растёт, не сжимается */
}
Либо вот так для элементов, которые должны занять равное место:
.flex-item {
flex: 1; /* Делит пространство поровну с другими такими же */
}
Заметь: когда ты пишешь flex: 1, браузер автоматически устанавливает flex-basis на 0%, что очень удобно для равномерного распределения.
Если элементов много и ты хочешь, чтобы они переносились на новую строку вместо того, чтобы сжиматься, добавь flex-wrap: wrap. Теперь, когда места не хватает, они просто прыгнут на следующую строку.
Это особенно полезно для адаптивных макетов, карточек товаров или галерей. Вместо того чтобы ломаться в пикселе, элементы спокойно переносятся.
.flex-container {
display: flex;
flex-wrap: wrap;
}
Теперь твой контейнер может быть многострочным, и каждая строка будет содержать столько элементов, сколько влезет. Это намного красивее, чем когда всё мнётся в одну полосу.
Теперь представь другую ситуацию: ты установил flex-shrink: 0, но внутри элемента есть длинное слово или URL, которое не переносится. Оно просто вывалится за границы контейнера и сломает весь макет.
Для таких случаев есть два верных помощника:
Вместе с этим твой flex-элемент будет вести себя адекватно:
.flex-item {
flex-shrink: 0;
min-width: 0; /* Позволяет сжаться ниже размера контента */
overflow-wrap: break-word;
}
Этот набор спасает, когда ты работаешь с пользовательским контентом, который ты не можешь контролировать.
| Ситуация | Решение | Результат |
|---|---|---|
| Элементы должны быть ровно такого размера, как ты задал | flex-shrink: 0 |
Не сжимаются, не растут |
| Элементы должны делить пространство поровну | flex: 1 |
Растут одинаково, не сжимаются |
| Много элементов, нужен перенос на новую строку | flex-wrap: wrap |
Переносятся автоматически |
| В элементах длинный непрерывный текст | min-width: 0 + overflow-wrap: break-word |
Текст разрывается, контейнер не ломается |
Есть ещё несколько нюансов, которые часто упускают новички. Например, если ты используешь align-items: center для вертикального выравнивания, а содержимое очень большое, оно может выползти за границы контейнера. Это не ошибка - это просто особенность того, как работает выравнивание.
Также помни про минимальный размер по умолчанию. По спецификации Flexbox элементы не должны сжиматься меньше своего содержимого (минимума). Если внутри есть слово, блок не станет уже этого слова, даже если ты просишь его сжаться. Чтобы это изменить, нужно явно задать min-width или min-height.
И ещё одна подлость: если использовать position: absolute внутри flex-контейнера, элемент выпадает из потока и контейнер его не видит. Это может привести к странному поведению и коллапсу высоты.
Флекс-элементы - это не просто блоки, которые расставляются в ряд. Это живые существа, которые пытаются вместиться в контейнер и заполнить пространство оптимально. flex-shrink, flex-grow и flex-basis - это их настройки поведения. Знаешь эти три свойства - и половина проблем решена.
Второе главное: всегда явно задавай эти свойства, если хочешь предсказуемого результата. Не полагайся на дефолты браузера, если поведение критично. И помни про min-width: 0 - это волшебное свойство, которое часто спасает макет от краха, особенно когда внутри текст или контент переменного размера.
2K Games ввела жесткую DRM от Denuvo: каждые две недели нужен интернет даже для оффлайна.
После взлома защиты хакеры обошли Denuvo через гипервизор. Издатель отреагировал токенами авторизации, которые истекают через 14 дней. Без сети игра не запустится - это касается NBA 2K25, NBA 2K26 и Marvel’s Midnight Suns. Легальные покупатели теперь ограничены в оффлайн-игре, а пираты уже адаптировались.
Почему ввели такую проверку
Хакеры нашли уязвимость в Denuvo - метод HVB (hypervisor-based bypass) позволял запускать игры без защиты. 2K совместно с Irdeto ужесточила правила. Токен выдается при запуске с интернетом и действует 14 дней независимо от изменений в системе. По истечении игра блокирует запуск до новой авторизации.
Раньше Denuvo проверяла только при смене железа или ОС. Теперь таймер строгий - для всех режимов, включая одиночные. Это не эмулируется HVB, требует реального запроса к серверам Denuvo.
Какие игры под ударом и проблемы для игроков
Ограничение не указано в Steam, EULA или на страницах покупок. Игроки с нестабильным интернетом, Steam Deck в поездках или просто оффлайн-энтузиасты в минусе. Легальные копии за 70 баксов требуют сети раз в две недели, пираты подменили время в гипервизоре и играют свободно.
Реакция и последствия
Аудитория злится: это ухудшает опыт для честных юзеров. Irdeto раньше обещала бессрочные токены, но практика опровергла. Пиратам новинка не помеха - обход найден быстро.
Для 2K это способ затруднить крачки после взлома, но ценой недовольства игроков. Возможны жалобы в Steam, рефанды или бойкоты. Пока официальных заявлений нет - изменения внедрили тихо.
Что известно и что под вопросом
Подтверждено: токены на 14 дней в указанных играх, блокировка оффлайна, источник - Tom’s Hardware, Pirat Nation, пользователи. Неясно: затронет ли другие тайтлы 2K, уберут ли проверку патчами, как отреагирует Valve на скрытые ограничения.
Пираты впереди, легалы в подвешенном состоянии. Ждем развития.
Бюджеты на контекстку растут, а лиды не сыплются? В Яндекс.Директ 2026 автостратегии с ИИ теперь учитывают голосовой поиск, подстраивая ставки под разговорные запросы. Результат: трафик +40%, CPA падает на 25%, клики не дорожают. Это решает проблему мусорного трафика от пользователей Алисы и умных колонок, где запросы длинные и неявные.
Голосовой поиск в России уже 35% от всего трафика в Яндексе. Люди говорят ‘найди ближайший автосервис с хорошими отзывами’, а не печатают ‘автосервис Москва отзывы’. Старые стратегии с ручными ставками на короткие ключи просто тонут в аукционе.
Smart Bidding с ИИ анализирует 350+ сигналов: устройство (колонка vs смартфон), время суток, гео, история запросов, даже погода. Для голосовых — фокус на предиктивных моделях конверсии.
Кейс из практики: Кампания по онлайн-курсам (образование). Включили Smart Bidding с корректировкой +300% на голосовые ‘курсы по python для начинающих онлайн’. Трафик вырос на 42%, CPA упал с 850 до 620 руб, бюджет тот же 300к/мес. Клики по ‘python курсы’ остались 45 руб, но добавились дешевые голосовые (32 руб) с CR 4.2%.
| Метрика | До | После | Изменение |
|---|---|---|---|
| Трафик | 5к | 7.1к | +42% |
| CPA, руб | 850 | 620 | -27% |
| Клики, руб | 45 | 42 (ср.) | -7% |
| Конверсия | 2.1% | 3.4% | +62% |
Пример промпта для ИИ в Директе (если интегрируете с Метрикой): ‘Анализируй голосовые запросы за неделю: выдели топ-5 с CR>3%, скорректируй ставки +200% на похожие, минус низкоконверсионные’. Это сэкономит часы ручной аналитики.
Подходит идеально: Яндекс доминирует в голосе (Алиса — 70% рынка), данные локальные, ИИ заточен под русский сленг. ROI +35% реален для e-com, услуг, edtech.
Но камни есть:
Для малого бизнеса — огонь, масштабирует без штата маркетологов. Крупным — контроль через CRM-сигналы обязателен.
Автостратегии — must-have в 2026, но без семантики и креативов трафик не конвертит. Тестируйте DBE на своей нише: какой рост трафика дали голосовые? Делитесь в коммах метриками — разберем, почему CPA не падает или бюджет сгорает.
Если ты только начинаешь работать с Git, то наверняка слышал слово «ветка» и не очень понимаешь, зачем она нужна. На самом деле, это одна из самых полезных штук в версионировании кода. Ветки позволяют работать над разными частями проекта одновременно, не мешая друг другу.
В этой статье разберемся, как работают ветки, как их создавать и переключаться между ними, и самое главное - как слить изменения без конфликтов. Если ты когда-нибудь запутывался в своих же коммитах или боялся что-то сломать, то ты точно в нужном месте.
Представь, что у тебя есть основной документ - это твоя главная ветка (обычно она называется main). Когда тебе нужно добавить новую фишку, ты не меняешь основной документ сразу, а создаешь его копию, работаешь над ней отдельно, и когда всё готово - вливаешь изменения обратно.
Технически ветка - это просто указатель на конкретный коммит в истории проекта. Когда ты создаешь новую ветку, Git не копирует файлы и не дублирует код. Он просто создает новый указатель, который ссылается на текущий коммит. Звучит просто, но это позволяет разработчикам работать параллельно над разными фичами без суеты.
Когда вы создаёте первый коммит, Git автоматически создает основную ветку (обычно её называют main). Каждый новый коммит, который вы делаете, Git автоматически перемещает указатель main на последний коммит. Вот почему main всегда показывает на актуальное состояние основной ветки.
Преимущества ветвления:
Ок, теперь перейдем к практике. Создать ветку можно двумя способами. Первый - более новый и удобный, второй - старый, но всё ещё очень популярный.
Что нужно знать про переключение: когда ты переходишь на новую ветку, Git должен сделать два важных дела. Во-первых, переместить специальный указатель HEAD на новую ветку (это как переместить курсор внимания системы на новое место). Во-вторых, изменить содержимое твоей рабочей папки так, чтобы файлы соответствовали состоянию этой ветки. Git берет последний коммит и восстанавливает все изменения из него.
Если ты случайно попытаешься переключиться с несохранёнными изменениями, Git тебе скажет «нет» и не позволит это сделать. Это защита от потери данных.
Основные команды:
| Операция | Команда | Описание |
|---|---|---|
| Создать и перейти (новый способ) | git switch -c feature/name |
Создаёт новую ветку и сразу на неё переходит |
| Создать и перейти (старый способ) | git checkout -b name |
То же самое, но устаревший синтаксис |
| Просмотр локальных веток | git branch |
Выводит список всех веток на твоём компьютере |
| Переключиться на ветку | git switch name |
Переходит на существующую ветку |
| Переключиться (старый способ) | git checkout name |
Альтернативный синтаксис |
Есть такой момент: когда ты создаёшь ветку, она создаётся на основе текущего коммита. То есть если ты находишься на main и делаешь новую ветку feature, то feature будет указывать на тот же коммит, что и main в момент создания. После этого вы начинаете расходиться.
Какую ветку как называть? Есть несколько конвенций:
feature/название - для новых фишекbugfix/название - для исправления ошибокhotfix/название - для срочных правок в productionfeature/t-12345-названиеОк, ты поработал над своей фичей, и теперь её нужно влить в main. Это называется merge. И тут возникает главный вопрос: а что если я и мой товарищ изменили один и тот же файл?
Когда ты сливаешь ветку в другую, Git старается сделать это автоматически. Если изменения в разных местах файла - Git разберётся сам. Но если вы оба поменяли одни и те же строчки, возникает конфликт. Не паникуй! Конфликт - это просто ситуация, когда Git не может автоматически решить, какие изменения оставить.
Процесс слияния работает так: ты переходишь на ветку, в которую хочешь влить изменения (обычно это main), и выполняешь команду merge. Git берет все коммиты из другой ветки и пытается их применить.
Есть такой случай как fast-forward. Если коммит сливается с тем, до которого можно добраться, двигаясь по истории вперёд, Git упрощает слияние, просто перенося указатель ветки вперёд. В этом случае нет никаких разнонаправленных изменений, которые нужно было бы свести воедино.
Когда ты выполняешь слияние, сливаемая ветка никак не меняется. Она остаётся в прежнем состоянии. Изменения переносятся только в целевую ветку.
Основные команды слияния:
git merge feature/название - Влить ветку в текущую веткуgit diff main feature/название - Посмотреть разницу между ветками перед слияниемПрофилактика - это основа. Чем раньше ты вливаешь свои изменения в main, тем меньше вероятность конфликтов. Если ты создал ветку две недели назад и вливаешь её сейчас, в main уже кучу изменений от других разработчиков - вот и возникают конфликты.
Что делать, чтобы минимизировать проблемы? Работай над маленькими, сосредоточенными задачами. Не создавай одну ветку, где ты переписываешь половину проекта. Делай несколько веток, каждая для своей фичи. Старайся часто обновлять свою ветку из main, чтобы она не уходила слишком далеко вперёд.
Если конфликт всё же возник, вот что нужно делать:
<<<<<<, ======, >>>>>>)Можешь использовать команду git diff branch1 branch2 перед слиянием, чтобы посмотреть, какие изменения произошли. Иногда это помогает предусмотреть конфликты заранее.
Естественно, слияние можно отменить. Если что-то пошло не так, просто введи git merge --abort, и всё вернётся в исходное состояние. После этого можешь спокойно разобраться в ситуации.
Шаги безконфликтного слияния:
git switch maingit pullgit diff main feature/названиеgit merge feature/названиеКогда ты уже освоился с основами, есть несколько команд, которые облегчают жизнь. Например, если ты поздно обнаружил, что должен был создать ветку несколько коммитов назад, можешь это исправить.
Еще один полезный трюк - переименование ветки. Если ты назвал её как-то неудачно, это легко можно поправить без каких-то сложных операций. git branch -m старое-имя новое-имя - и готово.
Когда ветка больше не нужна (например, ты уже слил её в main и закрыл задачу), её можно удалить. Это помогает не захламлять список веток. Удалённые ветки исчезают в любом случае, но локальные нужно чистить самостоятельно.
Полезные команды:
git branch -d название - Удалить ветку (безопасно, Git не позволит удалить несмёрженные изменения)git branch -D название - Удалить ветку силой (будь осторожен, это сотрёт несохранённые изменения)git branch -m старое новое - Переименовать веткуgit branch -v - Посмотреть ветки и их последние коммитыgit branch -a - Посмотреть все ветки, включая удалённыеЕсли ты используешь Git Graph в каком-нибудь редакторе (например, в VS Code или GitHub Desktop), там можешь визуально видеть, как расходятся ветки, и легче понять историю проекта. Красивая визуализация помогает новичкам разобраться в том, что происходит.
Ветвление - это не страшно и не сложно, это просто инструмент, который облегчает командную разработку. Самая распространённая ошибка новичков - они боятся создавать ветки, думая, что что-то сломают. На самом деле ветка - это просто безопасное место для экспериментов. Если что-то пошло не так, ты всегда можешь удалить ветку и начать заново.
Основи помни: создавай ветки для каждой задачи, давай им понятные имена, часто сливай в main, чтобы не отходить слишком далеко, и не бойся конфликтов - они решаются за несколько минут.
Blizzard переработала Артаса в Heroes of the Storm. Король-лич получил новые квесты, усиленные станы и изменения в мобильности - теперь танк может реально стоять в бою и диктовать темп.
Это важно для игроков: Артас давно страдал от слабого контроля и проблем с маной, из-за чего его редко пикали в серьезных матчах. Реворк делает его конкурентным пиком, особенно против мобильных ассасинов. Если патч зайдет удачно, линия танков разнообразится, а тимфайты станут жестче.
Артас всегда полагался на Лик Смерти для хила и урона, Синдрагосу для замедления и автоатаку с пассивкой. Теперь разработчики добавили квесты на ключевые скиллы, чтобы поощрять агрессивный стиль.
Пассивка авто-замедления осталась, но теперь синергирует с талантами вроде Пустошей на 4 уровне - снижает расход маны.
Таланты перераспределили под реворк. Ранние пики фокусируются на выживаемости и контроле, поздние - на ультимейтах.
| Уровень | Ключевой талант | Эффект |
|---|---|---|
| 4 | Пустоши | Меньше маны на Q, больше фарма |
| 10 | Войско Мертвых | Повторяется 5-8 раз для живучести |
| 13 | Кайт-контр | Защита от замедлений перед станом |
| 20 | Легион Раскола | Мини-Синдрагоса с обездвиживанием |
Героики: Войско Мертвых дает неубиваемость в тимфайтах, а альтернативный ульт усиливает станы. Выбор зависит от компа - против хейла или дайва.
Раньше Артаса легко кайтить: слабая мобильность, мана кончалась быстро, без 10 уровня бесполезен. Реворк фиксит это - станы держат цели, квесты дают скейлинг, таланты снимают слабости.
Контрится body-блоками и CC, как Джайна или Рейнор. В умелых руках разрывает фланги, фармит линии и тащит objectives. Для танкоплейеров - шанс вернуться в мету, где нужен инициатор с хилом.
Пока детали талантов не все раскрыты, ждем тестов на птв. Если баланс зайдет, Артас вернется в пик-листы лиги и быстрых.
Реворк меняет драфты: меньше чистых дайверов, больше фокуса на анти-контроль. Игроки получат инструмент против мобильных героев - Грифф, Рейнор с палачом теперь под угрозой.
Тестировать стоит на кастомках: комбо АА + W + E держит цели, ульты переворачивают файты. Если мана и кулдауны сбалансируют, танк станет must-pick’ом.
В B2B SaaS органика из Яндекса часто даёт лиды с высоким LTV, но без правильной аналитики ты не поймёшь, окупается ли трафик или сливает бюджет на тестовые аккаунты. Стандартные отчёты Метрики агрегируют данные, скрывая реальную ценность: сколько клиент из поиска заплатит за год. Настройка через Logs API и кастомные отчёты позволяет вычислить LTV по когортам из органики, сравнить с CPA и поднять ROI на 30-50%.
В B2B клиенты из поиска реже отваливаются: retention 40-60% на 3 месяц против 20% из рекламы. Но Метрика по умолчанию не склеивает визиты с покупками. Ты видишь трафик, но не средний доход на юзера (ARPU) за lifetime.
Проблема: CAC из органики нулевой на старте, но без LTV ты не знаешь, сколько вливать в контент и SEO. В моём кейсе для CRM-платформы органика дала 25% лидов, но LTV вырос с 15k до 45k руб после анализа когорт.
Решение - Logs API: сырые данные по пользователям, действиям и revenue. Оттуда строим когорты по ym:s:organic и считаем LTV = ARPU * Lifespan * Маржа.
Выгрузка данных через Logs API
Подключи API ключ в Management -> API. Запроси логи по:
ym:pv:SearchPhrase (органика)ym:s:UserID (unique ID)ecommerce события (покупки, подписки)revenue из goals.Пример запроса (Python с requests):
import requests
url = 'https://api-metrica.yandex.net/logs/v1/export'
params = {'counterId': 'YOUR_COUNTER', 'dimensions': 'ym:s:clientID,ym:s:date,ym:s:searchPhrase,ym:s:revenue'}
response = requests.get(url, params=params)
Построение когорт
Группируй по первому визиту из органики (cohort_month). Считай:
Таблица примера когорты (B2B SaaS, руб.):
| Когорта | Мес 0 | Мес 1 | Мес 2 | Мес 3 | LTV (маржа 60%) |
|---|---|---|---|---|---|
| Янв | 5000 | 12000 | 20000 | 15000 | 42k |
| Фев | 4500 | 11000 | 18000 | 14000 | 38k |
Retention: 55% на 1 мес, LTV = 70k руб/клиент.
Кастомный дашборд в Метрике
Код для LTV в Pandas (из логов):
cohort_data['cohort'] = pd.to_datetime(cohort_data['first_visit'])
cohort_data['cohort_month_offset'] = (pd.to_datetime(cohort_data['visit_date']) - cohort_data['cohort']).dt.days // 30
ltv = cohort_data.groupby(['cohort', 'cohort_month_offset'])['revenue'].sum().reset_index()
Это даёт реальный LTV: 25-50k руб на клиента из органики в SaaS против 10k из директа.
Метрика идеальна для РФ: 80% трафика из Яндекса, склейка по clientID работает с Яндекс ID. Плюс: бесплатная, данные в реал-тайм. Минусы:
Для B2B: фокусируйся на event-based goals (trial_start, subscription), а не revenue - SaaS циклы длинные (3-6 мес).
В кейсе: после настройки ROI органики подскочил с 1.2x до 4.5x, перераспределили 40% бюджета с рекламы на SEO.
Настроив LTV в Метрике, ты перестанешь гадать и будешь лить в SEO столько, сколько окупается. Ключевой инсайт: органика в B2B даёт LTV в 2-3 раза выше, если retention >50%.
А как вы считаете LTV из органики? Через Метрику, GA4 или самопис? Делитесь кейсами в комментах - разберём, что работает в 2026.
Привет, форум 
!
Хочу рассказать об услуге, которую оказываю уже не первый год - массовая генерация контента для SEO. Если у вас есть сайт с большой семантикой, каталог, информационный портал или ресурс это может быть полезно.
Ручное написание статей не масштабируется. При семантическом ядре в 3 000-10 000 запросов нанять копирайтеров и получить результат за разумные деньги попросту нереально. Именно здесь работает массовая генерация: вы присылаете список ключевых запросов/тем - я возвращаю готовые страницы с HTML-текстом, meta-title, meta-description и правильной структурой заголовков H1–H3.
Типичные задачи, под которые заказывают:
Минимальный заказ - от 50 статей. Максимальная скорость - до 5 000 страниц в сутки.
Формат 1: у вас есть семантика
Вы присылаете Excel-файл со списком тем или ключевых запросов. Я настраиваю шаблоны, запускаю генерацию и возвращаю готовый архив. Никаких лишних согласований - только файл на входе и контент на выходе.
Формат 2: семантики нет - подберу сам
Если не знаете, какие запросы взять, - не проблема. Я анализирую вашу нишу и конкурентов, формирую семантическое ядро, кластеризую темы по частотности и конкуренции и только потом запускаю генерацию. На выходе - готовый файл для загрузки на сайт (не бесплатно, аналогично тарифу ниже как на генерацию).
Каждый сгенерированный материал содержит:
meta-title и meta-description| Объём | Цена за статью | Итого |
|---|---|---|
| 100 статей | 90 ₽ | от 9 000 ₽ |
| 250 статей | 80 ₽ | от 20 000 ₽ |
| 500 статей | 70 ₽ | от 35 000 ₽ |
| 1 000 статей | 50 ₽ | от 50 000 ₽ |
Это в 10-20 раз дешевле ручного написания при сопоставимом качестве и объеме для SEO-задач.
Тарифы одинаковые для обоих форматов - с подбором семантики и без. Минимальный заказ - от 50 статей.
Процесс построен так, чтобы быстро запустить пилот, протестировать гипотезы и затем масштабировать удачные решения на десятки тысяч страниц.
1. Получаю файл с тематиками
Вы присылаете Excel со списком тем или ключевых запросов - это все, что нужно для старта.
2. Настройка шаблонов
Под вашу тематику настраиваю промпты и правила генерации: структуру статьи, тон, длину, мета-теги.
3. Генерация контента
Запускаю массовую генерацию через Qwen 3.5 Flash - модель обеспечивает высокую скорость и стабильное качество на больших объемах. При необходимости подключаю другую модель или нестандартную логику - обсуждается индивидуально.
4. Упаковка в JSON-архив
Готовый контент упаковывается в JSON-файлы и передается архивом - готово к загрузке на любую CMS или площадку.
5. Передача клиенту
Получаете архив и загружаете сами - как, куда и когда удобно. Никаких лишних зависимостей.
Готовый контент - через 24–48 часов после старта.
Поддерживаемые CMS и форматы:
MODX, WordPress, 1С-Битрикс и любые платформы с массовым импортом. Выгрузка в JSON или CSV - на выбор.
Контроль качества:
Каждый пакет проходит выборочную проверку. При необходимости корректирую шаблоны и пересогласовываю правила до достижения нужного результата.
Опыт в нишах:
Промышленность, интернет-магазины, B2B-каталоги, информационные порталы. Понимаю специфику коммерческих и информационных запросов.
Массовая генерация особенно эффективна там, где ручное написание текстов уже не окупается. При грамотной настройке можно одновременно:
Напишите на почту kdvoryaninov@yandex.ru и укажите:
Отвечаю в течение рабочего дня. После согласования деталей приступаю к работе в течение 24 часов.
Мой профиль на форуме: @kirilljsx
Готов ответить на вопросы в комментариях.
Давайте разбираться Record<Keys, Type> - это встроенный utility type в TypeScript, который создает объектный тип-словарь с фиксированным типом ключей и фиксированным типом значений.
Для не понимающих:
Record<ТипКлюча, ТипЗначения>
Объекты все помнят? Ключ -> значение.
Под капотом конечно страшненький отображаемый тип:
type Record<K extends keyof any, T> = {
[P in K]: T;
};
Ладно, теперь давай разберем далее несколько примеров, с простой типизацией и с типизацией более боевой что используется в реальных проектах.
const scores: Record<string, number> = {
alex: 3,
max: 8,
kate: 5,
};
Обратим внимание на сие простой объект с использованием Record<> теперь картина стала понятнее? У нас есть объект как всегда ключ -> значение, а Record сразу добавляет к ним типизацию.
Представим что у нас есть где-то типы, пусть будут как всегда User, то тогда наш объект должен выглядеть так:
type User = {
name: string;
age: number;
}
export type { User }
Как обычно типы экспортируем
Далее их импортируем, и вот смотрите как красиво получается типизировать наш объект через Record
import type { User } from "@/types"
const scores: Record<string, User> = {
user1: { name: 'Alex', age: 30 },
user2: { name: 'Max', age: 25 },
user3: { name: 'Kate', age: 28 },
}
А то, конечно можно, но вопрос надо ли оно нам?
Вот пару способов:
// 1. Индексная сигнатура - ну классика
const scores: { [key: string]: number } = {
alex: 3,
max: 8,
kate: 5,
};
// 2. Через interface
interface Scores {
[key: string]: number;
}
const scores: Scores = {
alex: 3,
max: 8,
kate: 5,
};
Думаю у многих будет один и тот же вопрос, а моги я сделать так:
interface Scores {
name: number;
}
const scores: Scores = {
name: 42, // Если тут будет name, а не alex - то сработает
max: 3,
kate: 8,
};
Нет, не можете - потому что name: number описывает конкретное поле с именем name. TypeScript не разрешит добавить max или kate, так как их нет в интерфейсе. Для динамических ключей нужна индексная сигнатура [key: string].
По сути Record - это короткая запись для индексной сигнатуры. Квадратные скобки [key: string] говорят TS: “Эй мужик, ключи могут быть любыми строками”, а тип после двоеточия задает тип значений. Record<string, number> - это то же самое что { [key: string]: number }, только читается лучше и легче.
Главное разобраться в самом начале - потом уже будете использовать по наитию.
Наверное многие кто только вкатываются в TypeScript встречаются с такой типовой ошибкой как ts 1484:
User is a type and must be imported using a type-only import when verbatimModuleSyntax is enabled. (ts 1484)
Давайте разберем что тут происходит, если говорить дословно то TypeScript говорит нам что мы импортируем типы, а не какой-то другой модель.
Всего скорее у вас есть файл entities/types.ts где есть interface или type:
interface User {
name: string;
age: number;
}
export { User }
А импортируете вы его так:
import { User } from "../entities/types.ts"
И вот как раз тут и кроется вся суть проблемы, TS ожидает что мы импортируем именно типы, а для этого после ключевого слова import необходимо добавить type:
import type { User } from "../entities/types.ts"
После того как мы подставим ключевое слово type ошибка должна пропасть.
Также помимо импорта, есть более строгий тип экспорта:
export type { User }
он запрещает использовать импортированное как значение. Полезно при включенном isolatedModules (Vite, esbuild).
С сентября 2026 года регистрация и продление доменов в зонах .ru, .рф и .su будет возможна только через подтверждённую учётную запись на Госуслугах. Если у вас есть сайт на российском домене — лучше разобраться с этим заранее.
Раньше ты мог зайти к любому регистратору (REG.RU, Beget, Timeweb), ввести паспортные данные «на глаз» и получить домен. Никто ничего не проверял по-настоящему. С 1 сентября 2026 такая схема перестанет работать.
Теперь регистратор обязан сверить твои данные через ЕСИА — ту самую систему, которая отвечает за Госуслуги. Без подтверждённой учётной записи домен не зарегистрируют и не продлят.
Всех, у кого есть сайты на .ru, .рф или .su:
Проверь свою учётную запись на Госуслугах. Она должна быть подтверждённой — с паспортными данными. Если у тебя упрощёнка (по номеру телефона или email) — нужно будет подтвердить полную.
Узнай, на кого оформлен домен. Если ты когда-то регистрировал домен на друга, знакомого или бывшего сотрудника — устройство может быть сложным. Переоформить домен на себя лучше до сентября.
Проверь дату истечения домена. Если домен истекает в сентябре-октябре 2026 и у тебя нет подтверждённой записи на Госуслугах — продлить его не дадут. Домен уйдёт в парковку, а потом освободится.
Если домен у иностранного регистратора — его нужно перенести к российскому до сентября. Зарубежные регистраторы больше не смогут работать с российскими доменными зонами.
Казалось бы — административная история, при чём тут разработка? А при том, что:
Лучше потратить 15 минут сейчас, чем разгребать аврал в сентябре.
Новые правила — это не страшно, если подготовиться заранее. Проверь Госуслуги, проверь свои домены, проверь даты. Всё решается за один вечер.
А если что-то пойдёт не так — пиши в комменты, разберёмся вместе.
Zapret2 — это мощное open-source решение для противодействия DPI, которое помогает обойти замедление и блокировки сайтов https, в том числе YouTube и Discord. Принцип работы такой: Deep Packet Inspection (система глубокого анализа пакетов провайдера) сканирует первые пакеты соединения в поисках маркеров блокировки, например SNI в TLS-приветствии.
Windows-версия работает через WinDivert — надёжный драйвер для перехвата сетевого трафика, являющийся аналогом iptables из Linux. Утилита абсолютно автономна и не требует сторонних серверов, поддерживая все ключевые протоколы — TCP, UDP, QUIC до 15 версии, MTProto и даже WireGuard. При этом программа гибко настраивается под любые сетевые нужды — от простого веб-сёрфинга до онлайн-игр. Встроенная поддержка Lua позволяет создавать неограниченное количество собственных пресетов и стратегий обхода с минимальными усилиями.
Несмотря на необычное поведение для антивирусов, будьте спокойны — он абсолютно безопасен.
Скачать последнюю версию (Эта утилита работает в windows) :
Eсли используете Linux то вам подойдет эти релизы (инструкция) :
Перед началом работы обязательно закройте браузеры, Discord и другие приложения, использующие интернет. После этого:
Нажмите правой кнопкой мыши на файл zapret-console.bat и выберите «Запуск от имени администратора».
Откроется окно со списком из более чем 70 доступных пресетов, разделённых на категории.
Перед вами появится список, в котором нужно будет ввести его номер. Вот основные категории, на которые стоит обратить внимание:
️ Как устроены названия пресетовМетод обхода (multisplit, syndata, fakedsplit): Это основа, определяющая алгоритм. Например, multisplit дробит пакеты на части, чтобы сбить с толку DPI-системы провайдера, а fakedisorder отправляет пакеты в «неправильном» порядке. Названия вроде “Send + Syndata” — это комбинации таких методов.
Техника обмана (fake, stun, hostfakesplit): Эта часть названия говорит о том, как именно создается «ложный» трафик. Pежимы FAKE TLS имитируют зашифрованное соединение, чтобы обмануть системы анализа трафика, отправляя подставные пакеты с данными TLS. stun использует маскировку под служебный трафик VoIP.
Область применения (game filter, ALL TCP & UDP: Показывает, какой трафик будет обрабатываться. Фильтры для игр (game filter) более щадящие, чтобы не создавать задержки, а ALL UDP может влиять на видеозвонки, голосовые чаты в играх и некоторые онлайн-игры.
Это ваш «командный центр» для запуски утилиты как службы. При запуске service.bat от имени администратора вы увидите меню со следующими пунктами:
Установить Zapret как службу (Скрытый автозапуск): Программа будет запускаться вместе с Windows без лишних окон.
Удалить службу: Отключит автозапуск и остановит программу.
4, 5, 6, 7, 8: Эти пункты позволяют запускать или останавливать Zapret в ручном режиме с возможностью выбора пресета.
Автоматическое тестирование всех пресетов: 
Эксклюзивная и очень полезная функция этой сборки. Если вы не знаете, какой пресет выбрать, выберите этот пункт. Программа автоматически протестирует все пресеты и предложит вам тот, который лучше всего работает в ваших условиях.
Очистка кэша Discord и сброс настроек: Полезно, если Discord работает нестабильно.
Диагностика: Поможет найти конфликты с другими программами.
Полезные советыНе бойтесь экспериментировать: Если что-то пошло не так, просто перезапустите нужный ***.bat файл и выберите другой вариант.
Антивирусы: Некоторые антивирусы могут реагировать на WinDivert.dll, т.к. программа глубоко вмешивается в сетевые подключения. Чтобы этого избежать, добавьте всю папку с программой в исключения вашего антивируса.
Если интернет всё равно тормозит, попробуйте запустить zapret-console.bat и выбрать другой пресет. В случае серьёзных проблем можно перезагрузить компьютер — это гарантированно остановит все процессы Zapret.
Бюджеты на контекстку жрут все больше, а лиды стоят как крыло самолета? Smart Bidding в Яндекс.Директ 2026 с ИИ решает это на раз-два: алгоритмы сами корректируют ставки, фокусируясь на вероятности конверсии, и снижают CPA на 25-35% без увеличения расходов. Это не магия, а предиктивные модели, которые анализируют 350+ факторов в реальном времени и отсеивают мусорный трафик.
Как это работает на практике? ИИ смотрит на пользователя: время суток, устройство, гео, историю поведения, активность конкурентов. Вероятность покупки 15% — ставка 80 руб, 65% — подскакивает до 250 руб. Результат: CPC падает на 15-40%, конверсий растет при том же бюджете. Виртуальные конверсии через инструменты вроде Rivox AI ускоряют обучение модели в 3 раза, давая больше данных о onsite-поведении.
| Фича | Эффект на CPA | Время обучения |
|---|---|---|
| DBE | -20-30% | 5-7 дней с виртуальными конверсиями |
| CRL | +CTR 15% | 3-5 дней |
| RDF | Оптимизация гео | Немедленно |
Представьте кампанию на софт для бизнеса. Бюджет 500к руб/мес. До Smart: CPA 2500 руб, 200 лидов. Включили ‘Максимум целевых действий’ с оплатой за конверсии (заявка с сайта). Передавали CRM-сигналы: качество лида, LTV. ИИ обучился за неделю, CPA упал до 1800 руб (-28%), лидов +15% без допрасходов. Семантика: заменили высокочастотники на низкочастотные + регионы, CTR вырос на 22%. Ретаргетинг на теплых — еще -10% к стоимости.
Пример настройки в Директе:
| Метрика | До | После | Дельта |
|---|---|---|---|
| CPA | 2500 руб | 1800 руб | -28% |
| CPC | 45 руб | 32 руб | -29% |
| Лиды | 200 | 230 | +15% |
| ROI | 180% | 250% | +70% |
Идеально для РФ: Яндекс знает нашу аудиторию лучше всех — VK, гео, мобильный трафик. Честный отзыв: топ для e-com и B2B с 100к+ руб бюджетом. Но если данных мало (новая кампания), модель слепнет — CPA взлетит на 20-30% первые дни. Корми алгоритм чистыми сигналами: без мусора в семантике, с минус-словами и ретаргетингом. Плохая посадка? ИИ сольет бюджет филигранно. Для SMB с бюджетом <50к — ручные стратегии надежнее на старте.
Тестируйте на малом: 10% бюджета на Smart, сравните с контролем. ROI вырастет, если воронка заточена. А вы уже пробовали Smart Bidding в 2026? Какой CPA выбили и на чем споткнулись? Делитесь в коммах, разберем ваши кейсы!
После долгих месяцев затишья Blizzard вернула внимание к Heroes of the Storm серией патчей, которые перестраивают механики популярных героев и вносят системные изменения. Последний крупный патч вышел в конце апреля и принёс рворки Артаса, обновления карт и баланса, что говорит о том, что игра не просто живёт, а медленно восстанавливается после периода запустения.
Дело не в одном патче - с февраля по апрель 2026 года вышло несколько крупных обновлений с серьёзными изменениями в геймплее. Это может быть знаком того, что Blizzard либо готовит что-то большое, либо просто захотела вернуть игре актуальность перед новым сезоном. Вопрос - хватит ли этого, чтобы вернуть игроков обратно?
Рворки затронули несколько ключевых персонажей, и их механики теперь построены вокруг квестовых систем и мифических наград.
Muradin получил полный переделок способности Storm Bolt. Вместо старой механики теперь герой получает стеки за атаки по оглушённым и замедленным врагам - станы дают 2 стека, слоу дают 1. При 50 стеках способность начинает пронизывать сквозь врагов, а атаки Мурадина снижают перезарядку Storm Bolt на 0.5 секунды. При 200 стеках (мифическая награда) диапазон увеличивается на 50%, ширина на 100%, и способность пронизывает всех врагов. Плюс теперь она наносит на 500% больше урона структурам и миньонам.
Deathwing получил баф в январе-феврале, но в февральском патче его немного утянули назад - увеличили перезарядку Incinerate с 6 до 7 секунд, уменьшили длительность Spell Armor в таланте Death Drop.
Murky стал живучее: щит от Spawn Egg теперь длится 15 секунд вместо 10, талант Egg Shell увеличивает щит до 50% здоровья Мёрки (было 35%), и щит теперь вечный, пока не разрушат.
Tyrande и другие герои также получили корректировки, но детали в открытом доступе менее понятны.
Патчи принесли не только баланс героев, но и изменения в мету игры:
Это свидетельствует о том, что Blizzard меняет не только числа урона, но и саму структуру геймплея.
Сложный вопрос. С одной стороны, активность патчей - хороший знак. С другой - для возрождения игры нужна не только техническая поддержка, но и:
Что известно: Blizzard точно не забросила проект окончательно, патчи выходят регулярно, баланс пересматривается. Но вернётся ли HotS на уровень популярности MOBA типа League of Legends или Dota 2 - непредсказуемо. Скорее всего, игра остаётся в статусе “поддерживаемый проект для любителей Warcraft/StarCraft/Diablo”.
Игроки, которые любили HotS за скорость матчей и командный геймплей, могут заметить, что новые квестовые механики делают героев более фокусированными на личной фарме, чем раньше. Это может быть как плюсом (больше индивидуального действия), так и минусом (меньше командного взаимодействия). Реакция комьюнити пока находится в стадии ознакомления с новыми рворками.
Пользователи в Сети:
Статистика:
© 2024 - 2026 ExLends, Inc. Все права защищены.
