写在前面的话
这个小项目是笔者的一个面试题,作者之前在学习量化战略的时分,喜爱完成一些战略,许多并未安置到币安实盘,可是这个项目是安置到币安上的项目,确实给我带来了一些挑战,不过也从中学到了不少东西,先学了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()
