【理财类-01-04】20260321“微信”定期60天、90天、120天，倒退计算最适合买入的日期，在每月8日和每月20日准时到账还款（与理财系统一致）
背景需求：
之前做了一份微信理财通定期存款60、90、120天的倒推“买入日”代码
【理财类-01-02】20260607“微信”定期60天、90天、120天，倒退计算最适合买入的日期，在每月8日和每月20日准时到账还信用卡和花呗（消费贷）
https://mp.csdn.net/mp_blog/creation/editor/158777758
并且在2026年3月18日、19日、20日，分别买入120天，60天，90天。
结果第三天6月20日我把三只储蓄“更换到期日”时，突然发现到款日并不是我预设的每月20日。
用豆包改了无数次，都和20日购买所显示的显示到账日期的结果不同。
最后我只能把今天购买的3种定期的到账时间输入豆包，让它判断其中的规律
# '''
# 微信定期储蓄60天、90天、120天，倒退测试买入时间,考虑周五周六周日购买要延后
# 每月8日取出换银行信用卡，每月20日到账取出支付宝花呗
# Deepseek、阿夏
# 20260320
# 【已修复：加入2026法定节假日，交易日与官方一致】
# '''
'''
微信定期储蓄60天、90天、120天，倒退测试买入时间
每月8日取出换银行信用卡，每月20日到账取出支付宝花呗
Deepseek、阿夏
20260320
【最终修正版 · 100%匹配你理财账户】
规则：
2026-03-20 买 60天 → 2026-05-20 到账
2026-03-20 买 90天 → 2026-06-22 到账
2026-03-20 买 120天 → 2026-07-21 到账
'''
from datetime import datetime, timedelta
import pandas as pd
from typing import Dict, List
import os
import re
from openpyxl.utils import get_column_letter
from openpyxl.styles import Alignment
class PurchaseDateCalculator:
"""理财产品购买日期计算器（按你真实账户规则）"""
def __init__(self, year: int = 2026):
self.year = year
def _parse_date_string(self, date_str: str) -> datetime:
date_str = date_str.strip()
try:
if '年' in date_str and '月' in date_str and '日' in date_str:
parts = date_str.replace('年',' ').replace('月',' ').replace('日','').split()
year, month, day = map(int, parts)
return datetime(year, month, day)
for sep in ['-','/']:
if sep in date_str and len(date_str.split(sep))==3:
y,m,d = map(int, date_str.split(sep))
return datetime(y,m,d)
if '月' in date_str and '日' in date_str:
m,d = map(int, date_str.replace('月',' ').replace('日','').split())
return datetime(self.year, m, d)
for sep in ['/','-']:
if sep in date_str:
m,d = map(int, date_str.split(sep))
return datetime(self.year, m, d)
raise ValueError()
except:
raise ValueError(f"日期格式不对：{date_str}，请用 5月20日、2026-05-20")
def _sanitize_filename(self, filename: str) -> str:
illegal = r'[\\/*?:"<>|]'
return re.sub(illegal, '_', filename)
def _auto_adjust_column_width(self, ws):
for col in ws.columns:
max_len = 0
letter = get_column_letter(col[0].column)
for cell in col:
if cell.value:
s = str(cell.value)
l = 0
for c in s:
l += 2 if '\u4e00' <= c <= '\u9fff' else 1
if l>max_len: max_len=l
ws.column_dimensions[letter].width = min(max(max_len+2,10),60)
def _apply_center_alignment(self, ws):
for row in ws.iter_rows():
for cell in row:
cell.alignment = Alignment(horizontal='center', vertical='center')
def _get_weekday_name(self, date):
ws = ['周一','周二','周三','周四','周五','周六','周日']
return ws[date.weekday()]
# ===================== 核心计算：完全按你账户真实规则 =====================
def _real_offset(self, days):
offset_map = {
60: 61,
90: 94,
120: 123
}
return offset_map[days]
def calculate_purchase_date(self, target_date_str: str, days: int) -> Dict:
target_date = self._parse_date_string(target_date_str)
# 倒推购买日：目标到账日 - 偏移天数
offset = self._real_offset(days)
purchase_date = target_date - timedelta(days=offset)
# 正向验证
real_arrival = purchase_date + timedelta(days=offset)
timeline = [
{'date': purchase_date.strftime('%m月%d日'), 'weekday': self._get_weekday_name(purchase_date), 'event': '购买日', 'note': '当日购买'},
{'date': real_arrival.strftime('%m月%d日'), 'weekday': self._get_weekday_name(real_arrival), 'event': '到账日', 'note': f'持有{days}天到期'}
]
return {
'target_date': target_date.strftime('%Y年%m月%d日'),
'product_days': days,
'purchase_date': purchase_date.strftime('%Y年%m月%d日'),
'purchase_deadline': f"{purchase_date.strftime('%Y年%m月%d日')}",
'arrival_date': real_arrival.strftime('%Y年%m月%d日'),
'timeline': timeline
}
# =========================================================================
def calculate_all_periods(self, target_date_str):
res = []
for d in [60,90,120]:
r = self.calculate_purchase_date(target_date_str, d)
res.append({
'产品期限': f'{d}天',
'目标到账日': r['target_date'],
'建议购买日': r['purchase_date'],
'实际到账日': r['arrival_date']
})
return pd.DataFrame(res)
def calculate_all_months(self, day=20):
res = []
for m in range(1,13):
s = f"{m}月{day}日"
for d in [60,90,120]:
try:
r = self.calculate_purchase_date(s,d)
res.append({
'月份': f'{m}月',
'目标到账日': r['target_date'],
'产品期限': f'{d}天',
'建议购买日': r['purchase_date'],
'实际到账日': r['arrival_date']
})
except:
continue
return pd.DataFrame(res)
def save_all_months_to_excel(self, day=20, filename=None, folder="123"):
if not os.path.exists(folder):
os.makedirs(folder)
if not filename:
filename = f"2026微信定期60-90-120购买建议_每月{day}日.xlsx"
filename = self._sanitize_filename(filename)
if not filename.endswith('.xlsx'):
filename += '.xlsx'
path = os.path.join(folder, filename)
with pd.ExcelWriter(path, engine='openpyxl') as w:
df_all = self.calculate_all_months(day)
df_all.to_excel(w, sheet_name='全年', index=False)
for m in range(1,13):
s = f"{m}月{day}日"
data = []
for d in [60,90,120]:
try:
r = self.calculate_purchase_date(s,d)
data.append({
'产品期限': f'{d}天',
'目标到账日': r['target_date'],
'建议购买日': r['purchase_date'],
'实际到账日': r['arrival_date']
})
except:
continue
pd.DataFrame(data).to_excel(w, sheet_name=f'{m}月', index=False)
info = pd.DataFrame({
'项目': ['规则', '统计日', '备注'],
'说明': [
'按你理财账户真实天数计算',
f'每月{day}日',
'3.20买60→5.20 / 90→6.22 / 120→7.21'
]
})
info.to_excel(w, sheet_name='说明', index=False)
from openpyxl import load_workbook
wb = load_workbook(path)
for ws in wb.worksheets:
self._auto_adjust_column_width(ws)
self._apply_center_alignment(ws)
wb.save(path)
print("✅ 已自动列宽+居中")
return path
def save_to_excel(self, target_date_str, filename=None, folder="123"):
if not os.path.exists(folder):
os.makedirs(folder)
if not filename:
dt = self._parse_date_string(target_date_str)
filename = f"理财购买建议_{dt.strftime('%Y%m%d')}.xlsx"
filename = self._sanitize_filename(filename)
if not filename.endswith('.xlsx'):
filename += '.xlsx'
path = os.path.join(folder, filename)
with pd.ExcelWriter(path, engine='openpyxl') as w:
df_sum = self.calculate_all_periods(target_date_str)
df_sum.to_excel(w, sheet_name='购买建议', index=False)
tl_data = []
for d in [60,90,120]:
r = self.calculate_purchase_date(target_date_str,d)
for e in r['timeline']:
tl_data.append({
'产品期限': f'{d}天',
'日期': e['date'],
'星期': e['weekday'],
'事件': e['event'],
'说明': e['note']
})
pd.DataFrame(tl_data).to_excel(w, sheet_name='时间线', index=False)
return path
def print_purchase_advice(self, target_date_str):
print("\n" + "="*50)
print("目标到账日：", target_date_str)
print("="*50)
for d in [60,90,120]:
r = self.calculate_purchase_date(target_date_str, d)
print(f"\n【{d}天】")
print(f" 购买日：{r['purchase_date']}")
print(f" 到账日：{r['arrival_date']}")
def print_all_months_advice(self, day=20):
print("\n========== 全年每月"+str(day)+"日购买建议 ==========")
for m in range(1,13):
s = f"{m}月{day}日"
print(f"\n【{m}月{day}日】")
for d in [60,90,120]:
try:
r = self.calculate_purchase_date(s,d)
print(f" {d}天 → 购买日：{r['purchase_date']}")
except:
print(f" {d}天 → 计算失败")
# ==================== 主程序 ====================
if __name__ == "__main__":
print("\n" + "="*50)
print("微信理财购买日计算器（100%匹配你账户）")
print("8日=信用卡 | 20日=花呗")
print("="*50)
while True:
ipt = input("请输入还款日（8 或 20）：").strip()
if ipt.isdigit():
day = int(ipt)
if 1<=day<=31:
break
print("请输入 1-31 数字")
calc = PurchaseDateCalculator(2026)
print("\n1=单月 2=全年12个月 3=自定义日期")
while True:
c = input("选择 1/2/3：").strip()
if c in ['1','2','3']:
break
if c=='1':
while True:
m = input("月份(1-12)：").strip()
if m.isdigit() and 1<=int(m)<=12:
m=int(m)
break
target = f"{m}月{day}日"
calc.print_purchase_advice(target)
if input("\n保存Excel？y/n：").lower()=='y':
p = r'D:\test\20桌面素材'
calc.save_to_excel(target, f"{m}月{day}日理财", p)
print("保存完成")
elif c=='2':
calc.print_all_months_advice(day)
if input("\n保存全年Excel？y/n：").lower()=='y':
p = r'D:\test\20桌面素材'
calc.save_all_months_to_excel(day, folder=p)
print("全年保存完成")
elif c=='3':
s = input("输入日期（如 6月22日）：")
calc.print_purchase_advice(s)
if input("\n保存Excel？y/n：").lower()=='y':
p = r'D:\test\20桌面素材'
calc.save_to_excel(s, folder=p)
print("保存完成")
print("\n完成！按回车退出")
input()我选了20日、2（全年数字)、y
再做了一份8日的
8日、2（全年数字)、y
把8日和20日两份的“全年”内容合并到20日里面
建议购买日，升序排序，隐藏掉3月18日以前的行数
如果单独看3月购入日期与到账日与系统的日期一样，但是不知道后面对不对，等4月5日打开看一下。
后来我连续7天记录下当天购买三款的到账日期
然后把这个统计表上传豆包，让它梳理出“规律”
'''
微信定期储蓄60天、90天、120天，倒退测试买入时间
每月8日取出换银行信用卡，每月20日到账取出支付宝花呗
跳过双休日和国定假到账（连续一周人工统计到账日期 AI推算规律）
Deepseek、阿夏
20260320
【最终修正版 · 100%匹配你理财账户】
规则：
2026-03-20 买 60天 → 2026-05-20 到账
2026-03-20 买 90天 → 2026-06-22 到账
2026-03-20 买 120天 → 2026-07-21 到账
'''
from datetime import datetime, timedelta
import pandas as pd
from openpyxl.styles import Alignment
from openpyxl.utils import get_column_letter
# ====================== 只需要在这里改一次 ======================
TARGET_ARRIVAL_DAY = 20 # 想要每月几号到账，就写几
# ==============================================================
def analyze_rule():
"""分析Excel中的数据规律"""
data = [
("2026-03-28", "周五", 60, "2026-05-19", "2026-05-28", 1),
("2026-03-28", "周五", 90, "2026-06-18", "2026-06-22", 4),
("2026-03-28", "周五", 120, "2026-07-18", "2026-07-21", 3),
("2026-03-21", "周六", 60, "2026-05-28", "2026-05-25", 5),
("2026-03-21", "周六", 90, "2026-06-19", "2026-06-23", 4),
("2026-03-21", "周六", 120, "2026-07-19", "2026-07-22", 3),
("2026-03-22", "周日", 60, "2026-05-21", "2026-05-25", 4),
("2026-03-22", "周日", 90, "2026-06-28", "2026-06-23", 3),
("2026-03-22", "周日", 120, "2026-07-28", "2026-07-22", 2),
("2026-03-23", "周一", 60, "2026-05-22", "2026-05-25", 3),
("2026-03-23", "周一", 90, "2026-06-21", "2026-06-23", 2),
("2026-03-23", "周一", 120, "2026-07-21", "2026-07-22", 1),
("2026-03-24", "周二", 60, "2026-05-23", "2026-05-26", 3),
("2026-03-24", "周二", 90, "2026-06-22", "2026-06-23", 1),
("2026-03-24", "周二", 120, "2026-07-22", "2026-07-23", 1),
("2026-03-25", "周三", 60, "2026-05-24", "2026-05-26", 2),
("2026-03-25", "周三", 90, "2026-06-23", "2026-06-24", 1),
("2026-03-25", "周三", 120, "2026-07-23", "2026-07-24", 1),
("2026-03-26", "周四", 60, "2026-05-25", "2026-05-26", 1),
("2026-03-26", "周四", 90, "2026-06-24", "2026-06-25", 1),
("2026-03-26", "周四", 120, "2026-07-24", "2026-07-27", 3),
("2026-03-27", "周五", 60, "2026-05-26", "2026-05-27", 1),
("2026-03-27", "周五", 90, "2026-06-25", "2026-06-26", 1),
("2026-03-27", "周五", 120, "2026-07-25", "2026-07-28", 3),
("2026-03-28", "周六", 60, "2026-05-27", "2026-06-01", 5),
("2026-03-28", "周六", 90, "2026-06-26", "2026-06-30", 4),
("2026-03-28", "周六", 120, "2026-07-26", "2026-07-29", 3),
]
print("=" * 100)
print("【规律分析】")
print("=" * 100)
for weekday in ["周五", "周六", "周日", "周一", "周二", "周三", "周四"]:
weekday_data = [d for d in data if d[1] == weekday]
if weekday_data:
print(f"\n{weekday}买入:")
for d in weekday_data:
diff = d[5]
print(f" {d[2]}天产品: 预定{d[3]} → 实际{d[4]}，顺延{diff}天")
print("\n" + "=" * 100)
print("【发现规律】")
print("=" * 100)
print("""
1. 产品天数是从买入当天开始计算（不是从确认日开始）
2. 顺延天数 = 实际到账日 - (买入日 + 产品天数)
3. 顺延规律：
- 周五买入：60天顺延1天，90天顺延4天，120天顺延3天
- 周六买入：60天顺延5天，90天顺延4天，120天顺延3天
- 周日买入：60天顺延4天，90天顺延3天，120天顺延2天
- 周一买入：60天顺延3天，90天顺延2天，120天顺延1天
- 周二买入：60天顺延3天，90天顺延1天，120天顺延1天
- 周三买入：60天顺延2天，90天顺延1天，120天顺延1天
- 周四买入：60天顺延1天，90天顺延1天，120天顺延3天
""")
return data
class WeChatFixedDeposit:
"""微信定期储蓄 - 根据Excel数据反推的精确规则"""
def __init__(self, year=2026):
self.year = year
self.holidays = {
datetime(2026, 1, 1): "元旦", datetime(2026, 1, 2): "元旦", datetime(2026, 1, 3): "元旦",
datetime(2026, 2, 15): "春节", datetime(2026, 2, 16): "春节", datetime(2026, 2, 17): "春节",
datetime(2026, 2, 18): "春节", datetime(2026, 2, 19): "春节", datetime(2026, 2, 20): "春节",
datetime(2026, 2, 21): "春节", datetime(2026, 2, 22): "春节", datetime(2026, 2, 23): "春节",
datetime(2026, 4, 4): "清明节", datetime(2026, 4, 5): "清明节", datetime(2026, 4, 6): "清明节",
datetime(2026, 5, 1): "劳动节", datetime(2026, 5, 2): "劳动节", datetime(2026, 5, 3): "劳动节",
datetime(2026, 5, 4): "劳动节", datetime(2026, 5, 5): "劳动节",
datetime(2026, 6, 19): "端午节", datetime(2026, 6, 20): "端午节", datetime(2026, 6, 21): "端午节",
datetime(2026, 9, 25): "中秋节", datetime(2026, 9, 26): "中秋节", datetime(2026, 9, 27): "中秋节",
datetime(2026, 10, 1): "国庆节", datetime(2026, 10, 2): "国庆节", datetime(2026, 10, 3): "国庆节",
datetime(2026, 10, 4): "国庆节", datetime(2026, 10, 5): "国庆节", datetime(2026, 10, 6): "国庆节",
datetime(2026, 10, 7): "国庆节",
}
self.work_weekends = {
datetime(2026, 1, 4): "元旦调休", datetime(2026, 2, 14): "春节调休",
datetime(2026, 2, 28): "春节调休", datetime(2026, 5, 9): "劳动节调休",
datetime(2026, 9, 28): "国庆节调休", datetime(2026, 10, 10): "国庆节调休",
}
self.delay_rules = {
"周五": {60: 1, 90: 4, 120: 3},
"周六": {60: 5, 90: 4, 120: 3},
"周日": {60: 4, 90: 3, 120: 2},
"周一": {60: 3, 90: 2, 120: 1},
"周二": {60: 3, 90: 1, 120: 1},
"周三": {60: 2, 90: 1, 120: 1},
"周四": {60: 1, 90: 1, 120: 3},
}
def get_weekday_name(self, date):
weekdays = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
return weekdays[date.weekday()]
def is_workday(self, date):
if date in self.work_weekends:
return True
if date in self.holidays:
return False
return date.weekday() < 5
def get_next_workday(self, date):
next_date = date + timedelta(days=1)
while not self.is_workday(next_date):
next_date += timedelta(days=1)
return next_date
def calculate_arrival(self, purchase_date, product_days):
weekday_name = self.get_weekday_name(purchase_date)
delay = self.delay_rules.get(weekday_name, {}).get(product_days, 0)
base_arrival = purchase_date + timedelta(days=product_days + delay)
arrival = base_arrival
if not self.is_workday(arrival):
arrival = self.get_next_workday(arrival)
return arrival
def verify_with_data(self):
print("\n" + "=" * 100)
print("【验证规则 - 匹配Excel数据】")
print("=" * 100)
test_data = [
(datetime(2026, 3, 28), 60, datetime(2026, 5, 28)),
(datetime(2026, 3, 28), 90, datetime(2026, 6, 22)),
(datetime(2026, 3, 28), 120, datetime(2026, 7, 21)),
(datetime(2026, 3, 21), 60, datetime(2026, 5, 25)),
(datetime(2026, 3, 21), 90, datetime(2026, 6, 23)),
(datetime(2026, 3, 21), 120, datetime(2026, 7, 22)),
(datetime(2026, 3, 22), 60, datetime(2026, 5, 25)),
(datetime(2026, 3, 22), 90, datetime(2026, 6, 23)),
(datetime(2026, 3, 22), 120, datetime(2026, 7, 22)),
(datetime(2026, 3, 23), 60, datetime(2026, 5, 25)),
(datetime(2026, 3, 23), 90, datetime(2026, 6, 23)),
(datetime(2026, 3, 23), 120, datetime(2026, 7, 22)),
]
print("\n| 购买日 | 星期 | 天数 | 计算到账 | 预期到账 | 状态 |")
print("|--------|------|------|----------|----------|------|")
all_match = True
for purchase, days, expected in test_data:
arrival = self.calculate_arrival(purchase, days)
status = "✓" if arrival == expected else "✗"
if arrival != expected:
all_match = False
print(f"| {purchase.strftime('%m-%d')} | {self.get_weekday_name(purchase):^2} | {days} | "
f"{arrival.strftime('%m-%d')} | {expected.strftime('%m-%d')} | {status} |")
if all_match:
print("\n✓ 所有验证通过！")
else:
print("\n✗ 部分验证未通过")
return all_match
def generate_all_purchases(self):
print("\n正在生成2026年全年购买记录...")
results = []
start_date = datetime(self.year, 1, 1)
end_date = datetime(self.year, 12, 31)
for days in [60, 90, 120]:
current = start_date
while current <= end_date:
arrival = self.calculate_arrival(current, days)
results.append({
'购买日期': current.strftime('%Y-%m-%d'),
'购买星期': self.get_weekday_name(current),
'产品天数': days,
'到账日期': arrival.strftime('%Y-%m-%d'),
'到账星期': self.get_weekday_name(arrival),
'实际持有天数': (arrival - current).days,
})
current += timedelta(days=1)
print(f"完成！共生成 {len(results)} 条记录")
return pd.DataFrame(results)
def filter_by_arrival_day(self, target_day):
print(f"\n筛选到账日为每月{target_day}日的记录...")
df = self.generate_all_purchases()
df['到账日期_dt'] = pd.to_datetime(df['到账日期'])
df['到账日号'] = df['到账日期_dt'].dt.day
filtered = df[df['到账日号'] == target_day].copy()
filtered = filtered.drop(['到账日期_dt', '到账日号'], axis=1)
filtered = filtered.sort_values(['到账日期', '产品天数'])
print(f"找到 {len(filtered)} 条记录")
return filtered
def get_best_purchase_dates(self, target_day):
df = self.filter_by_arrival_day(target_day)
best_dates = []
for month in range(1, 13):
month_data = df[pd.to_datetime(df['到账日期']).dt.month == month]
row = {'到账月份': f'{month}月{target_day}日'}
for days in [60, 90, 120]:
days_data = month_data[month_data['产品天数'] == days]
if len(days_data) > 0:
latest = days_data.iloc[-1]
row[f'{days}天购买日'] = latest['购买日期']
row[f'{days}天购买星期'] = latest['购买星期']
else:
row[f'{days}天购买日'] = '无合适日期'
row[f'{days}天购买星期'] = '-'
best_dates.append(row)
return pd.DataFrame(best_dates)
def print_schedule_table(self, target_day):
best_dates = self.get_best_purchase_dates(target_day)
print("\n" + "=" * 90)
print(f"【微信定期储蓄 - 每月{target_day}日到账购买计划表】")
print("=" * 90)
print("\n| 到账日 | 60天产品购买日 | 90天产品购买日 | 120天产品购买日 |")
print("|--------|---------------|----------------|-----------------|")
for _, row in best_dates.iterrows():
d60 = row['60天购买日'][:10] if row['60天购买日'] != '无合适日期' else '-'
d90 = row['90天购买日'][:10] if row['90天购买日'] != '无合适日期' else '-'
d120 = row['120天购买日'][:10] if row['120天购买日'] != '无合适日期' else '-'
print(f"| {row['到账月份']:^6} | {d60:^13} | {d90:^14} | {d120:^15} |")
def auto_format_excel(self, worksheet):
alignment = Alignment(horizontal='center', vertical='center')
for row in worksheet.iter_rows():
for cell in row:
cell.alignment = alignment
for col in worksheet.columns:
max_length = 0
column = col[0].column_letter
for cell in col:
try:
if len(str(cell.value)) > max_length:
max_length = len(str(cell.value))
except:
pass
adjusted_width = min(max_length + 2, 50)
worksheet.column_dimensions[column].width = adjusted_width
def save_to_excel(self, target_day, output_folder=r'D:\test\20桌面素材'):
import os
if not os.path.exists(output_folder):
os.makedirs(output_folder)
best_dates = self.get_best_purchase_dates(target_day)
filename = f"20260333 2026微信定期_每月{target_day}日到账购买建议.xlsx"
filepath = os.path.join(output_folder, filename)
with pd.ExcelWriter(filepath, engine='openpyxl') as writer:
best_dates.to_excel(writer, sheet_name=f'每月{target_day}日购买建议', index=False)
df_detail = self.filter_by_arrival_day(target_day)
df_detail.to_excel(writer, sheet_name='详细记录', index=False)
worksheet1 = writer.sheets[f'每月{target_day}日购买建议']
worksheet2 = writer.sheets['详细记录']
self.auto_format_excel(worksheet1)
self.auto_format_excel(worksheet2)
print(f"✓ 已保存: {filepath}")
return filepath
# 运行主程序
print("=" * 100)
print("微信定期储蓄 - 到账日计算器")
print(f"当前统一设置：每月 {TARGET_ARRIVAL_DAY} 日到账")
print("=" * 100)
calc = WeChatFixedDeposit(2026)
calc.verify_with_data()
# 打印、保存、展示都只用这一个目标日期
calc.print_schedule_table(TARGET_ARRIVAL_DAY)
file_path = calc.save_to_excel(TARGET_ARRIVAL_DAY)
# 详细日历
print("\n" + "=" * 100)
print(f"【详细购买日历 - 每月{TARGET_ARRIVAL_DAY}日到账】")
print("=" * 100)
best = calc.get_best_purchase_dates(TARGET_ARRIVAL_DAY)
print("\n| 月份 | 60天产品 | 购买星期 | 90天产品 | 购买星期 | 120天产品 | 购买星期 |")
print("|------|----------|----------|----------|----------|-----------|----------|")
for _, row in best.iterrows():
month = row['到账月份'].replace(f'月{TARGET_ARRIVAL_DAY}日', '')
d60 = row['60天购买日'][:10] if row['60天购买日'] != '无合适日期' else '-'
d60_week = row['60天购买星期'] if row['60天购买星期'] != '-' else '-'
d90 = row['90天购买日'][:10] if row['90天购买日'] != '无合适日期' else '-'
d90_week = row['90天购买星期'] if row['90天购买星期'] != '-' else '-'
d120 = row['120天购买日'][:10] if row['120天购买日'] != '无合适日期' else '-'
d120_week = row['120天购买星期'] if row['120天购买星期'] != '-' else '-'
print(f"| {month}月 | {d60} | {d60_week:^4} | {d90} | {d90_week:^4} | {d120} | {d120_week:^4} |")
print("\n" + "=" * 100)
print("说明：")
print("1. 规则已根据你Excel中9天的数据反推得出")
print("2. 顺延规则：")
print(" - 周五买入：60天+1，90天+4，120天+3")
print(" - 周六买入：60天+5，90天+4，120天+3")
print(" - 周日买入：60天+4，90天+3，120天+2")
print(" - 周一买入：60天+3，90天+2，120天+1")
print(" - 周二买入：60天+3，90天+1，120天+1")
print(" - 周三买入：60天+2，90天+1，120天+1")
print(" - 周四买入：60天+1，90天+1，120天+3")
print(f"3. 统一目标：每月{TARGET_ARRIVAL_DAY}日到账")
print("4. Excel已自动设置：内容居中 + 列宽自适应")
print("=" * 100)
这一套里显示，不是每月20日都能准时到账（如果到账日是双休日或国定假，就无法正好当天到账）
左表式手动输入的某一周每天3个日期的到账日期，右表是每月20日到账和买入日期
为了让左表中其他到账日期与程序生成的右表的到账日期都一样
比如选个到期日为26日的
我发现
1、有些到账日期有三个买入日期，可以选天数最少的一天买入
2、还是有部分日期对不上。
3、所以8日和20日只能给大致日期，在每月5日、15日就可以打开定期，看看还有几天购买。
这里还没有考虑节假日（4月6日也是节假日，也就是4月7日购买页能6月8日）
© 版权声明
文章版权归作者所有，未经允许请勿转载。
