Python 内置函数系列:r开头系列函数

range()：序列生成的"数字工厂"

1. 基础用法：创建不可变数字序列

range()函数用于生成不可变的数字序列，支持三种调用方式。

# 方式1：只指定结束值（从0开始）
r1 = range(5)
print(f"range(5): {list(r1)}")  # 输出: [0, 1, 2, 3, 4]

# 方式2：指定开始和结束值
r2 = range(2, 8)
print(f"range(2, 8): {list(r2)}")  # 输出: [2, 3, 4, 5, 6, 7]

# 方式3：指定开始、结束和步长
r3 = range(1, 10, 2)
print(f"range(1, 10, 2): {list(r3)}")  # 输出: [1, 3, 5, 7, 9]

# 负步长（递减）
r4 = range(10, 0, -2)
print(f"range(10, 0, -2): {list(r4)}")  # 输出: [10, 8, 6, 4, 2]

# range对象的基本操作
r = range(3)
print(f"长度: {len(r)}")      # 输出: 3
print(f"包含检查: {2 in r}")  # 输出: True
print(f"索引访问: {r[1]}")    # 输出: 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()：对象表示的"身份证"

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. 实际应用：调试和对象序列化

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()：反向迭代的"时光机"

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

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()：数值舍入的"精确尺"

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

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}")

总结

本文详细解析了Python中四个重要的内置功能：

1. 1. range(start, stop, step) - 序列生成的数字工厂，循环控制、序列生成、数值计算
2. 2. repr(object) - 对象表示的身份证，调试输出、日志记录、对象序列化
3. 3. reversed(sequence) - 反向迭代的时光机，数据反转、回文检测、反向处理
4. 4. round(number, ndigits) - 数值舍入的精确尺，

最佳使用场景：

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

注意事项：

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