Python列表元素修改之直接赋值与切片赋值方法详解

# 创建列表的多种方式
empty_list = []  # 空列表
number_list = [1, 2, 3, 4, 5]  # 数字列表
mixed_list = [10, "Python", 3.14, True, [1, 2]]  # 混合类型列表

# 列表的关键特性
print(isinstance(number_list, list))  # 输出: True
print(id(number_list))  # 查看内存地址（每次运行不同）
number_list.append(6)   # 修改列表
print(id(number_list))  # 内存地址不变！证明列表是可变的

my_list[index] = new_value

fruits = ["apple", "banana", "cherry", "date"]
print("原始列表:", fruits)  # ['apple', 'banana', 'cherry', 'date']

# 修改索引1处的元素（第二个元素）
fruits[1] = "blueberry"
print("修改后:", fruits)  # ['apple', 'blueberry', 'cherry', 'date']

# 修改索引-1处的元素（最后一个元素）
fruits[-1] = "dragonfruit"
print("再次修改:", fruits)  # ['apple', 'blueberry', 'cherry', 'dragonfruit']

numbers = [10, 20, 30, 40, 50]
numbers[-1] = 99  # 修改最后一个元素
numbers[-2] = 88  # 修改倒数第二个元素
print(numbers)  # [10, 20, 30, 88, 99]

colors = ["red", "green"]
colors[2] = "blue"  # 抛出 IndexError: list assignment index out of range

matrix = [[1, 2], [3, 4]]
matrix[0][0] = 99
print(matrix)  # [[99, 2], [3, 4]] → 预期结果

# 但注意这个陷阱：
row = [0, 0]
grid = [row, row]  # 两个元素引用同一个列表对象
grid[0][0] = 5
print(grid)  # [[5, 0], [5, 0]] → 意外修改了两个位置！

grid = [[0, 0] for _ in range(2)]  # 正确创建独立子列表

data = [10, 20, 30]
index = 1.5
data[index] = 25  # 抛出 TypeError: list indices must be integers or slices, not float

import timeit

# 测试大列表修改
large_list = list(range(10**6))
time = timeit.timeit('large_list[500000] = 999', 
                     globals=globals(), 
                     number=10000)
print(f"修改100万元素列表的中间元素1万次耗时: {time:.4f}秒")
# 典型输出: 0.0012秒 → 证明效率极高

my_list[start:stop:step] = iterable

letters = ['a', 'b', 'c', 'd', 'e', 'f']

# 案例1: 等长替换（最常见）
letters[1:4] = ['B', 'C', 'D']
print(letters)  # ['a', 'B', 'C', 'D', 'e', 'f']

# 案例2: 用更短序列替换 → 删除元素
letters[2:4] = ['X']
print(letters)  # ['a', 'B', 'X', 'e', 'f'] → 'C','D'被移除

# 案例3: 用更长序列替换 → 插入元素
letters[1:2] = ['Y', 'Z']
print(letters)  # ['a', 'Y', 'Z', 'X', 'e', 'f'] → 在'B'位置插入两个元素

# 案例4: 用字符串替换（字符串是可迭代对象！）
letters[3:5] = "MN"
print(letters)  # ['a', 'Y', 'Z', 'M', 'N', 'f'] → 'X','e'被替换

data = [1, 2, 3, 4]
data[:] = []  # 等效于 data.clear()
print(data)  # []

original = [1, 2, 3]
copy_ref = original  # 复制引用（非内容）

# 方式A: data = []
original = []  # 创建新空列表
print(copy_ref)  # 仍为 [1,2,3] → 引用未更新！

# 方式B: data[:] = []
original[:] = []
print(copy_ref)  # [] → 所有引用同步更新

numbers = [10, 20, 50, 60]

# 在索引2前插入 [30, 40]
numbers[2:2] = [30, 40]  # 注意：切片长度为0（start=stop）
print(numbers)  # [10, 20, 30, 40, 50, 60]

# 在开头插入
numbers[:0] = [5]
print(numbers)  # [5, 10, 20, 30, 40, 50, 60]

# 在结尾插入
numbers[len(numbers):] = [70]
print(numbers)  # [5, 10, 20, 30, 40, 50, 60, 70]

chars = ['a', 'b', 'c', 'd', 'e']
del chars[1:4]  # 等效于 chars[1:4] = []
print(chars)  # ['a', 'e']

items = [1, 2, 3, 4, 5, 6]
items[1:5] = items[4:0:-1]  # 将索引1-4的元素反转
print(items)  # [1, 5, 4, 3, 2, 6]

test = [0, 1, 2, 3]
test[3:1] = ['X']  # 空切片（start > stop）
print(test)  # [0, 1, 2, 'X', 3] → 'X'插入在索引3后

nums = [0, 1, 2, 3, 4, 5, 6]
nums[::2] = ['A', 'B', 'C', 'D']  # 替换所有偶数索引
print(nums)  # ['A', 1, 'B', 3, 'C', 5, 'D']

# 但注意：带步长的切片赋值有严格限制！
try:
    nums[::2] = ['X', 'Y']  # 新值长度必须匹配原切片长度
except ValueError as e:
    print("错误:", e)  # 提示: attempt to assign sequence of size 2 to extended slice of size 4

import timeit

# 测试变长替换
large_list = list(range(10000))

# 插入操作（在开头插入100个元素）
insert_time = timeit.timeit(
    'large_list[:0] = range(100)', 
    globals=globals(), 
    number=100
)

# 等长替换（中间100个元素）
replace_time = timeit.timeit(
    'large_list[4950:5050] = [99]*100', 
    globals=globals(), 
    number=1000
)

print(f"开头插入100元素100次: {insert_time:.4f}秒")
print(f"中间替换100元素1000次: {replace_time:.4f}秒")
# 典型输出:
# 开头插入100元素100次: 0.0015秒
# 中间替换100元素1000次: 0.0008秒

# 实时更新传感器读数
sensor_readings[latest_index] = new_reading

# 修改字典中的列表元素
user_data["history"][0] = "updated_value"

# 用新数据块替换旧数据
data_buffer[100:200] = new_chunk

# 删除无效数据段
log_entries[error_start:error_end] = []

# 在文本处理中插入字符串
text_chars[5:5] = list("INSERTED")

def clean_sensor_data(raw_data):
    """清洗传感器数据：修正异常值并填充缺失"""
    # 步骤1: 用直接赋值修正单个异常点
    for i, value in enumerate(raw_data):
        if value < 0:  # 无效负值
            raw_data[i] = 0  # 直接赋值修正
    
    # 步骤2: 用切片赋值填充缺失段（假设缺失段为连续0）
    i = 0
    while i < len(raw_data):
        if raw_data[i] == 0:
            start = i
            # 找到连续0的结束位置
            while i < len(raw_data) and raw_data[i] == 0:
                i += 1
            end = i
            
            # 用线性插值填充（简化版）
            if start > 0 and end < len(raw_data):
                gap = end - start
                step = (raw_data[end] - raw_data[start-1]) / (gap + 1)
                # 生成插值序列
                interpolated = [raw_data[start-1] + step * (j+1) 
                               for j in range(gap)]
                raw_data[start:end] = interpolated  # 切片赋值
        else:
            i += 1
    
    return raw_data

# 测试
data = [10, 20, 0, 0, 0, 50, 60, 0, 0, 90]
cleaned = clean_sensor_data(data.copy())
print("原始数据:", data)
print("清洗后:", cleaned)
# 输出: [10, 20, 30.0, 40.0, 50, 50, 60, 70.0, 80.0, 90]

# 字符串是可迭代的，但元素是字符（不可变）
text = ['h', 'e', 'l', 'l', 'o']
text[1:4] = "ELE"  # 成功：['h', 'E', 'L', 'E', 'o']

# 但尝试修改字符串本身会失败
s = "hello"
try:
    s[1] = "a"  # TypeError: 'str' object does not support item assignment
except TypeError as e:
    print("字符串不可变:", e)

# 元组同理（不可变）
t = (1, 2, 3)
try:
    t[0] = 99  # TypeError: 'tuple' object does not support item assignment
except TypeError as e:
    print("元组不可变:", e)

class CustomList:
    def __init__(self, data):
        self.data = data
    
    def __setitem__(self, index, value):
        print(f"设置索引 {index} 为 {value}")
        self.data[index] = value
    
    def __getitem__(self, index):
        return self.data[index]

c_list = CustomList([1, 2, 3])
c_list[1] = 99  # 触发 __setitem__ (index=1, value=99)
c_list[0:2] = [5, 6]  # 触发 __setitem__ (index=slice(0,2,None), value=[5,6])

original = [1,2,3]
print("修改前ID:", id(original))
original[1:2] = [9]
print("修改后ID:", id(original))  # ID相同！

arr = [1,2,3]
arr[0:2] = [10]  # 用1个元素替换2个元素 → 有效
print(arr)  # [10, 3]

lst = [1,2]
try:
    lst[2] = 3  # IndexError
except IndexError:
    lst.insert(2, 3)  # 正确插入方式

if 0 <= start < len(my_list) and start <= stop:
    my_list[start:stop] = new_values

# 错误：new_grid = [row] * 3
new_grid = [[x for x in row] for row in original_grid]  # 正确深拷贝

class TextEditor:
    def __init__(self):
        self.content = []  # 用字符列表表示文本
        self.history = []  # 存储历史状态
    
    def insert(self, position, text):
        self.history.append(self.content[:])  # 保存快照
        self.content[position:position] = list(text)  # 切片赋值插入
    
    def delete(self, start, end):
        self.history.append(self.content[:])
        self.content[start:end] = []  # 切片赋值删除
    
    def undo(self):
        if self.history:
            self.content = self.history.pop()

# 使用示例
editor = TextEditor()
editor.insert(0, "Hello")
editor.insert(5, " World")
print("当前文本:", ''.join(editor.content))  # "Hello World"
editor.undo()
print("撤销后:", ''.join(editor.content))    # "Hello"

class DataWindow:
    def __init__(self, size):
        self.window = [0.0] * size  # 初始化窗口
    
    def update(self, new_value):
        # 左移窗口：丢弃最旧值，添加新值
        self.window[:-1] = self.window[1:]  # 切片赋值移动数据
        self.window[-1] = new_value         # 直接赋值添加新值
    
    def average(self):
        return sum(self.window) / len(self.window)

# 模拟传感器数据流
sensor = DataWindow(5)
for value in [10, 20, 30, 40, 50, 60, 70]:
    sensor.update(value)
    print(f"添加 {value} → 当前平均: {sensor.average():.1f}")

# 输出:
# 添加 10 → 当前平均: 2.0  (初始[0,0,0,0,10])
# 添加 20 → 当前平均: 6.0
# ...
# 添加 70 → 当前平均: 50.0 ([30,40,50,60,70])

def flip_horizontal(pixels):
    """水平翻转图像（像素矩阵）"""
    for row in pixels:
        # 整行翻转：用切片赋值反转行
        row[:] = row[::-1]  # 关键操作！

# 示例：3x3像素矩阵
image = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

flip_horizontal(image)
print("翻转后:")
for row in image:
    print(row)
# 输出:
# [3, 2, 1]
# [6, 5, 4]
# [9, 8, 7]

# 旧代码（低效）
for i in range(3, 6):
    my_list[i] = 0

# 新代码（高效）
my_list[3:6] = [0, 0, 0]