币安挂单python实现
站长
· 阅读数 4
写在前面的话
这个小项目是笔者的一个面试题,作者之前在学习量化策略的时候,喜欢实现一些策略,很多并未部署到币安实盘,但是这个项目是部署到币安上的项目,确实给我带来了一些挑战,不过也从中学到了不少东西,先学了python异步编程,以及多线程.可能是因为作者的梯子设置有问题,所以没能真正运行起来,不过整体的逻辑完成了,因为网络的问题,没有进行调试,应该有很多业务上或者技术上的缺陷,但是我觉得随着以后的进步,这些肯定可以解决
自己对于量化交易很感兴趣,接到面试的时候,
我欣喜若狂,因为
我在想这会不会是一生中仅有的机会可以从事这个行业,
希望面试可以通过.
下面是我的项目解析
这里是一些必要的库,和很多需要的全局变量
import asyncio
import logging
import json
import websocket
from threading import Thread
from binance.lib.utils import config_logging
from binance.error import ClientError
from binance.websocket.um_futures.websocket_client import UMFuturesWebsocketClient
from websocket_client import BinanceWebsocketClient
from binance.um_futures import UMFutures
config_logging(logging, logging.DEBUG)
api_key = "vwE11TOZU5IHxXuXu0nZ4eIrNHLl0Pr5kWw59yDIGm5pK7k6X0DvExohpyZI"
api_secret = "OYLN7mk6iC7ypnV5UgKJj2BlnmsCzFBA6txxxrCbyI5HF7Liri0DbKssN"#密钥已经经过修改
symbol = "ETHUSDT"
start_order_amount = 100.0
max_order_amount = 1000.0
total_order_amount = 50000.0
price_move_limit = 0.1
price_margin_percent = 0.01
cancel_range_percentage=0.001
stop_loss_rate=0.01
buy_orders = []
sell_orders = []
global um_futures_client
global current_price
这里是止盈部分的代码,这里我参考了币安的文档,主要的逻辑是先获取账户信息,然后对于每一个仓位的盈利进行计算,然后进行止盈
async def stop_profit(current_price):
account_info = um_futures_client.account(recvWindow=6000)
positions = account_info['positions'][id]
for position in positions:
symbol = position['symbol']
position_size = float(position['positionAmt'])
unrealized_profit = float(position['unRealizedProfit'])
#对于每一个订单,只要盈利1%,那就可以平仓
if symbol == 'ETHUSDT' and position_size != 0:
# 计算订单盈利
profit_percent = (unrealized_profit /
(position_size * current_price)) * 100
if profit_percent >= 1.0 :#止盈
# 平仓
if position_size > 0:
await um_futures_client.new_order(
symbol=symbol,
side='SELL', # 平仓
type='MARKET',
quantity=abs(position_size)
)
else:
await um_futures_client.new_order(
symbol=symbol,
side='SELL', # 平仓
type='MARKET',
quantity=abs(position_size)
)
这里是止损部分的代码,止损是全仓止损,计算全仓的亏损,然后对于所有的订单进行平仓
async def stop_loss():
#注意是全仓亏损,所以这里的计算方式和止盈有所差别
account_info = um_futures_client.account(recvWindow=6000)#先获取账户信息
if account_info["totalUnrealizedProfit"]/account_info["totalInitialMargin"]>stop_loss_rate:
for position in positions:
if position_size > 0:
await um_futures_client.new_order(
symbol=symbol,
side='SELL', # 平仓
type='MARKET',
quantity=abs(position_size)
)
else:
await um_futures_client.new_order(
symbol=symbol,
side='SELL', # 平仓
type='MARKET',
quantity=abs(position_size)
)
这里是布置订单的接口,要从初始化的客户端调用新订单的布置,这里参考了GitHub上面的样例
async def place_order(side, price, amount):
try:
response = um_futures_client.new_order(
symbol=symbol,
side=side,
type="LIMIT",
quantity=amount,
timeInForce="GTC",
price=price,
)
logging.info(response)
except ClientError as error:
logging.error("Found error. status: {}, error code: {}, error message: {}".format(
error.status_code, error.error_code, error.error_message
))
这里是取消订单的接口,同样参考了github上面币安给的样例
async def cancel_orders(side, order_id):
try:
response = um_futures_client.cancel_order(
symbol=symbol, orderId=order_id, recvWindow=2000)
logging.info(response)
except ClientError as error:
logging.error("Found error. status: {}, error code: {}, error message: {}".format(
error.status_code, error.error_code, error.error_message
))
这里是订单控制,用于实现上下一共一百个订单的实现,作者思考这个函数花了很多的时间,可能还是有错误,但是应该基本上完善了,主要的逻辑就是把价格等分,然后上下价格设置订单,注意要把订单放在一个列表里面方便管理
sync def conduct_orders():
while True:
try:
scope = current_price * price_margin_percent
buy_price = current_price - scope
sell_price = current_price + scope
# 更新50买单
for i in range(1, 51):
order_price = buy_price - (scope * (25 - i) / 25)
order_amount = start_order_amount + \
i * (total_order_amount / 50)
order_amount = min(order_amount, max_order_amount)
buy_orders.append((order_price, order_amount))
# 更新50卖单
for i in range(1, 51):
order_price = sell_price + (scope * (i - 25) / 25)
order_amount = start_order_amount + \
(i - 25) * (total_order_amount / 50)
order_amount = min(order_amount, max_order_amount)
sell_orders.append((order_price, order_amount))
# 挂单
for order in buy_orders + sell_orders:
# IO等待
await place_order("BUY" if order in buy_orders else "SELL", order[0], order[1])
await asyncio.sleep(1)
except Exception as e:
print(f"Error conduct_orders: {e}")
这里也是非常核心的一段代码,目的是在什么情况下,进行订单的撤销,也就是行情波动的时候进行订单的撤销,业务逻辑上稍微有点复杂
async def delete_recent_orders():
while True:
try:
open_orders = await um_futures_client.get_open_orders("symbol",recvWindow=100)
if len(open_orders) > 0:
min_price = min(float(order["price"]) for order in open_orders)
max_price = max(float(order["price"]) for order in open_orders)
if max_price-min_price >= current_price*cancel_range_percentage:
# 撤销撤销千分之一范围内的订单
for order in open_orders:
if float(order["price"]) >= min_price and float(order["price"]) <= max_price:
# IO等待
await cancel_orders(order["side"], order["orderId"])#先撤单
await place_order(order["side"],order["price"],order['amount'])#再挂单
if max_price-min_price>=0.05*current_price:#我的理解是波动百分之五在万分之五的下面,如果大于百分之五,那么一定大于万分之5行情剧烈波动,假设为百分之五
#这时拉远最近的挂单距离
if(order["side"]=="buy"):#如果是买单那就假设向上拉百分之10
await place_order(order["side"],order["price"]*1.1,order["amount"])
if(order["side"]=="sell"):#如果是卖单,那就假设向下拉百分之10
await place_order(order["side"],order["price"]*0.9,order["amount"])
except Exception as e:
print(f"ERROR delete_recent_orders{e}")
await asynio.sleep(1)
回调函数,但是没有用到,
这里是一些回调函数,用于套接字的初始化,
def on_open():
data = {
"method": "SUBSCRIBE",
"params": [
"ethusdt@aggTrade",
"ethusdt@depth"
],
"id": 2
}
um_futures_client.send(data)
def on_close():
print('on close')
def message_handler(_, message):
print(message)
def on_error(error):
print(f"on error:{error}")
主函数的实现
作者在这一段纠结了好久到底该怎么样创建套接字websocket,试了很多方法,都无法链接url,可能是梯子的问题,也可能是自己对于websocket应用的不太熟练
def target1():
print("线程1运行")
# socket = 'wss://fstream.binance.com/ws'
# base_url = socket + '/ethusdt@trade'
# my_client = websocket.WebSocketApp(
# socket + '/ethusdt@trade', on_open=on_open, on_message=message_handler, on_close=on_close)
my_client = UMFuturesWebsocketClient(
on_open=on_open,
on_close=on_close,
on_message=message_handler,
on_error=on_error
) # 这里的url访问不了,我把梯子调成全局也不行
# 创建异步时间并运行
# my_client = BinanceWebsocketClient(
# base_url, on_open=on_open, on_close=on_close, on_error=on_error)
task = [conduct_orders(), delete_recent_orders()]
# 再写一个线程,进行平仓和止损的操作
# loop = asyncio.get_event_loop()
# loop.run_until_complete(asyncio.wait(task))py3.5
asyncio.run(task) # py3.7
def target2():
print("线程2运行")
task = [stop_profit(current_price),stop_loss()]
asyncio.run(task)
def main():
try:
um_futures_client = UMFutures(key=api_key, secret=api_secret)
current_price = um_futures_client.mark_price(symbol=symbol)
#这里我认为,止盈止损应该贯穿整个市场行情中,如果单线程的话,可能会发生止盈止损不及时的情况所以我用了两个线程,一个线程用来管理订单,一个用来止盈和止损
t1=Thread(target=target1)
t2=Thread(target=target2)
t2.start()
t1.start()
#回收两个线程的资源
except Exception as e:
t1.join()
t2.join()
#这里先启动止盈止损的线程,防止出现意外
if __name__ == '__main__':
main()