Lxy
/
Backtesting
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: 添加涨停回测；及优化

Browse Source
master
laixingyu 2 years ago
commit 1cc68a70c3
2 changed files with 1059 additions and 0 deletions
Show Stats Download Patch File Download Diff File

853
calculateTrends1.py
Unescape View File

@ -0,0 +1,853 @@
# 涨停后，各个场景买入后，第二天开盘卖出的成功率
import pandas as pd
import pymysql
from sqlalchemy import create_engine
import matplotlib.pyplot as plt
import os
# 计算盈亏, -6以上,-6,-3,0,3,6,6以上
def count_profit(diff, loss_over_6, loss_6_to_3, loss_3_to_0,profit_0_to_3,profit_3_to_6,profit_over_6):
if diff <= -6:
loss_over_6 += 1
elif diff > -6 and diff <= -3:
loss_6_to_3 += 1
elif diff > -3 and diff <= 0:
loss_3_to_0 += 1
elif diff > 0 and diff <= 3:
profit_0_to_3 += 1
elif diff > 3 and diff <= 6:
profit_3_to_6 += 1
else:
profit_over_6 += 1
return loss_over_6, loss_6_to_3, loss_3_to_0,profit_0_to_3,profit_3_to_6,profit_over_6
# 创建数据库连接
engine = create_engine('mysql+pymysql://root:1qazse42W3@192.168.0.222:3306/ry')
# 执行SQL查询来获取日期列表
# 假设你的数据表中有一个date字段表示日期
date_df = pd.read_sql_query('select date from trade_dates where trade = "trading" and date between "2023-01-01" and "2023-06-01" order by date', engine)
# 将date字段转换为日期类型
date_df['date'] = pd.to_datetime(date_df['date'])
# 获取日期列表
date_list = date_df['date'].tolist()
counters = {
'total': 0,
# 买入日的开盘价分布
'open': {'low_over_6': 0,'low_6_to_3': 0,'low_3_to_0': 0, 'high_0_to_3': 0, 'high_3_to_6': 0, 'high_over_6': 0},
# 买入日的收盘价分布
'close': {'low_over_6': 0,'low_6_to_3': 0,'low_3_to_0': 0, 'high_0_to_3': 0, 'high_3_to_6': 0, 'high_over_6': 0},
# 清仓日的开盘价分布
'sale_open': {'low_over_6': 0,'low_6_to_3': 0,'low_3_to_0': 0, 'high_0_to_3': 0, 'high_3_to_6': 0, 'high_over_6': 0},
# 清仓日的收盘价分布
'sale_close': {'low_over_6': 0,'low_6_to_3': 0,'low_3_to_0': 0, 'high_0_to_3': 0, 'high_3_to_6': 0, 'high_over_6': 0},
'scenarios': {
'low_open_low_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'low_open_high_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'low_open_normal_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'normal_open_low_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'normal_open_high_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'normal_open_normal_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'high_open_low_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'high_open_high_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
'high_open_normal_sale': {'high_profit': 0, 'low_profit': 0, 'low_loss': 0, 'high_loss': 0},
}
}
total_count = 0
# 低于-3%的开盘价计数
low_open_count = 0
# 正常开盘，介于-3%和3%之间的计数
normal_open_count = 0
# 高于3%的开盘价计数
high_open_count = 0
# 低于-3%的收盘价计数
low_close_count = 0
# 正常收盘，介于-3%和3%之间的计数
normal_close_count = 0
# 高于3%的收盘价计数
high_close_count = 0
# 开盘清仓，低于3%的清仓计数
low_sale_open_count = 0
# 开盘清仓，高于3%的清仓计数
high_sale_open_count = 0
# 开盘清仓，正常清仓计数
normal_sale_open_count = 0
# 收盘清仓，低于3%的清仓计数
low_sale_close_count = 0
# 收盘清仓，高于3%的清仓计数
high_sale_close_count = 0
# 收盘清仓，正常清仓计数
normal_sale_close_count = 0
##########基于开盘、收盘买入的整体盈亏分布############
# 盈利高于5%的清仓开盘价计数
high_profit_sale_open_count = 0
# 盈利低于5%的清仓开盘价计数
low_profit_sale_open_count = 0
# 亏损低于5%的清仓开盘价计数
low_loss_sale_open_count = 0
# 亏损高于5%的清仓开盘价计数
high_loss_sale_open_count = 0
# 盈利高于5%的清仓收盘价计数
high_profit_sale_close_count = 0
# 盈利低于5%的清仓收盘价计数
low_profit_sale_close_count = 0
# 亏损低于5%的清仓收盘价计数
low_loss_sale_close_count = 0
# 亏损高于5%的清仓收盘价计数
high_loss_sale_close_count = 0
#####################################
# 组合场景 低开盘-低清仓 低开盘-高清仓 低开盘-正常清仓 正常开盘-低清仓 正常开盘-高清仓 正常开盘-正常清仓 高开盘-低清仓 高开盘-高清仓 高开盘-正常清仓
low_open_low_sale_count = 0
low_open_high_sale_count = 0
low_open_normal_sale_count = 0
normal_open_low_sale_count = 0
normal_open_high_sale_count = 0
normal_open_normal_sale_count = 0
high_open_low_sale_count = 0
high_open_high_sale_count = 0
high_open_normal_sale_count = 0
# 各组合场景的收益情况 如 低开盘-高清仓：盈利高于5%的清仓收盘价计数 盈利低于5%的清仓收盘价计数 亏损低于5%的清仓收盘价计数 亏损高于5%的清仓收盘价计数
low_open_low_sale_high_profit_count = 0
low_open_low_sale_low_profit_count = 0
low_open_low_sale_low_loss_count = 0
low_open_low_sale_high_loss_count = 0
low_open_high_sale_high_profit_count = 0
low_open_high_sale_low_profit_count = 0
low_open_high_sale_low_loss_count = 0
low_open_high_sale_high_loss_count = 0
low_open_normal_sale_high_profit_count = 0
low_open_normal_sale_low_profit_count = 0
low_open_normal_sale_low_loss_count = 0
low_open_normal_sale_high_loss_count = 0
normal_open_low_sale_high_profit_count = 0
normal_open_low_sale_low_profit_count = 0
normal_open_low_sale_low_loss_count = 0
normal_open_low_sale_high_loss_count = 0
normal_open_high_sale_high_profit_count = 0
normal_open_high_sale_low_profit_count = 0
normal_open_high_sale_low_loss_count = 0
normal_open_high_sale_high_loss_count = 0
normal_open_normal_sale_high_profit_count = 0
normal_open_normal_sale_low_profit_count = 0
normal_open_normal_sale_low_loss_count = 0
normal_open_normal_sale_high_loss_count = 0
high_open_low_sale_high_profit_count = 0
high_open_low_sale_low_profit_count = 0
high_open_low_sale_low_loss_count = 0
high_open_low_sale_high_loss_count = 0
high_open_high_sale_high_profit_count = 0
high_open_high_sale_low_profit_count = 0
high_open_high_sale_low_loss_count = 0
high_open_high_sale_high_loss_count = 0
high_open_normal_sale_high_profit_count = 0
high_open_normal_sale_low_profit_count = 0
high_open_normal_sale_low_loss_count = 0
high_open_normal_sale_high_loss_count = 0
# 组合场景 低收盘-低清仓 低收盘-高清仓 低收盘-正常清仓 正常收盘-低清仓 正常收盘-高清仓 正常收盘-正常清仓 高收盘-低清仓 高收盘-高清仓 高收盘-正常清仓
low_close_low_sale_count = 0
low_close_high_sale_count = 0
low_close_normal_sale_count = 0
normal_close_low_sale_count = 0
normal_close_high_sale_count = 0
normal_close_normal_sale_count = 0
high_close_low_sale_count = 0
high_close_high_sale_count = 0
high_close_normal_sale_count = 0
# 各组合场景的收益情况 如 低收盘-高清仓：盈利高于5%的清仓收盘价计数 盈利低于5%的清仓收盘价计数 亏损低于5%的清仓收盘价计数 亏损高于5%的清仓收盘价计数
low_close_low_sale_high_profit_count = 0
low_close_low_sale_low_profit_count = 0
low_close_low_sale_low_loss_count = 0
low_close_low_sale_high_loss_count = 0
low_close_high_sale_high_profit_count = 0
low_close_high_sale_low_profit_count = 0
low_close_high_sale_low_loss_count = 0
low_close_high_sale_high_loss_count = 0
low_close_normal_sale_high_profit_count = 0
low_close_normal_sale_low_profit_count = 0
low_close_normal_sale_low_loss_count = 0
low_close_normal_sale_high_loss_count = 0
normal_close_low_sale_high_profit_count = 0
normal_close_low_sale_low_profit_count = 0
normal_close_low_sale_low_loss_count = 0
normal_close_low_sale_high_loss_count = 0
normal_close_high_sale_high_profit_count = 0
normal_close_high_sale_low_profit_count = 0
normal_close_high_sale_low_loss_count = 0
normal_close_high_sale_high_loss_count = 0
normal_close_normal_sale_high_profit_count = 0
normal_close_normal_sale_low_profit_count = 0
normal_close_normal_sale_low_loss_count = 0
normal_close_normal_sale_high_loss_count = 0
high_close_low_sale_high_profit_count = 0
high_close_low_sale_low_profit_count = 0
high_close_low_sale_low_loss_count = 0
high_close_low_sale_high_loss_count = 0
high_close_high_sale_high_profit_count = 0
high_close_high_sale_low_profit_count = 0
high_close_high_sale_low_loss_count = 0
high_close_high_sale_high_loss_count = 0
high_close_normal_sale_high_profit_count = 0
high_close_normal_sale_low_profit_count = 0
high_close_normal_sale_low_loss_count = 0
high_close_normal_sale_high_loss_count = 0
# 遍历日期列表
for i, date in enumerate(date_list):
if i+2 < len(date_list):
# 将日期转换为字符串格式，以便在SQL查询中使用
date_str = date.strftime('%Y-%m-%d')
if os.path.exists(f'D:/calculate_data/{date_str}_stock.csv'):
df = pd.read_csv(f'D:/calculate_data/{date_str}_stock.csv')
limit_list = df['code'].tolist()
for code in limit_list:
# 总统计数
total_count += 1
print(f'正在处理{date_str} - {code}的数据-从文件获取')
saleopen = df.loc[df['code'] == code, 'saleprice_open']
saleclose = df.loc[df['code'] == code, 'saleprice_close']
nextclose = df.loc[df['code'] == code, 'next_close']
# 计算清仓日开盘收盘价
saleprice_open_differrange = 100 * (saleopen - df.loc[df['code'] == code, 'next_open'])/df.loc[df['code'] == code, 'next_open']
saleprice_close_differrange = 100 * (saleclose - nextclose)/nextclose
# 第二日开盘价分布
next_open_diff = df.loc[df['code'] == code, 'next_open_diff'].values[0]
if next_open_diff < -3:
low_open_count += 1
elif next_open_diff > 3:
high_open_count += 1
else:
normal_open_count += 1
# 第二日收盘价分布
next_close_differrange = df.loc[df['code'] == code, 'next_close_differrange'].values[0]
if next_close_differrange < -3:
low_close_count += 1
elif next_close_differrange > 3:
high_close_count += 1
else:
normal_close_count += 1
# 清仓盈亏分布-开盘清仓
saleprice_open_differrange = df.loc[df['code'] == code, 'saleprice_open_differrange'].values[0]
if saleprice_open_differrange < -5:
high_loss_sale_open_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
low_loss_sale_open_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
low_profit_sale_open_count += 1
else:
high_profit_sale_open_count += 1
# 清仓盈亏分布-收盘清仓
saleprice_close_differrange = df.loc[df['code'] == code, 'saleprice_close_differrange'].values[0]
if saleprice_close_differrange < -5:
high_loss_sale_close_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
low_loss_sale_close_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
low_profit_sale_close_count += 1
else:
high_profit_sale_close_count += 1
# 组合场景 低开盘-低清仓 低开盘-高清仓 低开盘-正常清仓 正常开盘-低清仓 正常开盘-高清仓 正常开盘-正常清仓 高开盘-低清仓 高开盘-高清仓 高开盘-正常清仓
# 组合之类再进行计算盈亏分布
if next_open_diff < -3 :
if saleprice_open_differrange < -3:
low_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
low_open_high_sale_count += 1
else:
low_open_normal_sale_count += 1
if saleprice_open_differrange < -3:
if saleprice_open_differrange < -5:
low_open_low_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
low_open_low_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
low_open_low_sale_low_profit_count += 1
else:
low_open_low_sale_high_profit_count += 1
elif saleprice_open_differrange > 3:
if saleprice_open_differrange < -5:
low_open_high_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
low_open_high_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
low_open_high_sale_low_profit_count += 1
else:
low_open_high_sale_high_profit_count += 1
else:
if saleprice_open_differrange < -5:
low_open_normal_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
low_open_normal_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
low_open_normal_sale_low_profit_count += 1
else:
low_open_normal_sale_high_profit_count += 1
elif next_open_diff > 3:
if saleprice_open_differrange < -3:
high_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
high_open_high_sale_count += 1
else:
high_open_normal_sale_count += 1
if saleprice_open_differrange < -3:
if saleprice_open_differrange < -5:
high_open_low_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
high_open_low_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
high_open_low_sale_low_profit_count += 1
else:
high_open_low_sale_high_profit_count += 1
elif saleprice_open_differrange > 3:
if saleprice_open_differrange < -5:
high_open_high_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
high_open_high_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
high_open_high_sale_low_profit_count += 1
else:
high_open_high_sale_high_profit_count += 1
else:
if saleprice_open_differrange < -5:
high_open_normal_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
high_open_normal_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
high_open_normal_sale_low_profit_count += 1
else:
high_open_normal_sale_high_profit_count += 1
else:
if saleprice_open_differrange < -3:
normal_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
normal_open_high_sale_count += 1
else:
normal_open_normal_sale_count += 1
if saleprice_open_differrange < -3:
if saleprice_open_differrange < -5:
normal_open_low_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
normal_open_low_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
normal_open_low_sale_low_profit_count += 1
else:
normal_open_low_sale_high_profit_count += 1
elif saleprice_open_differrange > 3:
if saleprice_open_differrange < -5:
normal_open_high_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
normal_open_high_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
normal_open_high_sale_low_profit_count += 1
else:
normal_open_high_sale_high_profit_count += 1
else:
if saleprice_open_differrange < -5:
normal_open_normal_sale_high_loss_count += 1
elif saleprice_open_differrange > -5 and saleprice_open_differrange < 0:
normal_open_normal_sale_low_loss_count += 1
elif saleprice_open_differrange > 0 and saleprice_open_differrange < 5:
normal_open_normal_sale_low_profit_count += 1
else:
normal_open_normal_sale_high_profit_count += 1
# 组合场景 低收盘-低清仓 低收盘-高清仓 低收盘-正常清仓 正常收盘-低清仓 正常收盘-高清仓 正常收盘-正常清仓 高收盘-低清仓 高收盘-高清仓 高收盘-正常清仓
if next_close_differrange < -3 :
if saleprice_close_differrange < -3:
low_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
low_close_high_sale_count += 1
else:
low_close_normal_sale_count += 1
if saleprice_close_differrange < -3:
if saleprice_close_differrange < -5:
low_close_low_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
low_close_low_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
low_close_low_sale_low_profit_count += 1
else:
low_close_low_sale_high_profit_count += 1
elif saleprice_close_differrange > 3:
if saleprice_close_differrange < -5:
low_close_high_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
low_close_high_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
low_close_high_sale_low_profit_count += 1
else:
low_close_high_sale_high_profit_count += 1
else:
if saleprice_close_differrange < -5:
low_close_normal_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
low_close_normal_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
low_close_normal_sale_low_profit_count += 1
else:
low_close_normal_sale_high_profit_count += 1
elif next_close_differrange > 3:
if saleprice_close_differrange < -3:
high_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
high_close_high_sale_count += 1
else:
high_close_normal_sale_count += 1
if saleprice_close_differrange < -3:
if saleprice_close_differrange < -5:
high_close_low_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
high_close_low_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
high_close_low_sale_low_profit_count += 1
else:
high_close_low_sale_high_profit_count += 1
elif saleprice_close_differrange > 3:
if saleprice_close_differrange < -5:
high_close_high_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
high_close_high_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
high_close_high_sale_low_profit_count += 1
else:
high_close_high_sale_high_profit_count += 1
else:
if saleprice_close_differrange < -5:
high_close_normal_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
high_close_normal_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
high_close_normal_sale_low_profit_count += 1
else:
high_close_normal_sale_high_profit_count += 1
else:
if saleprice_close_differrange < -3:
normal_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
normal_close_high_sale_count += 1
else:
normal_close_normal_sale_count += 1
if saleprice_close_differrange < -3:
if saleprice_close_differrange < -5:
normal_close_low_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
normal_close_low_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
normal_close_low_sale_low_profit_count += 1
else:
normal_close_low_sale_high_profit_count += 1
elif saleprice_close_differrange > 3:
if saleprice_close_differrange < -5:
normal_close_high_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
normal_close_high_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
normal_close_high_sale_low_profit_count += 1
else:
normal_close_high_sale_high_profit_count += 1
else:
if saleprice_close_differrange < -5:
normal_close_normal_sale_high_loss_count += 1
elif saleprice_close_differrange > -5 and saleprice_close_differrange < 0:
normal_close_normal_sale_low_loss_count += 1
elif saleprice_close_differrange > 0 and saleprice_close_differrange < 5:
normal_close_normal_sale_low_profit_count += 1
else:
normal_close_normal_sale_high_profit_count += 1
else:
nextdate_str = date_list[i+1].strftime('%Y-%m-%d')#买入日
saledate_str = date_list[i+2].strftime('%Y-%m-%d')#卖出日
print(f'正在处理{date_str}的数据')
# 执行SQL查询（这只是一个示例，你需要根据你的实际需求和数据库结构进行修改）
query = f'select code,open,close,high,low, volumn,amount,differrange10,differrange20,differrange60 from stocks where islimit = "是" and trade_day = "{date_str}"'
df = pd.read_sql_query(query, engine)
limit_list = df['code'].tolist()
for code in limit_list:
# 总统计数
total_count += 1
print(f'正在处理{date_str} - {code}的数据')
query = f'select code,open,close,differrange from stocks where trade_day = "{nextdate_str}" and code = "{code}"'
dfnext = pd.read_sql_query(query,engine)
if dfnext.size <= 0:
total_count -= 1
continue
# 处理数据...
open = df.loc[df['code'] == code, 'open'].values[0]
nextopen = dfnext.loc[dfnext['code'] == code, 'open'].values[0]
nextclose = dfnext.loc[dfnext['code'] == code, 'close'].values[0]
nextdifferrange = dfnext.loc[dfnext['code'] == code, 'differrange'].values[0]
df.loc[df['code'] == code, 'next_open'] = nextopen
df.loc[df['code'] == code, 'next_open_diff'] = 100 * (nextopen - open)/open
df.loc[df['code'] == code, 'next_close'] = nextclose
df.loc[df['code'] == code, 'next_close_differrange'] = nextdifferrange
query = f'select code,open,close,differrange from stocks where trade_day = "{saledate_str}" and code = "{code}"'
dfsale = pd.read_sql_query(query,engine)
if dfsale.size <= 0:
total_count -= 1
continue
saleopen = dfsale.loc[dfsale['code'] == code, 'open'].values[0]
saleclose = dfsale.loc[dfsale['code'] == code, 'close'].values[0]
df.loc[df['code'] == code, 'saleprice_open'] = saleopen
df.loc[df['code'] == code, 'saleprice_close'] = saleclose
# 清仓盈亏
df.loc[df['code'] == code, 'saleprice_open_differrange'] = 100 * (saleopen - nextopen)/nextopen
df.loc[df['code'] == code, 'saleprice_close_differrange'] = 100 * (saleclose - nextclose)/nextclose
# 第二日开盘价分布
next_open_diff = df.loc[df['code'] == code, 'next_open_diff'].values[0]
if next_open_diff < -3:
low_open_count += 1
elif next_open_diff > 3:
high_open_count += 1
else:
normal_open_count += 1
# 第二日收盘价分布
next_close_differrange = df.loc[df['code'] == code, 'next_close_differrange'].values[0]
if next_close_differrange < -3:
low_close_count += 1
elif next_close_differrange > 3:
high_close_count += 1
else:
normal_close_count += 1
# 清仓盈亏分布-开盘清仓
saleprice_open_differrange = df.loc[df['code'] == code, 'saleprice_open_differrange'].values[0]
if saleprice_open_differrange < -3: # 亏损大于-3
low_sale_open_count += 1
elif saleprice_open_differrange > 0: # 盈利大于0
high_sale_open_count += 1
else:
normal_sale_open_count += 1 # 亏损小于-3
# 清仓盈亏分布-收盘清仓
saleprice_close_differrange = df.loc[df['code'] == code, 'saleprice_close_differrange'].values[0]
if saleprice_close_differrange < -3:
low_sale_close_count += 1
elif saleprice_close_differrange > 3:
high_sale_close_count += 1
else:
normal_sale_close_count += 1
# 组合场景 低开盘-低清仓 低开盘-高清仓 低开盘-正常清仓 正常开盘-低清仓 正常开盘-高清仓 正常开盘-正常清仓 高开盘-低清仓 高开盘-高清仓 高开盘-正常清仓
if next_open_diff < -3 :
if saleprice_open_differrange < -3:
low_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
low_open_high_sale_count += 1
else:
low_open_normal_sale_count += 1
elif next_open_diff > 3:
if saleprice_open_differrange < -3:
high_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
high_open_high_sale_count += 1
else:
high_open_normal_sale_count += 1
else:
if saleprice_open_differrange < -3:
normal_open_low_sale_count += 1
elif saleprice_open_differrange > 3:
normal_open_high_sale_count += 1
else:
normal_open_normal_sale_count += 1
# 组合场景 低收盘-低清仓 低收盘-高清仓 低收盘-正常清仓 正常收盘-低清仓 正常收盘-高清仓 正常收盘-正常清仓 高收盘-低清仓 高收盘-高清仓 高收盘-正常清仓
if next_close_differrange < -3 :
if saleprice_close_differrange < -3:
low_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
low_close_high_sale_count += 1
else:
low_close_normal_sale_count += 1
elif next_close_differrange > 3:
if saleprice_close_differrange < -3:
high_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
high_close_high_sale_count += 1
else:
high_close_normal_sale_count += 1
else:
if saleprice_close_differrange < -3:
normal_close_low_sale_count += 1
elif saleprice_close_differrange > 3:
normal_close_high_sale_count += 1
else:
normal_close_normal_sale_count += 1
# 将数据框保存到磁盘
df.to_csv(f'D:/calculate_data/{date_str}_stock.csv', index=False)
# # 从磁盘加载数据框
# df = pd.read_csv('df_distribution.csv')
print(f'总统计数：{total_count}')
print(f'低于-3%的开盘价计数：{low_open_count}')
print(f'正常开盘，介于-3%和3%之间的计数：{normal_open_count}')
print(f'高于3%的开盘价计数：{high_open_count}')
print(f'低于-3%的收盘价计数：{low_close_count}')
print(f'正常收盘，介于-3%和3%之间的计数：{normal_close_count}')
print(f'高于3%的收盘价计数：{high_close_count}')
print(f'低开盘-低清仓：{low_open_low_sale_count}')
print(f'低开盘-高清仓：{low_open_high_sale_count}')
print(f'低开盘-正常清仓：{low_open_normal_sale_count}')
print(f'正常开盘-低清仓：{normal_open_low_sale_count}')
print(f'正常开盘-高清仓：{normal_open_high_sale_count}')
print(f'正常开盘-正常清仓：{normal_open_normal_sale_count}')
print(f'高开盘-低清仓：{high_open_low_sale_count}')
print(f'高开盘-高清仓：{high_open_high_sale_count}')
print(f'高开盘-正常清仓：{high_open_normal_sale_count}')
print(f'低收盘-低清仓：{low_close_low_sale_count}')
print(f'低收盘-高清仓：{low_close_high_sale_count}')
print(f'低收盘-正常清仓：{low_close_normal_sale_count}')
print(f'正常收盘-低清仓：{normal_close_low_sale_count}')
print(f'正常收盘-高清仓：{normal_close_high_sale_count}')
print(f'正常收盘-正常清仓：{normal_close_normal_sale_count}')
print(f'高收盘-低清仓：{high_close_low_sale_count}')
print(f'高收盘-高清仓：{high_close_high_sale_count}')
print(f'高收盘-正常清仓：{high_close_normal_sale_count}')
print(f'低开盘-低清仓-盈利高于5%：{low_open_low_sale_high_profit_count}')
print(f'低开盘-低清仓-盈利低于5%：{low_open_low_sale_low_profit_count}')
print(f'低开盘-低清仓-亏损低于5%：{low_open_low_sale_low_loss_count}')
print(f'低开盘-低清仓-亏损高于5%：{low_open_low_sale_high_loss_count}')
print(f'低开盘-高清仓-盈利高于5%：{low_open_high_sale_high_profit_count}')
print(f'低开盘-高清仓-盈利低于5%：{low_open_high_sale_low_profit_count}')
print(f'低开盘-高清仓-亏损低于5%：{low_open_high_sale_low_loss_count}')
print(f'低开盘-高清仓-亏损高于5%：{low_open_high_sale_high_loss_count}')
print(f'低开盘-正常清仓-盈利高于5%：{low_open_normal_sale_high_profit_count}')
print(f'低开盘-正常清仓-盈利低于5%：{low_open_normal_sale_low_profit_count}')
print(f'低开盘-正常清仓-亏损低于5%：{low_open_normal_sale_low_loss_count}')
print(f'低开盘-正常清仓-亏损高于5%：{low_open_normal_sale_high_loss_count}')
print(f'正常开盘-低清仓-盈利高于5%：{normal_open_low_sale_high_profit_count}')
print(f'正常开盘-低清仓-盈利低于5%：{normal_open_low_sale_low_profit_count}')
print(f'正常开盘-低清仓-亏损低于5%：{normal_open_low_sale_low_loss_count}')
print(f'正常开盘-低清仓-亏损高于5%：{normal_open_low_sale_high_loss_count}')
print(f'正常开盘-高清仓-盈利高于5%：{normal_open_high_sale_high_profit_count}')
print(f'正常开盘-高清仓-盈利低于5%：{normal_open_high_sale_low_profit_count}')
print(f'正常开盘-高清仓-亏损低于5%：{normal_open_high_sale_low_loss_count}')
print(f'正常开盘-高清仓-亏损高于5%：{normal_open_high_sale_high_loss_count}')
print(f'正常开盘-正常清仓-盈利高于5%：{normal_open_normal_sale_high_profit_count}')
print(f'正常开盘-正常清仓-盈利低于5%：{normal_open_normal_sale_low_profit_count}')
print(f'正常开盘-正常清仓-亏损低于5%：{normal_open_normal_sale_low_loss_count}')
print(f'正常开盘-正常清仓-亏损高于5%：{normal_open_normal_sale_high_loss_count}')
print(f'高开盘-低清仓-盈利高于5%：{high_open_low_sale_high_profit_count}')
print(f'高开盘-低清仓-盈利低于5%：{high_open_low_sale_low_profit_count}')
print(f'高开盘-低清仓-亏损低于5%：{high_open_low_sale_low_loss_count}')
print(f'高开盘-低清仓-亏损高于5%：{high_open_low_sale_high_loss_count}')
print(f'高开盘-高清仓-盈利高于5%：{high_open_high_sale_high_profit_count}')
print(f'高开盘-高清仓-盈利低于5%：{high_open_high_sale_low_profit_count}')
print(f'高开盘-高清仓-亏损低于5%：{high_open_high_sale_low_loss_count}')
print(f'高开盘-高清仓-亏损高于5%：{high_open_high_sale_high_loss_count}')
print(f'高开盘-正常清仓-盈利高于5%：{high_open_normal_sale_high_profit_count}')
print(f'高开盘-正常清仓-盈利低于5%：{high_open_normal_sale_low_profit_count}')
print(f'高开盘-正常清仓-亏损低于5%：{high_open_normal_sale_low_loss_count}')
print(f'高开盘-正常清仓-亏损高于5%：{high_open_normal_sale_high_loss_count}')
print(f'低收盘-低清仓-盈利高于5%：{low_close_low_sale_high_profit_count}')
print(f'低收盘-低清仓-盈利低于5%：{low_close_low_sale_low_profit_count}')
print(f'低收盘-低清仓-亏损低于5%：{low_close_low_sale_low_loss_count}')
print(f'低收盘-低清仓-亏损高于5%：{low_close_low_sale_high_loss_count}')
print(f'低收盘-高清仓-盈利高于5%：{low_close_high_sale_high_profit_count}')
print(f'低收盘-高清仓-盈利低于5%：{low_close_high_sale_low_profit_count}')
print(f'低收盘-高清仓-亏损低于5%：{low_close_high_sale_low_loss_count}')
print(f'低收盘-高清仓-亏损高于5%：{low_close_high_sale_high_loss_count}')
print(f'低收盘-正常清仓-盈利高于5%：{low_close_normal_sale_high_profit_count}')
print(f'低收盘-正常清仓-盈利低于5%：{low_close_normal_sale_low_profit_count}')
print(f'低收盘-正常清仓-亏损低于5%：{low_close_normal_sale_low_loss_count}')
print(f'低收盘-正常清仓-亏损高于5%：{low_close_normal_sale_high_loss_count}')
print(f'正常收盘-低清仓-盈利高于5%：{normal_close_low_sale_high_profit_count}')
print(f'正常收盘-低清仓-盈利低于5%：{normal_close_low_sale_low_profit_count}')
print(f'正常收盘-低清仓-亏损低于5%：{normal_close_low_sale_low_loss_count}')
print(f'正常收盘-低清仓-亏损高于5%：{normal_close_low_sale_high_loss_count}')
print(f'正常收盘-高清仓-盈利高于5%：{normal_close_high_sale_high_profit_count}')
print(f'正常收盘-高清仓-盈利低于5%：{normal_close_high_sale_low_profit_count}')
print(f'正常收盘-高清仓-亏损低于5%：{normal_close_high_sale_low_loss_count}')
print(f'正常收盘-高清仓-亏损高于5%：{normal_close_high_sale_high_loss_count}')
print(f'正常收盘-正常清仓-盈利高于5%：{normal_close_normal_sale_high_profit_count}')
print(f'正常收盘-正常清仓-盈利低于5%：{normal_close_normal_sale_low_profit_count}')
print(f'正常收盘-正常清仓-亏损低于5%：{normal_close_normal_sale_low_loss_count}')
print(f'正常收盘-正常清仓-亏损高于5%：{normal_close_normal_sale_high_loss_count}')
print(f'高收盘-低清仓-盈利高于5%：{high_close_low_sale_high_profit_count}')
print(f'高收盘-低清仓-盈利低于5%：{high_close_low_sale_low_profit_count}')
print(f'高收盘-低清仓-亏损低于5%：{high_close_low_sale_low_loss_count}')
print(f'高收盘-低清仓-亏损高于5%：{high_close_low_sale_high_loss_count}')
print(f'高收盘-高清仓-盈利高于5%：{high_close_high_sale_high_profit_count}')
print(f'高收盘-高清仓-盈利低于5%：{high_close_high_sale_low_profit_count}')
print(f'高收盘-高清仓-亏损低于5%：{high_close_high_sale_low_loss_count}')
print(f'高收盘-高清仓-亏损高于5%：{high_close_high_sale_high_loss_count}')
print(f'高收盘-正常清仓-盈利高于5%：{high_close_normal_sale_high_profit_count}')
print(f'高收盘-正常清仓-盈利低于5%：{high_close_normal_sale_low_profit_count}')
print(f'高收盘-正常清仓-亏损低于5%：{high_close_normal_sale_low_loss_count}')
print(f'高收盘-正常清仓-亏损高于5%：{high_close_normal_sale_high_loss_count}')
df_distribution = pd.DataFrame({'test':[1]})
df_distribution['total_count'] = total_count
df_distribution['low_open_count'] = low_open_count
df_distribution['normal_open_count'] = normal_open_count
df_distribution['high_open_count'] = high_open_count
df_distribution['low_close_count'] = low_close_count
df_distribution['normal_close_count'] = normal_close_count
df_distribution['high_close_count'] = high_close_count
df_distribution['low_open_low_sale_count'] = low_open_low_sale_count
df_distribution['low_open_high_sale_count'] = low_open_high_sale_count
df_distribution['low_open_normal_sale_count'] = low_open_normal_sale_count
df_distribution['normal_open_low_sale_count'] = normal_open_low_sale_count
df_distribution['normal_open_high_sale_count'] = normal_open_high_sale_count
df_distribution['normal_open_normal_sale_count'] = normal_open_normal_sale_count
df_distribution['high_open_low_sale_count'] = high_open_low_sale_count
df_distribution['high_open_high_sale_count'] = high_open_high_sale_count
df_distribution['high_open_normal_sale_count'] = high_open_normal_sale_count
df_distribution['low_close_low_sale_count'] = low_close_low_sale_count
df_distribution['low_close_high_sale_count'] = low_close_high_sale_count
df_distribution['low_close_normal_sale_count'] = low_close_normal_sale_count
df_distribution['normal_close_low_sale_count'] = normal_close_low_sale_count
df_distribution['normal_close_high_sale_count'] = normal_close_high_sale_count
df_distribution['normal_close_normal_sale_count'] = normal_close_normal_sale_count
df_distribution['high_close_low_sale_count'] = high_close_low_sale_count
df_distribution['high_close_high_sale_count'] = high_close_high_sale_count
df_distribution['high_close_normal_sale_count'] = high_close_normal_sale_count
df_distribution['low_open_low_sale_high_profit_count'] = low_open_low_sale_high_profit_count
df_distribution['low_open_low_sale_low_profit_count'] = low_open_low_sale_low_profit_count
df_distribution['low_open_low_sale_low_loss_count'] = low_open_low_sale_low_loss_count
df_distribution['low_open_low_sale_high_loss_count'] = low_open_low_sale_high_loss_count
df_distribution['low_open_high_sale_high_profit_count'] = low_open_high_sale_high_profit_count
df_distribution['low_open_high_sale_low_profit_count'] = low_open_high_sale_low_profit_count
df_distribution['low_open_high_sale_low_loss_count'] = low_open_high_sale_low_loss_count
df_distribution['low_open_high_sale_high_loss_count'] = low_open_high_sale_high_loss_count
df_distribution['low_open_normal_sale_high_profit_count'] = low_open_normal_sale_high_profit_count
df_distribution['low_open_normal_sale_low_profit_count'] = low_open_normal_sale_low_profit_count
df_distribution['low_open_normal_sale_low_loss_count'] = low_open_normal_sale_low_loss_count
df_distribution['low_open_normal_sale_high_loss_count'] = low_open_normal_sale_high_loss_count
df_distribution['normal_open_low_sale_high_profit_count'] = normal_open_low_sale_high_profit_count
df_distribution['normal_open_low_sale_low_profit_count'] = normal_open_low_sale_low_profit_count
df_distribution['normal_open_low_sale_low_loss_count'] = normal_open_low_sale_low_loss_count
df_distribution['normal_open_low_sale_high_loss_count'] = normal_open_low_sale_high_loss_count
df_distribution['normal_open_high_sale_high_profit_count'] = normal_open_high_sale_high_profit_count
df_distribution['normal_open_high_sale_low_profit_count'] = normal_open_high_sale_low_profit_count
df_distribution['normal_open_high_sale_low_loss_count'] = normal_open_high_sale_low_loss_count
df_distribution['normal_open_high_sale_high_loss_count'] = normal_open_high_sale_high_loss_count
df_distribution['normal_open_normal_sale_high_profit_count'] = normal_open_normal_sale_high_profit_count
df_distribution['normal_open_normal_sale_low_profit_count'] = normal_open_normal_sale_low_profit_count
df_distribution['normal_open_normal_sale_low_loss_count'] = normal_open_normal_sale_low_loss_count
df_distribution['normal_open_normal_sale_high_loss_count'] = normal_open_normal_sale_high_loss_count
df_distribution['high_open_low_sale_high_profit_count'] = high_open_low_sale_high_profit_count
df_distribution['high_open_low_sale_low_profit_count'] = high_open_low_sale_low_profit_count
df_distribution['high_open_low_sale_low_loss_count'] = high_open_low_sale_low_loss_count
df_distribution['high_open_low_sale_high_loss_count'] = high_open_low_sale_high_loss_count
df_distribution['high_open_high_sale_high_profit_count'] = high_open_high_sale_high_profit_count
df_distribution['high_open_high_sale_low_profit_count'] = high_open_high_sale_low_profit_count
df_distribution['high_open_high_sale_low_loss_count'] = high_open_high_sale_low_loss_count
df_distribution['high_open_high_sale_high_loss_count'] = high_open_high_sale_high_loss_count
df_distribution['high_open_normal_sale_high_profit_count'] = high_open_normal_sale_high_profit_count
df_distribution['high_open_normal_sale_low_profit_count'] = high_open_normal_sale_low_profit_count
df_distribution['high_open_normal_sale_low_loss_count'] = high_open_normal_sale_low_loss_count
df_distribution['high_open_normal_sale_high_loss_count'] = high_open_normal_sale_high_loss_count
df_distribution['low_close_low_sale_high_profit_count'] = low_close_low_sale_high_profit_count
df_distribution['low_close_low_sale_low_profit_count'] = low_close_low_sale_low_profit_count
df_distribution['low_close_low_sale_low_loss_count'] = low_close_low_sale_low_loss_count
df_distribution['low_close_low_sale_high_loss_count'] = low_close_low_sale_high_loss_count
df_distribution['low_close_high_sale_high_profit_count'] = low_close_high_sale_high_profit_count
df_distribution['low_close_high_sale_low_profit_count'] = low_close_high_sale_low_profit_count
df_distribution['low_close_high_sale_low_loss_count'] = low_close_high_sale_low_loss_count
df_distribution['low_close_high_sale_high_loss_count'] = low_close_high_sale_high_loss_count
df_distribution['low_close_normal_sale_high_profit_count'] = low_close_normal_sale_high_profit_count
df_distribution['low_close_normal_sale_low_profit_count'] = low_close_normal_sale_low_profit_count
df_distribution['low_close_normal_sale_low_loss_count'] = low_close_normal_sale_low_loss_count
df_distribution['low_close_normal_sale_high_loss_count'] = low_close_normal_sale_high_loss_count
df_distribution['normal_close_low_sale_high_profit_count'] = normal_close_low_sale_high_profit_count
df_distribution['normal_close_low_sale_low_profit_count'] = normal_close_low_sale_low_profit_count
df_distribution['normal_close_low_sale_low_loss_count'] = normal_close_low_sale_low_loss_count
df_distribution['normal_close_low_sale_high_loss_count'] = normal_close_low_sale_high_loss_count
df_distribution['normal_close_high_sale_high_profit_count'] = normal_close_high_sale_high_profit_count
df_distribution['normal_close_high_sale_low_profit_count'] = normal_close_high_sale_low_profit_count
df_distribution['normal_close_high_sale_low_loss_count'] = normal_close_high_sale_low_loss_count
df_distribution['normal_close_high_sale_high_loss_count'] = normal_close_high_sale_high_loss_count
df_distribution['normal_close_normal_sale_high_profit_count'] = normal_close_normal_sale_high_profit_count
df_distribution['normal_close_normal_sale_low_profit_count'] = normal_close_normal_sale_low_profit_count
df_distribution['normal_close_normal_sale_low_loss_count'] = normal_close_normal_sale_low_loss_count
df_distribution['normal_close_normal_sale_high_loss_count'] = normal_close_normal_sale_high_loss_count
df_distribution['high_close_low_sale_high_profit_count'] = high_close_low_sale_high_profit_count
df_distribution['high_close_low_sale_low_profit_count'] = high_close_low_sale_low_profit_count
df_distribution['high_close_low_sale_low_loss_count'] = high_close_low_sale_low_loss_count
df_distribution['high_close_low_sale_high_loss_count'] = high_close_low_sale_high_loss_count
df_distribution['high_close_high_sale_high_profit_count'] = high_close_high_sale_high_profit_count
df_distribution['high_close_high_sale_low_profit_count'] = high_close_high_sale_low_profit_count
df_distribution['high_close_high_sale_low_loss_count'] = high_close_high_sale_low_loss_count
df_distribution['high_close_high_sale_high_loss_count'] = high_close_high_sale_high_loss_count
df_distribution['high_close_normal_sale_high_profit_count'] = high_close_normal_sale_high_profit_count
df_distribution['high_close_normal_sale_low_profit_count'] = high_close_normal_sale_low_profit_count
df_distribution['high_close_normal_sale_low_loss_count'] = high_close_normal_sale_low_loss_count
df_distribution['high_close_normal_sale_high_loss_count'] = high_close_normal_sale_high_loss_count
# 删除'test'列
df_distribution = df_distribution.drop(columns=['test'])
# 创建一个新的图形
fig, ax = plt.subplots()
# 创建一个条形图
df_distribution.plot(kind='bar', ax=ax)
# 设置图形的标题和轴标签
ax.set_title('Distribution')
ax.set_xlabel('Category')
ax.set_ylabel('Count')
# 显示图形
plt.show()

206
calculteLimit.py
Unescape View File

@ -0,0 +1,206 @@
import pandas as pd
import pymysql
from sqlalchemy import create_engine
import matplotlib.pyplot as plt
# # 创建数据库连接
# engine = create_engine('mysql+pymysql://root:1qazse42W3@192.168.0.222:3306/ry')
# # 执行SQL查询并将结果存储在pandas DataFrame中
# df = pd.read_sql_query('select code,trade_day as date ,open as open_price,close as close_price from stocks where trade_day between "2023-06-01" and "2023-06-30" ORDER BY trade_day', engine)
# # 将date字段转换为日期类型，并设置为索引
# df['date'] = pd.to_datetime(df['date'])
# df.set_index('date', inplace=True)
# # 对每个股票计算涨跌幅
# df['change'] = df.groupby('code')['open_price'].shift(-1) - df['close_price']
# # 计算涨跌幅分布
# distribution = df['change'].value_counts(bins=10, normalize=True)
# # 显示涨跌幅分布的图表
# distribution.plot(kind='bar')
# plt.title('Distribution of Price Changes')
# plt.xlabel('Price Change')
# plt.ylabel('Frequency')
# plt.show()
# 创建数据库连接
engine = create_engine('mysql+pymysql://root:1qazse42W3@192.168.0.222:3306/ry')
# 执行SQL查询来获取日期列表
# 假设你的数据表中有一个date字段表示日期
date_df = pd.read_sql_query('select date from trade_dates where trade = "trading" and date between "2023-06-01" and "2023-06-30" order by date', engine)
# 将date字段转换为日期类型
date_df['date'] = pd.to_datetime(date_df['date'])
# 获取日期列表
date_list = date_df['date'].tolist()
total_count = 0
# 低于-3%的开盘价计数
low_open_count = 0
# 正常开盘，介于-3%和3%之间的计数
normal_open_count = 0
# 高于3%的开盘价计数
high_open_count = 0
# 低于-3%的收盘价计数
low_close_count = 0
# 正常收盘，介于-3%和3%之间的计数
normal_close_count = 0
# 高于3%的收盘价计数
high_close_count = 0
# 收盘低于-3% 且开盘低于-3%的计数
low_open_low_close_count = 0
# 收盘价低于-3% 且开盘价介于-3%和3%之间的计数
low_open_normal_close_count = 0
# 收盘低于-3% 且开盘高于3%的计数
low_open_high_close_count = 0
# 收盘价介于-3%和3%之间 且开盘低于-3%的计数
normal_open_low_close_count = 0
# 收盘价介于-3%和3%之间 且开盘介于-3%和3%之间的计数
normal_open_normal_close_count = 0
# 收盘价介于-3%和3%之间 且开盘高于3%的计数
normal_open_high_close_count = 0
# 收盘高于3% 且开盘低于-3%的计数
high_open_low_close_count = 0
# 收盘高于3% 且开盘介于-3%和3%之间的计数
high_open_normal_close_count = 0
# 收盘高于3% 且开盘高于3%的计数
high_open_high_close_count = 0
# 遍历日期列表
for i, date in enumerate(date_list):
if i+1 < len(date_list):
# 将日期转换为字符串格式，以便在SQL查询中使用
date_str = date.strftime('%Y-%m-%d')
nextdate_str = date_list[i+1].strftime('%Y-%m-%d')
print(f'正在处理{date_str}的数据')
# 执行SQL查询（这只是一个示例，你需要根据你的实际需求和数据库结构进行修改）
query = f'select code,open,close,differrange from stocks where islimit = "是" and trade_day = "{date_str}"'
df = pd.read_sql_query(query, engine)
limit_list = df['code'].tolist()
for code in limit_list:
# 总统计数
total_count += 1
print(f'正在处理{date_str} - {code}的数据')
query = f'select code,open,close,differrange from stocks where trade_day = "{nextdate_str}" and code = "{code}"'
dfnext = pd.read_sql_query(query,engine)
# 处理数据...
df['next_open'] = dfnext['open']
df['next_open_diff'] = 100 * (dfnext['open'] - df['open'])/df['open']
print(df['next_open_diff'][0])
df['next_close'] = dfnext['close']
df['next_close_differrange'] = dfnext['differrange']
print(df['next_close_differrange'][0])
if df['next_open_diff'][0] < -3:
low_open_count += 1
elif df['next_open_diff'][0] > 3:
high_open_count += 1
else:
normal_open_count += 1
if df['next_close_differrange'][0] < -3:
low_close_count += 1
elif df['next_close_differrange'][0] > 3:
high_close_count += 1
else:
normal_close_count += 1
if df['next_open_diff'][0] < -3 and df['next_close_differrange'][0] < -3:
low_open_low_close_count += 1
elif df['next_open_diff'][0] < -3 and df['next_close_differrange'][0] > -3 and df['next_close_differrange'][0] < 3:
low_open_normal_close_count += 1
elif df['next_open_diff'][0] < -3 and df['next_close_differrange'][0] > 3:
low_open_high_close_count += 1
elif df['next_open_diff'][0] > -3 and df['next_open_diff'][0] < 3 and df['next_close_differrange'][0] < -3:
normal_open_low_close_count += 1
elif df['next_open_diff'][0] > -3 and df['next_open_diff'][0] < 3 and df['next_close_differrange'][0] > -3 and df['next_close_differrange'][0] < 3:
normal_open_normal_close_count += 1
elif df['next_open_diff'][0] > -3 and df['next_open_diff'][0] < 3 and df['next_close_differrange'][0] > 3:
normal_open_high_close_count += 1
elif df['next_open_diff'][0] > 3 and df['next_close_differrange'][0] < -3:
high_open_low_close_count += 1
elif df['next_open_diff'][0] > 3 and df['next_close_differrange'][0] > -3 and df['next_close_differrange'][0] < 3:
high_open_normal_close_count += 1
elif df['next_open_diff'][0] > 3 and df['next_close_differrange'][0] > 3:
high_open_high_close_count += 1
# 将数据框保存到磁盘
df.to_csv(f'./data/{date_str}_stock.csv', index=False)
# # 从磁盘加载数据框
# df = pd.read_csv('df_distribution.csv')
print(f'总统计数：{total_count}')
print(f'低于-3%的开盘价计数：{low_open_count}')
print(f'正常开盘，介于-3%和3%之间的计数：{normal_open_count}')
print(f'高于3%的开盘价计数：{high_open_count}')
print(f'低于-3%的收盘价计数：{low_close_count}')
print(f'正常收盘，介于-3%和3%之间的计数：{normal_close_count}')
print(f'高于3%的收盘价计数：{high_close_count}')
print(f'收盘低于-3% 且开盘低于-3%的计数：{low_open_low_close_count}')
print(f'收盘价低于-3% 且开盘价介于-3%和3%之间的计数：{low_open_normal_close_count}')
print(f'收盘低于-3% 且开盘高于3%的计数：{low_open_high_close_count}')
print(f'收盘价介于-3%和3%之间 且开盘低于-3%的计数：{normal_open_low_close_count}')
print(f'收盘价介于-3%和3%之间 且开盘介于-3%和3%之间的计数：{normal_open_normal_close_count}')
print(f'收盘价介于-3%和3%之间 且开盘高于3%的计数：{normal_open_high_close_count}')
print(f'收盘高于3% 且开盘低于-3%的计数：{high_open_low_close_count}')
print(f'收盘高于3% 且开盘介于-3%和3%之间的计数：{high_open_normal_close_count}')
print(f'收盘高于3% 且开盘高于3%的计数：{high_open_high_close_count}')
df_distribution = pd.DataFrame({'test':[1]})
df_distribution['total_count'] = total_count
df_distribution['low_open_count'] = low_open_count
df_distribution['normal_open_count'] = normal_open_count
df_distribution['high_open_count'] = high_open_count
df_distribution['low_close_count'] = low_close_count
df_distribution['normal_close_count'] = normal_close_count
df_distribution['high_close_count'] = high_close_count
df_distribution['low_open_low_close_count'] = low_open_low_close_count
df_distribution['low_open_normal_close_count'] = low_open_normal_close_count
df_distribution['low_open_high_close_count'] = low_open_high_close_count
df_distribution['normal_open_low_close_count'] = normal_open_low_close_count
df_distribution['normal_open_normal_close_count'] = normal_open_normal_close_count
df_distribution['normal_open_high_close_count'] = normal_open_high_close_count
df_distribution['high_open_low_close_count'] = high_open_low_close_count
df_distribution['high_open_normal_close_count'] = high_open_normal_close_count
df_distribution['high_open_high_close_count'] = high_open_high_close_count
# df_distribution["low_open_low_close_rate"] = low_open_low_close_count / total_count
# df_distribution["low_open_normal_close_rate"] = low_open_normal_close_count / total_count
# df_distribution["low_open_high_close_rate"] = low_open_high_close_count / total_count
# df_distribution["normal_open_low_close_rate"] = normal_open_low_close_count / total_count
# df_distribution["normal_open_normal_close_rate"] = normal_open_normal_close_count / total_count
# df_distribution["normal_open_high_close_rate"] = normal_open_high_close_count / total_count
# df_distribution["high_open_low_close_rate"] = high_open_low_close_count / total_count
# df_distribution["high_open_normal_close_rate"] = high_open_normal_close_count / total_count
# df_distribution["high_open_high_close_rate"] = high_open_high_close_count / total_count
# df_distribution["low_open_rate"] = low_open_count / total_count
# df_distribution["normal_open_rate"] = normal_open_count / total_count
# df_distribution["high_open_rate"] = high_open_count / total_count
# df_distribution["low_close_rate"] = low_close_count / total_count
# df_distribution["normal_close_rate"] = normal_close_count / total_count
# df_distribution["high_close_rate"] = high_close_count / total_count
# 删除'test'列
df_distribution = df_distribution.drop(columns=['test'])
# 创建一个新的图形
fig, ax = plt.subplots()
# 创建一个条形图
df_distribution.plot(kind='bar', ax=ax)
# 设置图形的标题和轴标签
ax.set_title('Distribution')
ax.set_xlabel('Category')
ax.set_ylabel('Count')
# 显示图形
plt.show()
Write Preview
Loading…
Cancel
Save