1. 答案：3；

解析：

• Python 中int()函数对浮点数的转换是截断取整（只保留整数部分），因此int(3.9)结果为 3；

2. 答案：nonlocal；global

解析：

• nonlocal：用于嵌套函数中，声明变量是外层函数的局部变量（非全局、非当前函数局部），可修改外层局部变量；
• global：声明变量是全局变量，即使在函数内也可修改全局作用域的变量。

x = 10  # 全局变量
def outer():
    y = 20  # 外层局部变量
    def inner():
        global x  # 声明修改全局x
        nonlocal y  # 声明修改外层y
        x = 100
        y = 200
    inner()
    print(y)  # 输出200
outer()
print(x)  # 输出100

3. 答案：-3；1

解析：

Python 中整数除法//遵循 “向下取整” 规则，取模%遵循公式：a = (a // b) * b + (a % b)。

• -5 // 2：2×(-3) = -6 ≤ -5，因此结果为 - 3；
• -5 % 2：代入公式，-5 = (-3)×2 + 1，因此余数为 1。

4. 答案："|".join (["Python","速成","课"])

解析：

str.join(iterable)函数的规则是：以调用 join 的字符串作为分隔符，拼接可迭代对象（列表、元组等）的所有元素，且元素必须是字符串类型。

执行"|".join(["Python","速成","课"])时，分隔符|会插入列表元素之间，结果为Python|速成|课。

5. 答案：解包时左右侧元素数量不匹配；字符串（str）

解析：

• a,b = 1报错原因：等号左侧是 2 个变量，右侧仅 1 个值，解包时 “数量不匹配”，Python 无法分配；若要正确赋值需a,b = 1,2（左右数量一致）；
• input()函数：无论用户输入数字、符号还是文字，均以字符串类型返回，如需数值需手动转换（如int(input())）。

6. 代码题解析

第 1 段代码

题目结论错误，正确看法：

输出结果是 100，而非 10。原因：

• 全局变量x=100，outer()函数内定义的x=10是外层函数局部变量（仅作用于outer内部）；
• inner()函数内的x=200是内层函数局部变量（仅作用于inner内部）；
• 三个x属于不同作用域，互不影响，最终print(x)打印的是全局变量x，结果为 100。

第 2 段代码

题目结论正确，补充验证：

"="*5会生成 5 个等号拼接的字符串=====，因此"="*5 + "Python" + "="*5拼接后结果为=====Python=====，print输出该字符串（无额外换行，题目描述符合实际）。

第 3 段代码

题目结论错误，正确看法：

代码会报错ValueError: too many values to unpack (expected 2)。原因：

解包赋值要求 “左侧变量数量 = 右侧可迭代对象元素数量”（或左侧用*接收剩余元素），而lst = [10,20,30]有 3 个元素，a,b = lst仅声明 2 个变量，无法匹配，直接报错（而非 “取前两个元素”）。

若要取前两个元素，正确写法：a,b,*_ = lst。

第 4 段代码

题目结论错误，正确看法：

输出结果是[1,2,3,4,6,1,2,3,4,6]（而非题目中的[1,2,3,6,1,2,3,4]）。原因：

• 链式赋值a = b = [1,2,3]中，a和b指向同一个列表对象（内存地址相同）；
• b.append(4)：列表变为[1,2,3,4]（a也同步变为该值）；
• a.append(6)：列表变为[1,2,3,4,6]（b也同步变为该值）；
• c = a + b：是两个相同列表拼接，结果为[1,2,3,4,6] + [1,2,3,4,6] = [1,2,3,4,6,1,2,3,4,6]。

生活需求：代码 + 解析

完整代码

# 1. 初始化共享购物清单
shop_list = [25, 0, 18, 32, 0, 15]
my_list = shop_list  # 小明手机端（共享同一份）
your_list = shop_list  # 小红手机端（共享同一份）

# 2. 数据清理：while循环移除所有0，使用continue控制逻辑
index = 0
while index < len(shop_list):
    if shop_list[index] == 0:
        shop_list.pop(index)  # 移除0元素，索引不递增（因为列表长度减1）
        continue  # 跳过本次循环剩余逻辑，直接进入下一次
    index += 1  # 非0元素，索引递增

# 3. 数据解构：提取前2个价格，剩余用*other_prices接收
price1, price2, *other_prices = shop_list

# 4. 内存验证：判断内存地址是否相同
is_same = id(my_list) == id(your_list)

# 5. while循环计算总价（禁止用sum）
total = 0
i = 0
while i < len(shop_list):
    total += shop_list[i]
    i += 1

# 6. 优惠计算：总价整除2
discount_price = total // 2

# 7. 结果输出
print(f"清理后清单：{shop_list}")
print(f"是否同一份清单：{is_same}")
print(f"price1={price1}, price2={price2}, other_prices={other_prices}")
print(f"总价：{total}, 优惠价：{discount_price}")

代码解析

1. 初始化共享清单

my_list = shop_list和your_list = shop_list表示三个变量指向同一个列表对象（内存地址相同），符合 “共享同步” 的需求。

2. 数据清理（核心逻辑）

• 用while循环遍历，索引index初始为 0；
• 若当前元素是 0：执行pop(index)移除该元素（列表长度减 1），然后continue跳过index += 1（因为移除后，下一个元素会移到当前索引位置，需重新检查）；
• 若当前元素非 0：index += 1，继续遍历下一个元素；
• 最终shop_list会被清理为[25, 18, 32, 15]。

3. 数据解构

Python 的 “解包赋值” 特性：price1, price2, *other_prices = shop_list会：

• 第一个元素赋值给price1（25）；
• 第二个元素赋值给price2（18）；
• 剩余所有元素打包为列表赋值给other_prices（[32, 15]）。

4. 内存验证

id()函数返回对象的唯一内存地址，id(my_list) == id(your_list)判断两个变量是否指向同一个列表，结果为True（符合共享需求）。

5. 总价计算

• 初始化total = 0，索引i = 0；
• while i < len(shop_list)：循环遍历每个元素，将元素值累加到total，然后i += 1；
• 最终total = 25+18+32+15 = 90。

6. 优惠计算

discount_price = total // 2：90 整除 2，结果为 45。

7. 结果输出

按指定格式打印所有关键结果，最终输出：

清理后清单：[25, 18, 32, 15]
是否同一份清单：True
price1=25, price2=18, other_prices=[32, 15]
总价：90, 优惠价：45

关键注意点

1. 清理 0 时，pop(index)后必须continue：否则index += 1会跳过下一个元素（例如移除索引 1 的 0 后，原索引 2 的 18 会移到索引 1，若直接index +=1会检查索引 2 的 32，漏掉 18）；
2. 链式赋值my_list = shop_list是 “引用赋值”，而非复制列表，确保共享特性；
3. 总价计算禁止用sum()，必须用while循环实现，符合题目要求。