📌Schaff Trend Cycle Strategy – Быстрые сигналы на основе MACD и рыночных циклов🧑‍💻

Суть индикатора:🛠️

Schaff Trend Cycle (STC) — это модифицированная версия MACD, разработанная Дугом Шаффом, которая сочетает:

- трендовые свойства MACD,

- фильтрацию через цикличность рынка (с помощью двойного применения стохастика).

В результате получается более быстрый и точный индикатор, чем MACD, с меньшим запаздыванием.

Основные сигналы STC:💸

- STC поднимается выше 25 или 50 → сигнал на покупку

- STC опускается ниже 75 или 50 → сигнал на продажу

- Также используются пересечения порогов и дивергенции как подтверждение

import ccxt
import pandas as pd
import numpy as np
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Шаг 1: MACD
macd_line = ta.trend.macd(df["close"], window_slow=26, window_fast=12)
macd_signal = ta.trend.macd_signal(df["close"], window_slow=26, window_fast=12, window_sign=9)
macd_hist = macd_line - macd_signal

# Шаг 2: Стохастик от MACD
lowest = macd_hist.rolling(window=10).min()
highest = macd_hist.rolling(window=10).max()
stoch = 100 * (macd_hist - lowest) / (highest - lowest + 1e-9)

# Шаг 3: Стохастик от стохастика (фильтр циклов)
stc = stoch.rolling(window=3).mean()

df["stc"] = stc

# Генерация сигналов
df["signal"] = 0
df.loc[(df["stc"] > 25) & (df["stc"].shift() <= 25), "signal"] = 1  # Buy
df.loc[(df["stc"] < 75) & (df["stc"].shift() >= 75), "signal"] = -1 # Sell

# Вывод последних сигналов
print(df[["ts", "close", "stc", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Ensemble Voting Classifier Strategy – Cтратегия на основе голосования моделей (ансамбль)🧑‍💻

Суть идеи:🛠️

Ensemble Voting Classifier — это метод, при котором несколько моделей машинного обучения (или правил/индикаторов) дают свои прогнозы, а итоговый сигнал формируется на основе голосования:

Majority voting — большинство голосов

Weighted voting — взвешенные по точности/достоверности

Soft voting — усреднение вероятностей (если модели дают вероятности)

Преимущества ансамбля:💸

- Уменьшает переобучение отдельных моделей

- Повышает устойчивость к шуму

- Позволяет объединять разные типы моделей (логика, ML, индикаторы)

Пример: 🧨

3 модели → голос за покупку или продажу

1. XGBoost, обученный на RSI/MACD/Bollinger

2. RandomForest, обученный на объёме и свечах

3. Rule-based, если close > EMA200 and RSI < 30 → лонг

import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Данные
df = pd.read_csv("features_signals.csv")  # Должны быть признаки и метка
X = df[["rsi", "macd", "volume", "sma_diff", "atr"]]
y = df["signal"]  # 1 = buy, -1 = sell, 0 = hold

# Разделение
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Масштабирование
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Модели
model1 = LogisticRegression()
model2 = RandomForestClassifier(n_estimators=100)
model3 = SVC(probability=True)

# Ансамбль голосования
ensemble = VotingClassifier(
    estimators=[("lr", model1), ("rf", model2), ("svc", model3)],
    voting="soft"  # можно "hard"
)

# Обучение
ensemble.fit(X_train, y_train)

# Прогноз
pred = ensemble.predict(X_test)
print("Прогнозы:", pred[-10:])

#инструмент

📌 Подпишись  Crypto Python❗️

📌Order Flow Visualizer – Визуализация входящих ордеров и их направления🧑‍💻

Суть идеи:🛠️

Order Flow Visualizer — это инструмент для отображения потока сделок (tape reading) в реальном времени:

- Показывает направление сделок: покупки против продаж,

- Визуализирует скорость, объём и агрессивность ордеров,

Помогает распознавать💸 импульсы, спайки ликвидности, активности "умных денег".

import websocket
import json
import pandas as pd
import matplotlib.pyplot as plt

# Сбор данных через WebSocket Binance
socket = "wss://stream.binance.com:9443/ws/btcusdt@aggTrade"

trades = []

def on_message(ws, message):
    data = json.loads(message)
    price = float(data["p"])
    qty = float(data["q"])
    side = "buy" if data["m"] == False else "sell"  # buyer maker = False => buy
    trades.append({"price": price, "qty": qty, "side": side})
    
    if len(trades) >= 200:
        ws.close()

def on_open(ws):
    print("Соединение открыто")

def on_close(ws):
    print("Соединение закрыто")
    df = pd.DataFrame(trades)
    # Визуализация
    plt.figure(figsize=(12, 6))
    colors = df["side"].map({"buy": "green", "sell": "red"})
    plt.scatter(df.index, df["price"], s=df["qty"]*10, c=colors, alpha=0.6)
    plt.title("Order Flow - BTC/USDT")
    plt.xlabel("Сделка")
    plt.ylabel("Цена")
    plt.show()

# Запуск WebSocket
ws = websocket.WebSocketApp(socket, on_message=on_message, on_open=on_open, on_close=on_close)
ws.run_forever()

#инструмент

📌 Подпишись  Crypto Python❗️

📌Statistical Arbitrage with Cointegration – Парный трейдинг на основе коинтеграции🧑‍💻

Суть стратегии:🛠️

Коинтеграция — это статистическая связь между двумя временными рядами, где их разность (спред) остаётся стационарной, даже если сами ряды нестационарны.
Statistical Arbitrage (StatArb) на коинтеграции предполагает:

- Найти пару активов, где есть долгосрочная устойчивая связь,

- Торговать на расхождении спреда от его среднего значения,

- Шортить актив, который ушёл выше, и лонговать актив, который остался ниже.

Идеальный случай для парного трейдинга:💸

- Активы движутся вместе долгосрочно, но краткосрочно могут расходиться

- Спред между ними возвращается к своему среднему (mean-reversion)

Как определить коинтеграцию:🧨

- Тесты: Engle-Granger, Johansen Test

- Статистика: p-value < 0.05 → есть коинтеграция

- Построение регрессии спреда между двумя активами

import ccxt
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.stattools import coint

# Получение данных
exchange = ccxt.binance()
symbol1 = "ETH/USDT"
symbol2 = "ETC/USDT"
tf = "1h"
limit = 500

ohlcv1 = exchange.fetch_ohlcv(symbol1, timeframe=tf, limit=limit)
ohlcv2 = exchange.fetch_ohlcv(symbol2, timeframe=tf, limit=limit)

df1 = pd.DataFrame(ohlcv1, columns=["ts", "open", "high", "low", "close", "volume"])
df2 = pd.DataFrame(ohlcv2, columns=["ts", "open", "high", "low", "close", "volume"])

# Синхронизация по времени
df1["ts"] = pd.to_datetime(df1["ts"], unit="ms")
df2["ts"] = pd.to_datetime(df2["ts"], unit="ms")
merged = pd.merge(df1[["ts", "close"]], df2[["ts", "close"]], on="ts", suffixes=('_eth', '_etc'))

# Тест коинтеграции
score, pvalue, _ = coint(merged["close_eth"], merged["close_etc"])
print(f"p-value коинтеграции: {pvalue:.5f}")

if pvalue < 0.05:
    print("✅ Пары коинтегрированы, можно строить стратегию!")

    # Построение спреда через регрессию
    model = sm.OLS(merged["close_eth"], sm.add_constant(merged["close_etc"])).fit()
    merged["spread"] = merged["close_eth"] - (model.params[1] * merged["close_etc"] + model.params[0])

    # Нормализация спреда (Z-скор)
    merged["z_score"] = (merged["spread"] - merged["spread"].mean()) / merged["spread"].std()

    # Генерация сигналов
    merged["signal"] = 0
    merged.loc[merged["z_score"] > 1, "signal"] = -1  # Short ETH / Long ETC
    merged.loc[merged["z_score"] < -1, "signal"] = 1  # Long ETH / Short ETC

    print(merged[["ts", "close_eth", "close_etc", "spread", "z_score", "signal"]].tail(10))
else:
    print("❌ Нет стабильной коинтеграции, пары не подходят.")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Execution Slippage Tracker – Фильтрация сигналов при высоком проскальзывании🧑‍💻

Суть инструмента:🛠️

Execution Slippage Tracker отслеживает разницу между ожидаемой и фактической ценой исполнения сделки.

Цель — избежать открытия сделок, если проскальзывание превышает допустимый порог и ухудшает риск-прибыль.

Как использовать на практике:💸

- Автоматически фильтровать трейдинг-сигналы

- Работать только с ликвидными инструментами

- Применять разную допустимую величину slippage для разных стратегий

- Блокировать ордера при неожиданных "провалах" ликвидности

import ccxt

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
desired_amount = 0.1  # количество BTC, которое хотим купить
expected_price = 27000  # ожидаемая цена входа
max_slippage_pct = 0.2  # максимальное допустимое проскальзывание в %

# Получение стакана
order_book = exchange.fetch_order_book(symbol, limit=20)

# Расчёт средней цены для покупки desired_amount
remaining = desired_amount
total_cost = 0

for price, volume in order_book['asks']:
    if volume >= remaining:
        total_cost += price * remaining
        break
    else:
        total_cost += price * volume
        remaining -= volume

avg_execution_price = total_cost / desired_amount

# Расчёт проскальзывания
slippage = (avg_execution_price - expected_price) / expected_price * 100

print(f"Ожидаемая цена: {expected_price}")
print(f"Фактическая средняя цена: {avg_execution_price:.2f}")
print(f"Проскальзывание: {slippage:.3f}%")

# Проверка
if slippage > max_slippage_pct:
    print("❌ Слишком высокое проскальзывание! Сделку пропустить.")
else:
    print("✅ Проскальзывание в пределах нормы. Сделку можно выполнять.")

#инструмент

📌 Подпишись  Crypto Python❗️

📌 Наш канал на YouTube 🧑‍💻

📌Synthetic Short Strategy – Создание шорта через два актива (long A, short B)🧑‍💻

Суть стратегии:🛠️

Synthetic Short — это техника, при которой трейдер имитирует короткую позицию, открывая лонг на одном активе и одновременно шорт на другом, вместо прямой продажи в шорт.

Используется когда:🧨

- Прямой шорт дорог или недоступен (например, нет маржи или фьючерсов),

- Требуется создать нейтральную или направленную позицию,

- Нужно использовать рыночно-нейтральные стратегии или парный трейдинг.

Когда Synthetic Short эффективен:💸

- Между активами существует стабильная корреляция

- Есть ожидание расхождения в скоростях роста/падения

- При торговле деривативами с низким свопом или через спотовые пары

Риски Synthetic Short:🧨

- Если обе позиции идут в неправильную сторону одновременно, убытки удваиваются

- Требуется правильная балансировка размера позиций (особенно, если волатильность активов разная)

import ccxt
import pandas as pd

# Получение данных
exchange = ccxt.binance()
symbol_a = "ETH/USDT"
symbol_b = "BTC/USDT"
limit = 300
tf = "1h"

ohlcv_a = exchange.fetch_ohlcv(symbol_a, timeframe=tf, limit=limit)
ohlcv_b = exchange.fetch_ohlcv(symbol_b, timeframe=tf, limit=limit)

df_a = pd.DataFrame(ohlcv_a, columns=["ts", "open", "high", "low", "close", "volume"])
df_b = pd.DataFrame(ohlcv_b, columns=["ts", "open", "high", "low", "close", "volume"])
df_a["ts"] = pd.to_datetime(df_a["ts"], unit="ms")
df_b["ts"] = pd.to_datetime(df_b["ts"], unit="ms")

# Объединение данных
df = pd.merge(df_a[["ts", "close"]], df_b[["ts", "close"]], on="ts", suffixes=('_a', '_b'))

# Расчёт спреда (A - B)
df["spread"] = df["close_a"] - df["close_b"]

# Логика: рост спреда → профит
df["spread_change"] = df["spread"].diff()

print(df[["ts", "close_a", "close_b", "spread", "spread_change"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Trade Journal Analyzer – Разбор истории трейдов с выводом статистики🧑‍💻

Суть инструмента:🛠️

Trade Journal Analyzer позволяет анализировать историю сделок, чтобы:

- Видеть реальные показатели эффективности,

- Находить сильные и слабые стороны стратегии,

- Улучшать риск-менеджмент и правила входа/выхода.

Что обычно анализируют:💸

- Количество сделок

- Winrate (процент прибыльных сделок)

- Средний профит/убыток

- Profit Factor (отношение общей прибыли к убыткам)

- Максимальная просадка (drawdown)

- Средний риск-ревард (R:R)

- Среднее время удержания сделки

import pandas as pd

# Загрузка журнала
df = pd.read_csv("trades_journal.csv")  # ваши данные

# Базовые расчёты
total_trades = len(df)
wins = df[df["PnL"] > 0]
losses = df[df["PnL"] <= 0]
winrate = len(wins) / total_trades * 100

avg_win = wins["PnL"].mean()
avg_loss = losses["PnL"].mean()
profit_factor = wins["PnL"].sum() / abs(losses["PnL"].sum())
gross_profit = wins["PnL"].sum()
gross_loss = losses["PnL"].sum()

# Максимальная просадка (кумулятивный PnL)
df["cum_pnl"] = df["PnL"].cumsum()
drawdown = df["cum_pnl"] - df["cum_pnl"].cummax()
max_drawdown = drawdown.min()

# Вывод отчёта
print(f"Общее количество сделок: {total_trades}")
print(f"Winrate: {winrate:.2f}%")
print(f"Средний профит: {avg_win:.2f} $")
print(f"Средний убыток: {avg_loss:.2f} $")
print(f"Profit Factor: {profit_factor:.2f}")
print(f"Валовая прибыль: {gross_profit:.2f} $")
print(f"Валовый убыток: {gross_loss:.2f} $")
print(f"Максимальная просадка: {max_drawdown:.2f} $")

#инструмент

📌 Подпишись  Crypto Python❗️

📌Queue Position Tactic – Выставление лимитного ордера для ранней позиции в очереди🧑‍💻

Суть идеи:🛠️

На биржах с приоритетом по времени (FIFO — First In, First Out), крайне важно занять как можно более высокую позицию в очереди лимитных ордеров:

Чем выше в очереди → тем быстрее исполнение при подходе цены,

Тем меньше шанс, что ордер "перепрыгнут" другими лимитками,

Тем выше вероятность избежать проскальзывания и комиссий.

Основные принципы Queue Tactic:

- Выставить лимитный ордер раньше других по желаемой цене,

- Обновлять лимитку, если впереди появляются новые крупные ордера,

- Избегать постоянной перезаявки, чтобы не терять свою очередь.

import ccxt
import time

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
side = "buy"  # или "sell"
limit_price = 27000  # желаемая цена
order_size = 0.01  # в BTC
depth_limit = 5

# Функция получения лучшего уровня
def get_best_price_volume(side):
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    if side == "buy":
        price, volume = depth['bids'][0]
    else:
        price, volume = depth['asks'][0]
    return price, volume

# Текущий статус
best_price, best_volume = get_best_price_volume(side)
print(f"Лучший {side.upper()} уровень: {best_price} | Объём: {best_volume}")

# Псевдологика отправки ордера
# order_id = exchange.create_limit_buy_order(symbol, order_size, limit_price)

# Циклический контроль
while True:
    time.sleep(2)
    current_price, current_volume = get_best_price_volume(side)

    if side == "buy" and current_price < limit_price:
        print("⚡ Появился более выгодный bid! Обновляем ордер...")
        # exchange.cancel_order(order_id, symbol)
        # order_id = exchange.create_limit_buy_order(symbol, order_size, current_price)
        limit_price = current_price

    elif side == "sell" and current_price > limit_price:
        print("⚡ Появился более высокий ask! Обновляем ордер...")
        # exchange.cancel_order(order_id, symbol)
        # order_id = exchange.create_limit_sell_order(symbol, order_size, current_price)
        limit_price = current_price

    else:
        print(f"Позиция в очереди удерживается на {current_price}.")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Cycle Phase Strategy (Hilbert Transform) – Вход по фазе рыночного цикла🧑‍💻

Суть стратегии:🛠️

Cycle Phase Strategy использует Гильберт-преобразование (Hilbert Transform) для определения фазы рыночного цикла:

Понимание, находится ли рынок в начале роста, на вершине, в падении или в основании.

Это позволяет точнее ловить развороты или поддерживать тренды.

Как работает Hilbert Transform в трейдинге:

- Преобразует временной ряд цен в аналитический сигнал (комплексная форма),

- Выделяет моментальную амплитуду и фазу движения,

Фаза цикла меняется от 0 до 360°:

0° → начало роста,

90° → вершина,

180° → начало падения,

270° → основание рынка.

Типовые сигналы Cycle Phase Strategy:💸

- Фаза около 0° или 360° → покупка (рост начинается)

- Фаза около 180° → продажа (падение начинается)

- Можно использовать фазовые переходы через ±45° для более точного входа/выхода.

import ccxt
import pandas as pd
import numpy as np
import scipy.signal

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт Hilbert Transform для цен закрытия
analytic_signal = scipy.signal.hilbert(df["close"])
instantaneous_phase = np.angle(analytic_signal, deg=True)  # В градусах
df["phase"] = (instantaneous_phase + 360) % 360  # Приведение к 0–360°

# Генерация сигналов
df["signal"] = 0
df.loc[(df["phase"] < 45) | (df["phase"] > 315), "signal"] = 1    # Buy
df.loc[(df["phase"] > 135) & (df["phase"] < 225), "signal"] = -1  # Sell

# Вывод последних данных
print(df[["ts", "close", "phase", "signal"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Sweep Detection Strategy – Вход после выявления "свипа" крупных лимиток🧑‍💻

Суть стратегии:🛠️

Sweep (свип) — это событие, когда огромный объём рыночных ордеров быстро сметает крупные лимитные заявки в стакане на определённой цене.

Такой всплеск ликвидации уровней часто сигнализирует о:

- Начале импульсного движения,

- Проломе поддержки или сопротивления,

- Важной инициативе покупателей или продавцов.

Что такое свип в стакане:🛠️

- Был крупный лимитный объём на ценовом уровне.

- Появился мощный рыночный ордер (market buy или market sell).

- Лимитки быстро исчезли → цена пошла в их сторону (или против них).

Сигналы стратегии:💸

- Buy: после свипа крупных sell-лимиток (ask sweep).

- Sell: после свипа крупных buy-лимиток (bid sweep).

- Подтверждение: объём, дельта, ускорение в ленте сделок.

import ccxt
import time

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 10
sweep_volume_threshold = 50  # например, 50 BTC
poll_interval = 2  # сек

def fetch_order_book():
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    return depth['bids'], depth['asks']

prev_bids, prev_asks = fetch_order_book()

while True:
    time.sleep(poll_interval)
    bids, asks = fetch_order_book()

    # Проверка на исчезновение крупных заявок
    for (prev_price, prev_volume), (new_price, new_volume) in zip(prev_bids, bids):
        if prev_volume > sweep_volume_threshold and new_volume < prev_volume * 0.5:
            print(f"⚡ Свип BID на {prev_price}: {prev_volume:.2f} -> {new_volume:.2f} BTC")

    for (prev_price, prev_volume), (new_price, new_volume) in zip(prev_asks, asks):
        if prev_volume > sweep_volume_threshold and new_volume < prev_volume * 0.5:
            print(f"⚡ Свип ASK на {prev_price}: {prev_volume:.2f} -> {new_volume:.2f} BTC")

    prev_bids, prev_asks = bids, asks

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Hidden Liquidity Revealer – Стратегия по выявлению скрытых заявок🧑‍💻

Суть идеи:🛠️

Hidden liquidity — это лимитные ордера, которые не видны в стакане или выглядят маленькими, но на самом деле:

- При попытке рыночной сделки через них объём оказывается гораздо больше, чем казалось,

- Или они постоянно восстанавливаются ("айсберги").

Стратегия "подсветки" — это способ обнаружить такие скрытые уровни, чтобы:💸

- Не попасть в ловушку при пробоях,

- Понимать настоящую поддержку/сопротивление,

- Использовать эти зоны для точного входа или выхода.

Как можно выявить скрытую ликвидность:🚀

1. Необычная устойчивость цены на уровне без видимой поддержки в стакане.

2. Повторное появление заявок после частичного съедения.

3. Замедление рыночного исполнения при небольших видимых ордерах.

4. Анализ ленты сделок — большое количество исполнений по одному уровню без перемещения цены.

import ccxt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 5
check_interval = 2  # секунды

def get_top_levels():
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    best_bid = depth["bids"][0]  # [цена, объём]
    best_ask = depth["asks"][0]
    return best_bid, best_ask

# Инициализация
previous_bid, previous_ask = get_top_levels()

while True:
    time.sleep(check_interval)
    current_bid, current_ask = get_top_levels()

    # Проверка на "регенерацию" объёма
    if abs(current_bid[0] - previous_bid[0]) < 1e-3 and current_bid[1] > previous_bid[1]:
        print(f"🟢 Обнаружено пополнение BID на {current_bid[0]}: {current_bid[1]:.2f} BTC")

    if abs(current_ask[0] - previous_ask[0]) < 1e-3 and current_ask[1] > previous_ask[1]:
        print(f"🔴 Обнаружено пополнение ASK на {current_ask[0]}: {current_ask[1]:.2f} BTC")

    previous_bid, previous_ask = current_bid, current_ask

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Triangular Arbitrage Bot — Арбитраж между тройкой валют на одной бирже🧑‍💻

Что такое треугольный арбитраж?🛠️

Это стратегия, при которой ты:

1. Обмениваешь валюту A на валюту B,

2. Обмениваешь валюту B на валюту C,

3. Обмениваешь валюту C обратно на валюту A.

Цель:💸

После завершения круга получить больше валюты A, чем было изначально, без риска изменения рынка.

Что нужно учитывать:🧨

- Комиссии биржи (обычно 0.075–0.1% за каждую операцию),

- Ликвидность на уровнях цен (объём в стакане),

- Время исполнения — сделки должны быть очень быстрыми,

- Минимальные лоты и требования к ордерам.

import ccxt

exchange = ccxt.binance()

symbols = ["BTC/USDT", "ETH/BTC", "ETH/USDT"]
tickers = exchange.fetch_tickers(symbols)

btc_usdt_ask = tickers["BTC/USDT"]["ask"]  # купить BTC
eth_btc_ask = tickers["ETH/BTC"]["ask"]    # купить ETH за BTC
eth_usdt_bid = tickers["ETH/USDT"]["bid"]   # продать ETH за USDT

initial_usdt = 1000

btc_amount = initial_usdt / btc_usdt_ask
eth_amount = btc_amount / eth_btc_ask
final_usdt = eth_amount * eth_usdt_bid

profit = final_usdt - initial_usdt
profit_pct = profit / initial_usdt * 100

print(f"Старт: {initial_usdt} USDT → Конец: {final_usdt:.2f} USDT")
print(f"Профит: {profit:.2f} USDT ({profit_pct:.2f}%)")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Google Trends Impact Strategy – Стратегия на основе роста поисковых запросов🧑‍💻

Суть идеи:🛠️

Google Trends Impact Strategy основывается на том, что:

- Всплеск интереса в поиске по названию актива (например, Bitcoin, Ethereum)

- Часто предшествует росту волатильности, импульсам, или даже ценовому тренду.

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

from pytrends.request import TrendReq
import pandas as pd

pytrends = TrendReq()

# Ключевое слово
kw = "Bitcoin"

# Получаем данные за последние 30 дней
pytrends.build_payload([kw], cat=0, timeframe='now 30-d', geo='', gprop='')
data = pytrends.interest_over_time()

# Проверяем последний прирост
data['change'] = data[kw].pct_change() * 100
latest = data.iloc[-1]

print(f"Актуальный интерес к '{kw}': {latest[kw]}")
print(f"Суточное изменение: {latest['change']:.2f}%")

# Сигнал
if latest['change'] > 30:
    print("⚡ Всплеск интереса! Возможен рост активности на рынке.")
else:
    print("Нет значимого роста поисковой активности.")

#инструмент

📌 Подпишись  Crypto Python❗️

📌ADX Reversion on Low Trend Regime – Стратегия возврата к среднему при слабом тренде🧑‍💻

Суть стратегии:🛠️

Индикатор ADX (Average Directional Index) измеряет силу тренда, не его направление.

Если ADX низкий (обычно < 20–25), рынок во флете или в фазе консолидации.

В такие периоды хорошо работает стратегия возврата к среднему (mean reversion).

Стратегия входит в контртрендовые сделки при сильном отклонении цены от средней, но только когда ADX указывает на слабый тренд.

Основные компоненты:💸

1. Фильтр по ADX:

- ADX < 20 → рынок во флете

Разрешаем вход только при низкой трендовости❗

2. Отклонение цены от средней (например, EMA):

Цена выше EMA + X% → Sell

Цена ниже EMA − X% → Buy

import ccxt
import pandas as pd
import talib as ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"
limit = 300

ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# EMA и ADX
df["ema"] = ta.trend.ema_indicator(df["close"], window=50).ema_indicator()
adx = ta.trend.adx(df["high"], df["low"], df["close"], window=14)
df["adx"] = adx

# Сигналы: если цена далеко от EMA при слабом тренде
threshold = 0.01  # 1%
df["signal"] = 0

# Buy при отклонении вниз и слабом тренде
df.loc[
    (df["adx"] < 20) & 
    (df["close"] < df["ema"] * (1 - threshold)), 
    "signal"
] = 1

# Sell при отклонении вверх и слабом тренде
df.loc[
    (df["adx"] < 20) & 
    (df["close"] > df["ema"] * (1 + threshold)), 
    "signal"
] = -1

# Последние сигналы
print(df[["ts", "close", "ema", "adx", "signal"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Liquidity Vacuum Entry – Вход в сделку при возникновении “вакуумов” ликвидности🧑‍💻

Суть стратегии:🛠️

Liquidity Vacuum — это участок рынка, где почти отсутствуют лимитные ордера в стакане на определённом ценовом диапазоне.
Если цена входит в такую зону, она часто проскальзывает быстро, пока не встретит новую ликвидность.

Стратегия Liquidity Vacuum Entry:💸

- Находит “пустые зоны” в стакане,

- Входит в сделку в сторону вакуума, ожидая импульс,

- Использует высокую скорость исполнения и фиксацию при наполнении ликвидности.

import ccxt

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth = exchange.fetch_order_book(symbol, limit=50)

# Задаём порог пустоты
vacuum_threshold = 1.0  # минимальный объём в BTC
gap_threshold = 2.0     # минимальное ценовое расстояние между уровнями

# Анализ BID-стороны
last_price = depth['bids'][0][0]
vacuum_zones = []

for i in range(len(depth['bids']) - 1):
    price1, vol1 = depth['bids'][i]
    price2, vol2 = depth['bids'][i + 1]

    if vol1 < vacuum_threshold and vol2 < vacuum_threshold:
        price_gap = abs(price1 - price2)
        if price_gap > gap_threshold:
            vacuum_zones.append((price2, price1))

print("Обнаружены BID-вакуумы:")
for low, high in vacuum_zones:
    print(f"Между {low:.2f} – {high:.2f}")

# Аналогично можно анализировать и ASK-сторону

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Dynamic Trend Channel Strategy – Скользящий канал на основе отклонений от EMA🧑‍💻

Суть стратегии:🛠️

Dynamic Trend Channel — это адаптивный канал, строящийся вокруг скользящей средней (обычно EMA), с границами, определёнными на основе:

- волатильности (например, ATR),

- или процентного отклонения от EMA.

Цель — определить динамический коридор, в пределах которого цена колеблется, и торговать:

- от границ к центру (mean reversion) во флэте,

- по направлению пробоя — в тренде.

Пример стратегии:💸

Вход в лонг, если цена касается нижней границы, и тренд восходящий

Вход в шорт, если цена касается верхней границы, и тренд нисходящий

Выход — в центре канала (EMA) или фиксированный тейк/стоп

import ccxt
import pandas as pd
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры канала
ema_period = 50
atr_period = 14
atr_mult = 1.5

# EMA и ATR
df["ema"] = ta.trend.ema_indicator(df["close"], window=ema_period).ema_indicator()
df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"], window=atr_period).average_true_range()

# Границы канала
df["upper"] = df["ema"] + atr_mult * df["atr"]
df["lower"] = df["ema"] - atr_mult * df["atr"]

# Сигналы
df["signal"] = 0
df.loc[df["close"] < df["lower"], "signal"] = 1   # Покупка
df.loc[df["close"] > df["upper"], "signal"] = -1  # Продажа

print(df[["ts", "close", "lower", "ema", "upper", "signal"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Fisher Transform Trend Filter – фильтрация фейковых движений с помощью индикатора Фишера🧑‍💻

Суть стратегии:🛠️

Fisher Transform — это осциллятор, который преобразует ценовое движение в нормальное распределение, делая развороты и тренды более чёткими и симметричными.

Применяется как тренд-фильтр или точка разворота, особенно для:💸

- Фильтрации ложных импульсов,

- Подтверждения сигнала входа,

- Точечного выхода из позиции.

Преимущества Fisher Transform:💸

- Улавливает экстремумы с меньшим запаздыванием, чем RSI

- Хорошо работает в связке с другими трендовыми индикаторами (EMA, ADX)

- Идеален для фильтрации входов только по сильным разворотам

import ccxt
import pandas as pd
import numpy as np

# Данные
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=500)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Настройки Fisher
period = 10
hl2 = (df["high"] + df["low"]) / 2
min_low = hl2.rolling(window=period).min()
max_high = hl2.rolling(window=period).max()

# Нормализация
value = 2 * ((hl2 - min_low) / (max_high - min_low + 1e-9) - 0.5)
value = value.clip(-0.999, 0.999)

# Расчёт Fisher Transform
fisher = 0.5 * np.log((1 + value) / (1 - value))
df["fisher"] = fisher.rolling(2).mean()

# Сигналы
df["signal"] = 0
df.loc[(df["fisher"] > 0) & (df["fisher"].shift(1) < 0), "signal"] = 1   # Лонг
df.loc[(df["fisher"] < 0) & (df["fisher"].shift(1) > 0), "signal"] = -1  # Шорт

# Вывод последних сигналов
print(df[["ts", "close", "fisher", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Volatility Stop Reversal – Переворот позиции при пробое волатильностного стоп-уровня🧑‍💻

Суть стратегии:🛠️

Volatility Stop Reversal (VSR) — это торговая тактика, при которой:

Позиция переворачивается, если цена пробивает волатильностный стоп-уровень,

Уровень рассчитывается на основе ATR (Average True Range) или других индикаторов,

Такой подход позволяет следовать за трендом, автоматически меняя сторону позиции при смене направления.

Механика стратегии:💸

1. Вход по тренду (например, вверх).

2. Уровень стопа:

для лонга: stop = high - k × ATR,

для шорта: stop = low + k × ATR.

3. Если цена пересекает этот уровень → позиция закрывается и открывается в противоположную сторону.

4. Новый стоп пересчитывается — и цикл повторяется.

import ccxt
import pandas as pd
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры
atr_period = 14
atr_multiplier = 2.0

# Расчёт ATR
df["atr"] = ta.volatility.AverageTrueRange(df["high"], df["low"], df["close"], window=atr_period).average_true_range()

# Инициализация
df["position"] = 0
df["stop"] = None

# Логика VSR
for i in range(1, len(df)):
    atr = df["atr"].iloc[i]
    close = df["close"].iloc[i]
    prev_pos = df["position"].iloc[i - 1]

    if prev_pos == 0:
        # Первая инициализация — допустим, открываем лонг
        df.loc[i, "position"] = 1
        df.loc[i, "stop"] = df["high"].iloc[i] - atr_multiplier * atr
    elif prev_pos == 1:
        stop = df["stop"].iloc[i - 1]
        if close < stop:
            df.loc[i, "position"] = -1  # Переворот в шорт
            df.loc[i, "stop"] = df["low"].iloc[i] + atr_multiplier * atr
        else:
            df.loc[i, "position"] = 1
            df.loc[i, "stop"] = max(stop, df["high"].iloc[i] - atr_multiplier * atr)
    elif prev_pos == -1:
        stop = df["stop"].iloc[i - 1]
        if close > stop:
            df.loc[i, "position"] = 1  # Переворот в лонг
            df.loc[i, "stop"] = df["high"].iloc[i] - atr_multiplier * atr
        else:
            df.loc[i, "position"] = -1
            df.loc[i, "stop"] = min(stop, df["low"].iloc[i] + atr_multiplier * atr)

# Вывод последних сигналов
print(df[["ts", "close", "position", "stop"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌VWAP Imbalance Entry – Вход при смещении торгов к одной стороне от VWAP🧑‍💻

Суть стратегии:🛠️

VWAP (Volume Weighted Average Price) — это средневзвешенная цена сделки по объёму.
Она часто выступает как балансная точка между покупателями и продавцами.
Когда цена и объёмы сильно сдвинуты на одну сторону от VWAP, это может сигнализировать о:

- доминировании одной стороны (покупатели или продавцы),

- готовности к импульсу или продолжению движения,

- потенциальном входе в позицию по направлению дисбаланса.

Принцип стратегии:💸

1. Вычисляем VWAP за сессию или торговый период

2. Анализируем, где проходит основной объём сделок — выше или ниже VWAP

3. Если 70%+ объёма идёт выше VWAP → лонговое смещение

4. Если 70%+ ниже VWAP → шортовое смещение

5. Вход по направлению дисбаланса (в сторону, где сосредоточен объём)

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
limit = 200
tf = "1m"

# Получаем свечи
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт VWAP вручную
df["tp"] = (df["high"] + df["low"] + df["close"]) / 3
df["vwap_num"] = df["tp"] * df["volume"]
df["cum_vol"] = df["volume"].cumsum()
df["cum_vwap"] = df["vwap_num"].cumsum()
df["vwap"] = df["cum_vwap"] / df["cum_vol"]

# Определим, где прошёл объём — выше или ниже VWAP
df["side"] = df["close"] > df["vwap"]
above_vol = df[df["side"] == True]["volume"].sum()
below_vol = df[df["side"] == False]["volume"].sum()
total_vol = df["volume"].sum()

above_pct = above_vol / total_vol * 100
below_pct = below_vol / total_vol * 100

print(f"Объём выше VWAP: {above_pct:.1f}% | ниже VWAP: {below_pct:.1f}%")

# Генерация сигнала
if above_pct > 70:
    print("⚡ Объём сконцентрирован выше VWAP → сигнал на ЛОНГ")
elif below_pct > 70:
    print("⚡ Объём сконцентрирован ниже VWAP → сигнал на ШОРТ")
else:
    print("Нет чёткого дисбаланса по VWAP")

#индикатор

📌 Подпишись  Crypto Python❗️

📌Trend Strength Delta Strategy – Вход при резком изменении силы тренда🧑‍💻

Суть стратегии:🛠️

Trend Strength Delta — это стратегия, основанная на отслеживании изменения силы тренда во времени.
Сигналы генерируются, когда дельта силы тренда (например, по ADX, CCI, MACD или собственному индикатору)
резко возрастает или снижается, указывая на:

- Начало нового импульса,

- Усиление/ослабление тренда,

- Переход из флетовой фазы в направленную.

Как использовать в стратегии:💸

- Фильтр по направлению тренда — использовать +DI и -DI (из ADX)

- Торговать импульсы при резком росте силы

- Переворачиваться при резком падении дельты

- Можно сочетать с EMA или MACD для подтверждения направления

import ccxt
import pandas as pd
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт ADX
adx_indicator = ta.trend.ADXIndicator(high=df["high"], low=df["low"], close=df["close"], window=14)
df["adx"] = adx_indicator.adx()

# Дельта ADX
df["adx_delta"] = df["adx"].diff(periods=3)

# Порог дельты
threshold = 10

# Генерация сигнала
df["signal"] = 0
df.loc[df["adx_delta"] > threshold, "signal"] = 1   # Вход в лонг
df.loc[df["adx_delta"] < -threshold, "signal"] = -1  # Вход в шорт

# Вывод
print(df[["ts", "close", "adx", "adx_delta", "signal"]].tail(10))

#торговые_стратегии

📌 Подпишись  Crypto Python❗️