• 量化交易全流程（四）

    本节目录

    数据准备（数据源与数据库）

    CTA策略

    数据源：
    在进行量化分析的时候，最基础的工作是数据准备，即收集数据、清理数据、建立数据库。下面先讨论收集数据的来源，数据来源可分为两大类：免费的数据源和商业数据库。
    免费数据源包括新浪财经、Yahoo财经等。这些数据源提供的接口比较复杂，不是很好用。好消息是，Python中有对应的开源工具可以让数据获取变得简单。比如，akShare 能够获取新浪财经的数据，pandas-reader能够获取 Yahoo Finance 的数据。本章主要讨论akShare 和 pandas-reader 的用法。
    商业数据库包括万得（Wind)、同花顺（iFind)、聚源等。商业数据库也分为两种，一种是软件终端，除了可以提供各种数据查询和可视化功能之外，还提供了接口以便从终端上提取数据。比如万得终端。终端的好处是价格便宜，简单易用。坏处是对提取的数据量有限制，而且数据的定制化功能很差，很多数据甚至都没有提供接口。另一种是落地数据库，通常是SQL数据库，所有数据直接落地，可以用SQL语句进行提取。落地数据库的好处是数据丰富，定制灵活，没有数据量限制；缺点是成本较高，而且技术门槛也相对较高。大部分人使用的是第一种，即终端提供的接口。本章就以Wind为例，讨论第一种数据库的用法。
    前几张也详细谈到过获取数据接口，这里就不展开了，接找几个有用的技巧：

    获取交易日历：

    1. import akshare as ak
    2. from datetime import datetime
    3.  
    4. # Get the trade date history dataframe
    5. tool_trade_date_hist_sina_df = ak.tool_trade_date_hist_sina()
    6.  
    7. # Specify the start and end dates
    8. start_date = "2022-01-01"
    9. end_date = "2022-12-31"
    10. start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
    11. end_date = datetime.strptime(end_date, "%Y-%m-%d").date()
    12.  
    13. # Extract the dates within the specified range
    14. selected_dates = tool_trade_date_hist_sina_df[(tool_trade_date_hist_sina_df["trade_date"] >= start_date)\
    15.                                               & (tool_trade_date_hist_sina_df["trade_date"] <= end_date)]
    16.  
    17. print(selected_dates)

    1. import akshare as ak
    2. from datetime import datetime
    3. macro_usa_gdp_monthly_df = ak.macro_usa_gdp_monthly()
    4. start_date = "2022-01-01"
    5. end_date = "2022-12-31"
    6. start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
    7. end_date = datetime.strptime(end_date, "%Y-%m-%d").date()
    8.  
    9. # Extract the dates within the specified range
    10. selected_dates = macro_usa_gdp_monthly_df[(macro_usa_gdp_monthly_df["日期"] >= start_date)\
    11.                                               & (macro_usa_gdp_monthly_df["日期"] <= end_date)]
    12. print(selected_dates)

    如果想要获取国外市场数据，那么pandas-reader将是一个很好的免费数据接口。但pandas-reader也没有包含在Anaconda当中，需要自行安装。可以使用pip命令进行安装，命令如下：

    pip install pandas-datareader

    Pandas集成了很多免费的数据接口，包括但不限于Yahoo Finance、Google Finance、quandl、美联储、世界银行等提供的数据。
    pandas-reader的接口使用也很简单。先导入相关的函数，命令如下：

    import pandas_datareader.data as web

    但是好像接口被关闭，获取不到数据。

    获取美国宏观经济数据：

    1. import akshare as ak
    2. from datetime import datetime
    3. macro_usa_gdp_monthly_df = ak.macro_usa_gdp_monthly()
    4. start_date = "2022-01-01"
    5. end_date = "2022-12-31"
    6. start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
    7. end_date = datetime.strptime(end_date, "%Y-%m-%d").date()
    8.  
    9. # Extract the dates within the specified range
    10. selected_dates = macro_usa_gdp_monthly_df[(macro_usa_gdp_monthly_df["日期"] >= start_date)\
    11.                                               & (macro_usa_gdp_monthly_df["日期"] <= end_date)]
    12. print(selected_dates)

     万得接口
    一个简单例子
    万得（Wind）提供了一系列的接口，其中也包含Python的接口。下面列举一段简单的示例代码，用于提取股票000001.SZ一周的日线数据，具体如下：

    由于没有账号不方便演示，自行学习跳过。教你使用Python连接Wind金融数据接口 - 知乎 (zhihu.com)

    基于Wind返回的data的数据结构特点，在创建DataFrame的时候，必须先将index与Fields 对应，columns与日期对应，之后再进行矩阵转置。

    数据库：

    存储数据有很多种方式。有人比较喜欢以文件的形式存储，比如，csv文件或hdf5文件。但通常情况下，我还是比较喜欢建立一个数据库，以便于进行数据的管理和分享。而且，数据库本身也能完成很多数据计算和分析工作。
    现今的数据库主要分为两种：一种是关系型数据库，也就是使用SQL语句进行操作的数据库，常见的有MySQL、PostgreSQL、SQL Sever等；一种是非关系型（NoSQL）数据库，比如MongoDB。这两种数据库各有其优势，这里主要还是使用传统的SQL数据库。本书中以PostgreSQL为例。SQL基础知识的讲解不在范围之内，大家可以自行查找相关的教程进行学习。这里假设读者已经具有SQL的相关基础。
    Pandas利用SQLAlchemy包，提供了简单的数据库接口。比如，我们想把一个dataframe 存储到数据库里面，

    前提是已经安装了：

    1. pip install psycopg2
    2. pip install sqlalchemy

    可以使用如下代码： 

    1. from sqlalchemy import create_engine
    2. engine=create_engine ('postgresql://postgres@localhost:5432/postgres')
    3. df.to_sql('stock_all_info',engine, if_exists='replace', index=True)

    其中，engine存储了连接数据库的相关信息（数据库地址、数据库名称、用户名和密码）。
    在df.to_sql中，第一个参数表示表的名称。参数if_exists表示假如现在已经存在此表，应进行什么操作；append代表在当前表中添加新的列；replace 表示替换当前表（删除当前已有的表）;fail 表示不进行任何操作，默认值是fail；参数index 表示是否将DataFrame的索引也存储到表中。
    存储的时候，数据库会自动识别每列的数据类型，并对应到SQL数据库的类型。比如我们将前面获取到的数据存储到stock_all_info中。数据库中会生成一张表。

    由于date在df里面是索引，所以数据库也会自动地为这张表创建一个 date索引。
    数据库的读取也非常容易，可以使用如下代码实现：

    df=pd.read_sql('select * from stock_info',where windcode = '000001.SZ',engine)

    其中，第一个参数是一个SQL查询语句，接口将返回该查询语句对应的DataFrame。

    下载所有股票历史数据并存储

    做策略研究的朋友经常会有建立一个完整的股票数据库的需求。本节将展示一个小程序，指导下载所有股票历史行情并存储到数据库中。

    此处展示只获取5只股票，市场上有5000多只股票，获取不完，要花很长时间，另外获取时间我固定为20210101到现在的行情，如果有需求的话自行修改代码中的start_date;

    先回顾如何在数据库里面创建表：(自行学习前面的数据库，这里不再介绍)

    1. CREATE TABLE stocks (
    2.     date DATE,
    3.     stock_code VARCHAR(20),
    4.     open DECIMAL(15,4),
    5.     high DECIMAL(15,4),
    6.     low DECIMAL(15,4),
    7.     close DECIMAL(15,4),
    8.     volume DECIMAL(30,8)
    9. );

    表里面具体的有日期，股票代码，四个价以及成交量。

    实现代码具体如下：

    delete from stocks;

    查看表里面内容：

    select * from stocks;

     

    全部代码如下：（已经封装成类）

    1. import akshare as ak
    2. import datetime
    3. import mysql.connector
    4. import pymysql
    5. import pandas as pd
    6.  
    7. class StockDataUpdater:
    8.     def __init__(self, host, user, password, port, db):
    9.         self.host = host
    10.         self.user = user
    11.         self.password = password
    12.         self.port = port
    13.         self.db = db
    14.  
    15.     # -------------------------获取数据库中每只股票的历史数据---------------------------------------
    16.     # 获取所有股票代码
    17.     def all_stock_codes(self):
    18.         all_stock_codes = ak.stock_zh_a_spot_em()[['代码']].sort_values(by='代码')
    19.         all_stock_codes = all_stock_codes.reset_index(drop=True)
    20.         return all_stock_codes
    21.  
    22.     # 判断股票所属市场
    23.     def code_type(self, code):
    24.         if code.find('60',0,3)==0:
    25.             gp_type='sh'
    26.         elif code.find('688',0,4)==0:
    27.             gp_type='sh'
    28.         elif code.find('689',0,4)==0:
    29.             gp_type='sh'
    30.         elif code.find('900',0,4)==0:
    31.             gp_type='sh'
    32.         elif code.find('00',0,3)==0:
    33.             gp_type='sz'
    34.         elif code.find('300',0,4)==0:
    35.             gp_type='sz'
    36.         elif code.find('301',0,4)==0:
    37.             gp_type='sz'
    38.         elif code.find('200',0,4)==0:
    39.             gp_type='sz'
    40.         elif code.find('8',0,1)==0:
    41.             gp_type='bj'
    42.         elif code.find('430',0,4)==0:
    43.             gp_type='bj'
    44.         code = gp_type+code
    45.         return code
    46.  
    47.     # 获取股票指标数据
    48.     def get_indicator(self, stock_ID):
    49.         stock_individual_info = ak.stock_individual_info_em(symbol = stock_ID)
    50.  
    51.         # 获取索引
    52.         index = stock_individual_info.loc[stock_individual_info['item'] == '上市时间'].index[0]
    53.  
    54.         # 使用索引定位value列的开始日期
    55.         start_date = str(stock_individual_info.loc[index, 'value'])
    56.         start_date = start_date[:4] + start_date[4:6] + start_date[6:]
    57.         
    58.         start_date = '20210104'
    59.         # 获取当前日期
    60.         end_date = datetime.datetime.now().strftime('%Y%m%d')
    61.         end_date = '20220104'
    62.         # 新浪拉取数据，有些数据拉取不全
    63.         stock_code = self.code_type(stock_ID)
    64.         try:
    65.             data = ak.stock_zh_a_daily(symbol=stock_code, start_date=start_date, end_date=end_date, adjust="qfq")
    66.             df = data[['date','open','high','low','close','volume']]
    67.             df = df.dropna()
    68.             return df
    69.         except:
    70.             return None
    71.  
    72.         # 连接数据库
    73.     def insert_info(self, stock_indicator):
    74.         conn = pymysql.connect(host = self.host # 连接名称，默认127.0.0.1
    75.         ,user = self.user # 用户名
    76.         ,password = self.password # 密码
    77.         ,port = self.port # 端口，默认为3306
    78.         ,db = self.db # 数据库名称
    79.         ,charset = 'utf8' # 字符编码
    80.         )
    81.         cur = conn.cursor() # 生成游标对象
    82.  
    83.         for index, row in stock_indicator.iterrows():
    84.             sql = "INSERT INTO stocks(date,stock_code,open,high,low,close,volume) VALUES (%s, %s, %s, %s, %s, %s, %s)"
    85.             cur.execute(sql, (row['date'], row['stock_code'], row['open'], row['high'],row['low'], row['close'],row['volume']))
    86.             conn.commit()   # 提交事务
    87.         cur.close() # 关闭游标
    88.         conn.close() # 关闭连接
    89.  
    90.  
    91.     # -------------------------更新数据库中每只股票的最新数据---------------------------------------
    92.  
    93.     # 获取数据库中每个股票的最新日期
    94.     def get_latest_date(self, stock_code):
    95.         conn = pymysql.connect(host='127.0.0.1', user='root', password='152617', port=3306, db='stock_info', charset='utf8')
    96.         cur = conn.cursor()
    97.         sql = f"SELECT MAX(date) FROM stocks WHERE stock_code = '{stock_code}'"
    98.         cur.execute(sql)
    99.         latest_date = cur.fetchone()[0]
    100.         cur.close()
    101.         conn.close()
    102.         return latest_date
    103.  
    104.     # 拉取股票历史数据
    105.     def update_historical_data(self):
    106.         stocks_info = self.all_stock_codes()
    107.         for i in range(len(stocks_info)):
    108.             if i<3:
    109.                 stock_indicator = self.get_indicator(stocks_info['代码'][i])
    110.                 if stock_indicator is not None:
    111.                     stock_indicator = stock_indicator.assign(stock_code = stocks_info['代码'][i])
    112.                     self.insert_info(stock_indicator)
    113.             else:
    114.                 break
    115.  
    116.     # 更新股票最新行情数据
    117.     def update_latest_data(self):
    118.         stocks_info = self.all_stock_codes()
    119.         for i in range(len(stocks_info)):
    120.             if i < 5:
    121.                 stock_code = stocks_info['代码'][i]
    122.                 latest_date = self.get_latest_date(stock_code)
    123.                 if latest_date is not None:
    124.                     latest_date = latest_date.strftime('%Y%m%d')
    125.                     stock_indicator = self.get_indicator(stock_code)
    126.                     if stock_indicator is not None:
    127.                         stock_indicator = stock_indicator.assign(stock_code=stock_code)
    128.                         if latest_date is not None:
    129.                             stock_indicator = stock_indicator[stock_indicator['date'] > latest_date]
    130.                         if not stock_indicator.empty:
    131.                             self.insert_info(stock_indicator)
    132.             else:
    133.                 break
    134.  
    135.  
    136.  
    137. host = '127.0.0.1'
    138. user = 'root'
    139. password = '152617'
    140. port = 3306
    141. db = 'stock_info'
    142. updater = StockDataUpdater(host, user, password, port, db)
    143.  
    144. # 更新历史数据
    145. updater.update_historical_data()
    146.  
    147. # 更新最新数据
    148. # updater.update_latest_data()

     在这里我先将时间固定在20210104—20220104：

    运行结果为：文件名为info.py

     

    在获取历史行情时要去掉updater.update_latest_data()；

    然后更新股票时去掉updater.update_historical_data()；同时要去掉end_date：

    重新运行：

     运行结果为：

    有一点不完善的是更新的数据并不是append在原来股票代码后面，但这并不影响，只要在数据库里面按照stock_code  sort一下即可。这里就不详细演示了。 

    上面的程序，主要分为两步，第一步获取所有A股的代码。第二步是针对每一个股票，获取对应的指标（这里是open、high、low、close)，并存储于数据库中，并进行实时更新。

    下面这部分代码是获取全部股票行情数据存放到数据库中（耗时很长，谨慎运行）：

    1. import akshare as ak
    2. import datetime
    3. import mysql.connector
    4. import pymysql
    5. import pandas as pd
    6.  
    7. class StockDataUpdater:
    8.     def __init__(self, host, user, password, port, db):
    9.         self.host = host
    10.         self.user = user
    11.         self.password = password
    12.         self.port = port
    13.         self.db = db
    14.  
    15.     # -------------------------获取数据库中每只股票的历史数据---------------------------------------
    16.     # 获取所有股票代码
    17.     def all_stock_codes(self):
    18.         all_stock_codes = ak.stock_zh_a_spot_em()[['代码']].sort_values(by='代码')
    19.         all_stock_codes = all_stock_codes.reset_index(drop=True)
    20.         return all_stock_codes
    21.  
    22.     # 判断股票所属市场
    23.     def code_type(self, code):
    24.         if code.find('60',0,3)==0:
    25.             gp_type='sh'
    26.         elif code.find('688',0,4)==0:
    27.             gp_type='sh'
    28.         elif code.find('689',0,4)==0:
    29.             gp_type='sh'
    30.         elif code.find('900',0,4)==0:
    31.             gp_type='sh'
    32.         elif code.find('00',0,3)==0:
    33.             gp_type='sz'
    34.         elif code.find('300',0,4)==0:
    35.             gp_type='sz'
    36.         elif code.find('301',0,4)==0:
    37.             gp_type='sz'
    38.         elif code.find('200',0,4)==0:
    39.             gp_type='sz'
    40.         elif code.find('8',0,1)==0:
    41.             gp_type='bj'
    42.         elif code.find('430',0,4)==0:
    43.             gp_type='bj'
    44.         code = gp_type+code
    45.         return code
    46.  
    47.     # 获取股票指标数据
    48.     def get_indicator(self, stock_ID):
    49.         stock_individual_info = ak.stock_individual_info_em(symbol = stock_ID)
    50.  
    51.         # 获取索引
    52.         index = stock_individual_info.loc[stock_individual_info['item'] == '上市时间'].index[0]
    53.  
    54.         # 使用索引定位value列的开始日期
    55.         start_date = str(stock_individual_info.loc[index, 'value'])
    56.         start_date = start_date[:4] + start_date[4:6] + start_date[6:]
    57.         
    58.         start_date = '20210104'
    59.         # 获取当前日期
    60.         end_date = datetime.datetime.now().strftime('%Y%m%d')
    61.         # end_date = '20220104'
    62.         # 新浪拉取数据，有些数据拉取不全
    63.         stock_code = self.code_type(stock_ID)
    64.         try:
    65.             data = ak.stock_zh_a_daily(symbol=stock_code, start_date=start_date, end_date=end_date, adjust="qfq")
    66.             df = data[['date','open','high','low','close','volume']]
    67.             df = df.dropna()
    68.             return df
    69.         except:
    70.             return None
    71.  
    72.         # 连接数据库
    73.     def insert_info(self, stock_indicator):
    74.         conn = pymysql.connect(host = self.host # 连接名称，默认127.0.0.1
    75.         ,user = self.user # 用户名
    76.         ,password = self.password # 密码
    77.         ,port = self.port # 端口，默认为3306
    78.         ,db = self.db # 数据库名称
    79.         ,charset = 'utf8' # 字符编码
    80.         )
    81.         cur = conn.cursor() # 生成游标对象
    82.  
    83.         for index, row in stock_indicator.iterrows():
    84.             sql = "INSERT INTO stocks(date,stock_code,open,high,low,close,volume) VALUES (%s, %s, %s, %s, %s, %s, %s)"
    85.             cur.execute(sql, (row['date'], row['stock_code'], row['open'], row['high'],row['low'], row['close'],row['volume']))
    86.             conn.commit()   # 提交事务
    87.         cur.close() # 关闭游标
    88.         conn.close() # 关闭连接
    89.  
    90.  
    91.     # -------------------------更新数据库中每只股票的最新数据---------------------------------------
    92.  
    93.     # 获取数据库中每个股票的最新日期
    94.     def get_latest_date(self, stock_code):
    95.         conn = pymysql.connect(host='127.0.0.1', user='root', password='152617', port=3306, db='stock_info', charset='utf8')
    96.         cur = conn.cursor()
    97.         sql = f"SELECT MAX(date) FROM stocks WHERE stock_code = '{stock_code}'"
    98.         cur.execute(sql)
    99.         latest_date = cur.fetchone()[0]
    100.         cur.close()
    101.         conn.close()
    102.         return latest_date
    103.  
    104.     # 拉取股票历史数据
    105.     def update_historical_data(self):
    106.         stocks_info = self.all_stock_codes()
    107.         for i in range(len(stocks_info)):
    108.             if True:
    109.                 stock_indicator = self.get_indicator(stocks_info['代码'][i])
    110.                 if stock_indicator is not None:
    111.                     stock_indicator = stock_indicator.assign(stock_code = stocks_info['代码'][i])
    112.                     self.insert_info(stock_indicator)
    113.             else:
    114.                 break
    115.  
    116.     # 更新股票最新行情数据
    117.     def update_latest_data(self):
    118.         stocks_info = self.all_stock_codes()
    119.         for i in range(len(stocks_info)):
    120.             if True:
    121.                 stock_code = stocks_info['代码'][i]
    122.                 latest_date = self.get_latest_date(stock_code)
    123.                 if latest_date is not None:
    124.                     latest_date = latest_date.strftime('%Y%m%d')
    125.                     stock_indicator = self.get_indicator(stock_code)
    126.                     if stock_indicator is not None:
    127.                         stock_indicator = stock_indicator.assign(stock_code=stock_code)
    128.                         if latest_date is not None:
    129.                             stock_indicator = stock_indicator[stock_indicator['date'] > latest_date]
    130.                             if not stock_indicator.empty:
    131.                                 self.insert_info(stock_indicator)
    132.             else:
    133.                 break
    134.  
    135.  
    136.  
    137. host = '127.0.0.1'
    138. user = 'root'
    139. password = '152617'
    140. port = 3306
    141. db = 'stock_info'
    142. updater = StockDataUpdater(host, user, password, port, db)
    143.  
    144. # 更新历史数据
    145. updater.update_historical_data()
    146.  
    147. # 更新最新数据
    148. # updater.update_latest_data()

     获取好后，数据库中存在所有行情大致为：反正一直在更新数据（数据量很大）

     这里面有一些重复数据的行，因为运行的时候忘记先保存再运行，导致查找到了一些重复的行并添加了进来。

    上传到在线数据库：

    1. import akshare as ak
    2. import datetime
    3. import pandas as pd
    4. import psycopg2
    5.  
    6. class StockDataUpdater():
    7.     
    8.     def __init__(self, host, user, password, port, db):
    9.         self.host = host
    10.         self.user = user
    11.         self.password = password
    12.         self.port = port
    13.         self.db = db
    14.         self.start_date = '20220103'
    15.         self.end_date = datetime.datetime.now().strftime('%Y%m%d')
    16.         # end_date = '20240104'
    17.  
    18.     # -------------------------获取数据库中每只股票的历史数据---------------------------------------
    19.     # 获取所有股票代码
    20.     def all_stock_codes(self):
    21.         all_stock_codes = ak.stock_zh_a_spot_em()[['代码']].sort_values(by='代码')
    22.         all_stock_codes = all_stock_codes.reset_index(drop=True)
    23.         # all_stock_codes = all_stock_codes.iloc[2563:].reset_index(drop=True)
    24.         return all_stock_codes
    25.  
    26.     # 判断股票所属市场
    27.     def code_type(self, code):
    28.         if code.find('60',0,3)==0:
    29.             gp_type='sh'
    30.         elif code.find('688',0,4)==0:
    31.             gp_type='sh'
    32.         elif code.find('689',0,4)==0:
    33.             gp_type='sh'
    34.         elif code.find('900',0,4)==0:
    35.             gp_type='sh'
    36.         elif code.find('00',0,3)==0:
    37.             gp_type='sz'
    38.         elif code.find('300',0,4)==0:
    39.             gp_type='sz'
    40.         elif code.find('301',0,4)==0:
    41.             gp_type='sz'
    42.         elif code.find('200',0,4)==0:
    43.             gp_type='sz'
    44.         elif code.find('8',0,1)==0:
    45.             gp_type='bj'
    46.         elif code.find('430',0,4)==0:
    47.             gp_type='bj'
    48.         code = gp_type+code
    49.         return code
    50.  
    51.     # 获取股票指标数据
    52.     def get_indicator(self, stock_ID, start_date, end_date):
    53.         stock_individual_info = ak.stock_individual_info_em(symbol = stock_ID)
    54.         # 获取索引
    55.         index = stock_individual_info.loc[stock_individual_info['item'] == '上市时间'].index[0]
    56.         # 使用索引定位value列的开始日期
    57.         startdate = str(stock_individual_info.loc[index, 'value'])
    58.         startdate = startdate[:4] + startdate[4:6] + startdate[6:]
    59.         date1 = datetime.datetime.strptime(startdate, '%Y%m%d')
    60.         date2 = datetime.datetime.strptime(start_date, '%Y%m%d')
    61.         # 比较日期大小
    62.         if date1 > date2:
    63.             start_date = startdate
    64.  
    65.         # 新浪拉取数据，有些数据拉取不全
    66.         stock_code = self.code_type(stock_ID)
    67.         try:
    68.             data = ak.stock_zh_a_daily(symbol=stock_code, start_date=start_date, end_date=end_date, adjust="qfq")
    69.             df = data[['date','open','high','low','close','volume']]
    70.             df = df.dropna()
    71.             return df
    72.         except:
    73.             return None
    74.  
    75.         # 连接数据库
    76.     def insert_info(self, stock_indicator):
    77.         conn = psycopg2.connect(host = self.host # 连接名称，默认127.0.0.1
    78.         ,user = self.user # 用户名
    79.         ,password = self.password # 密码
    80.         ,port = self.port # 端口，默认为3306
    81.         ,dbname = self.db # 数据库名称
    82.         # ,charset = 'utf8' # 字符编码
    83.         )
    84.         cur = conn.cursor() # 生成游标对象
    85.  
    86.         for index, row in stock_indicator.iterrows():
    87.             sql = "INSERT INTO stock_info(date,stock_code,open,high,low,close,volume) VALUES (%s, %s, %s, %s, %s, %s, %s)"
    88.             cur.execute(sql, (row['date'], row['stock_code'], row['open'], row['high'],row['low'], row['close'],row['volume']))
    89.             conn.commit()   # 提交事务
    90.         cur.close() # 关闭游标
    91.         conn.close() # 关闭连接
    92.  
    93.  
    94.     # -------------------------更新数据库中每只股票的最新数据---------------------------------------
    95.  
    96.     # 获取数据库中每个股票的最新日期
    97.     def get_latest_date(self, stock_code):
    98.         conn = psycopg2.connect(host = self.host # 连接名称，默认127.0.0.1
    99.         ,user = self.user # 用户名
    100.         ,password = self.password # 密码
    101.         ,port = self.port # 端口，默认为3306
    102.         ,dbname = self.db # 数据库名称
    103.         # ,charset = 'utf8' # 字符编码
    104.         )
    105.         cur = conn.cursor()
    106.         sql = f"SELECT MAX(date) FROM stock_info WHERE stock_code = '{stock_code}'"
    107.         cur.execute(sql)
    108.         latest_date = cur.fetchone()[0]
    109.         cur.close()
    110.         conn.close()
    111.         return latest_date
    112.  
    113.     # 拉取股票历史数据
    114.     def update_historical_data(self):
    115.         stocks_info = self.all_stock_codes()
    116.         for i in range(len(stocks_info)):
    117.             stock_indicator = self.get_indicator(stocks_info['代码'][i], self.start_date,self.end_date)
    118.             if stock_indicator is not None:
    119.                 stock_indicator = stock_indicator.assign(stock_code = stocks_info['代码'][i])
    120.                 self.insert_info(stock_indicator)
    121.             else:
    122.                 continue
    123.  
    124.     # 更新股票最新行情数据
    125.     def update_latest_data(self):
    126.         stocks_info = self.all_stock_codes()
    127.         for i in range(len(stocks_info)):
    128.             stock_code = stocks_info['代码'][i]
    129.             latest_date = self.get_latest_date(stock_code)
    130.             if latest_date is not None:
    131.                 latest_date = latest_date.strftime('%Y%m%d')
    132.                 stock_indicator = self.get_indicator(stock_code, latest_date, self.end_date)
    133.                 if stock_indicator is not None:
    134.                     stock_indicator = stock_indicator.assign(stock_code=stock_code)
    135.                     stock_indicator = stock_indicator[stock_indicator['date'] > latest_date]
    136.                     if not stock_indicator.empty:
    137.                         self.insert_info(stock_indicator)
    138.             else:
    139.                 continue
    140.  
    141.  
    142.  
    143. host = '139.196.89.94'
    144. user = 'w599806489'
    145. password = '*********'
    146. port = 5433
    147. db = 'dbc3ee3a547bce4158be8322fc0e89d451stock_info'
    148. updater = StockDataUpdater(host, user, password, port, db)
    149.  
    150. # 更新历史数据
    151. updater.update_historical_data()
    152.  
    153. # 更新最新数据
    154. # updater.update_latest_data()

    以下是在db里面运行：

    先备份表，

    1. -- 创建一个和stocks一样的表
    2. create table stock_info.stock like stock_info.stocks;
    3. -- 将信息复制到stock里面
    4. INSERT INTO stock_info.stock(date, stock_code ,open,high,low,close,volume)
    5. SELECT date, stock_code ,open,high,low,close,volume FROM stock_info.stocks;
    1. -- 添加唯一标识列id列
    2. ALTER TABLE stock_info.stock ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY;
    3. -- 创建临时表，按7个列的值排序
    4. use stock_info;
    5. CREATE TEMPORARY TABLE tmp_table
    6. SELECT MIN(id) AS id
    7. FROM stock_info.stock
    8. GROUP BY date, stock_code, open, high, low, close, volume;
    9. -- 删除重复值的行
    10. DELETE FROM stock_info.stock
    11. WHERE id NOT IN (
    12.   SELECT id FROM tmp_table
    13. );
    14. -- 删除临时表
    15. DROP TEMPORARY TABLE tmp_table;

    处理完后数据大概有：

    将stock数据赋值给stocks;

    1. -- 删除原表的内容
    2. delete from stocks;
    3.  
    4. -- 将信息复制到stocks里面，不复制id列
    5. INSERT INTO stock_info.stocks(date, stock_code ,open,high,low,close,volume)
    6. SELECT date, stock_code ,open,high,low,close,volume FROM stock_info.stock;

     数据准备过程就完成了。

    查看数据：

    1. select * from stock_info.stocks order by stock_code,date ;
    2.  
    3. select count(*) from stock_info.stocks;

    CTA策略

    数据准备好后，下面进行策略介绍：

    CTA全称是Commodity Trading Advisor，即"商品交易顾问"，是由NFA（美国全国期货协会）认定的，在CFTC（商品期货交易委员会）注册，并接受监管的投资顾问。CTA 一般是指通过为客户提供期权、期货方面的交易建议，或者直接通过受管理的期货账户参与实际交易，来获得收益的机构或个人。
    以上的定义只是原始的意思，随着市场的发展，市场对CTA策略的理解普遍发生了改变，它已不再只是商品期货了。实际上，目前国内的 CTA 策略大都是基于量价的趋势跟踪策略。无论是商品期货、金融期货，还是股票、外汇，只要是有历史公开量价的二级市场，都可以成为CTA策略运作的市场。国内市场中，期货是T+0，股票是T+1，且期货可以做多做空，所以期货的研究空间要大很多。国内成熟的第三方自动化交易软件，基本上都是从期货人手的。所以本部分就以期货作为研究对象，介绍基本的CTA策略研究思路和方法。

    趋势跟踪策略理论基础

    但凡接触过投资的，大概都听过"趋势跟踪"的概念。著名经济学家大卫．李嘉图曾将"趋势跟踪"策略表述为"截断亏损，让利润奔跑"。"趋势跟踪"策略，通俗地讲，就是涨了的股票，会涨得更高；跌了的股票，会跌得更低。只要我们顺着大势做，就能赚钱。

    很多人将"趋势跟踪"奉为圭臬，坚定不移。也有人将其当作"金融巫术"，认为该策略不值一提。那么"趋势跟踪"是否真的有效？很多信徒内心也不免打鼓。这种怀疑，就像肉中刺，平时隐隐作痛，令人不得安稳。假若不幸，连续亏损，则是"发炎肿胀"，让人难受得开始怀疑人生。

    "趋势跟踪"不是魔法，不可能让你天天赚钱，甚至都不一定能年年赚钱。但既然该策略能广为流传，那一定是有其道理的。

    为了"讲清道理"，各种机构的学者没少花时间和精力来研究该策略。

    2012年，Tobias J. Moskowitz 等人发表的文章《Time series momentum》，使用了最基本的"趋势跟踪"策略——买人最近上涨的资产，卖空最近下跌的资产。此策略自 1985年以来，在几乎所有的股票指数期货、债券期货、商品期货以及远期货币上，平均来看，都是盈利的。
    当然，30 年的数据不算太长，为了能有更强的说服力，美国著名的对冲基金AQR．发表了报告《A Century of Evidence on Trend-Following Investing》(《趋势投资策略：一个世纪的证据》)，报告中列举了100年的数据，证明了"趋势跟踪"策略是有效的，不仅长期来看取得了正收益，而且与各传统大类资产相关性很低，是一种非常好的分散风险的投资方法。
    既然上文已从实证的角度说明了"趋势跟踪"策略的有效性，那么此类策略的现实逻辑基础究竟是什么呢？为了回答这个问题，我们可以反过来思考："趋势跟踪"策略无效的理论基础是什么？就是赫赫有名的"弱有效市场假说"。此假说指出，证券的历史价格已反映了全部的市场信息。历史价格是公开的，所有投资者都可以基于此做出理性的判断，从而形成当前的有效价格。换句话说，当前资产是被完美定价的。
    此假说明显不符合事实，投资界的"非理性狂热"和"羊群效应"是明显存在的。也正是这种"非理性"的部分，常常使得证券价格偏离了"实际价值"，也就是被错误定价。由于"非理性"的长期存在，"趋势跟踪"策略也能长期有效。
    著名的《黑天鹅》作者，纳西姆·塔勒布其实也是类似策略的践行者。不过他实现的方式不一样，他的交易策略是买入那些远离实际价格的期权，平时亏小钱，希望在大波动来临的时候，一把挣足。实际情况就是，他开办的公司在最初几年，表现平平，略有亏损，结果在"911事件"的时候，大发横财。这也符合了他的理念，"极端行情比我们想象的要多而且极端"。正是这一认知误差，使得市场长期低估了"大趋势"出现的可能性。这也是"趋势跟踪"策略长期有效的根本原因。

    技术指标
    国内的量化CTA大部分使用的都是技术指标构建策略。所谓技术指标，就是价格、成交量、持仓量的数学组合。大体上，技术指标可分为三种类型，具体说明如下。
    (1）趋势型
    顾名思义，趋势型指标可用于描述并捕捉趋势行情，适合趋势跟踪策略，比如，MACD、SAR等。
    (2）超买超卖型（也可以称作"反转型")
    股市价格的涨跌中，也会有反复和振荡，比如，KDJ、RSI等。超买超卖型与趋势型刚好相反，此类指标可用于描述并捕捉趋势行情的终结，即反转状态，目标是为了识别震荡和短期的头部底部。

     (3）能量型
    能量型的指标是指从成交量的角度考察价格变动的力量，常用于辅助判断信号的强度。比如VOL、OBV等。

    主力合约的换月问题

    期货合约是会到期的。若要进行较长历史的回测，使用的数据则是由多个合约拼接而换月时会产生"假跳空"的问题。由于不同合约经常会存在一个较大的价差，因此表现在成的，也就是所谓的主力连续合约。使用这种主力连续合约，往往会存在一个问题，就是连续合约上，就会产生一个大的跳空，这个跳空就是"假跳空"。这种"假跳空"，最大的影响就是技术指标的计算会失真。比如，实际行情明明没有突破，但由于存在"假跳空"的问题，从而出现了突破。举个例子，比如某期货品种，假设换月前两天的收盘价依次为1020、1000，换月后的价格为1200、1220。那么由于跳空的问题，就好像价格突然上涨了200一样，从而就出现了"假突破"问题，如果不进行复权处理，那么很可能会产生多头信号，然则这个信号其实是错误的。
    在进行回测的时候，我们需要处理"假跳空"的问题。为了避免"假跳空"问题带来的误差，一般会采用如下三种方法。
    □使用期货的合成指数来进行回测。
    □对跳空进行复权处理。
    □不使用主力合约，而是使用单独月份的合约来进行分析。
    这三种方法的实现成本依次递增，准确性也依次增强。在实际应用中，需要针对自己的具体需求来选择。下面针对这三种方法做一个详细介绍。
    1使用合成指数进行回测
    合成指数，是指对某个品种各个月份的价格，分配权重，计算出一个综合性指数，用于代表该品种的整体走势。计算指数的时候，算法一般都会保证其连续性，不会出现"假跳空"的问题。市面上很多第三方平台都会提供期货的合成指数。这样就可以直接使用指数进行回测，回测结果也就不会受到"假跳空"问题的影响。但这种方法也存在缺点：一是指数不是真实的价格数据，多少会存在一些误差；二是指数的计算公式往往不是透明的，而且各个平台很可能又是不一样的。使用"黑盒"的指数，总是感觉会有些不踏实，这种方法比较适合进行初步的测试。初步回测通过之后，就可以考虑使用更精确的方法来回测了。
    2．对主力连续合约进行复权处理，抹平跳空
    复权算法共有好几种，一般包含两个维度。首先，复权可以分为加减复权和乘除复权；其次，可以分为前复权和后复权。这样两两组合，其实就有四种算法了。
    为了更清楚地解释复权的概念，这里使用本节开始的例子来进行说明。假设有四天的数据，换月前两天的收盘价依次为1020、1000，换月后的价格为1200、1250，这样在换月时候就会有200的"假跳空"价差了。
    先解释加减复权和乘除复权。所谓加减复权是指对跳空产生的价差进行加减平移。比如说，我们将换月后两天的数据，也就是1200和1250，都减去200，得到1000和1050。处理后的数据序列就是：1020、1000、1000、1050。加减复权的好处是，直观易理解，价格序列比较"整洁"，不会出现小数点。缺点是收益率会出现偏差，比如处理之前的1200到1250，涨幅是（1250-1200)/1200-0.042，处理之后涨幅是（1050-1000)/1000=0.05。为了保证收益率不出现偏差，就需要使用乘除复权了。顾名思义，乘除复权是指在价格的基础上乘上一个因子。比如这里，换月前后，1000跳空到1200，相当于是白白乘了1.2倍。为了复权，就需要将换月后的数据除以1.2。这样得到的数据序列就是1020和1000，1200/1.2=1000.1250/1.2=1041.66，这样保证每天收益率不会因为复权而产生偏差，缺点是复权之后的数据就没有那么"整洁"了，出现了小数点。在各大股票软件中，一般使用乘除复权。但其实这两种方法都有自己的用武之地。比如，在高频策略的研究中，由于价差变化非常小，因此加减复权带来的收益率偏差也很小，可以忽略不计，这个时候就可以使用加减复权，来保证数据的整洁性。
    3．不使用主力连续合约，使用单独的实际合约进行回测
    这种方法的缺点是，由于大部分指标都需要针对一段时间内的历史数据进行计算，因此这段时间内，是不会有交易信号的，相当于损失了这段时间内的历史数据，所以这种方法比较适合于小周期策略的回测（比如15分钟策略），因为小周期策略损失的数据会很少，一般就是两三天，影响并不大。

    用Python实现复权
    上一节中介绍了处理合约换月的几种方法，本节就来介绍如何编写程序完成复权操作。复权方法共有两种：加减复权和乘除复权。下面将讲解这两种复权方法的实现。
    加减复权
    假设每次换月的时候，换月前的收盘价和换月后的开盘价就是换月导致的"伪跳空"价差。这个假设并不完全准确，但是这样假设比较简便，容易处理。
    这样我们就可以得到相应的算法了，具体步骤如下。
    1）初始化复权因子为0。
    2）每次换月后，将"伪跳空"累加到复权因子上，算出所有的复权因子。
    3）统一将所有的价格都减去复权因子。
    在 Pandas 里面，我们可以很方便地用向量化还有对应的函数来实现这个功能，甚至不需要编写循环语句就可以完成。以下是完成加减复权的函数，具体代码如下：

    1. def adjust_price_sum(df):
    2.     """
    3.     加减复权
    4.     参数：df：原始的OHLC数据，列名依次为：date,trade_hiscode,open,high,low,close
    5.     其中，trade_hiscode代表了合约的代码，因为存在换月的问题，因此这个代码是会变动的
    6.     返回值：df：进行复权处理后的数据，OHLC 所有价格数据都要进行复权，并返回对应的复权因子adj_factor
    7.     """
    8.     # 生成前一天的收盘价，以便于向量化计算复权价格
    9.     df['close_pre'] = df.close.shift(1)
    10.     # 判断是否换月
    11.     df['roll_over'] = (df.trade_hiscode != df.trade_hiscode.shift(1)) & (~df.trade_hiscode.shift(1).isnull())
    12.     # 初始化复权因子
    13.     df['adj_factor'] = 0
    14.     # 计算因换月问题导致的复权因子变化
    15.     df.loc[df.roll_over, 'adj_factor'] = df.loc[df.roll_over, 'close_pre'] - df.loc[df.roll_over, 'open']
    16.     # 累积所有复权因子的变化，得到最终的复权因子
    17.     df['adj_factor_cum'] = df.adj_factor.cumsum()
    18.     # 对OHLC的四个数据都进行复权
    19.     df['open'] = df.open + df.adj_factor_cum
    20.     df['high'] = df.high + df.adj_factor_cum
    21.     df['low'] = df.low + df.adj_factor_cum
    22.     df['close'] = df.close + df.adj_factor_cum
    23.     # 删除中间数据
    24.     del df['close_pre']
    25.     del df['roll_over']
    26.     del df['adj_factor']
    27.     del df['adj_factor_cum']
    28.     df = df.dropna()
    29.     return df

    在以上函数中，我们使用了Pandas的 shift 函数完成了今日和昨日的比较和运算，使用cumsum(）函数完成了复权因子的累加。

    乘除复权
    乘除复权和加减复权在总体逻辑上是一致的，但是在算法的具体细节上却有所不同。乘除复权的具体算法步骤如下。

    1）初始化复权因子为1。 
    2）每次换月后，将"伪跳空"累乘到复权因子上，算出所有的复权因子。
    3）统一将所有的价格都乘以复权因子。
    乘除复权对应的函数代码具体如下：

    1. def adjust_price_sum(df):
    2.     """
    3.     乘除复权
    4.     参数：df：原始的OHLC数据，列名依次为：date,trade_hiscode,open,high,low,close
    5.     其中，trade_hiscode代表了合约的代码，因为存在换月的问题，因此这个代码是会变动的
    6.     返回值：df：进行复权处理后的数据，OHLC 所有价格数据都要进行复权，并返回对应的复权因子adj_factor
    7.     """
    8.     # 生成前一天的收盘价，以便于向量化计算复权价格
    9.     df['close_pre'] = df.close.shift(1)
    10.     # 判断是否换月
    11.     df['roll_over'] = (df.trade_hiscode != df.trade_hiscode.shift(1)) & (~df.trade_hiscode.shift(1).isnull())
    12.     # 初始化复权因子
    13.     df['adj_factor'] = 1
    14.     # 计算因换月问题导致的复权因子变化
    15.     df.loc[df.roll_over,'adj_factor'] = df.loc[df.roll_over,'close_pre']/df.loc[df.roll_over,'open']
    16.     # 累积所有复权因子的变化，得到最终的复权因子
    17.     df['adj_factor_cum'] = df.adj_factor.cumprod()
    18.     # 对OHLC的四个数据都进行复权
    19.     df['open']=round(df.open * df.adj_factor_cum, 2)
    20.     df['high']=round(df.high * df.adj_factor_cum, 2)
    21.     df['low']=round(df.low * df.adj_factor_cum, 2)
    22.     df['close']=round(df.close * df.adj_factor_cum, 2)
    23.     # 删除中间数据
    24.     del df['close_pre']
    25.     del df['roll_over']
    26.     del df['adj_factor']
    27.     del df['adj_factor_cum']
    28.     df=df.dropna()
    29.     return df

    处理好合约数据之后，我们就可以开始着手构建交易策略了。在"趋势跟踪"系统中，技术指标是必不可少的。好消息是，技术指标的计算不需要重新造轮子，因为已经有很成熟的库可供我们使用了，比如 ta-lib。ta-lib 本身是基于C语言的技术指标库，现在也提供开源的经Python包装后的库，那也是比较好用的。技术指标是技术分析流派的核心组成部件，所以花费较大的篇幅来介绍ta-lib将是很值得的。

    安装ta-lib

    Anaconda 预装是没有ta-lib的，我们需要手动进行安装。到这里寻找对应python版本的Ta-Lib进行下载：（新建了一个环境python3.8，因为没有3.11的Ta-Lib）

    Archived: Python Extension Packages for Windows - Christoph Gohlke (uci.edu)

    使用pip install Ta-Lib会报错，因此需要去下载安装，找对本地python对应版本 比如TA_Lib-0.4.24-cp38-cp38-win_amd64.whl这个文件此本版 他的python版本就是3.8的版本，然后点击下载 PS:我的是python3.8的所以就下载这个!  对于一切上述ERROR只要重新尝试下载不同版本TA_Lib即可解决，都是版本不适配导致的。

    下载完成后在下载路径下:

     打开cmd，先激活虚拟环境，再输入命令安装：

    安装好测试：

    可以正常调入，没有问题。

    ta-lib的指标和函数介绍
    本节将会详细介绍ta-lib的用法和指标函数。
    ta-lib本身是由C语言完成的，但ta-lib自己的官网文档却很少，反倒是Python封装项目文档比较详细，这也是我们主要的参考资料。不过，该文档是英文的，下面的指标名称主要以英文为主，同时也带有中文翻译。
    ta-lib的函数主要分为10组，具体如下。
    □ Overlap Studies （可叠加指标）

    □Momentum Indicators（动量指标）

    □ Volume Indicators（成交量指标）

    □ Volatility Indicators（波动率指标）

    □ Price Transform（价格变换）

    □ Cycle Indicators（周期指标）

    □ Pattern Recognition（模式识别）

    □ Statistic Functions（统计函数）

    □ Math Transform（数学变换）

    □Math Operators（数学运算符）

    Python版中ta-lib的使用语法是比较简单的，有两种方式来计算指标值。函数式API (Function API）和抽象API(Abastract API)。
    函数式API提供了一种轻量级的调用方式。函数式API主要输入的是四个同样长度的ndarray，分别是open、high、low和close。比如，我们首先可以通过如下命令生成一个close:

    在vscode里面更改内核为py38；

    1. import numpy
    2. import talib
    3. close=numpy.random.random(100)
    4. # 然后，调用talib.SMA计算简单的移动平均，代码如下：
    5. output=talib.SMA(close)
    6. output

    结果：


    有时候也可以指定不同的均线计算方式，比如计算布林线，命令如下：

    1. from talib import MA_Type
    2. # 下面使用参数matype 来指定使用三重指数平滑均线计算布林线。
    3. upper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3)
    4. # 同时，也可以使用参数timeperiods-5来指定计算周期，示例代码如下：
    5. output = talib.MOM(close,timeperiod=5)
    6. print(output)
    7. # 在调用形态识别函数的时候，需要输入open、high、low、close四组数据，示例代码如下
    8. import numpy as np
    9. # note that all ndarrays must be the same length!
    10. inputs = {
    11.     'open': np.random.random(100),
    12.     'high': np.random.random(100),
    13.     'low': np.random.random(100),
    14.     'close': np.random.random(100),
    15.     'volume': np.random.random(100)
    16. }
    17.  
    18. output = talib.CDL2CROWS (inputs['open'], inputs['high'], inputs['low'], inputs['close'])
    19. print(output)

    还有一种是抽象式API，也尝试过，但感觉不太习惯，就放弃使用了，现在一直坚持使用函数式API，因为该方式更清晰易懂。
    ta-lib总共包含了7组指标。下面将对比较重要的指标做一个简单的介绍。当然，限于篇幅，无法全部解释，读者可以自行查阅。

    我们可以显示Ta lib的所有TA函数,返回一个 list 或者 dict

    1. import talib
    2. print (talib.get_functions())
    3. print (talib.get_function_groups())

    指标学习参考：

    链接：https://pan.baidu.com/s/1vwEIUBJb-FVZ6B9sirAX8g?pwd=1234 
    提取码：1234

    Function Groups

     Overlap Studies

    1. BBANDS               Bollinger Bands #布林带
    2. DEMA                 Double Exponential Moving Average #双指数移动平均线
    3. EMA                  Exponential Moving Average #指数滑动平均
    4. HT_TRENDLINE         Hilbert Transform - Instantaneous Trendline #希尔伯特变换瞬时趋势
    5. KAMA                 Kaufman Adaptive Moving Average #卡玛考夫曼自适应移动平均
    6. MA                   Moving average #均线
    7. MAMA                 MESA Adaptive Moving Average #自适应移动平均 
    8. MAVP                 Moving average with variable period #变周期移动平均
    9. MIDPOINT             MidPoint over period #在周期的中点
    10. MIDPRICE             Midpoint Price over period #中间时段价格
    11. SAR                  Parabolic SAR #抛物线转向指标
    12. SAREXT               Parabolic SAR - Extended
    13. SMA                  Simple Moving Average
    14. T3                   Triple Exponential Moving Average (T3)
    15. TEMA                 Triple Exponential Moving Average
    16. TRIMA                Triangular Moving Average
    17. WMA                  Weighted Moving Average
    Momentum Indicators
    1. ADX                  Average Directional Movement Index
    2. ADXR                 Average Directional Movement Index Rating
    3. APO                  Absolute Price Oscillator
    4. AROON                Aroon
    5. AROONOSC             Aroon Oscillator
    6. BOP                  Balance Of Power
    7. CCI                  Commodity Channel Index
    8. CMO                  Chande Momentum Oscillator
    9. DX                   Directional Movement Index
    10. MACD                 Moving Average Convergence/Divergence
    11. MACDEXT              MACD with controllable MA type
    12. MACDFIX              Moving Average Convergence/Divergence Fix 12/26
    13. MFI                  Money Flow Index
    14. MINUS_DI             Minus Directional Indicator
    15. MINUS_DM             Minus Directional Movement
    16. MOM                  Momentum
    17. PLUS_DI              Plus Directional Indicator
    18. PLUS_DM              Plus Directional Movement
    19. PPO                  Percentage Price Oscillator
    20. ROC                  Rate of change : ((price/prevPrice)-1)*100
    21. ROCP                 Rate of change Percentage: (price-prevPrice)/prevPrice
    22. ROCR                 Rate of change ratio: (price/prevPrice)
    23. ROCR100              Rate of change ratio 100 scale: (price/prevPrice)*100
    24. RSI                  Relative Strength Index
    25. STOCH                Stochastic
    26. STOCHF               Stochastic Fast
    27. STOCHRSI             Stochastic Relative Strength Index
    28. TRIX                 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
    29. ULTOSC               Ultimate Oscillator
    30. WILLR                Williams' %R
    31.
    Volume Indicators
    1. AD                   Chaikin A/D Line
    2. ADOSC                Chaikin A/D Oscillator
    3. OBV                  On Balance Volume
    Volatility Indicators
    1. ATR                  Average True Range
    2. NATR                 Normalized Average True Range
    3. TRANGE               True Range
    Price Transform
    1. AVGPRICE             Average Price
    2. MEDPRICE             Median Price
    3. TYPPRICE             Typical Price
    4. WCLPRICE             Weighted Close Price

    Cycle Indicators

    1. HT_DCPERIOD          Hilbert Transform - Dominant Cycle Period
    2. HT_DCPHASE           Hilbert Transform - Dominant Cycle Phase
    3. HT_PHASOR            Hilbert Transform - Phasor Components
    4. HT_SINE              Hilbert Transform - SineWave
    5. HT_TRENDMODE         Hilbert Transform - Trend vs Cycle Mode
    Pattern Recognition
    1. CDL2CROWS            Two Crows
    2. CDL3BLACKCROWS       Three Black Crows
    3. CDL3INSIDE           Three Inside Up/Down
    4. CDL3LINESTRIKE       Three-Line Strike
    5. CDL3OUTSIDE          Three Outside Up/Down
    6. CDL3STARSINSOUTH     Three Stars In The South
    7. CDL3WHITESOLDIERS    Three Advancing White Soldiers
    8. CDLABANDONEDBABY     Abandoned Baby
    9. CDLADVANCEBLOCK      Advance Block
    10. CDLBELTHOLD          Belt-hold
    11. CDLBREAKAWAY         Breakaway
    12. CDLCLOSINGMARUBOZU   Closing Marubozu
    13. CDLCONCEALBABYSWALL  Concealing Baby Swallow
    14. CDLCOUNTERATTACK     Counterattack
    15. CDLDARKCLOUDCOVER    Dark Cloud Cover
    16. CDLDOJI              Doji
    17. CDLDOJISTAR          Doji Star
    18. CDLDRAGONFLYDOJI     Dragonfly Doji
    19. CDLENGULFING         Engulfing Pattern
    20. CDLEVENINGDOJISTAR   Evening Doji Star
    21. CDLEVENINGSTAR       Evening Star
    22. CDLGAPSIDESIDEWHITE  Up/Down-gap side-by-side white lines
    23. CDLGRAVESTONEDOJI    Gravestone Doji
    24. CDLHAMMER            Hammer
    25. CDLHANGINGMAN        Hanging Man
    26. CDLHARAMI            Harami Pattern
    27. CDLHARAMICROSS       Harami Cross Pattern
    28. CDLHIGHWAVE          High-Wave Candle
    29. CDLHIKKAKE           Hikkake Pattern
    30. CDLHIKKAKEMOD        Modified Hikkake Pattern
    31. CDLHOMINGPIGEON      Homing Pigeon
    32. CDLIDENTICAL3CROWS   Identical Three Crows
    33. CDLINNECK            In-Neck Pattern
    34. CDLINVERTEDHAMMER    Inverted Hammer
    35. CDLKICKING           Kicking
    36. CDLKICKINGBYLENGTH   Kicking - bull/bear determined by the longer marubozu
    37. CDLLADDERBOTTOM      Ladder Bottom
    38. CDLLONGLEGGEDDOJI    Long Legged Doji
    39. CDLLONGLINE          Long Line Candle
    40. CDLMARUBOZU          Marubozu
    41. CDLMATCHINGLOW       Matching Low
    42. CDLMATHOLD           Mat Hold
    43. CDLMORNINGDOJISTAR   Morning Doji Star
    44. CDLMORNINGSTAR       Morning Star
    45. CDLONNECK            On-Neck Pattern
    46. CDLPIERCING          Piercing Pattern
    47. CDLRICKSHAWMAN       Rickshaw Man
    48. CDLRISEFALL3METHODS  Rising/Falling Three Methods
    49. CDLSEPARATINGLINES   Separating Lines
    50. CDLSHOOTINGSTAR      Shooting Star
    51. CDLSHORTLINE         Short Line Candle
    52. CDLSPINNINGTOP       Spinning Top
    53. CDLSTALLEDPATTERN    Stalled Pattern
    54. CDLSTICKSANDWICH     Stick Sandwich
    55. CDLTAKURI            Takuri (Dragonfly Doji with very long lower shadow)
    56. CDLTASUKIGAP         Tasuki Gap
    57. CDLTHRUSTING         Thrusting Pattern
    58. CDLTRISTAR           Tristar Pattern
    59. CDLUNIQUE3RIVER      Unique 3 River
    60. CDLUPSIDEGAP2CROWS   Upside Gap Two Crows
    61. CDLXSIDEGAP3METHODS  Upside/Downside Gap Three Methods

    Statistic Functions

    1. BETA                 Beta
    2. CORREL               Pearson's Correlation Coefficient (r)
    3. LINEARREG            Linear Regression
    4. LINEARREG_ANGLE      Linear Regression Angle
    5. LINEARREG_INTERCEPT  Linear Regression Intercept
    6. LINEARREG_SLOPE      Linear Regression Slope
    7. STDDEV               Standard Deviation
    8. TSF                  Time Series Forecast
    9. VAR                  Variance
    10.

    熟悉上面指标需要花费大量时间，但是是必经之路，是必需要学习的。

    一个简单策略模式
    下面将介绍一个简单的策略模式，实际应用中我们可以根据自己的偏好和习惯进行选择和组合。一个合理的CTA策略，一般是以"趋势跟踪"为主，以反转指标和能量指标为辅。
    为了说明技术指标组合，下面分别选取趋势指标T、反转指标R、能量指标E进行说明。
    我们假设趋势指标为T,T＋代表趋势指标出现多头信号，比如5日均线（MA(5)）上穿20日均线（MA(20));T﹣代表空头信号，比如MA(5）下穿MA(20)。趋势指标是最重要的，一个策略可以没有反转指标、能量指标，但不能没有趋势指标。定义趋势可以有很多种方法，但各种方法其实都大同小异。以下两种方法最为常用。
    1）突破。当前价格大于先前N期的价格，就视为突破。举个例子，将N定义为10,如果当前价格大于前10天的最高价，则认为是向上突破。反之，当前价格小于前10天的最低价，则认为是向下突破。
    2）移动平均线的穿越。移动平均线简称均线，是一种平滑价格的方法。计算前N期（包含当期）收盘价的平均值，就得到了当期的均线值MA(N)。比如MA(10)，就是今天与过去9天收盘价的平均值。均线可以筛除一些短期波动，突显较长期的趋势，但也因此会让均线的转折点落后于价格本身的转折点。当短期均线上穿长期均线，比如MA(5）上穿MA(10）时，可以视为一种突破。
    假设反转指标为R,R＋代表反转指标出现多头信号，R﹣代表反转指标出现空头信号。反转指标R通常与趋势跟踪指标相反，价格越涨，我们越要害怕，怕涨太高会回调；或者跌太狠，会反抽。一个典型的反转指标是RSI。比如，我们假设RSI达到70以上，说明出现了超买情况，属于空头信号。RSI达到30以下，说明出现了超卖情况，属于多头信号。
    假设能量指标为E，能量指标通常与成交量结合计算，比如能量潮指标OBV。OBV指标的计算方法比较简单，主要是计算累积成交量。
    下面以日为计算周期举例说明，其计算公式为：
    当日OBV＝本日值＋前一日的OBV值
    如果本日收盘价或指数高于前一日收盘价或指数，则本日值为正值；如果本日的收盘价或指数低于前一日的收盘价，则本日值为负值；如果本日值与前一日的收盘价或指数持
    平，则本日值不参与计算，然后计算累积成交量。E大于某阈值m时，可以作为筛选条件。

    综合趋势指标T、反转指标R、能量指标E，我们就有了一个简单的策略套路，具体说
    明如下。
    口空仓时，若出现T+，则开多仓；若出现T-，则开空仓。

    口当前是多头时，若出现T-，则平多反手开空；若出现R-，则平多不开新仓。

    口 当前是空头时，若出现T+，则平空反手开多；若出现R+，则平空不开新仓。

    口所有的信号均可以用能量E超过某阈值m来辅助，只有当E有效时，信号才有效。

    这样就可以构建一个简单的策略。当然，在这个策略中，所有的参数，比如均线的周期数、RSI的信号范围、E的阈值m，都可以作为可变的参数。我们也可以对这些参数进行优化，以达到最佳历史效果。
    当然，这里只是列举了一个简单的例子，实际中，各种各样的组合非常多。都需要自己去尝试。这里只是提供一个思路和实现框架，供读者参考。
    当我们处理好输入的合约数据，并且确定了策略逻辑，就需要对策略进行回测了，下部分将会讨论策略回测中的相关问题。

  • 相关阅读:
    Python-print骚操作之rich库
    代码随想录Day60 | 739. 每日温度 | 496. 下一个更大元素
    银行软件测试：基于互联网金融平台的测试框架设计与分析
    操作系统的基本概念
    长春市OLED透明拼接屏：高清晰度和透明度的双重优势
    基于Nios-II实现流水灯
    来看看Python MetaClass元类详解
    HTML5新元素探索：重塑网页结构与功能的革新
    Batch normalization 和 Layer normalization
    独立产品灵感周刊 DecoHack #040 - Google公布2022年度最佳应用榜单
  • 原文地址：https://blog.csdn.net/mnwl12_0/article/details/133519411