📌 RSI Scanner, который находит криптовалютные пары с перепроданным (RSI < 30) и перекупленным (RSI > 70) состоянием.

RSI (Индекс относительной силы) — это технический индикатор, измеряющий скорость и силу изменения цены актива. Он показывает, находится ли актив в зоне перекупленности или перепроданности, и помогает трейдерам находить потенциальные развороты.👨‍💻

import ccxt
import talib
import pandas as pd

# Параметры сканера
EXCHANGE_NAME = "binance"  # Название биржи
TIMEFRAME = "1h"  # Таймфрейм (1 час)
RSI_PERIOD = 14  # Период RSI
TOP_N_PAIRS = 20  # Количество пар для анализа

# Инициализация CCXT
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получаем список популярных пар (например, USDT)
def get_top_pairs():
    tickers = exchange.fetch_tickers()
    usdt_pairs = [symbol for symbol in tickers.keys() if "/USDT" in symbol]
    return usdt_pairs[:TOP_N_PAIRS]  # Ограничиваем количество пар

# Получаем исторические данные
def fetch_ohlcv(symbol):
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=RSI_PERIOD + 1)
        df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
        return df
    except Exception as e:
        print(f"Ошибка при загрузке данных для {symbol}: {e}")
        return None

# Рассчитываем RSI
def calculate_rsi(df):
    if df is None or len(df) < RSI_PERIOD:
        return None
    return talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]

# Основной сканер
def rsi_scanner():
    pairs = get_top_pairs()
    rsi_results = []

    for pair in pairs:
        df = fetch_ohlcv(pair)
        rsi_value = calculate_rsi(df)

        if rsi_value is not None:
            rsi_results.append((pair, rsi_value))

    # Отображаем результаты
    overbought = [p for p in rsi_results if p[1] > 70]
    oversold = [p for p in rsi_results if p[1] < 30]

    print("\n🔹 **Перекупленные активы (RSI > 70):**")
    for pair, rsi in overbought:
        print(f"{pair}: {rsi:.2f}")

    print("\n🔹 **Перепроданные активы (RSI < 30):**")
    for pair, rsi in oversold:
        print(f"{pair}: {rsi:.2f}")

# Запуск сканера
if __name__ == "__main__":
    rsi_scanner()

#индикатор

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

📌 Торговля по индексу страха и жадности (Fear & Greed Index)

Индекс страха и жадности (Fear & Greed Index, FGI) — это показатель, который отражает настроение участников рынка. Он варьируется от 0 (максимальный страх) до 100 (максимальная жадность) и помогает трейдерам определять, когда рынок находится в экстремальных состояниях.

Как интерпретировать индекс?

0-25 (экстремальный страх) → Трейдеры паникуют, массово продают, рынок может быть перепродан.
Возможность покупки (LONG).

25-50 (страх) → Настроения негативные, но не экстремальные.

50-75 (жадность) → Оптимизм, но рынок еще не перегрет.

75-100 (экстремальная жадность) → Все покупают, рынок может быть перекуплен.
Возможность фиксации прибыли или открытия SHORT.👨‍💻

import requests
import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
RSI_PERIOD = 14
FGI_URL = "https://api.alternative.me/fng/?limit=1"

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Функция получения индекса страха и жадности
def get_fear_greed_index():
    response = requests.get(FGI_URL).json()
    fgi_value = int(response["data"][0]["value"])
    return fgi_value

# Получаем исторические свечи
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=RSI_PERIOD + 1)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчитываем RSI
def calculate_rsi(df):
    return talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]

# Основная логика
def trade_strategy():
    fgi = get_fear_greed_index()
    df = fetch_ohlcv(PAIR)
    rsi = calculate_rsi(df)

    print(f"Fear & Greed Index: {fgi}, RSI: {rsi:.2f}")

    # Лонг при страхе и подтверждении RSI
    if fgi < 25 and rsi < 30:
        print(f"📈 BUY SIGNAL (Fear {fgi}, RSI {rsi:.2f})")

    # Шорт при жадности и подтверждении RSI
    elif fgi > 75 and rsi > 70:
        print(f"📉 SELL SIGNAL (Greed {fgi}, RSI {rsi:.2f})")

# Запуск
if __name__ == "__main__":
    trade_strategy()

#индикатор

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

📌  Mean Reversion Bot – Бот на возврат к среднему

Смысл стратегии:

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

Если цена далеко от среднего:

Выше – возможен шорт.

Ниже – возможен лонг.

Используем скользящую среднюю (SMA) и полосы Боллинджера (BB) для определения отклонений.👨‍💻

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
SMA_PERIOD = 20  # Период скользящей средней
BB_STD_DEV = 2  # Отклонение Боллинджера

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получаем данные
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=SMA_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет SMA и Bollinger Bands
def calculate_indicators(df):
    sma = talib.SMA(df["close"], timeperiod=SMA_PERIOD).iloc[-1]
    upper, middle, lower = talib.BBANDS(df["close"], timeperiod=SMA_PERIOD, nbdevup=BB_STD_DEV, nbdevdn=BB_STD_DEV)
    return sma, upper.iloc[-1], lower.iloc[-1], df["close"].iloc[-1]

# Логика торговли
def mean_reversion_bot():
    df = fetch_ohlcv(PAIR)
    sma, upper, lower, close = calculate_indicators(df)

    print(f"Цена: {close:.2f}, SMA: {sma:.2f}, BB Upper: {upper:.2f}, BB Lower: {lower:.2f}")

    if close > upper:
        print("📉 Цена выше верхней границы → возможен шорт.")
    elif close < lower:
        print("📈 Цена ниже нижней границы → возможен лонг.")
    else:
        print("⚡ Цена в нормальном диапазоне.")

# Запуск
if __name__ == "__main__":
    mean_reversion_bot()

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

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

📌   Обнаружение пробоев Боллинджера (Bollinger Bands Breakout)

Индикатор полос Боллинджера (Bollinger Bands, BB) измеряет волатильность и определяет уровни перекупленности/перепроданности:

Пробой верхней границы → Возможный сигнал к продолжению роста или ложному пробою (short).

Пробой нижней границы → Возможный сигнал на разворот вверх (long).

Сжатие полос (squeeze) → Ожидание сильного движения. 👨‍💻

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
BB_PERIOD = 20  # Период Боллинджера
BB_STD_DEV = 2  # Отклонение

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получаем исторические данные
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=BB_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет Bollinger Bands
def calculate_bollinger_bands(df):
    upper, middle, lower = talib.BBANDS(df["close"], timeperiod=BB_PERIOD, nbdevup=BB_STD_DEV, nbdevdn=BB_STD_DEV, matype=0)
    return upper.iloc[-1], middle.iloc[-1], lower.iloc[-1], df["close"].iloc[-1]

# Анализ пробоя
def bollinger_breakout():
    df = fetch_ohlcv(PAIR)
    upper, middle, lower, close = calculate_bollinger_bands(df)

    print(f"Цена: {close:.2f}, BB Upper: {upper:.2f}, BB Lower: {lower:.2f}")

    if close > upper:
        print("📈 Пробой верхней границы! Возможное продолжение роста или ложный пробой.")
    elif close < lower:
        print("📉 Пробой нижней границы! Возможный отскок вверх.")

# Запуск
if __name__ == "__main__":
    bollinger_breakout()

#индикатор

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

📌 Moving Average Crossover – Сигнал при пересечении скользящих средних

Пересечение быстрой (короткой) и медленной (длинной) скользящей средней (SMA/EMA) генерирует торговый сигнал:

Golden Cross (быстрая пересекает медленную вверх) → сигнал на покупку (LONG).

Death Cross (быстрая пересекает медленную вниз) → сигнал на продажу (SHORT) 👨‍💻

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
SHORT_MA_PERIOD = 9   # Период короткой скользящей средней
LONG_MA_PERIOD = 21   # Период длинной скользящей средней
USE_EMA = True        # Использовать EMA (True) или SMA (False)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=LONG_MA_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Расчет скользящих средних
def calculate_moving_averages(df):
    if USE_EMA:
        short_ma = talib.EMA(df["close"], timeperiod=SHORT_MA_PERIOD)
        long_ma = talib.EMA(df["close"], timeperiod=LONG_MA_PERIOD)
    else:
        short_ma = talib.SMA(df["close"], timeperiod=SHORT_MA_PERIOD)
        long_ma = talib.SMA(df["close"], timeperiod=LONG_MA_PERIOD)
    
    return short_ma.iloc[-2], long_ma.iloc[-2], short_ma.iloc[-1], long_ma.iloc[-1]

# Логика торговли
def moving_average_crossover():
    df = fetch_ohlcv(PAIR)
    short_prev, long_prev, short_now, long_now = calculate_moving_averages(df)

    print(f"Текущая цена: {df['close'].iloc[-1]:.2f}")
    print(f"Короткая MA: {short_now:.2f}, Длинная MA: {long_now:.2f}")

    if short_prev < long_prev and short_now > long_now:
        print("📈 Golden Cross! Сигнал на покупку (LONG).")
    elif short_prev > long_prev and short_now < long_now:
        print("📉 Death Cross! Сигнал на продажу (SHORT).")
    else:
        print("⚡ Нет пересечения, ждем сигнала.")

# Запуск
if __name__ == "__main__":
    moving_average_crossover()

#индикатор

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

📌  Momentum Trading Bot – бот на основе моментума.

Смысл стратегии:

Momentum trading (торговля на моментуме) основана на том, что цена, движущаяся в одном направлении с высокой скоростью, имеет высокую вероятность продолжения тренда.

Используем:

ROC (Rate of Change) – скорость изменения цены.

RSI (Relative Strength Index) – подтверждение силы движения.

Скользящую среднюю (SMA) – определение тренда. 👨‍💻

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ROC_PERIOD = 10  # Период для Rate of Change
SMA_PERIOD = 50  # Период скользящей средней
RSI_PERIOD = 14  # Период RSI
MOMENTUM_THRESHOLD = 2  # Порог моментума

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получение исторических данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=max(ROC_PERIOD, SMA_PERIOD, RSI_PERIOD) + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикаторов
def calculate_indicators(df):
    roc = talib.ROC(df["close"], timeperiod=ROC_PERIOD).iloc[-1]
    sma = talib.SMA(df["close"], timeperiod=SMA_PERIOD).iloc[-1]
    rsi = talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]
    return roc, sma, rsi, df["close"].iloc[-1]

# Логика торговли
def momentum_trading_bot():
    df = fetch_ohlcv(PAIR)
    roc, sma, rsi, close = calculate_indicators(df)

    print(f"Цена: {close:.2f}, ROC: {roc:.2f}, SMA: {sma:.2f}, RSI: {rsi:.2f}")

    if close > sma and roc > MOMENTUM_THRESHOLD and rsi > 50:
        print("📈 Сильный восходящий моментум → возможный лонг.")
    elif close < sma and roc < -MOMENTUM_THRESHOLD and rsi < 50:
        print("📉 Сильный нисходящий моментум → возможный шорт.")
    else:
        print("⚡ Нет явного моментума.")

# Запуск
if __name__ == "__main__":
    momentum_trading_bot()

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

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

📌 MACD Signal Detector – Поиск дивергенций и сигналов MACD

Смысл стратегии:

MACD (Moving Average Convergence Divergence) – это индикатор, показывающий силу тренда и возможные точки разворота.

Используем:

MACD Line = EMA(12) - EMA(26) (разница между двумя экспоненциальными средними).

Signal Line = EMA(9) от MACD Line (сглаженная версия MACD).

Гистограмма MACD = MACD Line - Signal Line (определяет тренд).

Сигналы:

MACD Line пересекает Signal Line вверх → Сигнал на покупку (LONG).

MACD Line пересекает Signal Line вниз → Сигнал на продажу (SHORT).

Дивергенция MACD и цены → возможный разворот👨‍💻

import ccxt
import pandas as pd
import talib
import numpy as np

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
MACD_FAST = 12  # Быстрая EMA
MACD_SLOW = 26  # Медленная EMA
MACD_SIGNAL = 9  # EMA сигнальной линии

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=MACD_SLOW + MACD_SIGNAL + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет MACD и поиск дивергенции
def calculate_macd(df):
    macd, signal, hist = talib.MACD(df["close"], fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL)
    return macd.iloc[-2], signal.iloc[-2], hist.iloc[-2], macd.iloc[-1], signal.iloc[-1], hist.iloc[-1]

# Поиск дивергенции
def check_divergence(df, macd_hist):
    price_min = df["close"].iloc[-10:].min()
    price_max = df["close"].iloc[-10:].max()
    macd_min = macd_hist[-10:].min()
    macd_max = macd_hist[-10:].max()

    if price_min < df["close"].iloc[-1] and macd_min > macd_hist[-1]:
        return "📈 Бычья дивергенция! Возможен рост."
    elif price_max > df["close"].iloc[-1] and macd_max < macd_hist[-1]:
        return "📉 Медвежья дивергенция! Возможно падение."
    return "⚡ Дивергенции не найдено."

# Логика торговли
def macd_signal_detector():
    df = fetch_ohlcv(PAIR)
    macd_prev, signal_prev, hist_prev, macd_now, signal_now, hist_now = calculate_macd(df)

    print(f"Текущая цена: {df['close'].iloc[-1]:.2f}")
    print(f"MACD: {macd_now:.2f}, Signal: {signal_now:.2f}, Histogram: {hist_now:.2f}")

    if macd_prev < signal_prev and macd_now > signal_now:
        print("📈 MACD пересек сигнальную линию вверх! Возможный лонг.")
    elif macd_prev > signal_prev and macd_now < signal_now:
        print("📉 MACD пересек сигнальную линию вниз! Возможный шорт.")
    
    print(check_divergence(df, df["close"]))

# Запуск
if __name__ == "__main__":
    macd_signal_detector()

#индикатор

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

📌   Breakout Trading Bot – Бот для торговли на пробоях уровней

Смысл стратегии:

Пробой уровней сопротивления или поддержки сигнализирует о возможном сильном движении.

Пробой вверх (breakout) → цена выходит выше сопротивления → лонг (покупка).

Пробой вниз (breakdown) → цена пробивает поддержку → шорт (продажа).

Используем максимумы и минимумы за N периодов для определения ключевых уровней👨‍💻

import ccxt
import pandas as pd

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK_PERIOD = 20  # Количество свечей для поиска уровней

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=LOOKBACK_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Определение уровней сопротивления и поддержки
def calculate_levels(df):
    resistance = df["high"].iloc[-LOOKBACK_PERIOD:].max()  # Максимум за период
    support = df["low"].iloc[-LOOKBACK_PERIOD:].min()  # Минимум за период
    return resistance, support

# Логика пробоя
def breakout_trading_bot():
    df = fetch_ohlcv(PAIR)
    resistance, support = calculate_levels(df)
    close_price = df["close"].iloc[-1]

    print(f"Цена: {close_price:.2f}, Сопротивление: {resistance:.2f}, Поддержка: {support:.2f}")

    if close_price > resistance:
        print("📈 Пробой вверх! Возможный лонг.")
    elif close_price < support:
        print("📉 Пробой вниз! Возможный шорт.")
    else:
        print("⚡ Цена в диапазоне, ждем пробоя.")

# Запуск
if __name__ == "__main__":
    breakout_trading_bot()

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

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

📌 Фильтрация сильных трендов с помощью ADX

Смысл стратегии:

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

Directional Movement Index (DMI) – это индикатор, который оценивает направление и силу тренда, используя две линии:

+DI (Positive Directional Indicator) – показывает силу восходящего движения.

-DI (Negative Directional Indicator) – показывает силу нисходящего движения.

ADX > 25 → тренд сильный, можно входить в позицию.

ADX < 25 → тренда нет, лучше не торговать.

+DI выше -DI → бычий тренд (лонг).

-DI выше +DI → медвежий тренд (шорт).

Используем ADX + DI (Directional Movement Index) для фильтрации трендов 👨‍💻

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ADX_PERIOD = 14  # Период ADX
TREND_THRESHOLD = 25  # Порог тренда

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=ADX_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет ADX и DMI
def calculate_adx(df):
    adx = talib.ADX(df["high"], df["low"], df["close"], timeperiod=ADX_PERIOD).iloc[-1]
    plus_di = talib.PLUS_DI(df["high"], df["low"], df["close"], timeperiod=ADX_PERIOD).iloc[-1]
    minus_di = talib.MINUS_DI(df["high"], df["low"], df["close"], timeperiod=ADX_PERIOD).iloc[-1]
    return adx, plus_di, minus_di

# Логика торговли
def adx_trend_filter():
    df = fetch_ohlcv(PAIR)
    adx, plus_di, minus_di = calculate_adx(df)

    print(f"Цена: {df['close'].iloc[-1]:.2f}, ADX: {adx:.2f}, +DI: {plus_di:.2f}, -DI: {minus_di:.2f}")

    if adx > TREND_THRESHOLD:
        if plus_di > minus_di:
            print("📈 Сильный восходящий тренд! Возможный лонг.")
        elif minus_di > plus_di:
            print("📉 Сильный нисходящий тренд! Возможный шорт.")
    else:
        print("⚡ Тренда нет, лучше не торговать.")

# Запуск
if __name__ == "__main__":
    adx_trend_filter()

#индикатор

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

📌Scalping Bot – Бот для скальпинга с высокой частотой сделок

Смысл стратегии:

Скальпинг – это краткосрочная торговля с высокой частотой сделок, использующая маленькие движения цены.

Работает на низких таймфреймах (1m, 5m).

Использует быстрые индикаторы (EMA, VWAP, RSI, объём).

Быстро входит и выходит из рынка, зарабатывая на небольших колебаниях.  👨‍💻

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1m"  # Скальпинг на минутных свечах
EMA_SHORT = 9
EMA_LONG = 21
RSI_PERIOD = 14
RSI_OVERBOUGHT = 70
RSI_OVERSOLD = 30

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=EMA_LONG + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикаторов
def calculate_indicators(df):
    ema_short = talib.EMA(df["close"], timeperiod=EMA_SHORT).iloc[-1]
    ema_long = talib.EMA(df["close"], timeperiod=EMA_LONG).iloc[-1]
    rsi = talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]
    return ema_short, ema_long, rsi

# Логика сигналов
def scalp_signal():
    df = fetch_ohlcv(PAIR)
    ema_short, ema_long, rsi = calculate_indicators(df)
    price = df["close"].iloc[-1]

    print(f"Цена: {price:.2f}, EMA Short: {ema_short:.2f}, EMA Long: {ema_long:.2f}, RSI: {rsi:.2f}")

    if ema_short > ema_long and rsi < RSI_OVERBOUGHT:
        print("📈 Сигнал на покупку (лонг).")
    elif ema_short < ema_long and rsi > RSI_OVERSOLD:
        print("📉 Сигнал на продажу (шорт).")
    else:
        print("⚡ Нет сигнала, ждем.")

# Запуск
if __name__ == "__main__":
    while True:
        scalp_signal()
        time.sleep(10)  # Ждем 10 секунд перед следующей проверкой

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

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

📌 Stochastic Reversal Detector – Анализ точек разворота по стохастическому осциллятору

Смысл стратегии:

Стохастический осциллятор (Stochastic) измеряет перекупленность / перепроданность актива и помогает находить развороты.

%K – основная линия (быстрая).

%D – сглаженная линия (медленная, обычно SMA от %K).

Сигналы разворота:

%K > 80 и пересекает %D вниз → перекупленность → сигнал на шорт.

%K < 20 и пересекает %D вверх → перепроданность → сигнал на лонг🧑‍💻


⚠️ Важно: Стохастик может давать ложные сигналы на сильных трендах.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
STOCH_PERIOD = 14  # Период стохастика
STOCH_SMOOTH_K = 3  # Сглаживание %K
STOCH_SMOOTH_D = 3  # Сглаживание %D
OVERBOUGHT = 80
OVERSOLD = 20

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=STOCH_PERIOD + STOCH_SMOOTH_K + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет стохастического осциллятора
def calculate_stochastic(df):
    k, d = talib.STOCH(df["high"], df["low"], df["close"], 
                        fastk_period=STOCH_PERIOD, 
                        slowk_period=STOCH_SMOOTH_K, slowk_matype=0,
                        slowd_period=STOCH_SMOOTH_D, slowd_matype=0)
    return k.iloc[-2], d.iloc[-2], k.iloc[-1], d.iloc[-1]

# Логика сигналов
def stochastic_reversal_detector():
    df = fetch_ohlcv(PAIR)
    k_prev, d_prev, k_now, d_now = calculate_stochastic(df)
    price = df["close"].iloc[-1]

    print(f"Цена: {price:.2f}, Stoch %K: {k_now:.2f}, Stoch %D: {d_now:.2f}")

    if k_prev > OVERBOUGHT and k_prev > d_prev and k_now < d_now:
        print("📉 Стохастик в зоне перекупленности, пересечение вниз → сигнал на шорт.")
    elif k_prev < OVERSOLD and k_prev < d_prev and k_now > d_now:
        print("📈 Стохастик в зоне перепроданности, пересечение вверх → сигнал на лонг.")
    else:
        print("⚡ Нет разворотного сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        stochastic_reversal_detector()
        time.sleep(60)  # Обновление раз в минуту

#индикатор

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