Python 内置函数 range、repr、reversed、round 用法详解

1.2 实际应用：循环控制和序列生成

class RangeUtils:
    @staticmethod
    def generate_sequence(start, stop, step=1):
        """生成自定义序列"""
        return list(range(start, stop, step))

    @staticmethod
    def create_index_pairs(length):
        """创建索引对"""
        return [(i, length - i - 1) for i in range(length // 2)]

    @staticmethod
    def batch_process(data, batch_size):
        """批量处理数据"""
        for i in range(0, len(data), batch_size):
            batch = data[i:i + batch_size]
            yield batch

# 使用示例
utils = RangeUtils()
# 生成序列
even_numbers = utils.generate_sequence(0, 10, 2)
print(f"偶数序列：{even_numbers}")

# 创建索引对
pairs = utils.create_index_pairs(6)
print(f"索引对：{pairs}")

# 批量处理
data = [1, 2, 3, 4, 5, 6, 7, 8]
batches = list(utils.batch_process(data, 3))
print(f"批次处理：{batches}")

# 常见 range 用法
print("range 在循环中的应用:")
for i in range(3):
    print(f"第{i+1}次循环")

# 生成递减序列
countdown = list(range(5, 0, -1))
print(f"倒计时：{countdown}")

二、repr()：对象表示的"身份证"

2.1 基础用法：获取对象的可打印表示

repr() 函数返回对象的官方字符串表示，通常可以用于重新创建该对象。

# 基本数据类型
print(f"字符串 repr: {repr('hello')}")  # 输出：'hello'
print(f"整数 repr: {repr(42)}")  # 输出：42
print(f"列表 repr: {repr([1, 2, 3])}")  # 输出：[1, 2, 3]

# 特殊字符处理
text = "hello\nworld"
print(f"原始字符串：{text}")
print(f"repr 表示：{repr(text)}")  # 输出：'hello\nworld'

# 与 str() 的区别
data = "hello"
print(f"str(): {str(data)}")  # 输出：hello
print(f"repr(): {repr(data)}")  # 输出：'hello'

# 自定义对象
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

p = Person("张三", 25)
print(f"Person 对象 repr: {repr(p)}")  # 输出：Person('张三', 25)

2.2 实际应用：调试和对象序列化

class DebugHelper:
    @staticmethod
    def inspect_object(obj):
        """检查对象的详细信息"""
        return {
            'type': type(obj).__name__,
            'repr': repr(obj),
            'str': str(obj),
            'id': id(obj)
        }

    @staticmethod
    def safe_repr(obj, max_length=100):
        """安全的 repr 表示，限制长度"""
        repr_str = repr(obj)
        if len(repr_str) > max_length:
            return repr_str[:max_length] + '...'
        return repr_str

    @staticmethod
    def compare_representations(*objects):
        """比较多个对象的表示形式"""
        comparisons = []
        for obj in objects:
            comparisons.append({
                'object': obj,
                'repr': repr(obj),
                'str': str(obj)
            })
        return comparisons

# 使用示例
helper = DebugHelper()
# 对象检查
sample_data = [1, "hello", [1, 2, 3], {'key': 'value'}]
for item in sample_data:
    info = helper.inspect_object(item)
    print(f"{info['type']}: {info['repr']}")

# 安全 repr
long_text = "a" * 150
short_repr = helper.safe_repr(long_text, 50)
print(f"长文本 repr: {short_repr}")

# 自定义类的 repr
class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def __repr__(self):
        return f"Product(name='{self.name}', price={self.price}, quantity={self.quantity})"

    def __str__(self):
        return f"{self.name} - ${self.price}"

product = Product("笔记本电脑", 5999, 10)
print(f"产品 repr: {repr(product)}")  # 详细表示
print(f"产品 str: {str(product)}")  # 简洁表示

三、reversed()：反向迭代的"时光机"

3.1 基础用法：创建反向迭代器

reversed() 函数返回一个反向的迭代器，用于逆序访问序列元素。

# 列表反向
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(f"原始列表：{numbers}")
print(f"反向列表：{reversed_numbers}")

# 字符串反向
text = "hello"
reversed_text = ''.join(reversed(text))
print(f"原始字符串：{text}")
print(f"反向字符串：{reversed_text}")

# 元组反向
tuple_data = (10, 20, 30)
reversed_tuple = tuple(reversed(tuple_data))
print(f"原始元组：{tuple_data}")
print(f"反向元组：{reversed_tuple}")

# 直接使用迭代器
for char in reversed("Python"):
    print(char, end=" ")  # 输出：n o h t y P

3.2 实际应用：数据反转和回文检测

class ReversalUtils:
    @staticmethod
    def reverse_data_structure(data):
        """反转各种数据结构"""
        if isinstance(data, (list, tuple, str)):
            return type(data)(reversed(data))
        else:
            raise TypeError("不支持的数据类型")

    @staticmethod
    def is_palindrome(text):
        """检查是否为回文"""
        cleaned = ''.join(c.lower() for c in text if c.isalnum())
        return cleaned == ''.join(reversed(cleaned))

    @staticmethod
    def process_in_reverse(data, process_func):
        """反向处理数据"""
        return [process_func(item) for item in reversed(data)]

    @staticmethod
    def get_last_n_items(data, n):
        """获取最后 n 个元素（使用反向）"""
        return list(reversed(list(reversed(data))[:n]))

# 使用示例
utils = ReversalUtils()
# 数据结构反转
original_list = [1, 2, 3, 4, 5]
reversed_list = utils.reverse_data_structure(original_list)
print(f"列表反转：{original_list} -> {reversed_list}")

# 回文检测
test_texts = ["racecar", "hello", "A man a plan a canal Panama"]
for text in test_texts:
    result = utils.is_palindrome(text)
    print(f"'{text}' 是回文：{result}")

# 反向处理
numbers = [1, 2, 3, 4, 5]
squared_reverse = utils.process_in_reverse(numbers, lambda x: x ** 2)
print(f"反向平方：{squared_reverse}")

# 获取最后几个元素
data = [10, 20, 30, 40, 50]
last_three = utils.get_last_n_items(data, 3)
print(f"最后三个元素：{last_three}")

四、round()：数值舍入的"精确尺"

4.1 基础用法：数值四舍五入

round() 函数用于对数值进行四舍五入，支持指定小数位数。

# 基本舍入
print(f"round(3.14159): {round(3.14159)}")  # 输出：3
print(f"round(3.14159, 2): {round(3.14159, 2)}")  # 输出：3.14

# 银行家舍入（向偶数舍入）
print(f"round(0.5): {round(0.5)}")  # 输出：0
print(f"round(1.5): {round(1.5)}")  # 输出：2
print(f"round(2.5): {round(2.5)}")  # 输出：2

# 负小数位数
print(f"round(1234, -2): {round(1234, -2)}")  # 输出：1200
print(f"round(5678, -3): {round(5678, -3)}")  # 输出：6000

# 浮点数精度问题
print(f"round(2.675, 2): {round(2.675, 2)}")  # 输出：2.67（不是 2.68）

# 整数舍入
print(f"round(10): {round(10)}")  # 输出：10
print(f"round(10, 1): {round(10, 1)}")  # 输出：10.0

4.2 实际应用：财务计算和数据显示

class RoundingUtils:
    @staticmethod
    def financial_round(value, decimals=2):
        """财务舍入（处理货币）"""
        return round(value, decimals)

    @staticmethod
    def percentage_display(value, decimals=1):
        """百分比显示格式化"""
        return f"{round(value * 100, decimals)}%"

    @staticmethod
    def significant_figures(number, figures=3):
        """有效数字舍入"""
        if number == 0:
            return 0
        import math
        magnitude = math.floor(math.log10(abs(number)))
        return round(number, figures - magnitude - 1)

    @staticmethod
    def safe_round(value, decimals=None, default=0):
        """安全舍入（处理异常）"""
        try:
            if decimals is None:
                return round(value)
            else:
                return round(value, decimals)
        except (TypeError, ValueError):
            return default

# 使用示例
utils = RoundingUtils()
# 财务计算
prices = [19.999, 29.495, 49.985]
rounded_prices = [utils.financial_round(price) for price in prices]
print(f"价格舍入：{prices} -> {rounded_prices}")

# 百分比显示
ratios = [0.1234, 0.5678, 0.9876]
percentages = [utils.percentage_display(ratio) for ratio in ratios]
print(f"百分比显示：{percentages}")

# 有效数字
scientific_numbers = [1234.567, 0.00012345, 98765.4321]
sig_figs = [utils.significant_figures(num, 3) for num in scientific_numbers]
print(f"有效数字：{sig_figs}")

# 安全舍入
test_values = [3.14159, "invalid", None, 2.71828]
for val in test_values:
    result = utils.safe_round(val, 2, "N/A")
    print(f"安全舍入 {val}: {result}")

五、组合应用示例

5.1 数据分析工具

class DataAnalyzer:
    def __init__(self, data):
        self.data = data

    def summarize(self):
        """数据摘要统计"""
        if not self.data:
            return "无数据"
        return {
            'length': len(self.data),
            'first': self.data[0] if self.data else None,
            'last': self.data[-1] if self.data else None,
            'reversed_sample': list(reversed(self.data))[:3],
            'repr_sample': repr(self.data[:3]) + '...' if len(self.data) > 3 else repr(self.data)
        }

    def generate_report(self, decimal_places=2):
        """生成数据分析报告"""
        if not self.data or not all(isinstance(x, (int, float)) for x in self.data):
            return "无法生成数值报告"
        numeric_data = [float(x) for x in self.data]
        return {
            'count': len(numeric_data),
            'sum': round(sum(numeric_data), decimal_places),
            'average': round(sum(numeric_data) / len(numeric_data), decimal_places),
            'min': round(min(numeric_data), decimal_places),
            'max': round(max(numeric_data), decimal_places),
            'range_sequence': list(range(len(numeric_data))),
            'reversed_values': [round(x, decimal_places) for x in reversed(numeric_data)]
        }

# 使用示例
analyzer = DataAnalyzer([10.123, 20.456, 30.789, 40.111])
summary = analyzer.summarize()
print("数据摘要:")
for key, value in summary.items():
    print(f" {key}: {value}")
report = analyzer.generate_report(1)
print("\n数值报告:")
for key, value in report.items():
    print(f" {key}: {value}")

5.2 实用工具函数

def create_number_sequence(start, end, step=1, precision=2):
    """创建精确的数字序列"""
    return [round(x, precision) for x in range(start, end, step)]

def format_data_for_display(data, max_display=5):
    """格式化数据用于显示"""
    if len(data) > max_display:
        display_data = data[:max_display]
        return f"{repr(display_data)}... 和 {len(data) - max_display} 更多项"
    return repr(data)

def process_data_pipeline(data):
    """数据处理管道：反向→处理→舍入"""
    # 反向处理
    reversed_data = list(reversed(data))
    # 数值处理（平方）
    processed = [x ** 2 for x in reversed_data if isinstance(x, (int, float))]
    # 舍入
    rounded = [round(x, 2) for x in processed]
    return {
        'original': data,
        'reversed': reversed_data,
        'processed': processed,
        'rounded': rounded
    }

# 使用示例
print("=== 实用工具演示 ===")
# 数字序列
sequence = create_number_sequence(1, 5, 0.5)
print(f"数字序列：{sequence}")

# 数据显示
large_data = list(range(10))
display_str = format_data_for_display(large_data, 3)
print(f"数据显示：{display_str}")

# 数据处理管道
test_data = [1.234, 2.567, 3.891, 4.123]
pipeline_result = process_data_pipeline(test_data)
print("数据处理管道:")
for stage, result in pipeline_result.items():
    print(f" {stage}: {result}")

六、总结与实用建议

通过本文的详细解析，我们深入了解了 Python 中四个重要的内置功能：

1. range(start, stop, step) - 序列生成的数字工厂
2. repr(object) - 对象表示的身份证
3. reversed(sequence) - 反向迭代的时光机
4. round(number, ndigits) - 数值舍入的精确尺

关键知识点总结：

• range() 生成惰性序列，节省内存
• repr() 返回可 eval 的字符串表示，str() 返回用户友好表示
• reversed() 返回迭代器，支持各种序列类型
• round() 使用银行家舍入规则，注意浮点数精度问题

实用场景推荐：

• range()：循环控制、序列生成、数值计算
• repr()：调试输出、日志记录、对象序列化
• reversed()：数据反转、回文检测、反向处理
• round()：财务计算、数据显示、科学计算

最佳实践建议：

1. 合理使用 range：大数据集时使用 range() 避免内存浪费
2. 区分 repr 和 str：调试用 repr()，显示用 str()
3. 掌握反向迭代：reversed() 比切片 [::-1] 更节省内存
4. 理解舍入规则：财务计算要特别注意银行家舍入

注意事项：

• range() 的参数必须是整数
• repr() 可能暴露敏感信息，生产环境慎用
• reversed() 不改变原序列，返回新迭代器
• round() 的浮点数精度问题需要特别注意

进阶学习方向：

• 深入学习生成器表达式和 xrange()（Python 2）
• 研究 __repr__() 和 __str__() 的特殊方法
• 了解迭代器协议和自定义迭代器
• 探索 decimal 模块进行精确小数计算

这四个功能是 Python 编程的基础工具，从简单的循环控制到复杂的数据处理，它们为各种编程场景提供了强大的支持。掌握它们能够帮助你编写出更加高效、健壮的 Python 代码。