# Crocodile line trading system Python version

Author: , Created: 2020-05-07 14:33:19, Updated:

## Summary

People who have done financial trading will probably have an experience. Sometimes the price fluctuations are regular, but more often it shows an unstable state of random walk. It is this instability that is where market risks and opportunities lie. Instability also means unpredictable, so how to make returns more stable in an unpredictable market environment is also a problem for every trader. This article will introduce the crocodile trading rules strategy, hoping to inspire everyone.

## What is a crocodile line The crocodile line is actually three special moving averages, which correspond to the chin of the blue line, the teeth of the red line, and the upper lip of the green line. The chin is a 13-period moving average and moves 8 bars in the future. The tooth is an 8-period moving average and moves 5 bars in the future. The upper lip is a 5-period moving average and moves 3 bars in the future.

## Principle of crocodile line

The crocodile line is a set of technical analysis methods summarized based on geometry and nonlinear dynamics. When the crocodile’s chin, teeth and upper lip are closed or entangled, it means that the crocodile is asleep. At this time, we usually stay outside the market until the fragment appears, and only participate in the obvious trend market.

The longer the crocodile sleeps, the more hungry it will be when it wakes up, so once it wakes up, it will open its mouth wide. If the upper lip is above the teeth and the teeth are above the chin, it indicates that the market has entered a bull market and the crocodiles are going to eat beef. If the upper lip is below the teeth and the teeth are below the chin, it indicates that the market has entered a bear market and the crocodiles are going to eat bear meat. Until it is full, it will then close its mouth again (hold and make a profit).

## Crocodile line calculation formula

Upper lip = REF(SMA(VAR1,5,1),3) Teeth = REF(SMA(VAR1,8,1),5) Chin = REF(SMA(VAR1,13,1)

Crocodile strategy composition

### Step 1: Write a strategy framework

``````# Strategy main function
def onTick():
pass

# Program entry
def main ():
while True: # Enter infinite loop mode
onTick() # execute strategy main function
Sleep(1000) # sleep for 1 second
``````

FMZ using the polling mode, one is the onTick function, and the other is the main function, in which the onTick function is executed in an infinite loop in the main function.

### Step 2: Import Python library

``````import talib
import numpy as np
``````

The SMA function is used in our strategy. SMA is the arithmetic mean. There are already ready-made SMA functions in the talib library, so directly import the talib Python library and then call it directly. Because when calling this function, you need to pass in numpy format parameters, so we need to use import to import these two Python libraries at the beginning of the strategy.

### Step 3: Convert K-line array data

``````# Convert the K-line array into an array of highest price, lowest price, and closing price, for conversion to numpy.array
def get_data(bars):
arr = []
for i in bars:
arr.append(i['Close'])
return arr
``````

Here we created a get_data function, the purpose of this function is to process the ordinary K-line array into numpy format data. The input parameter is a K-line array, and the output result is processed data in numpy format.

### Step 4: Obtain position data

``````# Get the number of positions
def get_position ():
# Get position
position = 0 # The number of assigned positions is 0
position_arr = _C (exchange.GetPosition) # Get array of positions
if len (position_arr)> 0: # If the position array length is greater than 0
for i in position_arr:
if i ['ContractType'] == 'rb000': # If the position symbol is equal to the subscription symbol
if i ['Type']% 2 == 0: # If it is long position
position = i ['Amount'] # Assigning a positive number of positions
else:
position = -i ['Amount'] # Assigning a negative number of positions
return position
``````

Position status involves strategy logic. Our first ten lessons have always used virtual positions, but in a real trading environment it is best to use the GetPosition function to obtain real position information, including: position direction, position profit and loss, number of positions, etc.

### Step 5: Get the data

``````exchange.SetContractType('rb000') # Subscribe the futures varieties
bars_arr = exchange.GetRecords() # Get K line array
if len(bars_arr) < 22: # If the number of K lines is less than 22
return
``````

Before acquiring data, you must first use the SetContractType function to subscribe to relevant futures varieties. FMZ supports all Chinese commodity futures varieties. After subscribing to the futures symbol, you can use GetRecords function to obtain K-line data, which returns an array.

### Step 6: Calculate the data

``````np_arr = np.array (get_data (bars_arr)) # Convert closing price array
sma13 = talib.SMA (np_arr, 130) [-9] # chin
sma8 = talib.SMA (np_arr, 80) [-6] # teeth
sma5 = talib.SMA (np_arr, 50) [-4] # upper lip
current_price = bars_arr [-1] ['Close'] # latest price
``````

Before calculating the SMA using the talib library, you need to use the numpy library to process the ordinary K-line array into numpy data. Then get the chin, teeth and upper lip of the crocodile line separately. In addition, the price parameter needs to be passed in when placing an order, so we can use the closing price in the K-line array.

### Step 7: Place an order

``````position = get_position ()
if position == 0: # If there is no position
if current_price> sma5: # If the current price is greater than the upper lip
exchange.Buy (current_price + 1, 1) # open long position order
if current_price <sma13: # If the current price is less than the chin
exchange.SetDirection ("sell") # Set the trading direction and type
exchange.Sell (current_price-1, 1) # open short position order

if position> 0: # If you have long positions
if current_price <sma8: # If the current price is less than teeth
exchange.Sell (current_price-1, 1) # close long position

if position <0: # If you have short position
if current_price> sma8: # If the current price is greater than the tooth
exchange.SetDirection ("closesell") # Set the trading direction and type
exchange.Buy (current_price + 1, 1) # close short position
``````

Before placing an order, you need to get the actual position. The get_position function we defined earlier will return the actual number of positions. If the current position is long, it will return a positive number. If the current position is short, it will return a negative number. If there is no position, returns 0. Finally, the buy and sell functions are used to place orders according to the above trading logic, but before this, the trading direction and type also need to be set.

## Complete strategy

``````'' 'backtest
start: 2019-01-01 00:00:00
end: 2020-01-01 00:00:00
period: 1h
exchanges: [{"eid": "Futures_CTP", "currency": "FUTURES"}]
'' '

import talib
import numpy as np

# Convert the K-line array into an array of highest price, lowest price, and closing price, used to convert to numpy.array type data
def get_data (bars):
arr = []
for i in bars:
arr.append (i ['Close'])
return arr

# Get the number of positions
def get_position ():
# Get position
position = 0 # The number of assigned positions is 0
position_arr = _C (exchange.GetPosition) # Get array of positions
if len (position_arr)> 0: # If the position array length is greater than 0
for i in position_arr:
if i ['ContractType'] == 'rb000': # If the position symbol is equal to the subscription symbol
if i ['Type']% 2 == 0: # If it is long
position = i ['Amount'] # Assign a positive number of positions
else:
position = -i ['Amount'] # Assign a negative number of positions
return position

# Strategy main function
def onTick ():
# retrieve data
exchange.SetContractType ('rb000') # Subscribe to futures varieties
bars_arr = exchange.GetRecords () # Get K line array
if len (bars_arr) <22: # If the number of K lines is less than 22
return

# Calculation
np_arr = np.array (get_data (bars_arr)) # Convert closing price array
sma13 = talib.SMA (np_arr, 130) [-9] # chin
sma8 = talib.SMA (np_arr, 80) [-6] # teeth
sma5 = talib.SMA (np_arr, 50) [-4] # upper lip
current_price = bars_arr [-1] ['Close'] # latest price

position = get_position ()
if position == 0: # If there is no position
if current_price> sma5: # If the current price is greater than the upper lip
exchange.Buy (current_price + 1, 1) # open long position order
if current_price <sma13: # If the current price is less than the chin
exchange.SetDirection ("sell") # Set the trading direction and type
exchange.Sell (current_price-1, 1) # open short position order

if position> 0: # If you have long positions
if current_price <sma8: # If the current price is less than teeth
exchange.Sell (current_price-1, 1) # close long position

if position <0: # If you have short positions
if current_price> sma8: # If the current price is greater than the tooth
exchange.SetDirection ("closesell") # Set the trading direction and type
exchange.Buy (current_price + 1, 1) # close short position

# Program main function
def main ():
while True: # loop
onTick () # execution strategy main function
Sleep (1000) # sleep for 1 second
``````

Directly click the link below to copy the complete strategy without configuration: https://www.fmz.com/strategy/199025

End

The biggest role of the crocodile trading rule is to help us maintain the same direction as the market when trading, regardless of how the current market price changes, and continue to profit until the consolidation market appears. The crocodile line can be used well with other MACD and KDJ indicators.

More