【python】随笔 - 知识点小课堂 -3.python可迭代对象

前言

本文是关于python可迭代对象的一些习题的整理和讲解

3.12

已知vec =[[1,2]，[3,4]]，则表达式[[row[i]for row invec]for iin range(len(vec[8]))]的值为

列表推导式的基本结构

列表推导式是Python中一种简洁的构建列表的方法，其基本结构如下：

[expression for item in iterable if condition]

• expression：对每个item执行的表达式。
• item：来自iterable的元素。
• if condition：（可选）一个过滤条件，只有满足此条件的item才会被包含在最终的列表中。

双层列表推导式

双层列表推导式包含两个嵌套的循环，外层和内层：

1. 外层循环：控制整体的迭代逻辑，通常与内层循环的索引相关。

   [outer_expression for i in range(condition)]
   

   • outer_expression：外层循环中使用的表达式，通常依赖于i。
   • range(condition)：生成一个序列，用于外层循环的迭代。

2. 内层循环：通常与iterable的元素直接相关。

   [inner_expression for each_item in iterable]
   

   • inner_expression：内层循环中使用的表达式，通常直接处理each_item。

示例

考虑以下双层列表推导式：

[[row[i] for row in vec] for i in range(len(vec[0]))]

1. 外层循环：由for i in range(len(vec[0]))构成，i是vec中每个子列表的长度索引。
2. 内层循环：由for row in vec构成，row是vec中的每个子列表。

执行过程

1. 外层循环：迭代i从0到len(vec[0])-1。
2. 对于每个i：
   • 内层循环：迭代vec中的每个row。
   • 对于每个row，取出索引为i的元素。

结果

最终结果是一个列表，其中包含了vec中每个子列表在索引0到len(vec[0])-1下的所有元素。

注意事项

• 列表推导式可以包含多层嵌套，但通常建议不要超过两层，以保持代码的可读性。
• 每一层的循环都是独立的，外层循环的迭代变量（如i）在内层循环中是不可见的，除非明确传递。

3.13

表达式{1，2，3}<{3，4，5}的值为

在Python中，集合（set）是比较唯一性的数据结构，它不允许有重复的元素。集合之间比较时，遵循以下规则：

1. 集合之间的比较是基于它们的元素顺序进行的。在比较两个集合时，Python会按照元素在集合中的顺序（迭代的顺序）进行比较。

2. 如果一个集合是另一个集合的子集，那么它在比较中被视为“更小”。

3. 如果两个集合没有子集和超集的关系，那么比较是基于集合中元素的顺序。具体来说，如果两个集合的第一个不同元素中，一个集合的元素小于另一个集合的元素，那么这个集合在比较中被视为“更小”。

对于表达式 {1, 2, 3} < {3, 4, 5}：

• 集合 {1, 2, 3} 中的元素 1 在集合 {3, 4, 5} 中不存在，而集合 {3, 4, 5} 中的元素 3 在集合 {1, 2, 3} 中存在。
• 根据上述规则，因为 1 小于 3，所以 {1, 2, 3} 在比较中被视为小于 {3, 4, 5}。

因此，表达式 {1, 2, 3} < {3, 4, 5} 的值为 True。

3.14

表达式[1，2，3].count(4)的值为

在Python中，count()方法用于返回某个元素在列表中出现的次数。如果该元素在列表中不存在，则count()方法返回0。

对于表达式 [1, 2, 3].count(4)：

• 列表 [1, 2, 3] 中不包含元素 4。

因此，调用 count() 方法来计算 4 在这个列表中出现的次数，结果将为 0。

所以，表达式 [1, 2, 3].count(4) 的值为 0。

3.17

单选题:已知 x={1:‘a’，2:‘b’，3:‘c’}和y={1，3，4},那么表达式 x.keys()-y的值为

在Python中，集合（set）对象有一个-运算符，它用于求差集。表达式x.keys() - y意味着从x的键集合中移除y中的所有元素。

已知：

x = {1: 'a', 2: 'b', 3: 'c'}
y = {1, 3, 4}

x.keys()将生成一个包含x字典所有键的集合，即{1, 2, 3}。

然后，执行x.keys() - y操作，从{1, 2, 3}中移除{1, 3, 4}中的元素，由于4不在x.keys()中，它不会被包含在结果中。元素1和3将从x.keys()中移除，因为它们也存在于y中。

所以，结果将是：

{2}

表达式x.keys() - y的值为{2}。

3.18

单选题:已知 x={1:3，2:1，3:1}和y={1，3，4}，那么表达式x.values()-y的值为

这个错误是因为dict.values()返回的是一个字典值的视图（dynamic view），不是一个集合或列表，不能直接与set类型进行减法操作。

第一道题:

已知 x = {1: 'a', 2: 'b', 3: 'c'} 和 y = {1, 3, 4}，那么表达式 x.keys() - y 的值为：

x = {1: 'a', 2: 'b', 3: 'c'}
y = {1, 3, 4}
result = x.keys() - y
print(result)

Python 中 x.keys() 返回的是一个视图对象(dict_keys)，它表现得很像一个集合，这样就可以对它进行集合操作。所以在这个情况下：

• x.keys() 返回 dict_keys([1, 2, 3])
• y 是一个集合 {1, 3, 4}

因此，x.keys() - y 就等价于 set([1, 2, 3]) - {1, 3, 4}，结果是 {2}。

所以，正确答案是：

• A. {2}

第二道题:

已知 x = {1:3, 2:1, 3:1} 和 y = {1, 3, 4}，那么表达式 x.values() - y 的值为：

x = {1: 3, 2: 1, 3: 1}
y = {1, 3, 4}
result = x.values() - y
print(result)

在 Python 中，x.values() 返回的是一个视图对象(dict_values)，它不直接支持集合运算，因此会报错。试图对 dict_values 对象进行集合操作会导致 TypeError。为了能够进行集合操作，要明确地将 x.values() 转换为集合：

result = set(x.values()) - y

• x.values() 返回 dict_values([3, 1, 1])
• 转换为集合后，set(x.values()) 结果是 {1, 3}

所以，set(x.values()) - y 就等价于 {1, 3} - {1, 3, 4}，结果是 set()，即空集合。

在题目中, 如果直接使用 x.values() - y 而没有进行转换，会报错，这就解释了为什么两个表达式不一样：

• 第一个表达式 x.keys() - y 可以直接计算，因为 x.keys() 返回的 dict_keys 可以像集合一样操作。
• 第二个表达式 x.values() - y 会报错，因为 x.values() 返回的 dict_values 不支持直接进行集合操作，需要显式转换为 set。

所以，正确答案应该是
表达式错误，无法计算

3.19

多选题:下面的列表方法中有返回值并且返回值不是空值None 的有

)。
A.sort()
B.poP()
C.index()D.reverse()

在Python中，列表（list）是一种可变的数据结构，它提供了多种方法来操作列表。

A. .sort()：这个方法会对列表进行排序，并修改原列表。它没有返回值，或者说它的返回值是None。

B. .pop()：这个方法用于移除列表中的一个元素（默认是最后一个元素），并且返回被移除的元素。如果列表为空，会抛出一个IndexError异常。

C. .index()：这个方法用于找出某个元素在列表中第一次出现的索引位置，并返回这个索引。如果没有找到元素，会抛出一个ValueError异常。

D. .reverse()：这个方法会反转列表中的元素顺序，并修改原列表。它同样没有返回值，或者说它的返回值是None。

根据题目要求，我们需要找出有返回值并且返回值不是None的方法。根据上述解释，.pop() 和 .index() 是满足条件的方法。因此，正确答案是 B 和 C。

3.21

这几个函数返回值是不是一定是空值。
A.insert()B.clear()
C.count()D.extend()

在Python中，列表的方法通常用于对列表进行操作，有些方法会返回值，有些则不会。

A. .insert(index, item)：这个方法在指定位置index插入一个元素item。它没有返回值，即返回None。

B. .clear()：这个方法用于清空列表中的所有元素。它同样没有返回值，即返回None。

C. .count(item)：这个方法用于返回元素item在列表中出现的次数。它返回一个整数，所以返回值不是None。

D. .extend(iterable)：这个方法用于将一个可迭代对象（如另一个列表）的所有元素添加到列表末尾。这个方法没有返回值，即返回None。

综上所述，A.insert()、B.clear() 和 D.extend() 这三个方法都没有返回值，或者说它们的返回值是None。而 C.count() 方法返回一个整数，不是None。

3.22

多选题:下面的列表方法中不影响列表内存首地址的有(
X.sort()B.pop()C.index()
D. reverse()

在Python中，列表（list）是一个可变的数据结构，这意味着列表的内容可以被修改，而不需要创建新的对象。对于列表的内存首地址，它指的是列表对象在内存中的起始位置。列表的内存首地址通常在列表被创建时确定，并且只有在列表对象的内存被重新分配时才会改变。

对于列表方法是否影响内存首地址，关键在于这些操作是否会导致列表对象的内存被重新分配。以下是对每个方法的重新评估：

A. .sort()：这个操作会就地对列表中的元素进行排序，不会创建一个新的列表对象。排序操作本身不会改变列表的内存首地址，因为这是在原列表上进行的。

B. .pop()：pop() 方法移除列表中的一个元素（默认是最后一个），并返回它。这个操作通常不会改变列表的内存首地址，因为移除元素是在原列表上进行的，不需要重新分配内存。

C. .index()：这个方法用于找出某个元素在列表中的索引位置。它不修改列表的内容，因此不会影响列表的内存首地址。

D. .reverse()：reverse() 方法就地反转列表中的元素顺序。这个操作不会创建一个新的列表对象，而是直接修改原列表，因此不会影响列表的内存首地址。

综上所述，.sort()、.pop()、.index() 和 .reverse() 这四个方法都不会导致列表对象的内存被重新分配，因此它们都不会影响列表的内存首地址。这些方法都是就地修改列表，而不是创建一个新的列表对象。所以，正确答案是 A、B、C 和 D。

3.25

多选题:下面的列表方法中返回值一定为空值 None 的有(
在Python中，列表的insert()、copy()、remove()和append()方法中，返回值的具体情况如下：

1. .insert(index, item)：这个方法用于在指定位置插入一个元素，它没有返回值，即返回None。

2. .copy()：这个方法用于返回列表的一个浅拷贝，即返回一个新的列表对象，其中包含了原列表的所有元素。

3. .remove(item)：这个方法用于移除列表中第一个匹配的元素，并返回None。如果列表中没有该元素，则会抛出一个ValueError异常。

4. .append(item)：这个方法用于在列表末尾添加一个元素，它同样没有返回值，即返回None。

根据这些方法的描述，insert() 和 append() 方法的返回值一定是空值None。而copy()方法返回一个新的列表对象，不是None。remove()方法虽然可能抛出异常，但如果成功移除元素，它返回的也是None。

所以，返回值一定为空值None的方法是 insert()、remove() 和 append()。

3.26

多选题:下面可以使用表示位置或序号的整数做下标访问其中元素的有

)。
A.列表B.元组
C.字典D.集合
E.字符串

在Python中，不同的数据结构支持不同的操作和访问方式。以下是对每个选项的解释：

A. 列表（List）：可以使用整数下标来访问列表中的元素。列表是有序的，并且允许通过索引来访问、添加、删除元素。

B. 元组（Tuple）：元组也是有序的，并且可以通过整数下标来访问其中的元素。元组一旦创建，其内容就不能被修改。

C. 字典（Dictionary）：字典不支持使用整数下标来访问元素。字典中的元素是通过键（key）来访问的，键可以是字符串、数字等，但不是通过整数下标。

D. 集合（Set）：集合是无序的，不存储重复的元素。集合不支持通过下标来访问元素，因为集合中的元素没有索引。

E. 字符串（String）：字符串可以被视为字符的有序集合，可以使用整数下标来访问字符串中的特定字符。

综上所述，可以使用整数下标访问元素的数据结构有列表（A）、元组（B）和字符串（E）。因此，正确答案是 A、B 和 E。

3.27

3.27 多选题:下面可以支持下标（助理助理，这里是下标，不是整数下标）运算的有(
)。
B.元组
D.集合C.字典
A. 列表只字符串

ABCE注意，这里注意字典是按照他的剑来索引

3.27~END

3.28 随机整数及其出现次数统计

1. 使用random模块生成1000个0到100（包含0和100）的随机整数。
2. 创建一个长度为101的列表（因为范围是0到100），用于统计每个数字的出现次数，初始化所有元素为0。
3. 对于每个生成的随机整数，将对应索引的计数加1。
4. 打印出最终的计数列表。

3.29 使用切片获取列表中的子列表

1. 接收用户输入的列表和两个整数作为下标。
2. 确保下标在列表的范围内，并且第一个下标小于第二个下标。
3. 使用切片操作list[start:end+1]获取从start到end（包含end）的子列表。
4. 输出得到的子列表。

3.30 字典的输入与输出

1. 设计一个字典，其中包含若干键值对。
2. 提示用户输入一个键。
3. 检查用户输入的键是否存在于字典中。
   • 如果存在，输出对应的值。
   • 如果不存在，输出提示信息“输入的键不存在!”。

3.31 生成特定排序的随机数列表

1. 使用random模块生成一个包含20个随机数的列表。
2. 将列表分为两部分：前18个元素和后10个元素。
3. 对前18个元素使用sort()方法进行升序排序。
4. 对后10个元素使用sort(reverse=True)方法进行降序排序。
5. 将排序后的两部分合并回一个列表中。
6. 输出最终的排序列表。

3.32 为什么应尽量从列表的尾部进行元素的增加与删除操作？

• 列表的尾部增加和删除操作通常比头部或中间更高效，因为这些操作不需要移动列表中的其他元素。
• 当在列表中间或头部增加或删除元素时，Python需要移动该元素之后的所有元素，以保持列表的连续性，这增加了时间复杂度。
• 尾部操作不需要这种移动，因此更快，特别是对于大型列表来说，性能差异更加明显。

END