Python作业6

1.以下哪些代码会产生异常？
A. print([1, 2, 3][3])
尝试访问列表[1, 2, 3]的第 4 个元素，但该列表只有 3 个元素，索引最大为 2。异常类型：IndexError（索引错误）。
B. print(1 / 0)
试图进行除以零的操作。异常类型：ZeroDivisionError（除以零错误）。
C. print(int(‘abc’, 11))
解释：尝试将字符串’abc’转换为以 11 为基数的整数。在基数 11 中，有效的数字是 0 到 10，'a’和’b’超出了这个范围。异常类型：ValueError（值错误。
D. print(len(None))
解释：尝试获取None的长度，但None不是一个序列或集合类型，没有长度属性。异常类型：TypeError（类型错误）。

2.以下代码的输出结果是什么？

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print([x * y for x in list1 for y in list2])

分析：
这是一个列表推导式，用于生成一个新的列表。
外层循环是for x in list1，内层循环是for y in list2。
对于list1中的每个元素x，都会与list2中的每个元素y相乘，结果作为新列表的一个元素。
计算过程：
当x = 1时，y分别取 4、5、6，得到1 * 4 = 4，1 * 5 = 5，1 * 6 = 6。
当x = 2时，y分别取 4、5、6，得到2 * 4 = 8，2 * 5 = 10，2 * 6 = 12。
当x = 3时，y分别取 4、5、6，得到3 * 4 = 12，3 * 5 = 15，3 * 6 = 18。 结果列表：[4, 5, 6, 8, 10, 12, 12, 15, 18]

3.运行以下代码，输出结果是？

x = [1, 2]
def func():
    x = []
    x.append(3)
    x.append(4)
    print(x)
func()
print(x)

分析：
1 全局作用域中定义了一个列表x = [1, 2]。
2 函数func中定义了一个局部变量x（与全局变量同名），这是一个新的空列表。
3 在func中，向局部列表x添加元素 3、4、5，然后打印该局部列表。
4 调用func后，再次打印全局变量x。
执行过程：
• 调用func()时，函数内部的局部列表x被修改为[3,4,5]，并打印输出[3, 4]。 • 函数结束后，局部变量x被销毁。
• 最后打印全局变量x，其值仍为[1, 2]。
答案：[3, 4,5] [1, 2]

4.运行以下代码，输出结果是？

nums = [1, 2, 3, 4, 5]
i = 0
while i < len(nums):
    if nums[i] % 2 == 0:
        nums.pop(i)
    else:
        i += 1
print(nums)

初始化列表nums = [1, 2, 3, 4, 5]和索引i = 0。
2 使用while循环遍历列表：
如果当前元素nums[i]是偶数（能被 2 整除），则删除该元素。
如果是奇数，则索引i加 1。
3. 最终打印处理后的列表。
执行过程：
初始列表：[1, 2, 3, 4, 5]，i = 0。
nums[0] = 1（奇数），i变为 1。
nums[1] = 2（偶数），删除后列表变为[1, 3, 4, 5]，i保持 1。
nums[1] = 3（奇数），i变为 2。
nums[2] = 4（偶数），删除后列表变为[1, 3, 5]，i保持 2。
nums[2] = 5（奇数），i变为 3。
此时i = 3，len(nums) = 3，循环结束。
结果列表：[1, 3, 5]

5.关于变量作用域，以下说法正确的是？
A. 全局变量可以在函数内部直接访问： 解释：在函数内部，可以直接访问全局变量的值（除非被同名局部变量遮蔽）。
B. 局部变量可以在函数外部访问： 解释：局部变量的作用域仅限于定义它的函数内部，外部无法访问。
C. global关键字用于在函数内部修改全局变量： 解释：使用global关键字可以在函数内部声明并修改全局变量。
D. 函数内部定义的变量默认是局部变量： 解释：在函数内部定义的量，如果没有使用global或nonlocal关键字，默认是局部变量。
答案：①③④

6.以下代码的输出是什么？

s = "Python"
s[0] = "J"
print(s)

字符串在 Python 中是不可变对象，不支持直接修改其元素。
尝试执行s[0] = "J"会引发TypeError（类型错误）。

7.以下代码输出的结果是？

def transform_text(text):
    words = text.split()
    result = []
    for i, word in enumerate(words):
        if i % 2 == 0:
            reversed_word = word[::-1].capitalize()
            processed = reversed_word
        else:
            processed = word.lower()
        result.append(processed)
    return ' '.join(result)

text = "Hello WORLD this is a TEST"
print(transform_text(text))

1、text.split()将输入字符串分割成单词列表：[‘Hello’, ‘WORLD’, ‘this’, ‘is’, ‘a’, ‘TEST’]。
2、遍历每个单词及其索引：
索引为偶数（0, 2, 4）的单词：反转并首字母大写。
索引为奇数（1, 3, 5）的单词：转为小写。
3、处理后的单词列表：
索引 0：‘Hello’ → 反转’olleH’ → 首字母大写’Olleh’
索引 1：‘WORLD’ → 小写’world’
索引 2：‘this’ → 反转’siht’ → 首字母大写’Siht’
索引 3：‘is’ → 小写’is’
索引 4：‘a’ → 反转’a’ → 首字母大写’A’
索引 5：‘TEST’ → 小写’test’
4、最终结果：‘Olleh world Siht is A test’

8.以下代码打印的结果分别是

def manage_stack(operations):
    stack = []
    for op in operations:
        if op[0] == 'push':
            stack.append(op[1])
        elif op[0] == 'pop' and stack:
            stack.pop()
        elif op[0] == 'peek' and stack:
            print(stack[-1], end=' ')
    return stack

ops = [('push', 1), ('push', 2), ('peek',), ('push', 3), ('pop',), ('peek',), ('push', 4), ('peek',)]
final_stack = manage_stack(ops)
print(sum(final_stack))

1、初始化空栈stack = []。
2、遍历操作列表ops：
(‘push’, 1)：栈变为[1] ◦ (‘push’, 2)：栈变为[1, 2]
(‘peek’,)：打印栈顶元素2
(‘push’, 3)：栈变为[1, 2, 3]
(‘pop’,)：栈变为[1, 2]
(‘peek’,)：打印栈顶元素2
(‘push’, 4)：栈变为[1, 2, 4]
(‘peek’,)：打印栈顶元素4
3、打印结果：2 2 4 4. 最终栈final_stack = [1, 2, 4]，求和1 + 2 + 4 = 7
4. 答案：2、2、4、7

9.以下代码输出sums的元素依次是

def cumulative_sum(numbers):
    total = 0
    sums = []
    for num in numbers:
        total += num
        sums.append(total)
    return sums

sums = cumulative_sum([3, 1, 4, 1, 5])
print(sums)

1、初始化total = 0和空列表sums。
2.、遍历输入列表[3, 1, 4, 1, 5]：
3 → total = 3 → sums = [3]
1 → total = 4 → sums = [3, 4]
4 → total = 8 → sums = [3, 4, 8]
1 → total = 9 → sums = [3, 4, 8, 9]
5 → total = 14 → sums = [3, 4, 8, 9, 14]
3、 最终sums = [3, 4, 8, 9, 14]

10.关于 Python 容器的内存分配策略，以下说法错误的是？
A. list 采用过度分配策略减少 resize 次数 解释：列表在扩容时会预先分配额外空间，减少频繁扩容的开销。
B. dict 在删除元素后会自动收缩内存 解释：字典删除元素后不会立即释放内存，而是标记为可重用。
C. set 的存储结构与 dict 类似 解释：集合（set）基于哈希表实现，与字典（dict）的存储结构相似。
D. tuple 的内存分配是一次性的 解释：元组是不可变对象，内存分配在创建时完成，无法动态修改。
答案：B