def get_profit_df(code: str, start_date: str, end_date: str) -> pd.DataFrame:
column_mapping = {"pubDate": "date", "statDate": "period", "roeAvg": "value"}
fields = bs.query_profit_data(code="sh.600519", year=2020, quarter=1).fields
start_date = datetime.strptime(start_date, "%Y-%m-%d")
end_date = datetime.strptime(end_date, "%Y-%m-%d")
args = [(year, quarter) for quarter in range(1, 5) for year in range(start_date.year - 1, end_date.year + 1)]
profit_list = []
for year, quarter in args:
resp = bs.query_profit_data(code=code, year=year, quarter=quarter)
while (resp.error_code == "0") and resp.next():
if "pubDate" not in resp.fields:
continue
row_data = resp.get_row_data()
pub_date = pd.Timestamp(row_data[resp.fields.index("pubDate")])
if start_date <= pub_date <= end_date and row_data:
profit_list.append(row_data)
profit_df = pd.DataFrame(profit_list, columns=fields)
try:
profit_df = profit_df[list(column_mapping.keys())]
except KeyError:
return pd.DataFrame()
profit_df.rename(columns=column_mapping, inplace=True)
profit_df["field"] = "roeWa"
profit_df["value"] = pd.to_numeric(profit_df["value"], errors="ignore")
return profit_df
def get_profit_data(stock_number, stock_name, year, quarter):
print('==========================================================')
print("开始进行: " + stock_name + "(" + stock_number + ")" + "的数据处理")
print("尝试登陆baostock")
#####login#####
lg = bs.login(user_id="anonymous", password="******")
if (lg.error_code == '0'):
print("登陆成功")
else:
print("登录失败")
#####get stock data#####
rs = bs.query_profit_data(code=stock_number, year=year, quarter=quarter)
print('请求历史数据返回代码:' + rs.error_code)
print('请求历史数据返回信息:' + rs.error_msg)
data_list = []
while (rs.error_code == '0') & rs.next():
data_list.append(rs.get_row_data())
result = pd.DataFrame(data_list, columns=rs.fields)
bs.logout()
print(stock_name + "(" + stock_number + ")" + "的数据处理完成")
return result
def roeget(stackcode):
import baostock as bs
import pandas as pd
# 登陆系统
lg = bs.login()
# 显示登陆返回信息
# print('login respond error_code:'+lg.error_code)
# print('login respond error_msg:'+lg.error_msg)
# 查询季频估值指标盈利能力
profit_list = []
for y in range(2007, 2021):
qu = 4
if y == 2021:
qu = 1
for i in range(qu):
rs_profit = bs.query_profit_data(code=stackcode,
year=y,
quarter=i + 1)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
# 结果集输出到csv文件
result_profit.to_csv("profit_data.csv", encoding="utf8", index=False)
# 登出系统
bs.logout()
def get_quarter_data(code,start='2019-01-01',end='2020-02-02'):
start_year=start[:4]
end_year=end[:4]
cash_flow_list=[]
profit_list = []
balance_list =[]
growth_list = []
for year in range(int(start_year),int(end_year)):
for quarter in range(1,5):
if today[:4]>=str(year):
# print(code,start, end)
rs_cash_flow = bs.query_cash_flow_data(code=code, year=year, quarter=quarter)##现金流
while (rs_cash_flow.error_code == '0') & rs_cash_flow.next():
cash_flow_list.append(rs_cash_flow.get_row_data())
rs_profit = bs.query_profit_data(code=code, year=year, quarter=quarter)##盈利
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
rs_balance = bs.query_balance_data(code=code, year=year, quarter=quarter) ##资产负债
while (rs_balance.error_code == '0') & rs_balance.next():
balance_list.append(rs_balance.get_row_data())
rs_growth = bs.query_growth_data(code=code, year=year, quarter=quarter) ##成长
while (rs_growth.error_code == '0') & rs_growth.next():
growth_list.append(rs_growth.get_row_data())
result_cash_flow = pd.DataFrame(cash_flow_list, columns=rs_cash_flow.fields)
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
result_balance = pd.DataFrame(balance_list, columns=rs_balance.fields)
result_growth = pd.DataFrame(growth_list, columns=rs_growth.fields)
return result_cash_flow,result_profit,result_balance,result_growth
def fetch_profit_data(stocklist, start_year=2007, current_year=2020, current_quarter=4):
bs.login()
db_conn = create_engine(common.db_path_sqlalchemy)
for code in stocklist["code"]:
profit_list = []
if code.startswith("sh.6") | code.startswith("sz.00") | code.startswith("sz.300"):
for year in range(start_year, current_year + 1):
start_quarter = 1
if year < current_year:
end_quarter = 4
else:
end_quarter = current_quarter - 1
for quarter in range(start_quarter, end_quarter + 1):
# 查询季频估值指标盈利能力
print(code + ' profit: ' + year.__str__() + 'Q' + quarter.__str__())
rs_profit = bs.query_profit_data(code=code, year=year, quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append([year, quarter] + rs_profit.get_row_data())
if len(profit_list) > 0:
db_conn.execute(r'''INSERT OR REPLACE INTO stock_profit_data VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)''',
profit_list)
print(code + ' fetch profit data finish and write database')
bs.logout()
def jingzichshouyi(stock_code, myyear, myquarter):
list1 = []
rs1 = bs.query_profit_data(code=stock_code, year=myyear, quarter=myquarter)
while (rs1.error_code == '0') & rs1.next():
list1.append(rs1.get_row_data())
result1 = pd.DataFrame(list1, columns=rs1.fields)
return result1[['roeAvg']]
def query_profit_data(self, quarter):
data_list = []
rs = bs.query_profit_data(code=self.code, year=self.year, quarter=quarter)
fields = ['code', 'pubDate', 'statDate', 'roeAvg', 'npMargin', 'gpMargin', 'netProfit', 'epsTTM', 'MBRevenue', 'totalShare', 'liqaShare']
while (rs.error_code == '0') & rs.next():
data_list.append(rs.get_row_data())
data = jsonWrapper(data_list, fields)
return rs.error_code, rs.error_msg, list(map(lambda x: { attr: x.get(attr, '') for attr in self.attr_fields }, data)) if self.attr_fields else data
def queryProfitByCode(code,year,season):
# 查询季频估值指标盈利能力
profit_list = []
rs_profit = bs.query_profit_data(code=code, year=year, quarter=season)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
return result_profit
def queryInfo(self, stock_code):
profit_list = []
rs_profit = bs.query_profit_data(stock_code, year=2020, quarter=2)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
liqaShare = result_profit['liqaShare']
return float(liqaShare)
def getquarterdata(companycode, year, quarter):
profit_list = []
rs_profit = bs.query_profit_data(code=companycode,
year=year,
quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
if len(profit_list) == 0:
return [], []
# 营运能力
operation_list = []
rs_operation = bs.query_operation_data(code=companycode,
year=year,
quarter=quarter)
while (rs_operation.error_code == '0') & rs_operation.next():
operation_list.append(rs_operation.get_row_data())
# 成长能力
growth_list = []
rs_growth = bs.query_growth_data(code=companycode,
year=year,
quarter=quarter)
while (rs_growth.error_code == '0') & rs_growth.next():
growth_list.append(rs_growth.get_row_data())
# 偿债能力
balance_list = []
rs_balance = bs.query_balance_data(code=companycode,
year=year,
quarter=quarter)
while (rs_balance.error_code == '0') & rs_balance.next():
balance_list.append(rs_balance.get_row_data())
# 季频现金流量
cash_flow_list = []
rs_cash_flow = bs.query_cash_flow_data(code=companycode,
year=year,
quarter=quarter)
while (rs_cash_flow.error_code == '0') & rs_cash_flow.next():
cash_flow_list.append(rs_cash_flow.get_row_data())
# 查询杜邦指数
dupont_list = []
rs_dupont = bs.query_dupont_data(code=companycode,
year=year,
quarter=quarter)
while (rs_dupont.error_code == '0') & rs_dupont.next():
dupont_list.append(rs_dupont.get_row_data())
if len(profit_list) * len(operation_list) * len(growth_list) * len(
balance_list) * len(cash_flow_list) * len(dupont_list) == 0:
return [], []
datalist = [companycode + "-" + year + "-" + quarter]
datalist += profit_list[0] + operation_list[0] + growth_list[
0] + balance_list[0] + cash_flow_list[0] + dupont_list[0]
fieldslist = ["quaryContent"]
fieldslist += rs_profit.fields + rs_operation.fields + rs_growth.fields + rs_balance.fields + rs_cash_flow.fields + rs_dupont.fields
return datalist, fieldslist
def get_profit_data(id, year, quar):
profit_list = []
rs_profit = bs.query_profit_data(code=id, year=year, quarter=quar)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
result_profit["liqaShare"] = [
1 if x == "" else float(x) for x in result_profit["liqaShare"]
]
return (result_profit)
def get_profit_data():
"""
获取季频盈利能力数据
"""
# 登陆系统
lg = bs.login()
# 显示登陆返回信息
print('login respond error_code:' + lg.error_code)
print('login respond error_msg:' + lg.error_msg)
with concurrent.futures.ThreadPoolExecutor() as executor:
with session_scope() as sm:
rp = sm.query(TaskTable).filter(
TaskTable.task == TaskEnum.季频盈利能力.value,
TaskTable.finished == False)
for task in rp:
if task.finished:
continue
start_year = task.begin_date.year
end_year = task.end_date.year
dflist = []
for y in range(start_year, end_year):
for q in range(1, 5):
max_try = 8 # 失败重连的最大次数
for i in range(max_try):
rs_profit = bs.query_profit_data(code=task.ts_code,
year=y,
quarter=q)
if rs_profit.error_code == '0':
profit_list = []
while (rs_profit.error_code
== '0') & rs_profit.next():
profit_list.append(
rs_profit.get_row_data())
result_df = pd.DataFrame(
profit_list, columns=rs_profit.fields)
dflist.append(result_df)
break
elif i < (max_try - 1):
time.sleep(2)
_logger.error('{}:{}-{} 获取数据失败，重连……'.format(
task.ts_code, y, q))
continue
task.finished = True
executor.submit(_save_date, dflist, task.ts_code)
sm.commit()
# 登出系统
bs.logout()
def query_profit():
# 接口提供的数据最早从2007年开始
lg = bs.login()
shobjs = AStocksHeader.objects.all()
count = 0
start = time()
for obj in shobjs:
profit_list = []
count += 1
print(count)
for year in range(2007, 2020):
for quarter in range(1, 5):
if obj.stock_code.startswith('6'):
rs_profit = bs.query_profit_data(code="sh.{}".format(
obj.stock_code),
year=year,
quarter=quarter)
else:
rs_profit = bs.query_profit_data(code="sz.{}".format(
obj.stock_code),
year=year,
quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list,
columns=rs_profit.fields).values
for item in result_profit:
ap = AStocksProfit()
ap.stock = obj
ap.pub_date = item[1]
ap.stat_date = item[2]
ap.roe_avg = float(item[3]) if item[3] else 0.0
ap.np_margin = float(item[4]) if item[4] else 0.0
ap.gp_margin = float(item[5]) if item[5] else 0.0
ap.net_profit = float(item[6]) if item[6] else 0.0
ap.epsttm = float(item[7]) if item[7] else 0.0
ap.mb_revenue = float(item[8]) if item[8] else 0.0
ap.total_share = float(item[9]) if item[9] else 0.0
ap.liqa_share = float(item[10]) if item[10] else 0.0
ap.save()
print('import finish, need time: ', time() - start)
bs.logout()
def query_one_stock_profit_data(stock_code, year, quarter):
'''
查询季频估值指标盈利能力
'''
profit_list = []
rs_profit = bs.query_profit_data(code=stock_code,
year=year,
quarter=quarter)
print(rs_profit.fields)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
return profit_list
def query_profit_data(self, code, year = None, quarter = None):
'''
code：股票代码，sh或sz.+6位数字代码，或者指数代码，如：sh.601398。sh：上海；sz：深圳。此参数不可为空；
year：统计年份，为空时默认当前年；
quarter：统计季度，可为空，默认当前季度。不为空时只有4个取值：1，2，3，4。
'''
profit_list = []
rs = bs.query_profit_data(code=code, year=year, quarter=quarter)
self.log('query_profit_data respond error_msg:', rs)
while (rs.error_code == '0') & rs.next():
profit_list.append(rs.get_row_data())
result = pd.DataFrame(profit_list, columns=rs.fields)
return result
def profit(code, year, quarter):
filename = "data/profile_{}_{}_{}.csv".format(code, year, quarter)
if os.path.exists(filename):
result_profit = pd.read_csv(filename)
else:
rs_profit = bs.query_profit_data(code, year=year, quarter=quarter)
data_list = []
while (rs_profit.error_code == '0') & rs_profit.next():
data_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(data_list, columns=rs_profit.fields)
result_profit.to_csv(filename, encoding="utf-8", index=False)
return result_profit
def get_closeprice(code):
rs_open = bs.query_profit_data(code, year=2015, quarter=3)
data_list = []
while(rs_open.error_code == '0') & rs_open.next():
data_list.append(rs_open.get_row_data())
result_open = pd.DataFrame(data_list, columns=rs_open.fields, index=[code])
rs_close = bs.query_profit_data(code, year=2020, quarter=3)
data_list = []
while(rs_close.error_code == '0') & rs_close.next():
data_list.append(rs_close.get_row_data())
result_close = pd.DataFrame(data_list, columns=rs_close.fields, index=[code])
result = pd.merge(result_open, result_close, on="code")
result = result[["code","netProfit_x","netProfit_y","roeAvg_y","npMargin_y","gpMargin_y"]]
evalue_list = []
evalue = bs.query_history_k_data_plus(code, "peTTM", start_date="2021-03-08", frequency="d", adjustflag="3")
while(evalue.error_code == '0') & evalue.next():
evalue_list.append(evalue.get_row_data())
result["pe"] = evalue_list[len(evalue_list) - 1][0]
return result
def query_profit_data(self):
"""
季频盈利能力：query_profit_data()
方法说明：查询季频盈利能力信息，可以通过参数设置获取对应年份、季度数据，提供2007年至今数据。
返回类型：pandas的DataFrame类型。
"""
all_stock = pd.read_csv(self.path + "all_stock.csv")
all_stock.drop_duplicates(subset=['code'], keep='first', inplace=True)
end_year = int(self.end_date[0:4])
quarter_list = [1, 2, 3, 4]
# 登陆系统
lg = bs.login()
# 显示登陆返回信息
#print('login respond error_code:'+lg.error_code)
#print('login respond error_msg:'+lg.error_msg)
result_all = pd.DataFrame([])
for code in all_stock.code:
# 查询季频估值指标盈利能力
year = int(self.start_date[0:4])
while (year <= end_year):
for quarter in quarter_list:
profit_list = []
rs_profit = bs.query_profit_data(code=code,
year=year,
quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list,
columns=rs_profit.fields)
result_all = result_all.append(result_profit)
year = year + 1
# 结果集输出到csv文件
profit_data = pd.read_csv(self.path + "profit_data.csv")
result_all = result_all.append(profit_data)
result_all.drop_duplicates(subset=['code', 'pubDate', 'statDate'],
keep='first',
inplace=True)
result_all.to_csv(self.path + "profit_data.csv",
encoding="gbk",
index=False)
# 登出系统
bs.logout()
return
def find_data(code, year_list, quarter_list):
# 查询季频估值指标盈利能力
profit_list = []
for year in year_list:
for quarter in quarter_list:
rs_profit = bs.query_profit_data(code=code,
year=year,
quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
# print(result_profit)
return result_profit
def download_foundamental(start, end, gpb):
lg = bs.login()
logger.info("login error code: {}, logging error messge: {}".format(
lg.error_code, lg.error_msg))
df_stock = pd.read_excel(r'Tickers_download.xlsx')
new_stock_list = []
for i in df_stock.index:
new_stock_list.append(df_stock['Ticker'][i])
downloads = os.listdir('downloads_{}/'.format(gpb))
had = set()
for f in downloads:
parts = f.split("_")
had.add(int(parts[0]))
t = start
total = end - start
count = 0
for i in new_stock_list[start:end]:
count += 1
result_list = []
for k in range(2015, 2020):
for j in range(1, 5):
if (t in had):
logger.info("====omit {}====".format(t))
t += 1
continue
else:
logger.info("====process {}_{}, {} out of {}====".format(
i, t, count, total))
if gpb == "gro":
rs = bs.query_growth_data(code=i, year=k, quarter=j)
elif gpb == "pro":
rs = bs.query_profit_data(code=i, year=k, quarter=j)
elif gpb == "bal":
rs = bs.query_balance_data(code=i, year=k, quarter=j)
logger.info("error code: {}, error message: {}".format(
rs.error_code, rs.error_msg))
while (rs.error_code == '0') & rs.next():
result_list.append(rs.get_row_data())
# print(result_list)
result = pd.DataFrame(result_list, columns=rs.fields)
output = "downloads_{}/{}_{}.csv".format(gpb, t, i)
t += 1
result.to_csv(output, encoding="gbk", index=False)
def generate_stock_details(stock_price_df, quarter_date_list, saved=False):
code_list = stock_price_df['code'].unique()
result = pd.DataFrame()
lg = bs.login()
for i in range(len(quarter_date_list) - 1):
print(quarter_date_list[i], end=',')
left_date = datetime.datetime.strptime(
quarter_date_list[i], "%Y-%m-%d") - datetime.timedelta(1)
left_date_str = datetime.datetime(left_date.year, left_date.month,
left_date.day, 0,
0).strftime("%Y-%m-%d")
right_date_str = quarter_date_list[i + 1]
profit_list = []
for code in code_list:
rs_profit = bs.query_profit_data(code=code,
year=left_date.year,
quarter=left_date.month // 4 + 1)
while (rs_profit.error_code == '0') & rs_profit.next():
temp = rs_profit.get_row_data()
profit_list.append(temp)
profit_df = pd.DataFrame(profit_list, columns=rs_profit.fields)
result = pd.concat([
result,
pd.merge(
stock_price_df[(stock_price_df['date'] > left_date_str)
& (stock_price_df['date'] < right_date_str)],
profit_df[['code', 'totalShare']],
on='code')
])
result[['totalShare']] = result[['totalShare']].astype('float')
result['marketCapitalization'] = result['totalShare'] * result['ave_close']
bs.logout()
if saved is True:
result.to_csv("TMT_stock_details.csv",
index=False,
encoding='utf_8_sig')
else:
result.reset_index(drop=True)
return result
def get_profit_from_start_year(code, start_year: int):
"""
获取指定年度到现在的1,2,3,4季度
"""
data_list = []
for y in range(start_year, datetime.datetime.now().year + 1):
for i in range(1, 5):
rs = bs.query_profit_data(get_type(code) + code, year=y, quarter=i)
while (rs.error_code == '0') & rs.next():
d = {}
r = rs.get_row_data()
for k_i in range(len(r)):
d[rs.fields[k_i]] = r[k_i]
d['statDate'] = datetime.datetime.strptime(d['statDate'], '%Y-%m-%d')
for k in d.keys():
if k not in ['code', 'pubDate', 'statDate']:
d[k] = str_to_dec(d[k])
data_list.insert(0, d)
return data_list
def getFinDataFromBS(self, codes: list, year: int, quarter: int):
#盈利能力
bs.login()
for code in codes:
ay = code.split(".")
exchg = ay[0]
rawcode = ay[1]
bscode = ''
if exchg == 'SSE':
bscode = 'sh.' + rawcode
else:
bscode = 'sz.' + rawcode
fdata = dict()
fdata['code'] = code
rs = bs.query_profit_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
rs = bs.query_operation_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
rs = bs.query_growth_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
rs = bs.query_balance_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
rs = bs.query_cash_flow_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
rs = bs.query_dupont_data(bscode, year, quarter)
fdata = recordToDict(rs, fdata)
# rs = bs.query_performance_express_report(bscode, year, quarter)
# fdata = recordToDict(rs, fdata)
# rs = bs.query_forcast_report(bscode, year, quarter)
# fdata = recordToDict(rs, fdata)
bs.logout()
return fdata
def download(stockCode, yearList: list, fileName):
#### 登陆系统 ####
lg = bs.login()
# 显示登陆返回信息
print('login respond error_code:' + lg.error_code)
print('login respond error_msg:' + lg.error_msg)
# 查询季频估值指标盈利能力
profit_list = []
for year in yearList:
for quarter in [1, 2, 3, 4]:
rs_profit = bs.query_profit_data(code=stockCode, year=year, quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
saveToCsv(profit_list, fileName)
#### 登出系统 ####
bs.logout()
def get_profit_data_year(stock_number, stock_name, start_year, end_year):
print('==========================================================')
print("开始进行: " + stock_name + "(" + stock_number + ")" + "的数据处理")
print("尝试登陆baostock")
data_list = []
lg = bs.login(user_id="anonymous", password="******")
if (lg.error_code == '0'):
print("登陆成功")
else:
print("登录失败")
for y in range(int(start_year), int(end_year) + 1):
for q in range(1, 5):
#####get stock data#####
rs = bs.query_profit_data(code=stock_number, year=y, quarter=q)
while (rs.error_code == '0') & rs.next():
data_list.append(rs.get_row_data())
result = pd.DataFrame(data_list, columns=rs.fields)
bs.logout()
print(stock_name + "(" + stock_number + ")" + "的数据处理完成")
print('==========================================================')
return result
def post(self, request):
'''
quarter: 为空--""，默认查当前季度
'''
if request.body:
msg = json.loads(request.body)
# 查询季频估值指标盈利能力
profit_list = []
rs_profit = baostock.query_profit_data(code=msg["code"],
year=msg["year"],
quarter=msg["quarter"])
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pandas.DataFrame(profit_list,
columns=rs_profit.fields)
response = result_profit.to_json(orient="records")
print(response)
return HttpResponse(json.dumps(response))
else:
result = {"code": -1, "msg": "fail"}
return HttpResponse(result)
def query_profit_data(code, year=None, quarter=None):
"""
季频盈利能力
方法说明：通过API接口获取季频盈利能力信息，可以通过参数设置获取对应年份、季度数据，提供2007年至今数据。
返回类型：pandas的DataFrame类型。
参数含义：
code：股票代码，sh或sz.+6位数字代码，或者指数代码，如：sh.601398。sh：上海；sz：深圳。此参数不可为空；
year：统计年份，为空时默认当前年；
quarter：统计季度，可为空，默认当前季度。不为空时只有4个取值：1，2，3，4。
"""
lg = bs.login()
if lg.error_code != '0':
logger.error('login respond error_msg:' + lg.error_msg)
profit_list = []
rs_profit = bs.query_profit_data(code=code, year=year, quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list, columns=rs_profit.fields)
bs.logout()
return result_profit
def GetCurrentStockFundamentals(self, *args, **kwargs):
post_data_code = CheckKeyOrAbort(kStockCodeKey, kwargs)
profit_data_handler = bs.query_profit_data(post_data_code)
profit_data = profit_data_handler.get_data()
operation_data_handler = bs.query_operation_data(post_data_code)
operation_data = operation_data_handler.get_data()
growth_data_handler = bs.query_growth_data(post_data_code)
growth_data = growth_data_handler.get_data()
balance_data_handler = bs.query_balance_data(post_data_code)
balance_data = balance_data_handler.get_data()
cash_flow_data_handler = bs.query_balance_data(post_data_code)
cash_flow_data = cash_flow_data_handler.get_data()
dupont_data_handler = bs.query_dupont_data(post_data_code)
dupont_data = dupont_data_handler.get_data()
performance_data_handler = bs.query_performance_express_report(
post_data_code)
performance_data = performance_data_handler.get_data()
forecast_data_handler = bs.query_forecast_report(post_data_code)
forecast_data = forecast_data_handler.get_data()
return profit_data, operation_data, growth_data, balance_data, cash_flow_data, dupont_data, performance_data, forecast_data
def getProfit(code, year, quarter):
if DEBUG_PROFIT_CACHE:
fileName = "%s_%s_profit_data.csv" % (year, quarter)
filePath = DEBUG_CACHE_DIR + fileName
print("read cache profit: ", filePath)
result_profit = csv2DateFrame(filePath)
try:
result_profit.index = result_profit['code']
result_profit = result_profit.loc[code]
except:
result_profit = None
else:
lg = bs.login()
if lg.error_code == '0':
# 查询季频估值指标盈利能力
profit_list = []
rs_profit = bs.query_profit_data(code=code,
year=year,
quarter=quarter)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
result_profit = pd.DataFrame(profit_list,
columns=rs_profit.fields).loc[0]
bs.logout()
return result_profit
def getSeasonDataOneCode(i):
import baostock as bs
import pandas as pd
# #### 登陆系统 ####
# lg = bs.login()
profit_list = []
growth_list = []
dupont_list = []
code = codeFormat(i)
for j in range(2015, 2023):
for k in range(1, 5):
# 读取季度盈利
rs_profit = bs.query_profit_data(code=code, year=j, quarter=k)
while (rs_profit.error_code == '0') & rs_profit.next():
profit_list.append(rs_profit.get_row_data())
# 读取季度成长
rs_growth = bs.query_growth_data(code=code, year=j, quarter=k)
while (rs_growth.error_code == '0') & rs_growth.next():
growth_list.append(rs_growth.get_row_data())
# 读取杜邦分析
rs_dupont = bs.query_dupont_data(code=code, year=j, quarter=k)
while (rs_dupont.error_code == '0') & rs_dupont.next():
dupont_list.append(rs_dupont.get_row_data())
# 处理盈利分析
profit_list = profit_list[::-1]
if profit_list != []:
epsTTMArray = [i, "每股收益/epsTTM",
dateSeasonFormat(profit_list[0][2])] # 每股收益
# roeAvgArray = [i, "净资产收益率/roeAvg",profit_list[0][2]] #净资产收益率
for x in profit_list:
x[2] = dateSeasonFormat(x[2])
if x[7] != '':
epsTTMArray.append(round(float(x[7]), 2))
else:
epsTTMArray.append(0)
# roeAvgArray.append(round(float(x[3]),2))
# 处理成长
growth_list = growth_list[::-1]
yoyniArray = [
i, "净利润同比增长率G/yoyni",
dateSeasonFormat(growth_list[0][2])
] # 净利润同比增长率
for x in growth_list:
x[2] = dateSeasonFormat(x[2])
if x[5] == '':
yoyniArray.append('')
else:
yoyniArray.append(round(float(x[5]), 2))
# 处理杜邦分析
dupont_list = dupont_list[::-1]
dupontROEArray = [
i, "净资产收益率/dupontROE",
dateSeasonFormat(dupont_list[0][2])
] # 杜邦表ROE，净资产收益率
dupontNitogrArray = [
i, "销售净利润率/dupontNitogr",
dateSeasonFormat(dupont_list[0][2])
] # 销售净利润率，净利润/营业总收入
dupontAssetTurnArray = [
i, "总资产周转率/dupontAssetTurn",
dateSeasonFormat(dupont_list[0][2])
] # 总资产周转率
dupontAssetStoEquityArray = [
i, "权益乘数/dupontAssetStoEquity",
dateSeasonFormat(dupont_list[0][2])
] # 权益乘数
for x in dupont_list:
x[2] = dateSeasonFormat(x[2])
if x[3] == '':
dupontROEArray.append('')
else:
dupontROEArray.append(round(float(x[3]), 3))
if x[7] == '':
dupontNitogrArray.append('')
else:
dupontNitogrArray.append(round(float(x[7]), 2))
if x[5] == '':
dupontAssetTurnArray.append('')
else:
dupontAssetTurnArray.append(round(float(x[5]), 2))
if x[4] == '':
dupontAssetStoEquityArray.append('')
else:
dupontAssetStoEquityArray.append(round(float(x[4]), 2))
# 把数据聚合
# array.append(epsTTMArray)
# array.append(yoyniArray)
# array.append(dupontROEArray)
# array.append(dupontNitogrArray)
# array.append(dupontAssetTurnArray)
# array.append(dupontAssetStoEquityArray)
# bs.logout()
return [
epsTTMArray, yoyniArray, dupontROEArray, dupontNitogrArray,
dupontAssetTurnArray, dupontAssetStoEquityArray
]
#### 登出系统 ####
else:
# bs.logout()
return [[], [], [], [], [], []]
