711 lines
30 KiB
Python
711 lines
30 KiB
Python
import csv
|
||
import datetime
|
||
import logging
|
||
from pathlib import Path
|
||
from log_style import setup_logger
|
||
import pandas as pd
|
||
import tushare as ts
|
||
import time
|
||
|
||
# -------------------------- 配置参数区域 --------------------------
|
||
class Config:
|
||
"""配置参数类，集中管理所有配置"""
|
||
# 日志配置
|
||
LOG_NAME = 'market_data_check'
|
||
LOG_FILE = 'market_data_check.log'
|
||
LOG_LEVEL = logging.INFO
|
||
LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s'
|
||
LOG_CONSOLE = True
|
||
LOG_DIR = '.'
|
||
LOG_BACKUP_COUNT = 3
|
||
|
||
# Tushare配置
|
||
TUSHARE_TOKENS = [
|
||
'9343e641869058684afeadfcfe7fd6684160852e52e85332a7734c8d' # 主账户
|
||
]
|
||
|
||
# API请求频率控制
|
||
MAX_REQUESTS_PER_MINUTE = 500
|
||
|
||
# 数据目录配置
|
||
DATA_DIR = Path(r'D:\gp_data\day')
|
||
|
||
# 交易日历配置
|
||
TRADE_CALENDAR_START_YEARS = 2 # 过去2年
|
||
TRADE_CALENDAR_END_MONTHS = 1 # 未来1个月
|
||
|
||
# 输出文件配置
|
||
OUTPUT_FILE = Path('market_data_check_result.csv')
|
||
|
||
# 默认参数配置
|
||
DEFAULT_ONLINE_CHECK = False
|
||
|
||
# 配置日志
|
||
logger = setup_logger(
|
||
name=Config.LOG_NAME,
|
||
log_file=Config.LOG_FILE,
|
||
level=Config.LOG_LEVEL,
|
||
log_format=Config.LOG_FORMAT,
|
||
console=Config.LOG_CONSOLE,
|
||
log_dir=Config.LOG_DIR,
|
||
backup_count=Config.LOG_BACKUP_COUNT
|
||
)
|
||
logger.propagate = False # 避免日志消息向上传递到父记录器，防止重复输出
|
||
|
||
class TushareManager:
|
||
"""Tushare API管理类，处理账户轮询和请求频率控制"""
|
||
def __init__(self, tokens):
|
||
self.tokens = tokens
|
||
self.current_token_index = 0
|
||
self.last_request_time = time.time()
|
||
self.request_count = 0
|
||
|
||
def get_pro_api(self):
|
||
"""获取Tushare API实例，自动处理账户轮询"""
|
||
# 简单的账户轮询
|
||
token = self.tokens[self.current_token_index]
|
||
self.current_token_index = (self.current_token_index + 1) % len(self.tokens)
|
||
return ts.pro_api(token)
|
||
|
||
def control_request_rate(self):
|
||
"""控制请求频率，确保不超过API限制"""
|
||
current_time = time.time()
|
||
time_since_last_request = current_time - self.last_request_time
|
||
|
||
# 如果超过1分钟，重置计数器
|
||
if time_since_last_request > 60:
|
||
self.request_count = 0
|
||
self.last_request_time = current_time
|
||
|
||
# 如果请求次数超过限制，等待
|
||
if self.request_count >= Config.MAX_REQUESTS_PER_MINUTE:
|
||
wait_time = 60 - time_since_last_request + 1
|
||
logger.info(f"请求频率过高，等待 {wait_time:.1f} 秒")
|
||
time.sleep(wait_time)
|
||
self.request_count = 0
|
||
self.last_request_time = time.time()
|
||
|
||
# 简单的速率限制（每0.1秒一个请求）
|
||
if time_since_last_request < 0.1:
|
||
time.sleep(0.1 - time_since_last_request)
|
||
|
||
self.request_count += 1
|
||
self.last_request_time = current_time
|
||
|
||
# 创建Tushare管理器实例
|
||
tushare_manager = TushareManager(Config.TUSHARE_TOKENS)
|
||
|
||
# 全局变量，用于缓存交易日历
|
||
trade_calendar_cache = None
|
||
trade_calendar_dates = None # 交易日期集合，用于快速查询
|
||
|
||
def get_trade_calendar():
|
||
"""
|
||
一次性获取较大范围的交易日历并缓存到内存
|
||
:return: 交易日历DataFrame
|
||
"""
|
||
global trade_calendar_cache, trade_calendar_dates
|
||
|
||
# 如果已经缓存，直接返回
|
||
if trade_calendar_cache is not None:
|
||
return trade_calendar_cache
|
||
|
||
try:
|
||
# 计算日期范围：过去N年到未来M个月
|
||
today = datetime.datetime.now()
|
||
start_date = (today - datetime.timedelta(days=365 * Config.TRADE_CALENDAR_START_YEARS)).strftime('%Y%m%d')
|
||
end_date = (today + datetime.timedelta(days=30 * Config.TRADE_CALENDAR_END_MONTHS)).strftime('%Y%m%d')
|
||
|
||
pro = tushare_manager.get_pro_api()
|
||
tushare_manager.control_request_rate()
|
||
|
||
df = pro.trade_cal(exchange='SSE', start_date=start_date, end_date=end_date)
|
||
if df is None or df.empty:
|
||
logger.warning(f"未获取到{start_date}至{end_date}的交易日历")
|
||
return None
|
||
|
||
# 缓存结果
|
||
trade_calendar_cache = df
|
||
|
||
# 同时创建一个日期集合，方便快速查询
|
||
trade_calendar_dates = set(df[df['is_open'] == 1]['cal_date'].tolist())
|
||
|
||
logger.info(f"成功获取并缓存交易日历: {start_date}至{end_date}")
|
||
return df
|
||
except Exception as e:
|
||
logger.error(f"获取交易日历失败: {str(e)}")
|
||
return None
|
||
|
||
def is_trading_day(check_date):
|
||
"""
|
||
检查指定日期是否为交易日
|
||
:param check_date: 检查日期，格式YYYYMMDD
|
||
:return: True表示是交易日，False表示不是，None表示查询失败
|
||
"""
|
||
global trade_calendar_dates
|
||
|
||
# 如果还没有缓存交易日历，先获取
|
||
if trade_calendar_dates is None:
|
||
calendar_df = get_trade_calendar()
|
||
if calendar_df is None:
|
||
return None
|
||
|
||
# 使用集合快速查询
|
||
return check_date in trade_calendar_dates
|
||
|
||
|
||
def get_previous_trading_day(target_date):
|
||
"""
|
||
获取指定日期之前的最近一个交易日
|
||
:param target_date: 指定日期，格式YYYYMMDD
|
||
:return: 最近的前一个交易日，格式YYYYMMDD，如果查询失败返回None
|
||
"""
|
||
try:
|
||
# 确保交易日历已加载
|
||
calendar_df = get_trade_calendar()
|
||
if calendar_df is None:
|
||
logger.error("无法获取交易日历，无法计算前一个交易日")
|
||
return None
|
||
|
||
# 将目标日期转换为datetime对象
|
||
target_dt = datetime.datetime.strptime(target_date, '%Y%m%d')
|
||
|
||
# 筛选出目标日期之前的所有交易日
|
||
trading_days = calendar_df[(calendar_df['is_open'] == 1) & (calendar_df['cal_date'] < target_date)]
|
||
|
||
if trading_days.empty:
|
||
logger.warning(f"在目标日期 {target_date} 之前未找到交易日")
|
||
return None
|
||
|
||
# 按日期降序排序，取第一个（最近的）
|
||
previous_trading_day = trading_days.sort_values('cal_date', ascending=False).iloc[0]['cal_date']
|
||
|
||
logger.info(f"目标日期 {target_date} 的前一个交易日是 {previous_trading_day}")
|
||
return previous_trading_day
|
||
except Exception as e:
|
||
logger.error(f"获取前一个交易日失败: {str(e)}")
|
||
return None
|
||
|
||
|
||
def get_latest_trade_date(file_path):
|
||
|
||
"""
|
||
从txt文件中获取最新的交易日期
|
||
注意：现在数据文件按日期降序保存，最新的交易日期在文件第一行数据（跳过表头）
|
||
|
||
:param file_path: 文件路径
|
||
:return: 最新交易日期字符串，如'20251204'，如果文件为空返回None
|
||
"""
|
||
try:
|
||
with open(file_path, 'r', encoding='utf-8') as f:
|
||
# 优化：只读取前几行，不读取整个文件
|
||
header_line = f.readline().strip()
|
||
if not header_line:
|
||
logger.warning(f"文件 {file_path} 内容不足")
|
||
return None
|
||
|
||
# 解析表头，找到trade_date列的索引
|
||
headers = header_line.split('\t')
|
||
if 'trade_date' not in headers:
|
||
logger.warning(f"文件 {file_path} 缺少trade_date列")
|
||
return None
|
||
trade_date_idx = headers.index('trade_date')
|
||
|
||
# 跳过空行，从文件开头查找第一行有效数据（最新日期）
|
||
for line in f:
|
||
line = line.strip()
|
||
if line: # 找到非空行
|
||
columns = line.split('\t')
|
||
if len(columns) <= trade_date_idx: # 确保有足够的列
|
||
logger.warning(f"文件 {file_path} 数据格式不正确")
|
||
return None
|
||
return columns[trade_date_idx]
|
||
|
||
# 如果没有找到有效数据行
|
||
logger.warning(f"文件 {file_path} 无有效数据行")
|
||
return None
|
||
except Exception as e:
|
||
logger.error(f"读取文件 {file_path} 时出错: {str(e)}")
|
||
return None
|
||
|
||
def calculate_trading_days_diff(start_date, end_date):
|
||
"""
|
||
计算两个日期之间的交易日数量
|
||
:param start_date: 开始日期，格式YYYYMMDD
|
||
:param end_date: 结束日期，格式YYYYMMDD
|
||
:return: 交易日数量，如果计算失败返回None
|
||
"""
|
||
try:
|
||
# 确保日期格式正确并交换（如果需要）
|
||
if start_date > end_date:
|
||
start_date, end_date = end_date, start_date
|
||
|
||
# 获取缓存的交易日历
|
||
calendar_df = get_trade_calendar()
|
||
|
||
if calendar_df is None:
|
||
# 如果获取交易日历失败，使用简单的日期差作为近似值
|
||
start = datetime.datetime.strptime(start_date, '%Y%m%d')
|
||
end = datetime.datetime.strptime(end_date, '%Y%m%d')
|
||
days_diff = (end - start).days
|
||
logger.warning(f"无法获取交易日历，使用自然日差近似：{days_diff}天")
|
||
return days_diff
|
||
|
||
# 筛选出指定日期范围内的交易日
|
||
mask = (calendar_df['cal_date'] >= start_date) & (calendar_df['cal_date'] <= end_date) & (calendar_df['is_open'] == 1)
|
||
trading_days_count = calendar_df[mask]['cal_date'].count()
|
||
|
||
return trading_days_count
|
||
except Exception as e:
|
||
logger.error(f"计算交易日差失败: {str(e)}")
|
||
return None
|
||
|
||
def check_online_data_exists(ts_code, trade_date):
|
||
"""
|
||
检查在线数据是否存在
|
||
:param ts_code: 股票代码，如'688800.SH'
|
||
:param trade_date: 交易日期，格式YYYYMMDD
|
||
:return: True表示数据存在，False表示不存在，None表示查询失败
|
||
"""
|
||
try:
|
||
pro = tushare_manager.get_pro_api()
|
||
tushare_manager.control_request_rate()
|
||
|
||
# 查询指定日期的交易数据
|
||
df = pro.daily(ts_code=ts_code, trade_date=trade_date)
|
||
|
||
if df is None or df.empty:
|
||
logger.info(f"在线数据中未找到 {ts_code} {trade_date} 的交易数据")
|
||
return False
|
||
else:
|
||
logger.info(f"在线数据中找到 {ts_code} {trade_date} 的交易数据")
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"查询在线数据失败 {ts_code} {trade_date}: {str(e)}")
|
||
return None
|
||
|
||
def get_suspend_info(ts_code, start_date, end_date):
|
||
"""
|
||
获取股票停牌信息
|
||
:param ts_code: 股票代码，如'688800.SH'
|
||
:param start_date: 开始日期，格式YYYYMMDD
|
||
:param end_date: 结束日期，格式YYYYMMDD
|
||
:return: 停牌信息DataFrame，如果查询失败返回None
|
||
"""
|
||
try:
|
||
pro = tushare_manager.get_pro_api()
|
||
tushare_manager.control_request_rate()
|
||
|
||
# 查询指定日期范围内的停牌数据
|
||
df = pro.suspend_d(ts_code=ts_code, start_date=start_date, end_date=end_date)
|
||
|
||
if df is None or df.empty:
|
||
logger.info(f"未找到 {ts_code} 在 {start_date} 至 {end_date} 期间的停牌数据")
|
||
return None
|
||
else:
|
||
logger.info(f"找到 {ts_code} 在 {start_date} 至 {end_date} 期间的停牌数据: {len(df)}条")
|
||
return df
|
||
except Exception as e:
|
||
logger.error(f"查询停牌信息失败 {ts_code} {start_date}-{end_date}: {str(e)}")
|
||
return None
|
||
|
||
def check_stock_suspended(ts_code, check_date):
|
||
"""
|
||
检查股票在指定日期是否停牌
|
||
:param ts_code: 股票代码，如'688800.SH'
|
||
:param check_date: 检查日期，格式YYYYMMDD
|
||
:return: (is_suspended, suspend_dates, earliest_suspend_start) -
|
||
is_suspended表示是否停牌，suspend_dates表示停牌日期范围，earliest_suspend_start表示最早的停牌开始日期
|
||
"""
|
||
try:
|
||
# 为了确保获取完整的停牌信息，查询范围扩大1个月
|
||
check_dt = datetime.datetime.strptime(check_date, '%Y%m%d')
|
||
start_date = (check_dt - datetime.timedelta(days=30)).strftime('%Y%m%d')
|
||
end_date = (check_dt + datetime.timedelta(days=30)).strftime('%Y%m%d')
|
||
|
||
# 计算今天的日期，格式YYYYMMDD
|
||
today = datetime.datetime.now().strftime('%Y%m%d')
|
||
|
||
# 确保结束日期不超过今天
|
||
if end_date > today:
|
||
end_date = today
|
||
|
||
# 获取停牌信息
|
||
suspend_df = get_suspend_info(ts_code, start_date, end_date)
|
||
|
||
if suspend_df is None:
|
||
return False, "", None # 未找到停牌数据，假设未停牌
|
||
|
||
suspend_dates_list = []
|
||
is_suspended = False
|
||
earliest_suspend_start = None # 改为最早的停牌开始日期
|
||
|
||
# 检查指定日期是否在任何停牌期间内
|
||
for _, row in suspend_df.iterrows():
|
||
# 处理单日停牌数据格式（包含trade_date和suspend_type）
|
||
if 'trade_date' in row and 'suspend_type' in row:
|
||
trade_date = row['trade_date']
|
||
suspend_type = row['suspend_type']
|
||
|
||
# 如果suspend_type为'S'，表示该日停牌
|
||
if suspend_type == 'S':
|
||
# 更新最早的停牌日期（取最小值）
|
||
if earliest_suspend_start is None or trade_date < earliest_suspend_start:
|
||
earliest_suspend_start = trade_date
|
||
|
||
# 保存停牌日期
|
||
suspend_dates_list.append(trade_date)
|
||
|
||
# 检查当前检查日期是否就是停牌日期
|
||
if trade_date == check_date:
|
||
logger.info(f"股票 {ts_code} 在 {check_date} 处于停牌状态")
|
||
is_suspended = True
|
||
continue
|
||
|
||
# 处理传统的停牌数据格式（包含suspend_date和resume_date）
|
||
if 'suspend_date' in row and 'resume_date' in row:
|
||
suspend_start = row['suspend_date']
|
||
suspend_end = row['resume_date']
|
||
|
||
# 更新最早的停牌开始日期（取最小值）
|
||
if earliest_suspend_start is None or suspend_start < earliest_suspend_start:
|
||
earliest_suspend_start = suspend_start
|
||
|
||
# 如果恢复日期为None或00000000，表示尚未复牌
|
||
if not suspend_end or suspend_end == '00000000':
|
||
suspend_end = end_date # 使用查询结束日期
|
||
|
||
# 保存停牌日期范围
|
||
suspend_dates_list.append(f"{suspend_start}-{suspend_end}")
|
||
|
||
# 检查日期是否在停牌期间内
|
||
if suspend_start <= check_date <= suspend_end:
|
||
logger.info(f"股票 {ts_code} 在 {check_date} 处于停牌状态（{suspend_start}至{suspend_end}）")
|
||
is_suspended = True
|
||
elif 'ts_code' in row and 'trade_date' in row:
|
||
# 处理其他格式的单日停牌数据
|
||
trade_date = row['trade_date']
|
||
if earliest_suspend_start is None or trade_date < earliest_suspend_start:
|
||
earliest_suspend_start = trade_date
|
||
|
||
suspend_dates_list.append(trade_date)
|
||
logger.info(f"股票 {ts_code} 在 {trade_date} 处于停牌状态")
|
||
|
||
if trade_date == check_date:
|
||
is_suspended = True
|
||
else:
|
||
logger.warning(f"停牌数据缺少必要字段: {row}")
|
||
|
||
# 合并停牌日期范围
|
||
suspend_dates = ", ".join(suspend_dates_list)
|
||
|
||
if not is_suspended:
|
||
logger.info(f"股票 {ts_code} 在 {check_date} 未处于停牌状态")
|
||
|
||
return is_suspended, suspend_dates, earliest_suspend_start
|
||
except Exception as e:
|
||
logger.error(f"检查股票停牌状态失败 {ts_code} {check_date}: {str(e)}")
|
||
return None, "", None
|
||
|
||
def update_stock_data(ts_code):
|
||
"""
|
||
更新指定股票的行情数据
|
||
:param ts_code: 股票代码，如'688800.SH'
|
||
:return: True表示更新成功，False表示更新失败
|
||
"""
|
||
try:
|
||
logger.info(f"开始更新股票 {ts_code} 的行情数据")
|
||
|
||
# 构建输出文件路径
|
||
output_file = Config.DATA_DIR / f"{ts_code}_daily_data.txt"
|
||
|
||
# 获取Tushare API实例
|
||
pro = tushare_manager.get_pro_api()
|
||
|
||
# 检查是否存在现有数据文件
|
||
if output_file.exists():
|
||
# 读取现有数据，获取最新的交易日期
|
||
try:
|
||
# 使用与update_tushare_totxt.py相同的方式读取数据
|
||
df = pd.read_csv(output_file, sep='\t', encoding='utf-8')
|
||
|
||
if not df.empty and 'trade_date' in df.columns:
|
||
# 获取最新交易日期
|
||
latest_date = df['trade_date'].max()
|
||
|
||
# 计算下一个交易日的起始日期（避免重复获取同一天数据）
|
||
latest_dt = datetime.datetime.strptime(str(latest_date), '%Y%m%d')
|
||
next_dt = latest_dt + datetime.timedelta(days=1)
|
||
next_date = next_dt.strftime('%Y%m%d')
|
||
|
||
logger.info(f"股票 {ts_code} 现有最新日期: {latest_date}，将获取 {next_date} 至今的数据")
|
||
|
||
# 控制请求频率
|
||
tushare_manager.control_request_rate()
|
||
|
||
# 获取最新日期之后的数据
|
||
new_df = pro.daily(ts_code=ts_code, start_date=next_date)
|
||
|
||
if new_df is not None and not new_df.empty:
|
||
logger.info(f"获取到 {ts_code} 的新数据 {len(new_df)} 条")
|
||
|
||
# 合并现有数据和新数据
|
||
combined_df = pd.concat([df, new_df], ignore_index=True)
|
||
|
||
# 去重，避免重复数据
|
||
combined_df = combined_df.drop_duplicates(subset=['trade_date', 'ts_code'], keep='last')
|
||
|
||
# 按交易日期降序排序，最新交易日排在最前面
|
||
combined_df = combined_df.sort_values('trade_date', ascending=False)
|
||
|
||
# 保存合并后的数据
|
||
combined_df.to_csv(output_file, index=False, sep='\t', encoding='utf-8')
|
||
logger.info(f"股票 {ts_code} 的行情数据已成功更新")
|
||
return True
|
||
else:
|
||
logger.info(f"未获取到股票 {ts_code} 的新数据")
|
||
return True
|
||
else:
|
||
logger.warning(f"文件 {output_file} 内容异常，重新获取全部数据")
|
||
except Exception as e:
|
||
logger.error(f"读取文件 {output_file} 失败: {str(e)}")
|
||
|
||
# 文件不存在或读取失败，获取全部数据
|
||
logger.info(f"获取股票 {ts_code} 的全部行情数据")
|
||
|
||
# 控制请求频率
|
||
tushare_manager.control_request_rate()
|
||
|
||
# 获取全部数据
|
||
full_df = pro.daily(ts_code=ts_code)
|
||
|
||
if full_df is not None and not full_df.empty:
|
||
# 按交易日期降序排序，最新交易日排在最前面
|
||
full_df = full_df.sort_values('trade_date', ascending=False)
|
||
|
||
# 保存数据
|
||
full_df.to_csv(output_file, index=False, sep='\t', encoding='utf-8')
|
||
logger.info(f"股票 {ts_code} 的行情数据已成功获取并保存")
|
||
return True
|
||
else:
|
||
logger.warning(f"未能获取到股票 {ts_code} 的行情数据")
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"更新股票 {ts_code} 数据失败: {str(e)}")
|
||
return False
|
||
|
||
def check_market_data(online_check=Config.DEFAULT_ONLINE_CHECK):
|
||
"""
|
||
检查所有行情数据文件的完整性
|
||
|
||
Args:
|
||
online_check: 是否进行在线数据检查，默认False
|
||
"""
|
||
# 设置数据目录
|
||
data_dir = Config.DATA_DIR
|
||
|
||
# 获取当前时间
|
||
now = datetime.datetime.now()
|
||
today = now.strftime('%Y%m%d')
|
||
|
||
# 添加时间判断逻辑：如果当前时间早于16:00，检查日期为前一天；否则为当天
|
||
if now.hour < 16:
|
||
# 获取前一天日期
|
||
yesterday = now - datetime.timedelta(days=1)
|
||
check_date = yesterday.strftime('%Y%m%d')
|
||
logger.info(f"当前时间{now.strftime('%Y-%m-%d %H:%M:%S')}早于16:00，检查日期调整为前一天：{check_date}")
|
||
else:
|
||
check_date = today
|
||
logger.info(f"开始检查行情数据完整性，检查日期：{check_date}")
|
||
|
||
# 优先缓存交易日历，确保后续所有操作都能使用缓存
|
||
logger.info("正在加载交易日历缓存...")
|
||
calendar_df = get_trade_calendar()
|
||
if calendar_df is None:
|
||
logger.warning("交易日历加载失败，部分功能可能受影响")
|
||
else:
|
||
logger.info(f"交易日历缓存成功，共 {len(calendar_df)} 条记录")
|
||
# 验证检查日期是否为交易日
|
||
if is_trading_day(check_date):
|
||
logger.info(f"检查日期 {check_date} 是交易日")
|
||
else:
|
||
logger.warning(f"检查日期 {check_date} 不是交易日，正在寻找最近的前一个交易日...")
|
||
# 寻找最近的前一个交易日
|
||
previous_trading_day = get_previous_trading_day(check_date)
|
||
if previous_trading_day:
|
||
check_date = previous_trading_day
|
||
logger.info(f"已将检查日期调整为：{check_date}")
|
||
else:
|
||
logger.error("无法找到合适的检查日期，将使用原检查日期")
|
||
|
||
# 获取所有txt文件列表
|
||
all_files = list(data_dir.glob('*.txt'))
|
||
total = len(all_files)
|
||
completed = 0
|
||
logger.info(f"开始检查 {total} 个数据文件...")
|
||
|
||
# 记录开始时间
|
||
start_time = datetime.datetime.now()
|
||
|
||
# 存储不完整的数据文件
|
||
incomplete_files = []
|
||
|
||
# 遍历目录下的所有txt文件
|
||
for file_path in all_files:
|
||
file_name = file_path.name
|
||
|
||
# 从文件名中提取股票代码（如：688800.SH_daily_data.txt -> 688800.SH）
|
||
ts_code = file_name.split('_')[0]
|
||
|
||
# 获取最新交易日期
|
||
latest_date = get_latest_trade_date(file_path)
|
||
|
||
if latest_date is None:
|
||
incomplete_files.append({
|
||
'file_name': file_name,
|
||
'ts_code': ts_code,
|
||
'latest_date': 'N/A',
|
||
'trading_days_diff': 'N/A',
|
||
'online_data_exists': 'N/A',
|
||
'status': '文件内容异常',
|
||
'is_suspended': 'N/A',
|
||
'suspend_dates': 'N/A'
|
||
})
|
||
elif latest_date != check_date:
|
||
# 计算交易日差
|
||
trading_days_diff = calculate_trading_days_diff(latest_date, check_date)
|
||
|
||
# 检查在线数据是否存在
|
||
online_data_exists = None
|
||
if online_check:
|
||
online_data_exists = check_online_data_exists(ts_code, check_date)
|
||
|
||
status = '数据不完整'
|
||
if online_check and online_data_exists:
|
||
status += '，在线数据已更新'
|
||
|
||
# 先收集数据不完整的个股，不进行停牌检查
|
||
incomplete_files.append({
|
||
'file_name': file_name,
|
||
'ts_code': ts_code,
|
||
'latest_date': latest_date,
|
||
'trading_days_diff': trading_days_diff or 'N/A',
|
||
'online_data_exists': '是' if online_data_exists else '否' if online_data_exists is False else '未检查',
|
||
'status': status,
|
||
'is_suspended': 'N/A', # 先设为N/A，后续会更新
|
||
'suspend_dates': 'N/A' # 先设为N/A，后续会更新
|
||
})
|
||
# 更新进度
|
||
completed += 1
|
||
progress = (completed / total) * 100
|
||
elapsed = (datetime.datetime.now() - start_time).total_seconds()
|
||
|
||
# 显示进度条
|
||
print(f"\r进度: [{'#' * int(progress / 2)}{' ' * (50 - int(progress / 2))}] {progress:.1f}% | 已完成: {completed}/{total} | 耗时: {elapsed:.1f}s", end='', flush=True)
|
||
|
||
# 添加调试信息
|
||
logger.info(f"收集到的不完整文件数量: {len(incomplete_files)}")
|
||
if incomplete_files:
|
||
logger.info(f"前5个不完整文件示例: {[f['ts_code'] for f in incomplete_files[:5]]}")
|
||
|
||
# 进度条完成后换行
|
||
print()
|
||
|
||
# 对收集到的不完整个股进行统一的停牌检查
|
||
logger.info(f"开始对 {len(incomplete_files)} 个数据不完整的个股进行停牌检查")
|
||
|
||
# 创建新的列表存储经过停牌检查后的结果
|
||
final_incomplete_files = []
|
||
|
||
for file_info in incomplete_files:
|
||
ts_code = file_info['ts_code']
|
||
latest_date = file_info['latest_date']
|
||
|
||
# 如果是文件内容异常，直接添加到最终列表
|
||
if file_info['status'] == '文件内容异常':
|
||
final_incomplete_files.append(file_info)
|
||
continue
|
||
|
||
# 进行停牌检查
|
||
is_suspended, suspend_dates, earliest_suspend_start = check_stock_suspended(ts_code, check_date)
|
||
|
||
# 更新文件信息
|
||
file_info['is_suspended'] = '是' if is_suspended else '否' if is_suspended is not None else '检查失败'
|
||
file_info['suspend_dates'] = suspend_dates if suspend_dates else '无'
|
||
|
||
if is_suspended is True:
|
||
logger.info(f"股票 {ts_code} 当前处于停牌状态")
|
||
|
||
if earliest_suspend_start is not None:
|
||
# 检查最新行情日期是否等于或晚于停牌开始日期
|
||
if latest_date >= earliest_suspend_start:
|
||
logger.info(f"股票 {ts_code} 的最新行情日期 {latest_date} >= 停牌开始日期 {earliest_suspend_start}，数据完整，不输出报告")
|
||
continue # 跳过输出报告
|
||
else:
|
||
logger.info(f"股票 {ts_code} 的最新行情日期 {latest_date} < 停牌开始日期 {earliest_suspend_start}，开始更新数据")
|
||
# 更新数据到最新
|
||
update_success = update_stock_data(ts_code)
|
||
if update_success:
|
||
# 重新读取文件获取最新日期
|
||
file_path = Config.DATA_DIR / f"{ts_code}_daily_data.txt"
|
||
updated_latest_date = get_latest_trade_date(file_path)
|
||
if updated_latest_date:
|
||
file_info['latest_date'] = updated_latest_date
|
||
logger.info(f"股票 {ts_code} 数据更新成功，最新日期: {updated_latest_date}")
|
||
# 继续输出报告，因为已经更新了数据
|
||
elif is_suspended is None:
|
||
logger.warning(f"股票 {ts_code} 的停牌检查失败，继续输出报告")
|
||
|
||
# 如果没有停牌或停牌检查失败，添加到最终列表
|
||
final_incomplete_files.append(file_info)
|
||
|
||
# 更新incomplete_files为经过停牌检查后的最终列表
|
||
incomplete_files = final_incomplete_files
|
||
logger.info(f"停牌检查完成，剩余 {len(incomplete_files)} 个需要输出报告的不完整个股")
|
||
|
||
# 输出结果到CSV文件
|
||
output_file = Config.OUTPUT_FILE
|
||
with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
|
||
fieldnames = ['文件名称', '股票代码', '最新日期', '交易日差', '在线数据', '状态', '是否停牌', '停牌日期']
|
||
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
|
||
|
||
writer.writeheader()
|
||
for file_info in incomplete_files:
|
||
# 构建中文标题对应的字典
|
||
chinese_file_info = {
|
||
'文件名称': file_info['file_name'],
|
||
'股票代码': file_info['ts_code'],
|
||
'最新日期': file_info['latest_date'],
|
||
'交易日差': file_info['trading_days_diff'],
|
||
'在线数据': file_info['online_data_exists'],
|
||
'状态': file_info['status'],
|
||
'是否停牌': file_info['is_suspended'],
|
||
'停牌日期': file_info['suspend_dates']
|
||
}
|
||
writer.writerow(chinese_file_info)
|
||
|
||
logger.info(f"检查完成，共检查 {total} 个文件")
|
||
logger.info(f"发现 {len(incomplete_files)} 个未更新到最新的数据文件")
|
||
logger.info(f"检查结果已输出到：{output_file}")
|
||
|
||
# 打印总结
|
||
print(f"\n=== 行情数据检查结果 ===")
|
||
print(f"检查日期：{check_date}")
|
||
print(f"检查文件总数：{total}")
|
||
print(f"未更新到最新的文件数：{len(incomplete_files)}")
|
||
print(f"在线检查功能：{'开启' if online_check else '关闭'}")
|
||
print(f"检查结果已保存到：{output_file}")
|
||
|
||
if incomplete_files:
|
||
print(f"\n未更新到最新的文件列表：")
|
||
print(f"{'文件名称':<30} {'股票代码':<15} {'最新日期':<12} {'交易日差':<12} {'在线数据':<12} {'状态':<20}")
|
||
print("-" * 100)
|
||
for file_info in incomplete_files:
|
||
print(f"{file_info['file_name']:<30} {file_info['ts_code']:<15} {file_info['latest_date']:<12} "
|
||
f"{str(file_info['trading_days_diff']):<12} {file_info['online_data_exists']:<12} {file_info['status']:<20}")
|
||
|
||
if __name__ == "__main__":
|
||
# 默认关闭在线检查功能
|
||
check_market_data()
|
||
# 如果需要开启在线检查功能，可以使用以下方式
|
||
# check_market_data(online_check=True) |