币安合约网格策略实盘框架v1【python数字货币量化_21精华帖_策略第29篇】

显示全部楼层 · 2023-8-5 23:49:19

网格策略的逻辑很简洁，由于交易频繁，它可能是一个有利于刷返佣的策略，最近翻阅资料尝试将基于币安交易所的合约网格实盘代码敲了出来，供大家参考
网格策略的逻辑

网格策略的逻辑很简单：低买高卖。
假设某个标的目前1000元，那么我在999元处挂个买单，1001元处挂个卖单，价格波动一下：从1000元-->999元-->1001元，那么我就赚到了2块钱。
如果我挂单频率够高，价格也如我所愿地来回波动，那么我就不断地能赚到这2块钱。
当然，任何策略都有风险，网格策略的风险也很明显：如果遇到单边大行情，比如价格一路下跌到900元，我999元挂的买单成交后，价格再也没有涨上来过，我就被套了。
基于币安合约api实现的网格实盘代码

每个人可能对网格策略的理解不一样，我描述一下我的实现逻辑：
1. 获取某个标的当前的价格，并在当前价格下方x%处，挂一个买单，在当前价格上方x%处，挂一个卖单（价差是2*x%）；
2. 等待某个挂单成交后，同上一步一样，在成交价上下方x%处挂卖单和买单；
3. 价格不断波动，程序不断收割这个价差（2*x%）。
为实现以上逻辑，有几点需要注意：
· 币安合约挂单成交的手续费为0.02%，所以理论上x应该>0.02%，否则没有利润空间；
· 价格不断波动，程序会不断挂单，很可能出现同一个价位，有多个挂单，我的做法是撤销同价位的挂单，保证每个价位只有一个挂单；
· 为避免亏损，单个方向的挂单量不得超过max_orders（我个人设为3）；
· 即使设定了最大挂单量，还是有较大风险，因为虽然挂单量有限制，但是不断下跌就会不断买（只是买完后再挂买单的数量不会太多），所以我设了网格上下限，比如当前价格为20u，我设定网格范围为[18,22]，一旦价格波动太大，不在这个[18,22]的范围内，程序就撤单不再交易了，等待价格回到网内再继续执行网格逻辑（注意，只是撤单，现有仓位不平，等待解套）。
· 我是用上一次的成交价来计算新的挂单价格的：最新挂单价 = 上一次成交价 +- x%，如果网格执行周期比较长（程序默认为30s执行一次），价格波动又较大时，我的挂单可能会变成吃单，手续费会增加，所以在计算下单价格的时候，我会判断一下上一次的成交价与当前盘口的价格，避免maker变taker。
程序的配置文件config.ini：

代码主要逻辑：
def grid(exchange, symbol, gap_percent, quantity, pricePrecision, max_orders, grid_up, grid_down, buy_orders, sell_orders):

# 用于存放已在交易所挂单的订单信息
buy_orders = buy_orders
sell_orders = sell_orders

# 获取当前买一卖一价
bid_price, ask_price = get_bid_ask_price(exchange, symbol)
print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 当前ask_price: {ask_price} bid_price: {bid_price}')

# 判断是否还在网内，如果破网则撤单，不执行网格逻辑，直到价格回到网内
if bid_price > grid_up or ask_price < grid_down:

      # 撤掉目前所有挂单
      cancel_open_orders(exchange, symbol)
      buy_orders = []
      sell_orders = []
      print('破网！已撤销所有挂单，等待价格回归至网内继续交易。')
      print(f'grid_up: {grid_up}    grid_down: {grid_down}')
      print(f'ask_price: {ask_price}  bid_price: {bid_price}')

      return buy_orders, sell_orders

buy_orders.sort(key=lambda x: float(x['price']), reverse=True) # 按价格高到底排序（高价更容易成交）
sell_orders.sort(key=lambda x: float(x['price']), reverse=False) # 按价格低到高排序（低价更容易成交）

# 若buy_orders已记录有买单，逐个检查是否有最新成交
for buy_order_info in buy_orders:

      # 获取该订单当前最新状态
      order_info = get_order_info(exchange, symbol, buy_order_info.get('orderId'))

      # 若订单当下已成交
      if order_info.get('status') == 'FILLED':
         final_price = float(order_info.get('price'))
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} {symbol}买单成交了，买单价为{final_price}')

         # 成交后，从buy_orders中删除
         # 注意remove的是buy_order_info而不是order_info
         # order_info是成交后的buy_order_info
         buy_orders.remove(buy_order_info)

         # 买单成交，挂上一格的卖单
         sell_price = final_price * (1 + gap_percent)
         sell_price = round(sell_price, pricePrecision) # 处理价格精度

         # 防止新计算的sell_price比当前ask低
         # （如果网格运行时间间隔较长会出现该情况，因为新挂单价是由上一个成交价决定的，从成交到现在价格可能已经大幅波动了）
         if sell_price < ask_price:
            # 如果新计算的sell_price比当前ask低，以ask挂卖单，防止挂单变吃单
            sell_price = round(ask_price, pricePrecision)

         # 挂新卖单
         new_sell_order_info = place_order(exchange, symbol, 'SELL', quantity, sell_price)
         # 挂单成功后
         if new_sell_order_info.get('orderId'):
            # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 买单成交，根据成交价挂上一格卖单: {new_sell_order_info.get("symbol")} | price: {new_sell_order_info.get("price")} | qty: {new_sell_order_info.get("origQty")} | orderId: {new_sell_order_info.get("orderId")}')
            print_order(new_sell_order_info, '买单成交，根据成交价挂上一格卖单')
            # 新的卖单加入到sell_orders中
            sell_orders.append(new_sell_order_info)

         # 买单成交，挂下一格的买单（挂更便宜的买单）
         buy_price = final_price * (1 - gap_percent)
         buy_price = round(buy_price, pricePrecision) # 处理价格精度

         # 防止新计算的buy_price比当前bid高
         # （如果网格运行时间间隔较长会出现该情况，因为新挂单价是由上一个成交价决定的，从成交到现在价格可能已经大幅波动了）
         if buy_price < bid_price:
            # 如果新计算的buy_price比当前bid高，以bid挂买单，防止挂单变吃单
            sell_price = round(ask_price, pricePrecision)

         # 挂新买单
         new_buy_order_info = place_order(exchange, symbol, 'BUY', quantity, buy_price)
         # 挂单成功后
         if new_buy_order_info.get('orderId'):
            # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 买单成交，根据成交价挂下一格买单: {new_buy_order_info.get("symbol")} | price: {new_buy_order_info.get("price")} | qty: {new_buy_order_info.get("origQty")} | orderId: {new_buy_order_info.get("orderId")}')
            print_order(new_buy_order_info, '买单成交，根据成交价挂下一格买单')
            # 新的卖单加入到sell_orders中
            buy_orders.append(new_buy_order_info)

      elif order_info.get('status') == 'CANCELED':
         # 订单被取消，从buy_orders中删除
         buy_orders.remove(buy_order_info)

      elif order_info.get('status') == 'NEW':
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 买单尚未成交，挂单价{order_info.get("price")}')

      else:
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 买单当前状态为{order_info.get("status")}')

# 若sell_orders已记录有卖单，逐个检查是否有最新成交
for sell_order_info in sell_orders:

      # 获取该订单当前最新状态
      order_info = get_order_info(exchange, symbol, sell_order_info.get('orderId'))

      # 若订单当下已成交
      if order_info.get('status') == 'FILLED':
         final_price = float(order_info.get('price'))
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} {symbol}卖单成交了，卖单价为{final_price}')

         # 成交后，从buy_orders中删除
         # 注意remove的是sell_order_info不是order_info
         # order_info是成交后的sell_order_info
         sell_orders.remove(sell_order_info)

         # 卖单成交，挂下一格的买单
         buy_price = final_price * (1 - gap_percent)
         buy_price = round(buy_price, pricePrecision) # 处理价格精度

         # 防止新计算的buy_price比当前bid高
         #（如果网格运行时间间隔较长会出现该情况，因为新挂单价是由上一个成交价决定的，从成交到现在价格可能已经大幅波动了）
         if buy_price < bid_price:
            # 如果新计算的buy_price比当前bid高，以bid挂买单，防止挂单变吃单
            sell_price = round(ask_price, pricePrecision)

         # 挂新买单
         new_buy_order_info = place_order(exchange, symbol, 'BUY', quantity, buy_price)
         # 挂单成功后
         if new_buy_order_info.get('orderId'):
            # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 卖单成交，根据成交价挂下一格买单: {new_buy_order_info.get("symbol")} | price: {new_buy_order_info.get("price")} | qty: {new_buy_order_info.get("origQty")} | orderId: {new_buy_order_info.get("orderId")}')
            print_order(new_buy_order_info, '卖单成交，根据成交价挂下一格买单')
            # 新的买单加入到buy_orders中
            buy_orders.append(new_buy_order_info)

         # 卖单成交，挂上一格的卖单（挂更高价的卖单）
         sell_price = final_price * (1 + gap_percent)
         sell_price = round(sell_price, pricePrecision) # 处理价格精度

         # 防止新计算的sell_price比当前ask低
         # （如果网格运行时间间隔较长会出现该情况，因为新挂单价是由上一个成交价决定的，从成交到现在价格可能已经大幅波动了）
         if sell_price < ask_price:
            # 如果新计算的sell_price比当前ask低，以ask挂卖单，防止挂单变吃单
            sell_price = round(ask_price, pricePrecision)

         # 挂新买单
         new_sell_order_info = place_order(exchange, symbol, 'SELL', quantity, sell_price)
         # 挂单成功后
         if new_sell_order_info.get('orderId'):
            # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 卖单成交，根据成交价挂上一格卖单: {new_sell_order_info.get("symbol")} | price: {new_sell_order_info.get("price")} | qty: {new_sell_order_info.get("origQty")} | orderId: {new_sell_order_info.get("orderId")}')
            print_order(new_sell_order_info, '卖单成交，根据成交价挂上一格卖单')
            # 新的卖单加入到sell_orders中
            sell_orders.append(new_sell_order_info)

      elif order_info.get('status') == 'CANCELED':
         # 订单被取消，从sell_orders中删除
         sell_orders.remove(sell_order_info)

      elif order_info.get('status') == 'NEW':
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 卖单尚未成交，挂单价{order_info.get("price")}')

      else:
         print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 卖单当前状态为{order_info.get("status")}')

################################################################

# 若当下没有挂买单 - 挂个买单
if not buy_orders:

      # 计算买单价格
      price = bid_price * (1 - gap_percent) # 按当前买一价的下一格，挂买单
      price = round(price, pricePrecision) # 处理价格精度

      # 下单
      buy_order_info = place_order(exchange, symbol, 'BUY', quantity, price)

      # 下单成功后
      if buy_order_info.get('orderId'):
         # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 当下没有买单，根据买一价挂单: {buy_order_info}')
         # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 当下没有买单，根据买一价挂单: {buy_order_info.get("symbol")} | price: {buy_order_info.get("price")} | qty: {buy_order_info.get("origQty")} | orderId: {buy_order_info.get("orderId")}')
         print_order(buy_order_info, '当下没有买单，根据买一价挂单')
         buy_orders.append(buy_order_info)

# 若当下没有挂卖单 - 挂个卖单
if not sell_orders:

      # 计算卖单价格
      price = ask_price * (1 + gap_percent) # 按当前卖一价的上一格，挂卖单
      price = round(price, pricePrecision) # 处理价格精度

      # 下单
      sell_order_info = place_order(exchange, symbol, 'SELL', quantity, price)

      # 下单成功后
      if sell_order_info.get('orderId'):
         # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 当下没有卖单，根据卖一价挂单: {sell_order_info}')
         # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 当下没有卖单，根据卖一价挂单: {sell_order_info.get("symbol")} | price: {sell_order_info.get("price")} | qty: {sell_order_info.get("origQty")} | orderId: {sell_order_info.get("orderId")}')
         print_order(sell_order_info, '当下没有卖单，根据卖一价挂单')
         sell_orders.append(sell_order_info)

################################################################

# 确保某个价位下，仅有一个买单
if buy_orders:
      buy_orders.sort(key=lambda x: float(x['price']), reverse=False) # 最低价到最高价
      delete_orders = []
      for i in range(len(buy_orders)-1):
         order = buy_orders! {  u2 h0 B/ n5 {5 j- Q3 O7 C
         next_order = buy_orders[i+1]
" z% ^' j  K1 a7 _: C          # 价差过小，即为重复订单. @) J6 s- ^- ?7 U1 h1 _
         if abs(float(next_order['price'])/float(order['price']) - 1) < 0.0001:
" F9 N! Z- ~' S  h# ?9 f) n             # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 有重复买单，撤销订单：{next_order.get("symbol")} | price: {next_order.get("price")} | qty: {next_order.get("origQty")} | orderId: {next_order.get("orderId")}')
4 v' r& q. a1 ^             print_order(next_order, '有重复买单，撤销订单')
, |1 l( P" I; t' k( h; J  d             # 撤单8 ~3 C( Z; c6 o  z- |
            cancel_order(exchange, symbol, next_order.get('orderId'))5 p: s9 k4 u2 F. o' G# X
            # 将next_order放入delete_orders，循环结束后再remove，否则会影响buy_orders的下标i
7 @; F. E# X$ ^- E             delete_orders.append(next_order)
5 J! L$ [# @, I( [
4 M. L. Z# Z8 M) L" d       # 将buy_orders中，价格重复的订单remove, X9 Q$ j4 e2 B0 \; ^+ ?, D
      for order in delete_orders:
" c# t& h8 X3 r          buy_orders.remove(order), k, Y6 O& |& g: ]8 D
2 E3 `) p, }+ P, g- C2 g# q

  |( {7 ^. F6 h5 M # 确保某个价位下，仅有一个卖单
+ S" N  [1 |6 U. r if sell_orders:
; N) y2 h, }% \       sell_orders.sort(key=lambda x: float(x['price']), reverse=True) # 最低价到最高价$ \+ ^+ h- O9 `3 p1 v2 z- {$ f
      delete_orders = []
: ?4 N3 C: E& \. N) Q! Z       for i in range(len(sell_orders)-1):
2 P: V0 P. @+ u' i# @          order = sell_orders. R2 y+ Q- \4 \( H) ]
         next_order = sell_orders[i+1]
, K' `* L# v% {  Z# B3 k          # 价差过小，即为重复订单# H0 e+ `3 `, o( y+ Z
         if abs(float(next_order['price'])/float(order['price']) - 1) < 0.0001:! ]) @' s  X9 H2 f1 N
            # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 有重复卖单，撤销订单：{next_order.get("symbol")} | price: {next_order.get("price")} | qty: {next_order.get("origQty")} | orderId: {next_order.get("orderId")}')
9 f- \4 |, G' N. }, p% L0 }             print_order(next_order, '有重复卖单，撤销订单')- w3 |% v# O" i9 s+ ^! Q
            # 撤单- m! Z7 C: }/ _- e1 P
            cancel_order(exchange, symbol, next_order.get('orderId'))5 C) \& G1 P) ]0 F* |% v% F
            # 将next_order放入delete_orders，循环结束后再remove，否则会影响buy_orders的下标i) C5 h, @& E  H/ }. P7 i# s% F
            delete_orders.append(next_order)
! f$ u( l( N: R0 ?, j& H8 [; w: _9 W1 q" H
      # 将buy_orders中，价格重复的订单remove
  b0 {  [. g8 A, t. v       for order in delete_orders:
1 ^! \4 ^0 Y8 z6 M) S          sell_orders.remove(order)
; S& O& w9 }* l2 C5 ~0 p9 r3 h: G5 _0 {6 E( l1 `( B
################################################################9 b6 L, K% m1 a9 f, @0 U8 l% Y( L% D, ^

( L4 [1 ?' k2 P5 n+ Q* j8 ]6 q& G$ Q3 f: x, ]6 ?4 }6 b' e5 P
# 如果当前买单挂单数大于设置量，则撤掉部分买单: H; b# E: B+ l5 e# {" A
if len(buy_orders) > max_orders:
; ?3 \5 j2 E# E! Y
) E/ ^! e; a1 b: A2 r& ^5 D       # 最低价到最高价
$ R+ r/ @! N9 M       buy_orders.sort(key=lambda x: float(x['price']), reverse=False)
6 |' n! b2 O+ M9 t. u( Q       # 取出最低价的买单1 [+ k, X5 C7 V8 {
      delete_order = buy_orders[0]
) M1 Q! W% S* m       # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 买单超过设置量{max_orders}，撤销最低价的买单：{delete_order}')* J; E5 \2 U$ W/ w4 z
      print_order(delete_order, f'买单超过设置量{max_orders}，撤销最低价的买单')6 K' r$ ^4 L) b+ k2 x
      # 撤单
+ h# M& \0 U% g) V% g/ Z       cancel_order(exchange, symbol, delete_order.get('orderId'))# z; v, ]0 [9 q1 H3 M
      # 从buy_orders移除
) O4 V+ P3 ~; D       buy_orders.remove(delete_order)# ?) F* S) H" u" r! I3 Z
) C5 m. [$ ^" q" A$ F2 ?
# 如果当前买单挂单数大于设置量，则撤掉部分买单& T3 H- V' e( E& P+ y$ x8 q
if len(sell_orders) > max_orders:9 Y: r% T5 w. d8 S6 N

2 y, e6 X5 U4 g8 d! Y& m4 T' _       # 最高价到最低价6 [, G. i: B) U- R2 m  w/ O5 ^
      sell_orders.sort(key=lambda x: float(x['price']), reverse=True)4 R) z& n: V3 w# @3 y
      # 取出最高价的卖单1 Q/ B$ {' n0 ^- B
      delete_order = sell_orders[0]
/ b' I: T) F. X* _# p; \       # print(f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} 卖单超过设置量{max_orders}，撤销最高价的卖单：{delete_order}')1 Q9 Y; u/ ~" U5 }) q
      print_order(delete_order, f'卖单超过设置量{max_orders}，撤销最高价的卖单')
" m  H7 l) _1 D9 m) ?       # 撤单" @3 X/ s. b* T
      cancel_order(exchange, symbol, delete_order.get('orderId'))
% x- J7 h% C# y* m4 l: o5 G" p$ F       # 从sell_orders移除) \2 w" _- o+ r. }2 }$ }1 v$ |
      sell_orders.remove(delete_order)0 k" y: E5 u6 x3 @& u' h3 h6 ^
: m' q" N0 t  Q  `. s* `+ |6 d
# return最新的buy_orders, sell_orders! L( D; r3 C* b/ {' L# _
sell_orders.sort(key=lambda x: float(x['price']), reverse=True)
$ @) _3 f% |( S) F buy_orders.sort(key=lambda x: float(x['price']), reverse=True)- R8 d' L/ z# L7 ~& F; d
print_orders(sell_orders)" r* r( k0 _' _: F8 [
print_orders(buy_orders)8 b5 f3 Z% `$ E' V2 K& H4 O
0 g* X2 {9 J: A
/ E: B+ w+ i$ g3 G4 P

9 [* w+ _+ F7 H2 r; P0 g return buy_orders, sell_orders所有代码可参考附件，往config.ini填入api后即可使用。
4 Q+ J; c  ]% f7 b7 u程序我100u小资金在LINKUSDT上测试了两天，没碰到什么大的单边行情，赚了1u…程序逻辑上貌似没有什么大问题~- m) m( D6 f1 l3 j! a5 C

8 g+ F, P; D0 `+ _' l) T+ r# m4 q5 u  l" ~. p. b  t
注意事项+ j$ C, y. q4 z. H1 H

. g; S3 w, d" Z% X· 码力微薄，可能有我没发现的bug，建议阅读代码理清逻辑后谨慎使用，我尽量每句代码都有注释；$ k/ T8 u; c& a7 p! v, L
· 程序有钉钉和微信两种报错方式，我暂时都注释掉了，大家可自行打开；
3 P$ |% B8 R/ n  |7 S! y! ?/ y5 x2 f· 网格可能是一个赚小钱亏大钱的策略，大家注意风险，网格范围设小一些。
! U" C2 p4 Q3 W% V7 I代码附件：, r% w* [% S+ }8 R2 Y( e
% q  W. C2 `8 d! C