Python基础语法题库

引言：

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

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

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

continue

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

ABC

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

    A

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

ABCD

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

    C

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

ABCD

7、求比10小且大于或等于0的偶数，例题如下：

x = 10
while x:
    x = x-1
    if x%2!=0:
        ____
    print (x)

A   break
B   continue
C   yield
D   flag

    B

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

ABC

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

ACD

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

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

11、在python2中，如果变量x = 3,那么，请选择x /= 3的结果为()：

A   3
B   0
C   1.0
D   1

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

12、下列选项中，数值最小的是（）： 

A    十进制数 55
B    二进制数 110100
C    八进制数 101
D    十六进制数 33

    D

13、python2解释器在执行2L的8次方的结果为():

A   256
B   256L
C   256l
D   报错 

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

14、下列字符中对应ASCII码数值最小的是哪个选项（）：

A  B
B  a
C  k
D  M

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

15、python解释器执行 a = """""'aaa'"""""表达式的结果为( )：

A   \'aaa\''
B   '""\'aaa\''
C   语法错误
D   我不知道

    B

16、python解释器执行"金额："￥%f 元" % 1.5000 的结果为( )：

A   '金额：￥1.5 元'
B   '金额：￥1.500 元'
C   '金额：￥1.500000 元'
D   '金额：￥1.50000 元'

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

17、在python中的占位符中，请你选出不属于占位符的选项( ):

A   %d
B   %e
C   %E
D   %z

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

18、在python解释器中，执行 '%f' % 1.12345678的结果为( ):

A   '1.1234567'
B   '1.1234578'
C   '1.12345678'
D   '1.123457'  

D
# '1.123457'   # 四舍五入

19、python3解释器执行 not 1 and 1的结果为( ):

A   True
B   False
C   0
D   1

    B

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

C
# 汉字的内码也就是汉字的内部码，又称汉字机内码。_x000D_ 无论用何种输入码，计入计算机后就立即被转换为机内码进_x000D_ 行存储、运算和传送。规则是将国际码的高位字节、低位字_x000D_ 节各自加上128(十进制)或80(十六进制)。_x000D_ 例如：“中”字的内码以十六进制表示时为D6D0。这样做的目_x000D_ 的是使汉字内码区别于西文的ASCII码，因为每个西文字母的_x000D_ ASCII码的高位均为0，而汉字内码的每个字节的高位均为1。

# 简单理解就是按照汉字国标GB2312-80的规定，一个汉字字符占2Bytes,
而 1kb = 1024Bytes  = 2*512，即512个汉字字符

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

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

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

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

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

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

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

B
# 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)

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

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

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

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

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

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

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

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

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

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

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

.py

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

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

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

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

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

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

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

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

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

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

36、python解释器执行''.find('')的结果是():
A   -1
B   None
C   空
D   报错

A

b = 'abdegha'
print(b.find('b'),b.find('c')) # 1 -1 从下标0开始，查找在字符串里第一个出现的子串：返回结果
print(b.find('a',1),b.find('a',1,6)) # 6  -1 从下标1开始，查找在字符串里第一个出现的子串：返回结果6
# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
'''
find()方法语法：

str.find(str, beg=0, end=len(string))

str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。

如果包含子字符串返回开始的索引值，否则返回-1。
'''

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

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

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

BD
# join方法只能接受一个成员参数，并且无法连接int类型的数据，实例如下：
>>> print(''.join('a','b','c'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: join() takes exactly one argument (3 given)

>>> print(''.join([1,2,3]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

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

D
# join会把换行符当成普通连接字符进行连接,通过换行连接，实例如下：

>>> print('\n'.join(('ab','cd','we','xy')))
ab
cd
we
xy

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{'apple': 10, 'orange': 10}

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

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

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

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

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

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

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

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

C
# format 函数可以接受不限个参数，位置可以不按顺序，而可以指定位置传值
# 实例如下：
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

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

BD
# join方法只能接受一个成员参数，无法连接int类型的数据，实例如下：
>>> print(''.join('a','b))
  File "<stdin>", line 1
    print(''.join('a','b))
                         ^
SyntaxError: EOL while scanning string literal

>>> print(''.join(['a','b']))
ab

>>> print(''.join([1,2,3]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

>>> print(''.join(['','','']))
123

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

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

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

C
# isnumeric方法只针对unicode对象，所以python2执行会报错，想要不报错，字符串之前加u，实例如下：

# python2.7下
>>> print(''.isnumeric())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'isnumeric'

>>> print(u''.isnumeric())
True

# python3下
>>> print(''.isnumeric())
True

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

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

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

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

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

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

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

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

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

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

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

C
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

# Python 2.3. 以上版本可用，2.6 添加 start 参数。
# enumerate() 方法的语法: enumerate(sequence, [start=0])
# sequence -- 一个序列、迭代器或其他支持迭代对象 ；start -- 下标起始位置。
# 实例如下：
>>> for i,v in enumerate([0,1,2],2):
...     print(i,v)
...
2 0
3 1
4 2
>>> for i,v in enumerate([0,1,2]):
...     print(i,v)
...
0 0
1 1
2 2

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

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

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

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

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

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

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

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

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

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

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

[1,2,[3,4]]
# copy.deepcopy为深拷贝，完全的把l1拷贝了一份，所以l1怎么变动都不会跟l2有关系
# 实例如下：
>>> import copy
>>> l1 = [1,2,[3,4]]
>>> l2 = copy.deepcopy(l1)
>>> l1[2] = 'a'
>>> l2
[1, 2, [3, 4]]
>>> l1
[1, 2, 'a']

# 扩展，copy和deepcopy的区别：
>>> import copy
>>> l1 = [1,2,[3,4]]
>>> l2 = l1.copy() # # 浅拷贝
>>> l3 = copy.deepcopy(l1) #  # 深拷贝
>>> l1
[1, 2, [3, 4]]
>>> l2
[1, 2, [3, 4]]
>>> l3
[1, 2, [3, 4]]
>>> l1.append('a')
>>> l2.append('a')
>>> l3.append('a')
>>> l1
[1, 2, [3, 4], 'a']
>>> l2
[1, 2, [3, 4], 'a']
>>> l3
[1, 2, [3, 4], 'a']
>>> l1.append('a')
>>> l1
[1, 2, [3, 4], 'a', 'a']
>>> l1[2].append('b')
>>> l2[2].append('b')
>>> l3[2].append('b')
>>> l1
[1, 2, [3, 4, 'b', 'b'], 'a', 'a']
>>> l2
[1, 2, [3, 4, 'b', 'b'], 'a'] # copy后的第一层列表不受原列表影响，第二层列表仍受原列表的影响
>>> l3
[1, 2, [3, 4, 'b'], 'a'] # deepcopy后的列表完全独立，不受原列表影响

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

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

77、在python中，关于copy模块的说法，你认为对的是( ):

A   copy模块为python的内置模块，用时无需导入

B   我们可以通过变量复制操作代替copy

C   copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象

D   copy.deepcopy 深拷贝 拷贝对象及其子对象

CD

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

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

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

B
# 字符串、列表和元祖支持此种方法复制数据，字典和集合不行
# 实例如下：
>>> str = 'hello'
>>> str*3
'hellohellohello'
>>> t = (1,2)
>>> t*3
(1, 2, 1, 2, 1, 2)
>>> l = [1,2]
>>> l*3
[1, 2, 1, 2, 1, 2]

>>> t = {1,2}
>>> t*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'set' and 'int'
>>> dic = {1:'',2:''}
>>> dic*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'dict' and 'int'

80、在python3.6.2版本的解释器中，我们分别查询长度为一百万的列表和字典的靠后的元素，就查询速度来说():
A   列表快
B   字典快
C   一样快
D   元组快

B
# 字典快，字典为映射关系存储数据，一般的，不管字典多大，查询速度相差无几，而列表查询第一个元素和最后一个元素的速度天差地别

81、 python3解释器执行 d = {1:1,2:1}后查看d的结果是__。

{1: 1, 2: 1}
# 字典的value可以相同，实例如下：
>>> d = {1:1,2:1}
>>> d
{1: 1, 2: 1}

82、现有 d = {},python3解释器执行d['a'] = 'b'后d的结果是__。

{'a': 'b'}
# 实例如下：
>>> d = {}
>>> d['a'] = 'b'
>>> d
{'a': 'b'}

83、现有 d = {},python3解释器执行d[(1,2)] = ({3,(4)})后d的结果是():
A   {(1, 2): {3, 4}}
B   {(1, 2): ({3, 4})}
C   报错
D   以上都不对

A
# 为字典添加了一对键值对
# 实例如下：
>>> d = {}
>>> d[(1,2)] = ({3,(4)})
>>> d
{(1, 2): {3, 4}}

84、现有字典d1 = {'a':1, 'b':2, 'c':3}和d2 = {1:'a', 'b':4, 'd':3}，那么python3解释器执行d1.update(d2)后d2的结果是__。

{1: 'a', 'b': 4, 'd': 3}
# update方法不影响被更新的字典
# 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
# update() 方法语法：dict.update(dict2)
# 参数：dict2 -- 添加到指定字典dict里的字典。
# 返回值：该方法没有任何返回值。
# 实例如下：
>>> d1 = {'a':1, 'b':2, 'c':3}
>>> d2 = {1:'a', 'b':4, 'd':3}
>>> d1.update(d2)
>>> d1
{'a': 1, 'b': 4, 'c': 3, 1: 'a', 'd': 3}
>>> d2
{1: 'a', 'b': 4, 'd': 3}

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

True
# issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
# 语法： set.issubset(set)
# set -- 必需，判断集合 x 的所有元素是否都包含在集合 y 中,如果都包含，则返回 True，否则返回 False。
# 实例如下 ：
>>> x = {"a", "b", "c"}
>>> y = {"f", "e", "d", "c", "b", "a"}
>>> print(x.issubset(y))
True   # 集合x为集合y的子集
>>> print(y.issubset(x))
False  # 集合y不是x的子集

86、关于hash函数，下面说法正确的是( ):
A   hash函数提高了数据安全性
B   hash函数可以用来对密码进行加密
C   hash函数可以用来校验文件的一致性
D   上面说的都对

    D

87、在python中，hash函数无法直接hash字典，但hash(tuple(dict))这种方式是否可行( ):
A   不可行
B   可行
C   这么干不科学
D   上面说的都对

B
# 这么干是可行的，比如hash(tuple({1:1,2:2,3:3,4:4}))，就有hash值，实例如下：
>>> hash(tuple({1:1,2:2}))
3713081631934410656

88、在python中，hash函数依赖一个良好的hash算法，那么这个算法必须具有( ):
A   压缩性
B   抗计算原性
C   抗碰撞性
D   固定长度

ABCD