ianzeng123
Một cuộc thảo luận ngắn gọn về một số chiến lược lưới trong lĩnh vực tiền kỹ thuật số
0
660
Thị trường tiền điện tử mang đến một môi trường giao dịch độc đáo, tạo nên một kịch bản ứng dụng lý tưởng cho các chiến lược giao dịch lưới. So với thị trường tài chính truyền thống, lĩnh vực tiền điện tử hoạt động 24⁄7, với biến động giá liên tục và thường xuyên, tạo ra nhiều cơ hội chênh lệch giá cho các chiến lược lưới. Hơn nữa, các công cụ giao dịch chính như hợp đồng giao ngay và hợp đồng vĩnh viễn không có hạn chế về thời hạn, cho phép các nhà giao dịch nắm giữ vị thế trong dài hạn mà không phải lo lắng về rủi ro hết hạn hợp đồng. Hơn nữa, tính biến động cao và tính thanh khoản tương đối cao của thị trường tiền điện tử tạo điều kiện thuận lợi cho việc triển khai các chiến lược lưới.
Chính nhờ những đặc điểm này mà các chiến lược giao dịch lưới thể hiện tính ứng dụng cao và tiềm năng sinh lời mạnh mẽ trên thị trường tiền điện tử. Giao dịch lưới là một chiến lược được sử dụng rộng rãi trên thị trường tiền điện tử, cho phép các nhà giao dịch kiếm lời từ sự biến động của thị trường mà không cần phải dự đoán hướng đi của thị trường. Bằng cách đặt lệnh mua và bán ở các khoảng giá khác nhau, giao dịch lưới giúp các nhà giao dịch thu được lợi nhuận trong cả thời điểm giá tăng và giảm.
Chiến lược giao dịch lưới có nhiều biến thể. Bài viết này sẽ chỉ thảo luận ngắn gọn một vài định dạng để giúp người mới bắt đầu với phương pháp giao dịch định lượng cổ điển này. Ý tưởng cốt lõi của chiến lược giao dịch lưới là đặt một loạt lệnh mua và bán ở các mức giá khác nhau. Lệnh mua được đặt khi giá đạt đến các nút dưới của lưới, và lệnh bán được đặt khi giá đạt đến các nút trên, nhờ đó kiếm được lợi nhuận nhỏ từ biến động thị trường. Ưu điểm của chiến lược này là các nhà giao dịch không cần phải dự đoán hướng đi của thị trường; họ dựa vào biến động giá thị trường trong lưới.
Nguyên tắc chiến lược lưới
Các yếu tố chính của giao dịch lưới truyền thống
- Các nút lưới:Mức giá đặt trước để đặt lệnh mua hoặc bán.
- Khoảng cách lưới:Khoảng cách giá giữa các nút lưới liền kề quyết định mức giá cần dao động để kích hoạt giao dịch.
- Kích thước lưới:Tổng số nút lưới kiểm soát phạm vi giá mà chiến lược bao phủ.
Chiến lược giao dịch lưới hoạt động như thế nào
- Khi giá tăng từ mức thấp và vượt qua nút lưới đã thiết lập, lệnh bán sẽ được kích hoạt.
- Khi giá giảm trở lại từ mức cao và phá vỡ nút lưới đã thiết lập, lệnh mua sẽ được kích hoạt.
- Bằng cách liên tục “mua thấp và bán cao” ở các phạm vi khác nhau, ngay cả khi giá dao động qua lại trong phạm vi đó, bạn vẫn có thể kiếm được lợi nhuận từ mỗi biến động.
Ví dụ
Giả sử một chiến lược lưới được thiết lập với khoảng giá lưới từ 8.000 đến 9.000 đô la, với khoảng giá lưới là 500 đô la. Khi giá tăng từ 8.000 đến 8.500 đô la, chiến lược sẽ mua ở mức 8.000 đô la và bán ở mức 8.500 đô la. Nếu giá tiếp tục tăng lên 9.000 đô la, chiến lược sẽ bán một phần cổ phiếu đang nắm giữ. Khi giá giảm từ 9.000 đến 8.500 đô la, chiến lược sẽ mua lại. Bằng cách lặp lại quy trình này, chiến lược có thể liên tục tích lũy lợi nhuận giữa những biến động của thị trường.
So sánh giữa Chiến lược giao dịch lưới và Chiến lược giao dịch cân bằng
Cốt lõi của một chiến lược cân bằng là duy trì tỷ lệ tài sản cố định, chẳng hạn như 50% tiền kỹ thuật số và 50% tiền pháp định. Khi giá của một loại tiền điện tử tăng và tỷ lệ tiền điện tử nắm giữ vượt quá 50%, nó sẽ được bán ra; khi giá giảm, nó sẽ được mua vào. Điều này đảm bảo giá trị của các tài sản nắm giữ luôn gần với tỷ lệ cố định. Bất kể biến động của thị trường, một chiến lược cân bằng luôn duy trì một lượng tiền điện tử nhất định.
Điểm giống và khác nhau giữa chiến lược lưới và chiến lược cân bằng
- Điểm tương đồng:Cả hai đều hưởng lợi từ sự biến động bằng cách mua thấp và bán cao, và chiến lược này có thể mang lại giá trị khi thị trường trở lại mức giá ban đầu.
- Sự khác biệt:Chiến lược lưới chỉ hoạt động trong một phạm vi giá được thiết lập trước, trong khi chiến lược cân bằng không phụ thuộc vào phạm vi giá cụ thể. Chiến lược lưới có thể không thể tiếp tục giao dịch nếu giá nằm ngoài phạm vi, trong khi chiến lược cân bằng cho phép mua và bán liên tục, duy trì thanh khoản.
Hợp đồng: Chiến lược lưới số học
Chiến lược lưới số học là một chiến lược giao dịch định lượng cổ điển thường được sử dụng trong các thị trường biến động. Chiến lược này nắm bắt lợi nhuận từ biến động giá bằng cách đặt lệnh mua và bán theo các khoảng giá cố định (khoảng số học). Chiến lược này phù hợp với các thị trường có biến động cao nhưng hướng đi khó đoán, chẳng hạn như tiền điện tử và một số hợp đồng tương lai.
Logic cốt lõi
Các khái niệm cốt lõi:
khoảng cách đều
Trong chiến lược lưới số học, có một khoảng cách giữa giá mua và giá bán.Khoảng giá cố định, nằm trong mãgridVí dụ, khi giá dao động 300 đơn vị (như trong mãgrid=300), lệnh mua hoặc bán được kích hoạt.Khởi tạo lưới
Chiến lược này tạo ra giá mua và giá bán ban đầu dựa trên giá hiện tại, đó làbuypVàsellpHai khoảng giá được dựa trên khoảng lướigridĐể thiết lập tương ứng trên và dưới giá hiện tạigridđơn vị.Chốt lời và đảo ngược
Khi giá tăng đến một phạm vi nhất định, chiến lược sẽ mua vào ở vùng vị thế mua và đặt lệnh bán để chốt lời. Nếu giá tiếp tục tăng đến vùng vị thế đảo chiều (upper), vị thế mua sẽ thu lợi nhuận và bán, và ngược lại.Quản lý vị trí trong lưới
Mỗi hành động mua hoặc bán trong lưới sẽ được kích hoạt khi giá đạt đến giá được cài đặt trướcbuyphoặcsellpSau mỗi giao dịch, hệ thống sẽ tự động điều chỉnh nhóm giá mua và giá bán tiếp theo để duy trì khoảng cách lưới cố định.Thêm và giảm vị trí
Chiến lược này liên tục điều chỉnh vị thế dựa trên giá lưới. Khi giá chạm điểm mua, nó sẽ tăng vị thế (tăng vị thế); khi giá chạm điểm bán, nó sẽ giảm dần vị thế (giảm vị thế). Bằng cách mua và bán liên tục, nó nắm bắt được mọi biến động nhỏ của thị trường.
Mã chiến lược
'''backtest
start: 2024-08-26 00:00:00
end: 2024-09-25 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2500}]
args: [["H",30],["n1",0.001],["grid",300],["bottom",50000]]
'''
# 交易参数配置（设为策略参数）
M = 20 # 杠杆大小
H = 50 # 初始底仓份数
n1 = 1 # 单个网格交易数量
grid = 200 # 单个网格交易间距
bottom = 35000 # 开多点位
upper = 60000 # 开空点位
def CancelPendingOrders():
orders = _C(exchanges[0].GetOrders)
if len(orders)>0:
for j in range(len(orders)):
exchanges[0].CancelOrder(orders[j].Id, orders[j])
j=j+1
def main():
exchange.SetContractType('swap')
exchange.SetMarginLevel(M)
currency=exchange.GetCurrency()
if _G('buyp') and _G('sellp'):
buyp=_G('buyp')
sellp=_G('sellp')
Log('读取网格价格')
else:
ticker=exchange.GetTicker()
buyp=ticker["Last"]-grid
sellp=ticker["Last"]+grid
_G('buyp',buyp)
_G('sellp',sellp)
Log('网格数据初始化')
while True:
account=exchange.GetAccount()
ticker=exchange.GetTicker()
position=exchange.GetPosition()
orders=exchange.GetOrders()
if len(position)==0:
if ticker["Last"]>upper:
exchange.SetDirection('sell')
exchange.Sell(-1,n1*H)
Log(currency,'到达开空区域,买入空头底仓')
else:
exchange.SetDirection('buy')
exchange.Buy(-1,n1*H)
Log(currency,'到达开多区域,买入多头底仓')
if len(position)==1:
if position[0]["Type"]==1: #持有空头仓位
if ticker["Last"]<bottom:
Log(currency,'空单全部止盈反手')
exchange.SetDirection('closesell')
exchange.Buy(-1,position[0].Amount)
else:
orders=exchange.GetOrders()
if len(orders)==0:
exchange.SetDirection('sell')
exchange.Sell(sellp,n1)
exchange.SetDirection('closesell')
exchange.Buy(buyp,n1)
if len(orders)==1:
if orders[0]["Type"]==1: #止盈成交
Log(currency,'网格减仓,当前份数:',position[0].Amount)
CancelPendingOrders()
buyp=buyp-grid
sellp=sellp-grid
LogProfit(account["Balance"])
if orders[0]["Type"]==0:
Log(currency,'网格加仓,当前份数:',position[0].Amount)
CancelPendingOrders()
buyp=buyp+grid
sellp=sellp+grid
LogProfit(account["Balance"])
if position[0]["Type"]==0:
if ticker["Last"]>float(upper):
Log(currency,'多单全部止盈反手')
exchange.SetDirection('closebuy')
exchange.Sell(-1,position[0].Amount)
else:
orders=exchange.GetOrders()
if len(orders)==0:
exchange.SetDirection('buy')
exchange.Buy(buyp,n1)
exchange.SetDirection('closebuy')
exchange.Sell(sellp,n1)
if len(orders)==1:
if orders[0]["Type"]==0: #止盈成交
Log(currency,'网格减仓,当前份数:',position[0].Amount)
CancelPendingOrders()
buyp=buyp+grid
sellp=sellp+grid
LogProfit(account["Balance"])
if orders[0]["Type"]==1:
Log(currency,'网格加仓,当前份数:',position[0].Amount)
CancelPendingOrders()
buyp=buyp-grid
sellp=sellp-grid
LogProfit(account["Balance"])
Chiến lược lưới số học có tính ứng dụng đáng kể trong thị trường tiền điện tử, đặc biệt là trong những thị trường biến động nhưng khó lường. Bằng cách đặt lệnh mua và bán theo các khoảng giá cố định, chiến lược này nắm bắt hiệu quả biến động thị trường trong khi vẫn duy trì hoạt động tự động và logic đơn giản. Tính biến động cao của thị trường tiền điện tử tạo cơ hội tốt cho chiến lược này phát triển mạnh mẽ.
Cần lưu ý rằng chi phí giao dịch của chiến lược lưới số học chủ yếu đến từ các lệnh mua và bán thường xuyên, thay vì việc đặt hoặc hủy chúng. Đặc điểm này đòi hỏi sự chú ý đặc biệt đối với các sàn giao dịch tiền điện tử có phí giao dịch cao. Để tối ưu hóa lợi nhuận, nên chọn các sàn giao dịch có phí thấp hơn và điều chỉnh khoảng thời gian lưới và tỷ lệ phân bổ vốn dựa trên các điều kiện thị trường cụ thể.
Nhìn chung, chiến lược lưới số học rất phù hợp với thị trường tiền điện tử biến động mạnh, nhưng có thể chịu rủi ro đáng kể trong các thị trường đơn phương. Bằng cách thiết lập các thông số phù hợp và tối ưu hóa quản lý quỹ, tính vững chắc và lợi nhuận của chiến lược có thể được cải thiện hiệu quả.
Điểm nổi bật: Chiến lược lưới động
Chiến lược lưới độngKhác với chiến lược lưới cố định truyền thống, nóTạo độngVàĐiều chỉnh các nút lướiChiến lược này cho phép linh hoạt hơn trước những biến động của thị trường. Chiến lược này tạo ra các nút lưới mới dựa trên biến động thị trường theo thời gian thực, cải thiện khả năng thích ứng và kiểm soát rủi ro của chiến lược. Khái niệm cốt lõi là chỉ tạo ra các nút lưới mới khi biến động giá vượt quá một ngưỡng nhất định và quản lý vị thế một cách phù hợp.
Các tính năng cốt lõi
Tạo nút lưới động：
- Giá thị trường vượt qua nút lưới trước đó và phạm vi biến động vượt quá phạm vi được đặt trước (bằng
_GridPointDiskiểm soát), chiến lược này tạo ra các nút lưới mới. - Mỗi nút lưới ghi lại thông tin giá và vị trí hiện tại và thiết lập các điều kiện đóng (bằng
_GridCovDisChênh lệch đóng cửa được kiểm soát).
- Giá thị trường vượt qua nút lưới trước đó và phạm vi biến động vượt quá phạm vi được đặt trước (bằng
Hoạt động mua và bán：
- Hướng dài（
direction = 1): Khi giá tăng và vượt qua nút lưới, hãy bán tài sản bạn đang nắm giữ; khi giá giảm trở lại, hãy mua lại. - Hướng ngắn（
direction = -1): Khi giá giảm và vượt qua nút lưới, hãy mua tài sản; khi giá phục hồi, hãy bán tài sản đang nắm giữ.
- Hướng dài（
Hoạt động đóng cửa：
- Khi giá đạt đến giá đóng cửa đã thiết lập (
_GridCovDisĐặt), thực hiện các hoạt động mua lại (khi mua dài hạn) hoặc bán (khi bán ngắn hạn) theo hướng hiện tại để hoàn tất việc đóng vị thế.
- Khi giá đạt đến giá đóng cửa đã thiết lập (
Kiểm soát số lượng lưới：
- Nếu số lượng nút lưới vượt quá giá trị cài đặt tối đa (
_GridNum), chiến lược này sẽ tự động xóa nút lưới sớm nhất, do đó ngăn ngừa các vị trí quá mức và giảm thiểu rủi ro.
- Nếu số lượng nút lưới vượt quá giá trị cài đặt tối đa (
Logic cốt lõi
Tham số khởi tạo：
_GridNum: Số lượng nút lưới tối đa, số lượng nút lưới tối đa mà chiến lược điều khiển cho phép giữ cùng một lúc._GridPointAmount: Số lượng đặt hàng của mỗi nút lưới._GridPointDis: Khoảng cách giá giữa các nút lưới._GridCovDis: Chênh lệch giá khi đóng một vị thế. Khi biên độ dao động giữa giá thị trường và giá lưới vượt quá chênh lệch giá này, vị thế sẽ bị đóng.
Hàm UpdateGrid：
- Dựa trên giá hiện tại (
current_price), giá mua (bids_price) và giá bán (asks_price) cập nhật các nút lưới. Bất cứ khi nào giá thị trường vượt qua một nút lưới, chiến lược sẽ tạo ra một nút lưới mới và thực hiện giao dịch tương ứng. - Kiểm tra xem điều kiện đóng có được kích hoạt hay không và thực hiện thao tác đóng khi được kích hoạt.
- Kiểm soát số lượng nút lưới tối đa. Nếu vượt quá số lượng tối đa, các nút lưới cũ nhất sẽ bị xóa.
- Dựa trên giá hiện tại (
Vòng lặp chính：
mainChức năng này liên tục thu thập dữ liệu giá thị trường theo thời gian thực và các cuộc gọiUpdateGridCác chức năng cập nhật các nút lưới và thực hiện các hoạt động giao dịch.- vượt qua
LogStatusGhi lại trạng thái lưới hiện tại, thông tin tài khoản, v.v. để tạo điều kiện theo dõi hoạt động chiến lược theo thời gian thực.
Mã chiến lược (yêu cầu tham chiếu mẫu vẽ và điểm Python)
'''backtest
start: 2024-04-01 00:00:00
end: 2024-09-23 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"ETH_USDT"}]
'''
direction = 1 # 网格方向：1表示向上，-1表示向下
_GridNum = 10 # 网格节点数量
_GridPointAmount = 0.1 # 每个网格节点的下单量
_GridPointDis = 100 # 网格节点之间的价格间距
_GridCovDis = 150 # 平仓价与网格节点的差距
_Grid = [] # 网格数据列表
def UpdateGrid(nowBidsPrice, nowAsksPrice, direction): # up 1, down -1
global _Grid
# 检查是否需要创建新的网格节点
if len(_Grid) == 0 or (direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis) or \
(direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis):
if len(_Grid) == 0:
Log('策略起始')
if len(_Grid) != 0 and direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis:
Log('向上突破，突破阈值：', nowBidsPrice - _Grid[-1]['price'])
if len(_Grid) != 0 and direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis:
Log('向下突破，突破阈值：', _Grid[-1]['price'] - nowAsksPrice)
# 根据方向决定当前网格节点的价格
nowPrice = nowBidsPrice if direction == 1 else nowAsksPrice
_Grid.append({
'price': nowPrice if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction,
'hold': {'price': 0, 'amount': 0},
'coverPrice': (nowPrice - direction * _GridCovDis) if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction - direction * _GridCovDis
})
Log('网格更新数量：', len(_Grid), '网格最新增添：', _Grid[-1])
# 下单操作，向上突破时卖出，向下突破时买入
tradeInfo = ext.Sell(_GridPointAmount) if direction == 1 else ext.Buy(_GridPointAmount)
_Grid[-1]['hold']['price'] = tradeInfo['price']
_Grid[-1]['hold']['amount'] = tradeInfo['amount']
Log('网格操作：', '向上卖出' if direction == 1 else '向下买入')
# 检查是否需要平仓
if len(_Grid) > 0 and (
(direction == 1 and nowAsksPrice < _Grid[-1]['coverPrice']) or
(direction == -1 and nowBidsPrice > _Grid[-1]['coverPrice'])):
coverInfo = ext.Buy(_Grid[-1]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[-1]['hold']['amount'])
Log('价格跌破平仓价格，买入，去除最后添加网格' if direction == 1 else '价格突破平仓价格，卖出，去除最后添加网格')
_Grid.pop() # 移除已平仓的网格节点
# 如果网格数量超出设定值，则平掉最早的网格节点
elif len(_Grid) > _GridNum:
coverFirstInfo = ext.Buy(_Grid[0]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[0]['hold']['amount'])
Log('网格数量过多，买入操作，去除初始网格' if direction == 1 else '网格数量过多，卖出操作，去除初始网格')
_Grid.pop(0)
def main():
global _Grid
while True:
ticker = _C(exchange.GetTicker)
records = _C(exchange.GetRecords)
ext.PlotRecords(records, "kline")
UpdateGrid(ticker['Buy'], ticker['Sell'], direction)
# 记录当前网格状态
msg = ""
for grid in _Grid:
msg += str(grid) + "\n"
LogStatus(_D(), _C(exchange.GetAccount), "\n", "_Grid.length:", len(_Grid), "_GridNum:", _GridNum, "\n", msg)
Sleep(500)
Lưu ý:
- Để giúp mọi người hiểu được quy trình tạo lưới, nhiều chú thích được thêm vào mã, có thể xóa trong ứng dụng thực tế.
- Để thuận tiện cho việc giao dịch, chiến lược giao ngay sử dụng thư viện giao dịch mẫu giao ngay. Bạn có thể xem mã nguồn để tìm hiểu thêm.
- Khi áp dụng vào giao dịch thực tế, cần phải cải tiến theo đặc điểm của từng sàn giao dịch khác nhau.
Hợp đồng tương lai: Chiến lược lưới song hướng dài-ngắn
Chiến lược Lưới Song Hướng Dài-Ngắn là một biến thể lưới phức tạp hơn nhưng mạnh mẽ hơn, cho phép giao dịch đồng thời theo cả hướng mua và bán, tối đa hóa cơ hội lợi nhuận trong thị trường biến động. Về bản chất, chiến lược này tự động điều chỉnh vị thế dựa trên độ lệch giá so với giá ban đầu, đạt được một chiến lược thực sự trung lập với thị trường.
Các tính năng cốt lõi
- Cả chế độ dài và ngắn:Bất kể giá tăng hay giảm, chiến lược có thể thu được lợi nhuận bằng cách hoạt động theo hướng tương ứng
- Định vị động：Tính toán vị trí mục tiêu dựa trên tỷ lệ chênh lệch giá so với giá ban đầu
- Thứ tự lưới hai chiều: Đặt lệnh mua và bán cùng lúc để nắm bắt biến động giá theo cả hai hướng
- Kiểm soát rủi ro：Giảm thiểu rủi ro đơn phương thông qua quản lý vị thế hợp lý và kiểm soát lệnh
Chiến lược Logic
Logic cốt lõi của chiến lược này là xác định vị trí mục tiêu dựa trên mức độ lệch giữa giá và giá ban đầu:
- Khi giá tăng, vị thế mục tiêu là âm (bán khống) và giá càng tăng thì vị thế bán khống càng lớn.
- Khi giá giảm, vị thế mục tiêu là dương (long). Giá càng giảm, vị thế long càng lớn.
- Điều chỉnh dần vị trí thực tế đến vị trí mục tiêu thông qua việc thực hiện các lệnh lưới
Mã chiến lược
import time
import math
# 全局变量初始化
InitPrice = 800
Funding = 50000
# 策略参数（需要在策略页面设置）
pct = 5.0 # 网格间距百分比
value = 5000 # 每个网格的投入金额
Interval = 3 # 策略执行间隔（秒）
# 账户资产信息
assets = {
'USDT': {
'total_balance': 0,
'margin_balance': 0,
'margin': 0,
'unrealised_profit': 0
}
}
def init():
"""初始化策略"""
global symbol, Funding, base_currency
Log('交易模式：多空都做')
# 设置合约类型
exchange.SetContractType('swap')
# 获取交易币种
currency = exchange.GetCurrency()
symbol = currency # 保持原格式，如 "BTC_USDT"
base_currency = symbol.split('_')[0] # 获取基础币种，如 "BTC"
Log('交易币种：', symbol)
Log('基础币种：', base_currency)
swapcode = symbol + '.swap'
ticker = exchange.GetTicker(swapcode) # 回测系统需要
exchange_info = exchange.GetMarkets()
data = exchange_info.get(swapcode)
# 初始化资产信息
assets[base_currency] = {
'amount': 0,
'price': 0,
'hold_price': 0,
'price': 0,
'unrealised_profit': 0,
'leverage': 20,
'liquidation_price': 0,
'AmountPrecision': data['AmountPrecision'],
'PricePrecision': data['PricePrecision'],
'MinQty': data['MinQty']
}
# 撤销所有挂单
cancel_all_orders()
# 获取初始资金
account = exchange.GetAccount()
if account:
Funding = account.Balance + account.FrozenBalance
Log('初始资金：', Funding)
def calculate_grid_orders():
"""计算网格订单"""
if InitPrice == 0 or assets[base_currency]['price'] == 0:
return None
current_price = assets[base_currency]['price']
current_amount = assets[base_currency]['amount']
# 多空都做模式：根据价格变化计算目标持仓
price_change_ratio = (current_price - InitPrice) / InitPrice
target_amount = -price_change_ratio * (value / pct) / current_price
# 计算买卖价格
grid_spacing = current_price * (pct / 100) # 网格间距
buy_price = current_price - grid_spacing
sell_price = current_price + grid_spacing
# 计算订单数量
order_amount = value / current_price
return {
'buy_price': round(buy_price, assets[base_currency]['PricePrecision']),
'sell_price': round(sell_price, assets[base_currency]['PricePrecision']),
'buy_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
'sell_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
'target_amount': target_amount
}
def execute_strategy():
"""执行交易策略"""
# 计算网格订单
grid_info = calculate_grid_orders()
if not grid_info:
return
current_amount = assets[base_currency]['amount']
target_amount = grid_info['target_amount']
amount_diff = target_amount - current_amount
# 如果持仓偏离较大，先调整持仓
if abs(amount_diff) > assets[base_currency]['MinQty']:
cancel_all_orders()
Sleep(500)
# 判断需要的操作
if amount_diff > 0:
# 需要增加多头持仓或减少空头持仓
if current_amount >= 0:
# 当前是多头或空仓，直接开多
Log(f'当前持仓：{current_amount}，需要开多：{abs(amount_diff):.6f}')
open_position('LONG', assets[base_currency]['price'], abs(amount_diff))
else:
# 当前是空头，需要先平空再开多
if abs(amount_diff) <= abs(current_amount):
# 只需要平掉部分空仓
Log(f'当前空仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
safe_close_position(abs(amount_diff), assets[base_currency]['price'])
else:
# 需要平掉所有空仓，然后开多
Log(f'平掉所有空仓：{abs(current_amount):.6f}')
if safe_close_position(abs(current_amount), assets[base_currency]['price']):
Sleep(1000) # 等待平仓完成
# 更新持仓信息
update_account()
remaining_amount = abs(amount_diff) - abs(current_amount)
if remaining_amount > assets[base_currency]['MinQty']:
Log(f'开多剩余数量：{remaining_amount:.6f}')
open_position('LONG', assets[base_currency]['price'], remaining_amount)
elif amount_diff < 0:
# 需要增加空头持仓或减少多头持仓
if current_amount <= 0:
# 当前是空头或空仓，直接开空
Log(f'当前持仓：{current_amount}，需要开空：{abs(amount_diff):.6f}')
open_position('SHORT', assets[base_currency]['price'], abs(amount_diff))
else:
# 当前是多头，需要先平多再开空
if abs(amount_diff) <= current_amount:
# 只需要平掉部分多仓
Log(f'当前多仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
safe_close_position(abs(amount_diff), assets[base_currency]['price'])
else:
# 需要平掉所有多仓，然后开空
Log(f'平掉所有多仓：{current_amount:.6f}')
if safe_close_position(current_amount, assets[base_currency]['price']):
Sleep(1000) # 等待平仓完成
# 更新持仓信息
update_account()
remaining_amount = abs(amount_diff) - current_amount
if remaining_amount > assets[base_currency]['MinQty']:
Log(f'开空剩余数量：{remaining_amount:.6f}')
open_position('SHORT', assets[base_currency]['price'], remaining_amount)
# 检查是否需要重新挂网格单
orders = exchange.GetOrders()
if not orders or len(orders) < 2: # 多空都做模式需要2个订单
cancel_all_orders()
Sleep(500)
# 重新获取最新持仓信息
update_account()
current_amount = assets[base_currency]['amount']
# 挂买单和卖单（网格订单）
buy_amount = grid_info['buy_amount']
sell_amount = grid_info['sell_amount']
# 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
place_grid_orders(current_amount, grid_info, buy_amount, sell_amount)
def place_grid_orders(current_amount, grid_info, buy_amount, sell_amount):
"""放置网格订单 - 多空都做模式"""
Log(f'放置网格订单 - 当前持仓：{current_amount}')
# 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
Log(f'多空都做模式 - 挂开多单：数量={buy_amount:.6f}，价格={grid_info["buy_price"]}')
open_position('LONG', grid_info['buy_price'], buy_amount)
Sleep(200)
Log(f'多空都做模式 - 挂开空单：数量={sell_amount:.6f}，价格={grid_info["sell_price"]}')
open_position('SHORT', grid_info['sell_price'], sell_amount)
def cancel_all_orders():
"""撤销所有未成交订单"""
try:
orders = exchange.GetOrders()
if orders:
for order in orders:
exchange.CancelOrder(order['Id'])
Sleep(100) # 避免频繁操作
return True
except Exception as e:
Log('撤单异常：', str(e))
return False
def get_real_position():
"""获取真实持仓信息"""
try:
positions = exchange.GetPosition()
if positions:
for pos in positions:
if pos['ContractType'] == 'swap' and pos['Amount'] > 0:
position_amount = pos['Amount'] * (1 if pos['Type'] == 0 else -1)
return position_amount, pos['Price'], pos['Profit']
return 0, 0, 0
except Exception as e:
Log('获取持仓异常：', str(e))
return 0, 0, 0
def update_account():
"""更新账户信息"""
try:
account = exchange.GetAccount()
if not account:
Log('获取账户信息失败')
return False
# 更新USDT资产信息
assets['USDT']['total_balance'] = account.Balance + account.FrozenBalance
assets['USDT']['margin_balance'] = account.Balance
# 获取真实持仓信息
position_amount, hold_price, profit = get_real_position()
assets[base_currency]['amount'] = position_amount
assets[base_currency]['hold_price'] = hold_price
assets[base_currency]['unrealised_profit'] = profit
return True
except Exception as e:
Log('更新账户异常：', str(e))
return False
def update_price():
"""更新行情价格"""
global InitPrice
ticker = exchange.GetTicker()
if not ticker:
Log('获取行情失败')
return False
# 设置初始价格
if InitPrice == 0:
InitPrice = ticker.Last
Log('设置初始价格：', InitPrice)
assets[base_currency]['price'] = ticker.Last
return True
def create_order(side, price, amount, order_type="开仓"):
"""使用CreateOrder下单函数"""
try:
if amount <= 0:
Log(f'订单数量无效：{amount}')
return False
# 构造期货合约symbol
contract_symbol = f"{symbol}.swap"
# 下单
order_id = exchange.CreateOrder(contract_symbol, side, price, amount)
if order_id:
Log(f'{order_type} {side} 下单成功：价格={price}, 数量={amount}, 订单ID={order_id}')
return order_id
else:
Log(f'{order_type} {side} 下单失败：价格={price}, 数量={amount}')
return False
except Exception as e:
Log('下单异常：', str(e))
return False
def safe_close_position(close_amount, price=-1):
"""安全平仓函数"""
try:
if close_amount <= 0:
Log(f'平仓数量无效：{close_amount}')
return False
# 实时获取持仓信息
current_position, _, _ = get_real_position()
# 检查是否真的有持仓
if current_position == 0:
Log('当前无持仓，跳过平仓操作')
return False
# 检查平仓数量是否超过持仓
if abs(close_amount) > abs(current_position):
Log(f'平仓数量超过持仓：持仓{current_position}，平仓{close_amount}，调整为持仓数量')
close_amount = abs(current_position)
# 根据当前持仓方向确定平仓操作
if current_position > 0: # 当前是多仓
side = "closebuy" # 平多仓
Log(f'平多仓：数量={close_amount}，价格={price}')
else: # 当前是空仓
side = "closesell" # 平空仓
Log(f'平空仓：数量={close_amount}，价格={price}')
return create_order(side, price, close_amount, "平仓")
except Exception as e:
Log('平仓异常：', str(e))
return False
def open_position(direction, price, amount):
"""开仓函数"""
try:
if amount <= 0:
Log(f'开仓数量无效：{amount}')
return False
# 确定开仓方向
if direction == 'LONG':
side = "buy" # 开多仓
Log(f'开多仓：数量={amount}，价格={price}')
else: # SHORT
side = "sell" # 开空仓
Log(f'开空仓：数量={amount}，价格={price}')
return create_order(side, price, amount, "开仓")
except Exception as e:
Log('开仓异常：', str(e))
return False
def update_status():
"""更新状态显示"""
try:
if Funding > 0:
current_balance = assets['USDT']['total_balance']
profit = current_balance - Funding
profit_rate = (profit / Funding) * 100
status_info = f"""
策略状态 - {symbol}
交易模式: 多空都做
当前价格: {assets[base_currency]['price']}
初始价格: {InitPrice}
持仓数量: {assets[base_currency]['amount']}
持仓价格: {assets[base_currency]['hold_price']}
账户余额: {current_balance:.4f} USDT
总收益: {profit:.4f} USDT ({profit_rate:.2f}%)
未实现盈亏: {assets[base_currency]['unrealised_profit']:.4f} USDT
"""
LogStatus(status_info)
except Exception as e:
Log('状态更新异常：', str(e))
def main():
"""主函数"""
# 设置错误过滤
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused|Unknown")
# 初始化
init()
Log('策略启动成功')
while True:
try:
# 更新账户信息
if not update_account():
Log('更新账户信息失败，等待重试')
Sleep(5000)
continue
# 更新价格信息
if not update_price():
Log('更新价格信息失败，等待重试')
Sleep(5000)
continue
# 执行策略
execute_strategy()
# 更新状态
update_status()
# 休眠
Sleep(Interval * 1000)
except Exception as e:
Log('主循环异常：', str(e))
Sleep(5000) # 发生异常时等待5秒再继续
Ưu điểm của chiến lược lưới hai chiều dài-ngắn là khả năng thích ứng với nhiều điều kiện thị trường khác nhau, cho phép đạt được lợi nhuận thông qua các hoạt động phù hợp, dù tăng, giảm hay biến động. Tuy nhiên, chiến lược này cũng đòi hỏi việc quản lý rủi ro cẩn thận, đặc biệt là trong điều kiện thị trường khắc nghiệt.
Tóm tắt
Tính linh hoạt và tự động hóa của các chiến lược lưới khiến chúng trở thành một công cụ phổ biến trong giao dịch định lượng. Các biến thể lưới khác nhau có thể thích ứng với nhiều môi trường thị trường khác nhau. Mỗi chiến lược có các kịch bản ứng dụng và lợi thế riêng. Nhà đầu tư có thể lựa chọn chiến lược lưới phù hợp dựa trên biến động thị trường cụ thể và khẩu vị rủi ro cá nhân, đồng thời kết hợp với các công cụ như quản lý vị thế động, chiến lược cắt lỗ và chốt lời để tối ưu hóa hiệu quả chiến lược hơn nữa.
nhu cầuminh họaBa chiến lược được thảo luận trong bài viết này đều là từ Plaza chiến lược trên nền tảng nhà phát minh, cung cấp một bản tóm tắt. Là một loại chiến lược định lượng cổ điển, các chiến lược lưới vẫn cung cấp nhiều để khám phá, chẳng hạn như cách tránh các cuộc gọi ký quỹ và giảm thiểu rủi ro và cách tối ưu hóa việc sử dụng quỹ để tăng lợi nhuận. Các bên quan tâm có thể truy cập Plaza Strateg, nơi có sẵn các chiến lược lưới thời gian thực để tham khảo và nghiên cứu.