请提供您需要补充情节的标题关键词或现有情节描述。

引言：数据分析的重要性与Python的优势

在当今数据驱动的世界中，数据分析已成为各行各业不可或缺的核心技能。无论您是市场营销人员、金融分析师、产品经理还是科研人员，能够从海量数据中提取有价值的洞察都将为您的职业发展带来巨大优势。Python作为数据分析领域的首选编程语言，凭借其简洁的语法、丰富的库生态系统和强大的社区支持，已成为数据专业人士的标准工具。

Python在数据分析领域的优势主要体现在以下几个方面：

易学性：Python语法接近自然语言，初学者可以快速上手
丰富的库：Pandas、NumPy、Matplotlib、Seaborn等专业库覆盖数据分析全流程
强大的社区：遇到问题时可以轻松找到解决方案和最佳实践
可扩展性：从简单的Excel文件处理到大规模的机器学习项目都能胜任

第一部分：搭建Python数据分析环境

1.1 安装Python和必要的库

在开始数据分析之前，首先需要搭建合适的开发环境。推荐使用Anaconda发行版，它预装了所有必要的数据分析库。

# 如果您使用标准Python安装，可以通过pip安装必要的库
pip install pandas numpy matplotlib seaborn scikit-learn jupyter

# 如果您使用Anaconda，大部分库已经预装，只需更新
conda update pandas numpy matplotlib seaborn scikit-learn

1.2 选择合适的IDE或笔记本环境

对于数据分析，推荐使用以下两种环境：

Jupyter Notebook：适合交互式分析和数据可视化
VS Code：适合大型项目和版本控制

# 启动Jupyter Notebook的命令
jupyter notebook

# 在VS Code中，安装Python扩展后，可以直接创建.py文件或.ipynb文件

第二部分：Pandas基础操作详解

2.1 数据结构与数据读取

Pandas主要有两种数据结构：Series（一维）和DataFrame（二维）。几乎所有数据分析都从DataFrame开始。

import pandas as pd
import numpy as np

# 创建DataFrame的多种方式
# 1. 从字典创建
data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)

# 2. 从CSV文件读取
df_csv = pd.read_csv('data.csv')

# 3. 从Excel文件读取
df_excel = pd.read_excel('data.xlsx')

# 4. 从SQL数据库读取（需要安装sqlalchemy）
# from sqlalchemy import create_engine
# engine = create_engine('sqlite:///mydatabase.db')
# df_sql = pd.read_sql('SELECT * FROM my_table', engine)

print("创建的DataFrame:")
print(df)
print("\nDataFrame基本信息:")
df.info()

2.2 数据清洗与预处理

真实世界的数据往往是脏的，数据清洗是数据分析中最重要的步骤之一。

# 示例数据集
data = {
    '姓名': ['张三', '李四', '王五', None, '赵六'],
    '年龄': [25, 30, 35, None, 28],
    '工资': [8000, 12000, 15000, 9000, None],
    '城市': ['北京', '上海', '广州', '深圳', '上海']
}
df = pd.DataFrame(data)

print("原始数据:")
print(df)

# 1. 处理缺失值
# 检查缺失值
print("\n缺失值统计:")
print(df.isnull().sum())

# 填充缺失值
df['年龄'].fillna(df['年龄'].mean(), inplace=True)  # 用平均值填充
df['工资'].fillna(df['工资'].median(), inplace=True)  # 用中位数填充
df['姓名'].fillna('未知', inplace=True)  # 用特定值填充

# 2. 数据类型转换
df['年龄'] = df['年龄'].astype(int)
df['工资'] = df['工资'].astype(int)

# 3. 处理重复值
df = df.drop_duplicates()

# 4. 异常值处理（使用IQR方法）
Q1 = df['工资'].quantile(0.25)
Q3 = df['工资'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 过滤掉异常值
df = df[(df['工资'] >= lower_bound) & (df['工资'] <= upper_bound)]

print("\n清洗后的数据:")
print(df)

2.3 数据筛选与查询

# 继续使用上面的df

# 1. 基本筛选
# 选择特定列
names = df['姓名']  # 返回Series
subset = df[['姓名', '年龄']]  # 返回DataFrame

# 2. 条件筛选
# 单条件
beijing_employees = df[df['城市'] == '北京']

# 多条件（AND）
young_beijing = df[(df['城市'] == '北京') & (df['年龄'] < 30)]

# 多条件（OR）
high_salary = df[(df['工资'] > 10000) | (df['年龄'] > 30)]

# 3. 使用query方法
high_salary_query = df.query('工资 > 10000 and 年龄 > 25')

# 4. 使用isin进行多值筛选
selected_cities = df[df['城市'].isin(['北京', '上海'])]

# 5. 使用str方法进行字符串操作
# 假设有邮箱列
df['邮箱'] = ['zhangsan@email.com', 'lisi@email.com', 'wangwu@email.com']
email_filter = df[df['邮箱'].str.contains('email.com')]

print("北京员工:")
print(beijing_employees)
print("\n高薪员工:")
print(high_salary)

2.4 数据分组与聚合

# 创建更复杂的数据集用于分组分析
data = {
    '部门': ['销售', '技术', '销售', '技术', '人事', '销售', '技术', '人事'],
    '姓名': ['张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十'],
    '工资': [8000, 12000, 15000, 18000, 9000, 10000, 20000, 11000],
    '年龄': [25, 30, 35, 28, 32, 26, 33, 29],
    '城市': ['北京', '上海', '北京', '深圳', '上海', '北京', '深圳', '上海']
}
df = pd.DataFrame(data)

# 1. 基本分组聚合
# 按部门计算平均工资
avg_salary_by_dept = df.groupby('部门')['工资'].mean()

# 按部门和城市计算平均工资
avg_salary_multi = df.groupby(['部门', '城市'])['工资'].mean()

# 2. 多个聚合函数
dept_stats = df.groupby('部门').agg({
    '工资': ['mean', 'max', 'min', 'count'],
    '年龄': ['mean', 'std']
})

# 3. 自定义聚合函数
def salary_range(series):
    return series.max() - series.min()

dept_custom = df.groupby('部门').agg({
    '工资': ['mean', salary_range]
})

# 4. 转换和过滤
# 计算每个员工相对于部门平均工资的百分比
df['部门平均工资'] = df.groupby('部门')['工资'].transform('mean')
df['相对工资'] = (df['工资'] - df['部门平均工资']) / df['部门平均工资'] * 100

# 过滤掉样本数少于2的部门
filtered_groups = df.groupby('部门').filter(lambda x: len(x) >= 2)

print("按部门统计:")
print(dept_stats)
print("\n包含相对工资的DataFrame:")
print(df)

第三部分：数据可视化实战

3.1 使用Matplotlib创建基础图表

import matplotlib.pyplot as plt
import seaborn as sns

# 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False    # 用来正常显示负号

# 创建示例数据
np.random.seed(42)
dates = pd.date_range('2023-01-01', periods=12, freq='M')
sales = np.random.randint(100, 500, size=12)
profit = sales * 0.3 + np.random.normal(0, 20, 12)

# 1. 折线图
plt.figure(figsize=(12, 6))
plt.plot(dates, sales, marker='o', linewidth=2, label='销售额')
plt.plot(dates, profit, marker='s', linewidth=2, label='利润')
plt.title('2023年月度销售与利润趋势', fontsize=16)
plt.xlabel('月份', fontsize=12)
plt.ylabel('金额（万元）', fontsize=12)
plt.legend()
plt.grid(True, alpha=0.3)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# 2. 柱状图
departments = ['销售', '技术', '人事', '市场']
avg_salaries = [11000, 16000, 10000, 12000]

plt.figure(figsize=(10, 6))
bars = plt.bar(departments, avg_salaries, color=['#ff9999', '#66b3ff', '#99ff99', '#ffcc99'])
plt.title('各部门平均工资对比', fontsize=16)
plt.xlabel('部门', fontsize=12)
plt.ylabel('平均工资（元）', fontsize=12)

# 在柱子上显示数值
for bar in bars:
    height = bar.get_height()
    plt.text(bar.get_x() + bar.get_width()/2., height,
             f'{int(height)}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

# 3. 散点图
np.random.seed(0)
x = np.random.normal(100, 15, 100)
y = x * 0.8 + np.random.normal(0, 10, 100)

plt.figure(figsize=(10, 6))
plt.scatter(x, y, alpha=0.6, s=50, c='steelblue')
plt.title('工资与年龄关系散点图', fontsize=16)
plt.xlabel('年龄', fontsize=12)
plt.ylabel('工资（元）', fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

3.2 使用Seaborn创建高级可视化

Seaborn基于Matplotlib，但提供了更美观的默认样式和更高级的接口。

# 使用Seaborn创建更复杂的图表

# 1. 箱线图（展示分布和异常值）
plt.figure(figsize=(10, 6))
sns.boxplot(data=df, x='部门', y='工资', palette='Set2')
plt.title('各部门工资分布箱线图', fontsize=16)
plt.xlabel('部门', fontsize=12)
plt.ylabel('工资（元）', fontsize=12)
plt.tight_layout()
plt.show()

# 2. 小提琴图（结合箱线图和核密度估计）
plt.figure(figsize=(10, 6))
sns.violinplot(data=df, x='部门', y='工资', palette='pastel')
plt.title('各部门工资分布小提琴图', fontsize=16)
plt.xlabel('部门', fontsize=12)
plt.ylabel('工资（元）', fontsize=12)
plt.tight_layout()
plt.show()

# 3. 热力图（相关性分析）
# 创建相关性矩阵
correlation_data = df[['工资', '年龄']].corr()

plt.figure(figsize=(8, 6))
sns.heatmap(correlation_data, annot=True, cmap='coolwarm', center=0,
            square=True, linewidths=1, cbar_kws={"shrink": 0.8})
plt.title('工资与年龄相关性热力图', fontsize=16)
plt.tight_layout()
plt.show()

# 4. pairplot（多变量关系）
# 使用seaborn的内置数据集
tips = sns.load_dataset('tips')
sns.pairplot(tips, hue='day', palette='viridis', height=2.5)
plt.suptitle('餐厅小费数据多变量关系图', y=1.02, fontsize=16)
plt.tight_layout()
plt.show()

第四部分：高级数据分析技术

4.1 时间序列分析

# 创建时间序列数据
np.random.seed(42)
dates = pd.date_range('2023-01-01', periods=365, freq='D')
values = np.random.normal(100, 10, 365) + np.sin(np.arange(365) * 2 * np.pi / 365) * 20

ts = pd.Series(values, index=dates)

# 1. 重采样（Resampling）
# 按月计算平均值
monthly_mean = ts.resample('M').mean()

# 按周计算总和
weekly_sum = ts.resample('W').sum()

# 2. 滚动统计
rolling_mean = ts.rolling(window=7).mean()  # 7天移动平均
rolling_std = ts.rolling(window=7).std()    # 7天移动标准差

# 3. 时间序列可视化
plt.figure(figsize=(14, 7))
plt.plot(ts.index, ts, label='原始数据', alpha=0.6)
plt.plot(ts.index, rolling_mean, label='7天移动平均', linewidth=2)
plt.fill_between(ts.index, 
                 rolling_mean - rolling_std, 
                 rolling_mean + rolling_std, 
                 alpha=0.2, label='±1标准差')
plt.title('时间序列分析：原始数据与移动平均', fontsize=16)
plt.xlabel('日期', fontsize=12)
plt.ylabel('数值', fontsize=12)
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

4.2 数据透视表

# 创建销售数据
sales_data = {
    '日期': pd.date_range('2023-01-01', periods=20, freq='D'),
    '产品': ['A', 'B', 'C'] * 7 + ['A'],
    '地区': ['华北', '华东', '华南', '华北', '华东', '华南'] * 3 + ['华北'],
    '销量': np.random.randint(50, 200, 20),
    '单价': np.random.randint(10, 50, 20)
}
sales_df = pd.DataFrame(sales_data)
sales_df['销售额'] = sales_df['销量'] * sales_df['单价']

# 1. 创建数据透视表
pivot_table = pd.pivot_table(sales_df, 
                             values='销售额', 
                             index='产品', 
                             columns='地区', 
                             aggfunc='sum',
                             fill_value=0,
                             margins=True,
                             margins_name='总计')

print("销售数据透视表:")
print(pivot_table)

# 2. 多个聚合函数
pivot_multi = pd.pivot_table(sales_df,
                            values=['销量', '销售额'],
                            index='产品',
                            columns='地区',
                            aggfunc={'销量': 'sum', '销售额': ['sum', 'mean']},
                            fill_value=0)

print("\n多指标透视表:")
print(pivot_multi)

# 3. 可视化透视表
plt.figure(figsize=(12, 6))
pivot_table.drop('总计').plot(kind='bar', stacked=True, colormap='viridis')
plt.title('各产品在不同地区的销售额（堆叠柱状图）', fontsize=16)
plt.xlabel('产品', fontsize=12)
plt.ylabel('销售额', fontsize=12)
plt.legend(title='地区')
plt.xticks(rotation=0)
plt.tight_layout()
plt.show()

4.3 数据合并与连接

# 创建两个相关数据集
employees = pd.DataFrame({
    '员工ID': [1, 2, 3, 4, 5],
    '姓名': ['张三', '李四', '王五', '赵六', '孙七'],
    '部门ID': [101, 102, 101, 103, 102]
})

departments = pd.DataFrame({
    '部门ID': [101, 102, 103, 104],
    '部门名称': ['销售部', '技术部', '人事部', '市场部'],
    '预算': [500000, 800000, 300000, 600000]
})

# 1. 合并（Merge）
# 内连接（只返回匹配的行）
inner_merged = pd.merge(employees, departments, on='部门ID', how='inner')

# 左连接（保留左表所有行）
left_merged = pd.merge(employees, departments, on='部门ID', how='left')

# 外连接（保留所有行）
outer_merged = pd.merge(employees, departments, on='部门ID', how='outer')

print("内连接结果:")
print(inner_merged)

# 2. 连接（Join）
# 设置索引进行连接
employees_indexed = employees.set_index('部门ID')
departments_indexed = departments.set_index('部门ID')

joined_df = employees_indexed.join(departments_indexed, how='inner')

print("\n使用Join的结果:")
print(joined_df)

# 3. 拼接（Concat）
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})

# 纵向拼接
concat_vertical = pd.concat([df1, df2], ignore_index=True)

# 横向拼接
concat_horizontal = pd.concat([df1, df2], axis=1)

print("\n纵向拼接:")
print(concat_vertical)

第五部分：实战案例：销售数据分析

5.1 案例背景与数据准备

假设我们是一家电子产品公司的数据分析师，需要分析2023年的销售数据，找出销售趋势、热门产品和地区表现。

# 创建模拟销售数据
np.random.seed(42)

# 基础数据
dates = pd.date_range('2023-01-01', '2023-12-31', freq='D')
products = ['智能手机', '笔记本电脑', '平板电脑', '智能手表']
regions = ['华北', '华东', '华南', '西南', '东北']

# 生成1000条销售记录
n_records = 1000
sales_data = {
    '日期': np.random.choice(dates, n_records),
    '产品': np.random.choice(products, n_records),
    '地区': np.random.choice(regions, n_records),
    '销量': np.random.randint(1, 50, n_records),
    '单价': np.random.randint(1000, 8000, n_records)
}

sales_df = pd.DataFrame(sales_data)
sales_df['销售额'] = sales_df['销量'] * sales_df['单价']
sales_df['成本'] = sales_df['销售额'] * np.random.uniform(0.4, 0.6, n_records)
sales_df['利润'] = sales_df['销售额'] - sales_df['成本']

# 添加一些缺失值和异常值用于清洗练习
sales_df.loc[sales_df.sample(frac=0.05).index, '销量'] = np.nan
sales_df.loc[sales_df.sample(frac=0.02).index, '单价'] = 99999  # 异常值

print("销售数据概览:")
print(sales_df.head())
print(f"\n数据形状: {sales_df.shape}")

5.2 数据清洗与探索性分析

# 1. 数据清洗
print("=== 数据清洗 ===")
print("缺失值统计:")
print(sales_df.isnull().sum())

# 填充缺失值
sales_df['销量'].fillna(sales_df['销量'].median(), inplace=True)

# 处理异常值（单价异常）
sales_df = sales_df[sales_df['单价'] < 50000]  # 剔除异常值

# 2. 基础统计
print("\n=== 基础统计 ===")
print(sales_df.describe())

# 3. 按产品分析
product_analysis = sales_df.groupby('产品').agg({
    '销售额': ['sum', 'mean', 'count'],
    '利润': ['sum', 'mean'],
    '销量': 'sum'
}).round(2)

print("\n按产品分析:")
print(product_analysis)

# 4. 按地区分析
region_analysis = sales_df.groupby('地区').agg({
    '销售额': ['sum', 'mean'],
    '利润': ['sum', 'mean'],
    '销量': 'sum'
}).round(2)

print("\n按地区分析:")
print(region_analysis)

5.3 时间趋势分析

# 1. 按月汇总
monthly_sales = sales_df.groupby(sales_df['日期'].dt.to_period('M')).agg({
    '销售额': 'sum',
    '利润': 'sum',
    '销量': 'sum'
}).reset_index()
monthly_sales['日期'] = monthly_sales['日期'].astype(str)

# 2. 按周汇总
weekly_sales = sales_df.groupby(sales_df['日期'].dt.to_period('W')).agg({
    '销售额': 'sum',
    '利润': '100*利润/销售额'  # 计算利润率
}).reset_index()
weekly_sales['日期'] = weekly_sales['日期'].astype(str)

# 3. 可视化趋势
plt.figure(figsize=(15, 10))

# 月度销售额
plt.subplot(2, 2, 1)
plt.plot(monthly_sales['日期'], monthly_sales['销售额'], marker='o', linewidth=2)
plt.title('2023年月度销售额', fontsize=14)
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)

# 月度利润
plt.subplot(2, 2, 2)
plt.bar(monthly_sales['日期'], monthly_sales['利润'], color='green', alpha=0.7)
plt.title('2023年月度利润', fontsize=14)
plt.xticks(rotation=45)

# 产品销售额占比
plt.subplot(2, 2, 3)
product_sum = sales_df.groupby('产品')['销售额'].sum()
plt.pie(product_sum.values, labels=product_sum.index, autopct='%1.1f%%', startangle=90)
plt.title('产品销售额占比', fontsize=14)

# 地区销售额热力图
plt.subplot(2, 2, 4)
region_product = sales_df.pivot_table(values='销售额', index='地区', columns='产品', aggfunc='sum')
sns.heatmap(region_product, annot=True, fmt='.0f', cmap='YlOrRd', cbar_kws={'label': '销售额'})
plt.title('各地区产品销售额热力图', fontsize=14)

plt.tight_layout()
plt.show()

5.4 深入洞察与建议

# 1. 识别最佳和最差表现
print("=== 深入洞察 ===")

# 最佳产品（按利润）
best_product = sales_df.groupby('产品')['利润'].sum().sort_values(ascending=False).head(1)
print(f"最佳利润产品: {best_product.index[0]}, 总利润: {best_product.values[0]:.2f}")

# 最佳地区（按销售额）
best_region = sales_df.groupby('地区')['销售额'].sum().sort_values(ascending=False).head(1)
print(f"最佳销售地区: {best_region.index[0]}, 总销售额: {best_region.values[0]:.2f}")

# 2. 计算利润率
sales_df['利润率'] = (sales_df['利润'] / sales_df['销售额']) * 100

# 3. 识别高利润产品
profit_margin_analysis = sales_df.groupby('产品').agg({
    '销售额': 'sum',
    '利润': 'sum',
    '利润率': 'mean'
}).round(2)
profit_margin_analysis['利润率'] = profit_margin_analysis['利润率'].astype(str) + '%'

print("\n产品利润率分析:")
print(profit_margin_analysis)

# 4. 生成业务建议
print("\n=== 业务建议 ===")
print("1. 重点关注高利润产品:", profit_margin_analysis['利润'].idxmax())
print("2. 扩大高销售额地区:", best_region.index[0])
print("3. 优化低利润率产品:", profit_margin_analysis['利润率'].idxmin())
print("4. 建议按月监控销售趋势，及时调整策略")

第六部分：性能优化与最佳实践

6.1 处理大数据集的技巧

# 1. 使用适当的数据类型减少内存占用
def optimize_memory(df):
    """优化DataFrame内存使用"""
    start_mem = df.memory_usage().sum() / 1024**2
    
    for col in df.columns:
        col_type = df[col].dtype
        
        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
    
    end_mem = df.memory_usage().sum() / 1024**2
    print(f"内存优化: {start_mem:.2f} MB -> {end_mem:.2f} MB ({100*(start_mem-end_mem)/start_mem:.1f}% reduction)")
    return df

# 2. 使用chunksize处理大文件
def process_large_csv(file_path, chunk_size=10000):
    """分块读取大CSV文件"""
    chunks = []
    for chunk in pd.read_csv(file_path, chunksize=chunk_size):
        # 对每个chunk进行处理
        processed_chunk = chunk[chunk['value'] > 100]  # 示例过滤
        chunks.append(processed_chunk)
    
    return pd.concat(chunks, ignore_index=True)

# 3. 使用向量化操作替代循环
# 不好的做法
def calculate_tax_bad(df):
    result = []
    for i in range(len(df)):
        if df.loc[i, 'income'] > 50000:
            result.append(df.loc[i, 'income'] * 0.3)
        else:
            result.append(df.loc[i, 'income'] * 0.2)
    return result

# 好的做法（向量化）
def calculate_tax_good(df):
    return np.where(df['income'] > 50000, df['income'] * 0.3, df['income'] * 0.2)

# 4. 使用query()和eval()进行高效计算
# 创建大型数据集测试
large_df = pd.DataFrame({
    'a': np.random.randint(1, 100, 100000),
    'b': np.random.randint(1, 100, 100000),
    'c': np.random.randint(1, 100, 100000)
})

# 使用query进行高效筛选
result_query = large_df.query('a > 50 and b < 80 and c > 20')

# 使用eval进行高效计算
large_df['d'] = large_df.eval('a * b + c')

6.2 代码组织与可维护性

# 1. 使用函数封装重复逻辑
def load_and_clean_data(file_path):
    """加载并清洗数据的完整流程"""
    df = pd.read_csv(file_path)
    
    # 处理缺失值
    df.fillna({
        'age': df['age'].median(),
        'salary': df['salary'].median()
    }, inplace=True)
    
    # 处理异常值
    df = df[(df['salary'] > 0) & (df['salary'] < 1000000)]
    
    return df

def analyze_sales(df):
    """销售分析主函数"""
    # 按产品汇总
    product_analysis = df.groupby('product').agg({
        'sales': 'sum',
        'profit': 'sum'
    })
    
    # 按地区汇总
    region_analysis = df.groupby('region').agg({
        'sales': 'sum',
        'profit': 'sum'
    })
    
    return product_analysis, region_analysis

# 2. 使用配置文件管理参数
CONFIG = {
    'file_path': 'sales_data.csv',
    'min_sales': 100,
    'target_products': ['智能手机', '笔记本电脑'],
    'output_dir': './reports/'
}

# 3. 添加日志记录
import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('data_analysis.log'),
        logging.StreamHandler()
    ]
)

def analyze_with_logging(df):
    logging.info(f"开始分析，数据形状: {df.shape}")
    
    try:
        result = df.groupby('product')['sales'].sum()
        logging.info("分析完成")
        return result
    except Exception as e:
        logging.error(f"分析失败: {str(e)}")
        raise

第七部分：扩展学习路径

7.1 进阶技能推荐

机器学习集成：学习Scikit-learn进行预测分析
大数据处理：学习Dask或PySpark处理超大规模数据
数据库集成：学习SQLAlchemy和PostgreSQL
自动化报告：学习使用Jupyter Notebook生成自动化报告
Web应用：学习使用Streamlit或Dash创建交互式数据应用

7.2 推荐资源

官方文档：Pandas、NumPy、Matplotlib官方文档
在线课程：Coursera、DataCamp、Kaggle Learn
书籍：《利用Python进行数据分析》、《Python数据科学手册》
社区：Stack Overflow、GitHub、Kaggle论坛

结语

Python数据分析是一个持续学习和实践的过程。通过掌握Pandas、NumPy、Matplotlib等核心库，您已经具备了处理大多数数据分析任务的能力。记住，最好的学习方法是实践——找到您感兴趣的数据集，尝试回答实际问题，并不断优化您的分析流程。

随着经验的积累，您将能够处理更复杂的数据分析挑战，并为业务决策提供更有价值的洞察。祝您在数据分析的道路上取得成功！# 如何利用Python进行高效的数据分析：从入门到实践的完整指南