空行在代码中的重要性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ❌ 错误示例 - 缺少适当的空行会影响可读性
def function1():
    return "Hello"
def function2():
    return "World"
class MyClass:
    def method1(self):
        pass
    def method2(self):
        pass

# ✅ 正确示例 - 使用空行分隔
def function1():
    return "Hello"

def function2():
    return "World"

class MyClass:
    def method1(self):
        pass
    
    def method2(self):
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# ❌ 没有空行的代码 - 难以阅读
def process_data(data):
    cleaned_data = []
    for item in data:
        if item is not None:
            cleaned_data.append(item.strip())
    result = []
    for item in cleaned_data:
        if len(item) > 0:
            result.append(item.upper())
    final_count = len(result)
    print(f"Processed {final_count} items")
    return result

# ✅ 使用空行分组的代码 - 清晰易读
def process_data(data):
    # 数据清洗阶段
    cleaned_data = []
    for item in data:
        if item is not None:
            cleaned_data.append(item.strip())
    
    # 数据处理阶段
    result = []
    for item in cleaned_data:
        if len(item) > 0:
            result.append(item.upper())
    
    # 结果统计和返回
    final_count = len(result)
    print(f"Processed {final_count} items")
    return result

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class DataProcessor:
    """数据处理器类"""
    
    def __init__(self, config):
        self.config = config
        self.data = []
    
    # 数据输入方法
    def load_data(self, source):
        """加载数据"""
        pass
    
    def validate_data(self):
        """验证数据"""
        pass
    
    # 数据处理方法
    def clean_data(self):
        """清洗数据"""
        pass
    
    def transform_data(self):
        """转换数据"""
        pass
    
    # 输出方法
    def save_data(self, destination):
        """保存数据"""
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# ✅ 遵循 PEP 8 规范
import os
import sys


GLOBAL_CONSTANT = "value"


def utility_function():
    """工具函数"""
    pass


class FirstClass:
    """第一个类"""
    
    def __init__(self):
        pass
    
    def method1(self):
        pass


class SecondClass:
    """第二个类"""
    
    def __init__(self):
        pass


if __name__ == "__main__":
    # 主程序逻辑
    first = FirstClass()
    second = SecondClass()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
模块说明文档
"""

import os
import sys
from typing import List, Dict

# 第三方库导入
import requests
import pandas as pd

# 本地模块导入
from .utils import helper_function
from .config import settings


# 全局常量
DEFAULT_TIMEOUT = 30
API_VERSION = "v1"


# 全局变量
_cache = {}


def public_function():
    """公共函数"""
    pass


def _private_function():
    """私有函数"""
    pass


class MainClass:
    """主要类"""
    
    def __init__(self):
        self.data = []
    
    def public_method(self):
        """公共方法"""
        # 方法内的逻辑分组
        setup_data = self._prepare_data()
        
        processed_data = self._process_data(setup_data)
        
        return self._format_result(processed_data)
    
    def _prepare_data(self):
        """准备数据"""
        pass
    
    def _process_data(self, data):
        """处理数据"""
        pass
    
    def _format_result(self, data):
        """格式化结果"""
        pass


if __name__ == "__main__":
    main = MainClass()
    result = main.public_method()
    print(result)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

def analyze_sales_data(sales_records):
    """分析销售数据的完整示例"""
    
    # 输入验证
    if not sales_records:
        raise ValueError("销售记录不能为空")
    
    if not isinstance(sales_records, list):
        raise TypeError("销售记录必须是列表格式")
    
    # 数据预处理
    valid_records = []
    for record in sales_records:
        if record.get('amount', 0) > 0:
            valid_records.append(record)
    
    # 统计计算
    total_sales = sum(record['amount'] for record in valid_records)
    avg_sales = total_sales / len(valid_records) if valid_records else 0
    
    max_sale = max(valid_records, key=lambda x: x['amount']) if valid_records else None
    min_sale = min(valid_records, key=lambda x: x['amount']) if valid_records else None
    
    # 结果整理
    analysis_result = {
        'total_records': len(valid_records),
        'total_sales': total_sales,
        'average_sales': avg_sales,
        'highest_sale': max_sale,
        'lowest_sale': min_sale
    }
    
    # 日志记录
    print(f"分析完成：处理了 {len(valid_records)} 条记录")
    print(f"总销售额：{total_sales}")
    
    return analysis_result