js_data = {

"ErrCode": 0,

"ErrMsg": "0",

"Datas": [

{

"_id": "001171",

"CODE": "001171",

"NAME": "工银养老产业股票A",

"STOCKMARKET": "",

"NEWTEXCH": ""

},

......... # 省略若干

]

}

import akshare as ak



def get_fund_info(code,name):

    fund_open_fund_info_em_df = ak.fund_open_fund_info_em(symbol=code, indicator="累计收益率走势",period="3年")

    latest_perf = fund_open_fund_info_em_df.iloc[-1]['累计收益率']

    return {'code':code,'profit':latest_perf,'name':name}

fund_perf_list = []

for item in js_data['Datas']:

    print('processing code {}'.format(item['CODE']))

    try:

        fund_perf_list.append(get_fund_info(item['CODE'],item['NAME']))

        time.sleep(0.5)

    except Exception as e:

        print('error in processing code {}'.format(item['CODE']))

        print(e)

import pandas as pd

df = pd.DataFrame(fund_perf_list)



rank_df = df.sort_values(by='profit')

rank_df.to_excel('亏麻的养老基金.xlsx')

fof_fund_df = rank_df[rank_df['name'].str.contains('FOF')]

fof_fund_df.plot(kind='hist',bins=20,y='profit',width=2,grid=True)

您的连接不是私密连接

攻击者可能会试图从 139.224.24.109 窃取您的信息（例如：密码、通讯内容或信用卡信息）。了解详情

NET::ERR_CERT_COMMON_NAME_INVALID

如果您想获得 Chrome 最高级别

7、该接口只能获取2005年后的数据。

test_data = data = get_price(security='000001.SS',start_date='20050201',end_date='20050630',frequency='1d')

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:mobile="http://www.baidu.com/schemas/s ... gt%3B

<url>

<loc>http://30daydo.com/article/1</loc>

<mobile:mobile type="mobile"/>

<lastmod>2024-06-30</lastmod>

<changefreq>daily</changefreq>

<priority>0.8</priority>

</url>

</urlset>

<url>

<loc>http://30daydo.com/article/1</loc>

<mobile:mobile type="mobile"/>

<lastmod>2024-06-30</lastmod>

<changefreq>daily</changefreq>

<priority>0.8</priority>

</url>

# encoding:gbk

'''

实盘可以执行

固定数量

'''

import datetime





ACCOUNT = ''





def init(ContextInfo):

    ContextInfo.set_account(ACCOUNT)





def get_position_infos():

    # 信用账户可用资金

    position_infos = get_trade_detail_data(ACCOUNT, 'stock', 'position')

    



    pos_dict={}

    for pos in position_infos:

        code = pos.m_strInstrumentID

        if pos.m_nVolume > 0:

            pos_dict[code] = pos.m_nVolume

    return pos_dict

    

datax = get_position_infos() # 这里error



def handlebar(ContextInfo):

    if ContextInfo.is_last_bar():

        current = datetime.datetime.now().strftime('%H:%M:%S.%f')

        print(datax)

        

class RedisCls:



    def __init__(self):

        self.conn = self.getConn()



    def getConn(self):

        try:

            r = redis.Redis(host=redisconfig['redis']['host'], port=redisconfig['redis']['port'], db=0,

                            decode_responses=True, password=redisconfig['redis']['password'], socket_connect_timeout=5)

        except Exception as e:

            print(e)

            raise IOError('connect redis failed')

        else:

            return r

        



    def get(self, key):

        return self.conn.get(key)

    



    def set(self, key, value):

        return self.conn.set(key, value)

    

    def pop(self, key):

        print('==== pop data ====')

        return self.conn.brpop(key)



    def push(self, key, value):

        print('==== push data ====')

        self.conn.blpush(key, value)

AttributeError: 'Redis' object has no attribute 'blpush'. Did you mean: 'lpush'?

def initialize(context):

    run_daily(context, event, '09:38')





def handle_data(context, data):

    pass





def event(context):

    his60 = get_history(60, '1d', ['close'],  ['515220.SS'], fq='pre', include=False)

    print(his60)

# coding:gbk

def init(C):

    pass



def handlebar(C):

    iopv = get_etf_iopv("159928.SZ")

    print(f'基金净值为{iopv}')

    info = get_etf_info('513520.SH')

    print(f'基金申购信息： {info}')

# coding:gbk

# 公众号:可转债量化分析

DEBUG = True

import time

def get_datetime(ContextInfo):

    # 获取当前时间

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    if DEBUG:

        print('当前日期 ', date)

    return date

    

def init(ContextInfo):

    print("==============start==========")

    ContextInfo.start = '2024-03-27 10:00:00'

    ContextInfo.end = '2024-03-29 10:00:00'

    # 

    #ContextInfo.end = '2023-01-05'

    #ContextInfo.start = '2023-01-16'

    print('init')

    

def handlebar(ContextInfo):

    # 回测的时候不需要

    #if not ContextInfo.is_last_bar():

    #    print('return')

    #    return

    get_datetime(ContextInfo)

    print('handlebar')

    data = ContextInfo.get_market_data(['quoter'], stock_code = ['123167.SZ'], skip_paused = True, period = 'tick', dividend_type = 'front')

    

    #data = ContextInfo.get_market_data(['close'], stock_code = ['113567.SH'], skip_paused = True, period = '1d', dividend_type = 'front')

    #print(type(data))

    print(data)



def stop(ContextInfo):

    print( 'strategy is stop !')

import akshare as ak

fund_purchase_em_df = ak.fund_purchase_em()

def filter_func(df,type='指数型-海外股票'):

    df = df[~df['基金代码'].str.startswith('0')]

    condition1 = df['申购状态']=='限大额'

    condition2 = df['基金类型']==type

    df = df[condition1 & condition2]

    df= df[~df['基金简称'].str.contains('ETF')]

    df = df[(df['日累计限定金额']>0) & (df['日累计限定金额']<=10000)]

    df['基金代码'] = df['基金代码'].map(lambda x: 'SH'+x if x.startswith('5') else 'SZ'+x)

    return df

import requests

cookies = # 雪球上获取，不一定需要登录状态



headers = {

    'authority': 'stock.xueqiu.com',

    'origin': 'https://xueqiu.com',

    'user-agent': 'Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1C28 Safari/419.3',

}



def fund_premium_rate(code):

    params = {

        'symbol': code,

        'extend': 'detail',

    }



    response = requests.get('https://stock.xueqiu.com/v5/stock/quote.json', params=params, 

                            cookies=cookies, 

                            headers=headers)

    try:

        rate = response.json()['data']['quote']['premium_rate']

    except Exception as e:

        return None

    else:

        return rate

for code,name in code_name_mapper.items():

    rate = fund_premium_rate(code)

    if rate is not None:

        print(f'{code} - {name}的溢价率是: {rate}')

        if rate > 4:

            send_message_via_wechat(f'{code} - {name}的溢价率是: {rate}, 可以关注套利。 公众号：可转债量化分析')

# 用前须知



## xtdata提供和MiniQmt的交互接口，本质是和MiniQmt建立连接，由MiniQmt处理行情数据请求，再把结果回传返回到python层。使用的行情服务器以及能获取到的行情数据和MiniQmt是一致的，要检查数据或者切换连接时直接操作MiniQmt即可。



## 对于数据获取接口，使用时需要先确保MiniQmt已有所需要的数据，如果不足可以通过补充数据接口补充，再调用数据获取接口获取。



## 对于订阅接口，直接设置数据回调，数据到来时会由回调返回。订阅接收到的数据一般会保存下来，同种数据不需要再单独补充。



# 代码讲解



# 从本地python导入xtquant库，如果出现报错则说明安装失败

from xtquant import xtdata

import time



# 设定一个标的列表

code_list = ["000001.SZ"]

# 设定获取数据的周期

period = "1d"



# 下载标的行情数据

if 1:

    ## 为了方便用户进行数据管理，xtquant的大部分历史数据都是以压缩形式存储在本地的

    ## 比如行情数据，需要通过download_history_data下载，财务数据需要通过

    ## 所以在取历史数据之前，我们需要调用数据下载接口，将数据下载到本地

    for i in code_list:

        xtdata.download_history_data(i,period=period,incrementally=True) # 增量下载行情数据（开高低收,等等）到本地

    

    xtdata.download_financial_data(code_list) # 下载财务数据到本地

    xtdata.download_sector_data() # 下载板块数据到本地

    # 更多数据的下载方式可以通过数据字典查询



# 读取本地历史行情数据

history_data = xtdata.get_market_data_ex(,code_list,period=period,count=-1)

print(history_data)

print("=" * 20)



# 如果需要盘中的实时行情，需要向服务器进行订阅后才能获取

# 订阅后，get_market_data函数于get_market_data_ex函数将会自动拼接本地历史行情与服务器实时行情



# 向服务器订阅数据

for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1) # 设置count = -1来取到当天所有实时行情



# 等待订阅完成

time.sleep(1)



# 获取订阅后的行情

kline_data = xtdata.get_market_data_ex(,code_list,period=period)

print(kline_data)



# 获取订阅后的行情，并以固定间隔进行刷新,预期会循环打印10次

for i in range(10):

    # 这边做演示，就用for来循环了，实际使用中可以用while True

    kline_data = xtdata.get_market_data_ex(,code_list,period=period)

    print(kline_data)

    time.sleep(3) # 三秒后再次获取行情



# 如果不想用固定间隔触发，可以以用订阅后的回调来执行

# 这种模式下当订阅的callback回调函数将会异步的执行，每当订阅的标的tick发生变化更新，callback回调函数就会被调用一次

# 本地已有的数据不会触发callback

    

# 定义的回测函数

    ## 回调函数中，data是本次触发回调的数据，只有一条

def f(data):

    # print(data)

    

    code_list = list(data.keys())    # 获取到本次触发的标的代码



    kline_in_callabck = xtdata.get_market_data_ex(,code_list,period = period)    # 在回调中获取klines数据

    print(kline_in_callabck)



for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1,callback=f) # 订阅时设定回调函数



# 使用回调时，必须要同时使用xtdata.run()来阻塞程序，否则程序运行到最后一行就直接结束退出了。

xtdata.run()

#coding:utf-8

import time, datetime, traceback, sys

from xtquant import xtdata

from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback

from xtquant.xttype import StockAccount

from xtquant import xtconstant



#定义一个类 创建类的实例 作为状态的容器

class _a():

    pass

A = _a()

A.bought_list = 

A.hsa = xtdata.get_stock_list_in_sector('沪深A股')



def interact():

    """执行后进入repl模式"""

    import code

    code.InteractiveConsole(locals=globals()).interact()

xtdata.download_sector_data()



def f(data):

    now = datetime.datetime.now()

    for stock in data:

        if stock not in A.hsa:

            continue

        cuurent_price = data[stock]['lastPrice']

        pre_price = data[stock]['lastClose']

        ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0

        if ratio > 0.09 and stock not in A.bought_list:

            print(f"{now} 最新价 买入 {stock} 200股")

            async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 200, xtconstant.LATEST_PRICE, -1, 'strategy_name', stock)

            A.bought_list.append(stock)

    

class MyXtQuantTraderCallback(XtQuantTraderCallback):

    def on_disconnected(self):

        """

        连接断开

        :return:

        """

        print(datetime.datetime.now(),'连接断开回调')



    def on_stock_order(self, order):

        """

        委托回报推送

        :param order: XtOrder对象

        :return:

        """

        print(datetime.datetime.now(), '委托回调', order.order_remark)





    def on_stock_trade(self, trade):

        """

        成交变动推送

        :param trade: XtTrade对象

        :return:

        """

        print(datetime.datetime.now(), '成交回调', trade.order_remark)





    def on_order_error(self, order_error):

        """

        委托失败推送

        :param order_error:XtOrderError 对象

        :return:

        """

        # print("on order_error callback")

        # print(order_error.order_id, order_error.error_id, order_error.error_msg)

        print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")



    def on_cancel_error(self, cancel_error):

        """

        撤单失败推送

        :param cancel_error: XtCancelError 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_order_stock_async_response(self, response):

        """

        异步下单回报推送

        :param response: XtOrderResponse 对象

        :return:

        """

        print(f"异步委托回调 {response.order_remark}")



    def on_cancel_order_stock_async_response(self, response):

        """

        :param response: XtCancelOrderResponse 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_account_status(self, status):

        """

        :param response: XtAccountStatus 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)





if __name__ == '__main__':

    print("start")

    #指定客户端所在路径

    path = r'D:\qmt\sp3\迅投极速交易终端 睿智融科版\userdata_mini'

    # 生成session id 整数类型 同时运行的策略不能重复

    session_id = int(time.time())

    xt_trader = XtQuantTrader(path, session_id)

    # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定

    # 详见: http://docs.thinktrader.net/vip/pages/ee0e9b/#开启主动请求接口的专用线程

    # xt_trader.set_relaxed_response_order_enabled(True)



    # 创建资金账号为 800068 的证券账号对象

    acc = StockAccount('800068', 'STOCK')

    # 创建交易回调类对象，并声明接收回调

    callback = MyXtQuantTraderCallback()

    xt_trader.register_callback(callback)

    # 启动交易线程

    xt_trader.start()

    # 建立交易连接，返回0表示连接成功

    connect_result = xt_trader.connect()

    print('建立交易连接，返回0表示连接成功', connect_result)

    # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功

    subscribe_result = xt_trader.subscribe(acc)

    print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)



    #这一行是注册全推回调函数 包括下单判断 安全起见处于注释状态 确认理解效果后再放开

    # xtdata.subscribe_whole_quote(["SH", "SZ"], callback=f)

    # 阻塞主线程退出

    xt_trader.run_forever()

    # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）

    interact()

def get_all_market_code(ContextInfo):



    all_market_codes = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    return filter_ST_stock(ContextInfo, all_market_codes)

    

    

def filter_ST_stock(ContextInfo, code_list):

    result = 

    for code in code_list:

        if re.search('(st)|(ST)|(\*st)|(\*ST)|(退)',ContextInfo.get_stock_name(code)):

            print('排除 ： ',ContextInfo.get_stock_name(code),code)

            continue

        result.append(code)

    return result

    

global_dict = {}



def init(ContextInfo):

    now = time.ctime()

    print('策略初始化{}'.format(now))

    need_download = 1

    global_dict['start_date'] = '20231201'

    global_dict['end_date'] = ''

    global_dict['code_list'] = get_all_market_code(ContextInfo)

    

# coding:gbk

import time





class G():

    pass





g = G()





def init(ContextInfo):

    g.hsa = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    g.vol_dict = {}

    for stock in g.hsa:

        g.vol_dict[stock] = ContextInfo.get_last_volume(stock)

    ContextInfo.run_time("execution", "1nSecond", "2019-10-14 13:20:00")





def execution(ContextInfo):

    t0 = time.time()

    full_tick = ContextInfo.get_full_tick(g.hsa)

    total_market_value = 0

    total_ratio = 0

    count = 0

    for stock in g.hsa:

        if full_tick[stock]['lastClose'] == 0:

            continue

        ratio = full_tick[stock]['lastPrice'] / full_tick[stock]['lastClose'] - 1

        rise_price = round(full_tick[stock]['lastClose'] * 1.2, 2) if stock[0] == '3' or stock[:3] == '688' else round(

            full_tick[stock]['lastClose'] * 1.1, 2)

        # 如果要打印涨停品种

        if abs(full_tick[stock]['lastPrice'] - rise_price) <0.01:

            print(f"涨停股票 {stock} {ContextInfo.get_stock_name(stock)}")



        market_value = full_tick[stock]['lastPrice'] * g.vol_dict[stock]

        total_ratio += ratio * market_value

        total_market_value += market_value

        count += 1

    # print(count)

    total_ratio /= total_market_value

    total_ratio *= 100

    print(f'A股加权涨幅 {round(total_ratio, 2)}% 函数运行耗时{round(time.time() - t0, 5)}秒')