get_history(5, frequency='1d', field='close', security_list=['123084.SZ'], fq=None, include=False, fill='nan')

APScheduler (3.3.1)

arch (3.2)

bcolz (1.2.1)

beautifulsoup4 (4.6.0)

bleach (1.5.0)

boto (2.43.0)

Bottleneck (1.0.0)

bz2file (0.98)

cachetools (3.1.0)

click (4.0)

contextlib2 (0.4.0)

crypto (1.4.1)

cvxopt (1.1.8)

cx-Oracle (8.0.1)

cycler (0.10.0)

cyordereddict (0.2.2)

Cython (0.22.1)

decorator (4.0.10)

entrypoints (0.2.2)

fastcache (1.0.2)

gensim (0.13.3)

h5py (2.6.0)

hmmlearn (0.2.0)

hs-udata (0.3.6)

html5lib (0.9999999)

ipykernel (4.5.0)

ipython (5.1.0)

ipython-genutils (0.1.0)

ipywidgets (5.2.2)

jieba (0.38)

Jinja2 (2.8)

jsonpickle (1.0)

jsonschema (2.5.1)

jupyter (1.0.0)

jupyter-client (4.4.0)

jupyter-console (5.0.0)

jupyter-core (4.2.0)

jupyter-kernel-gateway (1.1.1)

Keras (2.3.1)

Keras-Applications (1.0.8)

Keras-Preprocessing (1.1.0)

line-profiler (2.1.2)

Logbook (1.4.3)

lxml (4.5.0)

Markdown (2.2.0)

MarkupSafe (0.23)

matplotlib (1.5.3)

mistune (0.7.3)

Naked (0.1.31)

nbconvert (4.2.0)

nbformat (4.1.0)

networkx (1.9.1)

nose (1.3.6)

notebook (4.2.3)

numexpr (2.6.1)

numpy (1.11.2)

pandas (0.23.4)

patsy (0.4.0)

pexpect (4.2.1)

pickleshare (0.7.4)

pip (9.0.1)

pkgconfig (1.0.0)

prompt-toolkit (1.0.8)

protobuf (3.3.0)

ptvsd (2.2.0)

ptyprocess (0.5.1)

PyBrain (0.3)

pycrypto (2.6.1)

Pygments (2.1.3)

PyMySQL (0.9.3)

pyparsing (2.1.10)

python-dateutil (2.7.5)

pytz (2015.4)

PyWavelets (0.4.0)

PyYAML (5.3.1)

pyzmq (16.1.0.dev0)

qtconsole (4.2.1)

requests (2.7.0)

retrying (1.3.3)

scikit-learn (0.18)

scipy (0.18.0)

seaborn (0.7.1)

setuptools (28.7.1)

setuptools-scm (3.1.0)

shellescape (3.4.1)

simplegeneric (0.8.1)

simplejson (3.17.0)

six (1.10.0)

sklearn (0.0)

smart-open (1.3.5)

SQLAlchemy (1.0.8)

statsmodels (0.10.2)

TA-Lib (0.4.10)

tables (3.3.0)

tabulate (0.7.5)

tensorflow (1.3.0rc1)

tensorflow-tensorboard (0.1.2)

terminado (0.6)

Theano (0.8.2)

toolz (0.7.4)

tornado (4.4.2)

traitlets (4.3.1)

tushare (1.2.48)

tzlocal (1.3)

wcwidth (0.1.7)

Werkzeug (0.12.2)

wheel (0.29.0)

widgetsnbextension (1.2.6)

xcsc-tushare (1.0.0)

xgboost (0.6a2)

xlrd (1.1.0)

xlwt (1.3.0)

zipline (0.8.3)

You are using pip version 9.0.1, however version 22.1.2 is available.

You should consider upgrading via the 'pip install --upgrade pip' command.

def get_jisilu_data():

	try:

		r = requests.get('http://127.0.0.1:8080/jisilu')

	except Exception as e:

		print(e)

		return []

	else:

		return r.json()

无影云桌面 (Elastic Desktop Service），是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资，帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数据安全管控、高性能计算等要求的安全办公、金融、设计、影视、教育等领域。

#coding:gbk



'''

回测模型示例（非实盘交易策略）



本策略每隔1个月定时触发计算1000能源（399381.SZ）、1000材料（399382.SZ）、1000工业（399383.SZ）、

1000可选（399384.SZ）、1000消费（399385.SZ）、1000医药（399386.SZ）这几个行业指数过去

20个交易日的收益率并选取了收益率最高的指数的成份股并获取了他们的市值数据

随后把仓位调整至市值最大的5只股票上

该策略在股票指数日线下运行

'''

import numpy as np

import math

def init(ContextInfo):

    MarketPosition ={}

    ContextInfo.MarketPosition = MarketPosition #初始化持仓

    index_universe = ['399381.SZ','399382.SZ','399383.SZ','399384.SZ','399385.SZ','399386.SZ'] 

    index_stocks = []

    for index in index_universe:

        for stock in ContextInfo.get_sector(index): # 获取指数的成分股

            index_stocks.append(stock)

    ContextInfo.set_universe(index_universe+index_stocks)   #设定股票池,

    ContextInfo.day = 20

    ContextInfo.ratio = 0.8

    ContextInfo.holding_amount = 5

    ContextInfo.accountID='testS'



def handlebar(ContextInfo):

    buy_condition = False

    sell_condition = False

    d = ContextInfo.barpos

    print(d)

    lastdate = timetag_to_datetime(ContextInfo.get_bar_timetag(d - 1), '%Y%m%d')

    date = timetag_to_datetime(ContextInfo.get_bar_timetag(d), '%Y%m%d')

    print(date)

    index_list = ['399381.SZ','399382.SZ','399383.SZ','399384.SZ','399385.SZ','399386.SZ']

    return_index = []

    weight = ContextInfo.ratio/ContextInfo.holding_amount

    size_dict = {}

    if  (float(date[-4:-2]) != float(lastdate[-4:-2])):

        #print '---------------------------------------------------------------------------------'

        #print '当前交易日',date,date[-4:-2] 20210101 获取到的月份不一样，这样在每个月初会执行一次这个函数

        

        # 获取的是股票池的

        his = ContextInfo.get_history_data(21,'1d','close')

        

        #print "his",his,timetag_to_datetime(ContextInfo.get_bar_timetag(d),"%Y%m%d")

        for k in list(his.keys()):

            if len(his[k]) == 0:

                del his[k]

        for index in index_list:

            ratio = 0

            try:

                ratio = (his[index][-2] - his[index][0])/his[index][0]

            except KeyError:

                print('key error:' + index)

            except IndexError:

                print('list index out of range:' + index)

            return_index.append(ratio)

        # 获取指定数内收益率表现最好的行业

        best_index = index_list[np.argmax(return_index)]

        #print '当前最佳行业是：', ContextInfo.get_stock_name(best_index)[3:]+'行业'

        # 获取当天有交易的股票

        index_stock = ContextInfo.get_sector(best_index)

        stock_available = []

        for stock in index_stock:

            if ContextInfo.is_suspended_stock(stock) == False: # 是否停牌

                stock_available.append(stock)

                

        for stock in stock_available:

            if stock in list(his.keys()):

                #目前历史流通股本取不到，暂用总股本

                if len(his[stock]) >= 2:

                    stocksize =his[stock][-2] * float(ContextInfo.get_financial_data(['CAPITALSTRUCTURE.total_capital'],[stock],lastdate,date).iloc[0,-1])

                    size_dict[stock] = stocksize

                elif len(his[stock]) == 1:

                    stocksize =his[stock][-1] * float(ContextInfo.get_financial_data(['CAPITALSTRUCTURE.total_capital'],[stock],lastdate,date).iloc[0,-1])

                    size_dict[stock] = stocksize

                else:

                    return

        size_sorted = sorted(list(size_dict.items()), key = lambda item:item[1]) # 根据股本顺序排序

        pre_holding = []

        

        for tuple in size_sorted[-ContextInfo.holding_amount:]: # 最好不要占用关键词

            pre_holding.append(tuple[0])

        #print '买入备选',pre_holding

        #函数下单

        if len(pre_holding) > 0:

            sellshort_list = []

            for stock in list(ContextInfo.MarketPosition.keys()): # 遍历持仓，如果不在当前条件范围内，卖出

                if stock not in pre_holding and (stock in list(his.keys())):

                    order_shares(stock,-ContextInfo.MarketPosition[stock],'lastest',his[stock][-1],ContextInfo,ContextInfo.accountID)

                    print('sell',stock)

                    sell_condition = True

                    sellshort_list.append(stock)

            if len(sellshort_list) >0: # 这句多余

                for stock in sellshort_list:

                    del ContextInfo.MarketPosition[stock]

            

            for stock in pre_holding:

                if stock not in list(ContextInfo.MarketPosition.keys()): # 买入

                    Lots = math.floor(ContextInfo.ratio * (1.0/len(pre_holding)) * ContextInfo.capital / (his[stock][-1] * 100))

                    order_shares(stock,Lots *100,'lastest',his[stock][-1],ContextInfo,ContextInfo.accountID)

                    print('buy',stock)

                    buy_condition = True

                    ContextInfo.MarketPosition[stock] = Lots *100

• 股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。
•  
• 财务报表：沪深港上市公司披露的2007年会计准则变更以来的所有财务报表数据，包含三大报表和财报附注等细节。
•  
• 公司行为：沪深上市公司业绩预告，业绩快报，IPO，配股，分红，拆股，股改等信息。
•  
• 基金：场内外各类基金的基本信息，日/分钟级别的场内基金行情，日级别的场外基金净值，以及基金资产配置，收益情况，净值调整等信息。
•  
• 期货：国内四大期货交易所期货合约的基本信息，日/分钟的期货行情，以及国债期货的转换因子等信息。
•  
• 指数：国内外指数基本信息，日/分钟级别的指数行情，以及指数成分构成情况，指数成分股权重情况等信息。
•  
• 港股：香港交易所股票基本信息以及日级别的股票行情。
•  
• 大宗商品：国内各个品种（包括期货合约可交割品种）的大宗商品现货价格行情，以及产销量，库存等信息。
•  
• 债券：债券/回购基本信息，日级别的债券/回购行情，以及发行上市，付息，利率，评级和评级变动，债券发行人评级及变动，担保人评级及变动等信息。
•  
• 期权：上交所期权合约的基本信息，日/分钟级别的期权行情，以及每日盘前静态数据等信息。
•  
• 宏观产业：中国及全球各国宏观指标，行业经济指标等数据。

• 股票/指数等品种的量化因子库
•  
• 雪球、股吧等社交媒体数据
•  
• 主流媒体新闻文本和结构化数据
•  
• 主流渠道公告文本和结构化数据
•  
• 淘宝、天猫等电商数据

import datetime



start = '2018-01-01'                       # 回测起始时间

end = '2021-05-28'                         # 回测结束时间

benchmark = 'HS300'                        # 策略参考标准

freq = 'd'                                 # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测            

refresh_rate = 5 # 调仓频率，表示执行handle_data的时间间隔，若freq = 'd' 时间间隔的单位为交易日，

hold_num = 10 # 持有转债的个数



    

def initialize(context):

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    MyPosition = {}  #持仓

    MyCash = 1000000  #现金

    Start_Cash= 1000000

    HighValue = MyCash  #最高市值

    Withdraw = 0  #最大回撤

    HoldRank = hold_num  #排名多少之后卖出

    HoldNum = hold_num  #持债支数

    

def bonds(beginDate=u"20170101",endDate=u"20201215",EB_ENABLE=False):

    code_set = set()

    df = DataAPI.MktConsBondPremiumGet(SecID=u"",

                                       tickerBond=u"",

                                       beginDate=beginDate,

                                       endDate=endDate,

                                       field=u"",

                                       pandas="1")



    cb_df = df.tickerBond.str.startswith(('12', '11'))

    df = df[cb_df]

    cb_df = df.tickerBond.str.startswith('117')

    df = df[~cb_df]

    if not EB_ENABLE:

        eb = df.secShortNameBond.str.match('\d\d.*?E[123B]')  # TODO 判断EB是否过滤

        df = df[~eb]



    ticker_list = 

    for _, row in df[['tickerBond', 'secShortNameBond', 'tickerEqu']].iterrows():

        if row['tickerBond'] not in code_set:

            ticker_list.append((row['tickerBond'], row['secShortNameBond'], row['tickerEqu']))

            code_set.add(row['tickerBond'])

    return list(code_set)





def handle_data(context):    

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    

    today_date = context.now.strftime('%Y%m%d')

    

    #每天重新计算双低排名

    ticker_list=bonds(today_date,today_date)

    data = DataAPI.MktConsBondPerfGet(beginDate=today_date,endDate=today_date,secID='',tickerBond=ticker_list,

                                      tickerEqu=u"",field=u"",pandas="1")

    data['secID']=data['tickerBond']

    data.set_index('secID',inplace=True)

    data['DoubleLow'] = data['closePriceBond'] + data['bondPremRatio']

    data = data.sort_values(by="DoubleLow" , ascending=True)

    PosValue = MyCash

    

    #抛出不在持有排名HoldRank的

    for stock in MyPosition.keys():

        try:

            CurPrice = data.loc[stock]['closePriceBond']

        except:

            last_date = (context.now + datetime.timedelta(days=-7)).strftime('%Y%m%d')

            CurPrice=get_last_price(stock,last_date,today_date)



        PosValue += MyPosition[stock] * CurPrice * 10 #计算当前市值

        

        if stock not in data.index[:HoldRank]:

            # 省略若干

                

            log.info('{} 卖出{},{},价格：{}'.format(today_date,stock,name,CurPrice))

  

            

    if PosValue > HighValue:HighValue = PosValue

    if (HighValue - PosValue) / HighValue > Withdraw:Withdraw = (HighValue - PosValue) / HighValue

    

    #买入排在HoldRank内的，总持有数量HoldNum

    min_hold = min(HoldRank,len(data.index))

    for i in range(min_hold):

        if len(MyPosition) >= HoldNum:break

        if data.index[i] not in MyPosition.keys():

            # 省略若干

            log.info('{} 买入{}, {}, 价格{}, 溢价率{}'.format(today_date,data.index[i],name,price,cb_ration))



    ratio = (PosValue-Start_Cash)/Start_Cash*100

    log.info(today_date + ': 最高市值 ' + str(HighValue) + ' , 当前市值 ' + str(PosValue) + '收益率 ： '

             +str(ratio)+'% , 最大回撤 ' + str(round(Withdraw*100,2))+'%') [/i][/i]

[i]欢迎讨论探索，星球里面有更多的完整策略与代码，回测数据，结论资源。
 

2018年末鹏华全球高收益债持有人户数为25445户，比成立时增长了10倍 







购买过鹏华全球高收益债的基金账户数已超16.52万







投资者平均持仓鹏华全球高收益债302.21天







持仓鹏华全球高收益债的客户中，60岁以上的客户平均收益最高，姜还是老的辣 







持有鹏华全球高收益债的客户账户平均资产为54140.93元 







共有20413位客户定投过鹏华全球高收益债，平均每人定投15.72次，平均持仓554天，平均盈利3315.71元







鹏华全球高收益债的平均复购间隔时间仅为8.68天，复购率为69.43% 







因“申购费率优惠”共为鹏华全球高收益债投资者节省了3318万元，最精明的个人客户共节省了118万元的申购费

DataAPI.MktBonddGet(secID=u"",ticker=u"122560",tradeDate=u"",beginDate=u"20180301",endDate=u"20180315",field=u"",pandas="1")

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

    days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

    days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

    

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

获取 排除满足强赎天数剩余N天的可转债，排除强赎可转债。



比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。







import requests



URL = 'http://11.11.11.11/api/redeem/'

# DAY 强赎倒数剩余天数小于 DAY （4）天， 已经公告强赎的也是被排除的

DAY = 4



SIGN = '私信星主获取' # sign和以前一致



data = {'day': DAY,

        'sign': SIGN}

r = requests.post(URL, data=data)



print(r.json())

def get_all_code(date):

    ''' 

    获取某天的股市运行的股票，排除停牌 

    ''' 

     df=DataAPI.MktEqudAdjGet(secID=u"",ticker=u"",

                           tradeDate=date, 

                           beginDate=u"", 

                           endDate=u"", 

                           isOpen="", 

                           field=u"", 

                           pandas="1")

    df=df[df['turnoverValue']>0] # 停牌 

    return df['ticker'].tolist()

 1import time

 2import datetime

 3

 4stock_profit_list=

 5start=time.time()

 6

 7today=datetime.datetime.now().strftime('%Y-%m-%d')

 8

 9def get_trade_date():

10    df=DataAPI.TradeCalGet(exchangeCD=u"XSHG,XSHE",

11                           beginDate=high_date,

12                           endDate=today,isOpen=u"1",

13                           field=u"",pandas="1")

14    return df['calendarDate'].tolist()

15

16def fixed_investment(code):

17    stock_profit_dict={}

18    stock_profit_dict['code']=code

19    df=DataAPI.MktEqudAdjGet(secID=u"",ticker=code,tradeDate=u'',beginDate=high_date,endDate=today,isOpen="1",field=u"",pandas="1")

20    total_amount=0

21    invest_count=0

22    every_invest_cash=10000

23    total_money_list=list()

24    last_date=None

25    for trade_date in trade_date_list_interval:

26        trade_df = df[df['tradeDate']==trade_date]

27        if len(trade_df)>0:

28            invest_count+=1

29            price=trade_df['closePrice'].iloc[0]

30            amount=every_invest_cash/price

31            cost=invest_count*every_invest_cash

32            profit=total_amount*price/cost

33            total_money_list.append(profit)

34            total_amount=total_amount+amount

35            total_money=price*total_amount

36            last_date=trade_date

37

38

39    stock_profit_dict['profit_rate']=profit

40    stock_profit_dict['last_date']=last_date

41    stock_profit_dict['invest_count']=invest_count

42    stock_profit_dict['total_amount']=total_amount

43    stock_profit_dict['total_money']=total_money

44    stock_profit_dict['profit_list']=total_money_list

45    stock_profit_dict['cost']=cost

46    return stock_profit_dict

47

48for code in target_codes:

49    profit_dict = fixed_investment(code)

50    stock_profit_list.append(profit_dict)

51

52print(time.time()-start)

profi_df_sorted = profit_df.sort_values(by='profit_rate',ascending=False)

profit_df['absolute_profit']=profit_df['total_money']-profit_df['cost']

profi_df_sorted['profit_rate'].mean()

df = pd.DataFrame(np.arange(16).reshape((8,2)),index=list('abcdefgh'),columns=['COL1','COL2'])

COL1	COL2

a	0	1

b	2	3

c	4	5

d	6	7

e	8	9

f	10	11

g	12	13

h	14	15

	COL1	COL2

a	0	1

b	2	3

c	4	5

d	6	7

e	8	9

main("162411", "6", "100");

//可转债量化分析

function main(code, count, money) {

    log(code, count, money);

    if (!code) {

        toast("请输入基金代码");

        return;

    }

    if (!count) {

        toast("股东账户数量");

        return;

    }

    if (!money) {

        toast("申购金额");

        return;

    }

    app.launchApp("中国银河证券");

    waitForPackage("com.galaxy.stock");

    log("成功打开银河证券");

    sleep(1000);

    // 切换到【交易】tab

    const tradeBtn = text("交易")

        .findOne()

        .parent()

        .parent();

    log(tradeBtn);

    tradeBtn.click();



    //点击【场内基金】

    sleep(1000);

    const internalFund = text("场内基金")

        .findOnce()

        .parent();

    internalFund.click();



    //点击【基金申购】

    waitForActivity("cn.com.chinastock.trade.activity.LofActivity");

    const fundPurchase = text("基金申购")

        .findOnce()

        .parent();

    fundPurchase.click();



    // 自动填信息

    sleep(1000);



    purchaseFund(code, count, money);

}



function purchaseFund(code, count, money) {

    for (let i = 0; i < count; i++) {

        log(code, count, money);

        const codeInput = id("stockCode").findOne();

        codeInput.click();

        codeInput.setText(code);

        sleep(1000);

        const accountSelect = id("secuidList").findOne();

        accountSelect.click();

        sleep(1000);

        const options = className("CheckedTextView").find();

        click(options[i].bounds().left + 2, options[i].bounds().top + 2);

        sleep(300);

        const orderAmount = id("orderAmount")

            .findOnce()

            .children()[0];

        log(orderAmount);

        orderAmount.setText(money);

        sleep(300);

        id("order")

            .findOnce()

            .click();

        sleep(6000);

        id("acceptedCb")

            .findOnce()

            .click();

        id("okBtn")

            .findOnce()

            .click();

        sleep(6000);

        click("本人已认真阅读并理解上述内容");

        sleep(200);

        click("我接受");

        sleep(200);

        click("本人已认真阅读并理解上述内容");

        sleep(200)

        click("我接受");

        sleep(7000);

        click("本人已认真阅读并理解上述内容");

        sleep(200);

        click("我接受");

        sleep(500);

        text('确认申购').findOnce().click();

        sleep(1000);

        text("确定")

            .findOnce()

            .click();



        sleep(1000);

    }

}



main("162411", "6", "100");[/i][/i]

• [i]手机设置无障碍模式，把autojs添加进去，一般按住app的时候会提示引导你这么操作[/i][list][*][i]打开autojs app，把上面的JS代码复制进去[/i][list][*][i]登录你的X河牌拖拉机[/i][list][*][i]在autojs app里面点击执行[/i]

[i] 
然后就静静的等待脚本执行完成，你的6个股东号就全部打完啦。如果你有多个证券账户，需要你退出当前的账户，然后登陆下一个账号，然后继续运行这个脚本即可。


后台回复：autojs 就可以获取autojs的app与上面的源码打包。

PS：如果你有有趣的想法要验证或者苦于没有数据无从下手，可以后台留言，一起交流，笔者会尝试帮你们验证分析。
 
关注公众号：

 

Suppose you have a matrix M whose (i,j)-th element equals



M_ij = 2*i + 3*j

One way to define this matrix would be



i, j = np.indices((2,3))

M = 2*i + 3*j

which yields



array([[0, 3, 6],

       [2, 5, 8]])

In other words, np.indices returns arrays which can be used as indices. The elements in i indicate the row index:



In [12]: i

Out[12]: 

array([[0, 0, 0],

       [1, 1, 1]])

The elements in j indicate the column index:



In [13]: j

Out[13]: 

array([[0, 1, 2],

       [0, 1, 2]])

# 测试一下那个方差

x=[1,2,3,4,5,6,7,8,9,10]

X = np.array(x)

def my_fangca(X):

    l=len(X)

    mean=X.mean()

    sum_ = 0

    sum_std=0

    for i in X:

        sum_+=(i-mean)**2

    var_=sum_/l

    std_=(sum_/(l))**0.5

    return var_,std_

pywinauto.application.AppStartError: Could not create the process "C:\全能行证券交易终端\xiadan.exe"
Error returned by CreateProcess: (2, 'CreateProcess', '系统找不到指定的文件。')

class GJ(CommonConfig):

    DEFAULT_EXE_PATH = "C:\\Tool\\xiadan.exe"

x=np.array([[1,2,3,4],[5,6,7,8]])

array([[1, 2, 3, 4],

       [5, 6, 7, 8]])

x.flatten()

array([1, 2, 3, 4, 5, 6, 7, 8])