--- title: "LLM代码生成：AI辅助编程" description: "使用LLM进行代码生成、补全和转换" tags: ["代码生成", "AI编程", "代码补全", "LLM", "编程辅助"] category: "llm" icon: "💻"

LLM代码生成：AI辅助编程

代码生成概述

LLM代码生成是利用大语言模型辅助编程的技术，包括代码生成、补全、转换和解释。

核心功能

1. 代码生成器

from openai import OpenAI
from typing import List, Dict, Optional
from dataclasses import dataclass

@dataclass
class CodeGenerationRequest:
    """代码生成请求"""
    description: str
    language: str
    context: Optional[str] = None
    requirements: Optional[List[str]] = None

@dataclass
class CodeGenerationResult:
    """代码生成结果"""
    code: str
    explanation: str
    language: str
    dependencies: List[str]

class CodeGenerator:
    """代码生成器"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.model = model
    
    def generate_code(self, request: CodeGenerationRequest) -> CodeGenerationResult:
        """生成代码"""
        prompt = self._build_prompt(request)
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "你是一个专业的程序员，擅长生成高质量的代码。"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )
        
        result = response.choices[0].message.content
        code, explanation = self._parse_response(result)
        
        return CodeGenerationResult(
            code=code,
            explanation=explanation,
            language=request.language,
            dependencies=self._extract_dependencies(code, request.language)
        )
    
    def _build_prompt(self, request: CodeGenerationRequest) -> str:
        """构建提示"""
        prompt = f"请用{request.language}编写以下功能的代码：\n\n"
        prompt += f"描述：{request.description}\n"
        
        if request.context:
            prompt += f"\n上下文：\n{request.context}\n"
        
        if request.requirements:
            prompt += "\n要求：\n"
            for req in request.requirements:
                prompt += f"- {req}\n"
        
        prompt += "\n请提供：\n1. 完整的代码\n2. 代码说明\n"
        
        return prompt
    
    def _parse_response(self, response: str) -> tuple:
        """解析响应"""
        # 简化解析：寻找代码块
        import re
        
        code_blocks = re.findall(r'```(?:\w+)?\n(.*?)```', response, re.DOTALL)
        
        if code_blocks:
            code = code_blocks[0].strip()
            explanation = response.replace(code_blocks[0], "").strip()
        else:
            code = response
            explanation = ""
        
        return code, explanation
    
    def _extract_dependencies(self, code: str, language: str) -> List[str]:
        """提取依赖"""
        import re
        
        dependencies = []
        
        if language == "python":
            imports = re.findall(r'^(?:from|import)\s+(\w+)', code, re.MULTILINE)
            dependencies = list(set(imports))
        elif language in ["javascript", "typescript"]:
            imports = re.findall(r'import\s+.*?from\s+[\'"](.+?)[\'"]', code)
            dependencies = list(set(imports))
        
        return dependencies

2. 代码补全器

class CodeCompleter:
    """代码补全器"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.model = model
    
    def complete_code(self, code: str, language: str, cursor_position: int = None) -> List[str]:
        """补全代码"""
        prompt = f"""请为以下{language}代码提供补全建议：

代码：
```{language}
{code}

请提供3个不同的补全建议，每个建议一行。"""

    response = self.client.chat.completions.create(
        model=self.model,
        messages=[
            {"role": "system", "content": "你是一个代码补全助手。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.5
    )
    
    result = response.choices[0].message.content
    return self._parse_completions(result)

def _parse_completions(self, result: str) -> List[str]:
    """解析补全建议"""
    lines = result.strip().split("\n")
    completions = []
    
    for line in lines:
        line = line.strip()
        if line and not line.startswith("#") and not line.startswith("//"):
            # 移除编号
            import re
            cleaned = re.sub(r'^\d+[\.\)]\s*', '', line)
            if cleaned:
                completions.append(cleaned)
    
    return completions[:3]  # 返回前3个建议

### 3. 代码转换器

```python
class CodeConverter:
    """代码转换器"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.model = model
    
    def convert_code(self, source_code: str, source_lang: str, target_lang: str) -> Dict:
        """转换代码"""
        prompt = f"""请将以下{source_lang}代码转换为{target_lang}：

源代码（{source_lang}）：
```{source_lang}
{source_code}

请提供：

1. 转换后的代码（{target_lang}）

2. 转换说明

3. 注意事项"""

    response = self.client.chat.completions.create(
        model=self.model,
        messages=[
            {"role": "system", "content": f"你是{target_lang}编程专家。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.3
    )
    
    result = response.choices[0].message.content
    return self._parse_conversion(result, target_lang)
   

   def _parse_conversion(self, result: str, target_lang: str) -> Dict: """解析转换结果""" import re code_match = re.search(rf'(?:{target_lang})?\n(.*?)', result, re.DOTALL) if code_match: code = code_match.group(1).strip() explanation = result.replace(code_match.group(0), "").strip() else: code = result explanation = "" return { "converted_code": code, "explanation": explanation, "target_language": target_lang }

## 代码分析

### 1. 代码解释器

```python
class CodeExplainer:
    """代码解释器"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.model = model
    
    def explain_code(self, code: str, language: str, detail_level: str = "medium") -> str:
        """解释代码"""
        prompt = f"""请{detail_level}程度地解释以下{language}代码：

```{language}
{code}

请提供：

1. 代码功能概述

2. 关键部分解释

3. 执行流程

4. 潜在问题或改进建议"""

    response = self.client.chat.completions.create(
        model=self.model,
        messages=[
            {"role": "system", "content": "你是一个代码解释专家。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.5
    )
    
    return response.choices[0].message.content
   

### 2. 代码审查器

```python
class CodeReviewer:
    """代码审查器"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.model = model
    
    def review_code(self, code: str, language: str) -> Dict:
        """审查代码"""
        prompt = f"""请审查以下{language}代码：

```{language}
{code}

请从以下方面进行评估：

1. 代码质量
2. 性能
3. 安全性
4. 可维护性
5. 最佳实践

请提供评分（1-10）和详细建议。"""

    response = self.client.chat.completions.create(
        model=self.model,
        messages=[
            {"role": "system", "content": "你是一个代码审查专家。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.3
    )
    
    result = response.choices[0].message.content
    return self._parse_review(result)

def _parse_review(self, result: str) -> Dict:
    """解析审查结果"""
    import re
    
    # 提取分数
    score_match = re.search(r'(\d+(?:\.\d+)?)\s*[/／]\s*10', result)
    score = float(score_match.group(1)) if score_match else 7.0
    
    return {
        "score": score,
        "review": result,
        "passed": score >= 7.0
    }

## 完整工作流

```python
class CodeDevelopmentWorkflow:
    """代码开发工作流"""
    
    def __init__(self):
        self.generator = CodeGenerator()
        self.completer = CodeCompleter()
        self.explainer = CodeExplainer()
        self.reviewer = CodeReviewer()
    
    def develop_feature(self, description: str, language: str) -> Dict:
        """开发功能"""
        # 1. 生成代码
        request = CodeGenerationRequest(
            description=description,
            language=language,
            requirements=["代码简洁", "有注释", "处理异常"]
        )
        gen_result = self.generator.generate_code(request)
        
        # 2. 解释代码
        explanation = self.explainer.explain_code(gen_result.code, language)
        
        # 3. 审查代码
        review = self.reviewer.review_code(gen_result.code, language)
        
        # 4. 如果审查不通过，改进代码
        if not review["passed"]:
            improved_code = self._improve_code(gen_result.code, language, review["review"])
        else:
            improved_code = gen_result.code
        
        return {
            "code": improved_code,
            "explanation": explanation,
            "review": review,
            "dependencies": gen_result.dependencies
        }
    
    def _improve_code(self, code: str, language: str, review_feedback: str) -> str:
        """改进代码"""
        prompt = f"""请根据以下反馈改进代码：

原始代码：
```{language}
{code}

审查反馈： {review_feedback}

请提供改进后的完整代码。"""

    response = self.client.chat.completions.create(
        model=self.model,
        messages=[
            {"role": "system", "content": "你是一个代码优化专家。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.3
    )
    
    result = response.choices[0].message.content
    import re
    code_match = re.search(rf'```(?:{language})?\n(.*?)```', result, re.DOTALL)
    
    return code_match.group(1).strip() if code_match else result

使用示例

workflow = CodeDevelopmentWorkflow() result = workflow.develop_feature("创建一个计算斐波那契数列的函数", "python")

print("生成的代码:") print(result["code"]) print("\n代码审查:") print(f"分数: {result['review']['score']}/10")

## 最佳实践

1. **明确需求**：提供清晰的功能描述
2. **迭代改进**：根据审查结果迭代改进代码
3. **测试验证**：生成的代码需要测试验证
4. **安全审查**：确保代码安全性

## 总结

LLM代码生成是提高开发效率的强大工具。通过代码生成、补全、转换和分析，可以显著加速软件开发过程。