# 錯誤示例1：列表的意外修改
def add_item(my_list, item):
    my_list.append(item)
    return my_list

original_list = [1, 2, 3]
new_list = add_item(original_list, 4)

print("Original list:", original_list)  # [1, 2, 3, 4]
print("New list:", new_list)           # [1, 2, 3, 4]
# 兩個列表都被修改了！

# 錯誤示例2：字符串"修改"的困惑
text = "hello"
text.upper()  # 初學(xué)者可能認(rèn)為這會修改text
print(text)   # 輸出仍然是"hello"，不是"HELLO"

# 正確做法1：創(chuàng)建列表的副本
def add_item_safe(my_list, item):
    new_list = my_list.copy()  # 或者使用 my_list[:]
    new_list.append(item)
    return new_list

original_list = [1, 2, 3]
new_list = add_item_safe(original_list, 4)

print("Original list:", original_list)  # [1, 2, 3]
print("New list:", new_list)           # [1, 2, 3, 4]

# 正確做法2：理解不可變對象的操作
text = "hello"
uppercase_text = text.upper()  # 創(chuàng)建新字符串
print("Original:", text)              # hello
print("Uppercase:", uppercase_text)   # HELLO

# 正確做法3：使用元組保護(hù)數(shù)據(jù)
coordinates = (10, 20)  # 不可變，不會被意外修改
# coordinates[0] = 5   # 這會報錯，防止意外修改

# 錯誤示例：使用可變對象作為默認(rèn)參數(shù)
def add_to_list(item, my_list=[]):  # 危險！默認(rèn)參數(shù)在定義時創(chuàng)建
    my_list.append(item)
    return my_list

# 第一次調(diào)用看起來正常
result1 = add_to_list(1)
print(result1)  # [1]

# 第二次調(diào)用出現(xiàn)問題！
result2 = add_to_list(2)
print(result2)  # [1, 2] 而不是期望的 [2]

# 正確做法1：使用None作為默認(rèn)值
def add_to_list_safe(item, my_list=None):
    if my_list is None:
        my_list = []  # 每次調(diào)用時創(chuàng)建新列表
    my_list.append(item)
    return my_list

result1 = add_to_list_safe(1)
print(result1)  # [1]

result2 = add_to_list_safe(2)
print(result2)  # [2] - 符合預(yù)期！

# 正確做法2：使用不可變默認(rèn)值
def greet(name, prefix="Hello"):
    return f"{prefix}, {name}!"

print(greet("Alice"))  # Hello, Alice!
print(greet("Bob", "Hi"))  # Hi, Bob!

# 錯誤示例1：在賦值前使用變量
count = 0

def increment():
    count += 1  # UnboundLocalError!
    return count

# 錯誤示例2：混淆局部和全局變量
x = 10

def confusing_function():
    print(x)  # 這能工作嗎？
    x = 5     # 這行導(dǎo)致問題
    
confusing_function()  # UnboundLocalError!

# 正確做法1：明確使用global關(guān)鍵字
count = 0

def increment():
    global count  # 明確聲明使用全局變量
    count += 1
    return count

print(increment())  # 1
print(increment())  # 2

# 正確做法2：避免使用全局變量，通過參數(shù)傳遞
def better_increment(current_count):
    return current_count + 1

count = 0
count = better_increment(count)
print(count)  # 1

# 正確做法3：使用返回值而不是修改全局狀態(tài)
def process_data(data):
    # 處理數(shù)據(jù)并返回結(jié)果，不修改輸入
    return [x * 2 for x in data]

original_data = [1, 2, 3]
new_data = process_data(original_data)
print("Original:", original_data)  # [1, 2, 3]
print("New:", new_data)           # [2, 4, 6]

# 錯誤示例1：在迭代時修改列表
numbers = [1, 2, 3, 4, 5]

for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # 危險！在迭代時修改列表

print(numbers)  # [1, 3, 5] - 但可能跳過一些元素

# 錯誤示例2：錯誤使用range和索引
fruits = ['apple', 'banana', 'cherry']

# 不必要的復(fù)雜方式
for i in range(len(fruits)):
    print(fruits[i])

# 錯誤示例3：無限循環(huán)
count = 0
while count < 5:
    print(count)
    # 忘記增加count，導(dǎo)致無限循環(huán)！

# 正確做法1：創(chuàng)建新列表而不是修改原列表
numbers = [1, 2, 3, 4, 5]

# 方法1：列表推導(dǎo)式
odd_numbers = [num for num in numbers if num % 2 != 0]
print(odd_numbers)  # [1, 3, 5]

# 方法2：迭代副本，修改原列表
numbers = [1, 2, 3, 4, 5]
for num in numbers[:]:  # 迭代副本
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # [1, 3, 5]

# 正確做法2：直接迭代元素
fruits = ['apple', 'banana', 'cherry']

# Pythonic的方式
for fruit in fruits:
    print(fruit)

# 如果需要索引，使用enumerate
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# 正確做法3：確保循環(huán)有明確的退出條件
count = 0
while count < 5:
    print(count)
    count += 1  # 重要：更新循環(huán)變量

# 錯誤示例1：錯誤使用is比較值
a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True - 值相等
print(a is b)  # False - 不是同一個對象

# 錯誤示例2：小整數(shù)的緩存陷阱
x = 256
y = 256
print(x is y)  # True - Python緩存小整數(shù)

x = 257
y = 257
print(x is y)  # False - 大整數(shù)不緩存

# 錯誤示例3：與None比較
value = None

# 錯誤的做法（但有時能工作）
if value is None:
    print("Value is None")

# 更糟的做法
if value == None:  # 不推薦
    print("Value is None")

# 正確做法1：理解使用場景
# 比較值是否相等 - 使用 ==
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print("list1 == list2:", list1 == list2)  # True - 值相等
print("list1 is list2:", list1 is list2)  # False - 不同對象
print("list1 is list3:", list1 is list3)  # True - 同一個對象

# 正確做法2：與單例對象比較使用is
# 與None, True, False比較時使用is
value = None

if value is None:  # 正確的方式
    print("Value is None")

if value is True:  # 而不是 value == True
    print("Value is True")

# 正確做法3：字符串駐留
str1 = "hello"
str2 = "hello"
str3 = "hell" + "o"

print("str1 is str2:", str1 is str2)  # True - 字符串駐留
print("str1 is str3:", str1 is str3)  # True - 編譯時優(yōu)化

# 但不要依賴這種行為！
str4 = "hell"
str5 = str4 + "o"
print("str1 is str5:", str1 is str5)  # False - 運行時創(chuàng)建

# 錯誤示例1：過于寬泛的異常捕獲
try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except:  # 捕獲所有異常 - 危險！
    print("Something went wrong")

# 錯誤示例2：靜默忽略異常
try:
    risky_operation()
except:
    pass  # 靜默忽略 - 非常危險！

# 錯誤示例3：不提供有用的錯誤信息
try:
    file = open("nonexistent.txt")
except FileNotFoundError:
    print("Error")  # 沒有有用的信息

# 正確做法1：具體捕獲預(yù)期的異常
try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except ValueError:
    print("Please enter a valid number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

# 正確做法2：提供有用的錯誤信息
try:
    with open("data.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("Error: data.txt file not found. Please check the file path.")
except PermissionError:
    print("Error: Permission denied. Check file permissions.")
except IOError as e:
    print(f"Error reading file: {e}")

# 正確做法3：使用else和finally
try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError as e:
    print(f"File not found: {e}")
else:
    # 只有在沒有異常時執(zhí)行
    print("File read successfully")
    print(f"Content length: {len(content)}")
finally:
    # 無論是否發(fā)生異常都執(zhí)行
    file.close()  # 確保資源被清理
    print("Cleanup completed")

# 更Pythonic的方式：使用上下文管理器
try:
    with open("data.txt", "r") as file:  # 自動處理文件關(guān)閉
        content = file.read()
except FileNotFoundError:
    print("File not found")
else:
    print("File processed successfully")

# 錯誤示例1：賦值不是拷貝
original = [[1, 2], [3, 4]]
assigned = original  # 這只是創(chuàng)建引用，不是拷貝

assigned[0][0] = 99
print("Original:", original)  # [[99, 2], [3, 4]] - 也被修改了！

# 錯誤示例2：淺拷貝的局限性
import copy

original = [[1, 2], [3, 4]]
shallow_copied = original.copy()  # 或 original[:]

shallow_copied.append([5, 6])  # 修改第一層沒問題
print("Original after append:", original)  # [[1, 2], [3, 4]]

shallow_copied[0][0] = 99  # 修改嵌套對象會影響原對象！
print("Original after nested modification:", original)  # [[99, 2], [3, 4]]

# 正確做法1：理解三種"拷貝"的區(qū)別
import copy

original = [[1, 2], [3, 4]]

# 1. 賦值 - 創(chuàng)建引用
assigned = original

# 2. 淺拷貝 - 只拷貝第一層
shallow_copied = copy.copy(original)  # 或 original.copy()

# 3. 深拷貝 - 遞歸拷貝所有層次
deep_copied = copy.deepcopy(original)

# 測試修改的影響
assigned[0][0] = "assigned"
shallow_copied[0][0] = "shallow"  
deep_copied[0][0] = "deep"

print("Original:", original)        # [['assigned', 2], [3, 4]]
print("Assigned:", assigned)        # [['assigned', 2], [3, 4]]
print("Shallow:", shallow_copied)   # [['shallow', 2], [3, 4]]
print("Deep:", deep_copied)         # [['deep', 2], [3, 4]]

# 正確做法2：根據(jù)需求選擇拷貝方式
# 情況1：只有一層結(jié)構(gòu)，使用淺拷貝
simple_list = [1, 2, 3, 4]
copied_list = simple_list.copy()  # 淺拷貝足夠
copied_list[0] = 99
print("Simple original:", simple_list)  # [1, 2, 3, 4] - 不受影響

# 情況2：嵌套結(jié)構(gòu)，使用深拷貝
nested_list = [[1, 2], [3, 4]]
deep_copied_list = copy.deepcopy(nested_list)
deep_copied_list[0][0] = 99
print("Nested original:", nested_list)  # [[1, 2], [3, 4]] - 不受影響

# 錯誤示例：意外共享的類變量
class Student:
    grades = []  # 類變量 - 所有實例共享！
    
    def __init__(self, name):
        self.name = name
    
    def add_grade(self, grade):
        self.grades.append(grade)  # 修改的是類變量！

# 測試
student1 = Student("Alice")
student2 = Student("Bob")

student1.add_grade(90)
student2.add_grade(85)

print("Alice's grades:", student1.grades)  # [90, 85]
print("Bob's grades:", student2.grades)    # [90, 85] - 意外共享！

# 正確做法1：正確使用實例變量
class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []  # 實例變量 - 每個實例獨有
    
    def add_grade(self, grade):
        self.grades.append(grade)

# 測試
student1 = Student("Alice")
student2 = Student("Bob")

student1.add_grade(90)
student2.add_grade(85)

print("Alice's grades:", student1.grades)  # [90]
print("Bob's grades:", student2.grades)    # [85] - 正確！

# 正確做法2：理解類變量的正確用途
class Circle:
    # 類變量 - 用于所有實例共享的常量或默認(rèn)值
    pi = 3.14159
    count = 0  # 跟蹤創(chuàng)建的實例數(shù)
    
    def __init__(self, radius):
        self.radius = radius  # 實例變量
        Circle.count += 1     # 通過類名訪問類變量
    
    def area(self):
        return Circle.pi * self.radius ** 2  # 使用類變量
    
    @classmethod
    def get_count(cls):
        return cls.count

# 使用
circle1 = Circle(5)
circle2 = Circle(3)

print("Circle 1 area:", circle1.area())  # 使用類變量pi
print("Circle 2 area:", circle2.area())
print("Total circles:", Circle.get_count())  # 2

# 錯誤示例：在循環(huán)中使用+拼接字符串
words = ["hello", "world", "python", "programming"]

# 低效的方式
result = ""
for word in words:
    result += word + " "  # 每次循環(huán)創(chuàng)建新字符串

print(result)

# 對于大量數(shù)據(jù)，這會非常慢！
large_list = ["word"] * 10000
result = ""
for word in large_list:  # 非常低效！
    result += word

# 正確做法1：使用join方法
words = ["hello", "world", "python", "programming"]

# 高效的方式
result = " ".join(words)
print(result)

# 正確做法2：使用列表推導(dǎo)式 + join
numbers = [1, 2, 3, 4, 5]
# 將數(shù)字轉(zhuǎn)換為字符串并拼接
result = ", ".join(str(num) for num in numbers)
print(result)  # "1, 2, 3, 4, 5"

# 正確做法3：使用f-string（Python 3.6+）
name = "Alice"
age = 25

# 現(xiàn)代Python的方式
message = f"My name is {name} and I'm {age} years old."
print(message)

# 正確做法4：使用字符串格式化
# 當(dāng)需要復(fù)雜格式化時
template = "Name: {}, Age: {}, Score: {:.2f}"
formatted = template.format("Bob", 30, 95.5678)
print(formatted)

# 性能對比
import time

# 低效方法
start_time = time.time()
result = ""
for i in range(10000):
    result += str(i)
end_time = time.time()
print(f"Using + operator: {end_time - start_time:.4f} seconds")

# 高效方法
start_time = time.time()
result = "".join(str(i) for i in range(10000))
end_time = time.time()
print(f"Using join: {end_time - start_time:.4f} seconds")

# 錯誤示例1：非Pythonic的循環(huán)
fruits = ["apple", "banana", "cherry"]

# C風(fēng)格循環(huán)
for i in range(len(fruits)):
    print(fruits[i])

# 錯誤示例2：不必要的復(fù)雜條件
if x > 0 and x < 10 and x != 5:  # 冗長
    pass

# 錯誤示例3：手動管理資源
file = open("data.txt")
try:
    content = file.read()
finally:
    file.close()  # 容易忘記

# 正確做法1：編寫Pythonic的代碼
fruits = ["apple", "banana", "cherry"]

# Pythonic的循環(huán)
for fruit in fruits:
    print(fruit)

# 需要索引時使用enumerate
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# 正確做法2：利用Python的表達(dá)能力
# 鏈?zhǔn)奖容^
if 0 < x < 10 and x != 5:  # 更清晰
    pass

# 使用真值測試
name = ""
if not name:  # 而不是 if name == ""
    print("Name is empty")

# 列表推導(dǎo)式
squares = [x**2 for x in range(10) if x % 2 == 0]

# 正確做法3：使用上下文管理器
# 自動資源管理
with open("data.txt") as file:
    content = file.read()
# 文件自動關(guān)閉

# 正確做法4：使用zip同時迭代多個序列
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

# 正確做法5：使用內(nèi)置函數(shù)
numbers = [3, 1, 4, 1, 5, 9, 2]

# 而不是手動實現(xiàn)
max_value = max(numbers)
min_value = min(numbers)
total = sum(numbers)

print(f"Max: {max_value}, Min: {min_value}, Sum: {total}")

"""
Pythonic代碼檢查清單
"""

# ? 使用描述性變量名
student_name = "Alice"  # 而不是 snm

# ? 使用列表推導(dǎo)式代替簡單循環(huán)
squares = [x**2 for x in range(10)]

# ? 使用enumerate獲取索引和值
for i, value in enumerate(my_list):
    pass

# ? 使用with語句管理資源
with open("file.txt") as f:
    content = f.read()

# ? 使用zip并行迭代
for a, b in zip(list_a, list_b):
    pass

# ? 使用if __name__ == "__main__"
if __name__ == "__main__":
    main()

# ? 使用異常處理而不是返回錯誤代碼
try:
    risky_operation()
except SpecificError as e:
    handle_error(e)

# ? 使用默認(rèn)參數(shù)和關(guān)鍵字參數(shù)
def greet(name, message="Hello"):
    return f"{message}, {name}"

# ? 使用屬性而不是getter/setter方法
class Person:
    def __init__(self, name):
        self.name = name  # 而不是set_name方法

"""
重構(gòu)示例：從初學(xué)者代碼到Pythonic代碼
"""

# 初學(xué)者版本
def process_data_beginner(data):
    """初學(xué)者版本的數(shù)據(jù)處理函數(shù)"""
    result = []
    for i in range(len(data)):
        if data[i] % 2 == 0:  # 檢查偶數(shù)
            temp = data[i] * 2  # 乘以2
            result.append(temp)  # 添加到結(jié)果
    
    total = 0
    for j in range(len(result)):
        total = total + result[j]  # 計算總和
    
    avg = 0
    if len(result) > 0:
        avg = total / len(result)  # 計算平均值
    
    output = {"numbers": result, "total": total, "average": avg}
    return output

# Pythonic版本
from typing import List, Dict, Union
from numbers import Number

def process_data_pythonic(data: List[Number]) -> Dict[str, Union[List[Number], Number]]:
    """
    Pythonic版本的數(shù)據(jù)處理函數(shù)
    
    參數(shù):
        data: 數(shù)字列表
        
    返回:
        包含處理結(jié)果、總和、平均值的字典
    """
    # 使用列表推導(dǎo)式過濾和轉(zhuǎn)換數(shù)據(jù)
    processed_numbers = [x * 2 for x in data if x % 2 == 0]
    
    # 使用內(nèi)置函數(shù)計算統(tǒng)計信息
    total = sum(processed_numbers) if processed_numbers else 0
    average = total / len(processed_numbers) if processed_numbers else 0
    
    return {
        "numbers": processed_numbers,
        "total": total,
        "average": average
    }

# 測試對比
test_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

beginner_result = process_data_beginner(test_data)
pythonic_result = process_data_pythonic(test_data)

print("初學(xué)者版本結(jié)果:")
print(beginner_result)

print("\nPythonic版本結(jié)果:")
print(pythonic_result)

print("\n結(jié)果是否相同:", beginner_result == pythonic_result)

# 性能測試
import timeit

beginner_time = timeit.timeit(
    'process_data_beginner([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])',
    globals=globals(),
    number=10000
)

pythonic_time = timeit.timeit(
    'process_data_pythonic([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])',
    globals=globals(),
    number=10000
)

print(f"\n性能對比:")
print(f"初學(xué)者版本: {beginner_time:.4f}秒")
print(f"Pythonic版本: {pythonic_time:.4f}秒")
print(f"速度提升: {beginner_time/pythonic_time:.1f}倍")