Python程序设计任务驱动式教程题库带答案.docx

单元1 程序开发环境构建与数据输入输出
（一）选择题
1．Python是一种优秀并广泛使用的语言，得到行业内众多领域的认可，下列选项属于Python主要应用领域的是（ ABCD ）。
A．人工智能
B．科学计算和统计
C．大数据处理
D．游戏开发
2．Python相比其他程序设计语言具有的特点是（ ABC ）。
A．交互式
B．解释型
C．面向对象
D．服务端语言
3．计算机中进行信息处理和信息储存使用的是（ A ）。
A．二进制代码
B．十进制代码
C．十六进制代码
D．ASCII代码
4．Python源程序执行的方式是（ B ）。
A．编译执行
B．解析执行
C．直接执行
D．边编译边执行
5．Python代码块的标记是( C )。
A．分号
B．逗号
C．缩进
D．/
6．安装好Python之后，可以有多种方式运行，下列不属于其可行运行方式的是（ A ）。
A．浏览器中运行
B．交互式解释器
C．命令行脚本
D．PyCharm
7．Python解释器执行'{0},{2},{1}'.format('a','b','c')的结果为（ C ）。
A．'a,b,c'
B．'a,c,c'
C．'a,c,b'
D．'c,c,b'
8．在Python解释器的主提示符或从属提示符后输入中断符（ A ）就会取消当前输入，回到主提示符，会抛出一个KeyboardInterrupt异常。
A．Ctrl+C
B．Ctrl+Z
C．Ctrl+O
D．Alt+C
9．学习Python要先明白什么是编程语言。下列选项正确的是（ ABCD ）。
A．编程语言是程序员与计算机沟通的介质
B．能够被计算机识别的表达方式即是编程语言
C．编程即程序员根据要求把自己的思想流程按照某种编程语言的语法格式编写下来
D．人类编程控制计算机工作
10．下列选项对Unicode作用的描述，正确的是（ AC ）。
A．能够使计算机对跨语言的文本进行转换和处理
B．能够减少存储容量，节约存储成本
C．能够使计算机对跨平台的文本进行转换和处理
D．能够使计算机处理文本速度更快
11．在Python 3中执行以下语句后得到的结果是（ D ）。
>>>word="Python"
>>>print "hello "+ word
A．hello Python
B．"hello" Python
C．hello word
D．语法错误
（二）填空题
1．用编程语言编写的文件通常有固定的扩展名，Python文件的扩展名通常为{ .py }。
2．Python安装扩展库常用的是{ pip }工具。
3．使用pip工具查看当前已安装的Python扩展库的完整命令是{ pip list }。
4．在IDLE交互模式中浏览上一条语句的快捷键是{ Alt+P }。
5．在Python中，使用内置函数{ print() }可以将结果输出到IDLE或者标准控制台中。
6．Python的编程方式主要有{ 交互式 }编程、脚本式编程两种。
7．Python编程时关键字都不能作为变量名，在程序中先导入keyword模块，然后调用{ keyword.kwlist }即可查看Python包含的所有关键字。
8．在IDLE窗口出现{ >>> }提示符时，表示Python已经准备好了，等待用户输入Python程序代码。
9．多行注释使用三引号'''或者3个{ 双引号“"""” }将注释括起来。
10．Python提供了{ input() }内置函数从标准输入中读入文本，默认的标准输入是键盘。
11．Python 3语句print(1, 2, 3, sep=',')的输出结果为{ 1,2,3 }。
（三）判断题
1．Python是一种跨平台、开源、免费的动态编程语言。（ 对 ）
2．Python 3完全兼容Python 2。（ 错 ）
3．在Windows平台上编写的Python程序无法在UNIX平台运行。（ 错 ）
4．不可以在同一台计算机上安装多个Python版本。（ 错 ）
5．pip命令也支持扩展名为“.whl”的文件直接安装Python扩展库。（ 对 ）
6．Python使用缩进来体现代码之间的逻辑关系。（ 对 ）
7．Python代码的注释只有一种方式，那就是使用#符号。（ 错 ）
8．为了让代码更加紧凑，编写Python程序时应尽量避免加入空格和空行。（ 错 ）
9．Python程序只能在安装了Python环境的计算机上以源代码形式运行。（ 错 ）
10．在Python 3中，使用内置函数input()接收用户输入时，不论用户输入什么格式的内容，一律按字符串进行返回。（ 对 ）
11．安装Python扩展库时只能使用pip工具在线安装，如果安装不成功就没有别的办法了。（ 错 ）

单元2 基本数据类型与运算符应用
（一）选择题
1．在信息组织和存储中，最基本的单位是（ B ）。
A．字节（Byte）
B．位（bit）
C．字（Word）
D．双字（Double Word）
2．现有代码t=('a')，在Python 3解释器中查看type(t)的结果为（ A ）。
A．<class 'str'>
B．<class 'tuple'>
C．(class 'str')
D．(class 'tuple')
3．设任意一个十进制整数D，转换成二进制数为B，根据数制的概念，下列叙述中正确的是（ C ）。
A．数字B的位数<数字D的位数
B．数字B的位数≤数字D的位数
C．数字B的位数≥数字D的位数
D．数字B的位数>数字D的位数
4．字长为7位的无符号二进制整数能表示的十进制整数范围是（ C ）。
A．0~128
B．0~255
C．0~127
D．1~127
5．下列选项中，八进制数24转换成二进制数正确的是（ B ）。
A．00101100
B．00010100
C．00011100
D．00011101
6．将二进制数10010101转换成十进制数，正确的选项为（ C ）。
A．139
B．141
C．149
D．151
7．下列字符中对应ASCII数值最小的选项是（ A ）。
A．B
B．a
C．k
D．M
8．在Python中，数值类型包括（ ABCD ）。
A．int
B．float
C．complex
D．bool
9．以下选项为整数类型的有（ ACD ）。
A．3
B．3.1
C．-3
D．0
10．Python 3解释器执行long(10)的结果为（ C ）。
A．10L
B．10l
C．NameError: name 'long' is not defined
D．1
11．在Python 3中，如果变量x = 3，那么x /= 3的结果为（ C ）。
A．3
B．0
C．1.0
D．1
12．下列选项中，数值最小的是（ D ）。
A．十进制数 55
B．二进制数110100
C．八进制数 101
D．十六进制数33
13．Python 3解释器执行2的8次方的结果为（ A ）。
A．256
B．256L
C．256l
D．报错
14．下列选项中不是Python合法的标识符的是（ B ）。
A．int32
B．40XL
C．self
D．__name__
15．Python不支持的数据类型是（ A ）。
A．char
B．int
C．float
D．list
16．print(type(1+2*3.14))的结果是（ C ）。
A．<class 'int'>
B．<class 'long'>
C．<class 'float'>
D．<class 'str'>
17．以下不是Python中的关键字的是（ D ）。
A．raise
B．with
C．import
D．final
18．下列语句在Python中为非法的是（ B ）。
A．x = y = z = 1
B．x = (y = z + 1)
C．x, y = y, x
D．x += y
19．关于Python内存管理，下列说法错误的是（ B ）。
A．变量不必事先声明
B．变量无须先创建和赋值而可以直接使用
C．变量无须指定类型
D．可以使用del释放资源
20．关于Python中的复数，下列说法错误的是（ C ）。
A．表示复数的语法是real + imag*j
B．实部和虚部都是浮点数
C．虚部末尾必须加上j，且必须是小写
D．方法conjugate返回复数的共轭复数
21．print(100 - 25 * 3 % 4)输出的结果是（ B ）。
A．1
B．97
C．25
D．0
（二）填空题
1．在Python中{ None }表示空类型。
2．查看变量类型的Python内置函数是{ type() }。
3．以3为实部、4为虚部，Python复数的表达形式为{ 3+4j }或3+4J。
4．Python运算符中用来计算商的整数部分的是{ // }。
5．已知x = 3，那么执行语句x += 6之后，x的值为{ 9 }。
6．已知x = 3，那么执行语句x *= 6之后，x的值为{ 18 }。
7．表达式int(4**0.5)的值为{ 2 }。
8．已知x=3和y=5，执行语句 x, y = y, x 后x的值是{ 5 }。
9．表达式3 ** 2 的值为{ 9 }。
10．表达式3 * 2的值为。{ 6 }
11．表达式3 | 5的值为{ 7 }。
12．表达式3 & 6的值为{ 2 }。
13．表达式3<<2的值为{ 12 }。
14．表达式65 >> 1的值为{ 32 }。
15．表达式isinstance('abc', str)的值为{ True }。
16．表达式isinstance('abc', int)的值为{ False }。
17．表达式isinstance(4j, (int, float, complex))的值为{ True }。
18．表达式isinstance('4', (int, float, complex))的值为{ False }。
19．表达式type(3) in (int, float, complex)的值为{ True }。
20．表达式type(3.0) in (int, float, complex)的值为{ True }。
21．表达式type(3+4j) in (int, float, complex)的值为{ True }。
22．表达式type('3') in (int, float, complex)的值为{ False }。
23．表达式type(3) == int的值为{ True }。
24．表达式print(0b10101)的值为{ 21 }。
25．表达式1234%1000//100的值为{ 2 }。
26．表达式3 // 5的值为{ 0 }。
27．表达式15 // 4的值为{ 3 }。
28．已知x为整数变量，那么表达式int(hex(x), 16) == x的值为{ True }。
29．表达式16**0.5的值为{ 4.0 }。
30．表达式isinstance('Hello Python', str)的值为{ True }。
31．已知x = 3+4j和y = 5+6j，那么表达式x+y的值为{ 8+10j }。
32．表达式int('11', 2)的值为{ 3 }。
33．表达式int('11', 8)的值为{ 9 }。
34．表达式int(bin(54321), 2)的值为{ 54321 }。
35．表达式chr(ord('A')+1)的值为{ 'B' }。
36．表达式int(str(34)) == 34的值为{ True }。
37．表达式chr(ord('a')^32^32)的值为{ 'a' }。
38．表达式chr(ord('a')^32)的值为{ 'A' }。
39．表达式chr(ord('b')^32)的值为{ 'B' }。
40．表达式'abc' in 'abdcefg'的值为{ False }。
41．表达式isinstance(3, object)的值为{ True }。
（三）判断题
1．已知x = 3，那么赋值语句x = 'abcedfg'是无法正常执行的。（ 错 ）
2．Python变量使用前必须先声明，并且一旦声明就不能在当前作用域内改变其类型。（ 错 ）
3．Python采用的是基于值的自动内存管理方式。（ 对 ）
4．在任何时刻相同的值在内存中都只保留一份。（ 错 ）
5．Python不允许使用关键字作为变量名，允许使用内置函数名作为变量名，但这会改变函数名的含义。（ 对 ）
6．在Python中可以使用if作为变量名。（ 错 ）
7．在Python 3中可以使用中文作为变量名。（ 对 ）
8．Python变量名必须以字母或下划线开头，并且区分字母大小写。（ 对 ）
9．9999**9999这样的命令在Python中无法运行。（ 错 ）
10．3+4j不是合法的Python表达式。（ 错 ）
11．0o12f是合法的八进制数字表示形式。（ 错 ）
12．在Python中0xad是合法的十六进制数字表示形式。（ 对 ）
13．3+4j是合法Python的数值类型。（ 对 ）
14．在Python中0oa1是合法的八进制数字表示形式。（ 错 ）
15．Python运算符%不仅可以用来求余数，还可以用来格式化字符串。（ 对 ）
16．已知x = 3，那么执行语句x+=6之后，x的内存地址不变。（ 错 ）
17．一个数字5也是合法的Python表达式。（ 对 ）
18．在Python中可以使用for作为变量名。（ 错 ）
19．在Python中可以使用id作为变量名，尽管不建议这样做。（ 对 ）
20．Python关键字不可以作为变量名。（ 对 ）
21．Python变量名区分大小写，所以student和Student不是同一个变量。（ 对 ）
22．在Python中，变量不直接存储值，而是存储值的引用，也就是值在内存中的地址。（ 对 ）
23．在条件表达式中不允许使用赋值运算符“=”，会提示语法错误。（ 对 ）

单元3 逻辑运算与流程控制
（一）选择题
1．当知道条件为True，想要程序无限执行直到人为停止的话，需要使用（ C ）语句。
A．for
B．break
C．while
D．if
2．下列表达式的值为True的是（ C ）。
A．5+4j > 2-3j
B．3>2>2
C．1==1 and 2!=1
D．not(1==1 and 0!=1)
3．求比10小且大于或等于0的偶数的代码如下，请将代码补充完善。
x = 10
while x:
x = x-1
if x%2!=0:
（ B ）
print (x)
A．break
B．continue
C．yield
D．flag
4．Python 3解释器执行not 1 and 1的结果为（ B ）。
A．True
B．False
C．0
D．1
5．有以下的程序段，其中k取（ A ）值时x =3。
if k<=10 and k>0:
if k>5:
if k>8:
x=0
else:
x=1
else:
if k>2:
x=3
else:
x=4

A．3 4 5
B．1 2
C．5 6 7
D．5 6
6．以下程序的执行结果是（ B ）。
s = 0
for i in range(1,11):
s += i
if i == 10:
print(s)
break
A．66
B．55
C．45
D．0
7．以下程序的执行结果是（ A ）。
s = 0
for i in range(2,11):
s += i
print(s)
else:
print(1)
A．1
B．2
C．5
D．9
8．假设n为5，那么表达式n&1 == n%2的值为（ B ）。
A．False
B．True
C．5
D．1
9．执行以下代码，其结果为（ A ）。
x = 5
y = 8
print(x == y)
A．False
B．True
C．5
D．8
10．执行以下代码，其结果为（ C ）。
n = 10
sum = 0
number = 1
while number <= n:
sum = sum + number
number += 1
print(sum)
A．0
B．45
C．55
D．66
（二）填空题
1．表达式'\x41' == 'A'的值为{ True }。
2．表达式not 3的值为{ False }。
3．表达式5 if 5>6 else (6 if 3>2 else 5)的值为{ 6 }。
4．表达式1<2<3的值为{ True }。
5．表达式3 or 5的值为{ 3 }。
6．表达式0 or 5的值为{ 5 }。
7．表达式3 and 5的值为{ 5 }。
8．表达式3 and not 5的值为{ False }。
9．Python中用于表示逻辑与、逻辑或、逻辑非运算的关键字分别是and、or和{ not }。
10．Python 3语句for i in range(3):print(i, end= ', ')的输出结果为{ 0,1,2, }。
11．对于带有else子句的for循环和while循环，当循环因循环条件不成立而自然结束时{ 会 }执行else中的代码。
12．在循环语句中，{ break }语句的作用是提前结束本层循环。
13．在循环语句中，{ continue }语句的作用是跳过当前循环中的剩余语句，提前进入下一次循环。
14．表达式[5 for i in range(3)]的值为{ [ 5, 5, 5 ] }。
15．表达式3<5>2的值为{ True }。
（三）判断题
1．带有else子句的循环如果因为执行了break语句而终止的话，则会执行else子句中的代码。（ 错 ）
2．对于带有else子句的循环语句，如果是因为循环条件表达式不成立而自然结束循环，则执行else子句中的代码。（ 对 ）
3．如果仅仅是用于控制循环次数，那么使用for i in range(20)和for i in range(20, 40)的作用是等价的。（ 对 ）
4．在循环中continue语句的作用是跳出当前循环。（ 错 ）
5．在编写多层循环语句时，为了提高运行效率，应尽量减少内循环中不必要的计算。（ 对 ）
6．带有else子句的异常处理结构，如果不发生异常则执行else子句中的代码。（ 对 ）
7．当作为条件表达式时，[]与None等价。（ 对 ）
8．表达式[] == None的值为True。（ 错 ）
9．表达式pow(3,2) == 3**2的值为True。（ 对 ）
10．当作为条件表达式时，空值、空字符串、空列表、空元组、空字典、空集合、空迭代对象以及任意形式的数字0都等价于False。（ 对 ）
11． pass语句仅起到占位符的作用，并不会做任何操作。（ 对 ）

单元4 序列数据与正则表达式操作——列表
（一）选择题
1．Python的join()方法用于将序列中的元素连接生成一个新的字符串，下列描述正确的是（ BD ）。
A．语句''.join('a','b')是合法的
B．语句''.join(['a','b'])是合法的
C．语句''.join([1,2,3])是合法的
D．语句''.join(['1','2','3'])是合法的
2．Python 3解释器执行for i,v in enumerate([0,1,2],2):print(i,v)和for i,v in enumerate([0,1,2]):print(i,v)的结果，正确的选项是（ C ）。
A．结果一致
B．第一个报错
C．第一个序号从2开始，第二个序号从0开始
D．两个都报错
3．Python 3解释器执行list=[1,4,3]，list.extend(list)后list的值是（ C ）。
A．[1,4,3]
B．[1,4,3,[]]
C．[1, 4, 3, 1, 4, 3]
D．None
4．Python3解释器对列表[1,2,[3,4],5,6]使用reverse()方法执行的结果为（ A ）。
A．[6, 5, [3, 4], 2, 1]
B．[6, 5, [4, 3], 2, 1]
C．[6, 5, 2, 1, [3, 4]]
D．报错
5．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[1:3]='abc'后执行list[2]的结果是（ D ）。
A．4
B．c
C．abc
D．b
6．在Python中，关于reverse()方法的说法中，正确的是（ BD ）。
A．reverse()方法返回新的列表
B．reverse()方法没有返回值
C．reverse()方法对列表内的所有元素进行反向排序
D．reverse()方法只对一级元素进行反向排序
7．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list.insert(2,'a')后执行 list[3]的结果是（ B ）。
A．'a'
B．3
C．2
D．4
8．已知列表x = [1, 3, 2]，那么执行语句a, b, c= sorted(x)之后，b的值为（ C ）。
A．1
B．3
C．2
D．None
9．已知x = [3, 5, 7]，那么执行语句x[1:] = [2]之后，x的值为（ B ）。
A．[3, 5, 7]
B．[3, 2]
C．[3, 5, 2]
D．[3]
10．已知x = [1, 2, 3]，那么连续执行y = x和y.append(4)两条语句之后，x的值为（ A ）。
A．[1, 2, 3, 4]
B．[1, 2, 3]
C．[4]
D．[]
11．以下选项属于可变对象的是 ( B )。
A．数值类型(int,float)
B．列表
C．元组
D．字符串
12．设list=['a', 'b', 'c', 'd', 'e', 'f', 'g']，则list[::2]的值是（ C ）。
A．['d', 'e']
B．['d', 'e', 'f', 'g']
C．['a', 'c', 'e', 'g']
D．['c', 'd', 'e']
（二）填空题
1．Python 3解释器执行以下代码后，结果是{ [1, 2, ['a', 5]] }。
>>>list2 = list1 = [1,2,[(3,4),5]]
>>>list1[2][0] = 'a'
>>>list2
2．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[1::2]的结果是{ [2, 4, 6, 8, 0] }。
3．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list.insert(-2,'b')后执行 list[-2]的结果是{ 9 }。
4．Python 3解释器执行list=[2,4,6]，list.extend(list)后的结果是{ [2, 4, 6, 2, 4, 6] }。
5．现有列表list=[2,3,['a','b','c'],1]，那么Python 3解释器执行list[2]=2后list的值是{ [2, 3, 2, 1] }。
6．现有列表list=[2,3,['a','b','c'],1]，那么Python3解释器执行list[2].extend('de')后list的值是{ [2, 3, ['a', 'b', 'c', 'd', 'e'], 1] }。
7．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[3::-1]的结果是{ [4, 3, 2, 1] }。
8．已知x = list(range(20))，那么表达式x[-1]的值为{ 19 }。
9．已知x = [3]，那么执行x += [5]之后x的值为{ [3, 5] }。
10．已知x = [3, 3, 4]，那么表达式id(x[0])==id(x[1])的值为{ True }。
11．表达式list(str([3, 4])) == [3, 4]的值为{ False }。
12．已知x = [3, 2, 4, 1]，那么执行语句x = x.sort()之后，x的值为{ None }。
13．表达式list(filter(lambda x: x>5, range(10)))的值为{ [6, 7, 8, 9] }。
14．已知x = list(range(20))，那么语句print(x[100:200])的输出结果为{ [] }。
15．已知x = list(range(20))，那么执行语句x[:18] = []后列表x的值为{ [18, 19] }。
16．已知x = [1, 2, 3]，那么连续执行y = x[:]和y.append(4)两条语句之后，x的值为{ [1, 2, 3] }。
17．已知x = [1, 2, 3]，那么连续执行y = [1, 2, 3]和y.append(4)两条语句之后，x的值为{ [1, 2, 3] }。
18．已知x = [[]] * 3，那么执行语句x[0].append(1)之后，x的值为{ [[1], [1], [1]] }。
19．已知x = [[] for i in range(3)]，那么执行语句x[0].append(1)之后，x的值为{ [[1], [], []] }。
20．表达式[1, 2] + [3]的值为{ [1, 2, 3] }。
21．已知列表x = list(range(5))，那么执行语句x.remove(3)之后，表达式x.index(4)的值为{ 3 }。
22．已知列表x = [1, 3, 2]，那么执行语句x.reverse()之后，x的值为{ [2, 3, 1] }。
23．已知列表x = [1, 3, 2]，那么执行语句x = x.reverse()之后，x的值为{ None }。
24．已知x为非空列表，那么表达式x.reverse()== list(reversed(x))的值为{ False }。
25．已知x为非空列表，那么表达式x.sort()== sorted(x)的值为{ False }。
26．已知列表x = [1, 3, 2]，那么执行语句y = list(reversed(x))之后，x的值为{ [1, 3, 2] }。
27．已知列表x = [1, 3, 2]，那么执行语句y = list(reversed(x))之后，y的值为{ [2, 3, 1] }。
28．已知列表x中包含超过5个以上的元素，那么表达式x == x[:5]+x[5:] 的值为{ True }。
29．已知列表x = [1, 3, 2]，那么表达式[value for index, value in enumerate(x) if index==2]的值为{ [2] }。
30．已知列表x = [1, 3, 2]，那么执行语句a, b, c= map(str,sorted(x))之后，c的值为{ '3' }。
31．已知x = [1, 2, 3, 4, 5]，那么执行语句del x[:3]之后，x的值为{ [4, 5] }。
32．表达式sorted(['abc', 'acd', 'ade'], key=lambda x:(x[0],x[2]))的值为{ ['abc', 'acd', 'ade'] }。
33．表达式[1, 2, 3] == [1, 3, 2]的值为{ False }。
34．已知x = [1, 2, 1]，那么表达式id(x[0]) == id(x[2])的值为{ True }。
35．表达式3 not in [1, 2, 3]的值为{ False }。
36．已知x = [1, 2]，那么执行语句x[0:0] = [3, 3]之后，x的值为{ [3, 3, 1, 2] }。
37．已知x = [1, 2]，那么执行语句x[0:1] = [3, 3]之后，x的值为{ [3, 3, 2] }。
38．已知x = [1, 2, 3, 4, 5]，那么执行语句del x[1:3]之后，x的值为{ [1, 4, 5] }。
39．已知x = [[1, 2, 3,], [4, 5, 6]]，那么表达式sum([i*j for i,j in zip(*x)])的值为{ 32 }。
40．已知列表x = [1, 2, 3]和y = [4, 5, 6]，那么表达式[(i,j) for i, j in zip(x,y) if i==3]的值为{ [(3, 6)] }。
41．已知列表x = [1.0, 2.0, 3.0]，那么表达式sum(x)/len(x)的值为{ 2.0 }。
42．执行语句x, y, z = sorted([1, 3, 2])之后，变量y的值为{ 2 }。
43．执行语句x, y, z = [1, 2, 3]之后，变量y的值为{ 2 }。
44．已知x = [[1,3,3], [2,3,1]]，那么表达式sorted(x, key=lambda item:(item[1],item[2]))的值为{ [[2, 3, 1], [1, 3, 3]] }。
45．已知列表x = [1, 2]，那么连续执行语句y = x和y.append(3)之后，x的值为{ [1, 2, 3] }。
46．已知列表x = [1, 2]，那么连续执行语句y =x[:]和y.append(3)之后，x的值为{ [1, 2] }。
47．已知列表x = [1, 2]，执行语句y = x[:]后，表达式id(x) == id(y)的值为{ False }。
48．已知列表x = [1, 2]，执行语句y = x后，表达式id(x) == id(y)的值为{ True }。
49．已知列表x = [1, 2]，执行语句y = x后，表达式x is y的值为{ True }。
50．已知列表x = [1, 2]，执行语句y = x[:]后，表达式x is not y的值为{ True }。
51．表达式sorted(random.sample(range(5), 5))的值为{ [0, 1, 2, 3, 4] }。
52．表达式[i for i in range(10) if i>8]的值为{ [9] }。
53．已知有列表x = [[1, 2, 3], [4, 5, 6]]，那么表达式[[row[i] for row in x] for i in range(len(x[0]))]的值为{ [[1, 4], [2, 5], [3, 6]] }。
54．已知列表x = [1, 2]，那么执行语句x.extend([3])之后，x的值为{ [1, 2, 3] }。
55．已知列表x = [1, 2]，那么执行语句x.append([3])之后，x的值为{ [1, 2, [3]] }。
56．假设列表对象x = [1, 1, 1]，那么表达式id(x[0]) == id(x[2])的值为{ True }。
57．已知列表x = list(range(10))，那么执行语句del x[::2]之后，x的值为{ [1, 3, 5, 7, 9] }。
58．已知列表x = [1, 2, 3, 4]，那么执行语句del x[1]之后，x的值为{ [1, 3, 4] }。
59．表达式[1] * 2的值为{ [1, 1] }。
60．表达式[1, 2] * 2的值为{ [1, 2, 1, 2] }。
61．已知列表x = [1, 2, 3]，那么执行语句x.insert(1, 4) 之后，x的值为{ [1, 4, 2, 3] }。
62．已知列表x = [1, 2, 3]，那么执行语句x.insert(0, 4) 之后，x的值为{ [4, 1, 2, 3] }。
63．已知列表x = [1, 2, 3]，那么执行语句x.pop(0)之后，x的值为{ [2, 3] }。
64．已知x = [[1]] * 3，那么执行语句x[0][0] = 5之后，变量x的值为{ [[5], [5], [5]] }。
65．已知x = [1, 2, 3]，那么执行语句x[len(x)-1:] = [4, 5, 6]之后，变量x的值为{ [1, 2, 4, 5, 6] }。
66．已知x是一个列表对象，那么执行语句y = x[:]之后，表达式id(x) == id(y)的值为{ False }。
67．表达式sorted([13, 1, 237, 89, 100], key=lambda x: len(str(x)))的值为