代码收藏家技术教程 2025-01-03

python——列表

一，选择题

二，判断题

三，列表的思维导图

一，选择题

1.已知列表 x=list(range(9))，那么执行之后，x的值为( D )
A. [1,3，5，7，9]
B.[1,3,5，7]
C.[0,1，3，5，7]

D.[2，3，4，5，6，7，8]

解析：列表x初始化为list(range(9)),其元素范围是从0-8（即x=[0,1,2,3,4,5,6,7,8]）.

语句 de1x[:2]的含义是删除列表x中从索引0到索引1（不包含1）的所有元素

2.len(range(1，10))的值是( B )
A.8 B.9 C.10 D.11

解析：range(1,10)生成序列为[1，2，3，4，5，6，7，8，9]，其中包含9个元素。

使用内置函数len()计算该序列的长度，即元素的个数。经过计算，序列中包含9个元素，因此len(range(1,10))的值为9.

3.表达式”,".join(list)中 list 是列表类型，以下选项中对其功能的描述正确的是( D )
A.将逗号字符串增加到列表 list 中
B.在列表 list 每个元素后增加一个逗号
C.将列表所有元素连接成一个字符串，每个元素后增加一个逗号

D.将列表所有元素连接成一个字符串，元素之间增加一个逗号

解析：A：错误，该操作不会将逗号字符串添加到列表中

B：错误，应该是在元素之间插入逗号，而不是在每个元素后。

C：错误，应该是在元素之间插入逗号和空格

4.表达式[1.2.3]*3 的执行结果为( A )
A. [1,2.3,1.2,3.1.2.3]
B. {[1, 2,3],[1,2,3],[1,2,3]}
C.[1,2,3],[1,2.3],[1,2.3]

D.([1, 1, 1,2, 2, 2,3, 3,3])

解析：列表 * 3，意味着将列表中的每个元素重复三次

5.假设列表对象 aList 的值为[3,4,5,6,7,9,11,13,15,17]，那么切片 aList[3:7]得到的值是( B )
A. [5, 6, 7, 9, 11]

B. [6, 7, 9, 11]

C. [5,6, 7,9,]

D. [7, 9, 11, 13]

解析：对于给定的列表 aList = [3,4,5,6,7,9,11,13,15,17] ，切片操作 aList[3:7] 中：start 为 3，也就是从索引为 3 的元素开始取（索引从 0 开始计数，所以索引 3 对应的元素是 6）。stop 为 7，意味着取到索引为 6 的元素为止（不包含索引为 7 的元素）.按照这个规则，从索引 3（元素 6）开始，依次取到索引 6（元素 11）之前的元素，得到的切片结果就是 [6, 7, 9, 11]

6.已知 x=list(range(20))，那么表达式x[-1]的值为( D )。

A.0

B.1

C.20

D. 19

解析：list(range(20))=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]，-1对应的位置就是该序列的倒数第一个

7.切片操作 list(range(6))[::2]执行结果为( D )
A.[0.1] B.[0.2.4.6] C.[0.1.2] D.[0.2.4]

8.已知 x=[3,7,5]，那么执行语句 x=x.sort(reverse=True)之后，x的值为( C )
A.[3,5,7] B.[7,5,3] C.None D . [3,7,5]

解析：列表而初始值x=[3,7,5]，调用 x.sort(reverse=True)之后，列表x将按降序排序，排序后的结果为[7,5,3]。由于sort（）方法没有返回值，所以x的值仍然是原列表的引用，所以返回值None

9.下面程序输出是什么? （ D ）
txt=["a, "b","c", "d","e”]
stop_words=["d","i"]

t=[x for x in txt if xnot in stop_words]
print(t)
A [ "a" ,"b" ,"c" ,"d","e"]
B [ "a" ,"b“ ,"c” ,"d"]
C [“a” ,"b“ ,"c” ]
D.[ “a" ,"b","c","e”]

解析：已知 txt = ["a", "b", "c", "d", "e"] 以及 stop_words = ["d", "i"] 。

对于元素 "a" ，它并不在 stop_words 列表里，满足条件，会被添加到新列表中。

对于元素 "b" ，同样不在 stop_words 列表中，符合条件，也会被添加进去。

对于元素 "c" ，不在 stop_words 列表内，会被加入新列表。

对于元素 "d" ，因为它存在于 stop_words 列表中，不满足条件，不会被添加到新列表里。

对于元素 "e" ，不在 stop_words 列表中，会被添加到新列表中。

10.下面程序的输出是: （ C ）
ls=[ “abcd", "ab","cd","cdab”]
n, m=0,0
for line in ls:
if "ab" and "cd" in line:
n+=1
m+=1
elif "ab" in line:
n+=1
elif "cd" in line:
m+=1

print(n,m)
A:3 3 B:3 4 C:4 3 D:4 4

解析：已知列表 ls = ["abcd", "ab", "cd", "cdab"] ：

对于字符串 "abcd" ，按照正确的逻辑，它同时包含 "ab" 和 "cd" 子串，所以会使得 n 和 m 都加 1。对于字符串 "ab" ，它只包含 "ab" 子串，所以会使得 n 加 1。

对于字符串 "cd" ，它只包含 "cd" 子串，所以会使得 m 加 1。

对于字符串 "cdab" ，它同时包含 "ab" 和 "cd" 子串，所以会使得 n 和 m 都加 1。

经过上述对每个字符串元素的分析和相应的计数操作，最终 n 的值为 4（因为 "abcd" 、 "ab" 、 "cdab" 这三个元素会使得 n 增加），m 的值为 3（因为 "abcd" 、 "cd" 、 "cdab" 这三个元素会使得 m 增加）。

11、以下程序的输出结果是( D ):
Is=[11,22,33, 44]

for i in ls:
if i=="33”:
print("找到!i=”,i)
break
else:
print("未找到…")

A:未找到…
B:未找到…未找到…找到! I=33
C:未找到… 未找到… 未找到… 未找到…
D:找到! I=33

12.以下程序的输出结果是( C ):
k=0
for i in range (4):
for j in range(i+1):
k+=j
if j>1:
break
print(k)
A: 5 B: 6 C: 7 D: 8

解析：1），当 i = 0 时：

内层循环 for j in range(i + 1) ，此时 j 的取值范围是 range(0 + 1) 也就是 range(1) ，意味着 j 只能取到 0 这一个值。执行 k += j ，也就是 k += 0 ，此时 k 的值仍然为 0 。接着判断 if j > 1 ，由于 j = 0 ，不满足条件，不会执行 break 操作，内层循环结束。

2），当 i = 1 时：

内层循环 for j in range(i + 1) ，此时 j 的取值范围是 range(1 + 1) 也就是 range(2) ，意味着 j 可以取到 0 和 1 这两个值。当 j = 0 时，执行 k += j ，即 k += 0 ，k 的值还是 0 。当 j = 1 时，执行 k += j ，即 k += 1 ，此时 k 的值变为 1 。接着判断 if j > 1 ，由于 j = 1 ，不满足条件，不会执行 break 操作，内层循环结束。

3），当 i = 2 时：

内层循环 for j in range(i + 1) ，此时 j 的取值范围是 range(2 + 1) 也就是 range(3) ，意味着 j 可以取到 0 、1 和 2 这三个值。当 j = 0 时，执行 k += j ，即 k += 0 ，k 的值还是 1 。当 j = 1 时，执行 k += j ，即 k += 1 ，此时 k 的值变为 2 。当 j = 2 时，执行 k += j ，即 k += 2 ，此时 k 的值变为 4 。接着判断 if j > 1 ，由于 j = 2 ，满足条件，执行 break 操作，内层循环提前结束。

4），当 i = 3 时：

内层循环 for j in range(i + 1) ，此时 j 的取值范围是 range(3 + 1) 也就是 range(4) ，意味着 j 可以取到 0 、1 、2 和 3 这四个值。当 j = 0 时，执行 k += j ，即 k += 0 ，k 的值还是 4 。当 j = 1 时，执行 k += j ，即 k += 1 ，此时 k 的值变为 5 。当 j = 2 时，执行 k += j ，即 k += 2 ，此时 k 的值变为 7 。接着判断 if j > 1 ，由于 j = 2 ，满足条件，执行 break 操作，内层循环提前结束。

二，判断题

13.Python 列表属于无序序列。 ( x )
14.Python 列表中所有元素必须为相同类型的数据 ( x )
16.对于列表而言，在尾部追加元素比在中间位置插入元素速度更快些，尤其是对于包含大量元素的列表。 ( √ )
17.使用 Python 列表的方法 insert()为列表插入元素时会改变列表中插入位置之后元素的索引。 ( √ )

18.已知列表 x=[1,3,2]，那么执行语句 x=x.reverse()之后，x的值
为___None__________
19.已知 x=([1],[2])，那么执行语句x[0].append(3)后x的值为____([1, 3], [2])___

20.编程题:有一个 1ist1 列表存储 2-99 的数据，查找孪生素数后输出，李生素数:两个素数之间间隔为2

分析：1.首先定义了函数 is_prime 用于判断一个数是否为素数。它通过一些基本的素数判断规则来实现，比如排除小于等于 1 的数，2 和 3 是素数，能被 2 或 3 整除的数（除了 2 和 3 本身）不是素数，然后通过循环判断是否能被 5 及以 6 为步长的数整除。

2.接着创建了 list1 存储 2 到 99 的数据。

3.然后通过循环遍历 list1，对于每个数，判断它以及它加 2 后的数是否都是素数，如果是，则将这一对孪生素数以元组的形式添加到 twin_primes 列表中。

4.最后遍历 twin_primes 列表并输出每一对孪生素数。

代码：

def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

list1 = list(range(2, 100))
twin_primes = []

for i in range(len(list1)):
    if is_prime(list1[i]) and is_prime(list1[i] + 2):
        twin_primes.append((list1[i], list1[i] + 2))

for twin_prime in twin_primes:
    print(twin_prime)

运行结果：