python tushare库的使用例子

说明：
'''
1、结合tushare 简单封装的调用接口——大宗交易接口为例
2、对大宗交易数据的处理：
	达到效果：
	（1）买入和卖出机构相同的时候，去除该条数据（这个还涉及到同属于一个大机构的情况，暂时没做处理）
	（2）相同买方机构处理数据（去重和求和统计）
	（3）按照相同卖方机构处理数据（去重和统计）
	（4）计算不同机构的持仓情况和成交均价
'''
import tushare as ts

#1、结合tushare 简单封装的调用接口——大宗交易接口为例
class Stock_Api():
    def __init__(self,stock):
        self.stock = stock  #股票代码
        # 
        #初始化pro接口对象
        self.pro = ts.pro_api("")
    def big_trade(self,start='',end='',trade_date='',):
        '''
        查询大宗交易数据
        :param stock:股票代码--只支持查找一支股票
        :param trade_date: 交易日
        :param start: 开始时间
        :param end: 结束时间
        :return: dataframe

        输出参数:--一般支持fields:
        名称	类型	默认显示	描述
        ts_code	str	Y	TS代码
        trade_date	str	Y	交易日历
        price	float	Y	成交价
        vol	float	Y	成交量（万股）
        amount	float	Y	成交金额
        buyer	str	Y	买方营业部
        seller	str	Y	卖方营业部
        '''
        big_data = self.pro.query('block_trade',ts_code=self.stock,start_date=str(start),end_date=str(end),trade_date=trade_date,fields='')
        return big_data

    def stock_hold_number(self,end):
        '''
        查询股东人数：
        :param stock:股票代码
        :param end: 截止日期
        :return: dataframe
        '''
        holder_date = self.pro.query('stk_holdernumber',ts_code=self.stock, enddate=end)
        return holder_date

    def stockhold_trade(self,start,end,ann_date,type,holderpy=''):
        '''
        查询股东增减持信息：
        :param stock: 股票代码
        :param start: 开始时间
        :param end: 结束时间
        :param ann_date: 公告日期（查询某一天）
        :param type: IN增持；DE减持
        :param holderpy: C公司；P个人；G高管
        :return: dataframe
        '''
        trade_data = self.pro.query('stk_holdertrade',ts_code=self.stock,start_date=start,end_date=end,ann_date=ann_date, trade_type=type,holder_type=holderpy,
                               fields='ts_code,ann_date,holder_name,holder_type,in_de,change_ratio,after_ratio,avg_price,total_share,change_vol,after_share,begin_date,close_date'
                               )
        return trade_data

#2、对大宗交易数据的处理

#实例化对象，调用接口，获取原始数据
ST = Stock_Api('000009.SZ')
big_data = ST.big_trade(20160202,20210701) #原始数据
#（1）买入和卖出机构相同的时候，去除该条数据（这个还涉及到同属于一个大机构的情况，暂时没做处理）
'''
own_data = big_data.to_dict()
# print(own_data)
same_list = []
use_list = []
sum_buyer = 0
sum_seller = 0
for i in own_data["buyer"]:
    simple = own_data["buyer"][i][:5]
    # print(simple)
    if own_data["buyer"][i].startswith(simple) and own_data["seller"][i].startswith(simple):
        same_list.append(i)
        # print(same_list)
    else:
        use_list.append(i)
print(same_list)
print(use_list)
use_data = big_data[big_data.index.isin(use_list)]  #取到不是倒卖的数据（包括本身和同属于一机构的）
'''
use_data = big_data[big_data["buyer"] != big_data["seller"]] #取到不是倒卖的数据(仅包括机构本身)

# 取出所有的机构名(转化成列表)
buyer_name = use_data["buyer"].values.tolist()
seller_name = use_data["seller"].values.tolist()
#合并在一起并去重--1、名称相同；2、同属于一机构（这个不能处理，处理后交易会漏掉），合并后去重和分开去重后者更好
#all_name = buyer_name + seller_name
#all_name = set(all_name)
#all_name = list(all_name)

buyer_name = set(buyer_name)
seller_name = set(seller_name)
buyer_name = list(buyer_name)
seller_name = list(seller_name)


#（2）相同买方机构处理数据（去重和求和统计）
#（3）按照相同卖方机构处理数据（去重和统计）
#这种处理方式会因为卖方和卖方分别不是等同于去重的全部机构，这样查出来会有很多空值——不采用；采用分开形式
# for i in all_name:
#     # 买方
#     # if i in use_data["buyer"].values.tolist() or i in use_data["seller"].values.tolist():
#         choose_data_1 = use_data[use_data["buyer"]==i]
#         # choose_data = use_data["buyer"].isin(all_name)
#         print(choose_data_1)
#         b_t = choose_data_1["vol"].sum()  # 计算成交量--万股
#         # print(b_t)
#         b_p = choose_data_1["price"].mean()  # 计算买入均价--元
#
#
#     # 买方
#     # if i in use_data["seller"].values.tolist():
#         choose_data = use_data[use_data["seller"]==i]
#         # choose_data = use_data["seller"].isin(all_name)
#         print(choose_data)
#         s_t = choose_data["vol"].sum()  # 计算成交量--万股
#         # print(s_t)
#         s_p = choose_data["price"].mean()  # 计算卖出均价--元
#
#
#         #计算持有量
#         t = b_t - s_t
#
#         vol.append(t)
#         b_avr_price.append(b_p)
#         s_avr_price.append(s_p)
#         company_name.append(i)
b_avr_price = []
s_avr_price = []
company_name = []
vol_buy = []
vol_seller = []
seller_company_name = []
buyer_company_name = []
#分卖方和买方的分别统计
for i in buyer_name:
    # 买方
    # if i in use_data["buyer"].values.tolist() or i in use_data["seller"].values.tolist():
        choose_data_1 = use_data[use_data["buyer"]==i]
        b_t = choose_data_1["vol"].sum()  # 计算成交量--万股
        b_p = choose_data_1["price"].mean()  # 计算买入均价--元

        b_avr_price.append(b_p)
        vol_buy.append(b_t)
        buyer_company_name.append(i)

for i in seller_name:
    # 买方
        choose_data = use_data[use_data["seller"]==i]
        s_t = choose_data["vol"].sum()  # 计算成交量--万股
        s_p = choose_data["price"].mean()  # 计算卖出均价--元

        s_avr_price.append(s_p)
        vol_seller.append(s_t)
        seller_company_name.append(i)


print(vol_buy,len(vol_buy))
print(vol_seller,len(vol_seller))
print(b_avr_price,len(b_avr_price))
print(s_avr_price,len(s_avr_price))
print(seller_company_name,len(seller_company_name))
print(buyer_company_name,len(buyer_company_name))

（4）计算不同机构的持仓情况和成交均价
#分开处理数据dict-dataframe
big_dict_1 = {}  #买方
big_dict_2 = {}  #卖方
big_dict_1["company_name"]=buyer_company_name
big_dict_1["remain_holding"]=vol_buy
big_dict_1["avg_price"]=b_avr_price


big_dict_2["company_name"]=seller_company_name
big_dict_2["remain_holding"]=vol_seller
big_dict_2["avg_price"]=s_avr_price

import  pandas as pd
a_b = pd.DataFrame(big_dict_1)
a_s = pd.DataFrame(big_dict_2)

# 错误
# for i in a_s["company_name"].values:
#     if i in a_b["company_name"].values:
#         a_b[a_b["company_name"]==i]["remain_holding"] = a_b[a_b["company_name"]==i]["remain_holding"]-a_b[a_b["company_name"]==i]["remain_holding"]
#         a_b[a_b["company_name"] == i]["avg_price"] = (a_b[a_b["company_name"] == i]["avg_price"] + a_b[a_b["company_name"] == i][ "avg_price"])*1/2
#
#     else:
#         a_b.append(a_s[a_s["company_name"]==i])


# dataframe-dict（转换后因为keys为index，比较好操作）
'''
外层keys:company_name,remain_holding,avg_price
内层keys:index
'''
a_b_data = a_b.to_dict()
a_s_data = a_s.to_dict()

# 如果卖出机构的名称没在买入机构里面：则添加卖出数据到买入的信息里面
# 如果卖出信息的机构名称在买入机构里面：则改变持有量和持有价格
for i in a_s_data["company_name"]:
    if a_s_data["company_name"][i] in a_b_data["company_name"].values():
        a_b_data["remain_holding"][i] = int(a_b_data["remain_holding"][i] - a_s_data["remain_holding"][i])
        a_b_data["avg_price"][i] = (float(a_b_data["avg_price"][i]) + float(a_s_data["avg_price"][i])*0.5)

    else:
        # dict.setdefault('word', []).append([1, 2, 3])--给字典新增一个item
        a_b_data["company_name"][len(a_b_data["company_name"]) + 1] = a_s_data["company_name"][i]
        a_b_data["remain_holding"][len(a_b_data["remain_holding"])+1] = a_s_data["remain_holding"][i]
        a_b_data["avg_price"][len(a_b_data["avg_price"]) + 1] = a_s_data["avg_price"][i]

print(pd.DataFrame(a_b_data))

如果对于有更好的处理方式，欢迎指教哟~~