Python 作业错题整理：作业1-Python的数据结构（列表和元组）
作业1-Python的数据结构（列表和元组）
1.列表可以用 find () 函数来搜索数据是否在列表中。（T/F）
答案：F
解析：在 Python 中，列表（list）没有 find () 方法，find () 是字符串（str）的方法。要检查元素是否在列表中，应使用in关键字，或使用 index () 方法（但 index () 会在元素不存在时抛出异常）。
2.字符串和列表都是序列类型。（T/F）
答案：T
解析：在 Python 中，字符串（str）和列表（list）都属于序列类型，它们都支持索引访问、切片操作、长度计算等序列共有的特性。
3.在 Python 中，切片的完整语法是 sequence[start:end:step]，其中三个参数的含义如下：
start：起始索引（包含该位置元素，默认为序列开头，即索引 0）end：结束索引（不包含该位置元素，默认为序列结尾）step：步长（取值间隔，默认为 1，负数表示反向取值）
lst[::-1] 的完整写法是 lst[len(lst)-1 : -len(lst)-1 : -1]，但这种写法非常繁琐且不常用。
lst[len(lst)-1 : 0 : -1] 这种写法不能完整反转列表，因为它会漏掉第一个元素（索引为 0 的元素）。
原因如下：
- 切片的规则是「包含 start，不包含 end」
当start=len(lst)-1（最后一个元素索引）、 end=0、step=-1时：
- 取值范围是从最后一个元素开始，向左取到索引为 1 的元素（因为不包含 end=0）
- 最终会漏掉索引为 0 的元素
4.在 Python 中，列表（list）的索引是0-based（从 0 开始），而不是 1-based（从 1 开始）。
这意味着：
- 列表的第一个元素的索引是
0 - 第二个元素的索引是
1 - 第
n个元素的索引是n-1 - 最后一个元素的索引是
len(lst) - 1（len(lst)是列表的长度）
列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]，lst[1::2]的结果是[12, -22, -26, 0, 3]。
答案：F
解析：lst[1::2]表示从索引 1 开始，以步长 2 正向取值。
依次取索引 1、3、5、7、9 的元素：-5（1）、-10（3）、35（5）、49（7）、-21（9），结果应为[-5, -10, 35, 49, -21]，与题目描述不符。
5.下面程序的输出是3。 （T/F）
lst=[34,6,7,0,0,0,9]
n=0
for i in lst:
if i==0:
lst.remove(i)
n+=1
print(n)F
这段代码的目的是统计列表 lst 中值为0的元素个数，并在统计过程中移除这些0。让我们逐步分析：
初始列表： lst = [34, 6, 7, 0, 0, 0, 9]
代码逻辑：
- 初始化计数器
n=0 使用
for循环遍历列表lst中的每个元素i如果
i等于0：- 从列表中移除第一个匹配的0（即当前遇到的0）
- 计数器
n加1
- 循环结束后，打印
n（即移除的0的个数）
执行过程：
- 第一次迭代：i=34（非0）-> 无操作
- 第二次迭代：i=6（非0）-> 无操作
- 第三次迭代：i=7（非0）-> 无操作
- 第四次迭代：i=0 -> 移除第一个0（位置3），列表变为
[34,6,7,0,0,9]，n=1 - 第五次迭代：i=0（注意：此时列表是
[34,6,7,0,0,9]，下一个元素是索引4处的0）-> 移除这个0（位置4），列表变为[34,6,7,0,9]，n=2 - 第六次迭代：i=9（非0）-> 无操作
问题： 由于在循环中修改了列表（移除了元素），导致迭代跳过了一个0。初始列表有三个0，但只移除了两个。
最终结果：
- 列表变为
[34,6,7,0,9]（还有一个0未被移除） - 打印
n=2（但实际有3个0）
结论： 这段代码的本意是统计并移除所有0，但由于在遍历过程中修改列表，导致漏掉了一个0。因此，输出是2而不是3。
注意： 在遍历列表时修改列表（如删除元素）通常会导致意外行为，因为迭代器是基于原始列表索引的。建议使用列表推导式或创建新列表来安全地过滤元素。例如，要移除所有0并计数：
lst = [34,6,7,0,0,0,9]
n = lst.count(0)
lst = [i for i in lst if i != 0]
print(n) # 输出36.[1,2,[3]]+[4,5]的结果是[1,2,3,4,5]。（T/F）
答案：F
解析：在 Python 中，列表的 + 运算符用于拼接列表，会保留原列表的元素结构，不会对嵌套列表进行展开。
对于表达式 [1,2,[3]] + [4,5]，其结果是将两个列表直接拼接，保留嵌套的 [3]，即 [1, 2, [3], 4, 5]，而非 [1,2,3,4,5]。
7.以下代码运行后列表It中内容为[hello,'se',520,123,446]。 li = ["hello",'se', 520, 123, 446] lt=li li[0]='hi' print(lt)（T/F）
答案：F
解析：在 Python 中，列表赋值 lt = li 是引用赋值，即 lt 和 li 指向同一个列表对象。当修改 li[0] = 'hi' 时，由于两个变量引用同一个列表，lt 也会同步发生变化。
因此，代码运行后 lt 的内容应为 ['hi', 'se', 520, 123, 446]，而非 ['hello', 'se', 520, 123, 446]。
若要让 lt 保持原列表的值，需创建列表副本，例如 lt = li.copy() 或 lt = li[:]。
8.输出结果？data=[[1]*3]*3...
data=[[1]*3]*3
data[0][1]=45
print(data[2][1])这段代码的输出结果是 45。让我详细解释为什么：
代码分析
data = [[1]*3]*3 # 创建3x3的二维列表，所有元素初始为1
data[0][1] = 45 # 修改第0行第1列的元素为45
print(data[2][1]) # 输出第2行第1列的元素为什么输出是45？
（1）列表创建的问题
[[1]*3]*3 这种创建方式实际上创建了3个对同一个列表的引用，而不是3个独立的列表。
等价于：
inner_list = [1, 1, 1] # 创建一个包含3个1的列表
data = [inner_list, inner_list, inner_list] # 3个引用指向同一个列表（2）内存结构示意图
data → [引用1, 引用2, 引用3]
↓ ↓ ↓
都指向同一个列表对象：[1, 1, 1]（3）修改操作的影响
当执行 data[0][1] = 45 时：
data[0]、data[1]、data[2]都指向同一个列表- 修改任何一个引用都会影响所有行
- 实际上修改的是：
[1, 45, 1]
（4）验证
data = [[1]*3]*3
print("初始状态:")
print(f"data[0] is data[1]: {data[0] is data[1]}") # True
print(f"data[0] is data[2]: {data[0] is data[2]}") # True
data[0][1] = 45
print("\n修改后:")
print(f"data[0]: {data[0]}") # [1, 45, 1]
print(f"data[1]: {data[1]}") # [1, 45, 1]
print(f"data[2]: {data[2]}") # [1, 45, 1]正确的创建方式
如果要创建真正独立的二维列表，应该使用：
方法1：列表推导式（推荐）
data = [[1]*3 for _ in range(3)]
data[0][1] = 45
print(data[2][1]) # 输出: 1 （不会被影响）方法2：循环创建
data = []
for i in range(3):
data.append([1]*3)
data[0][1] = 45
print(data[2][1]) # 输出: 1总结
[[1]*3]*3创建的是浅拷贝，所有行共享同一个列表对象- 修改任何一行的元素都会影响所有行
- 应该使用列表推导式
[[1]*3 for _ in range(3)]来创建真正独立的二维列表 - 这种行为是由于Python中列表是可变对象，赋值操作传递的是引用而不是副本
[1]本身也是列表吧
您说得非常对！[1] 本身确实是一个列表，但这里的关键区别在于 \* 操作符对可变对象和不可变对象的不同行为。
(1)[1]*3 的情况
inner_list = [1]*3
# 创建的是: [1, 1, 1]
# 这里的 1 是整数（不可变对象）对于不可变对象（如整数、字符串、元组等），* 操作符会创建值的副本，所以每个 1 都是独立的。
(2)[[1]]*3 的情况
data = [[1]]*3
# 创建的是: [[1], [1], [1]]
# 但这里的每个 [1] 都是对同一个列表对象的引用！对于可变对象（如列表），* 操作符会创建引用的副本，而不是对象的副本。
内存结构对比
情况1：[1]*3
inner_list → [1, 1, 1]
│ │ │
三个独立的整数对象情况2：[[1]]*3
data → [引用1, 引用2, 引用3]
↓ ↓ ↓
都指向同一个列表对象：[1]验证代码
# 测试 [1]*3
list1 = [1]*3
print("测试 [1]*3:")
print(f"list1[0] is list1[1]: {list1[0] is list1[1]}") # True（但没关系，因为1是不可变的）
# 测试 [[1]]*3
list2 = [[1]]*3
print("\n测试 [[1]]*3:")
print(f"list2[0] is list2[1]: {list2[0] is list2[1]}") # True（有问题！）
# 修改测试
list2[0][0] = 999
print(f"修改后: {list2}") # [[999], [999], [999]]根本原因
问题的根源在于：
1)[1] 创建了一个列表对象
2)*3 复制了这个列表的引用，而不是创建新的列表对象
3)所有引用都指向内存中的同一个列表对象
正确的理解方式
# 等价于：
temp = [1] # 创建一个列表对象
data = [temp, temp, temp] # 创建三个对同一个对象的引用
# 而不是：
data = [[1], [1], [1]] # 创建三个不同的列表对象9.执行下述代码会出现语法错误。（ ） （T/F）
student = ['张三', 18, '男', 180, 130]
print(student[0]+"的身高是"+student[3])T
该代码会出现类型错误（TypeError），核心原因是不同数据类型无法直接使用+进行拼接：
student[0]是字符串类型（值为'张三'）student[3]是整数类型（值为180）
在 Python 中，+运算符在字符串语境下仅支持字符串与字符串的拼接，若尝试将字符串与整数拼接，会触发TypeError: can only concatenate str (not "int") to str错误。
需先将整数类型的student[3]转换为字符串，再进行拼接，代码如下：
student = ['张三', 18, '男', 180, 130]
# 使用str()函数将整数转为字符串
print(student[0] + "的身高是" + str(student[3]))
# 输出：张三的身高是180因此，原代码执行时会出现错误，该说法正确。
10.下述代码执行后，两句print()的输出结果都是：[0, 1, 2, 4, 5, 5, 6]。（ ）（T/F）
number = [1,5,2,4,5,6,0]
result = sorted(number)
print(number)
print(result)F
该说法错误，核心原因是sorted()函数的特性 ——它不会修改原列表，而是返回一个新的排序后的列表。具体分析如下：
- 原列表
number的状态：
变量number初始值为[1,5,2,4,5,6,0]，由于sorted()不改变原序列，因此print(number)输出的是原列表的原始顺序，即[1,5,2,4,5,6,0]。 - 新列表
result的状态：sorted(number)会对number中的元素进行升序排序，并将排序结果存入新变量result，因此print(result)输出的是排序后的列表，即[0, 1, 2, 4, 5, 5, 6]。
两句话的输出结果不同，故该说法错误。
若希望直接修改原列表并实现排序，需使用列表的sort()方法（无返回值，直接修改原列表），代码如下：
number = [1,5,2,4,5,6,0]
number.sort() # 直接修改原列表
print(number) # 输出：[0, 1, 2, 4, 5, 5, 6]
print(number) # 输出：[0, 1, 2, 4, 5, 5, 6]11.列表的元素可以是任何类型的对象。（T/F）
答案：T
在 Python 中，列表是一种灵活的数据结构，其元素可以是任何类型的对象，包括但不限于：
- 基本数据类型（整数、字符串、布尔值等）
- 复合数据类型（列表、元组、字典、集合等）
- 函数、类实例等复杂对象
12.调用以下函数返回的数据的类型是列表，列表内的元素是分别是1,2,3这3个数。（T/F） return 1,2,3
def foo():
return 1,2,3F
该说法错误，因为函数foo()返回的不是列表，而是一个元组（tuple）。
在 Python 中，当函数返回多个值并用逗号分隔时，这些值会被自动打包成一个元组。因此：
return 1,2,3等价于return (1,2,3)- 调用
foo()得到的是元组(1,2,3)，而不是列表[1,2,3]
验证代码：
def foo():
return 1,2,3
result = foo()
print(type(result)) # 输出：<class 'tuple'>因此，函数返回的是元组类型，而非列表类型，该说法错误。
13.tuple(x)：可以用于生成元组，输入的参数可以是任何组合数据类型。 （T/F）
答案：F
tuple(x)的作用是将可迭代对象（iterable） 转换为元组，而非 “任何组合数据类型”。
- 合法参数（可迭代对象）：列表、字符串、字典（仅转换键）、集合、生成器等，例如
tuple([1,2,3])（结果为(1,2,3)）、tuple("abc")（结果为('a','b','c')）。 - 非法参数（非可迭代对象）：若输入不可迭代的基本数据类型（如整数
5、浮点数3.14），会触发TypeError（例如tuple(5)会报错 “int is not iterable”）。
因此 “输入参数可以是任何组合数据类型” 的表述错误，该说法错误。
14.元组是不可变的，不支持列表对象的inset()、remove()等方法，也不支持del命令删除其中的元素，但可以使用del命令删除整个元组对象。 （T/F）
答案：T
该说法完全正确，具体分析如下：
- 元组不可变的体现：
元组没有insert()（插入元素）、remove()（删除元素）等修改元素的方法（这些是列表的可变方法），也无法通过del 元组[索引]删除单个元素（会触发TypeError）。 - del 命令的作用范围：
del命令无法删除元组内部的元素，但可以删除整个元组对象（即删除变量与元组的引用关系，后续无法再通过该变量访问元组）。
已知x = (1, 2, 3, 4)，那么执行x[0] = 5之后，x的值为(5, 2, 3, 4)。（T/F）
F
元组（tuple）是不可变对象，无法通过索引赋值修改其内部元素。
15.创建只包含一个元素的元组时，必须在元素后面加一个逗号，例如(3,)。 （T/F）
T
该说法正确，核心原因是括号在 Python 中既用于定义元组，也用于表示运算优先级，仅靠单个元素加括号无法明确表示 “元组”，必须通过末尾的逗号区分。
具体分析如下：
- 若写作
(3)：Python 会将其解析为整数3（括号仅起优先级强调作用），而非元组，type((3))的结果是<class 'int'>。 - 若写作
(3,)：末尾的逗号是元组的标志性语法，Python 会明确解析为只包含一个元素3的元组，type((3,))的结果是<class 'tuple'>。
此外，在省略括号的元组定义中（如t = 3,），逗号同样不可省略，否则t = 3会被解析为整数。因此，创建只包含一个元素的元组时，必须在元素后面加逗号，该说法正确。
16.在Python中元组的值是不可变的，因此，已知x = ([1], [2])，那么语句x[0].append(3)是无法正常执行的。 （T/F）
答案：F
该说法错误，核心在于混淆了 “元组的不可变性” 与 “元组内可变元素的可修改性”：
- 元组的不可变性：指元组元素的引用（即指向的对象）不可修改，例如不能替换
x[0]为其他列表或值（如x[0] = [1,3]会报错）。 - 元组内可变元素的可修改性：若元组的元素是可变对象（如列表、字典），则可以修改该可变对象自身的内容（不改变其引用）。
对于x = ([1], [2])，x[0]是一个列表（可变对象），x[0].append(3)是修改列表自身的内容，并未改变元组对该列表的引用，因此语句可正常执行，执行后 x 的值为([1,3], [2])。
已知 x=10, y=(x)，那么 y 的类型为 tuple。（T/F）
答案：F
该说法错误，核心原因是 Python 中创建单元素元组的语法规则特殊：
- 仅用括号包裹单个元素（如
(x)）时，括号会被解释为 “运算优先级括号”，而非元组的定义符号，此时y的类型与x一致（此处x=10为整数类型，故y也为int）。 - 若要创建单元素元组，需在元素后加逗号，正确语法为
y=(x,)，此时y的类型才是tuple。
示例：执行x=10; y=(x); print(type(y))，输出结果为<class 'int'>，而非<class 'tuple'>。因此该说法错误。
lst = [10]是包含了一个元素的列表，而tup = (10)是包含了一个元素的元组。（T/F）
答案：F
Python 中，仅用括号包裹单个元素时，括号会被解释为 “改变运算优先级的括号”，而非元组的定义符号，此时tup的类型是整数（与元素10的类型一致）。
元组是不可变序列，不能对元组中的元素进行修改操作，因此对元组tp = (1, 2) 进行tp*2操作是错误的。（T/F）
答案：F
对tp = (1, 2)执行tp*2，结果为(1, 2, 1, 2)，原元组tp本身并未被修改，完全符合元组的不可变性规则，操作合法且正确。
17.无效的索引在列表 / 元组等进行切片操作时不会引起异常。（T/F）
答案：T
在 Python 中，列表、元组的切片操作（[start:end:step]）具有 “容错性”，即使start或end超出了序列的实际索引范围（即 “无效索引”），也不会触发IndexError（索引错误），而是会自动调整到序列的边界（如start小于 0 时按 0 处理，end大于序列长度时按序列长度处理）。
示例：
- 对于列表
lst = [1,2,3]，执行lst[10:20]（索引 10、20 均无效），结果为[]（空列表），无异常。 - 执行
lst[-5:1]（-5 为无效负索引），结果为[1]（自动调整start为 0），无异常。
因此 “无效的索引在切片操作时不会引起异常” 的说法正确。
18.sort方法重新排列列表的元素，使它们以升序或降序排列。（T/F）
T
列表的sort()方法确实可以对列表元素进行重新排列，支持升序（默认）或降序排列。
- 升序排列（默认）：
list.sort()，元素将按照从小到大的顺序排列。 - 降序排列：
list.sort(reverse=True)，元素将按照从大到小的顺序排列。
示例：
nums = [3, 1, 4, 2]
nums.sort() # 升序排列
print(nums) # 输出：[1, 2, 3, 4]
nums.sort(reverse=True) # 降序排列
print(nums) # 输出：[4, 3, 2, 1]因此，该说法正确。
在对列表进行排序时，sort方法和内置函数sorted有什么区别？
在 Python 中，sort()方法和sorted()内置函数都可以对列表进行排序，但它们有以下核心区别：
是否修改原列表
list.sort()：是列表对象的方法，直接修改原列表，排序后原列表的元素顺序会改变，且该方法没有返回值（返回None）。sorted()：是内置函数，不会修改原列表，而是创建并返回一个新的排序后的列表，原列表保持不变。
适用范围
list.sort()：仅适用于列表（list类型），不能用于其他可迭代对象（如元组、字符串等）。sorted()：适用于所有可迭代对象（列表、元组、字符串、字典等），灵活性更高。
返回值
list.sort()：返回None（因此不能直接将其赋值给变量）。sorted()：返回排序后的新列表（可以直接赋值给变量）。
# 使用 sort() 方法
nums = [3, 1, 4, 2]
result = nums.sort() # 直接修改原列表，result 为 None
print(nums) # 输出：[1, 2, 3, 4]
print(result) # 输出：None
# 使用 sorted() 函数
nums = [3, 1, 4, 2]
new_nums = sorted(nums) # 原列表不变，返回新列表
print(nums) # 输出：[3, 1, 4, 2]（原列表未修改）
print(new_nums) # 输出：[1, 2, 3, 4]总结：如果需要修改原列表，用sort()；如果需要保留原列表并获取排序结果，用sorted()。
19.表达式list(map(str, [1, 2, 3]))的值为______。
['1', '2', '3']。
解析如下：
map(str, [1, 2, 3])会将str函数应用到列表[1, 2, 3]中的每个元素，将整数 1、2、3 分别转换为字符串 '1'、'2'、'3'，得到一个迭代器。list()函数将这个迭代器转换为列表，最终结果就是['1', '2', '3']。
map()函数将一个函数应用到可迭代对象（如列表、元组等）的每个元素上并返回一个迭代器（map 对象）。
在 Python 中，map() 是一个内置函数，用于将一个函数应用到可迭代对象（如列表、元组等）的每个元素上，并返回一个迭代器（map 对象），该迭代器包含应用函数后的结果。
基本语法：
map(function, iterable)function：要应用的函数（可以是内置函数、自定义函数或 lambda 匿名函数）。iterable：一个或多个可迭代对象（如列表、元组等）。
工作原理：
map()会遍历iterable中的每个元素，将其作为参数传入function进行处理。- 收集所有处理后的结果，返回一个
map迭代器（需通过list()、tuple()等转换为具体序列才能直接查看内容）。
用自定义函数处理列表
# 自定义函数：计算平方
def square(x):
return x **2
nums = [1, 2, 3, 4]
result = list(map(square, nums))
print(result) # 输出：[1, 4, 9, 16]用 lambda 函数处理多个可迭代对象
# 计算两个列表对应元素的和
a = [1, 2, 3]
b = [4, 5, 6]
result = list(map(lambda x, y: x + y, a, b))
print(result) # 输出：[5, 7, 9]20.用 Python 创建图，我们需要做以下哪个操作？
A. import matplotlib
B. import pyplot
C. import matplotlib.pyplot
D. import matplotlib import pyplot
答案：C
在 Python 中，matplotlib.pyplot是matplotlib库中用于创建各种图表（如折线图、柱状图等）的子模块。要使用它来创建图，需要通过import matplotlib.pyplot的方式导入该子模块，之后就可以调用其中的函数（如plot、bar等）来绘图了。
A 选项只导入matplotlib主库，不能直接用于创建图；B 选项pyplot不是独立的库，不能直接这样导入；D 选项的导入方式错误，不能这样同时导入两个模块。
21.使用元组而非列表的好处在于：（）
A.元组的大小不受限制。
B.元组可以存放任意类型的数据作为元素。
C.元组的处理速度比列表快。
D.使用元组没有任何优势。
答案：C
解析如下：
- A. 元组的大小不受限制：错误。元组和列表的大小都受系统内存限制，不存在 “元组大小不受限制” 的特性。
- B. 元组可以存放任意类型的数据作为元素：错误。列表同样可以存放任意类型的数据作为元素，这是两者共有的特性，并非元组独有的优势。
- C. 元组的处理速度比列表快：正确。元组是不可变序列，在创建后无需预留动态扩容的内存空间，因此 Python 对元组的处理（如访问元素）效率更高，速度比列表快。
- D. 使用元组没有任何优势：错误。除了处理速度快，元组的不可变性还能保证数据安全性（避免意外修改），在某些场景下是重要优势。
因此，使用元组而非列表的好处是元组的处理速度更快，正确答案是 C。
22.元组和列表都支持切片操作。（T）
元组支持切片操作！tup = (1,2,3,4) → tup[1:3] 结果为 (2,3)。
23.tup的变量命名与语言关键字冲突。（F）
24.如何创建一个包含如下元素：‘p’,’y’,’t’,’h’,’o’,’n’的列表?
A.x=['p','y','t','h','o','n']
B.x=['p','y','t','h','o','n']
C.x=list('python')
D.x = list({'p': 'y', 't': 'h', 'o': 'n'})
答案：A、C
解析如下，逐一分析各选项能否创建包含['p','y','t','h','o','n']的列表：
- A. x=['p','y','t','h','o','n']：正确。直接使用列表字面量（方括号
[]）定义，将每个字符作为独立元素列出，创建的列表正是目标结果。 - B. x=list['python']：错误。
list是内置函数，调用时需用圆括号()而非方括号[]，该语法会触发TypeError（列表不可调用或索引错误）。 - C. x=list('python')：正确。
list()函数可将字符串（可迭代对象）转换为列表，字符串'python'的每个字符会被作为独立元素，结果为['p','y','t','h','o','n']。 - D. x = list({'p': 'y', 't': 'h', 'o': 'n'})：错误。
list()函数转换字典时，仅提取字典的键（'p'、't'、'o'），结果为['p', 't', 'o']，与目标不符。
因此正确选项为 A 和 C。
25.已知：x=[1,2,3]，y=[4,5,6],欲生成新列表 x=[1,2,3,4,5,6],则下面的操作哪种方案可行?（ ）
A.x+=y或者x=x+y
B.x.extend(y)
C.x=x.add(y)
D.x=x.append(y)
extend()方法将另一个可迭代对象（如列表y）的所有元素，逐一追加到当前列表x的末尾。
extend()是列表的内置方法，功能是 “将另一个可迭代对象（如列表y）的所有元素，逐一追加到当前列表x的末尾”。
执行x.extend(y)后，原列表x直接变为[1,2,3,4,5,6]，完全符合需求，B 正确。
列表没有add()方法
对列表调用add()会触发AttributeError。
26.下面语句运行结果为True的是：
A.2 in set(range(6))
B.2 in set("123456")
C.2 in list(6)
D.2 in list(range(6))
答案：A、D
选项 B：2 in set("123456") → False
- 步骤 1：字符串
"123456"的元素是字符（'1'、'2'、'3'等，非整数）。 - 步骤 2：
set("123456")转换为集合后，元素为{'1','2','3','4','5','6'}（仍为字符）。 - 步骤 3：判断 整数
2是否在字符集合中 → 字符'2'与整数2类型不同，不在集合中，结果为False。
B 错误。
选项 C：2 in list(6) → 语法错误（无运行结果）
list()函数的参数必须是可迭代对象（如range、字符串、元组等），而6是整数（不可迭代）。- 执行
list(6)会直接触发TypeError: 'int' object is not iterable（整数不可迭代），无法生成列表，更无法判断2是否在其中。
C 错误。
27.下面程序的输出是（）t,a=2,t+1
t=1
t,a=2,t+1
print(a)代码的执行结果是 2。
解析过程如下：
- 首先给变量
t赋值为1，即t = 1。 然后执行t, a = 2, t + 1，这是一个同时赋值的操作：
- 右侧表达式先计算：
t + 1中的t此时还是初始值1，所以t + 1 = 2。 - 然后将计算结果分别赋值给左侧变量：
t被赋值为2，a被赋值为2（即t + 1的结果）。
- 右侧表达式先计算：
- 最后打印
a，输出结果为2。
28.len('3//11//2018'.split('/'))的结果是_____。
要计算len('3//11//2018'.split('/'))的结果，我们可以分步分析：
- 首先看字符串
'3//11//2018'，其中包含//作为分隔符。 使用split('/')方法时，会以'/'为分隔符拆分字符串。由于原字符串中有连续的'/'，拆分后会产生空字符串元素：
- 拆分结果为
['3', '', '11', '', '2018']
- 拆分结果为
- 最后使用
len()函数计算这个列表的长度，包含 5 个元素。
因此，结果是5。
29.list(range(2,12,2))[:-2].pop()的结果是：_____。（易错）
正解是求返回值
错解：误以为是列表的值，[2,4]
正解：要计算list(range(2,12,2))[:-2].pop()的结果，我们分步解析：
- 生成 range 对象：
range(2,12,2)生成从 2 开始、步长为 2、小于 12 的整数序列，即2,4,6,8,10。 - 转换为列表：
list(range(2,12,2))将上述序列转为列表，结果为[2,4,6,8,10]。 - 切片操作：
[:-2]表示取列表中除最后 2 个元素外的所有元素，即从索引 0 到索引-3（包含），结果为[2,4,6]。 - pop () 方法：列表的
pop()方法默认删除并返回最后一个元素，对[2,4,6]执行pop()，返回6。
最终结果是6。
30.猜生日（易错）
运行下面程序，输入是10011时，输出是（ ）。
如果你的生日在列表中，输入1，否则输入0。如你的生日是19号，输入11001。这个程序能猜到你的生日吗？（ ）。能,填yes;不能,填no。
lst1=[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31]
lst2=[2,3,6,7,10,11,14,15,18,19,22,23,26,27,30,31]
lst3=[4,5,6,7,12,13,14,15,20,21,22,23,28,29,30,31]
lst4=[8,9,10,11,12,13,14,15,24,25,26,27,28,29,30,31]
lst5=[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]
s=input()
print((lst1[0] if s[0]=="1" else 0)
+(lst2[0] if s[1]=="1" else 0)
+(lst3[0] if s[2]=="1" else 0)
+(lst4[0] if s[3]=="1" else 0)
+(lst5[0] if s[4]=="1" else 0))程序的输出和判断如下：
当输入是10011时：
分析各字符对应的数值：
- s [0] = "1" → 取 lst1 [0] = 1
- s[1] = "0" → 0
- s[2] = "0" → 0
- s [3] = "1" → 取 lst4 [0] = 8
- s [4] = "1" → 取 lst5 [0] = 16
- 总和为：1 + 0 + 0 + 8 + 16 = 25，因此输出是25。
关于 "这个程序能猜到你的生日吗？" 的判断：
- 程序的逻辑存在问题。它使用每个列表的第一个元素（而非元素在列表中的二进制权重）进行累加，这与正确的生日猜数逻辑（基于二进制位运算）不符。
- 例如，若生日是 3 号，正确输入应为 "11000"，但程序会计算 1 + 2 + 0 + 0 + 0 = 3（恰好正确）；但对于其他日期（如 19 号），程序计算结果将与实际日期不符。
因此，程序不能准确猜到生日，答案是no。
mat=[[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15]]
mattrans=[[1,4,7,10,11,13],[2,5,8,11,14],[3,6,9,12,15]]
31.7-2 列表去重
输入一个列表，去掉列表中重复的数字，按原来次序输出！
输入格式:
在一行中输入列表
输出格式:
在一行中输出不重复列表元素
输入样例:
在这里给出一组输入。例如：
[4,7,5,6,8,6,9,5] 输出样例:
在这里给出相应的输出。例如：
4 7 5 6 8 9# 读取输入的列表并转换为Python列表对象
input_str = input().strip()
lst = eval(input_str)
# 用于记录已经出现过的元素
seen = set()
# 用于存储结果的列表
result = []
# 遍历原列表
for num in lst:
# 如果元素没有出现过，则添加到结果列表并标记为已出现
if num not in seen:
seen.add(num)
result.append(num)
# 按照要求的格式输出结果
print(' '.join(map(str, result)))input_str = input().strip()这行代码的作用是获取用户输入并处理输入的字符串，具体解释如下：input()函数：这是 Python 的内置函数，用于从标准输入（通常是键盘）读取用户输入的一行内容，返回结果是一个字符串类型。例如，当用户输入[4,7,5,6,8,6,9,5]时，input()会返回字符串"[4,7,5,6,8,6,9,5]"（包含用户输入的所有字符）。strip()方法：这是字符串的内置方法，用于移除字符串首尾的空白字符（包括空格、换行符\n、制表符\t等）。例如，如果用户输入时不小心在首尾多敲了空格（如" [4,7,5] "），strip()会将其处理为"[4,7,5]"，避免多余空白对后续解析造成影响。map(str, result)：map()函数会对result列表中的每个元素应用str()函数，将所有元素转换为字符串类型。
例如，如果result是[4, 7, 5, 6, 8, 9]，转换后会得到一个迭代器，包含['4', '7', '5', '6', '8', '9']。' '.join(...)：join()是字符串的方法，用于将一个可迭代对象（这里是经map处理后的字符串列表）中的所有元素连接成一个新字符串，元素之间用单引号中的字符（这里是空格' '）分隔。
上述例子中，连接后会得到字符串"4 7 5 6 8 9"。在这个场景中，
str()是必要的，原因如下：join()方法要求传入的可迭代对象中的元素必须是字符串类型，否则会抛出TypeError。在你的代码中，
result列表存储的是数字类型的元素（如输入样例中的[4,7,5,6,8,9]）。如果直接使用' '.join(result)，Python 会报错：
本文系作者 @xiin 原创发布在To Future$站点。未经许可，禁止转载。
暂无评论数据