# 創(chuàng)建列表的多種方式
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)]  # 正確創(chuàng)建獨立子列表

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 = []  # 創(chuàng)建新空列表
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: 用切片賦值填充缺失段（假設缺失段為連續(xù)0）
    i = 0
    while i < len(raw_data):
        if raw_data[i] == 0:
            start = i
            # 找到連續(xù)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  # 觸發(fā) __setitem__ (index=1, value=99)
c_list[0:2] = [5, 6]  # 觸發(fā) __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 = []  # 存儲歷史狀態(tài)
    
    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]