单独在框架加了一个自定义股票池，支持自定义交易品种，支持股票，etf，可转债混合交易，我们只需要把买入，卖出的股票代码放在买入股票文件夹就可以

比如我们自定义纳斯达克和黄金趋势交易，程序带了一个趋势模块

"自定义交易品种交易":"自定义交易类型比如股票，可转债，etf***********",
    "自定义交易品种跌破N日均线卖出":5,
    "自定义交易品种持有分数":50,
    "买入前N":5,
    "自定义交易":"************************",

目前支持的策略

"模型策略":{
        "get_wencai_buy_data":"问财买入股票",
        "get_wencai_sell_data":"问财卖出股票",
        "get_dfcf_zh_buy_stock":"东方财富自选股买入",
        "get_dfcf_zh_sell_stock":"东方财富自选股卖出",
        "run_bond_cov_rend_strategy":"可转债趋势轮动策略",
        "run_limit_trading_strategy":"涨停板策略",
        "run_etf_trend_strategy":"etf趋势轮动策略",
        "run_bond_cov_popularity_strategy":"可转债人气策略",
        "run_stock_sentiment_strategy":"股票人气策略",
        "run_bond_cov_custom_factor_rotation":"可转债自定义因子轮动策略",
        "run_bond_cov_hot_concept_strategy":"可转债热门概念策略",
        "run_micro_stock_cap_trend_trading":"微盘股趋势轮动策略",
        "run_tdx_yj_trader_func_1":"通达信警告交易函数1",
        "run_tdx_trader_stock_buy":"通达信自选股买入",
        "run_tdx_trader_stock_sell":"通达信自选股卖出",
        "get_connect_trader_data":"合并交易数据",
        "run_joinquant_trader_strategy_get_simultaneous_stock_hold_models":"聚宽跟单持股模式",
        "run_joinquant_trader_strategy_get_simultaneous_transaction_models":"聚宽跟单成交模式",
        "run_customize_trading_strategies":"自定义交易股票池"
    },

自定义买入股票文件夹设置，只需要证券代码，比如纳斯达克+黄金，自定义

卖出股票也是一样的

第二步：选择交易系统

比如qmt

"交易系统设置":"*********************************************",
    "交易系统选择":"ths/qmt",
    "交易系统":"qmt",
    "交易品种":"全部",
    "交易品种说明":["stock","fund","bond","全部"],
    "同花顺下单路径":"C:/同花顺软件/同花顺/xiadan.exe",
    "识别软件安装位置":"C:/Program Files/Tesseract-OCR/tesseract",
    "qmt路径":"D:/国金QMT交易端模拟/userdata_mini",
    "qmt账户":"55009640",
    "qmt账户类型":"STOCK",
    "证券公司交易设置":"兼容老牌证券公司可转债1手为单位",

设置仓位

"资金管理模块说明":"程序默认管理方式有数量/资金",
    "资金分配设置":"交易数量设置数量和金额,利用可转债最低单位位设置条件,股票在基础数据*10，etf*100,值调整持有限制，持股限制",
    "交易模式":"数量",
    "固定交易资金":2500,
    "持有金额限制":5000,
    "固定交易数量":10,
    "持有限制":20,
    "持股限制":10,

第三步：运行user_def_models

处理一下自定义股票池，做趋势分析

尾盘股趋势交易策略

更新数据

程序分析程序写入的数据买入

卖出

第四步：运行trader_st开通的运行实盘交易

选择交易策略，自定义交易策略

"目前设置说明":"早上交易人气,下午做概念,2个策略的间隔长，干扰小，手动更新数据是最后一个策略的",
    "自定义函数运行类型":["定时"],
    "自定义函数模块运行时间":["09:45"],
    "自定义函数":["run_customize_trading_strategies"],
    "黑名单":["600031"],

运行效果

开始下单

下单的结果

下单的结果，当前时间不能交易

源代码

自定义交易模块的代码，支持同花顺，qmt

from trader_tool.stock_data import stock_data
from trader_tool.bond_cov_data import bond_cov_data
from trader_tool.shape_analysis import shape_analysis
from trader_tool.analysis_models import analysis_models
import pandas as pd
from trader_tool.ths_rq import ths_rq
from tqdm import tqdm
import numpy as np
import json
from  trader_tool import jsl_data
from qmt_trader.qmt_trader_ths import qmt_trader_ths
from xgtrader.xgtrader import xgtrader
from trader_tool.ths_rq import ths_rq
from trader_tool.ths_board_concept_data import ths_board_concept_data
from trader_tool.unification_data import unification_data
import os
import pandas as pd
class customize_trading_strategies:
    def __init__(self,trader_tool='ths',exe='C:/同花顺软件/同花顺/xiadan.exe',tesseract_cmd='C:/Program Files/Tesseract-OCR/tesseract',
                qq='1029762153@qq.com',open_set='否',qmt_path='D:/国金QMT交易端模拟/userdata_mini',
                qmt_account='55009640',qmt_account_type='STOCK',name='customize_trading_strategies'):
        '''
        分析模型
        '''
        self.exe=exe
        self.tesseract_cmd=tesseract_cmd
        self.qq=qq
        self.trader_tool=trader_tool
        self.open_set=open_set
        self.qmt_path=qmt_path
        self.qmt_account=qmt_account
        self.qmt_account_type=qmt_account_type
        if trader_tool=='ths':
            self.trader=xgtrader(exe=self.exe,tesseract_cmd=self.tesseract_cmd,open_set=open_set)
        else:
            self.trader=qmt_trader_ths(path=qmt_path,account=qmt_account,account_type=qmt_account_type)
        self.stock_data=stock_data()
        self.bond_cov_data=bond_cov_data()
        self.ths_rq=ths_rq()
        self.path=os.path.dirname(os.path.abspath(__file__))
        self.ths_board_concept_data=ths_board_concept_data()
        self.name=name
        self.data=unification_data(trader_tool=self.trader_tool)
        self.data=self.data.get_unification_data()
        self.trader.connect()
    def save_position(self):
        '''
        保存持股数据
        '''
        with open(r'分析配置.json',encoding='utf-8') as f:
            com=f.read()
        text=json.loads(com)
        del_stock_list=text['黑名单']
        trader_type=text['交易品种']
        def select_del_stock_list(x):
            if str(x)[:6] in del_stock_list:
                return '是'
            else:
                return '否'
        df=self.trader.position()
        try:
            if df==False:
                print('获取持股失败')
        except:
            if df.shape[0]>0:
                if trader_type=='全部':
                    df=df
                else:
                    df['选择']=df['证券代码'].apply(self.trader.select_data_type)
                    df=df[df['选择']==trader_type]
                print(df)
                df=df[df['可用余额']>=10]
                df['黑名单']=df['证券代码'].apply(select_del_stock_list)
                df=df[df['黑名单']=='否']
                print('剔除黑名单**********')
                df.to_excel(r'持股数据\持股数据.xlsx')
                return df
            else:
                df=pd.DataFrame()
                df['账号类型']=None
                df['资金账号']=None
                df['证券代码']=None
                df['股票余额']=None
                df['可用余额']=None
                df['成本价']=None
                df['市值']=None
                df['选择']=None
                df['持股天数']=None
                df['交易状态']=None
                df['明细']=None
                df['证券名称']=None
                df['冻结数量']=None
                df['市价']=None  
                df['盈亏']=None
                df['盈亏比(%)']=None
                df['当日买入']=None  
                df['当日卖出']=None
                df.to_excel(r'持股数据\持股数据.xlsx')
                return df
    def save_balance(self):
        '''
        保持账户数据
        '''
        df=self.trader.balance()
        df.to_excel(r'账户数据\账户数据.xlsx')
        return df
    def mean_line_models(self,df):
        '''
        均线模型
        趋势模型
        5，10，20，30，60
        '''
        df=df
        #df=self.bond_cov_data.get_cov_bond_hist_data(stock=stock,start=start_date,end=end_date,limit=1000000000)
        df1=pd.DataFrame()
        df1['date']=df['date']
        df1['5']=df['close'].rolling(window=5).mean()
        df1['10']=df['close'].rolling(window=10).mean()
        df1['20']=df['close'].rolling(window=20).mean()
        df1['30']=df['close'].rolling(window=30).mean()
        df1['60']=df['close'].rolling(window=60).mean()
        score=0
        #加分的情况
        mean_5=df1['5'].tolist()[-1]
        mean_10=df1['10'].tolist()[-1]
        mean_20=df1['20'].tolist()[-1]
        mean_30=df1['30'].tolist()[-1]
        mean_60=df1['60'].tolist()[-1]
        #相邻2个均线进行比较
        if mean_5>mean_10:
            score+=25
        if mean_10>mean_20:
            score+=25
        if mean_20>mean_30:
            score+=25
        if mean_30>mean_60:
            score+=25
        return score
    def get_del_buy_sell_data(self):
        '''
        处理交易股票池买入股票
        '''
        with open(r'分析配置.json',encoding='utf-8') as f:
            com=f.read()
        text=json.loads(com)
        limit=text['持股限制']
        n=text['自定义交易品种跌破N日均线卖出']
        df=pd.read_excel(r'持股数据\持股数据.xlsx',dtype='object')
        df1=df[df['可用余额']>=10]
        hold_stock_list=df['证券代码'].tolist()
        trader_df=pd.read_excel(r'买入股票\买入股票.xlsx',dtype='object')
        if trader_df.shape[0]>0:
            trader_df['证券代码']=trader_df['证券代码'].astype(str)
            def select_data(stock):
                if stock in hold_stock_list:
                    try:
                        num=df1[df1['证券代码']==stock]['可用余额'].tolist()[-1]
                        if float(num)>=float(limit):
                            return '持股超过限制'
                        else:
                            return '持股不足'
                    except:
                        return '持股超过限制'
                else:
                    return '没有持股'
            trader_df['持股检查']=trader_df['证券代码'].apply(select_data)
            trader_df=trader_df[trader_df['持股检查'] !='持股超过限制']
            hold_stock_list=trader_df['证券代码'].tolist()
            sell_list=[]
            mean_score_list=[]
            for stock in hold_stock_list:
                try:
                    hist_df=self.data.get_hist_data_em(stock=stock)
                    score=self.mean_line_models(df=hist_df)
                    mean_score_list.append(score)
                    models=shape_analysis(df=hist_df)
                    mean_line=models.get_down_mean_line_sell(n=n)
                    if mean_line=='是':
                        sell_list.append('是')
                    else:
                        sell_list.append('不是')
                except:
                    print('{}有问题--处理交易股票池买入股票'.format(stock))
                    mean_score_list.append(None)
                    sell_list.append('是')
            trader_df['跌破均线']=sell_list
            trader_df['均线得分']=mean_score_list
            trader_df=trader_df[trader_df['跌破均线']=='不是']  
            trader_df=trader_df.sort_values(by='均线得分',ascending=False)
            trader_df.to_excel(r'买入股票\买入股票.xlsx')
            print(trader_df)
            return trader_df
        else:
            print('-处理交易股票池买入股票,买入文件没有数据')
    def get_buy_sell_stock(self):
        '''
        获取买卖数据
        '''
        with open('分析配置.json'.format(self.path),encoding='utf-8') as f:
            com=f.read()
        text=json.loads(com)
        buy_num=text['买入前N']
        hold_limit=text['持有限制']
        df=pd.read_excel(r'持股数据\持股数据.xlsx',dtype='object')
        hold_min_score=text['自定义交易品种持有分数']
        df1=df[df['可用余额']>=10]
        hold_stock_list=df['证券代码'].tolist()
        def select_stock(x):
            '''
            选择股票
            '''
            if x in hold_stock_list:
                return '持股不足'
            else:
                return "持股不足"
        try:
            del df['Unnamed: 0']
        except:
            pass
        trader_df=pd.read_excel(r'买入股票\买入股票.xlsx',dtype='object')
        try:
            del trader_df['Unnamed: 0']
        except:
            pass
        sell_df=pd.read_excel(r'卖出股票\卖出股票.xlsx')
        if sell_df.shape[0]>0:
            sell_df['证券代码']=sell_df['证券代码'].astype(str)
            sell_list=sell_df['证券代码'].tolist()
        else:
            print('卖出文件没有数据')
            sell_list=[]
        if trader_df.shape[0]>0:
            trader_df['选择']=trader_df['证券代码'].apply(select_stock)
            trader_df=trader_df[trader_df['选择']=='持股不足']
            if df1.shape[0]>0:
                #卖出列表
                
                #持股列表
                hold_stock_list=df['证券代码'].tolist()
                #对持有的可转债做均线分析
                for stock in hold_stock_list:
                    try:
                        bond_data=self.data.get_hist_data_em(stock=stock)
                        socre=self.mean_line_models(df=bond_data)
                        if socre<hold_min_score:
                            print('{} {}分数不符合最低{}分'.format(stock,socre,hold_min_score))
                            sell_list.append(stock)
                        else:
                            pass
                    except:
                        print('{}卖出数据有问题'.format(stock))
                #跌破均线分析
                n=text['自定义交易品种跌破N日均线卖出']
                for stock in hold_stock_list:
                        try:
                            hist_df=self.data.get_hist_data_em(stock=stock)
                            models=shape_analysis(df=hist_df)
                            mean_line=models.get_down_mean_line_sell(n=n)
                            if mean_line=='是':
                                sell_list.append(stock)
                                print('{}跌破均线'.format(stock))
                            else:
                                pass
                        except:
                            pass
                sell_df=pd.DataFrame()
                sell_df['证券代码']=sell_list
                sell_df['交易状态']='未卖'
                if sell_df.shape[0]>0:
                    print('卖出*****************')
                    print(sell_df)
                    sell_df['策略名称']=self.name
                    sell_df=sell_df[['证券代码','交易状态']]
                    sell_df.to_excel(r'卖出股票\卖出股票.xlsx')
                else:
                    print('没有卖出的可转债')
                    sell_df['证券代码']=[None]
                    sell_df['交易状态']=[None]
                    sell_df['策略名称']=self.name
                    sell_df=sell_df[['证券代码','交易状态']]
                    sell_df.to_excel(r'卖出股票\卖出股票.xlsx')
                hold_num=df1.shape[0]
                if hold_num>0:
                    av_buy_num=hold_limit-hold_num
                    av_buy_num=av_buy_num+sell_df.shape[0]
                    buy_df=trader_df[:av_buy_num]
                else:
                    buy_df=trader_df[:buy_num]
                buy_df['交易状态']='未买'
                print('买入*****************')
                print(buy_df)
                buy_df=buy_df[['证券代码','交易状态']]
                buy_df.to_excel(r'买入股票\买入股票.xlsx')
                return buy_df
            else:
                buy_df=trader_df[:hold_limit]
                buy_df['交易状态']='未买'
                print('买入*****************')
                print(buy_df)
                buy_df=buy_df[['证券代码','交易状态']]
                buy_df.to_excel(r'买入股票\买入股票.xlsx')
                return buy_df
        else:
            print('买入股票文件没有数据')
    def update_all_data(self):
        '''
        更新策略数据
        '''
        print(self.save_position())
        print(self.save_balance())
        self.get_del_buy_sell_data()
        self.get_buy_sell_stock()