Python基础语法题库

引言：

语法练习包括Python基础语法、数据类型、字符编码和简单文件操作等内容。

正文（参考答案附录在题目下方）：

1、Python 里用来告知解释器跳过当前循环中的剩余语句，然后继续进行下一轮循环，此关键词是__。

continue

View Code

12、Python的设计具有很强的可读性，相比其他语言具有的特色语法有以下选项，正确的是()：
2A   交互式
3B   解释型
4C   面向对象
5D   服务端语言

ABC

View Code

13、Python中==运算符比较两个对象的值，下列选项中哪一个是is比较对象的因素()：
2A   id()
3B   sum()
4C   max()
5D   min()

    A

View Code

14、Python崇尚优美、清晰、是一个优秀并广泛使用的语言，得到行内众多领域的认可，下列属于Python主要应用领域的是:()
2A   系统运维
3B   科学计算、人工智能
4C   云计算
5D   金融量化

ABCD

View Code

15、当知道条件为真，想要程序无限执行直到人为停止的话，可以需要下列哪个选项()：
2A   for
3B   break
4C   while
5D   if

    C

View Code

16、下列实例变量a值为字符串"hello",b变量值为"mooc",下列选项属于正确字符串运算的是()：
2A   a+b
3B   a*2
4C   'h' in a
5D   print("Learn python in %s"%('mooc'))

ABCD

View Code

17、求比10小且大于或等于0的偶数，例题如下：
2
3x = 10
4while x:
5    x = x-1
6    if x%2!=0:
7        ____   
8    print (x)
9
10A   break
11B   continue
12C   yield
13D   flag

    B

View Code

18、在python中，数字类型共包括以下哪几种类型()：
2A   int
3B   float
4C   complex
5D   bool

ABC

View Code

19、以下选项为整数类型的有():
2A   3
3B   3.1
4C   -3
5D   0

ACD

View Code

110、python3解释器执行long(10)的结果为()：
2A   10L
3B   10l
4C   NameError: name 'long' is not defined 
5D   1

1C
2#python3中无long类型，python2中long类型，在python2中输出 10

View Code

111、在python2中，如果变量x = 3,那么，请选择x /= 3的结果为()：
2
3A   3
4B   0
5C   1.0  
6D   1

1D
2 # python3中输出 1.0（相除结果均为小数），只有使用 //(地板除)才可得到整数(两数均为整数时)
3# python2除数中有一数为小数时，结果为小数；都为整数时，则输出整数

View Code

112、下列选项中，数值最小的是（）： 
2
3A    十进制数 55
4B    二进制数 110100
5C    八进制数 101
6D    十六进制数 33

    D

View Code

113、python2解释器在执行2L的8次方的结果为():
2
3A   256   
4B   256L 
5C   256l
6D   报错 

1B
2# python2中有long类型,输出时为大写的 L（小写的l容易误认）
3#python3报错，无long类型

View Code

114、下列字符中对应ASCII码数值最小的是哪个选项（）：
2
3A  B
4B  a
5C  k
6D  M

1A
2# B的值为66，a的值为97，C的值为99，M的值为77，

View Code

115、python解释器执行 a = """""'aaa'"""""表达式的结果为( )：
2
3A   \'aaa\''
4B   '""\'aaa\''
5C   语法错误
6D   我不知道

    B

View Code

116、python解释器执行"金额："￥%f 元" % 1.5000 的结果为( )：
2
3A   '金额：￥1.5 元'
4B   '金额：￥1.500 元'
5C   '金额：￥1.500000 元'
6D   '金额：￥1.50000 元'

1C
2# %f只能占位浮点数，%.xf 则是精确至小数点后x位，默认是6位
3# %s　　字符串占位符

View Code

117、在python中的占位符中，请你选出不属于占位符的选项( ):
2
3A   %d  
4B   %e  
5C   %E  
6D   %z

1D
2%d  整数占位符，即使是原数字为浮点数他也会强制转换变成整数
3%e  将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
4%E  将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）

View Code

118、在python解释器中，执行 '%f' % 1.12345678的结果为( ):
2
3A   '1.1234567'
4B   '1.1234578'
5C   '1.12345678'
6D   '1.123457'  

1D
2# '1.123457'   # 四舍五入

View Code

119、python3解释器执行 not 1 and 1的结果为( ):
2
3A   True
4B   False
5C   0
6D   1

    B

View Code

120、 根据汉字国标GB2312-80的规定，1kb存储容量能存储的汉字机内码的个数是( ):
2A 128
3B 256
4C 512
5D 1024

1C
2# 汉字的内码也就是汉字的内部码，又称汉字机内码。_x000D_ 无论用何种输入码，计入计算机后就立即被转换为机内码进_x000D_ 行存储、运算和传送。规则是将国际码的高位字节、低位字_x000D_ 节各自加上128(十进制)或80(十六进制)。_x000D_ 例如：“中”字的内码以十六进制表示时为D6D0。这样做的目_x000D_ 的是使汉字内码区别于西文的ASCII码，因为每个西文字母的_x000D_ ASCII码的高位均为0，而汉字内码的每个字节的高位均为1。
3
4# 简单理解就是按照汉字国标GB2312-80的规定，一个汉字字符占2Bytes,
5而 1kb = 1024Bytes  = 2*512，即512个汉字字符

View Code

121、在信息组织和存储中，最基本的单位是( ):
2A 字节（Byte）
3B 二进制位（bit）
4C 字（Word）
5D 双字（Double Word）

1B
2# 1 Byte=8bit 位是计算机数据中最小单元，位的值只会是0或1。

View Code

122、设任意一个十进制整数D，转换成二进制数为B，根据数制的概念，下列叙述中正确的是（）。
2A    数字B的位数<数字D的位数
3B    数字B的位数≤数字D的位数
4C    数字B的位数≥数字D的位数 
5D    数字B的位数>数字D的位数

1C
2#   在数值转换中，基数越大，位数越少。当为0、1时，位数可以相等。

View Code

123、字长为7位的无符号二进制整数能表示的十进制整数范围是（）。
2A   0~128
3B   0~255
4C   0~127
5D   1~127

1C
2# 无符号二进制数的第一位可为0，_x000D_ 所以当全为0时最小值为0，当全为1时，_x000D_ 最大值为2**7-1=127。

View Code

124、下列选项中，八进制数24转换成二进制数正确的是（）。
2A   00101100
3B   00010100
4C   00011100
5D   00011101

1B
2# 24(8)=2*8**1+4*18**0=20(10) 利用“除k取余法”是将十进制数除以2， 然后将商继续除以2，直到商为0， 最后将依次所得的余数倒序排列即可得到答案。 例如：8÷2=4……0 4÷2=2……0 2÷2=1……0 1÷2=0……1 故，8(10)--->1000(2)

View Code

125、将二进制数10010101,转换成十进制数，正确的选项为（）。
2A   139
3B   141
4C   149
5D   151

1C
2# 二进制是用0、1表示的数:11101=1*2(4)+1*2(3)+1*2(2)+0*2(1)+1*2(0)算成平时用的数字(十进制)即可

View Code

126、关于下面对unicode作用的描述，正确的是（）。
2A   能够使计算机对跨语言的文本进行转换及处理
3B   能够减少存储大小，节约存储成本
4C   能够使计算机对跨平台的文本进行转换及处理
5D   能够使计算机处理文本速度更快

1AC
2# unicode主要是解决跨语言和跨平台文本的编码问题。

View Code

127、下列对于字符编码的发展历史节点，正确的是（）。
2A   ASCII--->GBK--->UTF-8--->Unicode
3B   ASCII--->Unicode--->GBK--->UTF-8
4C   ASCII--->GBK--->Unicode--->UTF-8
5D   ASCII--->Unicode--->UTF-8--->GBK

1C
2# 最初的ASCII，到中国的gbk，为了满足支持全球的语言到Unicode，为了解决存储问题，最后到UTF-8。

View Code

128、假设，现在有一个UTF-8编码的文件，需要转码成GBK编码的文件，下列操作流程正确的是（）。
2A   encode('gbk')--->decode('utf-8')
3B   encode('utf-8')--->decode('gbk')
4C   decode('gbk')--->encode('utf-8')
5D   decode('utf-8')--->encode('gbk'

1D
2# encode编码，decode解码，文件是什么方式编码的，就应以什么方式解码，故，应先以UTF-8解码成Unicode，然后编码成GBK，此题选D

View Code

129、 Python的解释器本身也可以看作是个程序,并且有多种解释器版本，下列选项属于Python解释器的是():
2A   Cpython
3B   Ipython
4C   PyPy
5D   Jython

1ABCD
2# python的几种解释器，分别是Cpython、Ipython、PyPy、Jython

View Code

30、编程语言通常有固定的后缀，如golang文件是"test.go"，Python文件后缀通常定义为以____结尾。

.py

View Code

131、安装好Python之后，可以有三种方式运行，通过命令行窗口进入，执行Python文件，集成开发环境，下列属于运行方式的是():
2A   浏览器中运行
3B   交互式解释器
4C   命令行脚本
5D   Pycharm

1BCD
2#Python可以通过交互式解释器、命令行脚本、IDE开发环境运行，浏览器无法运行python文件

View Code

132、 Python解释器在主提示符或从属提示符后输入中断符____就会取消当前输入，回到主提示符，会抛出一个KeyboardInterrupt异常。
2A   control-c
3B   ctrl-z
4C   ctrl-o
5D   alt-c

1A
2# control(ctrl) -c可以中断输入，程序运行

View Code

133、作为学习python的开始，需要事先搞清楚，什么是编程语言?下列选项正确的是()：
2A   编程语言是程序员与计算机沟通的介质
3B   能够被计算机识别的表达方式即是编程语言
4C   编程即程序员根据需求把自己的思想流程按照某种编程语言的语法风格编写下来
5D   人类编程控制计算机工作

1ABCD
2# 程序员通过自己的思想流程转换为计算机识别的表达方式即是编程语言

View Code

134、在python中，字符串s = 'abc',那么执行表达式s+'d'之后，s的打印结果是什么():
2A   'abc'
3B   'abcd'
4C   'abc+d'
5D   报错

1A
2# 'abc'，字符串是不可变数据类型，所以字符串s还是不变，但字符串相加后的结果是 'abcd’

View Code

135、关于字符串的replace方法，你认为正确的选项是():
2A   replace方法如果没有替换成功则报错
3B   replace方法如果没有替换成功则将原字符串返回
4C   replace方法如果替换成功返回新的字符串
5D   replace方法如果替换成功，返回原字符串

1BC
2# replace方法如果替换不成功则将原字符串返回，替换成功则返回新的字符串,实例如下：
3a = 'abadaf'
4print(a.replace('a','A',2)) # AbAdaf
5print(a.replace('e','E')) # abadaf
6print(a) # abadaf  不改变原字符串的模样

View Code

136、python解释器执行'1234'.find('5')的结果是():
2A   -1
3B   None
4C   空
5D   报错

1A
2
3b = 'abdegha'
4print(b.find('b'),b.find('c')) # 1 -1 从下标0开始，查找在字符串里第一个出现的子串：返回结果
5print(b.find('a',1),b.find('a',1,6)) # 6  -1 从下标1开始，查找在字符串里第一个出现的子串：返回结果6
6# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
7'''
8find()方法语法：
9
10str.find(str, beg=0, end=len(string))
11
12str -- 指定检索的字符串
13beg -- 开始索引，默认为0。
14end -- 结束索引，默认为字符串的长度。
15
16如果包含子字符串返回开始的索引值，否则返回-1。
17'''

View Code

137、python解释器执行 'abbacabb'.strip('ab') 的结果是()：
2A   'aca'
3B   'ca'
4C   'c'
5D   语法错误

1C
2# strip方法匹配两侧所有的符合条件的字符（括号内指定字符串中的每个字符）

View Code

138、python的join方法用于将序列中的元素以指定的字符连接生成一个新的字符串，那么下列选中中正确的是():
2A   语句''.join('a','b')是合法的
3B   语句''.join(['a','b'])是合法的
4C   语句''.join([1,2,3])是合法的
5D   语句''.join(['1','2','3'])是合法的    

1BD
2# join方法只能接受一个成员参数，并且无法连接int类型的数据，实例如下：
3>>> print(''.join('a','b','c'))
4Traceback (most recent call last):
5  File "<stdin>", line 1, in <module>
6TypeError: join() takes exactly one argument (3 given)
7
8>>> print(''.join([1,2,3]))
9Traceback (most recent call last):
10  File "<stdin>", line 1, in <module>
11TypeError: sequence item 0: expected str instance, int found

View Code

139、python解释器执行 '\n'.join(('ab','cd','we','xy'))的结果为():
2A   报错
3B   'ab\cd\we\xy'
4C   'abcdwexy'
5D   'ab\ncd\nwe\nxy'

1D
2# join会把换行符当成普通连接字符进行连接,通过换行连接，实例如下：
3
4>>> print('\n'.join(('ab','cd','we','xy')))
5ab
6cd
7we
8xy

View Code

40、python2解释器执行 u'abc'.isnumeric()的结果是__ 。

1False
2# isdigit方法判断字符串里全为数字才返回True,而且，python2要通过字符串前加u才能成功判断

View Code

141、python3解释器执行'AB2C3D'.lower().title()的结果是():
2A   'Ab2c3d'
3B   'Ab2C3D'
4C   'AB2C3D'
5D   语法错误

1B
2# title方法将字符串内每个连续字母的首字母大写，其余小写，数字后面的字母被title当成首字母大写了

View Code

42、 现有列表 l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行 l[3::-1] 的结果是__ 。

1[4, 3, 2, 1]
2# 从索引为3的地方开始，依次向前取值

View Code

43、现有列表l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行 l.insert(-2,'b')后执行 l[-2]的结果是__。 

19
2# insert将元素插入到列表对应位置的前一位,插入后列表元素为[1,2,3,4,5,6,7,8,'b',9,0]。

View Code

144、现有列表l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行l[1:3]='abc'后执行 l[2]的结果是():
2A   4
3B   b
4C   abc
5D   c

1B
2# 把l[1:3]的值为2,3 把这两个值替换为a,b,c后，列表[1, 'a', 'b', 'c', 4, 5, 6, 7, 8, 9, 0],那前四个值为，1，'a','b','c'

View Code

145、在python中，关于reverse方法的说法中，你认为正确的是( ):
2A   reverse方法返回新的列表
3B   reverse方法没有返回值
4C   reverse方法对列表内的所有元素进行反向排序
5D   reverse方法只对一级元素进行反向排序

1BD
2# 实例如下：
3>>> L = ['a','d','b',1,2,3,[4,5,6]]
4>>> print(L.reverse(),L)
5(None, [[4, 5, 6], 3, 2, 1, 'b', 'd', 'a'])

View Code

146、现有代码t=('a')，在python3解释器中查看type(t)的到的结果为( ):
2A   <class 'str'>
3B   <class 'tuple'>
4C   (class 'str')
5D   (class 'tuple')

1A
2#此时python解释器将t识别为字符串，哪怕它穿着衣服(套着括号)
3# >>> t = ('a')
4# >>> print(type(t))
5# <class 'str'>

View Code

147、现有代码 d={}，在python3解释器中执行 d[([1,2])] = 'b'得到的结果为():
2A   TypeError: unhashable type: 'list'
3B   {([1, 2]): 'b'}
4C   {(1): 'b'}
5D   以上说法都不对

1A
2# 只有当元组内的所有元素都为不可变类型的时候，才能成为字典的key，实例如下：
3# >>> d ={}
4# >>> d[([1,2])] = 'b'
5# Traceback (most recent call last):
6#   File "<stdin>", line 1, in <module>
7# TypeError: unhashable type: 'list'

View Code

148、python3解释器执行 d = {(1,[2]):'a',(1,2):1}后查看d的结果是( ):
2A   {(1,[2]):'a',(1,2):1}
3B   TypeError: unhashable type: 'list'
4C   {(1,2):'a',(1,2):1}
5D   以上说法都不对

1B
2# 字典的key要为不可变类型
3# >>> d = {(1,[2]):'a',(1,2):1}
4# Traceback (most recent call last):
5#   File "<stdin>", line 1, in <module>
6# TypeError: unhashable type: 'list'

View Code

149、现有d = {'a': 'b',1:1,2:2},python3解释器执行d.pop()的结果是():
2A   报错
3B   (1,1)
4C   ('a':'b')
5D   以上都不对

1A
2# pop方法需要指定删除的key，实例如下：
3>>> d = {'a': 'b',1:1,2:2}
4>>> d.pop('a')
5'b'
6>>> d
7{1: 1, 2: 2}
8>>> d.pop()
9Traceback (most recent call last):
10  File "<stdin>", line 1, in <module>
11TypeError: pop expected at least 1 arguments, got 0

View Code

150、python3解释器执行for x in {'a':'b','c':'d'}:print(x)的结果是什么():
2A   b c
3B   a c
4C   b d
5D   a b

1B
2# 打印字典的key，实例如下：
3>>> for x in {'a':'b','c':'d'}:
4...     print(x)
5...
6a
7c

View Code

151、python3解释器执行 for k,v in {1:'a',2:'b'}:print(k,v)的结果是():
2A   1  b
3B   b  1
4C   1  'b'
5D   TypeError: 'int' object is not iterable

1D
2# 实例如下：
3>>> for k,v in {1:'a',2:'b'}:
4...     print(k,v)
5...
6Traceback (most recent call last):
7  File "<stdin>", line 1, in <module>
8TypeError: cannot unpack non-iterable int object

View Code

152、有集合 s = {1,2,3}，python3解释器执行 del s[2]的结果为( ):
2A   3
3B   2
4C   {1，2}
5D   TypeError: 'set' object doesn't support item deletion 

1D
2# 集合不能索引取值
3>>> s = {1,2,3}
4>>> del s[2]
5Traceback (most recent call last):
6  File "<stdin>", line 1, in <module>
7TypeError: 'set' object doesn't support item deletion

View Code

153、python3解释器执行{1, 2, 'a'} | {2, 3, 4}的结果为():
2A   {2,3,4}
3B   {1, 2, 3, 4, 'a'}
4C   {1,2,3,4}
5D   {2,3,4,'a'}

1B
2# “ | ” 表示并集，即求两个集合的所有元素

View Code

54、python3解释器执行 {2, 3, 4}.symmetric_difference({1, 2, 'a'})的结果为__。

1{3, 1, 'a', 4}
2# symmetric_difference方法表示求集合的对称补集，就是各自求了一次补集，然后加在一起的结果

View Code

55、python3解释器执行 {2, 3, 4}.issubset({2, 3, 4})的结果为__。

1True
2# issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，即前者是否为后者的子集，如果是则返回 True，否则返回 False。此处二者互为子集，实例如下：
3>>> {1,2,3,4}.issubset({2,3,4})
4False
5>>> {1,2,3,4}.issubset({1,2,3,4,5})
6True
7>>> {2,3,4}.issubset({2,3,4})
8True

View Code

56、python3解释器执行d = dict.fromkeys(['apple', 'orange']，10)得到的结果是__ 。

1{'apple': 10, 'orange': 10}
2
3# Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。该方法返回一个新字典。实例如下：
4>>> dic1 = dict.fromkeys((1,2,3))
5>>> dic1
6{1: None, 2: None, 3: None}  # 不指定键值时，默认为None
7>>> dic2 = dict.fromkeys((1,2,3),'hello')
8>>> dic2
9{1: 'hello', 2: 'hello', 3: 'hello'} # 初始化键值为“hello”

View Code

157、 在python中，一共用多少位的精度来表示一个浮点数( ):
2A   128
3B   64
4C   53
5D   32

1B
2# 知识点扩展
3int(x [,base ])         将x转换为一个整数  
4long(x [,base ])        将x转换为一个长整数  
5float(x )               将x转换到一个浮点数  
6complex(real [,imag ])  创建一个复数  
7str(x )                 将对象 x 转换为字符串  
8repr(x )                将对象 x 转换为表达式字符串  
9eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
10tuple(s )               将序列 s 转换为一个元组  
11list(s )                将序列 s 转换为一个列表  
12chr(x )                 将一个整数转换为一个字符  
13unichr(x )              将一个整数转换为Unicode字符  
14ord(x )                 将一个字符转换为它的整数值  
15hex(x )                 将一个整数转换为一个十六进制字符串  
16oct(x )                 将一个整数转换为一个八进制字符串  

View Code

158、请选择python解释器执行'123'.isdigit() 方法返回的结果():
2A   True
3B   False
4C   'True'
5D   因语法错误而报错

1True
2# isdigit() 方法检测字符串是否只由数字组成。
3# 语法：str.isdigit()
4# 返回值: 如果字符串只包含数字则返回 True 否则返回 False。
5# 实例如下：
6>>> print('123'.isdigit() )
7True
8>>> print('abc123'.isdigit())
9False

View Code

59、python3解释器执行'oldboy'.center(8,'-')的结果为__。 

1--mgwl--
2# center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
3# 语法：str.center(width[, fillchar])
4# 参数:   width -- 字符串的总宽度      fillchar -- 填充字符
5# 实例如下：
6>>> str = 'mgwl'
7>>> print(str.center(8,'-'))
8--mgwl--

View Code

160、python解释器执行'{0},{2},{1}'.format('a','b','c')的结果为():
2A   'a,b,c'
3B   'a,c,c'
4C   'a,c,b'
5D   'c,c,b'

1C
2# format 函数可以接受不限个参数，位置可以不按顺序，而可以指定位置传值
3# 实例如下：
4>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
5'hello world'
6 
7>>> "{0} {1}".format("hello", "world")  # 设置指定位置
8'hello world'
9 
10>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
11'world hello world'

View Code

161、python的join方法用于将序列中的元素以指定的字符连接生成一个新的字符串，那么下列选中中正确的是():
2A语句''.join('a','b')是合法的
3B语句''.join(['a','b'])是合法的
4C语句''.join([1,2,3])是合法的
5D语句''.join(['1','2','3'])是合法的

1BD
2# join方法只能接受一个成员参数，无法连接int类型的数据，实例如下：
3>>> print(''.join('a','b))
4  File "<stdin>", line 1
5    print(''.join('a','b))
6                         ^
7SyntaxError: EOL while scanning string literal
8
9>>> print(''.join(['a','b']))
10ab
11
12>>> print(''.join([1,2,3]))
13Traceback (most recent call last):
14  File "<stdin>", line 1, in <module>
15TypeError: sequence item 0: expected str instance, int found
16
17>>> print(''.join(['1','2','3']))
18123

View Code

162、 python解释器执行'-'.join({'a':'b','c':'d'})的结果为():
2A   'a-c'
3B   'a-b-c-d'
4C   'b-d'
5D   报错

1A
2# join的对象是字典的时候，只会连接字典的key，实例如下：
3>>> print('-'.join({'a':'b','c':'d'}))
4a-c

View Code

163、 python中，判断一个字符串是否全由数字组成的方法为str.isnumeric,那么，python2和python3都执行'123'.isnumeric()得到的结果为():
2A   Ture,False
3B   False,True
4C   报错，True
5D   True,报错

1C
2# isnumeric方法只针对unicode对象，所以python2执行会报错，想要不报错，字符串之前加u，实例如下：
3
4# python2.7下
5>>> print('123'.isnumeric())
6Traceback (most recent call last):
7  File "<stdin>", line 1, in <module>
8AttributeError: 'str' object has no attribute 'isnumeric'
9
10>>> print(u'123'.isnumeric())
11True
12
13# python3下
14>>> print('123'.isnumeric())
15True

View Code

164、python3解释器执行'AB2C3D'.lower().title()的结果是():
2A   'Ab2c3d'
3B   'Ab2C3D'
4C   'AB2C3D'
5D   语法错误

1B
2# title方法将字符串内每个连续字母的首字母大写，其余小写，数字后面的字母被title当成首字母大写了，实例如下：
3>>> print('AB2C3D'.lower().title())
4Ab2C3D

View Code

65、 python3解释器执行'abcdd'.endswith('cd')的结果是__。

1False
2# endswith方法是检查字符串是否以指定字符结尾，实例如下：
3>>> print('abcdd'.endswith('cd'))
4False
5>>> print('abcdd'.endswith('dd'))
6True

View Code

66、现有列表l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行l[1::2] 的结果是__。

1[2, 4, 6, 8, 0]
2# 从索引为1的地方开始，以索引+=2的方式取值，实例如下：
3>>> l=[1,2,3,4,5,6,7,8,9,0]
4>>> print(l[1::2])
5[2, 4, 6, 8, 0]

View Code

67、现有列表l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行 l.insert(2,'a')后执行 l[3]的结果是__。

13
2# insert把 ‘a'，插入到l索引为2的地方，前面的值不变，后面的值往后移一个位置，所以 l[3]=3。实例如下：
3>>> l=[1,2,3,4,5,6,7,8,9,0]
4>>> l.insert(2,'a')
5>>> print(l)
6[1, 2, 'a', 3, 4, 5, 6, 7, 8, 9, 0]
7>>> l.insert(-2,'a')
8>>> print(l)
9[1, 2, 'a', 3, 4, 5, 6, 7, 8, 'a', 9, 0]

View Code

68、现有列表l=[1,2,3,4,5,6,7,8,9,0],那么python3解释器执行 l.insert(-2,'b')后执行 l[-1]的结果是__。 

19
2# insert方法将指定元素插入到指定位置原元素的前一位，实例如下：
3>>> l=[1,2,3,4,5,6,7,8,9,0]
4>>> l.insert(-2,'b')
5>>> print(l[-2])
69
7>>> print(l)
8[1, 2, 3, 4, 5, 6, 7, 8, 'b', 9, 0]
9>>> l.insert(2,'a')
10>>> print(l)
11[1, 2, 'a', 3, 4, 5, 6, 7, 8, 'b', 9, 0]

View Code

169、python3解释器执行 for i,v in enumerate([0,1,2],2):print(i,v)和 for i,v in enumerate([0,1,2]):print(i,v)的结果，你认为对的选项是():
2A   结果一致
3B   第一个报错
4C   第一个序号从2开始，第二个从0开始
5D   两个都报错

1C
2# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
3
4# Python 2.3. 以上版本可用，2.6 添加 start 参数。
5# enumerate() 方法的语法: enumerate(sequence, [start=0])
6# sequence -- 一个序列、迭代器或其他支持迭代对象 ；start -- 下标起始位置。
7# 实例如下：
8>>> for i,v in enumerate([0,1,2],2):
9...     print(i,v)
10...
112 0
123 1
134 2
14>>> for i,v in enumerate([0,1,2]):
15...     print(i,v)
16...
170 0
181 1
192 2

View Code

170、 python3解释器执行l=[1,4,3].extend(list())后l的值是():
2A   [1,4,3]
3B   [1,4,3,[]]
4C   []
5D   None

1None
2# extend方法并无返回值，所以l是 None
3# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
4# 方法：list.extend(seq)   该方法没有返回值，但会在已存在的列表中添加新的列表内容。
5# 实例如下：
6la = [1,2,3]
7lb = [5,6,7]
8la.extend(lb)
9print('列表la:',la) # 列表la: [1, 2, 3, 5, 6, 7]

View Code

71、python3解释器执行l=[1,4,3],l.extend(l)后 l的值是__。

1[1, 4, 3, 1, 4, 3] 
2# 实例如下：
3l=[1,4,3]
4l.extend(l)
5print(l) # [1, 4, 3, 1, 4, 3] 

View Code

72、现有列表l=[2,3,['a','b','c'],1],那么python3解释器执行l[2]=2后l的值是__。

1[2, 3, 2, 1]
2# l[2]是['a','b','c'] ,将 ['a','b','c'] 替换为 2
3# 实例如下 ：
4l=[2,3,['a','b','c'],1]
5l[2] = 2
6print(l) # [2, 3, 2, 1] 

View Code

73、现有列表l=[2,3,['a','b','c'],1]，那么python3解释器执行l[2].extend('de')后l的值是__。

1[2, 3, ['a', 'b', 'c', 'd', 'e'], 1]
2# l[2]是['a','b','c'] ,在['a','b','c'] 里追加 ‘d','e', 两个元素。
3# 实例如下：
4l=[2,3,['a','b','c'],1]
5l[2].extend('de')
6print(l) # [2, 3, ['a', 'b', 'c', 'd', 'e'], 1]

View Code

174、python3解释器对列表[1,2,[3,4],5,6]使用reverse方法执行的结果为():
2A   [6, 5, [3, 4], 2, 1]
3B   [6, 5, [4, 3], 2, 1]
4C   [6, 5, 2, 1, [3, 4]]
5D   报错

1[6, 5, [3, 4], 2, 1]
2# reverse方法对列表内的所有元素进行反向排序,而内嵌的2级元素列表内的元素不会被反向排序
3# 实例如下：
4L  = [1,2,[3,4],5,6]
5L.reverse()
6print(L) # [6, 5, [3, 4], 2, 1]

View Code

175、python3解释器执行，下面的示例代码后，l2的结果是():
2>>> import copy
3>>> l1 = [1,2,[3,4]]
4>>> l2 = copy.deepcopy(l1)
5>>> l1[2] = 'a'
6>>> l2

1[1,2,[3,4]]
2# copy.deepcopy为深拷贝，完全的把l1拷贝了一份，所以l1怎么变动都不会跟l2有关系
3# 实例如下：
4>>> import copy
5>>> l1 = [1,2,[3,4]]
6>>> l2 = copy.deepcopy(l1)
7>>> l1[2] = 'a'
8>>> l2
9[1, 2, [3, 4]]
10>>> l1
11[1, 2, 'a']
12
13# 扩展，copy和deepcopy的区别：
14>>> import copy
15>>> l1 = [1,2,[3,4]]
16>>> l2 = l1.copy() # # 浅拷贝
17>>> l3 = copy.deepcopy(l1) #  # 深拷贝
18>>> l1
19[1, 2, [3, 4]]
20>>> l2
21[1, 2, [3, 4]]
22>>> l3
23[1, 2, [3, 4]]
24>>> l1.append('a')
25>>> l2.append('a')
26>>> l3.append('a')
27>>> l1
28[1, 2, [3, 4], 'a']
29>>> l2
30[1, 2, [3, 4], 'a']
31>>> l3
32[1, 2, [3, 4], 'a']
33>>> l1.append('a')
34>>> l1
35[1, 2, [3, 4], 'a', 'a']
36>>> l1[2].append('b')
37>>> l2[2].append('b')
38>>> l3[2].append('b')
39>>> l1
40[1, 2, [3, 4, 'b', 'b'], 'a', 'a']
41>>> l2
42[1, 2, [3, 4, 'b', 'b'], 'a'] # copy后的第一层列表不受原列表影响，第二层列表仍受原列表的影响
43>>> l3
44[1, 2, [3, 4, 'b'], 'a'] # deepcopy后的列表完全独立，不受原列表影响

View Code

176、python3解释器执行下面的示例代码后，l2的结果是():
2>>> l1 = [1,2,[3,4]]
3>>> l2 = copy.deepcopy(l1)
4>>> l1[2] = 'a'
5>>> l2
6A   [1, 2, ['a', 4]]
7B   [1, 2, 'a']
8C   [1, 2, [3, 4]]
9D   报错

1D
2# 没有导入copy模块（需要使用 import 引入），报copy变量没有定义的错误

View Code

177、在python中，关于copy模块的说法，你认为对的是( ):
2
3A   copy模块为python的内置模块，用时无需导入
4
5B   我们可以通过变量复制操作代替copy
6
7C   copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象
8
9D   copy.deepcopy 深拷贝 拷贝对象及其子对象

CD

View Code

178、python3解释器执行下面示例代码后，l2的结果是():
2>>> l2 = l1 = [1,2,[(3,4),5]]
3>>> l1[2][0] = 'a'
4>>> l2

1[1, 2, ['a', 5]]
2# 链式复制，相当于copy.copy
3# 实例如下：
4l2 = l1 = [1,2,[(3,4),5]]
5l1[2][0] = 'a'
6print(l2) # [1, 2, ['a', 5]]

View Code

179、现有代码 t = (1,2)，在python3解释器中执行t * 3 得到的结果为():
2A   语法错误
3B   (1, 2, 1, 2, 1, 2)
4C   (2, 4, 2, 4)
5D   以上说法都不对