彩票分析与预测

import pandas as pd
import numpy as np
from collections import Counter, defaultdict
import random
import time
import datetime
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
import warnings
import openpyxl # 确保已安装 openpyxl 库

warnings.filterwarnings('ignore')

class LotteryAnalyzer:
def init(self):
self.front_range = range(1, 36) # 前区号码范围1-35
self.back_range = range(1, 13) # 后区号码范围1-12
self.front_columns = ['前区1', '前区2', '前区3', '前区4', '前区5']
self.back_columns = ['后区1', '后区2']

text
def read_excel_file(self, file_path):
    """读取Excel文件并进行基础处理"""
    try:
        print(f"开始读取Excel文件: {file_path}")
        start_time = time.time()
        df = pd.read_excel(file_path)
        # 确保所有列都是数值类型
        for col in self.front_columns + self.back_columns:
            df[col] = pd.to_numeric(df[col], errors='coerce')

        end_time = time.time()
        print(f"Excel文件读取完成，耗时 {end_time - start_time:.2f} 秒")
        return df
    except Exception as e:
        print(f"读取Excel文件时发生错误: {e}")
        return None

def calculate_missing_values(self, df):
    """计算每个号码的遗漏值"""
    missing_values = {
        'front': defaultdict(int),
        'back': defaultdict(int)
    }

    # 初始化遗漏值计数器
    for num in self.front_range:
        missing_values['front'][num] = 0
    for num in self.back_range:
        missing_values['back'][num] = 0

    # 计算每期之间的遗漏值
    latest_appearances = {
        'front': defaultdict(int),
        'back': defaultdict(int)
    }

    for idx, row in df.iterrows():
        front_numbers = [row[col] for col in self.front_columns]
        back_numbers = [row[col] for col in self.back_columns]

        # 更新前区遗漏值
        for num in self.front_range:
            if num in front_numbers:
                missing_values['front'][num] = idx - latest_appearances['front'][num]
                latest_appearances['front'][num] = idx

        # 更新后区遗漏值
        for num in self.back_range:
            if num in back_numbers:
                missing_values['back'][num] = idx - latest_appearances['back'][num]
                latest_appearances['back'][num] = idx

    return missing_values

def analyze_hot_cold_numbers(self, df, periods=30):
    """分析冷热号"""
    recent_df = df.tail(periods)

    # 统计前区号码频率
    front_numbers = []
    for col in self.front_columns:
        front_numbers.extend(recent_df[col].tolist())
    front_freq = Counter(front_numbers)

    # 统计后区号码频率
    back_numbers = []
    for col in self.back_columns:
        back_numbers.extend(recent_df[col].tolist())
    back_freq = Counter(back_numbers)

    # 定义冷热号的阈值
    front_threshold = np.mean(list(front_freq.values()))
    back_threshold = np.mean(list(back_freq.values()))

    # 将号码分类为冷号和热号
    hot_cold = {
        'front': {'hot': [], 'cold': []},
        'back': {'hot': [], 'cold': []}
    }

    for num in self.front_range:
        if front_freq.get(num, 0) > front_threshold:
            hot_cold['front']['hot'].append(num)
        else:
            hot_cold['front']['cold'].append(num)

    for num in self.back_range:
        if back_freq.get(num, 0) > back_threshold:
            hot_cold['back']['hot'].append(num)
        else:
            hot_cold['back']['cold'].append(num)

    return hot_cold, front_freq, back_freq

def analyze_winning_trends(self, df, periods=10):
    """分析最近中奖号码的走势热度"""
    recent_df = df.tail(periods)

    # 计算近期号码出现频率
    front_numbers = []
    back_numbers = []

    for col in self.front_columns:
        front_numbers.extend(recent_df[col].tolist())
    for col in self.back_columns:
        back_numbers.extend(recent_df[col].tolist())

    front_freq = Counter(front_numbers)
    back_freq = Counter(back_numbers)

    # 计算号码的连续出现情况
    front_consecutive = defaultdict(int)
    back_consecutive = defaultdict(int)

    for i in range(len(recent_df) - 1):
        current_front = set(recent_df.iloc[i][self.front_columns])
        next_front = set(recent_df.iloc[i + 1][self.front_columns])
        for num in current_front & next_front:
            front_consecutive[num] += 1

        current_back = set(recent_df.iloc[i][self.back_columns])
        next_back = set(recent_df.iloc[i + 1][self.back_columns])
        for num in current_back & next_back:
            back_consecutive[num] += 1

    # 计算综合热度分数
    front_heat_score = {}
    for num in self.front_range:
        freq_score = front_freq.get(num, 0) / periods
        consec_score = front_consecutive.get(num, 0) / (periods - 1)
        front_heat_score[num] = (freq_score * 0.7) + (consec_score * 0.3)

    back_heat_score = {}
    for num in self.back_range:
        freq_score = back_freq.get(num, 0) / periods
        consec_score = back_consecutive.get(num, 0) / (periods - 1)
        back_heat_score[num] = (freq_score * 0.7) + (consec_score * 0.3)

    return front_heat_score, back_heat_score

def generate_trend_based_combination(self, df):
    """基于走势热度生成号码组合"""
    front_heat_score, back_heat_score = self.analyze_winning_trends(df)

    # 选择热度最高的号码
    sorted_front = sorted(front_heat_score.items(), key=lambda x: x[1], reverse=True)
    sorted_back = sorted(back_heat_score.items(), key=lambda x: x[1], reverse=True)

    # 从热度最高的号码中随机选择，保持一定随机性
    front_pool = [num for num, _ in sorted_front[:10]]  # 从前10个热门号码中选择
    back_pool = [num for num, _ in sorted_back[:5]]  # 从前5个热门号码中选择

    front_numbers = sorted(random.sample(front_pool, 5))
    back_numbers = sorted(random.sample(back_pool, 2))

    return front_numbers + back_numbers

def generate_optimized_combinations(self, df, num_combinations=5):
    """生成优化后的号码组合，确保高中奖概率"""
    missing_values = self.calculate_missing_values(df)
    hot_cold, front_freq, back_freq = self.analyze_hot_cold_numbers(df)

    combinations = []

    # 1. 热号+冷号组合
    try:
        front_hot = random.sample(hot_cold['front']['hot'], min(3, len(hot_cold['front']['hot'])))
        front_cold = random.sample(hot_cold['front']['cold'], min(2, len(hot_cold['front']['cold'])))
        back_numbers = sorted(random.sample(hot_cold['back']['hot'], min(2, len(hot_cold['back']['hot']))))
        combinations.append(sorted(front_hot + front_cold) + back_numbers)
    except:
        # 如果热号或冷号数量不足，使用随机选择
        front_numbers = sorted(random.sample(list(self.front_range), 5))
        back_numbers = sorted(random.sample(list(self.back_range), 2))
        combinations.append(front_numbers + back_numbers)

    # 2. 遗漏值优先组合
    front_missing = sorted(missing_values['front'].items(), key=lambda x: x[1], reverse=True)
    back_missing = sorted(missing_values['back'].items(), key=lambda x: x[1], reverse=True)
    front_numbers = sorted([num for num, _ in front_missing[:5]])
    back_numbers = sorted([num for num, _ in back_missing[:2]])
    combinations.append(front_numbers + back_numbers)

    # 3. 机器学习模型预测组合
    try:
        lstm_pred = self.build_lstm_model(df)
        front_numbers = sorted([int(round(x)) for x in lstm_pred[:5]])
        back_numbers = sorted([int(round(x)) for x in lstm_pred[5:7]])
        # 确保数字在有效范围内
        front_numbers = [max(1, min(35, x)) for x in front_numbers]
        back_numbers = [max(1, min(12, x)) for x in back_numbers]
        # 确保没有重复数字
        front_numbers = list(dict.fromkeys(front_numbers))
        while len(front_numbers) < 5:
            new_num = random.randint(1, 35)
            if new_num not in front_numbers:
                front_numbers.append(new_num)
        front_numbers = sorted(front_numbers)[:5]

        back_numbers = list(dict.fromkeys(back_numbers))
        while len(back_numbers) < 2:
            new_num = random.randint(1, 12)
            if new_num not in back_numbers:
                back_numbers.append(new_num)
        back_numbers = sorted(back_numbers)[:2]

        combinations.append(front_numbers + back_numbers)
    except:
        try:
            tree_pred = self.build_decision_tree(df)
            combinations.append(tree_pred)
        except:
            # 如果机器学习预测失败，使用随机组合代替
            front_numbers = sorted(random.sample(list(self.front_range), 5))
            back_numbers = sorted(random.sample(list(self.back_range), 2))
            combinations.append(front_numbers + back_numbers)

    # 4. 走势热度组合
    trend_combination = self.generate_trend_based_combination(df)
    combinations.append(trend_combination)

    # 5. 随机生成组合
    front_numbers = sorted(random.sample(list(self.front_range), 5))
    back_numbers = sorted(random.sample(list(self.back_range), 2))
    combinations.append(front_numbers + back_numbers)

    return combinations

def save_recommendations(self, combinations, output_file):
    """保存推荐号码到Excel文件"""
    valid_combinations = []
    for combo in combinations:
        if len(combo) == 7:  # 5前区 + 2后区
            front = sorted(combo[:5])
            back = sorted(combo[5:])
            if (all(1 <= x <= 35 for x in front) and
                    all(1 <= x <= 12 for x in back) and
                    len(set(front)) == 5 and
                    len(set(back)) == 2):
                valid_combinations.append(front + back)

    if not valid_combinations:
        print("没有生成有效的号码组合")
        return

    # 创建DataFrame并保存
    df_recommendations = pd.DataFrame(valid_combinations,
                                      columns=self.front_columns + self.back_columns)

    current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    sheet_name = f"推荐_{current_time}"

    try:
        with pd.ExcelWriter(output_file, engine='openpyxl', mode='a' if openpyxl.__version__ >= '3.0' else 'w') as writer:
            df_recommendations.to_excel(writer, sheet_name=sheet_name, index=False)
        print(f"\n推荐号码已保存到 {output_file} 的 {sheet_name} 工作表中")

        # 打印推荐号码
        print("\n推荐号码组合：")
        for i, combo in enumerate(valid_combinations, 1):
            front = ' '.join(map(str, combo[:5]))
            back = ' '.join(map(str, combo[5:]))
            print(f"组合{i}: 前区: {front} | 后区: {back}")

    except Exception as e:
        print(f"保存推荐号码时发生错误: {e}")

def calculate_trends(self, df):
    """分析号码走势"""
    front_numbers = df[self.front_columns]

    # 计算和值
    trends_sum_values = front_numbers.sum(axis=1)

    # 计算跨度
    trends_span_values = front_numbers.max(axis=1) - front_numbers.min(axis=1)

    # 计算奇偶比
    odd_counts = front_numbers.apply(lambda x: (x % 2 != 0).sum(), axis=1)
    trends_odd_even_ratio = odd_counts / len(self.front_columns)

    # 计算大小比
    big_counts = front_numbers.apply(lambda x: (x > 17).sum(), axis=1)
    trends_big_small_ratio = big_counts / len(self.front_columns)

    return {
        'sum': trends_sum_values,
        'span': trends_span_values,
        'odd_even_ratio': trends_odd_even_ratio,
        'big_small_ratio': trends_big_small_ratio
    }

def build_lstm_model(self, df):
    """使用LSTM模型进行号码预测"""
    try:
        # 准备数据
        data = df[self.front_columns + self.back_columns].values
        scaler = StandardScaler()
        scaled_data = scaler.fit_transform(data)

        # 重塑数据为LSTM所需的格式
        X = scaled_data[:-1]
        y = scaled_data[1:]
        X = X.reshape((X.shape[0], 1, X.shape[1]))

        # 构建模型
        model = Sequential([
            LSTM(64, input_shape=(1, X.shape[2]), return_sequences=True),
            Dropout(0.2),
            LSTM(32),
            Dropout(0.2),
            Dense(y.shape[1])
        ])

        model.compile(optimizer='adam', loss='mse')

        # 训练模型
        model.fit(X, y, epochs=50, batch_size=32, verbose=0)

        # 预测下一期号码
        last_data = scaled_data[-1].reshape(1, 1, -1)
        prediction = model.predict(last_data)

        # 转换回原始比例
        prediction = scaler.inverse_transform(prediction)

        return prediction[0]
    except Exception as e:
        print(f"LSTM模型预测失败: {e}")
        raise

def build_decision_tree(self, df):
    """使用决策树进行号码预测"""
    try:
        # 准备数据
        X = df[self.front_columns + self.back_columns].values
        y = np.roll(X, -1, axis=0)[:-1]  # 使用下一期的数据作为目标
        X = X[:-1]  # 移除最后一行，因为它没有对应的下一期数据

        # 训练模型
        model = DecisionTreeClassifier(max_depth=5, random_state=42)
        model.fit(X, y)

        # 预测下一期号码
        last_data = X[-1].reshape(1, -1)
        prediction = model.predict(last_data)

        # 确保预测结果在有效范围内
        front_pred = [max(1, min(35, int(x))) for x in prediction[0][:5]]
        back_pred = [max(1, min(12, int(x))) for x in prediction[0][5:]]

        # 确保没有重复数字
        front_pred = list(dict.fromkeys(front_pred))
        while len(front_pred) < 5:
            new_num = random.randint(1, 35)
            if new_num not in front_pred:
                front_pred.append(new_num)

        back_pred = list(dict.fromkeys(back_pred))
        while len(back_pred) < 2:
            new_num = random.randint(1, 12)
            if new_num not in back_pred:
                back_pred.append(new_num)

        return sorted(front_pred)[:5] + sorted(back_pred)[:2]

    except Exception as e:
        print(f"决策树模型预测失败: {e}")
        raise

def validate_combination(self, combination):
    """验证号码组合是否有效"""
    if len(combination) != 7:
        return False

    front = combination[:5]
    back = combination[5:]

    # 检查号码范围和唯一性
    if not (all(1 <= x <= 35 for x in front) and
            all(1 <= x <= 12 for x in back) and
            len(set(front)) == 5 and
            len(set(back)) == 2):
        return False

    return True

def format_combination(self, combination):
    """格式化号码组合输出"""
    front = ' '.join(map(str, sorted(combination[:5])))
    back = ' '.join(map(str, sorted(combination[5:])))
    return f"前区: {front} | 后区: {back}"

def main():
"""主程序入口"""
try:
# 创建分析器实例
analyzer = LotteryAnalyzer()

text
    # 设置文件路径
    input_file = 'C:/Users/Administrator/Desktop/新建文件夹/pythonProject1/DLD.xlsx'  # 输入文件路径
    output_file = 'C:/Users/Administrator/Desktop/新建文件夹/pythonProject1/幸运七.xlsx'  # 输出文件路径

    print("开始运行大乐透号码分析...")

    # 读取历史数据
    df = analyzer.read_excel_file(input_file)

    if df is not None:
        print("\n开始生成号码组合...")

        # 生成推荐号码组合
        combinations = analyzer.generate_optimized_combinations(df)

        # 保存并显示结果
        analyzer.save_recommendations(combinations, output_file)

        print("\n号码生成说明：")
        print("1. 组合1: 热号+冷号平衡组合")
        print("2. 组合2: 基于遗漏值分析")
        print("3. 组合3: 机器学习模型预测")
        print("4. 组合4: 走势热度分析组合")
        print("5. 组合5: 随机平衡组合")

        print("\n分析完成！请在输出文件中查看详细结果。")

    else:
        print("无法读取历史数据，程序终止。")

except Exception as e:
    print(f"程序运行出错: {e}")

finally:
    print("\n程序运行结束。")

if name == 'main':
main()帮你优化一下并提高预测准确度1. 历史数据分析
频率分析：统计过去中奖号码的出现频率，找出哪些号码出现得最多（热号）或最少（冷号）。
号码组合模式：分析中奖号码的模式，比如奇偶比例、高低分布等。
趋势分析：通过时间序列图表观察号码的出现趋势，试图预测未来的可能性。
2. 随机性模拟
蒙特卡洛模拟：通过大量模拟，随机生成可能的号码组合并评估其覆盖面。
覆盖优化：设计组合方式，最大化中奖范围（例如，使用数学中的组合学来减少投注总数而覆盖更多号码）。
3. 机器学习（仅适用于有足够历史数据的情况）
回归分析：尝试建立一个模型来预测号码的出现概率（虽然难以有效，因为彩票是独立随机事件）。
分类算法：根据历史数据训练模型，尝试分类哪些号码组合可能中奖。
深度学习：用神经网络从历史中奖号码中寻找复杂模式，尽管这可能导致过拟合。
4. 数学优化
轮盘算法：设计彩票投注策略，比如分层选号法（将号码分区，每区挑选一部分）。
概率覆盖策略：选择特定的号码组合，以确保覆盖更多可能的结果。