python实现砖型图策略

砖型图策略是一种技术分析工具,它可以帮助交易者识别趋势和价格变动方向,并为交易决策提供支持。在这篇文章中,我们将探讨砖型图策略的基本原理和如何使用它来制定交易策略。

砖型图策略的基本原理

砖型图策略是由日本股票交易家斋藤康嘉于1990年代初发明的。该策略使用的是一种称为“砖块”的图形来显示价格的变化。砖块由一系列的价格区间组成,这些价格区间可以是股票、期货、外汇或其他资产的价格。

砖型图策略的核心思想是识别价格趋势。如果价格上涨,砖块的颜色为红色;如果价格下跌,砖块的颜色为绿色。当价格趋势改变时,砖块的颜色也会随之改变。

在这里插入图片描述

如何使用砖型图策略来制定交易策略

使用砖型图策略来制定交易策略通常需要以下步骤:

  1. 确定砖块大小

在砖型图策略中,砖块的大小可以影响趋势的识别。通常,交易者可以根据交易资产的波动性和自己的交易风险偏好来确定砖块大小。例如,如果交易者希望捕捉短期波动,可以选择较小的砖块大小。而如果交易者希望捕捉长期趋势,可以选择较大的砖块大小。

  1. 识别价格趋势

使用砖型图策略的一个主要目的是识别价格趋势。交易者可以通过观察砖块的颜色和大小来识别价格趋势。例如,如果看到一系列的红色砖块,就表明价格处于上涨趋势中。反之,如果看到一系列的绿色砖块,就表明价格处于下跌趋势中。

  1. 制定交易策略

一旦交易者识别了价格趋势,就可以制定相应的交易策略。例如,如果价格处于上涨趋势中,交易者可以考虑买入或持有头寸。而如果价格处于下跌趋势中,交易者可以考虑卖空或者持有空头头寸。
砖型图策略是一种简单而有效的技术分析工具,可以帮助交易者识别价格趋势,并为交易决策提供支持。使用砖型图策略制定交易策略需要根据交易资产的波动性和自己的交易风险偏好来确定砖块大小,并通过观察砖块的颜色和大小来识别价格趋势。最终,交易者可以根据价格趋势制定相应的交易策略。

使用Python可以方便地实现砖型图策略,下面将介绍如何使用Python编写一个简单的砖型图策略。

from simctp import *  # 导入simctp库中的所有内容
from simctp import Tick_Data  # 导入simctp库中的Tick_Data类

再写一个策略类,在策略代码里写了注释,这里不做过多介绍

class 砖型策略(obj):  # 定义一个名为砖型策略的类,继承自obj类
    def __init__(self):  # 初始化方法
        super().__init__()  # 调用父类的初始化方法
        self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"]   # 订阅合约列表
        self.objtype = objtype.renko  # 策略类型设置为renko,默认为tick
        self.renko_tick = 1   # 设定砖型幅度,默认合约10,最小变动价
    def on_bar(self, bar, tick: Tick_Data):  # on_bar方法,在每根K线更新时被调用
        print(tick.LastPrice)  # 打印最新tick的价格
        if len(bar) < 2:  # 如果bar的长度小于2,则返回
            return
        kline = bar[-1]  # 获取最新的砖型数据
        position = self.get_pos(tick.code)  # 获取指定合约的持仓信息
        if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "上涨":  # 如果是空仓,且连续两个上涨砖,则开多单
            print("砖型图策略开多单")
            self.insert_order(tick.code, 1, tick.AskPrice1, DirectionType.Buy, OffsetType.Open)  # 开多单
        if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "下跌":  # 如果是空仓,且连续两个下跌砖,则开空单
            print("砖型图策略开空单")
            self.insert_order(tick.code, 1, tick.BidPrice1, DirectionType.Sell, OffsetType.Open)  # 开空单
        if position.pos_long > 0 and position.long_pos_frozen == 0 and kline["Renko"] == "下跌":  # 如果有多单,最新砖下跌,上一砖是上涨,则平多单开空单
            print("砖型图策略平多单并开空")
            if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]:  # 判断是否为上期所和能源所今仓
                self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.CloseToday)  # 多头平今
            else:
                self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.Close)  # 多头平仓
        if position.pos_short > 0 and position.short_pos_frozen == 0 and kline["Renko"] == "上涨":  # 如果有空单,最新砖上涨,上一砖是下跌,则平空单开多单
            print("砖型图策略平空单并开多")
            if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]:  # 判断是否为上期所和能源所今仓
                self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open)  # 空头平今
            else:
                self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open)  # 空头平仓
        Account = self.get_account()
        print(Account.close_profit) #获取账号状态并打印平仓盈亏
        print(Account.commission) #获取账号状态并打印手续费

最后启动策略

t = TMS()
t.add_obj(砖型策略())
t.run()

执行后的效果

在这里插入图片描述
策略完整源码

from simctp import *  # 导入simctp库中的所有内容
from simctp import Tick_Data  # 导入simctp库中的Tick_Data类

class macd(obj):
    def __init__(self):
        super().__init__()
        self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"]   # 订阅合约 
        self.objtype = objtype.bar
        self.dete = dete.time3
        self.orders = {}  # 保存每个合约的订单信息
        self.pyramid_ratio = 0.5  # 金字塔加仓比例为50%
        self.max_pyramid_count = 3  # 最大加仓次数为3次
    def get_volume(self,code):
        quote = self.get_quote(code)
        available = self.get_account().balance #静态权益
        multiplier = quote.VolumeMultiple*quote.LastPrice
        max_open = available * 0.1
        # 计算最大开仓手数
        max_volume = int(max_open / multiplier)
        if max_volume <= 0:
            max_volume = 1
        else:
            max_volume = max_volume
        return max_volume
    def get_volume2(self, code, last_price, stop_loss_price, take_profit_ratio=3, is_long=True):
        quote = self.get_quote(code)
        account = self.get_account()
        available_funds = account.balance
        risk_percent = 1 / 100
        max_acceptable_loss = available_funds * risk_percent
        if is_long:
            loss_per_trade = (last_price - stop_loss_price) * quote.VolumeMultiple
        else:
            loss_per_trade = (stop_loss_price - last_price) * quote.VolumeMultiple
        max_position = int(max_acceptable_loss / loss_per_trade)
        stop_profit_price = last_price + (last_price - stop_loss_price) * take_profit_ratio if is_long else last_price - (stop_loss_price - last_price) * take_profit_ratio
        if max_position <= 0:
            max_position = 1
        else:
            max_position = max_position
        return [max_position, stop_profit_price]        
    def calculate_max_position(self, code, last_price, stop_loss_price, take_profit_ratio=3, is_long=True):
        quote = self.get_quote(code)
        account = self.get_account()
        # 计算可用资金
        # available_funds = account.static_balance - account.margin - account.commission
        available_funds = account.available

        # 计算总资金的1%
        risk_percent = 1 / 100
        # 计算最大亏损金额
        max_acceptable_loss = available_funds * risk_percent
        # 计算最大开仓量
        if is_long:
            loss_per_trade = (last_price - stop_loss_price) * quote.VolumeMultiple
            max_position = int(max_acceptable_loss / loss_per_trade)
            stop_profit_price = last_price + (last_price - stop_loss_price) * take_profit_ratio
        else:
            loss_per_trade = (stop_loss_price - last_price) * quote.VolumeMultiple
            max_position = int(max_acceptable_loss / loss_per_trade)
            stop_profit_price = last_price - (stop_loss_price-last_price) * take_profit_ratio
        if max_position <= 0:
            max_position = 1
        else:
            max_position = max_position
        return [max_position,stop_profit_price]
    def pyramid_open(self, symbol, direction, price, volume, stop_loss_price, stop_profit_price, Stop_loss_range, count):
        """
        金字塔加仓开仓函数
        """
        if count >= self.max_pyramid_count:
            return
        new_volume = int(volume * self.pyramid_ratio)
        if new_volume <= 0:
            new_volume = 1
        else:
            new_volume = new_volume
        new_price = price
        # if direction == "BUY":
        #     print(Stop_loss_range)
        #     new_price += Stop_loss_range * 0.5
        # else:
        #     new_price -= Stop_loss_range * 0.5
        new_order = self.send(symbol=symbol, volume=new_volume, price=new_price, direction=direction, offset="OPEN")
        self.orders[symbol]["volume"] += new_volume
        self.orders[symbol]["count"] += 1
        self.orders[symbol]["open_price"] = new_price
        self.orders[symbol]["stop_loss_price"] = stop_loss_price
        self.orders[symbol]["stop_profit_price"] = stop_profit_price
        self.orders[symbol]["Stop_loss_range"] = Stop_loss_range
        # self.pyramid_open(symbol, direction, new_price, new_volume, stop_loss_price, stop_profit_price, Stop_loss_range, count + 1)

    def on_bar(self, bar, tick: Tick_Data):
        symbol = tick.InstrumentID
        macd = self.MACD(bar)
        # print(macd)
        xh = self.XH(macd.dif,macd.dea)
        MACD_cross = self.MACDZT(macd)
        HHLL = self.HHLL(bar,10)
        position = self.get_pos(symbol)
        last_price = bar[-1]["close"]
        # print(max(HHLL.H.iloc[-10:]))
        if symbol in self.orders:
            open_price = self.orders[symbol]["open_price"]
            stop_loss_price = self.orders[symbol]["stop_loss_price"]
            stop_profit_price = self.orders[symbol]["stop_profit_price"]
            Stop_loss_range = self.orders[symbol]["Stop_loss_range"]
            volume = self.orders[symbol]["volume"]
            count = self.orders[symbol]["count"]
        else:
            open_price = None
            stop_loss_price = None
            stop_profit_price = None
            Stop_loss_range = None
            volume = 0
            count = 0
        # 如果是空仓
        if position.pos_long <= 0 and position.pos_short <= 0 and MACD_cross.get("shangjin")==1 and MACD_cross.get("zhuangtai")=='金叉':
            volume = self.get_volume(symbol)
            stop_loss_price = min(HHLL.L.iloc[-10:]) # 设置止损位为前10日最低价
            order = self.send(symbol=symbol, volume=volume, price=0, direction="BUY", offset="OPEN")
            stop_profit_price = last_price + (last_price - stop_loss_price) * 3  # 设置止盈位为开仓价与止损幅度的3倍
            Stop_loss_range = last_price - stop_loss_price
            self.orders[symbol] = {"open_price": last_price, "stop_loss_price": stop_loss_price, "stop_profit_price": stop_profit_price, "Stop_loss_range": Stop_loss_range, "volume": volume, "count": 1}
        # 如果是空仓
        if position.pos_long <= 0 and position.pos_short <= 0 and MACD_cross.get("xiasi")==1 and MACD_cross.get("zhuangtai")=='死叉':
            volume = self.get_volume(symbol)
            stop_loss_price = max(HHLL.H.iloc[-10:]) # 设置止损位为前10日最高价
            order = self.send(symbol=symbol, volume=volume, price=0, direction="SELL", offset="OPEN")
            stop_profit_price = last_price - (stop_loss_price - last_price) * 3  # 设置止盈位为开仓价与止损幅度的3倍
            Stop_loss_range = stop_loss_price - last_price
            self.orders[symbol] = {"open_price": last_price, "stop_loss_price": stop_loss_price, "stop_profit_price": stop_profit_price, "Stop_loss_range": Stop_loss_range, "volume": volume, "count": 1}
        
        # 如果有多单
        if position.pos_long > 0 and stop_loss_price is not None:
            profit = position.float_profit_long / position.pos_long  # 计算当前持仓盈亏
            stop_distance = 0  # 默认值为0,避免Stop_loss_range为None时出现TypeError异常
            if Stop_loss_range is not None:
                stop_distance = Stop_loss_range  # 计算止损幅度
            # 止损、止盈和平仓
            if MACD_cross.get("deazhuangtai")=="下穿" or (stop_loss_price is not None and last_price <= stop_loss_price) or (stop_profit_price is not None and last_price >= stop_profit_price):
                if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]:
                    order = self.send(symbol=symbol, volume=position.pos_long, price=0, direction="SELL", offset="CLOSETODAY")
                else:
                    order = self.send(symbol=symbol, volume=position.pos_long, price=0, direction="SELL", offset="CLOSE")
                self.orders.pop(symbol, None)
                return
            # 金字塔加仓
            if profit > stop_distance * 1 and count < self.max_pyramid_count and MACD_cross.get("zhuangtai")=="金叉":
                self.pyramid_open(symbol, "BUY", tick.LastPrice, volume, stop_loss_price, stop_profit_price, stop_distance, count)
            # 动态跟踪止损
            if stop_loss_price is not None and profit > stop_distance * 3:
                stop_loss_price = max(stop_loss_price, last_price - stop_distance)
                if stop_loss_price != self.orders[symbol]["stop_loss_price"]:
                    self.orders[symbol]["stop_loss_price"] = stop_loss_price
        elif position.pos_short > 0 and stop_loss_price is not None:
            profit = position.float_profit_short / position.pos_short  # 计算当前持仓盈亏
            stop_distance = Stop_loss_range  # 计算止损幅度
            if Stop_loss_range is not None:
                stop_distance = Stop_loss_range  # 计算止损幅度
            # 止损、止盈和平仓
            if MACD_cross.get("deazhuangtai")=="上穿" or (stop_loss_price is not None and last_price >= stop_loss_price) or (stop_profit_price is not None and last_price <= stop_profit_price):
                if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]:
                    order = self.send(symbol=symbol, volume=position.pos_short, price=0, direction="BUY", offset="CLOSETODAY")
                else:
                    order = self.send(symbol=symbol, volume=position.pos_short, price=0, direction="BUY", offset="CLOSE")
                self.orders.pop(symbol, None)
                return
            # 金字塔加仓
            if profit > Stop_loss_range * 1 and count < self.max_pyramid_count and  MACD_cross.get("zhuangtai")=="死叉":
                self.pyramid_open(symbol, "SELL", tick.LastPrice, volume, stop_loss_price, stop_profit_price, Stop_loss_range, count)

            # 动态跟踪止损
            if stop_loss_price is not None and profit > stop_distance * 3:
                stop_loss_price = min(stop_loss_price, last_price + Stop_loss_range)
                if stop_loss_price != self.orders[symbol]["stop_loss_price"]:
                    self.orders[symbol]["stop_loss_price"] = stop_loss_price
        print(position.json)

class kdj(obj):
    def __init__(self):
        super().__init__()
        self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"]   # 订阅合约 
        # self.codelist = ["IF2403"]
        self.objtype = objtype.bar
        self.dete = dete.time3
    def get_volume(self,code):
        quote = self.get_quote(code)
        available = self.get_account().balance #静态权益
        multiplier = quote.VolumeMultiple*quote.LastPrice
        max_open = available * 0.1
        # 计算最大开仓手数
        max_volume = int(max_open / multiplier)
        if max_volume <= 0:
            max_volume = 1
        else:
            max_volume = max_volume
        return max_volume

    def on_bar(self, bar, tick: Tick_Data):
        if len(bar)<10:
            return
        kdj = self.KDJ(bar)
        xh = self.XH(kdj.K,kdj.D)
        position = self.get_pos(tick.code)
        print(xh,tick.LastPrice)
        
        # 止损止盈逻辑
        if position.pos_long > 0:
            stop_loss = position.open_price_long - tick.PriceTick*9  # 设置止损价为成本价-3最小变动价
            if tick.LastPrice <= stop_loss:
                self.send(symbol=tick.code, volume=position.pos_long, price=tick.BidPrice1, direction="SELL", offset="CLOSE")
            else:
                take_profit = position.open_price_long +  tick.PriceTick*3  # 设置止盈价为成本价+9最小变动价
                if tick.LastPrice >= take_profit:
                    self.send(symbol=tick.code, volume=position.pos_long, price=tick.AskPrice1, direction="SELL", offset="CLOSE")
        elif position.pos_short > 0:
            stop_loss = position.open_price_short +  tick.PriceTick*9  # 设置止损价为成本价+3最小变动价
            if tick.LastPrice >= stop_loss:
                self.send(symbol=tick.code, volume=position.pos_short, price=tick.AskPrice1, direction="BUY", offset="CLOSE")
            else:
                take_profit = position.open_price_short -  tick.PriceTick*3  # 设置止盈价为成本价-9最小变动价
                if tick.LastPrice <= take_profit:
                    self.send(symbol=tick.code, volume=position.pos_short, price=tick.BidPrice1, direction="BUY", offset="CLOSE")
        
        # 金叉死叉逻辑
        if position.pos_long <= 0 and position.pos_short <= 0 and xh == '金叉':
            self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="OPEN")
        if position.pos_long <= 0 and position.pos_short <= 0 and xh == "死叉":
            self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="OPEN")
        # if position.pos_long > 0 and xh == '死叉':
        #     self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="CLOSE")
        #     self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="OPEN")
        # if position.pos_short > 0 and xh == '金叉':
        #     self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="CLOSE")
        #     self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="OPEN")
        
        position = self.get_pos(tick.code)
        print("合约持仓数据: ",position.json)
        print("账户平仓盈亏: ",self.get_account().close_profit)
class 砖型策略(obj):  # 定义一个名为砖型策略的类,继承自obj类
    def __init__(self):  # 初始化方法
        super().__init__()  # 调用父类的初始化方法
        self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"]   # 订阅合约列表
        self.objtype = objtype.renko  # 策略类型设置为renko,默认为tick
        self.renko_tick = 1   # 设定砖型幅度,默认合约10,最小变动价
    def on_bar(self, bar, tick: Tick_Data):  # on_bar方法,在每根K线更新时被调用
        print(tick.LastPrice)  # 打印最新tick的价格
        if len(bar) < 2:  # 如果bar的长度小于2,则返回
            return
        kline = bar[-1]  # 获取最新的砖型数据
        position = self.get_pos(tick.code)  # 获取指定合约的持仓信息
        if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "上涨":  # 如果是空仓,且连续两个上涨砖,则开多单
            print("砖型图策略开多单")
            self.insert_order(tick.code, 1, tick.AskPrice1, DirectionType.Buy, OffsetType.Open)  # 开多单
        if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "下跌":  # 如果是空仓,且连续两个下跌砖,则开空单
            print("砖型图策略开空单")
            self.insert_order(tick.code, 1, tick.BidPrice1, DirectionType.Sell, OffsetType.Open)  # 开空单
        if position.pos_long > 0 and position.long_pos_frozen == 0 and kline["Renko"] == "下跌":  # 如果有多单,最新砖下跌,上一砖是上涨,则平多单开空单
            print("砖型图策略平多单并开空")
            if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]:  # 判断是否为上期所和能源所今仓
                self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.CloseToday)  # 多头平今
            else:
                self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.Close)  # 多头平仓
        if position.pos_short > 0 and position.short_pos_frozen == 0 and kline["Renko"] == "上涨":  # 如果有空单,最新砖上涨,上一砖是下跌,则平空单开多单
            print("砖型图策略平空单并开多")
            if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]:  # 判断是否为上期所和能源所今仓
                self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open)  # 空头平今
            else:
                self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open)  # 空头平仓
        Account = self.get_account()
        print(Account.close_profit) #获取账号状态并打印平仓盈亏
        print(Account.commission) #获取账号状态并打印手续费
class zszy(obj):  # 定义一个名为zszy的类,继承自obj类
    def __init__(self):  # 初始化方法
        super().__init__()  # 调用父类的初始化方法
        self.codelist = ["IC2403"]  # 存储合约代码列表
        self.objtype = objtype.tick  # 设置对象类型为tick
        self.zs = -500  # 止损条件,浮动盈亏小于该值时进行平仓
        self.zy = 1500  # 止盈条件,浮动盈亏大于该值时进行平仓
    def on_tick(self, tick: Tick_Data, code):  # on_tick方法,在每根K线更新时被调用
        all_pos = self.get_pos()  # 获取所有持仓信息
        for pos in all_pos.values():  # 遍历所有持仓
            if pos.pos_long == 0 and pos.pos_short == 0:  # 如果该合约没有持仓,则跳过本次循环
                continue
            if pos.pos_long > 0 and (pos.float_profit_long < self.zs or pos.float_profit_long > self.zy):  # 如果多单达到了止损或者止盈条件
                self.send(pos.symbol, abs(pos.pos_long), pos.last_price, DirectionType.Sell, OffsetType.Close)  # 发送平仓指令
            elif pos.pos_short > 0 and (pos.float_profit_short < self.zs or pos.float_profit_short > self.zy):  # 如果空单达到了止损或者止盈条件
                self.send(pos.symbol, abs(pos.pos_short), pos.last_price, DirectionType.Buy, OffsetType.Close)  # 发送平仓指令
            print(f"{pos.symbol} close_profit: {pos.close_profit}")  # 输出该合约的平仓盈亏信息

t = TMS()
# t.add_obj(macd())
# t.add_obj(kdj())
t.add_obj(砖型策略())
# t.add_obj(zszy())
t.run()
  • 8
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
CPPi策略是一种基于资产管理的投资策略,其全称为Constant Proportion Portfolio Insurance(恒定比例投资组合保险),主要是为了在投资中实现资产保值和增值的双重目标。 在Python实现CPPi策略,我们可以通过以下步骤: 1. 设置初始投资组合比例:首先,我们需要确定投资组合中股票和保险资产的比例。这个比例可以根据个人风险承受能力和预期收益进行调整。 2. 获取市场数据:使用Python的金融数据包,如pandas和yfinance,获取所需股票和保险资产的历史价格数据。 3. 计算保险金额:根据CPPi策略,投资组合中根据保险基金的规模确定保险金额,即总投资额减去保险基金投资的金额。 4. 计算投资组合价值:根据历史价格数据和初始投资组合比例,计算每个周期投资组合的价值。 5. 根据保险金额调整投资组合比例:根据保险金额和投资组合的价值,计算投资组合中股票和保险资产的比例。如果投资组合价值低于保险金额,则将股票资产的比例降低,增加保险资产的比例;反之亦然。 6. 重新平衡投资组合:根据调整后的投资组合比例,卖出或购买相应的股票或保险资产,以保持投资组合比例不变。 通过上述步骤,我们可以实现CPPi策略Python代码。通过对历史数据的分析和实时调整,我们可以保持投资组合的保值和增值目标,以最大程度地满足投资者的需求和风险偏好。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

投图匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值