initial_quant.py

# 导入函数库
from jqdata import *
import talib as tl
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import datetime
# 内置的email模块负责构建邮件
from email import *
from email.mime.text import MIMEText
# smtplib模块负责发送邮件
import smtplib


# 初始化函数，设定基准等等
def initialize(context):
    g.security_universe_index = ["000002.XSHG", "399101.XSHE",
                                 "399102.XSHE"]  # 选股"000300.XSHG" 沪深300 "399101.XSHE" 中小版  "399102.XSHE" 创业板
    g.watch_list = get_security_universe(context, g.security_universe_index, [])
    # 设置参数
    set_params(context)
    # 设定沪深300作为基准
    set_benchmark('000300.XSHG')
    # 开启动态复权模式(真实价格)
    set_option('use_real_price', True)
    # 输出内容到日志 log.info()
    log.info('初始函数开始运行且全局只运行一次')

    ### 股票相关设定 ###
    # 重置全局变量
    after_code_changed(context)
    # 股票类每笔交易时的手续费是：买入时佣金万分之三，卖出时佣金万分之三加千分之一印花税, 每笔交易佣金最低扣5块钱
    set_order_cost(OrderCost(close_tax=0.001, open_commission=0.0003, close_commission=0.0003, min_commission=5),
                   type='stock')

    ## 运行函数（reference_security为运行时间的参考标的；传入的标的只做种类区分，因此传入'000300.XSHG'或'510300.XSHG'是一样的）
    # 开盘前运行
    run_daily(before_market_open, time='07:00', reference_security='000300.XSHG')
    run_daily(before_market, time='07:05', reference_security='000300.XSHG')
    # 开盘时运行
    run_daily(market_open, time='open', reference_security='000300.XSHG')
    # 收盘后运行
    run_daily(after_market_close, time='16:00', reference_security='000300.XSHG')


def set_params(context):
    log.info('设置初始参数，每日早上7点将盘前符合条件买入/卖出得list收集')
    g.orderBuy = []  # 可买入list
    g.orderSell = []  # 可卖出list
    g.cleanSell = []  # 清仓list
    g.isSell = False  # 是否整体减仓25%
    g.bin_code = {}
    g.wai_code = {'002714.XSHE', '000876.XSHE'}


## 开盘前运行函数
def before_market(context):
    print('开盘前运行函数')
    date = context.current_dt.strftime("%Y-%m-%d")
    today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
    yesterday = context.previous_date.strftime('%Y-%m-%d')
    before_yesterday = shifttradingday(today, shift=-2)

    val = ''
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg.as_string())

    # val_wai = '昨日外资增持超1亿的股票列表如下：\n'
    # g.wai_list = []
    # g.wai_list = wai_select(context,g.watch_list) # 根据外资指标选股
    # g.jian_list = jian_select(context,g.watch_list)
    g.mao_list = {'300748.XSHE', '002460.XSHE', '300014.XSHE', '600111.XSHG', '600073.XSHG', '601985.XSHG',
                  '002182.XSHE', '603393.XSHG', '600787.XSHG', '003816.XSHE', '002302.XSHE', '601216.XSHG',
                  '600027.XSHG', '002202.XSHE', '601390.XSHG', '000830.XSHE', '601186.XSHG', '600089.XSHG',
                  '601618.XSHG', '601117.XSHG', '600072.XSHG', '002302.XSHE', '601128.XSHG', '600011.XSHG',
                  '600150.XSHG', '600438.XSHG', '002050.XSHE', '600801.XSHG', '002839.XSHE', '000425.XSHE',
                  '002258.XSHE', '002129.XSHE', '002493.XSHE', '601233.XSHG', '600332.XSHG', '600295.XSHG',
                  '600348.XSHG', '002064.XSHE', '000983.XSHE', '601857.XSHG', '601668.XSHG', '601669.XSHG',
                  '601800.XSHG', '601899.XSHG', '603993.XSHG', '600547.XSHG', '002340.XSHE', '601600.XSHG',
                  '601168.XSHG', '601919.XSHG', '600019.XSHG', '601225.XSHG', '601808.XSHG', '002353.XSHE',
                  '002092.XSHE'}

    val_wai = '昨日外资增持超1亿的股票列表如下：\n'
    g.wai_list = []
    g.wai_list = wai_select(context, g.watch_list)  # 根据外资指标选股
    g.jian_list = jian_select(context, g.watch_list)
    g.mao_list = {'601515.XSHG', '002610.XSHE', '300115.XSHE', '000400.XSHE', '002460.XSHE', '001979.XSHE',
                  '300748.XSHE', '002460.XSHE', '300014.XSHE', '600111.XSHG', '600073.XSHG', '601985.XSHG',
                  '002182.XSHE', '603393.XSHG', '600787.XSHG', '003816.XSHE', '002302.XSHE', '601216.XSHG',
                  '600027.XSHG', '002202.XSHE', '601390.XSHG', '000830.XSHE', '601186.XSHG', '600089.XSHG',
                  '601618.XSHG', '601117.XSHG', '600072.XSHG', '002302.XSHE', '601128.XSHG', '600011.XSHG',
                  '600150.XSHG', '600438.XSHG', '002050.XSHE', '600801.XSHG', '002839.XSHE', '000425.XSHE',
                  '002258.XSHE', '002129.XSHE', '002493.XSHE', '601233.XSHG', '600332.XSHG', '600295.XSHG',
                  '600348.XSHG', '002064.XSHE', '000983.XSHE', '601857.XSHG', '601668.XSHG', '601669.XSHG',
                  '601800.XSHG', '601899.XSHG', '603993.XSHG', '600547.XSHG', '002340.XSHE', '601600.XSHG',
                  '601168.XSHG', '601919.XSHG', '600019.XSHG', '601225.XSHG', '601808.XSHG', '002353.XSHE',
                  '002092.XSHE'}

    for wai_code in g.wai_list:
        industry_forcast_1 = get_industry(wai_code)[wai_code].get('sw_l2')
        # 昨日股价收盘价
        df_price = get_price(wai_code, start_date=yesterday, end_date=yesterday, frequency='daily', fields=['close'])
        df_share = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                                            finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                            finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share_1 = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                                              finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                                              finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share = df_share.append(df_share_1)
        share_num = df_share.share_number

        # 前日股价收盘价
        df_the_price = get_price(wai_code, start_date=before_yesterday, end_date=before_yesterday, frequency='daily',
                                 fields=['close'])
        df_share_bef = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef_1 = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef = df_share_bef.append(df_share_bef_1)
        share_num_bef = df_share_bef.share_number

        if not (industry_forcast_1 is None):
            securityName = get_security_info(wai_code).display_name
            val_wai += '名称：' + str(securityName) + ' 所属二级行业：' + str(
                industry_forcast_1['industry_name']) + ' 外资总市值：' + str(
                round(np.float64(share_num.values) * np.float64(df_price['close']) / 100000000,
                      2)) + '亿，昨日增持：' + str(
                round(np.float64((share_num.values - share_num_bef.values) * df_price['close']) / 100000000, 2)) + '亿\n'

            # 获取主力资金流向
            df1 = get_money_flow(wai_code, start_date=yesterday, end_date=yesterday)
            if not (df1 is None):
                if np.float64(round(df1['net_amount_main'] / 10000, 2)) > np.float64(1):
                    val_wai += '     主力净流入超1亿\n'
                elif np.float64(round(df1['net_amount_main'] / 10000, 2)) < np.float64(-1):
                    val_wai += '     主力净流出超1亿\n'

    val_wai += '\n昨日外资减持超1亿的股票列表如下：\n'

    for wai_code in g.jian_list:
        industry_forcast_1 = get_industry(wai_code)[wai_code].get('sw_l2')
        # 昨日股价收盘价
        df_price = get_price(wai_code, start_date=yesterday, end_date=yesterday, frequency='daily', fields=['close'])
        df_share = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                                            finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                            finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share_1 = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                                              finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                                              finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share = df_share.append(df_share_1)
        share_num = df_share.share_number

        # 前日股价收盘价
        df_the_price = get_price(wai_code, start_date=before_yesterday, end_date=before_yesterday, frequency='daily',
                                 fields=['close'])
        df_share_bef = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef_1 = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == wai_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef = df_share_bef.append(df_share_bef_1)
        share_num_bef = df_share_bef.share_number

        if not (industry_forcast_1 is None):
            securityName = get_security_info(wai_code).display_name
            val_wai += '名称：' + str(securityName) + ' 所属二级行业：' + str(
                industry_forcast_1['industry_name']) + ' 外资总市值：' + str(
                round(np.float64(share_num.values) * np.float64(df_price['close']) / 100000000,
                      2)) + '亿，昨日减持：' + str(
                round(np.float64((share_num_bef.values - share_num.values) * df_price['close']) / 100000000, 2)) + '亿\n'

            # 获取主力资金流向
            df1 = get_money_flow(wai_code, start_date=yesterday, end_date=yesterday)
            if not (df1 is None):
                if np.float64(round(df1['net_amount_main'] / 10000, 2)) > np.float64(1):
                    val_wai += '     主力净流入超1亿\n'
                elif np.float64(round(df1['net_amount_main'] / 10000, 2)) < np.float64(-1):
                    val_wai += '     主力净流出超1亿\n'

    val_wai += '\n观察股的外资资金数据如下：\n'

    for mao_code in g.mao_list:
        # 昨日港资数据
        df_share = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == mao_code,
                                                                            finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                            finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share_1 = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == mao_code,
                                                                              finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                                              finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share = df_share.append(df_share_1)
        share_num = df_share.share_number

        # 前日港资数据
        df_share_bef = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == mao_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef_1 = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == mao_code,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef = df_share_bef.append(df_share_bef_1)
        share_num_bef = df_share_bef.share_number

        if not (share_num is None) and not (share_num_bef is None):
            securityName = get_security_info(mao_code).display_name
            if not (securityName is None):
                val_wai += '名称：' + str(securityName) + ' 外资昨日持股：' + str(
                    np.round(np.float64(share_num.values) / 10000, 2)) + '万股' + '，前日持股：' + str(
                    np.round(np.float64(share_num_bef.values) / 10000, 2)) + '万股\n'

            # 获取主力资金流向
            df1 = get_money_flow(mao_code, start_date=yesterday, end_date=yesterday)
            if not (df1 is None):
                if np.float64(round(df1['net_amount_main'] / 10000, 2)) > np.float64(1):
                    val_wai += '     主力净流入超1亿\n'
                elif np.float64(round(df1['net_amount_main'] / 10000, 2)) < np.float64(-1):
                    val_wai += '     主力净流出超1亿\n'

    # 构建邮件主体
    sender = 'autumnqt0913@vip.qq.com'
    # mailto_list = ['chang20204@163.com']
    mailto_list = ['chang20204@163.com']
    # mailto_list = ['chang20204@163.com','863897058@qq.com']
    # smtp服务器
    smtp_server = 'smtp.qq.com'
    # 授权码
    password = 'docprdidujgebcjb'
    # 负责发送邮件
    server = smtplib.SMTP(smtp_server, 25)
    # 登录SMTP服务器,password不是邮箱登录的密码，而是授权码
    server.login(sender, password)

    msg_wai = MIMEText(val_wai, 'plain', 'utf-8')
    msg_wai['From'] = sender
    msg_wai['To'] = ';'.join(mailto_list)
    msg_wai['Subject'] = '沪深港通-外资资金数据'
    # 发送邮件
    server.sendmail(sender, mailto_list, msg_wai.as_string())

    val_fund = '昨日场内基金份额数据如下：\n'

    g.fund_list = {'516950.XSHG', '512880.XSHG', '512400.XSHG', '512000.XSHG', '511010.XSHG', '512660.XSHG',
                   '518880.XSHG', '512800.XSHG', '515210.XSHG', '515220.XSHG'}

    for fund_code in g.fund_list:
        df_fund = finance.run_query(query(finance.FUND_SHARE_DAILY).filter(finance.FUND_SHARE_DAILY.date == yesterday,
                                                                           finance.FUND_SHARE_DAILY.code == fund_code).limit(
            1))
        if not (df_fund is None):
            val_fund += '基金：' + str(df_fund.name.values) + ' 昨日份额：' + str(
                np.round(np.float64(df_fund.shares.values) / 10000, 2)) + '万份\n'
        df_fund_bef = finance.run_query(
            query(finance.FUND_SHARE_DAILY).filter(finance.FUND_SHARE_DAILY.date == before_yesterday,
                                                   finance.FUND_SHARE_DAILY.code == fund_code).limit(1))
        if not (df_fund_bef is None):
            val_fund += '             前日份额：' + str(round(np.float64(df_fund_bef.shares.values) / 10000, 2)) + '万份\n'

    msg_fund = MIMEText(val_fund, 'plain', 'utf-8')
    msg_fund['From'] = sender
    msg_fund['To'] = ';'.join(mailto_list)
    msg_fund['Subject'] = '场内基金-份额数据'
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg_fund.as_string())

    server.quit()


def wai_select(context, stock_list):
    date = context.current_dt.strftime("%Y-%m-%d")
    today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
    yesterday = context.previous_date.strftime('%Y-%m-%d')
    before_yesterday = shifttradingday(today, shift=-2)

    final_list = []

    for stock in stock_list:
        # 昨日股价收盘价
        df_price = get_price(stock, start_date=yesterday, end_date=yesterday, frequency='daily', fields=['close'])
        df_share = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                            finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                            finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share_1 = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                              finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                                              finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share = df_share.append(df_share_1)
        share_num = df_share.share_number

        # 前日股价收盘价
        df_the_price = get_price(stock, start_date=before_yesterday, end_date=before_yesterday, frequency='daily',
                                 fields=['close'])
        df_share_bef = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                                finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                                finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef_1 = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef = df_share_bef.append(df_share_bef_1)
        share_num_bef = df_share_bef.share_number

        if share_num.empty or share_num_bef.empty:
            security = g.security
        # 获取到每天外资买入持仓市值>6亿（昨天股价*昨天数量），且当天买入超过1亿市值（昨天股价*昨天数量 -昨天股价*前天数量）的股票
        elif int((share_num.values - share_num_bef.values) * df_price['close']) > int(1e+8):
            if int(share_num.values * df_price['close']) > int(6e+8):
                final_list.append(stock)

    # for x in a:
    #    final_list.append(x[0])

    return final_list


def jian_select(context, stock_list):
    date = context.current_dt.strftime("%Y-%m-%d")
    today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
    yesterday = context.previous_date.strftime('%Y-%m-%d')
    before_yesterday = shifttradingday(today, shift=-2)

    final_list = []

    for stock in stock_list:
        # 昨日股价收盘价
        df_price = get_price(stock, start_date=yesterday, end_date=yesterday, frequency='daily', fields=['close'])
        df_share = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                            finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                            finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share_1 = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                              finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                                              finance.STK_HK_HOLD_INFO.day == yesterday))
        df_share = df_share.append(df_share_1)
        share_num = df_share.share_number

        # 前日股价收盘价
        df_the_price = get_price(stock, start_date=before_yesterday, end_date=before_yesterday, frequency='daily',
                                 fields=['close'])
        df_share_bef = finance.run_query(query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                                                finance.STK_HK_HOLD_INFO.link_id == 310001,
                                                                                finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef_1 = finance.run_query(
            query(finance.STK_HK_HOLD_INFO).filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                   finance.STK_HK_HOLD_INFO.link_id == 310002,
                                                   finance.STK_HK_HOLD_INFO.day == before_yesterday))
        df_share_bef = df_share_bef.append(df_share_bef_1)
        share_num_bef = df_share_bef.share_number

        if share_num.empty or share_num_bef.empty:
            security = g.security
        # 获取到每天外资买入持仓市值>10亿（昨天股价*昨天数量），且当天卖出超过1亿市值（昨天股价*前天数量 - 昨天股价*昨天数量）的股票
        elif int((share_num_bef.values - share_num.values) * df_price['close']) > int(1e+8):
            if int(share_num.values * df_price['close']) > int(6e+8):
                final_list.append(stock)

    return final_list


## 开盘时运行函数
def market_open(context):
    log.info('开盘时函数运行时间(market_open):' + str(context.current_dt.time()))
    security = g.security
    # （g.为全局变量）
    # 每笔交易资金为初始资金的12.5%
    value = context.portfolio.starting_cash * 0.125

    print('目标池买入：' + str(g.orderBuy))
    print('目标池卖出：' + str(g.orderSell))

    val = ''

    if g.isSell:
        # 获取当前所持仓位
        long_positions_dict = context.subportfolios[0].long_positions
        list_long = list(long_positions_dict.keys())
        print('当前所持仓位：' + str(list_long))
        g.orderB = []
        for stock_today in long_positions_dict:
            df_share_num = finance.run_query(query(finance.STK_HK_HOLD_INFO)
                                             .filter(finance.STK_HK_HOLD_INFO.code == stock_today,
                                                     finance.STK_HK_HOLD_INFO.day == context.previous_date.strftime(
                                                         '%Y-%m-%d')))
            print('持股Number昨天1：' + str(stock_today) + str(df_share_num.share_ratio))
            date = context.current_dt.strftime("%Y-%m-%d")
            today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
            before_yesterday = shifttradingday(today, shift=-2)
            df_share_before_num = finance.run_query(query(finance.STK_HK_HOLD_INFO)
                                                    .filter(finance.STK_HK_HOLD_INFO.code == stock_today,
                                                            finance.STK_HK_HOLD_INFO.day == before_yesterday))
            print('持股Number前天1：' + str(stock_today) + str(df_share_before_num.share_ratio))

            ifPercent = df_share_num.share_ratio / df_share_before_num.share_ratio
            if np.float64(ifPercent) > 1:
                print('未流出')
                g.orderB.append(stock_today)
        # 如果当前持仓股未流出，那么就不减仓，取差集
        list_for_sell = list(set(list_long).difference(set(g.orderB)))
        print('需要减持的仓位：' + str(list_for_sell))
        val += '外资净流出超过40亿，需要减仓操作以下仓位：\n'
        # 减少50%仓位
        for stock_list_sell in list_for_sell:
            print('减仓：' + str(stock_list_sell) + '该股原始仓位:' + str(
                context.subportfolios[0].long_positions[stock_list_sell].total_amount))
            print('减仓：' + str(stock_list_sell) + '减仓后仓位:' + str(
                0.5 * context.subportfolios[0].long_positions[stock_list_sell].total_amount))
            if (context.subportfolios[0].long_positions[stock_list_sell].security != '600519.XSHG'):
                # if (context.subportfolios[0].long_positions[stock_list_sell].total_amount * 0.25) <= 100:
                if (context.subportfolios[0].long_positions[stock_list_sell].total_amount * 0.5) <= 100:
                    order_target(stock_list_sell, 0)
                else:
                    total_amount_sell = g.bin_code[stock_list_sell]
                    print('*********' + str(total_amount_sell))
                    # order(stock_list_sell, -0.5 * total_amount_sell)
                    order(stock_list_sell, -0.25 * total_amount_sell)
                    # order_target(stock_list_sell, 0.75 * total_amount_sell)
                sec = get_security_info(context.subportfolios[0].long_positions[stock_list_sell].security)
                val += str(sec.display_name) + '\n'
    else:
        # 现持仓的股票，如果在“目标池卖出”中就卖出,每次卖出持仓的25%，直到卖没
        for stock_sell in g.orderSell:
            print('除开茅台')
            if (context.subportfolios[0].long_positions[stock_sell].security != '600519.XSHG'):
                if (context.portfolio.long_positions[stock_sell].total_amount > 0):
                    if (0.75 * context.subportfolios[0].long_positions[stock_sell].total_amount > 100):
                        # if (0.875 * context.subportfolios[0].long_positions[stock_sell].total_amount > 100) :
                        # if (0.125 * context.subportfolios[0].long_positions[stock_sell].total_amount <= 100) :
                        if (0.25 * context.subportfolios[0].long_positions[stock_sell].total_amount <= 100):
                            order_target(stock_sell, 0)
                        else:
                            total_amount_sell = g.bin_code[stock_sell]
                            print('*********#' + str(total_amount_sell))
                            order(stock_sell, -0.25 * total_amount_sell)
                            # order_target(stock_sell, 0.875 * total_amount_sell)
                    else:
                        order_target(stock_sell, 0)
                    sec = get_security_info(context.subportfolios[0].long_positions[stock_sell].security)
                    val += '根据昨日港资数据，卖出仓位：' + str(sec.display_name) + '\n'
                    # order_value(stock_sell, -value)
                    print('##########该股：' + stock_sell + '已卖出1/4仓位，目前持有股数: ' + str(
                        context.portfolio.long_positions[stock_sell].total_amount) + '股')

    long_positions_dict = context.subportfolios[0].long_positions
    for long_dict in long_positions_dict:
        if long_positions_dict[long_dict].avg_cost > 1.15 * long_positions_dict[long_dict].price:
            print('亏损15%，止损')
            order_target(long_dict, 0)
            sec = get_security_info(context.subportfolios[0].long_positions[long_dict].security)
            val += '亏损15%，止损该股：' + str(sec.display_name) + '\n'
            total_stock = {long_dict: context.portfolio.long_positions[long_dict].total_amount}
            g.bin_code.update(total_stock)

    # 依次买入“目标池买入”中的股票,每次买入初始资金的12.5%，直到买满
    if context.portfolio.available_cash >= context.portfolio.starting_cash * 0.125:
        for stock in g.orderBuy:
            # 当前账户可用资金大于12.5%且单只股票持仓资金占比不超过总资金的37.5%就可以买入
            if (context.portfolio.long_positions[stock].value >= (context.portfolio.starting_cash * 0.26)):
                print('##########11该只股票：' + stock + '持仓资金已占37.5%总市值，不继续买入')
            else:
                if context.portfolio.available_cash >= context.portfolio.starting_cash * 0.125:
                    order_value(stock, value)
                    sec = get_security_info(context.subportfolios[0].long_positions[stock].security)
                    val += '根据昨日港资数据，买入仓位：' + str(sec.display_name) + '\n'
                    print('##########该股：' + stock + ' 买入价：' + str(context.portfolio.long_positions[stock].price) +
                          ' 目前持有股数: ' + str(
                        context.portfolio.long_positions[stock].total_amount) + '股 当前持仓成本： ' + str(
                        context.portfolio.long_positions[stock].acc_avg_cost))
                    total_stock = {stock: context.portfolio.long_positions[stock].total_amount}
                    g.bin_code.update(total_stock)

    # 获取当前所持仓位
    long_positions_dict_today = context.subportfolios[0].long_positions
    val += '\n当前持仓明细：\n'
    for position in list(long_positions_dict_today.values()):
        # 获得持仓名称
        sec = get_security_info(position.security)
        value = round(position.value / context.subportfolios[0].positions_value, 2) * 100
        val += str(sec.display_name) + '持仓价值占比:' + str(value) + '%\n'
        val += '开仓均价:' + str(round(position.avg_cost, 2)) + '\n'
        val += '该股总仓位:' + str(position.total_amount) + '股\n'
        val += '建仓时间:' + str(position.init_time) + '\n'
        val += '最后交易时间:' + str(position.transact_time) + '\n'
        ying = round(((position.value - position.avg_cost * position.total_amount) / (
                    position.avg_cost * position.total_amount)), 2) * 100
        val += '盈亏占比:' + str(ying) + '%\n'
        val += '\n'
        total_stock = {position.security: position.total_amount}
        g.bin_code.update(total_stock)

    # 构建邮件主体
    # sender = 'autumnqt0913@vip.qq.com'
    # mailto_list = ['chang20204@163.com']
    # mailto_list = ['chang20204@163.com','syh227ss@163.com','863897058@qq.com','songqun03111@163.com']
    # smtp服务器
    # smtp_server = 'smtp.qq.com'
    # 授权码
    # password = 'docprdidujgebcjb'
    # 负责发送邮件
    # server = smtplib.SMTP(smtp_server,25)
    # 登录SMTP服务器,password不是邮箱登录的密码，而是授权码
    # server.login(sender,password)
    msg = MIMEText(val, 'plain', 'utf-8')
    msg['From'] = sender
    msg['To'] = ';'.join(mailto_list)
    msg['Subject'] = '沪深港通-模拟持仓明细'
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg.as_string())
    # server.quit()


## 收盘后运行函数
def after_market_close(context):
    date = context.current_dt.strftime("%Y-%m-%d")
    today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
    yesterday = context.previous_date.strftime('%Y-%m-%d')
    before_yesterday = shifttradingday(today, shift=-15)

    log.info(str('函数运行时间(after_market_close):' + str(context.current_dt.time())))

    df_future = get_extras('futures_positions',
                           ['IC9999.CCFX', 'IF9999.CCFX', 'IH9999.CCFX', 'T9999.CCFX', 'SC9999.XINE', 'AU9999.XSGE'],
                           start_date=before_yesterday, end_date=today, df=True)

    val = '商品名称：\n'

    val += '1.中证500: 今日仓单:' + str(df_future['IC9999.CCFX'][-1]) + '手，昨日仓单:' + str(
        df_future['IC9999.CCFX'][-2]) + '手，持仓变化：' + str(
        df_future['IC9999.CCFX'][-1] - df_future['IC9999.CCFX'][-2]) + '手\n'
    val += '2.沪深300: 今日仓单:' + str(df_future['IF9999.CCFX'][-1]) + '手，昨日仓单:' + str(
        df_future['IF9999.CCFX'][-2]) + '手，持仓变化：' + str(
        df_future['IF9999.CCFX'][-1] - df_future['IF9999.CCFX'][-2]) + '手\n'
    val += '3.上证50: 今日仓单:' + str(df_future['IH9999.CCFX'][-1]) + '手，昨日仓单:' + str(
        df_future['IH9999.CCFX'][-2]) + '手，持仓变化：' + str(
        df_future['IH9999.CCFX'][-1] - df_future['IH9999.CCFX'][-2]) + '手\n'
    val += '4.十年期国债: 今日仓单:' + str(df_future['T9999.CCFX'][-1]) + '手，昨日仓单:' + str(
        df_future['T9999.CCFX'][-2]) + '手，持仓变化：' + str(
        df_future['T9999.CCFX'][-1] - df_future['T9999.CCFX'][-2]) + '手\n'
    val += '5.原油主力: 今日仓单:' + str(df_future['SC9999.XINE'][-1]) + '手，昨日仓单:' + str(
        df_future['SC9999.XINE'][-2]) + '手，持仓变化：' + str(
        df_future['SC9999.XINE'][-1] - df_future['SC9999.XINE'][-2]) + '手\n'
    val += '6.沪金主力: 今日仓单:' + str(df_future['AU9999.XSGE'][-1]) + '手，昨日仓单:' + str(
        df_future['AU9999.XSGE'][-2]) + '手，持仓变化：' + str(
        df_future['AU9999.XSGE'][-1] - df_future['AU9999.XSGE'][-2]) + '手'

    # 构建邮件主体
    sender = 'autumnqt0913@vip.qq.com'
    # mailto_list = ['chang20204@163.com']
    mailto_list = ['chang20204@163.com', 'syh227ss@163.com', '863897058@qq.com', 'songqun03111@163.com']
    # smtp服务器
    smtp_server = 'smtp.qq.com'
    # 授权码
    password = 'docprdidujgebcjb'
    # 负责发送邮件
    server = smtplib.SMTP(smtp_server, 25)
    # 登录SMTP服务器,password不是邮箱登录的密码，而是授权码
    server.login(sender, password)
    msg = MIMEText(val, 'plain', 'utf-8')
    msg['From'] = sender
    msg['To'] = ';'.join(mailto_list)
    msg['Subject'] = '股指国债原油黄金持仓明细'
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg.as_string())
    server.quit()

    log.info('一天结束#')


def set_params(context):
    log.info('设置初始参数，每日早上7点将盘前符合条件买入/卖出得list收集')
    g.orderBuy = []  # 可买入list
    g.orderSell = []  # 可卖出list
    g.cleanSell = []  # 清仓list
    g.isSell = False  # 是否整体减仓25%
    g.bin_code = {}
    g.wai_code = {'002714.XSHE', '000876.XSHE'}


## 开盘前运行函数
def before_market_open(context):
    g.wai_code = {'002064.XSHE', '600519.XSHG', '600009.XSHG', '000858.XSHE', '002594.XSHE', '002511.XSHE',
                  '600887.XSHG', '002714.XSHE', '000651.XSHE', '300059.XSHE', '300750.XSHE', '601012.XSHG',
                  '600570.XSHG', '601318.XSHG', '600309.XSHG', '600438.XSHG', '600036.XSHG', '000661.XSHE',
                  '600276.XSHG', '300750.XSHE', '000333.XSHE', '601888.XSHG', '603288.XSHG', '600585.XSHG',
                  '600031.XSHG', '002475.XSHE', '600176.XSHG', '300014.XSHE', '000786.XSHE', '002142.XSHE',
                  '600048.XSHG', '000002.XSHE', '603993.XSHG', '601899.XSHG', '601225.XSHG', '002460.XSHE',
                  '002340.XSHE', '601919.XSHG', '600019.XSHG', '600547.XSHG'}
    # 输出运行时间
    log.info('函数运行时间(before_market_open)：' + str(context.current_dt.time()))
    date = context.current_dt.strftime("%Y-%m-%d")
    today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
    yesterday = context.previous_date.strftime('%Y-%m-%d')
    print('当天交易日:' + str(yesterday))
    ##沪市
    q_hu = query(finance.STK_EL_TOP_ACTIVATE).filter(finance.STK_EL_TOP_ACTIVATE.day == yesterday,
                                                     finance.STK_EL_TOP_ACTIVATE.link_id == '310001').limit(10)
    df_hu = finance.run_query(q_hu)
    ##深市
    q_shen = query(finance.STK_EL_TOP_ACTIVATE).filter(finance.STK_EL_TOP_ACTIVATE.day == yesterday,
                                                       finance.STK_EL_TOP_ACTIVATE.link_id == '310002').limit(10)
    df_shen = finance.run_query(q_shen)

    # 净买入;净买入占买入卖出比例
    df_hu['net'] = df_hu.buy - df_hu.sell
    df_shen['net'] = df_shen.buy - df_shen.sell

    df_hu['net_p'] = (df_hu.buy - df_hu.sell) / (df_hu.buy + df_hu.sell)
    df_shen['net_p'] = (df_shen.buy - df_shen.sell) / (df_hu.buy + df_hu.sell)

    # 条件1买入：倒序排列净买入最多的，筛选出净买入金额大于1亿 且 净买入占比买入卖出>15% 的DataFrame，再转换为list”
    df_hu_buy = df_hu.sort_values(by=['net'], axis=0, ascending=False).ix[
        (df_hu.net > 100000000) & ((df_hu.net / df_hu.total) > 0.15)]
    df_hu_buy = df_hu_buy.head(2)
    df_shen_buy = df_shen.sort_values(by=['net'], axis=0, ascending=False).ix[
        (df_shen.net > 100000000) & ((df_shen.net / df_shen.total) > 0.15)]
    df_shen_buy = df_shen_buy.head(2)

    # 条件1卖出：正序排列净卖出最多的，筛选出净卖出金额大于1亿 且 净卖出占比买入卖出>15% 的DataFrame，再转换为list”
    # df_hu_sell = df_hu.sort_values(by = ['net'] , axis = 0, ascending = True).ix[(df_hu.net < -100000000) & ((df_hu.net / df_hu.total) < -0.15)]
    df_hu_sell = df_hu.sort_values(by=['net'], axis=0, ascending=True).ix[(df_hu.net < -100000000)]
    # df_hu_sell = df_hu_sell.head(2)
    # df_shen_sell = df_shen.sort_values(by = ['net'] , axis = 0, ascending = True).ix[(df_shen.net <- 100000000) & ((df_shen.net / df_shen.total) < -0.15)]
    df_shen_sell = df_shen.sort_values(by=['net'], axis=0, ascending=True).ix[(df_shen.net < - 100000000)]
    # df_shen_sell = df_shen_sell.head(2)

    stock_list_buy_hu = list(df_hu_buy['code'])
    stock_list_sell_hu = list(df_hu_sell['code'])
    stock_list_buy_shen = list(df_shen_buy['code'])
    stock_list_sell_shen = list(df_shen_sell['code'])

    # 取深沪前两位的并集
    stock_list_buy = list(set(stock_list_buy_hu).union(set(stock_list_buy_shen)))
    stock_list_sell = list(set(stock_list_sell_hu).union(set(stock_list_sell_shen)))

    order_shareNum = []
    order_shareHolder = []

    val = ''

    for stock in stock_list_buy:
        # 查询出该股外资持股数量
        df_share_num = finance.run_query(query(finance.STK_HK_HOLD_INFO)
                                         .filter(finance.STK_HK_HOLD_INFO.code == stock,
                                                 finance.STK_HK_HOLD_INFO.day == yesterday))
        # 查询处该股当日收盘价
        h = attribute_history(stock, 1, '1d', ('close'), fq='pre')
        # 条件2：北向资金持股市值沪市>70亿,深市>35亿的加入临时shareNum list中
        if (stock.startswith('60')):
            if int((float(df_share_num.share_number) * h['close'])) > int(7e+9):
                # if (df_share_num.share_number * h['current'] > 7e+9).bool:
                print('沪市大于70')
                order_shareNum.append(stock)
        else:
            if int((float(df_share_num.share_number) * h['close'])) > int(3.5e+9):
                # if (df_share_num.share_number * h['current'] > 3.5e+9).bool:
                print('深市大于35')
                order_shareNum.append(stock)
        # 查询十大流通股东
        df_share_holder = finance.run_query(query(finance.STK_SHAREHOLDER_FLOATING_TOP10)
                                            .filter(finance.STK_SHAREHOLDER_FLOATING_TOP10.code == stock,
                                                    finance.STK_SHAREHOLDER_FLOATING_TOP10.pub_date > '2019-09-28').limit(
            10))
        # 条件3：前十大流动股东基金（基金代码3003）或者机构（代码25007）持仓比例（share_ratio）＞3%的加入临时shareHolder list中
        for row in df_share_holder.iterrows():
            if (df_share_holder.share_ratio > 3).bool and ((df_share_holder.shareholder_class_id == 3003).bool or (
                    df_share_holder.sharesnature_id == 25007).bool):
                order_shareHolder.append(stock)
                break;
    # 在条件1的基础上，取满足条件2，3的list，作为最终买入卖出的list表
    g.orderBuy = set(order_shareNum).intersection(set(order_shareHolder))

    # 卖出条件1：获取外资净流出金额
    df_quata_hu = finance.run_query(query(finance.STK_ML_QUOTA).filter(finance.STK_ML_QUOTA.day == yesterday,
                                                                       finance.STK_ML_QUOTA.link_id == '310001'))
    quata_hu = df_quata_hu.sell_amount - df_quata_hu.buy_amount

    df_quata_shen = finance.run_query(query(finance.STK_ML_QUOTA).filter(finance.STK_ML_QUOTA.day == yesterday,
                                                                         finance.STK_ML_QUOTA.link_id == '310002'))
    quata_shen = df_quata_shen.sell_amount - df_quata_shen.buy_amount

    print('净卖出hu: ' + str(quata_hu))
    print('净卖出shen: ' + str(quata_shen))

    # 如果外资整体净流出金额超过40亿就需要做减仓操作
    g.isSell = False
    if (quata_hu + quata_shen).values > 40:
        print('外资净流出超过40亿，需要减仓操作')
        g.isSell = True

    # 获取当前所持仓位
    long_positions_dict_today = context.subportfolios[0].long_positions
    for position in list(long_positions_dict_today.values()):
        # 获得持仓名称
        sec = get_security_info(position.security)
        total_stock = {position.security: position.total_amount}
        g.bin_code.update(total_stock)

    g.orderSell = list(set(stock_list_sell).intersection(set(long_positions_dict_today)))

    val = ''
    val += '昨日港资买入列表且满足北向资金持股市值沪市>70亿,深市>35亿的为:\n'
    for stock in g.orderBuy:
        sec = get_security_info(stock)
        val += str(sec.display_name) + '\n'
    val += '\n' + '昨日港资卖出列表：\n'
    for stock_sell in list(set(stock_list_sell)):
        sec = get_security_info(stock_sell)
        val += str(sec.display_name) + '\n'

    # 获取指数的当前PE，PB,股息率
    df_zhishu = get_zz_quote(
        ['000016', '000300', '399102', '399673', '399905', '000001', '399106', '399975', '000819', '399997', '399933',
         '399417', '399998', '399995', '399438'], start_date=yesterday)
    df_zhishu_07 = get_zz_quote(
        ['000016', '000300', '399102', '399673', '399905', '000001', '399106', '399975', '000819', '399997', '399933',
         '399417', '399998', '399995', '399438'], end_date='2007-10-16', count=1)
    df_zhishu_15 = get_zz_quote(
        ['000016', '000300', '399102', '399673', '399905', '000001', '399106', '399975', '000819', '399997', '399933',
         '399417', '399998', '399995', '399438'], end_date='2015-6-12', count=1)
    # print(df_zhishu)
    # 编码，动态市盈率，指数总市值，市净率
    # print(str(df['IndexCode']) + str(df['PE_TTM']) + str(df['TotalMV']) + str(df['PB_LF']))
    val += '\n指数数据\n'
    for index, zhishu in df_zhishu.iterrows():
        code_df = jy.run_query(query(
            jy.SecuMain.ChiNameAbbr
        ).filter(
            jy.SecuMain.InnerCode == zhishu.IndexCode))
        # print( str(df_zhishu['PE_TTM']))
        val += str(code_df['ChiNameAbbr'].values) + '\n'
        val += '动态市盈率：' + str(zhishu.PE_TTM)
        val += '  市净率：' + str(zhishu.PB_LF) + '\n'

        # 获取该指数的15年数据
        for index15, zhishu15 in df_zhishu_15.iterrows():
            if zhishu15.IndexCode == zhishu.IndexCode:
                val += '2015动态市盈率：' + str(zhishu15.PE_TTM)
                val += '  市净率：' + str(zhishu15.PB_LF) + '\n'

        # 获取该指数的07年数据
        for index07, zhishu07 in df_zhishu_07.iterrows():
            if zhishu07.IndexCode == zhishu.IndexCode:
                val += '2007动态市盈率：' + str(zhishu07.PE_TTM)
                val += '  市净率：' + str(zhishu07.PB_LF) + '\n'
    val += '\n'
    sumZhishu = 0
    # 获取上证和深圳综指的总市值及之和
    for index1, zhishu1 in df_zhishu.iterrows():
        if zhishu1.IndexCode == 1:
            val += '上证综指当日市值:' + str(round(zhishu1.TotalMV / 100000000, 2)) + '亿元\n'
            sumZhishu += zhishu1.TotalMV
        if zhishu1.IndexCode == 1059:
            val += '深证综指当日市值:' + str(round(zhishu1.TotalMV / 100000000, 2)) + '亿元\n'
            sumZhishu += zhishu1.TotalMV

    val += '两市总市值：' + str(round(sumZhishu / 100000000, 2)) + '亿元\n'

    val += '\n'

    quote_list = ['000016', '000300', '399102', '399673', '399905', '000001', '399106', '399975', '000819', '399997',
                  '399933', '399417']
    for quote in quote_list:
        q_zhongwei = []
        q_zhongpb = []
        s = repr(today.year)
        sy = s[2:]
        sy = int(sy)
        if today.month < 4:
            sy = sy - 1
        for i in range(sy + 1):
            year = 2000 + i
            df_quote = get_zz_quote(quote, end_date=str(year) + '-04-10', count=1)
            if df_quote is not None:
                if len(df_quote.PE_TTM.values) == 1:
                    q_zhongwei.append(df_quote.PE_TTM.values)
                    q_zhongpb.append(df_quote.PB_LF.values)

        q_zhongwei.sort()
        q_zhongpb.sort()
        zhongwei = int(len(q_zhongwei) / 2)
        zhongpb = int(len(q_zhongpb) / 2)

        code_df = jy.run_query(
            query(jy.SecuMain.ChiNameAbbr).filter(jy.SecuMain.SecuCode == quote, jy.SecuMain.ChiName.contains('指数')))

        val += '\n' + str(code_df['ChiNameAbbr'].values) + '\n'

        if len(q_zhongwei) % 2 == 0:
            val += '市盈率中位数：' + str((q_zhongwei[zhongwei - 1] + q_zhongwei[zhongwei]) / 2) + '\n'
            val += '市盈率平均数：' + str(sum(q_zhongwei) / len(q_zhongwei)) + '\n'
        else:
            val += '市盈率中位数：' + str(q_zhongwei[zhongwei]) + '\n'
            val += '市盈率平均数：' + str(sum(q_zhongwei) / len(q_zhongwei)) + '\n'

        if len(q_zhongpb) % 2 == 0:
            val += '市净率中位数：' + str(q_zhongpb[zhongpb]) + '\n'
            val += '市净率平均数：' + str(sum(q_zhongpb) / len(q_zhongpb)) + '\n'
        else:
            val += '市净率中位数：' + str(q_zhongpb[zhongpb]) + '\n'
            val += '市净率平均数：' + str(sum(q_zhongpb) / len(q_zhongpb)) + '\n'

    # 构建邮件主体
    sender = 'autumnqt0913@vip.qq.com'
    # mailto_list = ['chang20204@163.com']
    mailto_list = ['chang20204@163.com', 'syh227ss@163.com', '863897058@qq.com', 'songqun03111@163.com']
    # smtp服务器
    smtp_server = 'smtp.qq.com'
    # 授权码
    password = 'docprdidujgebcjb'
    # 负责发送邮件
    # server = smtplib.SMTP(smtp_server,25)
    # 登录SMTP服务器,password不是邮箱登录的密码，而是授权码
    # server.login(sender,password)
    msg = MIMEText(val, 'plain', 'utf-8')
    msg['From'] = sender
    msg['To'] = ';'.join(mailto_list)
    msg['Subject'] = '沪深港通-港资买卖'
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg.as_string())
    # server.quit()

    g.security = '000001.XSHE'


def get_zz_quote(code, end_date=None, count=None, start_date=None):
    if isinstance(code, str):
        code = [code]
    code.sort()
    days = get_trade_days(start_date, end_date, count)
    code_df = jy.run_query(query(
        jy.SecuMain.InnerCode, jy.SecuMain.SecuCode, jy.SecuMain.ChiName
    ).filter(
        jy.SecuMain.SecuCode.in_(code), jy.SecuMain.ChiName.contains('指数')).order_by(jy.SecuMain.SecuCode))

    if days.size != 0:
        df = jy.run_query(query(
            jy.LC_IndexDerivative).filter(
            jy.LC_IndexDerivative.IndexCode.in_(code_df.InnerCode),
            jy.LC_IndexDerivative.TradingDay == days[0],
        ))

        return df
    return None


## 开盘时运行函数
def market_open(context):
    log.info('开盘时函数运行时间(market_open):' + str(context.current_dt.time()))
    security = g.security
    # （g.为全局变量）
    # 每笔交易资金为初始资金的12.5%
    value = context.portfolio.starting_cash * 0.125

    print('目标池买入：' + str(g.orderBuy))
    print('目标池卖出：' + str(g.orderSell))

    val = ''

    if g.isSell:
        # 获取当前所持仓位
        long_positions_dict = context.subportfolios[0].long_positions
        list_long = list(long_positions_dict.keys())
        print('当前所持仓位：' + str(list_long))
        g.orderB = []
        for stock_today in long_positions_dict:
            df_share_num = finance.run_query(query(finance.STK_HK_HOLD_INFO)
                                             .filter(finance.STK_HK_HOLD_INFO.code == stock_today,
                                                     finance.STK_HK_HOLD_INFO.day == context.previous_date.strftime(
                                                         '%Y-%m-%d')))
            print('持股Number昨天1：' + str(stock_today) + str(df_share_num.share_ratio))
            date = context.current_dt.strftime("%Y-%m-%d")
            today = datetime.datetime.strptime(date, "%Y-%m-%d").date()
            before_yesterday = shifttradingday(today, shift=-2)
            df_share_before_num = finance.run_query(query(finance.STK_HK_HOLD_INFO)
                                                    .filter(finance.STK_HK_HOLD_INFO.code == stock_today,
                                                            finance.STK_HK_HOLD_INFO.day == before_yesterday))
            print('持股Number前天1：' + str(stock_today) + str(df_share_before_num.share_ratio))

            ifPercent = df_share_num.share_ratio / df_share_before_num.share_ratio
            if np.float64(ifPercent) > 1:
                print('未流出')
                g.orderB.append(stock_today)
        # 如果当前持仓股未流出，那么就不减仓，取差集
        list_for_sell = list(set(list_long).difference(set(g.orderB)))
        print('需要减持的仓位：' + str(list_for_sell))
        val += '外资净流出超过40亿，需要减仓操作以下仓位：\n'
        # 减少50%仓位
        for stock_list_sell in list_for_sell:
            print('减仓：' + str(stock_list_sell) + '该股原始仓位:' + str(
                context.subportfolios[0].long_positions[stock_list_sell].total_amount))
            print('减仓：' + str(stock_list_sell) + '减仓后仓位:' + str(
                0.5 * context.subportfolios[0].long_positions[stock_list_sell].total_amount))
            if (context.subportfolios[0].long_positions[stock_list_sell].security != '600519.XSHG'):
                # if (context.subportfolios[0].long_positions[stock_list_sell].total_amount * 0.25) <= 100:
                if (context.subportfolios[0].long_positions[stock_list_sell].total_amount * 0.5) <= 100:
                    order_target(stock_list_sell, 0)
                else:
                    total_amount_sell = g.bin_code[stock_list_sell]
                    print('*********' + str(total_amount_sell))
                    # order(stock_list_sell, -0.5 * total_amount_sell)
                    order(stock_list_sell, -0.25 * total_amount_sell)
                    # order_target(stock_list_sell, 0.75 * total_amount_sell)
                sec = get_security_info(context.subportfolios[0].long_positions[stock_list_sell].security)
                val += str(sec.display_name) + '\n'
    else:
        # 现持仓的股票，如果在“目标池卖出”中就卖出,每次卖出持仓的25%，直到卖没
        for stock_sell in g.orderSell:
            print('除开茅台')
            if (context.subportfolios[0].long_positions[stock_sell].security != '600519.XSHG'):
                if (context.portfolio.long_positions[stock_sell].total_amount > 0):
                    if (0.75 * context.subportfolios[0].long_positions[stock_sell].total_amount > 100):
                        # if (0.875 * context.subportfolios[0].long_positions[stock_sell].total_amount > 100) :
                        # if (0.125 * context.subportfolios[0].long_positions[stock_sell].total_amount <= 100) :
                        if (0.25 * context.subportfolios[0].long_positions[stock_sell].total_amount <= 100):
                            order_target(stock_sell, 0)
                        else:
                            total_amount_sell = g.bin_code[stock_sell]
                            print('*********#' + str(total_amount_sell))
                            order(stock_sell, -0.25 * total_amount_sell)
                            # order_target(stock_sell, 0.875 * total_amount_sell)
                    else:
                        order_target(stock_sell, 0)
                    sec = get_security_info(context.subportfolios[0].long_positions[stock_sell].security)
                    val += '根据昨日港资数据，卖出仓位：' + str(sec.display_name) + '\n'
                    # order_value(stock_sell, -value)
                    print('##########该股：' + stock_sell + '已卖出1/4仓位，目前持有股数: ' + str(
                        context.portfolio.long_positions[stock_sell].total_amount) + '股')

    long_positions_dict = context.subportfolios[0].long_positions
    for long_dict in long_positions_dict:
        if long_positions_dict[long_dict].avg_cost > 1.15 * long_positions_dict[long_dict].price:
            print('亏损15%，止损')
            order_target(long_dict, 0)
            sec = get_security_info(context.subportfolios[0].long_positions[long_dict].security)
            val += '亏损15%，止损该股：' + str(sec.display_name) + '\n'
            total_stock = {long_dict: context.portfolio.long_positions[long_dict].total_amount}
            g.bin_code.update(total_stock)

    # 依次买入“目标池买入”中的股票,每次买入初始资金的12.5%，直到买满
    if context.portfolio.available_cash >= context.portfolio.starting_cash * 0.125:
        for stock in g.orderBuy:
            # 当前账户可用资金大于12.5%且单只股票持仓资金占比不超过总资金的37.5%就可以买入
            if (context.portfolio.long_positions[stock].value >= (context.portfolio.starting_cash * 0.26)):
                print('##########11该只股票：' + stock + '持仓资金已占37.5%总市值，不继续买入')
            else:
                if context.portfolio.available_cash >= context.portfolio.starting_cash * 0.125:
                    order_value(stock, value)
                    sec = get_security_info(context.subportfolios[0].long_positions[stock].security)
                    val += '根据昨日港资数据，买入仓位：' + str(sec.display_name) + '\n'
                    print('##########该股：' + stock + ' 买入价：' + str(context.portfolio.long_positions[stock].price) +
                          ' 目前持有股数: ' + str(
                        context.portfolio.long_positions[stock].total_amount) + '股 当前持仓成本： ' + str(
                        context.portfolio.long_positions[stock].acc_avg_cost))
                    total_stock = {stock: context.portfolio.long_positions[stock].total_amount}
                    g.bin_code.update(total_stock)

    # 获取当前所持仓位
    long_positions_dict_today = context.subportfolios[0].long_positions
    val += '\n当前持仓明细：\n'
    for position in list(long_positions_dict_today.values()):
        # 获得持仓名称
        sec = get_security_info(position.security)
        value = round(position.value / context.subportfolios[0].positions_value, 2) * 100
        val += str(sec.display_name) + '持仓价值占比:' + str(value) + '%\n'
        val += '开仓均价:' + str(round(position.avg_cost, 2)) + '\n'
        val += '该股总仓位:' + str(position.total_amount) + '股\n'
        val += '建仓时间:' + str(position.init_time) + '\n'
        val += '最后交易时间:' + str(position.transact_time) + '\n'
        ying = round(((position.value - position.avg_cost * position.total_amount) / (
                    position.avg_cost * position.total_amount)), 2) * 100
        val += '盈亏占比:' + str(ying) + '%\n'
        val += '\n'
        total_stock = {position.security: position.total_amount}
        g.bin_code.update(total_stock)

    # 构建邮件主体
    # sender = 'autumnqt0913@vip.qq.com'
    # mailto_list = ['chang20204@163.com']
    # mailto_list = ['chang20204@163.com','syh227ss@163.com','863897058@qq.com']
    # smtp服务器
    # smtp_server = 'smtp.qq.com'
    # 授权码
    # password = 'docprdidujgebcjb'
    # 负责发送邮件
    # server = smtplib.SMTP(smtp_server,25)
    # 登录SMTP服务器,password不是邮箱登录的密码，而是授权码
    # server.login(sender,password)
    # msg = MIMEText(val,'plain','utf-8')
    # msg['From'] = sender
    # msg['To'] = ';'.join(mailto_list)
    # msg['Subject'] = '沪深港通-模拟持仓明细'
    # 发送邮件
    # server.sendmail(sender,mailto_list,msg.as_string())
    # server.quit()


## 收盘后运行函数
def after_market_close(context):
    log.info('一天结束')


def shifttradingday(date, shift):
    # 获取N天前的交易日日期
    # 获取所有的交易日，返回一个包含所有交易日的 list,元素值为 datetime.date 类型.
    tradingday = get_all_trade_days()
    # 得到date之后shift天那一天在列表中的行标号 返回一个数
    shiftday_index = list(tradingday).index(date) + shift
    # 根据行号返回该日日期 为datetime.date类型
    return tradingday[shiftday_index]


# 获取股票股票池
def get_security_universe(context, security_universe_index, security_universe_user_securities):
    temp_index = []
    for s in security_universe_index:
        if s == 'all_a_securities':
            temp_index += list(get_all_securities(['stock'], context.current_dt.date()).index)
        else:
            temp_index += get_index_stocks(s)
    for x in security_universe_user_securities:
        temp_index += x
    return sorted(list(set(temp_index)))


def shifttradingday(date, shift):
    # 获取N天前的交易日日期
    # 获取所有的交易日，返回一个包含所有交易日的 list,元素值为 datetime.date 类型.
    tradingday = get_all_trade_days()
    # 得到date之后shift天那一天在列表中的行标号 返回一个数
    shiftday_index = list(tradingday).index(date) + shift
    # 根据行号返回该日日期 为datetime.date类型
    return tradingday[shiftday_index]


def after_code_changed(context):
    print('after_code')
    unschedule_all()
    # 开盘前运行
    run_daily(before_market_open, time='07:00', reference_security='000300.XSHG')
    run_daily(before_market, time='07:05', reference_security='000300.XSHG')
    # 开盘时运行
    run_daily(market_open, time='open', reference_security='000300.XSHG')
    # 收盘后运行
    run_daily(after_market_close, time='16:00', reference_security='000300.XSHG')
    g.security_universe_index = ["000002.XSHG", "399101.XSHE",
                                 "399102.XSHE"]  # 选股"000300.XSHG" 沪深300 "399101.XSHE" 中小版  "399102.XSHE" 创业板
    g.watch_list = get_security_universe(context, g.security_universe_index, [])