Python range 函数的自定义实现与常见陷阱解析

numList = [] # 全局变量
def myRange(start, stop=None, step=None):
    # ... 函数逻辑 ...
    numList.append(...)
    return numList

def myRange(start, stop=None, step=None):
    if stop == None and step == None:
        start, stop, step = 0, start, 1
        # ...
    elif start < stop and step == None:
        start, stop, step = start, stop, start # 错误：这里将step设为start
        # ...
    # ...

def myRange(start, stop=None, step=1): # step默认值为1
    if stop is None: # 处理只提供一个参数的情况
        start, stop = 0, start
    # ...

    elif start > stop and step == None:
        start, stop, step = start, stop, start # 错误：这里将step设为start
        while start >= stop: # 错误：循环条件和内部变量更新不匹配
            numList.append(step)
            step -= 1

def myRange(start, stop=None, step=1):
    """
    自定义实现类似于Python内置range函数的myRange。
    该函数返回一个列表，而不是一个range对象。

    参数:
    start -- 序列的起始值。如果只提供一个参数，则此参数为stop，start默认为0。
    stop -- 序列的结束值（不包含）。
    step -- 序列的步长，默认为1。不能为0。
    """
    # 1. 处理只有一个参数的情况：将其视为stop，start默认为0
    if stop is None:
        start, stop = 0, start

    # 2. 处理步长为0的非法情况
    if step == 0:
        raise ValueError("myRange() step cannot be zero")

    result = [] # 3. 使用局部列表存储结果

    # 4. 根据步长的正负确定循环条件
    if step > 0:
        # 当步长为正时，只要start小于stop就继续
        while start < stop:
            result.append(start)
            start += step # 更新start
    else: # step < 0
        # 当步长为负时，只要start大于stop就继续
        while start > stop:
            result.append(start)
            start += step # 更新start (因为step是负数，所以start会递减)

    return result

# 1. 只有一个参数：myRange(stop) -> 0 到 stop-1
print(f"myRange(5): {myRange(5)}") # 预期: [0, 1, 2, 3, 4]
print(f"range(5) (list): {list(range(5))}\n")

# 2. 两个参数：myRange(start, stop) -> start 到 stop-1
print(f"myRange(2, 7): {myRange(2, 7)}") # 预期: [2, 3, 4, 5, 6]
print(f"range(2, 7) (list): {list(range(2, 7))}\n")

# 3. 三个参数：myRange(start, stop, step) -> start 到 stop (不包含), 步长为step
print(f"myRange(1, 10, 2): {myRange(1, 10, 2)}") # 预期: [1, 3, 5, 7, 9]
print(f"range(1, 10, 2) (list): {list(range(1, 10, 2))}\n")

# 4. 负数步长：递减序列
print(f"myRange(10, 0, -2): {myRange(10, 0, -2)}") # 预期: [10, 8, 6, 4, 2]
print(f"range(10, 0, -2) (list): {list(range(10, 0, -2))}\n")

# 5. start >= stop 且 step > 0，返回空列表
print(f"myRange(5, 5): {myRange(5, 5)}") # 预期: []
print(f"range(5, 5) (list): {list(range(5, 5))}\n")
print(f"myRange(10, 5): {myRange(10, 5)}") # 预期: []
print(f"range(10, 5) (list): {list(range(10, 5))}\n")

# 6. start <= stop 且 step < 0，返回空列表
print(f"myRange(5, 10, -1): {myRange(5, 10, -1)}") # 预期: []
print(f"range(5, 10, -1) (list): {list(range(5, 10, -1))}\n")

# 7. 步长为0，抛出 ValueError
try:
    print(f"myRange(1, 5, 0): {myRange(1, 5, 0)}")
except ValueError as e:
    print(f"Caught expected error: {e}\n")

# 8. 验证局部列表行为
list1 = myRange(3)
list2 = myRange(4)
print(f"list1: {list1}") # 预期: [0, 1, 2]
print(f"list2: {list2}") # 预期: [0, 1, 2, 3]
print(f"list1 is list2: {list1 is list2}") # 预期: False (验证是不同的列表对象)