Python
Mit nur wenigen Änderungen und Erweiterungen können Sie sich zu einer sehr leistungsstarken Handelsstrategie auf Basis der MACD-Logik erweitern.
Beachten Sie, dass diese Strategie nur ein Code-Framework ist, um Ihnen einen grundlegenden Rahmen für die Erweiterung Ihres Strategie-Raums zu geben. Das Studium dieses Strategie-Logik-Frameworks der FMZ-Plattform kann Ihnen helfen, schnell die gewünschte Strategie zu entwickeln. Der Zweck des Design-Frameworks ist es, Ihre Zeit zu sparen. In der FMZ-Plattform finden Sie nicht nur die zugrunde liegenden Schnittstellentechnologie-Details, sondern auch die Strategie-Ebene.
In Zukunft werden wir mehr Strategiemodelle für den Grundrahmen haben, so dass Sie wirklich auf die Strategie selbst achten können und sich nur auf den Aufbau der
class Trader: # Declare a python class
def __init__(self, q, symbol): # The constructor of the Trader class, the parameter self (representing the object after the class is instantiated),
# q (the transaction processing object constructed by reference to the commodity futures trading class library template),
# symbol (commodity futures contract code)
self.q = q # Add the attribute q to the object constructed by the constructor and assign it with the parameter q.
self.symbol = symbol # As above, add the symbol attribute to the constructed object and assign it with the parameter symbol.
self.position = 0 # Add the attribute position assignment 0, which is used to record the number of positions.
self.isPending = False # Add the attribute isPending to assign False, which is used to mark the state of the object and whether it is suspended.
def onOpen(self, task, ret): # The class member function performs the callback function after the completion of the open position (that is, after the object q that
# simulates the multi-threaded transaction completes the current task, the callback to the onOpen function handles some post-opening work.)
if ret: # The transaction processing object q will call back onOpen after processing the transaction task, and pass in 2 parameters.
# The first one is received by the parameter task, the specific data is the executed transaction task data,
# and the second parameter is the transaction completion.
# If ret is valid data (the transaction is unsuccessful, ret is None), then the if block code is processed.
self.position = ret['position']['Amount'] * (1 if (ret['position']['Type'] == PD_LONG or ret['position']['Type'] == PD_LONG_YD) else -1)
# Assign the value of the attribute position of the object that calls the function, ret['position']['Amount'] is the number of
# positions after the transaction, according to ret['position']['Type'], the position type is equal to PD_LONG (holding long positions)
# Or PD_LONG_YD (short position) to choose ret['position']['Amount'] multiplied by 1 or -1, and finally assign the number
# of positions to parameter position, (the role is to distinguish between long positions or short positions by parameter position)
Log(task["desc"], "Position:", self.position, ret) # Print multiple items: the description of the data task dictionary of the task executed by q,
# the assigned position, the completion of the transaction processed by the q object (current position information)
self.isPending = False # Assigning value to isPending means that the current variety trading logic is in a non-suspended state and can accept tasks.
def onCover(self, task, ret): # The callback function to be executed after the closing task is completed, the parameters are the same as onOpen
self.isPending = False # Set the trading logic of isPending to False, which is the current variety to be non-suspended and accept the task.
self.position = 0 # The variable position of the record position is assigned a value of 0, that is, there is no position.
Log(task["desc"], ret) # Print the transaction description object q the task description (desc) of this processing, the result of the completion of the processing (ret)
def onTick(self): # The main trading logic, the core of the MACD strategy.
if self.isPending: # If the isPending attribute of the current logical object constructed by the Trader class is True, it means
# that the current transaction task is executing in the transaction processing object q queue.
return # The trading logic is in a suspended state and no processing is done.
ct = exchange.SetContractType(self.symbol) # According to the constructor passed in the symbol assigned to the object member property symbol passed to the API function
# ie: the SetContractType function of the exchange object exchange, used to set the contract type of the operation
if not ct: # The SetContractType function will return the details of the contract after the transaction contract code (symbol) succeeds.
# If it returns None, ie not ct is true, it will return immediately and wait for the next round.
return
r = exchange.GetRecords() # Declare the variable r (used to store the K line data), call the API function GetRecords to get the set K line data of the contract, and assign it to r.
if not r or len(r) < 35: # If r is None or r is less than 35 (because the MACD indicator is to be calculated,
# there must be a sufficient number of K-bars, less than 35 cannot be calculated)
return # Return immediately, the next round of processing.
macd = TA.MACD(r) # Call the API indicator function TA.MACD, pass in the argument r, calculate the MACD indicator data, and assign it to the variable macd.
# (The data that TA.MACD successfully returns is a two-dimensional array [dif, dea, quantum column])
# Do not understand dif, dea can google MACD indicators
diff = macd[0][-2] - macd[1][-2] # Calculate the difference between dif and dea (note that the calculation here uses the calculated dif and dea of the penultimate bar,
# because the K line of the last bar of the last number is constantly changing, and the macd indicator is always changing, only the
# the penultimate bar is accurate)
if abs(diff) > 0 and self.position == 0: # Open position, if the absolute value of the indicator (dif - dea) is greater than 0 at this moment
# and there is no position (ie: position is equal to 0)
self.isPending = True # Change state is set to suspend state, isPending = True
self.q.pushTask(exchange, self.symbol, ("buy" if diff > 0 else "sell"), 1, self.onOpen) # Call the member function pushTask of the transaction processing object q to issue the
# open trading task, parameter: exchange trading platform object (passing)
# Self.symbol contract code (passing when constructing), set "buy" or "sell" according to whether diff is greater than 0 or less than 0. 1
# This parameter refers to the order quantity 1 unit, self.onOpen reference to the incoming callback function
if abs(diff) > 0 and ((diff > 0 and self.position < 0) or (diff < 0 and self.position > 0)): # Closing the position, if the absolute value of the indicator (dif - dea) is greater
# than 0 at this moment and the condition after "and" is established, the code in the if block is executed.
# Diff is greater than 0 and holds a short position or diff is less than 0 and holds long positions, all of which are closed position condition.
self.isPending = True # Set to suspend state.
self.q.pushTask(exchange, self.symbol, ("closebuy" if self.position > 0 else "closesell"), 1, self.onCover) # Send the closing trading task, the parameters are the same as the above to
# send the opening position task.
def main(): # Entry function
q = ext.NewTaskQueue() # The export function (ie interface) of the Python version of the commodity futures trading class library template is called,
# and ext.NewTaskQueue returns a constructed trading processing object. Reference and assign it to variable q
Log(_C(exchange.GetAccount)) # Start calling the _C fault-tolerant function, passing in the API for fault-tolerant processing: GetAccount function,
# return account information and output to the log by the Log function.
tasks = [] # Declare an empty array tasks.
for symbol in ["MA701", "rb1701"]: # Traversing the elements in the array ["MA701", "rb1701"], each time the element symbol and the transaction processing object
# q are passed as parameters to the constructor of the Trader class to construct the trading logic object.
tasks.append(Trader(q, symbol)) # The constructed trading logic object is pushed into the tasks array. Used to loop through the execution process.
while True: # Set a while infinite loop
if exchange.IO("status"): # Call the API function IO every time, pass the parameter "status" to detect the connection status with the futures company's
# front-end server (CTP protocol), return True, connect the transaction server and the market server.
for t in tasks: # Traversing the tasks array, calling the member function onTick of the constructed property of the Trader class,
# constantly checking the market, opening and closing the position.
t.onTick() # See the onTick function in the Trader class
q.poll() # The member function poll of the transaction processing object q is called to process the transaction task in the queue within the q object.
Sleep(1000) # The program pauses for a period of time each time the while loop (1000): pause for 1 second (1000 milliseconds) to avoid accessing the API too frequently.
Kleine TräumeDas ist toll!
Kleine TräumeSie sind herzlich willkommen!
Gutes- Danke. - Danke.