# DeepSeek-R1代码生成实战：Python函数自动编写案例 ## 1. 项目简介与环境准备 DeepSe1-R1是一个基于深度蒸馏技术的本地化推理引擎，专门针对代码生成和逻辑推理任务进行了优化。这个1.5B参数的模型最大的优势是可以在纯CPU环境下流畅运行，无需依赖昂贵的GPU硬件。 ### 1.1 核心特性亮点 - **强大的代码生成能力**：特别擅长Python函数编写、算法实现和代码优化 - **本地化隐私保护**：所有计算在本地完成，代码和数据不会上传到云端 - **极速响应体验**：CPU推理延迟极低，即时获得代码生成结果 - **思维链推理**：能够理解复杂需求并生成逻辑清晰的代码 ### 1.2 快速部署步骤 部署过程非常简单，只需要几个步骤就能开始使用： ```bash # 克隆项目仓库 git clone https://github.com/modelscope/DeepSeek-R1-Distill-Qwen-1.5B.git # 进入项目目录 cd DeepSeek-R1-Distill-Qwen-1.5B # 安装依赖（建议使用虚拟环境） pip install -r requirements.txt # 启动Web服务 python app.py ``` 启动完成后，在浏览器中访问显示的端口地址，就能看到清爽的聊天界面，可以开始输入代码生成需求了。 ## 2. Python函数自动生成实战 现在让我们通过几个实际案例，看看DeepSeek-R1在Python函数生成方面的强大能力。 ### 2.1 基础函数生成案例 **需求**：生成一个函数，计算斐波那契数列的第n项 在聊天界面输入： ``` 请帮我写一个Python函数，计算斐波那契数列的第n项，要求使用递归实现 ``` DeepSeek-R1生成的代码： ```python def fibonacci(n): """ 计算斐波那契数列的第n项（递归实现） 参数: n (int): 要计算的项数 返回: int: 斐波那契数列的第n项 """ if n <= 0: return 0 elif n == 1: return 1 else: return fibonacci(n-1) + fibonacci(n-2) # 测试函数 if __name__ == "__main__": # 测试前10项 for i in range(10): print(f"fibonacci({i}) = {fibonacci(i)}") ``` ### 2.2 数据处理函数生成 **需求**：生成一个数据处理函数，处理CSV文件并计算统计信息 输入提示： ``` 请写一个Python函数，读取CSV文件，计算每列的平均值、最大值、最小值，并返回结果字典 ``` 生成的代码： ```python import csv from typing import Dict, List def analyze_csv_file(file_path: str) -> Dict[str, Dict[str, float]]: """ 分析CSV文件并计算每列的统计信息 参数: file_path (str): CSV文件路径 返回: Dict[str, Dict[str, float]]: 每列的统计信息字典 """ results = {} try: with open(file_path, 'r', encoding='utf-8') as file: reader = csv.DictReader(file) data = list(reader) if not data: return {} # 获取所有列名 columns = data[0].keys() for column in columns: # 尝试转换为数值类型 values = [] for row in data: try: value = float(row[column]) values.append(value) except (ValueError, TypeError): continue if values: results[column] = { '平均值': sum(values) / len(values), '最大值': max(values), '最小值': min(values), '数据量': len(values) } else: results[column] = { '平均值': None, '最大值': None, '最小值': None, '数据量': 0 } except FileNotFoundError: print(f"错误：文件 {file_path} 不存在") except Exception as e: print(f"读取文件时出错：{e}") return results # 使用示例 if __name__ == "__main__": stats = analyze_csv_file("data.csv") for column, info in stats.items(): print(f"{column}: {info}") ``` ### 2.3 算法实现案例 **需求**：实现一个快速排序算法 输入提示： ``` 请用Python实现快速排序算法，要求包含详细的注释说明 ``` 生成的代码： ```python def quick_sort(arr): """ 快速排序算法实现 参数: arr (list): 待排序的列表 返回: list: 排序后的列表 """ # 基线条件：如果数组长度为0或1，直接返回 if len(arr) <= 1: return arr # 选择基准元素（这里选择中间元素） pivot = arr[len(arr) // 2] # 分割数组 left = [x for x in arr if x < pivot] # 小于基准的元素 middle = [x for x in arr if x == pivot] # 等于基准的元素 right = [x for x in arr if x > pivot] # 大于基准的元素 # 递归排序左右子数组并合并结果 return quick_sort(left) + middle + quick_sort(right) def quick_sort_inplace(arr, low=0, high=None): """ 原地快速排序（节省内存空间） 参数: arr (list): 待排序的列表 low (int): 起始索引 high (int): 结束索引 """ if high is None: high = len(arr) - 1 if low < high: # 分割数组并获取基准位置 pivot_index = partition(arr, low, high) # 递归排序左右子数组 quick_sort_inplace(arr, low, pivot_index - 1) quick_sort_inplace(arr, pivot_index + 1, high) def partition(arr, low, high): """ 分割数组，返回基准元素的最终位置 参数: arr (list): 待分割的数组 low (int): 起始索引 high (int): 结束索引 返回: int: 基准元素的最终位置 """ # 选择最右边的元素作为基准 pivot = arr[high] # 小于基准的元素的边界索引 i = low - 1 for j in range(low, high): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] # 将基准元素放到正确位置 arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1 # 测试代码 if __name__ == "__main__": # 测试数据 test_array = [64, 34, 25, 12, 22, 11, 90, 88] print("原始数组:", test_array) # 使用非原地版本 sorted_array = quick_sort(test_array) print("排序后（非原地）:", sorted_array) # 使用原地版本 test_array2 = [64, 34, 25, 12, 22, 11, 90, 88] quick_sort_inplace(test_array2) print("排序后（原地）:", test_array2) ``` ## 3. 高级代码生成技巧 ### 3.1 使用具体的提示词技巧 要让DeepSeek-R1生成更符合需求的代码，可以使用以下提示词技巧： **普通提示**： ``` 写一个函数处理字符串 ``` **优化后的提示**： ``` 请编写一个Python函数，实现字符串的驼峰命名法转换： 1. 输入：下划线命名法的字符串，如 "user_name" 2. 输出：驼峰命名法的字符串，如 "userName" 3. 要求处理连续下划线的情况 4. 添加类型注解和文档字符串 ``` 生成的代码： ```python def underscore_to_camelcase(s: str) -> str: """ 将下划线命名法的字符串转换为驼峰命名法 参数: s (str): 下划线命名法的字符串，如 "user_name" 返回: str: 驼峰命名法的字符串，如 "userName" 示例: >>> underscore_to_camelcase("user_name") 'userName' >>> underscore_to_camelcase("hello_world_python") 'helloWorldPython' >>> underscore_to_camelcase("single") 'single' """ # 处理空字符串 if not s: return s # 分割字符串，过滤空字符串（处理连续下划线） parts = [part for part in s.split('_') if part] if not parts: return '' # 第一个单词保持小写，后续单词首字母大写 camelcase_str = parts[0].lower() for part in parts[1:]: if part: # 确保不是空字符串 camelcase_str += part[0].upper() + part[1:].lower() return camelcase_str # 测试函数 if __name__ == "__main__": test_cases = [ "user_name", "hello_world", "python_programming", "test__multiple__underscores", "single", "", "_leading_underscore", "trailing_underscore_" ] for test in test_cases: result = underscore_to_camelcase(test) print(f"'{test}' -> '{result}'") ``` ### 3.2 生成测试代码 DeepSeek-R1还可以帮助生成相应的测试代码： 输入提示： ``` 为上面的驼峰命名法转换函数编写单元测试，使用pytest框架 ``` 生成的测试代码： ```python import pytest from your_module import underscore_to_camelcase # 替换为实际模块名 def test_underscore_to_camelcase_basic(): """测试基本的转换功能""" assert underscore_to_camelcase("user_name") == "userName" assert underscore_to_camelcase("hello_world") == "helloWorld" assert underscore_to_camelcase("python_programming") == "pythonProgramming" def test_underscore_to_camelcase_edge_cases(): """测试边界情况""" # 空字符串 assert underscore_to_camelcase("") == "" # 单个单词 assert underscore_to_camelcase("single") == "single" assert underscore_to_camelcase("SINGLE") == "single" # 只有下划线 assert underscore_to_camelcase("___") == "" def test_underscore_to_camelcase_multiple_underscores(): """测试连续多个下划线的情况""" assert underscore_to_camelcase("test__multiple__underscores") == "testMultipleUnderscores" assert underscore_to_camelcase("a__b_c__d") == "aBCD" def test_underscore_to_camelcase_with_uppercase(): """测试包含大写字母的情况""" assert underscore_to_camelcase("User_Name") == "userName" assert underscore_to_camelcase("HTML_Parser") == "htmlParser" def test_underscore_to_camelcase_leading_trailing_underscores(): """测试开头和结尾的下划线""" assert underscore_to_camelcase("_leading_underscore") == "leadingUnderscore" assert underscore_to_camelcase("trailing_underscore_") == "trailingUnderscore" assert underscore_to_camelcase("_both_underscores_") == "bothUnderscores" if __name__ == "__main__": pytest.main([__file__, "-v"]) ``` ## 4. 实际应用场景示例 ### 4.1 数据分析管道生成 **需求**：创建一个完整的数据分析管道 输入提示： ``` 请创建一个完整的数据分析管道类，包含以下功能： 1. 数据加载（支持CSV和Excel） 2. 数据清洗（处理缺失值、重复值） 3. 数据转换（数值标准化、独热编码） 4. 统计分析（描述性统计、相关性分析） 5. 结果导出为HTML报告 要求使用面向对象设计，代码结构清晰 ``` 生成的代码： ```python import pandas as pd import numpy as np from pathlib import Path from typing import Union, Dict, List import jinja2 class DataAnalysisPipeline: """ 数据分析管道类，提供端到端的数据分析功能 """ def __init__(self): self.data = None self.report_data = {} def load_data(self, file_path: Union[str, Path], file_type: str = 'auto') -> 'DataAnalysisPipeline': """ 加载数据文件 参数: file_path: 文件路径 file_type: 文件类型 ('csv', 'excel', 'auto') 返回: self: 支持方法链调用 """ file_path = Path(file_path) if file_type == 'auto': if file_path.suffix.lower() == '.csv': file_type = 'csv' elif file_path.suffix.lower() in ['.xlsx', '.xls']: file_type = 'excel' try: if file_type == 'csv': self.data = pd.read_csv(file_path) elif file_type == 'excel': self.data = pd.read_excel(file_path) else: raise ValueError(f"不支持的文件类型: {file_type}") self.report_data['load'] = { 'success': True, 'rows': len(self.data), 'columns': list(self.data.columns), 'file_type': file_type } except Exception as e: self.report_data['load'] = { 'success': False, 'error': str(e) } raise return self def clean_data(self) -> 'DataAnalysisPipeline': """数据清洗""" if self.data is None: raise ValueError("请先加载数据") # 记录原始信息 original_shape = self.data.shape original_missing = self.data.isnull().sum().sum() # 处理缺失值 numeric_cols = self.data.select_dtypes(include=[np.number]).columns categorical_cols = self.data.select_dtypes(include=['object']).columns # 数值列用中位数填充 for col in numeric_cols: self.data[col].fillna(self.data[col].median(), inplace=True) # 分类列用众数填充 for col in categorical_cols: self.data[col].fillna(self.data[col].mode()[0] if not self.data[col].mode().empty else 'Unknown', inplace=True) # 删除重复行 duplicates_removed = self.data.duplicated().sum() self.data.drop_duplicates(inplace=True) self.report_data['clean'] = { 'original_shape': original_shape, 'final_shape': self.data.shape, 'missing_values_removed': original_missing, 'duplicates_removed': duplicates_removed } return self def analyze_data(self) -> 'DataAnalysisPipeline': """执行统计分析""" if self.data is None: raise ValueError("请先加载和清洗数据") # 描述性统计 numeric_stats = self.data.describe().to_dict() # 相关性分析 correlation = self.data.corr().round(3).to_dict() # 数据分布信息 distribution = {} for col in self.data.columns: if self.data[col].dtype == 'object': distribution[col] = { 'type': 'categorical', 'unique_values': self.data[col].nunique(), 'top_values': self.data[col].value_counts().head(5).to_dict() } else: distribution[col] = { 'type': 'numeric', 'unique_values': self.data[col].nunique(), 'skewness': round(self.data[col].skew(), 3) } self.report_data['analysis'] = { 'numeric_stats': numeric_stats, 'correlation': correlation, 'distribution': distribution } return self def generate_report(self, output_path: Union[str, Path]) -> str: """生成HTML报告""" # 简单的HTML模板 template_str = """ <!DOCTYPE html> <html> <head> <title>数据分析报告</title> <style> body { font-family: Arial, sans-serif; margin: 40px; } .section { margin-bottom: 30px; } table { border-collapse: collapse; width: 100%; } th, td { border: 1px solid #ddd; padding: 8px; text-align: left; } th { background-color: #f2f2f2; } </style> </head> <body> <h1>数据分析报告</h1> <div class="section"> <h2>数据加载信息</h2> {% if report_data.load.success %} <p>成功加载{{ report_data.load.rows }}行{{ report_data.load.columns|length }}列数据</p> <p>文件类型: {{ report_data.load.file_type }}</p> {% else %} <p>数据加载失败: {{ report_data.load.error }}</p> {% endif %} </div> <div class="section"> <h2>数据清洗结果</h2> <p>原始数据形状: {{ report_data.clean.original_shape[0] }}行 × {{ report_data.clean.original_shape[1] }}列</p> <p>清洗后形状: {{ report_data.clean.final_shape[0] }}行 × {{ report_data.clean.final_shape[1] }}列</p> <p>移除缺失值: {{ report_data.clean.missing_values_removed }}</p> <p>移除重复行: {{ report_data.clean.duplicates_removed }}</p> </div> <div class="section"> <h2>统计分析摘要</h2> <h3>数值列统计信息</h3> <table> <tr> <th>统计量</th> {% for col in report_data.analysis.numeric_stats.keys() %} <th>{{ col }}</th> {% endfor %} </tr> {% for stat in ['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max'] %} <tr> <td>{{ stat }}</td> {% for col, values in report_data.analysis.numeric_stats.items() %} <td>{{ values[stat] if stat in values else 'N/A' }}</td> {% endfor %} </tr> {% endfor %} </table> </div> </body> </html> """ template = jinja2.Template(template_str) html_content = template.render(report_data=self.report_data) with open(output_path, 'w', encoding='utf-8') as f: f.write(html_content) return html_content # 使用示例 if __name__ == "__main__": pipeline = DataAnalysisPipeline() try: pipeline.load_data('data.csv') \ .clean_data() \ .analyze_data() \ .generate_report('analysis_report.html') print("分析完成！报告已生成") except Exception as e: print(f"分析过程中出错: {e}") ``` ## 5. 使用技巧与最佳实践 ### 5.1 提示词优化策略 根据实践经验，以下提示词策略可以获得更好的代码生成效果： 1. **明确具体需求**：提供详细的输入输出示例 2. **指定代码风格**：要求添加类型注解、文档字符串等 3. **包含边界情况**：说明需要处理的各种特殊情况 4. **要求测试代码**：让模型同时生成测试用例 5. **分步骤请求**：复杂功能可以分多次请求，逐步完善 ### 5.2 代码质量检查 虽然DeepSeek-R1生成的代码质量很高，但仍建议进行以下检查： - **逻辑正确性验证**：运行测试用例确保功能正确 - **代码风格统一**：检查是否符合团队的编码规范 - **性能优化**：对于性能敏感的场景进行优化 - **错误处理完善**：添加适当的异常处理和日志记录 ### 5.3 集成到开发流程 可以将DeepSeek-R1集成到日常开发流程中： 1. **原型快速开发**：快速生成功能原型代码 2. **代码片段生成**：生成常用的工具函数和算法实现 3. **测试用例生成**：自动生成单元测试代码 4. **文档生成**：根据代码生成相应的文档说明 ## 6. 总结 DeepSeek-R1在Python代码生成方面表现出色，特别是对于函数级别的代码生成任务。通过本文的实战案例，我们可以看到： 1. **高质量代码生成**：能够生成结构清晰、注释完整的Python代码 2. **强大的逻辑理解**：能够理解复杂需求并生成相应的实现 3. **快速响应能力**：在CPU环境下也能提供快速的代码生成服务 4. **隐私安全保护**：所有代码生成都在本地完成，保护代码隐私 无论是简单的工具函数还是复杂的数据处理管道，DeepSeek-R1都能提供高质量的代码生成服务。结合合适的提示词技巧，可以显著提高开发效率。 在实际使用中，建议先从小型函数开始尝试，逐步熟悉模型的代码生成风格和能力边界，然后应用到更复杂的开发任务中。 --- > **获取更多AI镜像** > > 想探索更多AI镜像和应用场景？访问 [CSDN星图镜像广场](https://ai.csdn.net/?utm_source=mirror_blog_end)，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。