杂货铺

hyperliquid 基于python 的操作代码

Mon, 01 Jun 2026 15:51:31 +0800

代码来源

https://github.com/RobotTraders/bits_and_bobs/blob/main/hyperliquid-trading-live-bot.py

视频教程

https://www.youtube.com/watch?v=pdKi6V8VJb4

代码

import os
import ccxt
import pandas as pd
import ta
from dotenv import load_dotenv

load_dotenv()


# ==========================================
# PART 1: HYPERLIQUID CLIENT
# ==========================================

class HyperliquidClient:
    """Simple synchronous client for Hyperliquid exchange using CCXT."""
    
    def __init__(self, wallet_address: str, private_key: str):
        """Initialize the Hyperliquid client.
        
        Args:
            wallet_address: Your Hyperliquid wallet address
            private_key: Your wallet's private key
        """
        if not wallet_address:
            raise ValueError("wallet_address is required")
        
        if not private_key:
            raise ValueError("private_key is required")
            
        try:
            self.exchange = ccxt.hyperliquid({
                "walletAddress": wallet_address,
                "privateKey": private_key,
                "enableRateLimit": True,
            })
            self.markets = {}
            self._load_markets()
        except Exception as e:
            raise Exception(f"Failed to initialize exchange: {str(e)}")

    def _load_markets(self) -> None:
        """Load market data from the exchange."""
        try:
            self.markets = self.exchange.load_markets()
        except Exception as e:
            raise Exception(f"Failed to load markets: {str(e)}")

    def _amount_to_precision(self, symbol: str, amount: float) -> float:
        """Convert amount to exchange precision requirements.
        
        Args:
            symbol: Trading pair symbol
            amount: Order amount to format
            
        Returns:
            Amount formatted with correct precision as float
        """
        try:
            result = self.exchange.amount_to_precision(symbol, amount)
            return float(result)
        except Exception as e:
            raise Exception(f"Failed to format amount precision: {str(e)}")

    def _price_to_precision(self, symbol: str, price: float) -> float:
        """Convert price to exchange precision requirements.
        
        Args:
            symbol: Trading pair symbol
            price: Order price to format
            
        Returns:
            Price formatted with correct precision as float
        """
        try:
            result = self.exchange.price_to_precision(symbol, price)
            return float(result)
        except Exception as e:
            raise Exception(f"Failed to format price precision: {str(e)}")

    def get_current_price(self, symbol: str) -> float:
        """Get the current market price for a symbol.
        
        Args:
            symbol: Trading pair (e.g., "ETH/USDC:USDC")
            
        Returns:
            Current market price
        """
        try:
            return float(self.markets[symbol]["info"]["midPx"])
        except Exception as e:
            raise Exception(f"Failed to get price for {symbol}: {str(e)}")

    def fetch_balance(self) -> dict:
        """Fetch account balance information.
        
        Returns:
            Account balance data
        """
        try:
            result = self.exchange.fetch_balance()
            return result
        except Exception as e:
            raise Exception(f"Failed to fetch balance: {str(e)}")

    def fetch_positions(self, symbols: list[str]) -> list:
        """Fetch open positions for specified symbols.
        
        Args:
            symbols: List of trading pairs
            
        Returns:
            List of position dictionaries with active positions
        """
        try:
            positions = self.exchange.fetch_positions(symbols)
            return [pos for pos in positions if float(pos["contracts"]) != 0]
        except Exception as e:
            raise Exception(f"Failed to fetch positions: {str(e)}")

    def fetch_ohlcv(self, symbol: str, timeframe: str = "1d", limit: int = 100) -> pd.DataFrame:
        """Fetch OHLCV candlestick data.
        
        Args:
            symbol: Trading pair symbol
            timeframe: Candle interval (1m, 5m, 15m, 30m, 1h, 4h, 12h, 1d)
            limit: Maximum number of candles to fetch
            
        Returns:
            DataFrame with OHLCV data
        """
        try:
            ohlcv_data = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
            
            df = pd.DataFrame(
                data=ohlcv_data,
                columns=["timestamp", "open", "high", "low", "close", "volume"]
            )
            df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
            df = df.set_index("timestamp").sort_index()
            
            numeric_cols = ["open", "high", "low", "close", "volume"]
            df[numeric_cols] = df[numeric_cols].astype(float)
            
            return df
        except Exception as e:
            raise Exception(f"Failed to fetch OHLCV data: {str(e)}")
    
    def set_leverage(self, symbol: str, leverage: int) -> bool:
        """Set leverage for a symbol.
        
        Args:
            symbol: Trading pair symbol
            leverage: Leverage multiplier
            
        Returns:
            True if successful
        """
        try:
            self.exchange.set_leverage(leverage, symbol)
            return True
        except Exception as e:
            raise Exception(f"Failed to set leverage: {str(e)}")

    def set_margin_mode(self, symbol: str, margin_mode: str, leverage: int) -> bool:
        """Set margin mode for a symbol.
        
        Args:
            symbol: Trading pair symbol
            margin_mode: "isolated" or "cross"
            leverage: Required leverage multiplier for Hyperliquid
            
        Returns:
            True if successful
        """
        try:
            self.exchange.set_margin_mode(margin_mode, symbol, params={"leverage": leverage})
            return True
        except Exception as e:
            raise Exception(f"Failed to set margin mode: {str(e)}")

    def place_market_order(
        self, 
        symbol: str, 
        side: str, 
        amount: float,
        reduce_only: bool = False,
        take_profit_price: float | None = None,
        stop_loss_price: float | None = None
    ) -> dict:
        """Place a market order with optional take profit and stop loss.
        
        Args:
            symbol: Trading pair symbol
            side: "buy" or "sell"
            amount: Order size in contracts
            reduce_only: If True, order will only reduce position size
            take_profit_price: Optional price level to take profit
            stop_loss_price: Optional price level to stop loss
            
        Returns:
            Order execution details
        """
        try:
            formatted_amount = self._amount_to_precision(symbol, amount)
            
            price = float(self.markets[symbol]["info"]["midPx"])
            formatted_price = self._price_to_precision(symbol, price)
            
            params = {"reduceOnly": reduce_only}
            
            if take_profit_price is not None:
                formatted_tp_price = self._price_to_precision(symbol, take_profit_price)
                params["takeProfitPrice"] = formatted_tp_price
                
            if stop_loss_price is not None:
                formatted_sl_price = self._price_to_precision(symbol, stop_loss_price)
                params["stopLossPrice"] = formatted_sl_price
            
            order_info = {}
            order_info_final = {}
            
            order_info["market_order"] = self.exchange.create_order(
                symbol=symbol,
                type="market",
                side=side,
                amount=formatted_amount,
                price=formatted_price,
                params=params
            )
            order_info_final["market_order"] = order_info["market_order"]["info"]
            
            if take_profit_price is not None:
                order_info["take_profit_order"] = self._place_take_profit_order(symbol, side, formatted_amount, formatted_price, take_profit_price)
                order_info_final["take_profit_order"] = order_info["take_profit_order"]["info"]
                
            if stop_loss_price is not None:
                order_info["stop_loss_order"] = self._place_stop_loss_order(symbol, side, formatted_amount, formatted_price, stop_loss_price)
                order_info_final["stop_loss_order"] = order_info["stop_loss_order"]["info"]
            
            return order_info_final
        except Exception as e:
            raise Exception(f"Failed to place market order: {str(e)}")

    def _place_take_profit_order(self, symbol: str, side: str, amount: float, price: float, take_profit_price: float) -> dict:
        """Internal method to place a take-profit order."""
        tp_price = self._price_to_precision(symbol, take_profit_price)
        close_side = "sell" if side == "buy" else "buy"
        return self.exchange.create_order(
                symbol=symbol,
                type="market",
                side=close_side,
                amount=amount,
                price=price,
                params={"takeProfitPrice": tp_price, "reduceOnly": True},
            )

    def _place_stop_loss_order(self, symbol: str, side: str, amount: float, price: float, stop_loss_price: float) -> dict:
        """Internal method to place a stop-loss order."""
        sl_price = self._price_to_precision(symbol, stop_loss_price)
        close_side = "sell" if side == "buy" else "buy"
        return self.exchange.create_order(
                symbol=symbol,
                type="market",
                side=close_side,
                amount=amount,
                price=price,
                params={"stopLossPrice": sl_price, "reduceOnly": True},
            )


def my_print(message: str, verbose: bool):
    if verbose:
        print(message)


# ==========================================
# PART 2: STRATEGY CONFIG
# ==========================================

# Trading parameters
params = {
    "symbol": "ETH/USDC:USDC",
    "timeframe": "4h",
    "position_size_pct": 5.0,
    "leverage": 1,
    "margin_mode": "isolated",  # "isolated" or "cross"
    "rsi_length": 14,
    "rsi_overbought": 70,
    "tp_pct": 10.0, 
    "sl_pct": 5.0,
}

# Trading conditions to ignore
ignore_longs = False
ignore_shorts = True
ignore_exit = False
ignore_tp = False
ignore_sl = False

# Verbosity
verbose = True 

# Define Technical Indicators
def compute_indicators(data): # check https://technical-analysis-library-in-python.readthedocs.io/en/latest/ta.html
    """Compute technical indicators"""
    data['RSI'] = ta.momentum.rsi(data['close'], window=params["rsi_length"])
    
    # data['ATR'] = ta.volatility.average_true_range(data['high'], data['low'], data['close'], window=params["..."])

    # data['EMAf'] = ta.trend.ema_indicator(data['close'], params["..."])
    # data['EMAs'] = ta.trend.ema_indicator(data['close'], params["..."])

    # MACD = ta.trend.MACD(data['close'], window_slow=params["..."], window_fast=params["..."], window_sign=params["..."])
    # data['MACD'] = MACD.macd()
    # data['MACD_histo'] = MACD.macd_diff()
    # data['MACD_signal'] = MACD.macd_signal()

    # BB = ta.volatility.BollingerBands(close=data['close'], window=params["..."], window_dev=params["..."])
    # data["BB_lower"] = BB.bollinger_lband()
    # data["BB_upper"] = BB.bollinger_hband()
    # data["BB_avg"] = BB.bollinger_mavg()
    return data

# Long Position Rules
def check_long_entry_condition(row, previous_candle):
    return previous_candle["RSI"] <= params["rsi_overbought"] < row["RSI"]

def check_long_exit_condition(row, previous_candle):
    return previous_candle["RSI"] >= params["rsi_overbought"] > row["RSI"]

def compute_long_tp_level(price):
    return price * (1 + params["tp_pct"] / 100)

def compute_long_sl_level(price):
    return price * (1 - params["sl_pct"] / 100)

# Short Position Rules
def check_short_entry_condition(row, previous_candle):
    pass

def check_short_exit_condition(row, previous_candle):
    pass

def compute_short_tp_level(price):
    pass

def compute_short_sl_level(price):
    pass

# Define position sizing rules
def calculate_position_size(balance):
    return balance * params["position_size_pct"] / 100


# ==========================================
# PART 3: TRADING BOT
# ==========================================

if __name__ == "__main__":
    
    try:
        # ==========================================
        # 1. Initialize Client
        # ==========================================
        wallet_address = os.getenv("HYPERLIQUID_WALLET_ADDRESS")
        private_key = os.getenv("HYPERLIQUID_PRIVATE_KEY")
        client = HyperliquidClient(wallet_address, private_key)

        # ==========================================
        # 2. Get Account Information
        # ==========================================
        balance_info = client.fetch_balance()
        balance = float(balance_info["total"]["USDC"])
        my_print(f"Current balance: {balance} USDC", verbose)

        # ==========================================
        # 3. Get Market Data
        # ==========================================
        # Fetch OHLCV data
        df = client.fetch_ohlcv(params["symbol"], params["timeframe"])

        # Compute indicators
        df = compute_indicators(df)
        
        # Get current and previous candle
        current_candle = df.iloc[-2]
        previous_candle = df.iloc[-3]
        current_price = current_candle['close']

        # ==========================================
        # 4. Check Positions & Execute Strategy
        # ==========================================
        # Check for open positions
        positions = client.fetch_positions([params["symbol"]])
        current_position = positions[0] if positions else None

        if current_position:
            # ----------------------------------------
            # 4a. Position Management
            # ----------------------------------------
            position_side = current_position["side"].lower()
            
            # Check long exit
            if position_side == "long" and not ignore_longs and not ignore_exit:
                if check_long_exit_condition(current_candle, previous_candle):
                    my_print("Long exit signal detected", verbose)
                    client.place_market_order(
                        params["symbol"], 
                        "sell", 
                        abs(current_position["contracts"]),
                        reduce_only=True
                    )
                    my_print("Long position closed", verbose)
            
            # Check short exit
            elif position_side == "short" and not ignore_shorts and not ignore_exit:
                if check_short_exit_condition(current_candle, previous_candle):
                    my_print("Short exit signal detected", verbose)
                    client.place_market_order(
                        params["symbol"], 
                        "buy", 
                        abs(current_position["contracts"]),
                        reduce_only=True
                    )
                    my_print("Short position closed", verbose)

        else:
            # ----------------------------------------
            # 4b. Setup Trading Account
            # ----------------------------------------
            # Set leverage and margin mode before opening new positions
            client.set_leverage(
                symbol=params["symbol"],
                leverage=params["leverage"]
            )
            
            client.set_margin_mode(
                symbol=params["symbol"],
                margin_mode=params["margin_mode"],
                leverage=params["leverage"]
            )
            
            # ----------------------------------------
            # 4c. Entry Management
            # ----------------------------------------
            if not ignore_longs and check_long_entry_condition(current_candle, previous_candle):
                my_print("Long entry signal detected", verbose)
                
                # Calculate position size
                position_size = calculate_position_size(balance)
                amount = position_size / current_price
                
                # Calculate TP/SL levels only if not ignored
                tp_price = None
                sl_price = None
                
                if not ignore_tp:
                    tp_price = compute_long_tp_level(current_price)
                    
                if not ignore_sl:
                    sl_price = compute_long_sl_level(current_price)
                    
                my_print(f"Opening long position with TP at {tp_price} and SL at {sl_price}", verbose)
                
                # Open position with optional TP/SL
                orders = client.place_market_order(
                    params["symbol"], 
                    "buy", 
                    amount,
                    take_profit_price=tp_price,
                    stop_loss_price=sl_price
                )
                
                if orders.get("market_order"):
                    my_print(f"Long position opened: {orders['market_order']['resting']}", verbose)
                    
                    if orders.get("take_profit_order"):
                        my_print(f"Long take profit order placed: {orders['take_profit_order']['resting']}", verbose)
                    
                    if orders.get("stop_loss_order"):
                        my_print(f"Long stop loss order placed: {orders['stop_loss_order']['resting']}", verbose)
            
            # Check short entry
            elif not ignore_shorts and check_short_entry_condition(current_candle, previous_candle):
                my_print("Short entry signal detected", verbose)
                
                # Calculate position size
                position_size = calculate_position_size(balance)
                amount = position_size / current_price
                
                # Calculate TP/SL levels only if not ignored
                tp_price = None
                sl_price = None
                
                if not ignore_tp:
                    tp_price = compute_short_tp_level(current_price)
                    
                if not ignore_sl:
                    sl_price = compute_short_sl_level(current_price)
                    
                my_print(f"Opening short position with TP at {tp_price} and SL at {sl_price}", verbose)
                
                # Open position with optional TP/SL
                orders = client.place_market_order(
                    params["symbol"], 
                    "sell", 
                    amount,
                    take_profit_price=tp_price,
                    stop_loss_price=sl_price
                )
                
                if orders.get("market_order"):
                    my_print(f"Short position opened: {orders['market_order']['resting']}", verbose)
                    
                    if orders.get("take_profit_order"):
                        my_print(f"Short take profit order placed: {orders['take_profit_order']['resting']}", verbose)
                    
                    if orders.get("stop_loss_order"):
                        my_print(f"Short stop loss order placed: {orders['stop_loss_order']['resting']}", verbose)

    except Exception as e:
        my_print(f"Error in main loop: {e}", verbose)
        exit(1)

为什么年轻人拼命努力，也过不上好日子？

Thu, 28 May 2026 21:28:11 +0800

网络上盛传的，都是‘’年轻人拼命努力也无法过上好日子“，”分配有问题“，“阶层固化”，”内卷“，”不如躺平“等等，是不是这样？只有这样才叫政治正确，你要不这样，那你就脱离了人民群众，你是资本家，或者精神资本家，或者何不食肉糜。

总有人觉得社会有问题，才导致年轻人”拼命努力“也无法改变命运。

打住，拼命是怎么个拼命法？据我所知，所听，所见，大多数人还是房非常惜命的，又何来拼命一说？你不会告诉我到店上班下班，哪怕再”过分“点，996就算很拼命了吧？

别恼，我们来理个逻辑，这个世上注定只能有一小部分人过的“好”，是不是？它不是任何社会或者主义的问题，而是人类社会必然自带的现象。因为“好”这个词的定义，就是超越平均的才叫好——从定义上，我们就限死了它必然只有小部分人能达到——所有人都有车开了，那开上豪车的才叫好；所有人都有50平米的房子住了，那100平才叫好。

好是个主观词，跟它对应的是差，没有差就不存在好——也就是没有绝对的”好日子“，只有相对于其他人的”好日子“。

所以你以为你在拼命努力，事实上如果其他人也在这么干，那你的程度就不能叫”拼命“了，而只是普通。你要”有可能好“，就得大幅度领先其他人的努力程度——所有人都996，那你007也不一定够。比如你的起点低，那你每天领先别人一点点是不够的，只有人家在休息，人家都在爽，每个人都在躺平和享乐，这是候出来一个007的你，那你改变命运才快，是不是这样？

这世上绝对不存在“大家都能过上好日子”这种事。因为所有人都好，就是所有人都不好。因此不要再说“年轻人无法过上好日子”这种话了，从来都是“哪一部分人过上了好日子”的问题。如果你赞同这一点，却说“
但努力没用，有权有势有资源才有用”——我部分认同，但无权无势无资源起步的年轻人，改变命运的并不少，至少我就见过很多，怎么能叫没用呢？只是刚好不是你而已。况且现在或许已经是整个5000年历史上，最不靠家世和资源就能获得成功的时代了，你还要啥自行车？给你平移到任何其他的时代和社会，你的处境都不会比现在更好。

很多人蠢的点在于，别人说”不如躺平“，说”干了也没用，反正没希望“，他就听进去了，看看旁边的同事，对面的老板，也开始忿忿不平，讨厌资本家，然后也开始偷奸耍滑，开始躺平啃老。你难道不知道只有当别人都是傻逼的时候，你的努力才有性价比吗？如果大家一起卷，你真以为能卷得过啊？这么说吧，人人都去下围棋，那柯洁也就不咋地了；人人都去踢足球，梅西也不会是最强；人人都去造火箭，现在最出名的一定不是马斯克。

你要明白你不是在跟一个虚拟的“社会”竞争，而是在跟其他人竞争，跟那些你觉得在为你说话，你觉得在为你争取权益，你觉得“说躺平有理”的人竞争——这个社会规则再为你以为你所处的群体着想，你也喝不到汤，因为汤再多，架不住来喝的人多，你的生活不会变好一点，到时候大量“之前你以为跟你在同一战线”的人抢起来，直接就给你挤到门外头去了。他只有单为你一个人制定萝卜规则，你才能真正受益，但那可能吗？

所以重点是什么？跟他们反着来，他们爽，你不能爽；他们躺，你不能躺。这帮人的人数阅越多，跟他们反着来的社会压力越大，自我怀疑，想放弃的时刻越多，但潜在收益却恰好是最高的。

（完）

人世间最佳投资组合

Tue, 26 May 2026 08:29:30 +0800

饮茶观雨，其中一个大家讨论额问题就是最佳的投资组合是什么？

对于很多人，我们面临的选择有以下投资品。

1. 美国房地产。

2. 中国房地产。

3. 美国股票。

4. 中国股票。

5. 实物黄金或者黄金ETF

6. 食物大饼或者是大饼ETF。

7. 现金，中国或者是美国的债券。

那么到底是应该怎样一个投资组合最好呢？

在传统的投资组合观念中，相对保守稳健的投资组合方式应该是。1和2加在一起占25%。3和4加在一起占25%。5和6加在一起占25%。第7类属于高流动性的资产，占25%。

至于中美之间的配置，根据自己的喜好和生活的地点，选一个合适的比例。

这样的投资组合可以获得比较好的长期收益，同时相对稳健，在需要花钱的时候不至于捉襟见肘，当机会来临的时候也不至于没有资金。投资人可以根据当下市场行情的变化做5%左右微小的比例调整。

然而没有一个投资组合是适应所有人的，总的来说风险越高，回报越大，偏于保守，那肯定回报相对低。

我自己觉得在当下这个时代，对于还是相对年轻的投资人而言，也许最佳的投资组合是。

定投食物大饼+一份不咸不淡的工作+健康投资。

这是一个奇特的投资组合，可能所有的教科书都没有提到过。后来一点点解释背后的原因。

首先我们要明白所有的投资最主要的目的就是抗拒法币的增发。之前我发过这个数据，现在再发一次。

1970年，美国的平均年工资是9,800美元，平均房价是1.7万美元，黄金是38美元一盎司，S&P指数是83. 0当时美元M2的发行量是590 billions.

现在，美国的平均工资是6万美元。平均房价是41.6万美元，黄金是1900美元一盎司，S&P指数是4,400. 看着一切都变得昂贵的很多。现在M2的发行量是20.8万亿美元。

如果你计算过去50年的年均增长率。他们分别为：黄金（7.8%），股票（7.9%），平均房价（6.4%），平均工资（3.55%）。美元M2 的年增长率为 7.1%。

股票投资的确会胜出黄金与房子。但背后最主要的原因依旧是法币增发，而不是公司的成长。

抗拒法币增发，有任何一个投资品能够超过食物大饼么？

答案是没有。MSTR的总裁有同样的感受。黄金被源源不断地开采出来，每天都有新的公司被制造出来上市，房子也在远远的不断被建造出来。投资股票能够获得和货币增发不相上下的收益，是因为个别公司有成长性。投资房地产，能够赚得盆满钵满，最主要的原因是因为使用了杠杆。

然而投资人为此需要付出很大的代价。前者只能通过购买股市指数解决风险控制问题，不得不持有垃圾公司。后者，需要投入大量的精力去管理和修缮房屋。

第2条为什么要有一份不咸不淡的工作？最主要的原因是有稳定的现金流。让你有钱去投资。但是随着未来AI和科技进步。个人在职场上的工作努力可能没有那么重要。

在过去的传统世界里，投资于自己的职场长期规划是一个非常好的方式。俗称向上爬公司的梯子。但是未来的社会是多变和动荡的。节奏也越来越快，一不当心一个行业就被颠覆掉了。

不相信你可以去问问那些被裁掉的大厂或者是著名企业的中高层管理人员，他们中年下岗是什么滋味？

可能更稳健的模式是自己有一个small business。把自己的命运掌握在自己手里。

不一定要特别热爱自己的工作。但是需要做小的创业，需要一个side business.

第三天投资在自己的健康。可能我最近一些年看到越来越多的人出现各种健康问题。投资在自己的健康其实远比投资在其他项目上更重要。

投资健康是需要时间，金钱和精力付出的。很多人只是把投资健康挂在嘴边，并没有采取有效的行动。活的长是投资中最关键的因素，不然巴菲特也不会成为最伟大的股神。

当一些长线投资，短期看不到效果的时候，人们就会停止或者难以坚持下去。对于自己的健康投资就属于这一类。所以人们宁愿投资在美妆，而不愿意投资在皮肤以下的健康。投资健康需要有超长期的延迟满足能力，才能做到这一点。

如果历史回看，经历20-30年我相信这个投资组合会获得超高的回报。但是缺点就是会有巨大的起伏。

人们的行为习惯总是觉得付出额外的努力就可以获得更多的回报。常言道一分耕耘，一分收获。可是在投资界往往不是这样的。做少而正确的事情，远比每天忙碌更加重要。很多人像老黄牛一样忙忙碌碌一生却一无所得。

我的人世间最佳投资组合就是埋头干活固然好，也要抬头看清楚前方路的方向。

tradingview webhook

Mon, 25 May 2026 08:36:45 +0800

ETH-USDT-SWAP|{{strategy.order.action}}|{{strategy.order.contracts}}

http://okx.hk*****.com/macd30min

ATR通道突破系统	1000
巴赫1D	2000
巴赫12h	2000
布林策略	1000
四均线	1000
海龟	1000
macd_4h	1000

v2ray 一键安装仅在ubuntu 上测试成功

Sun, 17 May 2026 21:08:51 +0800

bash <(curl -L -s https://raw.githubusercontent.com/evon16888/V2Ray_ws-tls_bash_onekey/refs/heads/master/install.sh) | tee v2ray_ins.log

准备好一个域名即可

黄果树

Mon, 11 May 2026 10:26:06 +0800

原版黄果树

# 没有后置过滤 random.sample(range(24), 8)

# Cci + QuoteVolumeMean
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [0],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 1 * 0.5 * 0.6 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('Cci', False, 240, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 240, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# MinMax + QuoteVolumeMean
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [21],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 1 * 0.5 * 0.6 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('MinMax', False, 240, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 240, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# BiasQ + QuoteVolumeMean
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [18],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 1 * 0.5 * 0.6 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('BiasQ', False, 192, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 192, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + MinMax
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列2",
    "offset_list": [14],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 1 * 0.5 * 0.2 * 0.6 / 2,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 312, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('MinMax', 312, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + BiasQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树",
    "offset_list": [4],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 1 * 0.25 * 0.75 / 4,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 432, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('BiasQ', 432, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + Cci
{
    "strategy": "Strategy_黄果树系列2",
    "offset_list": [14],
    "hold_period": '24H',
    "market": 'swap_swap',
    'cap_weight': 0.2 / 3,
    'long_cap_weight': 0,
    'short_cap_weight': 1,
    'long_select_coin_num': 0,
    'short_select_coin_num': 0.5,
    "factor_list": [
        ('QuoteVolumeMean', True, 624, 1),
    ],
    "filter_list": [
        ('Cci', 624, 'pct:<0.2'),
    ],
    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
},

# QuoteVolumeMean + BiasQ & QuoteVolumeMean
{
    "strategy": "Strategy_黄果树系列3",
    "offset_list": [3],
    "hold_period": '24H',
    "market": 'swap_swap',
    'cap_weight': 0.2 / 3,
    'long_cap_weight': 0,
    'short_cap_weight': 1,
    'long_select_coin_num': 0,
    'short_select_coin_num': 9999,
    "factor_list": [
        ('QuoteVolumeMean', True, 1, 1),
    ],
    "filter_list": [
        ('BiasQ', 576, 'pct:<0.15'),
        ('QuoteVolumeMean', 576, 'pct:<0.15', False),
    ],
    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
},

# QuoteVolumeMean + MinMax & QuoteVolumeMean
{
    "strategy": "Strategy_黄果树系列3",
    "offset_list": [11],
    "hold_period": '24H',
    "market": 'swap_swap',
    'cap_weight': 0.2 / 3,
    'long_cap_weight': 0,
    'short_cap_weight': 1,
    'long_select_coin_num': 0,
    'short_select_coin_num': 9999,
    "factor_list": [
        ('QuoteVolumeMean', True, 1, 1),
    ],
    "filter_list": [
        ('MinMax', 216, 'pct:<0.15'),
        ('QuoteVolumeMean', 216, 'pct:<0.15', False),
    ],
    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
},

# QuoteVolumeMean + Cci & QuoteVolumeMean
{
    "strategy": "Strategy_黄果树系列3",
    "offset_list": [23],
    "hold_period": '24H',
    "market": 'swap_swap',
    'cap_weight': 0.2 / 3,
    'long_cap_weight': 0,
    'short_cap_weight': 1,
    'long_select_coin_num': 0,
    'short_select_coin_num': 9999,
    "factor_list": [
        ('QuoteVolumeMean', True, 1, 1),
    ],
    "filter_list": [
        ('Cci', 576, 'pct:<0.15'),
        ('QuoteVolumeMean', 576, 'pct:<0.15', False),
    ],
    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
},

# Cci + QuoteVolumeMean + ZfMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [16, 22],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('Cci', False, 648, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 648, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('ZfMeanQ', 648, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# Cci + QuoteVolumeMean + VolumeMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [22, 5],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('Cci', False, 384, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 384, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('VolumeMeanQ', 384, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# MinMax + QuoteVolumeMean + ZfMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [0, 3],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('MinMax', False, 504, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 504, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('ZfMeanQ', 504, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# MinMax + QuoteVolumeMean + VolumeMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [0, 2],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('MinMax', False, 648, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 648, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('VolumeMeanQ', 648, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# BiasQ + QuoteVolumeMean + ZfMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [6, 21],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('BiasQ', False, 312, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 312, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('ZfMeanQ', 312, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# BiasQ + QuoteVolumeMean + VolumeMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列1",
    "offset_list": [1, 7],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.6 / 6,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('BiasQ', False, 312, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('QuoteVolumeMean', 312, 'pct:<0.2', False),
        # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('VolumeMeanQ', 312, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + MinMax + VolumeMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列2",
    "offset_list": [9, 11],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.2 / 2,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 168, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('MinMax', 168, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('VolumeMeanQ', 168, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + Cci + ZfMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列2",
    "offset_list": [22, 8],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.2 / 2,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 360, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('Cci', 360, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
    "filter_list_post": [
        ('ZfMeanQ', 360, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + Cci & QuoteVolumeMean + ZfMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列3",
    "offset_list": [18, 2],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.2 / 2,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 9999,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 1, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('Cci', 432, 'pct:<0.15'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
        ('QuoteVolumeMean', 432, 'pct:<0.15', False),
    ],
    "filter_list_post": [
        ('ZfMeanQ', 432, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

# QuoteVolumeMean + MinMax & QuoteVolumeMean + VolumeMeanQ
{
    # 策略名称。与strategy目录中的策略文件名保持一致。
    "strategy": "Strategy_黄果树系列3",
    "offset_list": [2, 11],  # 只选部分offset[1, 3, 6]；
    "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
    "is_use_spot": False,  # 多头支持交易现货；
    # 资金权重。程序会自动根据这个权重计算你的策略占比
    'cap_weight': 0.5 * 0.2 / 2,
    'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
    'short_cap_weight': 1,
    # 选币数量
    'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
    'short_select_coin_num': 9999,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
    "factor_list": [
        ('QuoteVolumeMean', True, 1, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
    ],
    "filter_list": [
        ('MinMax', 312, 'pct:<0.15'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
        ('QuoteVolumeMean', 312, 'pct:<0.15', False),
    ],
    "filter_list_post": [
        ('VolumeMeanQ', 312, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
    ],
},

伽利略选股策略

Sun, 03 May 2026 12:03:03 +0800

伽利略选股策略

"""
邢不行策略分享会
微信：xbx9025
"""
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from program.选股策略.Functions import *
pd.set_option('expand_frame_repr', False)  # 当列太多时不换行
pd.set_option('display.max_rows', 5000)  # 最多显示数据的行数

# ===参数设定
select_stock_num = 3  # 选股数量
c_rate = 1.5 / 10000  # 手续费
t_rate = 1 / 1000  # 印花税

# ===导入数据
# 从hdf文件中读取整理好的所有股票数据
df = pd.read_hdf('/Users/xingbuxingx/Desktop/策略分享会直播/191108- 伽利略选股策略_资金流选股策略/伽利略选股策略/data/选股策略/all_stock_data_W.h5', 'df')
df.dropna(subset=['下周期每天涨跌幅'], inplace=True)

# ===选股
# 删除下个交易日不交易、开盘涨停的股票，因为这些股票在下个交易日开盘时不能买入。
df = df[df['下日_是否交易'] == 1]
df = df[df['下日_开盘涨停'] == False]
df = df[df['下日_是否ST'] == False]
df = df[df['下日_是否退市'] == False]

# ****************************以下内容可以改动****************************
# ===常见因子
# df['因子'] = df['量价相关系数_1_10']  # 量价相关策略
# df['因子'] = df['总市值']  # 小市值策略
# df['因子'] = df['收盘价']  # 低价股策略。用最低价代替，不会更好？
# df['因子'] = df['成交额'] / df['流通市值']  # 换手率
# 还有很多其他的策略在开发中，展示隐藏策略页面

# ===技术指标因子
# bias指标
# df['因子'] = df['bias_20']  # 反转因子
# # kdj
# df['因子'] = df['K']  # 根据某个指标的值来，单调性很差。不一定这么用，之后会讲其他改进方法。

# ===财务数据因子：展示正在为大家准备的财务数据


# ===先筛选一部分股票
# df = df[df['上市至今交易天数'] > 250]
# df = df[df['bias_20'] < 0.05]

# ===策略组合
# 组合方式1：相乘。当几个因子都有效，可以将其相乘，然后组合起来
# df['因子'] = df['总市值'] * df['收盘价'] * df['成交额']
# 不是相乘就会变得更好
# df['因子'] = df['总市值'] * df['收盘价']
# 有的不能直接相乘，比如'量价相关系数_1_10'有负数
# df['因子'] = df['总市值'] * df['收盘价'] * df['成交额'] * df['量价相关系数_1_10']

# 组合方式2：排名相加
df['总市值_排名'] = df.groupby('交易日期')['总市值'].rank()
df['收盘价_排名'] = df.groupby('交易日期')['收盘价'].rank()
df['成交额_排名'] = df.groupby('交易日期')['成交额'].rank()
df['量价相关系数_1_10_排名'] = df.groupby('交易日期')['量价相关系数_1_10'].rank()
df['bias_20'] = df.groupby('交易日期')['bias_20'].rank()
df['因子'] = df['总市值_排名'] + df['收盘价_排名'] + df['成交额_排名'] + df['量价相关系数_1_10_排名'] + df['bias_20']

# 组合方式3：排名相加，代表各个因子对最终结果的权重是一样的，那么我希望不一样怎么办？
# 因子之间有相关性怎么办？
# 多因子模型

# 组合方式4：有这么多的因子，自己人工组合好累，能不能让程序自动帮我组合？
# 机器学习

# 根据选股因子对股票进行排名
# 计算排名绝对值
df['排名'] = df.groupby('交易日期')['因子'].rank()
# 计算排名百分比
# df['排名_百分比'] = df.groupby('交易日期')['因子'].rank(pct=True)

# 选取排名靠前的股票
df = df[df['排名'] <= select_stock_num]
# df = df[df['排名_百分比'] < 0.1]

# ****************************以上内容可以改动****************************

# 按照开盘买入的方式，修正选中股票在下周期每天的涨跌幅。
# 即将下周期每天的涨跌幅中第一天的涨跌幅，改成由开盘买入的涨跌幅
df['下日_开盘买入涨跌幅'] = df['下日_开盘买入涨跌幅'].apply(lambda x: [x])
df['下周期每天涨跌幅'] = df['下周期每天涨跌幅'].apply(lambda x: x[1:])
df['下周期每天涨跌幅'] = df['下日_开盘买入涨跌幅'] + df['下周期每天涨跌幅']
print(df[['交易日期', '股票名称', '下日_开盘买入涨跌幅', '下周期每天涨跌幅']].tail(6))

# ===整理选中股票数据
# 挑选出选中股票
df['股票代码'] += ' '
df['股票名称'] += ' '
group = df.groupby('交易日期')
select_stock = pd.DataFrame()
select_stock['买入股票代码'] = group['股票代码'].sum()
select_stock['买入股票名称'] = group['股票名称'].sum()

# 计算下周期每天的资金曲线
select_stock['选股下周期每天资金曲线'] = group['下周期每天涨跌幅'].apply(lambda x: np.cumprod(np.array(list(x))+1, axis=1).mean(axis=0))

# 扣除买入手续费
select_stock['选股下周期每天资金曲线'] = select_stock['选股下周期每天资金曲线'] * (1 - c_rate)  # 计算有不精准的地方
# 扣除卖出手续费、印花税。最后一天的资金曲线值，扣除印花税、手续费
select_stock['选股下周期每天资金曲线'] = select_stock['选股下周期每天资金曲线'].apply(lambda x: list(x[:-1]) + [x[-1] * (1 - c_rate - t_rate)])

# 计算下周期整体涨跌幅
select_stock['选股下周期涨跌幅'] = select_stock['选股下周期每天资金曲线'].apply(lambda x: x[-1] - 1)
# 计算下周期每天的涨跌幅
select_stock['选股下周期每天涨跌幅'] = select_stock['选股下周期每天资金曲线'].apply(lambda x: list(pd.DataFrame([1] + x).pct_change()[0].iloc[1:]))
del select_stock['选股下周期每天资金曲线']

# 计算整体资金曲线
select_stock.reset_index(inplace=True)
select_stock['资金曲线'] = (select_stock['选股下周期涨跌幅'] + 1).cumprod()
print(select_stock)

# ===计算选中股票每天的资金曲线
# 计算每日资金曲线
index_data = import_index_data('/Users/xingbuxingx/Desktop/策略分享会直播/191011- 若干选股策略说明及如何简单组合策略/如何简单组合策略/data/选股策略/sh000001.csv')
equity = pd.merge(left=index_data, right=select_stock[['交易日期', '买入股票代码']], on=['交易日期'],
                  how='left', sort=True)  # 将选股结果和大盘指数合并

equity['持有股票代码'] = equity['买入股票代码'].shift()
equity['持有股票代码'].fillna(method='ffill', inplace=True)
equity.dropna(subset=['持有股票代码'], inplace=True)
del equity['买入股票代码']

equity['涨跌幅'] = select_stock['选股下周期每天涨跌幅'].sum()
equity['equity_curve'] = (equity['涨跌幅'] + 1).cumprod()
equity['benchmark'] = (equity['指数涨跌幅'] + 1).cumprod()


# ===画图
equity.set_index('交易日期', inplace=True)
plt.plot(equity['equity_curve'])
plt.plot(equity['benchmark'])
plt.legend(loc='best')
plt.show()

RequestsDependencyWarning: urllib3 (2.6.3) or pycharm报错

Fri, 01 May 2026 11:13:17 +0800

看到这个警告（RequestsDependencyWarning），通常是因为你安装的 requests 库与当前环境中的 urllib3 或 chardet 版本不兼容导致的。

简单来说，requests 内部对这些依赖库有特定的版本要求，而你目前安装的版本可能太新或太旧。

核心解决思路：对齐版本

最稳妥的办法是更新 requests 及其相关依赖，或者强制安装 requests 官方推荐的兼容版本。

方案一：一键更新（推荐）

大多数情况下，直接更新这三个库就能解决版本错配问题：

pip install --upgrade requests urllib3 chardet

针对币安下架的指数择时处理方案

Thu, 30 Apr 2026 19:14:06 +0800

不想写代码了，手工处理一下得了

下架信息

https://www.binance.com/zh-CN/support/announcement/list/161

处理路径：

1、删除【低价币指数_select_coin.csv】

sed -i '/B3USDT/d' 低价币指数_select_coin.csv

sed -i '/BOBUSDT/d' 低价币指数_select_coin.csv

sed -i '/DEGENUSDT/d' 低价币指数_select_coin.csv

2、删除【低价币指数.csv】

sed -i 's/B3USDT //g' 低价币指数.csv

sed -i 's/BOBUSDT //g' 低价币指数.csv

sed -i 's/DEGENUSDT //g' 低价币指数.csv

3、更新数据库

UPDATE account
SET strategy_pos = JSON_REMOVE(strategy_pos, '$.symbols."B3USDT"')
WHERE JSON_CONTAINS_PATH(strategy_pos, 'one', '$.symbols."B3USDT"');

UPDATE account
SET strategy_pos = JSON_REMOVE(strategy_pos, '$.symbols."BOBUSDT"')
WHERE JSON_CONTAINS_PATH(strategy_pos, 'one', '$.symbols."BOBUSDT"');

UPDATE account
SET strategy_pos = JSON_REMOVE(strategy_pos, '$.symbols."DEGENUSDT"')
WHERE JSON_CONTAINS_PATH(strategy_pos, 'one', '$.symbols."DEGENUSDT"');

学习英语提示词

Sun, 26 Apr 2026 15:25:48 +0800

从现在开始，我需要你像专业英文老师、学习教练和口语伙伴一样为我服务。

我目前的英文水平: A1

目标水平: B1

每天可用时间: [每天30分钟]

学习目的: [面试国际学校/听懂国际学校 7、8、9 年级课程]

1) 个人学习计划

制定按周划分、有明确目标、可与ChatGPT直接应用的学习计划。

每周包括:

•学习话题

•词汇目标

•听力和口语任务

•小型评估测试

2) 逐步实施

不只是讲解，让我开始实践。

每个新步骤:

•简短说明

•立即给练习

•等我回答

•以教学方式纠正错误

3) 词汇教学

我不认识的单词用以下方式教:

•英文解释

•中文意思

•日常例句

•最常见错误

•与相似词的区别

然后给使用任务。

4) 真实场景

对于咖啡馆、机场、酒店、面试等真实环境:

•自然对话

•常用表达

•替代表达

•正式/日常用法区别

5) 角色扮演(口语练习)

进入角色扮演模式。

你扮演不同角色问我。

纠正我的:

•语法

•流畅性

•自然度

并展示更好的版本。

6) 听力练习

符合我水平的:

•短听力文本

•关键词

•理解问题

•必要时慢速和正常版本

然后给我测试。

7) 写作检查

检查我写的所有文本:

•分析错误

•解释原因

•用更自然英文重写

•提供改进建议

8) 口语发展

为提高口语:

•每天10-15分钟的任务

•符合我水平的话题

•独立和与你的口语练习

9) 语言+文化

为我学习目标语言文化:

•推荐符合水平的书籍、电影、视频

•指出需要学习的词汇和短语

10) 水平测试和路线图

定期给我短而有效的水平测试。

根据结果:

•更新薄弱领域

•确认强项

•更新达到B1的清晰路线图

现在按此系统指导我，立即开始第一课。

杂货铺

hyperliquid 基于python 的操作代码

为什么年轻人拼命努力，也过不上好日子？

人世间最佳投资组合

tradingview webhook

v2ray 一键安装 仅在ubuntu 上测试成功

黄果树

伽利略选股策略

RequestsDependencyWarning: urllib3 (2.6.3) or pycharm报错

核心解决思路：对齐版本

方案一：一键更新（推荐）

针对币安下架的指数择时处理方案

学习英语提示词

v2ray 一键安装仅在ubuntu 上测试成功