[118题+解析] Python面试题_设以下变量均为int类型,表达式的值不为 9 的是().a.(x = y = 8, x+y, x+1

1. 以下用C语言开发的Python解释器是（ ）

A JPython
B IronPython
C CPython
D PyPy

正确答案是：C， 您的选择是：C
解析：Jpython是Java语言开发的Python解析器，PyPy是使用Python语言开发的Python解析，IronPython是.net平台上实现的Python解析器。CPython使用C语言开发的解析器，也是默认的Python解析。

2. Python3中获取用户输入并默认以字符串存储的函数是（ ）

A raw_input
B input
C raw
D print

正确答案是：B， 您的选择是：B
解析：Python3中已经删除的raw_input函数。使用input函数用以获取用户输入。

3. 下面函数能够查看变量a指向对象标识的命令是： a=‘julyedu.com’

A id()
B help()
C memoryview()
D type()

正确答案是：A， 您的选择是：D
解析：id函数用以查询对象的ID.

>>> a = "leovin"
>>> id(a)
139767545548912
>>> type(a)
<class 'str'>
1
2
3
4
5

4. 关于Python变量，下列说法错误的是

A 变量不必事先声明类型但区分大小写
B 变量无须先创建和赋值而直接使用
C 变量无须指定类型
D 可以使用del关键字释放变量

正确答案是：B， 您的选择是：B
解析：该题考察了对Python变量的掌握，变量区别大小写，不用事先声明类型，但使用前必须赋值。

5. 下列哪个语句在Python中是非法的？

A x = y = z = 1
B x = (y = z + 1)
C x, y = y, x
D x += y

正确答案是：B， 您的选择是：B
解析：该题考察了对Python操作符的掌握，A,C,D的赋值方法都是正确的。本题选项 B 中的语句非法，因为将 x = (y = z + 1) 中右半部分括起来后，相当于把一个赋值表达式赋值给变量 x，因此出现语法错误。 正确的赋值语法应把括号去掉，即： x = y = z + 1 ，这种赋值方式可称为 连续赋值、批量赋值、多元赋值、多变量赋值 等

6.float('inf')-1执行后的结果

A 1
B inf
C -inf

正确答案是：B， 您的选择是：B
解析：该题考察了对Python数值对象中的无穷数的掌握，inf加减任何数结果都是inf。

>>> float('inf') - 1
inf
>>> 
1
2
3

7. float('inf') < float('inf')+1执行后的结果

A True
B False

正确答案是：B， 您的选择是：B
解析：该题考察了对Python数值对象中的无穷数的掌握，inf加减任何数结果都是inf。因此两个inf比较大小结果为False

>>> float('inf') < float('inf')+1
False

>>> float('inf') == float('inf')+1
True
1
2
3
4
5

8. 运行以下Python中表达式后，x的值为是

x = 3 == 3, 5
1

A. 3
B. 5
C. (True,5)
D. (False,5)

正确答案是：C， 您的选择是：C
解析：程序运算流程：（1）3==3 判定为True；（2）Ture,5 赋值给 x ；（3）x 的值为元组 (True,5)

---

在Python中，不同运算符的优先级决定了表达式中运算符的计算顺序。优先级较高的运算符会先于优先级较低的运算符进行计算。

下表总结了Python中运算符的优先级，从最高优先级（最紧密绑定）到最低优先级（最不紧密绑定）：

在表达式中，如果有多个运算符，那么优先级较高的运算符会先进行计算。例如，在表达式 1 + 2 * 3 中，乘法运算符 * 的优先级高于加法运算符 +，因此会先计算 2 * 3 = 6，然后再计算 1 + 6 = 7。

---

在python中可以将多个值赋给一个变量，这时变量使用tuple接收

>>> a = "leovin", 1024, [1, 2, 3], {"key": "value"}, ("tp1", "tp2")
>>> a
('leovin', 1024, [1, 2, 3], {'key': 'value'}, ('tp1', 'tp2'))
1
2
3

9. 不使用 isinstance() 的情况下，下面（）可以用于测试一个对象是否是一个可迭代对象。

A in
B type
C for
D while

正确答案是：C， 您的选择是：B
解析：该题考察了对Python迭代器的理解。for循环即是对可迭代对象持续进行next调用直到结束。

type()只返回类型

---

isinstance() 是Python的一个内置函数，用于判断一个对象是否为一个已知的类型¹。它的语法如下：

isinstance(object, classinfo)
1

其中，object 是要检查的对象，classinfo 是要检查的类型。如果 object 是 classinfo 类型的实例，则返回 True，否则返回 False。

例如，下面的代码演示了如何使用 isinstance() 函数来检查一个变量是否为整数类型：

x = 1
print(isinstance(x, int)) # 输出 True
1
2

在这个例子中，我们使用 isinstance(x, int) 来检查变量 x 是否为整数类型。由于 x 的值为 1，它是一个整数，因此 isinstance(x, int) 返回 True。

10. 以下代码运行的结果为：

a=b=['AI教育','julyedu.com']
a.append('七月在线') 
print(b)
1
2
3

A [‘AI教育’,‘julyedu.com’]
B [‘AI教育’,‘julyedu.com’,‘七月在线’]
C [‘七月在线’]
D NoneType

正确答案是：B， 您的选择是：A
解析：该题考察了对Python中可变对象与不可变对象的理解 。可变对象是指可以被其引用所改变的对象。

在这段代码中，a 和 b 都被赋值为指向同一个列表对象的引用。当我们使用 a.append('七月在线') 时，实际上是在修改这个列表对象，向其中添加了一个新元素 '七月在线'。由于 a 和 b 都指向这个列表对象，因此当我们打印 b 时，会看到列表中已经添加了新元素 '七月在线'。

数组.append是会改变数据本身的！

11. 以下代码返回：

a=15 
True if a!=5 else False
1
2

A 5
B 15
C True
D False

正确答案是：C， 您的选择是：C
解析：该题考察了对Python中三元表达式的掌握 。

>>> correct = "True"
>>> "Yes" if correct else "Nope"
'Yes'
1
2
3

12. 下面程序的输出结果是什么？

alist = [[1,2],3,4]
blist = alist 
blist[0]=1 
print(alist)
1
2
3
4

A [1,[1,2],3,4]
B [1, 3,4]
C [[1,2],1, 3,4]
D [[1,1,2], 3,4]

正确答案是：B， 您的选择是：B
解析：考查对可变数据类型（列表）的使用，以及列表的索引赋值的使用。

13. 以下python数据类型中不支持索引访问的是（ ）

A 字符串
B 列表
C 元组
D 集合

正确答案是：D， 您的选择是：D
解析：ABC都是Python中的序列，但set不是，set本身是无序且不重复的，因此，它不能够通过索引及切片进行访问。

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
1
2
3
4
5
6
7
8
9
10

14. Python3中，9/3.0的结果是

A 3
B 3.0
C 1.0

正确答案是：B， 您的选择是：B
解析：3.0是一个浮点数，返回结果也是一个浮点数。

不管是3还是3.0，运算符/都返回一个浮点数

15. 现要将某气象观测站每天不同时间点的气温及湿度的观察值保存，方便以后进行调用及查询，在Python3哪种数据结构更合适？

A 字符串
B 列表
C 集合
D 字典

正确答案是：D， 您的选择是：D
解析：字典是一个非常重要且非常有用的数据结构。我们可以把日期时间当做key值，value值由一个列表或一个字典构成，来记录温湿度等情况。

>>> record_dict = {"2022.5.4": {"temp": "25", "humi": "xxx"}}
>>> record_dict["2022.5.4"]
{'temp': '25', 'humi': 'xxx'}
>>> record_dict["2022.5.4"]["temp"]
'25'
>>> record_dict["2022.5.4"]["humi"]
'xxx'
>>> record_dict = {"2022.5.4": [25, "xxx"]}
>>> record_dict
{'2022.5.4': [25, 'xxx']}
>>> record_dict["2022.5.4"]
[25, 'xxx']
>>> record_dict["2022.5.4"][0]
25
>>> record_dict["2022.5.4"][1]
'xxx'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

16. Python3中，2*5**2的值为

A 20
B 30
C 40
D 50

正确答案是：D， 您的选择是：D
解析：考察对Python中运算符的顺序理解，**优先级高于*。

17. 如果一个函数没有return语句，调用它后的返回值为

A 0
B True
C False
D None

正确答案是：D， 您的选择是：D
解析：考察对Python函数中return关键词的使用，无return时，函数依旧会返回一个类型为NoneType的对象None。

18. 如果一个函数没有return语句，调用它的返回值的类型为

A bool
B function
C None
D NoneType

正确答案是：D， 您的选择是：D
解析： 考察Python函数返回的认识，一个函数可以有return，也可以没有。但无论有没有return，函数都被返回一个对象。如果没有return,返回的是None对象，它的type就是NoneType.

19. 类中的变量一般不允许直接修改，否则会破坏面向对象（ ）

A 封装特性
B 继承特性
C 多态特性
D 以上都对

正确答案是：A， 您的选择是：D
解析：无论是类变量还是实例变量，通常都设计为私有变量，然后通过指定的方法作为接口供外部访问，这样能保证数据的封装性。

20. 可以使用函数（ ）查看包含当前作用域内所有局部变量和值的字典。

A locals()
B globals()
C dir()
D help()

正确答案是：A， 您的选择是：C
解析：locals() 函数会以字典类型返回当前位置的全部局部变量。

>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': ('leovin', 1024, [1, 2, 3], {'key': 'value'}, ('tp1', 'tp2')), 'correct': 'True', 'record_dict': {'2022.5.4': [25, 'xxx']}}
1
2

21. 正则表达式中\s表示的是

A 非空格
B 空格
C 非数字
D 数字

正确答案是：B， 您的选择是：C
解析：正则表达式基本知识点。s代表space

22. sorted([15, ‘china’, 407], key=lambda x: len(str(x))) 返回为

A [15,407,‘china’]
B [‘china’,407,15]
C [‘china’,15,407]
D [15,‘china’,407]

正确答案是：A， 您的选择是：B
解析：sorted本身是一个高阶函数，参数key接收传入函数及参数，并按参数的长度进行重新排序。默认升序

23. 下列哪种情况不会导致Python对象的引用计数增加

A 对象被创建
B 被作为参数传递给函数
C 成为容器对象的元素
D 该对象无法访问时

正确答案是：D， 您的选择是：D
解析：可以使用sys库中的getrefcount方法用于查看，一个对象被引用多少次。

---

在Python中，每个对象都有一个引用计数，用于记录有多少个变量或数据结构指向该对象。当一个对象被创建时，它的引用计数会初始化为1。当有新的变量或数据结构指向该对象时，它的引用计数会增加。例如，当一个对象被作为参数传递给函数时，或者成为容器对象的元素时，它的引用计数都会增加。

当一个对象无法访问时，它的引用计数不会增加。相反，当一个变量或数据结构不再指向该对象时，它的引用计数会减少。当一个对象的引用计数减少到0时，它将被垃圾回收器回收。

>>> sys.getrefcount(a)
2
1
2

24. 下列表达式的值为True的是

A 5+4j > 2-3j
B 3 > 2 > 2
C (3,2) < (‘a’, ‘b’)
D ‘abc’ < ‘xyz’

正确答案是：D， 您的选择是：D
解析：A复数之间无法比较,B是两次比较。C中数字和字符串无法直接进行比较。。D中的字符串可以进行比较，按ASCII编码的大小进行比较。可以使用ord函数查看。

>>> ord("a")
97
>>> ord("b")
98
>>> ord("c")
99
>>> ord("x")
120
>>> ord("y")
121
>>> ord("z")
122
1
2
3
4
5
6
7
8
9
10
11
12

24. 对于Python中的复数，下列说法错误的是

A 表示复数的语法是real + image j
B 实部和虚部都是浮点数
C 虚部必须后缀j，且必须是小写
D 复数对象之间无法进行比较

正确答案是：C， 您的选择是：D
解析：考察对于复数的理解。C项错误,大写J也可以

25. 对函数式编程思想的理解中，不正确的是

A 函数式编程是一种结构化编程范式，是如何编写程序的方法论
B 函数是第一等公民first class,是指它享有与变量同等的地位
C 函数式编程中，变量不可以指向函数
D 高阶函数可以接收入另一个函数作为其输入参数

正确答案是：C， 您的选择是：C
解析：函数可以像变量一样被当被参数传入，也可以被return。

26. 下面创建集合语句中错误的是

A s1 = set ()
B s2 = set (“abcd”)
C s3 = {1, 2, 3, 4}
D s4 = frozenset( (‘string’) ,(1,2,3) )

正确答案是：D， 您的选择是：B
解析：set的初始化可以是set(),也可以是{}，但frozenset的初始化参数只有一个。frozenset()返回一个冻结的集合,冻结后集合不能再添加或删除任何元素

>>> a = {"a", 123, [12,34]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> a = {"a", 123}
>>> type(a)
<class 'set'>
1
2
3
4
5
6
7

27. 正则中的^符号，用在一对中括号中则表示要匹配

A 字符串的开始
B 除中括号内的其它字符
C 字符串的结束
D 仅中括号内含有的字符

正确答案是：B， 您的选择是：D
解析：考察正则匹配中^符号的不同使用方法的掌握。

• 当^不出现在中括号中，代表是匹配开始字符。
• ^在中括号中出现时，就代表匹配除了该中括号中出现的所有字符。

28. 静态成员变量称为类变量，非静态成员变量称为实例变量，下列关于一个类的静态成员的描述中，不正确的是

A 该类的对象共享其静态成员变量的值
B 静态成员变量可被该类的所有方法访问
C 该类的静态方法只能访问该类的静态成员变量
D 该类的静态数据成员变量的值不可修改

正确答案是：D， 您的选择是：D
解析：该题考察了对Python中静态成员变量（类变量）的掌握程度。只有Ｄ项陈述有误，类变量可以被实例或类本身访问或修改。这也是类变量存在的作用。

29. 在Python3下输入100000000L，会得到

A 100000000L
B 100000000
C SyntaxError: invalid syntax
D 1e8

正确答案是：C， 您的选择是：D
解析：Python2中的长整形变量的初始化及表示，在3中被取消了，因为赋值会出现。

>>> 100000000L
  File "<stdin>", line 1
    100000000L
             ^
SyntaxError: invalid syntax

>>> 100000000
100000000
1
2
3
4
5
6
7
8

30. 下面的排序算法中初始数据集的排列顺序对算法的性能无影响的是

A 插入排序
B 堆排序
C 冒泡排序
D 快速排序

正确答案是：B， 您的选择是：B
解析：堆排序本质为完全二叉树，最小元素位于根部。

冒泡排序有优化步骤，最优情况是O(n), 和初始顺序有关

31. 正则表达式中的特殊字符，匹配字母,数字,下划线（ ）

A. \d
B. \D
C. \w
D. \s

正确答案是：C， 您的选择是：B
解析：正则表达式中反斜线代表对后边的字符进行转义，＼ｗ

32. 正则表达式中的非贪婪模式使用哪个符号

A. $
B. \∧
C. {}
D. ?

正确答案是：D， 您的选择是：A
解析：本题考察了Python正则的非贪婪模式的表示。

33. Python中heapq是一种（ ）数据结构

A 树型数据结构
B 列表数据结构
C 队列数据结构
D 链表数据结构

正确答案是：A， 您的选择是：C
解析：heapq是Python自带的完全二叉树结构的类型

34. deque是一种（ ）数据结构

A Heap
B Stack
C 队列
D 双端队列

正确答案是：D， 您的选择是：C
解析：queue是Python自带队列类型，deque是双端队列

deque = dual queue

35. 可以认为list类型是一种（ ）结构

A 树型
B 队列
C Stack
D 链表

正确答案是：C， 您的选择是：B
解析：list数据类型本质上既不是栈（stack）也不是链表（linked list）结构。它是一种动态数组，底层使用连续的内存空间来存储元素。

然而，list数据类型可以用来实现栈和队列这两种数据结构。栈是一种后进先出（LIFO）的数据结构，可以使用list类型的 append() 方法来实现入栈操作，使用 pop() 方法来实现出栈操作。队列是一种先进先出（FIFO）的数据结构，可以使用list类型的 append() 方法来实现入队操作，使用 pop(0) 方法来实现出队操作。

此外，list数据类型也可以用来模拟链表结构。链表是一种线性数据结构，它由一组节点组成，每个节点都包含一个数据元素和一个指向下一个节点的指针。尽管list类型在底层实现上并不是严格意义上的链表，但它提供了类似于链表的功能和操作。

总之，list数据类型本质上是一种动态数组，但它可以用来实现栈、队列和链表这三种数据结构。

36. 下列的说法中，不正确的是

A 迭代器协议是指：对象必须提供一个next方法
B list、dict、str虽然是Iterable，却不是Iterator
C 生成器与迭代器对象的区别在于：它仅提供next()方法
D 生成器实现了迭代器协议，但生成器是边计算边生成达到节省内存及计算资源

正确答案是：C， 您的选择是：C
解析：迭代器和生成器都是Python中特有的概念，迭代器可以看作是一个特殊的对象，每次调用该对象时会返回自身的下一个元素。 一个可迭代的对象必须是定义了__iter__()方法的对象（如列表，元组等），而一个迭代器必须是定义了__iter__()方法和next()方法的对象。因此C选项错误。

37. 以下代码的作用是？

import sys
sys.path.append('/root/mydir/')
1
2

A 改变python的启动路径
B 改变python目前的工作路径
C 添加一个新的python模块的搜索路径
D 从/root/mydir中移除所有的文件夹

正确答案是：C， 您的选择是：C
解析：sys是python中的系统模块，sys.path.apped是增加python模块的搜索路径。

38. [index]执行以下代码的结果是？

names = ['Amir', 'Betty', 'Chales', 'Tao'] 
names.index("Edward")
1
2

A -1
B 4
C 异常报错

正确答案是：C， 您的选择是：A
解析：该题考察列表对象index方法的使用及出现异常（即元素不存在列表中）的情况。

>>> names = ['Amir', 'Betty', 'Chales', 'Tao']
>>> names.index("Amir")
0
>>> names.index("leovin")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'leovin' is not in list
1
2
3
4
5
6
7

39. [list]执行以下代码的结果是？

numbers = [1, 2, 3, 4] 
numbers.extend([5,6,7,8]) 
len(numbers)
1
2
3

A. 4
B. 5
C. 8
D. 12

正确答案是：C， 您的选择是：B
解析：该题考察对列表对象的extend方法的掌握，extend方法会将一个可迭代对象中的每个元素，依次添加到列表对象的最右侧。与之相对的是append方法。

append、extend都是在末尾添加元素。虽然两者都是以容器的形式添加元素，但

• append添加是将容器看作整体来进行添加
• extend是将容器打碎后添加（加入的只是元素）

>>> a = [1, 2, 3, 4]
>>> a.extend([5, 6, 7, 8])
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a = [1, 2, 3, 4]
>>> a.append([5, 6, 7, 8])
>>> a
[1, 2, 3, 4, [5, 6, 7, 8]]
1
2
3
4
5
6
7
8

40. [list]执行以下代码的结果是？

def addItem(listParam):
	listParam += [1] 

mylist = [1, 2, 3, 4] 
addItem(mylist) 
print(len(mylist))
1
2
3
4
5
6

A. 1
B. 2
C. 5
D. 8

正确答案是：C， 您的选择是：C
解析：该题考察的是list对象的+号操作符的使用，以及len的使用。

>>> a = [1, 2, 3, 4]
>>> a += [5]
>>> a
[1, 2, 3, 4, 5]  # + 号是append
>>> b = [6]
>>> a + b
[1, 2, 3, 4, 5, 6]  # + 号是append
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]  # + 号是append
1
2
3
4
5
6
7
8
9

列表对 + 和 * 的操作符与字符串相似。

• + 号用于组合列表
• * 号用于重复列表。

如下所示：

41. [list]执行以下代码的结果是？

list1 = [1, 2, 3, 4] 
list2 = [5, 6, 7, 8] 
len(list1 + list2)
1
2
3

A. 2
B. 4
C. 5
D. 8

正确答案是：D， 您的选择是：B
解析：该题考察的是list对象+号操作符的使用，以及len的使用。+号用于连接两个列表对象，返回一个新列表中包含两个列表中的每个元素。

[tuple]42. 执行以下代码的结果是？

my_tuple = (1, 2, 3, 4) 
my_tuple.append( (5, 6, 7) ) 
len(my_tuple)
1
2
3

A. 2
B. 5
C. 8
D. An exception is thrown

正确答案是：D， 您的选择是：D
解析：该题考察的是tuple对象的理解。tuple对象一经建立，便无法再对其进行添加，删除等操作。tuple可以认为是只读的list

43. Python3 执行以下代码的结果是？

type(lambda:None)
1

A < type ‘NoneType’>
B < type ‘function’>
C < type ‘tuple’>
D < type ‘type’>

正确答案是：B， 您的选择是：B
解析：该题考察的是函数对象的理解，lambda是匿名函数，因此它的type和普通函数一样，也是function。

>>> type(lambda:None)
<class 'function'>
>>> type(lambda x,y: x+y)
<class 'function'>
1
2
3
4

44. [global]执行以下代码的结果是？

counter = 0 
def doThings(): 
	global counter 
	for i in (1, 2, 3):  
		counter += 1 

doThings() 
print(counter)
1
2
3
4
5
6
7
8

A. 3
B. 5
C. 6
D. 8

正确答案是：A， 您的选择是：C
解析：该题考察的是Python中变量作用域的掌握。当在函数中使用global关键字时，即代表使用的是全局变量。这时对该变量的变更，即便是函数结束后，也会存在。

[or and] 45. 执行以下代码的结果是？

x=True
y,z=False，False 
if x or y and z: 
	print('yes') 
else: print('no')
1
2
3
4
5

A. yes
B. no
C. unable to run
D. An exception is thrown

正确答案是：A， 您的选择是：B
解析：该题考察的是变量赋值的知识点，以及对and与 or或运算顺序的掌握。 x or y and z，先执行的是and得到了False，然后再去执行or，得到True。

>>> print("Yes") if x or y and z else print("No")
Yes
1
2

46. [len] 执行以下代码的结果是？

len([1,2,3,None,(),[],])
1

A. 3
B. 4
C. 5
D. 6

正确答案是：D， 您的选择是：D
解析：该题考察的是对列表对象中元素计数的掌握，None是一个NoneType型对象，()为元组型对象，[]为列表型对象，列表中最后一个逗号可以存在，不会引起语法错误。

47. [type] 执行以下代码的结果是？

def f():
	pass 
type(f())
1
2
3

A < type ‘function’ >
B < type ‘NoneType’ >
C < type ‘type’ >
D < type ‘str’ >

正确答案是：B， 您的选择是：B
解析：该题考察的是对函数调用的掌握。调用函数时使用()小括号，返回的是函数执行后的结果。即使是只有pass语句，没有return，函数依旧会返回一个None对象。

48. [type] 执行以下代码的结果是？

def f():
	pass 
type(f)
1
2
3

A < type ‘function’ >
B < type ‘NoneType’ >
C < type ‘type’ >
D < type ‘str’ >

正确答案是：A， 您的选择是：A
解析：该题考察的是对函数引用的掌握。函数名也是一个变量，用于建立起对函数的引用。这时的type就是看f这个变量指向的函数的类型，即function.

49. [map]执行以下代码的结果是？

values = [2, 3, 2, 4] 
def my_transformation(num):
	return num ** 2 
for i in map(my_transformation, values):
	print (i)
1
2
3
4
5

A. 2,3,2,4
B. 4,6,4,8
C. 4,5,4,6
D. 4,9,4,16

正确答案是：D， 您的选择是：D
解析：该题考察对高阶函数map的使用，map函数的工作流程是接收一个处理函数，和一个可迭代对象。然后将可迭代对象中的元素一个一个传递给处理函数去处理，由处理函数负责对元素进行映射后返回。

---

map()会根据提供的函数对指定序列做映射。

语法：

map(function, iterable, ...)
1

参数：

• function – 函数
• iterable – 一个或多个序列

返回值：

• Python 2.x 返回列表。
• Python 3.x 返回迭代器。

例子：

>>> def square(x):
...     return x ** 2
... 
>>> map(square, [1, 2, 3, 4, 5])  # 计算列表各个元素的平方
<map object at 0x7f3b14b18550>  # 返回的是一个map对象，该对象是可迭代的
>>> list(map(square, [1, 2, 3, 4, 5]))  # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x**2, [1, 2, 3, 4, 5]))
[1, 4, 9, 16, 25]

# ---------------------

# 遍历可迭代对象
>>> map_a = map(square, [1, 2, 3, 4, 5])  # 计算列表各个元素的平方
>>> for i in map_a:  
...     print(i)
... 
1
4
9
16
25

# 迭代可迭代对象
>>> map_a = map(square, [1, 2, 3, 4, 5])  # 计算列表各个元素的平方
>>> for idx, value in enumerate(map_a):
...     print(f"{idx}: {value}")
... 
0: 1
1: 4
2: 9
3: 16
4: 25
>>> for idx, value in enumerate(map_a):
...     print(f"{idx}: {value}")
...   # 可以看到，可迭代对象被迭代完毕了，再次迭代就没有值了

>>> list = range(5)
>>> for i in list:
...     print(i)
... 
0
1
2
3
4
>>> for i in list:
...     print(i)
... 
0
1
2
3
4
>>> for idx, value in enumerate(list):
...     print(idx, value)
... 
0 0
1 1
2 2
3 3
4 4
>>> for idx, value in enumerate(list):
...     print(idx, value)
... 
0 0
1 1
2 2
3 3
4 4

"""
	说明map对象被迭代会自动销毁被取出的值
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

50. 执行以下代码的结果是？

def checkit(num):
	if num in [1,2,3]:
		return True
	else:
		return False

for i in filter(checkit,[1,2,1,3,1,4]):
	print (i)
1
2
3
4
5
6
7
8

A. 1 2 3
B. 1,2,3,4
C. 1,2,1,3,1
D. 1,2,1,3,1,4

正确答案是：C， 您的选择是：C
解析：该题考察对高阶函数filter的使用，filter函数的工作流程是接收一个处理函数，和一个可迭代对象。然后将可迭代对象中的元素一个一个传递给处理函数去处理，由处理函数负责对元素进行处理后，选择返回是True,或False，然后将所有可迭代对象中位置为True的元素进行返回。

51. [len & 类]执行以下代码的结果是？

class Person:
	def __init__(self, id):
		self.id = id 


jack = Person(1) 
jack.__dict__['age'] = 22 
print(jack.age + len(jack.__dict__))
1
2
3
4
5
6
7
8

A. 2
B. 22
C. 23
D. 24

正确答案是：D， 您的选择是：D
解析：该题考察对对象中__dict__的掌握。 __dict__除了能返回的是一个字典，key为对象的属性，value为属性的值。还可以对对象直接新增属性。

>>> class Person:
...     def __init__(self, id):
...         self.id = id
... 
>>> jack = Person(10086)
>>> print(jack.__dict__)
{'id': 10086}
>>> print(jack.age)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'age'
>>> jack.__dict__['age'] = 25
>>> print(jack.age)
25
>>> jack.money = 1000
>>> jack.__dict__["money"]
1000
>>> jack.money
1000
>>> jack.__dict__
{'id': 10086, 'age': 25, 'money': 1000}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

记住：

• 实例对象.__dict__可以以dict的形式查看类属性（不能查看类方法）
• 实例对象.xxx = xxxx可以为实例对象添加类属性
• 可以使用dir(实例对象)来查看类所有的属性和方法

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', 
'__str__', '__subclasshook__', '__weakref__', 'drink', 'id']
1
2
3
4
5

52. [doc] 执行以下代码的结果是？

def foo():
	"This is a cool simple function that return 1"
	return 1 

foo.__doc__[-8:-2]
1
2
3
4
5

A. 1
B. ‘returns 1’
C. ‘return’
D. True

正确答案是：C， 您的选择是：C
解析：该题考察对类中__doc__，及字符串切片访问的掌握。 __doc__是Python中类的魔法属性，通常为在类及函数定义时的第一行字符串，作为文档共使用者使用.__doc__进行调用。返回值是字符串类型。因此C选项正确

>>> def foo():
...     "This is a cool simple function that return 1"
...     return 1
... 
>>> foo()
1
>>> foo.__doc__
'This is a cool simple function that return 1'
>>> foo.__doc__[-8: -2]
'return'
1
2
3
4
5
6
7
8
9
10

53. [set] 执行以下代码的结果是？

foo = {1,3,3,4} 
type(foo)
1
2

A set
B dict
C tuple
D object

正确答案是：A， 您的选择是：A
解析：该题考察对集合初始化的掌握。集合可以用set(),或{}两种方式进行初始化。当使用{}进行初始化时，如果元素为k：v对应型元素，则自动转为字典类型。如果只是key值，则为set集合。

>>> exp_1 = {"123", "abc"}
>>> exp_2 = {"123":"abc"}
>>> type(exp_1)
<class 'set'>
>>> type(exp_2)
<class 'dict'>
1
2
3
4
5
6

关于set需要注意的是，set里面是没有重复元素的，例子如下：

>>> set_exp = {"123", "123", "123"}
>>> tuple_exp = {"123", "123", "123"}
>>> set_exp = {"123", "123", "123"}
>>> tuple_exp = ("123", "123", "123")
>>> dict_exp = {"123": "123", "123": "123", "123": "123"}
>>> list_exp = ["123", "123", "123"]
>>> print(f"{set_exp}\n {tuple_exp}\n {dict_exp}\n {list_exp}")
{'123'}
 ('123', '123', '123')
 {'123': '123'}
 ['123', '123', '123']
1
2
3
4
5
6
7
8
9
10
11

字典（dict）也有和set类似的属性，我们看下面的例子：

>>> dict_1 = {"123": "123", "123": "123", "123": "123"}
>>> dict_2 = {"123": "123", "123": "456", "123": "789"}
>>> dict_3 = {"abc": "123", "def": "123", "ghi": "123"}
>>> print(f"{dict_1}\n{dict_2}\n{dict_3}")
{'123': '123'}
{'123': '789'}
{'abc': '123', 'def': '123', 'ghi': '123'}
1
2
3
4
5
6
7

从上面很容易明白，dict和set一样，不存在重复的元素，只不过dict是针对key，不针对value

• set：里面没有重复的元素
• dict：没有重复的key，哪怕value不同也不行（对于相同的key后面的value会覆盖前面的value）

54. [*传参]执行以下代码的结果是？

def dosomethings(param1, *param2):     
	print (param2) 
dosomethings('apples', 'bananas', 'cherry', 'kiwi')
1
2
3

A (‘bananas’)
B (‘bananas’, ‘cherry’, ‘kiwi’)
C [‘bananas’, ‘cherry’, ‘kiwi’]
D param2

正确答案是：B， 您的选择是：B
解析：该题考察对Python函数中的定位参数及不定长定位参数的掌握。 param1参数在本例中对应的传入参数apples,而后边的’bananas’, ‘cherry’, 'kiwi’均被打包进param2中，因为在函数定义时param2的前边有*号表示这是一个不定长定位参数,会将后边的不定长个定位参数打包为一个tuple。因为B选项正确。

55. [*list]执行以下代码的结果是？

def myfoo(x, y, z, a):
	return x + z
nums = [1, 2, 3, 4] 
myfoo(*nums)
1
2
3
4

A. 3
B. 4
C. 6
D. 10

正确答案是：B， 您的选择是：B
解析：该题考察对 Python 函数中的定位参数，不定长定位参数的掌握。本题中将 nums 这个含有 4 个元素的列表对象作为参数传递给 myfoo 函数。但 myfoo 函数声明时接收 4 个参数，个数是匹配的。这时在 nums 前边加入*号，代表将 nums 列表对象进行解包后传参。另外需注意的是定位参数的位置这个重要的特性。

56. [getattr & setattr]执行以下代码的结果是？

class A: 
	def __init__(self, a, b, c):
		self.x = a + b + c 

a = A(1,2,3) 
b = getattr(a, 'x') 
setattr(a, 'x', b+1) 
a.x
1
2
3
4
5
6
7
8

A. 6
B. 7
C. 8

正确答案是：B， 您的选择是：B
解析：该题考察对BIFs中getattr及setattr的掌握。

• setattr可以对一个对象动态添加属性
• 而getattr负责读取某类的指定属性的值

57. [dict.update()]执行以下代码的结果是？

d1= { '1' : 1, '2' : 2 , '3' : 3, '4' : 4, '5' : 5} 
d2 = { '1' : 10, '3' : 30 } 
d1.update(d2) 
sum(d1.values())
1
2
3
4

A. 15
B. 40
C. 51
D. 54

正确答案是：C， 您的选择是：C
解析：该题考察对Python字典对象update方法掌握。 update方法会把参数字典对象的元素与原调用字典进行合并，如果遇到重名的key值，则会覆盖原字典。因此C选择对。

58. [dict()]执行以下代码的结果是？

d1 = { '1' : 1, '2' : 2 } 
d1copy = dict(d1) 
d1['1'] = 5 
d1['1'] + d1copy['1']
1
2
3
4

A. 2
B. 4
C. 6

正确答案是：C， 您的选择是：C
解析：list(),set(),dict()等工厂函数执行的是深拷贝

>>> d1 = {"1": 1, "2": 2}
>>> d1_copy = dict(d1)
>>> d1['1'] = 5
>>> print(f"{d1}\n{d1_copy}")
{'1': 5, '2': 2}
{'1': 1, '2': 2}
>>> d1["1"] + d1_copy["1"]
6
1
2
3
4
5
6
7
8

59. [copy.deepcopy()]执行以下代码的结果是？

import copy 
l1=[1,2,3,[1,2,3]] 
l2=copy.deepcopy(l1) 
l2[-1].append(4) 
l1
1
2
3
4
5

A. [1,2,3,[1,2,3]]
B. [1,2,3,[1,2,3,4]]
C. [1,2,3,4]
D. [1,2,3,4,[1,2,3]]

正确答案是：A， 您的选择是：A
解析：该题考察对深度拷贝的掌握。 深度拷贝是将原对象中所有的值完全复制一份存放在内存中(包括可变数据类型对象)。这样遇到原对象即使是更改，也不会影响其值。

60. [浅拷贝]执行以下代码的结果是？

import copy 
l1=[1,2,3,[1,2,3]] 
l2=copy.copy(l1) 
l2[-1].append(4) 
l1
1
2
3
4
5

A. [1,2,3,[1,2,3]]
B. [1,2,3,[1,2,3,4]]
C. [1,2,3,4]
D. [1,2,3,4,[1,2,3]]

正确答案是：B， 您的选择是：B
解析：该题考察对浅拷贝的掌握。 当使用切片[:]访问，工厂函数（如list/dir/set），copy模块中的copy()函数均引起浅拷贝。 对列表进行浅拷贝后，当修改的元素为可变对象时，修改操作会修改原列表。

61. [__builtins__] 执行以下代码的结果是？

type (__builtins__)
1

A. < class ‘function’ >
B. < class ‘module’ >
C. < class ‘builtin_function_or_method’ >
D. < class ‘type’ >

正确答案是：B， 您的选择是：C
解析：该题考察对Python中模块类型的掌握 __builtins__是python内置模块，其中包括了非常多非常有用的函数，也被叫做Python自带电池。__builtins__本身是一个模块module，因此它的type选B。C为该模拟中函数的type。

62. [局部变量和全局变量] 执行以下代码的结果是？

n1=5 
def foo(num): 
	n1=5 # 声明局部变量n1（这个n1和全局变量无关）
	n1+=num 
	return n1 

foo(n1),n1
1
2
3
4
5
6
7

A. (5,10)
B. (10,5)
C. (10,10)
D. 异常报错

正确答案是：B， 您的选择是：C
解析：该题考察对Python全局，局部变量，及变量作用域的掌握。 foo函数内部的n1为局域变量，对foo进行调用后，该n1先是被声明，然后被赋值后返回。均与全局变量n1无关。因为B选项正确。

如果程序改为以下这样：

>>> n1 = 5
>>> def foo(num):
...     n1 += num
...     return n1
... 
>>> foo(n1), n1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'n1' referenced before assignment
1
2
3
4
5
6
7
8
9
10

声明全局变量后：

>>> n1 = 5
>>> def foo(num):
...     global n1
...     n1 += num
...     return n1
... 
>>> foo(n1), n1
(10, 10)
1
2
3
4
5
6
7
8

63. [复数] 执行以下代码的结果是？

3+5j >= 5+3j
1

A. True
B. False
C. 异常报错

正确答案是：C， 您的选择是：A
解析：该题考察对复数类型的掌握。 Python中的复数类型由实部与虚数组合构成。并且两个虚数对象无法进行比较。因为D选项正确。

64. 从访问权限的角度来看，类中的方法默认都是（ ）

A 私有方法
B 公有方法
C 静态方法
D 实例方法

正确答案是：B， 您的选择是：A
解析：该题考察对类中默认方法权限的考察。 在Python类的，私有方法和变量的定义需要在其名称前加__，如果没有__进行标识，默认均为公有方法。

65. 定义在类中的方法之外的变量是（ ）

A 实例变量
B 类变量
C 公有变量
D 私有变量

正确答案是：B， 您的选择是：B
解析：该题考察对类中成员属性的定义的掌握。 在Python类中，公有/私有变量是通过__进行区别，而在方法之外的变量均为类变量，实例变量均在方法中进行定义且以self.开始。

66. 使用一个还未赋予对象的变量错误提示是（ ）

A NameError
B KeyError
C SystemError
D ReferenceError

正确答案是：A， 您的选择是：A
解析：该题考察对Python常见错误返回值的掌握。Python是弱类型语言，可以不用声明类型直接进行赋值，但无法直接去使用一个还未赋值（对象）的变量。否则会报NameError。

67. [ 捕获异常] 以下哪个语句不适宜对异常捕获（ ）

A. try…except
B. assert
C. with
D. if elif

正确答案是：D， 您的选择是：D
解析：该题考察对Python常见错误处理语句的掌握。 ABC选项均可对异常进行捕获，但if elif是用于逻辑判断，不适宜进行异常捕获。

# 0. 前置知识 -> 手动抛出异常
# 0.1 手动抛出字符串异常
>>> raise Exception("手动抛出异常")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: 手动抛出异常

# 0.2 指定数据类型异常
>>> raise Exception(NameError)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: <class 'NameError'>


# 1. try catch
>>> try:
...     print("这里写不确定是否会报错的操作")
... except "这里可以写异常的类型":
...     print("出现指定异常时的操作")
... except:
...     print("也可以不指导异常的类型（捕获所有异常）")
...     print("这里写发生任何异常时的操作")
... finally:
...     print("不管是否发生异常均会执行的操作（finally可以不写）")
... 
这里写不确定是否会报错的操作
不管是否发生异常均会执行的操作（finally可以不写）

# 2. assert
>>> a = 0
>>> assert a == 1, f"a应该为0，此时a为{a}"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: a应该为0，此时a为0

# 3. with
try:
     with open("myFile.txt") as f:
          print(f.readlines())
except:
    print('No such file or directory')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

68. [Python搜索变量的顺序] 以下哪个选项是正确的Python搜索变量的顺序

A 内置作用域（Built-in）→全局/模块作用域（Global）→当前作用域被嵌入的本地作用域（Enclosing locals）→本地作用域（Local）
B 本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals））→内置作用域（Built-in）→全局/模块作用域（Global）
C 本地作用域（Local）→内置作用域（Built-in）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）
D 本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

正确答案是：D， 您的选择是：B
解析：该题考察了对Python变量作用域及哪些对象会引入作用域的考察。 在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域。Python的变量名解析机制也称为 LEGB 法则，因此D选项正确。

Python 在查找"名称"时，是按照 LEGB 规则查找的：

• Local–>Enclosed–>Global–>Built in

• Local 指的就是函数或者类的方法内部
• Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）
• Global 指的是模块中的全局变量
• Built in 指的是 Python 为自己保留的特殊名称

69. [dict的key的数据类型] 执行以下代码的结果是？

confusion = {} 
confusion[1] = 1 
confusion['1'] = 2 
confusion[1.0] = 4 
sum = 0 
for k in confusion:     
	sum += confusion[k] 
print(sum)
1
2
3
4
5
6
7
8

A. 4
B. 5
C. 6
D. 7

正确答案是：C
解析：在这段代码中，首先创建了一个空字典 confusion。接着，使用 confusion[1] = 1、confusion['1'] = 2 和 confusion[1.0] = 4 为字典添加了三个键值对。

需要注意的是，在Python中，整数和浮点数的值相等时，它们被视为相同的键。因此，在这个例子中，confusion[1] = 1 和 confusion[1.0] = 4 实际上是对同一个键进行了两次赋值。最终，字典 confusion 中只有两个键值对：{1: 4, '1': 2}。

然后，使用一个 for 循环遍历字典中的所有键，并累加它们对应的值。由于字典中只有两个键值对，因此最终累加的结果为 4 + 2 = 6。最后，使用 print(sum) 打印出累加的结果。

所以，执行这段代码的结果是 6。

>>> confusion = {}
>>> confusion[1] = 1
>>> confusion["1"] = 2
>>> confusion[1.0] = 4
>>> confusion
{1: 4, '1': 2}
# for in 遍历字典
>>> for k in confusion:  # for in遍历dict，返回的是key
...     print(k)
... 
1
1
# for in 遍历 字典.items()
>>> for k, v in confusion.items():  # for k, v in dict.items():  # 返回的key和value
...     print(k, v)
... 
1 4
1 2

# for in enumerate 遍历字典
>>> for idx, k in enumerate(confusion):
...     print(idx, k)
... 
0 1
1 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1. for key in dict：返回的是key
2. for key, value in dict.items()：返回的是key和value
3. for idx, k in enumerate(dict)：返回的是index和key
4. for idx, k, v in enumerate(dict.items())：返回的是index和tuple

>>> for idx, k in enumerate(confusion.items()):
...     print(idx, k)
... 
0 (1, 4)
1 ('1', 2)
1
2
3
4
5

70. [join函数] 下面哪个语句能够让列表中的名字按行输出？

names = ['Dick', 'Nancy', 'Roger']
1

A print (“\n”.join(names))
B print (names.join(“\n”))
C print (names.append(“\n”))
D print (names.join(“%s\n”, names))

正确答案是：A

解析：该题考察使用字符串的join函数对列表的进行分割，及文本换行符的掌握。

• 字符串有join函数 ，而列表没有因此B,D选项错误。
• C选项仅仅在列表的最后一项添加一个换行，起不到每个名字都有换行的效果。因为A正确。

---

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
join()方法语法：

str.join(sequence)

# sequence -- 要连接的元素序列。
# 返回通过指定字符连接序列中元素后生成的新字符串。

# 例子
>>> str = "-"
>>> seq = ("a", "b", "c")
>>> print(str.join(seq))
a-b-c

>>> seq = ["a", "b", "c"]
>>> print(str.join(seq))
a-b-c
1
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> names = ['leovin', 'tom', 'jerry']
>>> print("\n".join(names))
leovin
tom
jerry
1
2
3
4
5

注意：不要把str.join(seq)和os.path.join(path_1, path_2)弄混了！

>>> # python中的join()
>>> file_path = "xxx/"
>>> file_name = "yyy.zzz"
>>> print(file_path.join(file_name))
yxxx/yxxx/yxxx/.xxx/zxxx/zxxx/z

>>> # os.path.join()
>>> import os
>>> print(os.path.join(file_path, file_name))
xxx/yyy.zzz
1
2
3
4
5
6
7
8
9
10

71. [is & ==] 关于Python中is与==说法正确的是

A is对比两个变量指向是否为同一对象,==对比两个变量指向对象是否为同值
B is对比两个变量指向对象是否为同一值,==是对比两个变量指向是否为同一对象
C is与==除均可用于比较对象是否为同一对象外，==还可以用于比较对象的值
D 以上说法均不正确

正确答案是：A， 您的选择是：A
解析：is用于对比对象地址,如a=7;b=7;a is b；返回为True，代表的a,b这两个变量指向的对象（7这个整形变量）为同一个。ab返回同样为True，代表a,b这两个变量指向变量的值都为7。而a=[1,2,3];b=[1,2,3]; a is b返回为False，因为此时a,b指向的对象不是同一个了（参见Python可变数据对象），而ab依据为True,因为这个对象的值相等。

72. 如果要在函数内部改变全局变量，须使用______关键字进行声明

A locals
B global
C __init__
D __new__

正确答案是：B， 您的选择是：B
解析：该题考察了对Python变量作用域及修改全局变量知识点的考察。 C,D两项均为类中的魔法方法，与全局变量无关。 Python只有locals()的内置函数，而没有这个关键字。因此选择B

73. 类中的实例方法，总会有一个参数（ ）

A self
B cls
C @staticmethod
D @classmethod

正确答案是：A， 您的选择是：A
解析：该题考察了对Python中类的实例方法的掌握。 类中任何实例方法，第一个参数都必须是self,用以指向该实例本身。

• cls为类方法中的第一个参数
• CD选项分别为类中静态方法，类方法定义前的装饰器

74. Python使用缩进作为语法边界,一般建议怎样缩进?

A TAB
B 两个空格
C 四个空格
D 八个空格

正确答案是：C， 您的选择是：A
解析：标准Python风格是每个缩进级别是使用4个空格，不要使用Tab制表符，Python的代码原则是代码只包含空格

75. [运算符优先级] 100 - 25 * 3 % 4 应该输出什么?

A. 1
B. 25
C. 97

正确答案是：C， 您的选择是：C
解析：考察了python运算符的运行顺序，优先级* = % > -，及%取余运算符的使用

76. [dict工厂函数] dict([[‘one’,1],[‘two’,2]])的返回是

A {‘one’: 1, ‘two’: 2}
B [{‘one’: 1, ‘two’: 2}]
C {2,3}
D [‘one’,‘two’]

正确答案是：A， 您的选择是：A
解析：

该题考察了对从列表出初始化字典对象的运用。一个列表对象包含的每个列表对象为新字典对象的item，每个元素的第0，1个元素分别对应item为key,value.

>>> dict([["one", 1], ["two", 2]])
{'one': 1, 'two': 2}
>>> dict(["one", 1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: dictionary update sequence element #0 has length 3; 2 is required
1
2
3
4
5
6

76. [tuple的函数] 以下操作中对象t=(1,3.7,5+2j,‘test’)，哪个是正确的

A t.remove(0)
B t.count()
C t.sort
D list(t)

正确答案是：D， 您的选择是：D
解析：在Python中，元组（tuple）是一种不可变的序列类型。一旦创建了一个元组，就不能再对它进行修改。因此，元组没有 remove 或 sort 方法，选项 A 和 C 都是错误的。

元组有一个 count 方法，用于统计指定元素在元组中出现的次数。但是，count 方法需要一个参数，用于指定要统计的元素。因此，选项 B 中的 t.count() 也是错误的，因为它没有提供参数。

77. [字符串*int]表达式的返回值是

list(map(lambda x:x*2,[1,2,3,4,'hi']))
1

A [1,2,3,4,‘hi’]
B [2, 4, 6, 8, ‘hihi’]
C [2, 4, 6, 8, ‘hi’,‘hi’]
D 异常

正确答案是：B， 您的选择是：B
解析：访题考察对lambda以及map函数的综合掌握。lambda为匿名函数，接受1个或多个参数，map是一个Python中的高阶函数，负责将一个可迭代对象中的每个元素一个一个映射给负责处理的函数。

>>> a = "leovin"
>>> a * 10
'leovinleovinleovinleovinleovinleovinleovinleovinleovinleovin'
1
2
3

78. [list + int] 列表l1=[1,2,3]，则表达式1+l1

A. [2,3,4]
B. [1,1,2,3]
C. [1,2,4]
D. 异常

正确答案是：D， 您的选择是：B
解析：本题考察对list对象相关运算的掌握。list对象仅能与list对象进行相加。与其它类型对象相加均会报出类型异常错误。 TypeError: can only concatenate list (not "int") to list

>>> l1 = [1, 2, 3]
>>> l1 + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "int") to list
>>> l1 + [5, 6, 7]
[1, 2, 3, 5, 6, 7]
1
2
3
4
5
6
7

79. [help函数] 想查看BIF len的文档信息，输入以下命令

A help len
B help --len
C len help
D help(len)

正确答案是：D， 您的选择是：B
解析：本题说明了在Python正确使用帮助的方法。

80. [exec] 执行exec(‘l1=[1,2,3]’)后：

A [1,2,3]
B l1=[1,2,3]
C 异常
D None

正确答案是：D， 您的选择是：B
解析：函数的作用：动态执行Python代码。也就是说exec可以执行复杂的Python代码，返回值永远为None

81. [eval] 执行eval(‘l1=[5,7,9]’)后

A [5,7,9]
B l1=[5,7,9]
C 异常
D 没有任何返回

正确答案是：C， 您的选择是：A
解析：本题考察对Python中BIF eval的掌握，eval意为求值，即对一个对象进行求值。Python中的语句分别表达式与声明，声明statement是对变量进行赋值，函数，类的定义等操作，一般不返回信息。而表达式Expression则是对执行某具体代码，对象求值的操作，一般会返回信息。 eval主要用于是执行字符串中的Python表达式。但该题中给eval的是一个声明（赋值），因此报错

---

exec 和 eval 都是Python的内置函数，它们用于动态执行Python代码。但是，它们之间有一些重要的区别。

eval 函数用于计算一个字符串表达式的值，并返回结果。它接受一个字符串参数，该字符串包含一个有效的Python表达式。例如：

x = 1
y = 2
result = eval("x + y")
print(result) # 输出 3
1
2
3
4

在这个例子中，使用 eval("x + y") 计算字符串表达式 "x + y" 的值。由于 x 和 y 的值分别为 1 和 2，因此表达式的值为 3。

与 eval 不同，exec 函数用于执行一段Python代码。它接受一个字符串参数，该字符串包含一段有效的Python代码。与 eval 不同，exec 不返回任何值。例如：

x = 1
y = 2
exec("result = x + y")
print(result) # 输出 3
1
2
3
4

在这个例子中，使用 exec("result = x + y") 执行了一段Python代码。这段代码计算了 x + y 的值，并将结果赋值给变量 result。

总之，eval 和 exec 都可以用来动态执行Python代码，但它们之间有一些重要的区别。

• eval 用于计算一个表达式的值，并返回结果；
• 而 exec 用于执行一段Python代码，不返回任何值。

---

82. [str] 用户自定义类时，如果想让该类实例对象被print调用时返回类的特定信息，就必须实现Python魔术方法中的

A __init__
B __str__
C __rep__
D __cmp__

正确答案是：B， 您的选择是：B
解析：本题考察对Python类中魔法函数的使用，

• 类中重写__str__魔术方法就能够在对象被print(对象名)时返回特定信息
• __init__是用初始化对象时触
• __cmp__用于对象的比较时触发
• __repr__和__str__这两个方法都是用于显示的
  • 当我们想在不同环境下支持不同的显示，例如终端用户显示使用__str__，实际上__str__只是覆盖了__repr__以得到更友好的用户显示。

举个例子：

class Person():
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    def drink(self, things):
        print(f"{self.name} is drinking {things}!")
        
    def __str__(self):  # 里面的self不能丢掉！
        msg_1 = "这是一条消息，当你在打印实例对象时就会出现"
        msg_2 = f"甚至还可以调用其他变量: {self.name}: {self.age}"
        return msg_1 + "\n" + msg_2
    
    
tom = Person(name='tom', age=25)
print(tom)

"""
这是一条消息，当你在打印实例对象时就会出现
甚至还可以调用其他变量: tom: 25
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

83. s1='%s';s1%(s1)的输出是：

A. %s
B. %%s
C. %s%s
D. s

正确答案是：A， 您的选择是：A
解析：该题考察了对字符串格式化输出的掌握。%s是字符串的占位符

s1 = "%s"
s1%(s1)

# '%s'
1
2
3
4

82. [格式化输出] 要将 3.1415926 变成 00003.14 如何进行格式化输出?

A “%.2f”% 3.1415629
B “%8.2f”% 3.1415629
C “%0.2f”% 3.1415629
D “%08.2f”% 3.1415629

正确答案是：D， 您的选择是：D
解析：该题考察了对字符串格式化输出的掌握。%f是浮点数的占位符，小数点后代表保留的小数，小数点前代表保留的整数位，D项中的0代表用0填充空余的位数。

output = 3.14159236
print(f"output: {output:08.2f}")  # 08.2f
print(f"output: {output:8.2f}")  # 8.2f

"""
    output: 00003.14
    output:     3.14
"""
1
2
3
4
5
6
7
8

83. [逻辑运算符or] 表达式'x' or 'y' or []的返回值为

A True
B []
C None
D ‘x’

正确答案是：D， 您的选择是：A
解析：本题考察了对逻辑运算符or的掌握，or为或，取两个表达式中为True的返回。如果两个表达均为True,则取最左边。因此该题D选项正确。

1. x and y：默认返回右边的
   • 如果 x 为 False，x and y 返回 False
   • 否则它返回 y 的计算值。
2. x or y：默认返回左边的
   • 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值
3. not x
   • 如果 x 为 True，返回 False
   • 如果 x 为 False，它返回 True。

print(bool("x"))  # 这就是一个字符串，当然是True
print(bool("y"))
print(bool([]))  # 空list当然为False
print(bool(()))  # 空tuple当然为False
print(bool({}))  # 空dict/set当然为False

"""
True
True
False
False
False
"""
1
2
3
4
5
6
7
8
9
10
11
12
13

bool()函数用于将其他类型的值转换为布尔值。它返回False的条件如下：

• 数字0（包括整数0、浮点数0.0和复数0j）
• 空序列（包括空字符串''、空列表[]和空元组()）
• 空字典{}
• 空集合set()
• 常量None
• 自定义对象的实例，如果其类定义了__bool__()或__len__()方法并返回False

除了上述情况，bool()函数都会返回True。例如，表达式bool(1)的返回值为True，因为1不是上述情况之一。

84. [tuple切片]下列表达式会返回（）

('julyedu',)[0]
1

A. 异常
B. ‘julyedu’
C. j
D. (‘julyedu’)

正确答案是：B， 您的选择是：C
解析：该题为Python基础题，考察了Python中对序列的索引访问特性，以及元组序列的理解。'julyedu’是做为元组中的第一个元素。

>>> ("leovin", )[0]
'leovin'
>>> ("leovin")[0]  # 这个()并非将str转换为元组，只是可以让str进行切片而加的而已
'l'
1
2
3
4

85. [Python中的文件操作] 以下哪个方法属于Python中的文件操作

A writeline
B getline
C mapping
D readlines

正确答案是：D， 您的选择是：B
解析：该题为Python基础题，考察了对文件操作的掌握。4个选项中只有readlines是文件对象提供的方法：读取所有行。

• file.read([size])：从文件读取指定的字节数，如果未给定或为负则读取所有。
• file.readline([size])：读取整行，包括 “\n” 字符。
• file.readlines([sizeint])：读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
• file.write(str)：将字符串写入文件，返回的是写入的字符长度。
• file.writelines(sequence)：向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

86. [*关键字] 表达式会返回

a=lambda *x:x
a(7,'月')
1
2

A ‘月月月月月月月’
B ‘7月’
C (7,’月’)
D 异常

正确答案是：C， 您的选择是：B
解析：该题一是考察对lambda函数的掌握，二是考察对函数参数中不定长定位参数的掌握。lambda函数在定义时参数前有*,表明能接收不定长个定位参数，并以元组的形式返回。因为C项正常

>>> a = lambda *x:x
>>> a("Leovin", 123, [456, 789], {'a':111})
('Leovin', 123, [456, 789], {'a': 111})
1
2
3

87. [class装饰器] 通过类内部的装饰器______，可以指定方法为类方法

A @property
B @staticmethod
C @classmethod
D @method

正确答案是：C， 您的选择是：C
解析：该题一是考察对Python类中方法装饰器的使用。@property装饰器将方法变为属性，@staticmethod将方法变为静态方法，@classmethod是将方法变为类方法

88. [class装饰器] 通过类内部的装饰器____，可以指定类的方法变为属性

A @property
B @staticmethod
C @classmethod
D @method

正确答案是：A， 您的选择是：A
解析：该题一是考察对Python类中方法装饰器的使用。@property装饰器将方法变为属性，@staticmethod将方法变为静态方法，@classmethod是将方法变为类方法

89. [.fromkeys] 表达式{}.fromkeys((1,2),3)，返回

A 异常
B {1,2,3}
C {1:2,3:None}
D {1: 3, 2: 3}

正确答案是：D， 您的选择是：A
解析：fromkeys是字典对象提供的方法，用于创建一个新字典，以第一个参数中的元素做字典的键，第二个参数为字典所有键对应的初始值。

90. [super] Python中的子类调用父类的方法，需要使用函数

A up
B get
C parent
D super

正确答案是：D， 您的选择是：D
解析：该题为Python类的基础题，选项为D，在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时我们又希望能同时实现父类的功能，我们就需要调用父类的方法了，可通过使用 super 来实现

91. [Exception] Python中，以下哪个关键字可以显示地引发异常

A except
B try
C finally
D raise

正确答案是：D， 您的选择是：D
解析：该题考察了对异常捕获及处理的掌握，python会自动引发异常，也可以通过raise显式地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

92. 下列关于Stackless Python的说法中错误的是

A Python的一个增强版本
B 提供并发式编程的模式
C 为Python添加微线程扩展
D Python中重要的多线程模块

正确答案是：D， 您的选择是：C
解析：该题考察了对Stackless Python的掌握，Stackless并非以库的形式和Python整合，Stackless提供的并发建模工具，比目前其它大多数传统编程语言所提供的工具都更加易用： 不仅用于Python自身，也包括Java、C++，以及其它语言。

93. 关于使用Scrapy时，下列哪项说法是错误的:

A scrapy中可以用Xpath
B scrapy中可以用正则
C scrapy必须重写中间件
D scrapy中可以用BeautifulSoup

正确答案是：C， 您的选择是：C
解析：Scrapy是Python进行网络抓取的第三方库，ABD三项均为在Scarpy中可以使用的HTML解析方式。C项是错误的，因为Scrapy中，middlewares的重写不是必要的。

94. Scrapy主要组件不包括：

A 引擎(Scrapy)
B 调度器(Scheduler)
C 沟通隧道（connect）
D 爬虫(Spiders)

正确答案是：C， 您的选择是：C
解析：Scrapy是Python进行网络抓取的第三方库，Scrapy框架中组件包括，Scrapy引擎，下载器，爬虫，调度器，Item Pipeline以及中间件。不包括C项。

95. 执行下列语句后的显示结果是什么（ ）

b = 2*a/ 4 
a = "one" 
print(a,b)
1
2
3

A 10
B one 0.5
C error
D one 0

正确答案是：C， 您的选择是：C
解析：该题考察了Python基础语法的掌握。该题中第一行代码使用了变量a，但a的定义在第二行。因此，执行第一行时便会报错。因此选C

即便变量定义正确也是不对的：

a = "one"
b = 2 * a / 4

print(a, b)


"""
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [120], in <cell line: 2>()
      1 a = "one"
----> 2 b = 2 * a / 4
      4 print(a, b)

TypeError: unsupported operand type(s) for /: 'str' and 'int'
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

96. Python是解释型的编程语言，该类型的语言的特性是？

A 脱离解释器运行
B 效率低
C 独立
D 效率高性

正确答案是：B， 您的选择是：C
解析：解释型语言的程序代码由相应语言的解释器“翻译”成目标代码(机器语言)后执行，因此效率比较低，而且不能生成可独立执行的可执行文件，应用程序不能脱离其解释器而运行。因此选择B

97. 下面哪个不是Python Requests库提供的方法？

A .get()
B .push()
C .post()
D .head()

正确答案是：B， 您的选择是：B
解析：Requests库中的get和post用于不同方式请求网络资源,head方法用于查看返回头部信息，因此选择B

98. 字符串函数strip()的作用是什么？

A 按照指定字符分割字符串为数组
B 连接两个字符串序列
C 去掉字符串两侧空格或指定字符
D 替换字符串中特定字符

正确答案是：C， 您的选择是：C
解析：

该题考查了对Python中字符串对象提供的相应函数的掌握：

• strip()常用于去除字符串的含有的左右空格
• lstrip是只去除左边空格
• rstrip是只去除右边空格

99. 在Python中实现多路分支的最佳结构是

A if-elif-else
B if
C while
D if-else

正确答案是：A， 您的选择是：A
解析：该题考查了对Python3中循环控制中多路分支的掌握。

• if，if-else是对条件进行单次判断
• While是开启条件循环的关键字
• 只有A项是实现多路分支判断的合适选择。

100. 以下哪个不是函数的作用？

A 降低编程复杂度
B 增强代码可读性
C 提高代码执行速度
D 复用代码

正确答案是：C， 您的选择是：C
解析：该题为Python基础题，考察了函数思想及功能的理解。函数是对代码和功能的封装，本质上是人们为了提升编程效率所做的一种抽象，带来ABD项的便利。与计算机执行及速度无关。因此选项C项。

将一段功能写成函数，可能会略微降低代码的执行速度。这是因为函数调用会产生一些额外的开销，例如参数传递、栈帧分配和返回地址跳转等。但是，这些开销通常都非常小，对程序的整体性能影响不大。相比之下，使用函数可以带来更多的好处，例如降低编程复杂度、增强代码可读性和复用代码等。因此，在大多数情况下，使用函数都是值得的。

101. 假设函数中不包含global保留字，下面对于改变参数值的说法，哪个是不正确的？

A 参数的值是否被改变，与函数中对变量的操作有关，与参数类型无关。
B 参数是列表类型时，改变原参数的值
C 参数是组合类型（可变对象）时，改变原参数的值
D 参数是整数类型时，不改变原参数的值

正确答案是：A， 您的选择是：D
解析：选项A是不正确的。参数的值是否被改变，与函数中对变量的操作有关，也与参数类型有关。如果参数是不可变对象（例如整数、字符串、元组），那么在函数中对该参数进行操作时，不会改变原参数的值。如果参数是可变对象（例如列表、字典），那么在函数中对该参数进行操作时，可能会改变原参数的值。因此，选项B、C和D都是正确的。

102. 下面对一个Python函数，哪种说法不正确？

def func(a, b):
	c = a**2 + b
	b = 100
	return c
	
a = 10
b = 100
c = func(a, b) + a 
print('a = ', a) 
print('b = ', b) 
print('c = ', c)
1
2
3
4
5
6
7
8
9
10
11

A 该函数执行后，变量 a 的值为10
B 该函数执行后，变量 b 的值为100
C 该函数执行后，变量 c 的值为200
D 该函数func本次的传入参数均为不可变类型的数据对象

正确答案是：C， 您的选择是：D
解析：该题考察了对Python3函数中的参数可变的理解与掌握，首先func函数接收的两个参数均为整型，均为不可变数据类型对，因此D项正确。 a,b两个参数在函数执行完成后，其值也不会有变化，因此A,B选项正确。 变量c是被重新函数返回值与a相加重新赋值，不应为200，应为210。

def func(a, b):
    # 因为int为不可变类型，所以这里的 c 和 b 均为local变量
    c = a**2 + b  # 100 + 100 = 200 -> 局部变量
    b = 100  # 局部变量
    return c


a = 10  # 全局变量 a
b = 100  # 全局变量 b
c = func(a, b) + a  # 全局变量 c = 函数返回值 + 全局变量 a -> c = 200 + 10 = 210
print('a = ', a) 
print('b = ', b) 
print('c = ', c)


"""
    a =  10
    b =  100
    c =  210
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

看下面这个例子：

def func_local():
    a_int = 100
    b_tuple = ("函数内赋值", 100)
    c_list = ["函数内赋值", 100]
    d_dict = {"函数内赋值": 100}
    e_set = {"函数内赋值", 100}
    
a_int = 1
b_tuple = ("main赋值", 1)
c_list = ["main赋值", 1]
d_dict = {"main赋值": 1}
e_set = {"main赋值", 1}
print(f"调用函数前: \na_int: {a_int}\nb_tuple: {b_tuple}\nc_list: {c_list}\nd_dict: {d_dict}\ne_set: {e_set}")

print("\n")

func_local()
print(f"[local]调用函数后: \na_int: {a_int}\nb_tuple: {b_tuple}\nc_list: {c_list}\nd_dict: {d_dict}\ne_set: {e_set}")


def func_global():
    """
        在声明函数时， 形参不能是全局变量，不然会报错：  SyntaxError: name 'x' is parameter and global
    """
    global a_int
    global b_tuple
    global c_list
    global d_dict
    global e_set
    a_int = 100
    b_tuple = ("函数内赋值", 100)
    c_list = ["函数内赋值", 100]
    d_dict = {"函数内赋值": 100}
    e_set = {"函数内赋值", 100}
    

func_global()    
print("\n")
print(f"[global]调用函数后: \na_int: {a_int}\nb_tuple: {b_tuple}\nc_list: {c_list}\nd_dict: {d_dict}\ne_set: {e_set}")


"""
    调用函数前: 
    a_int: 1
    b_tuple: ('main赋值', 1)
    c_list: ['main赋值', 1]
    d_dict: {'main赋值': 1}
    e_set: {1, 'main赋值'}


    [local]调用函数后: 
    a_int: 1
    b_tuple: ('main赋值', 1)
    c_list: ['main赋值', 1]
    d_dict: {'main赋值': 1}
    e_set: {1, 'main赋值'}


    [global]调用函数后: 
    a_int: 100
    b_tuple: ('函数内赋值', 100)
    c_list: ['函数内赋值', 100]
    d_dict: {'函数内赋值': 100}
    e_set: {'函数内赋值', 100}
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

def func_local():
    # 除非声明是它们是全局变量，否则直接赋值是不会生效的
#     a_int = 100
#     b_tuple = ("函数内赋值", 100)
#     c_list = ["函数内赋值", 100]
#     d_dict = {"函数内赋值": 100}
#     e_set = {"函数内赋值", 100}
    
    # 对可变类型进行操作
#     a_int += 100  # int是不可变数据类型，所以无效
#     b_tuple = b_tuple + ("New",)  # tuple是不可变数据类型，所以无效
    c_list.append("New")  # list是可变数据类型，有效！
    d_dict.update({"New_key":"New_value"})  # dict是可变数据类型，有效！
    e_set.add("New")  # set是可变数据类型（只是顺序不固定且相同值唯一），有效！
    
a_int = 1
b_tuple = ("main赋值", 1)
c_list = ["main赋值", 1]
d_dict = {"main赋值": 1}
e_set = {"main赋值", 1}
print(f"调用函数前: \na_int: {a_int}\nb_tuple: {b_tuple}\nc_list: {c_list}\nd_dict: {d_dict}\ne_set: {e_set}")

print("\n")

func_local()
print(f"调用函数后: \na_int: {a_int}\nb_tuple: {b_tuple}\nc_list: {c_list}\nd_dict: {d_dict}\ne_set: {e_set}")


"""
    调用函数前: 
    a_int: 1
    b_tuple: ('main赋值', 1)
    c_list: ['main赋值', 1]
    d_dict: {'main赋值': 1}
    e_set: {1, 'main赋值'}


    调用函数后: 
    a_int: 1
    b_tuple: ('main赋值', 1)
    c_list: ['main赋值', 1, 'New']
    d_dict: {'main赋值': 1, 'New_key': 'New_value'}
    e_set: {1, 'main赋值', 'New'}
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

103. 递归函数有什么特点？

A 函数名称作为返回值
B 函数内部包含对本函数的再次调用
C 包含一个循环结构
D 函数比较复杂

正确答案是：B， 您的选择是：B
解析：该题考察了对Python3中递归函数的理解，递归函数的本质就是在函数内部直接或间接调用函数本身。递归函数的调用和其他一般函数调用没有本质区别，只是在形式上能够建立循环的逻辑调用。因此只有B项正确。

104. 有关递归函数基例的说明，哪个是不正确的？

A 递归函数的基例决定递归的深度
B 递归函数必须有基例
C 递归函数的基例不再进行递归
D 每个递归函数只能有一个基例

正确答案是：D， 您的选择是：D
解析：该题考察了对Python3中递归函数中基例的理解，递归函数中的基例列出了产生集合中其他元素的基本元素。因此ABC项正确。选择D项。

---

递归函数的基例是指在递归调用中不再进行递归的情况。它是递归函数的终止条件，用于防止无限递归。每个递归函数都必须有一个或多个基例，以确保递归调用能够在某个时刻终止。例如，在计算阶乘的递归函数中，当输入参数为0或1时，函数返回1，这就是阶乘函数的基例。

这里有一个计算阶乘的递归函数的例子：

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)
1
2
3
4
5

在这个例子中，当输入参数n为0时，函数返回1，这就是阶乘函数的基例。当n不为0时，函数会调用自身计算factorial(n-1)，然后将结果乘以n并返回。这个过程会一直进行下去，直到输入参数为0时，函数返回1，递归调用终止。

105. 有关函数的说法，哪个是不正确的？

A 函数是代码功能的一种抽象
B 函数是代码逻辑的封装
C 函数是计算机对代码执行优化的要求
D 函数对一段代码的命名填空

正确答案是：C， 您的选择是：C
解析：该题为Python基础题考察了函数思想及功能的理解。函数是对代码和功能的封装，本质上是人们为了提升编程效率所做的一种抽象，带来ABD项的便利。与计算机执行及速度无关。因此选项C项。

106. 关于HTTP状态码错误的是

A 100 继续客户端当继续发送请求
B 102 继续处理
C 201请求完成结果是跳转
D 202请求被接受，但处理未完成

正确答案是：C， 您的选择是：A
解析：该题为Python数据抓取工作中对HTTP相应知识的掌握。201 (SC_CREATED)表示服务器在请求的响应中建立了新文档；应在定位头信息中给出它的URL。

107. content-Type的作用:

A 用来表明浏览器信息
B 用来表明用户信息
C 用来确定HTTP 返回信息的解析方式
D没有明确意义

正确答案是：C， 您的选择是：C
解析：该题为Python数据抓取工作中对HTTP相应知识的掌握。ContentType属性指定响应的 HTTP内容类型。content-Type用于定义网络文件的类型和网页的编码，决定文件接收方将以什么形式、什么编码读取这个文件，如果未指定 ContentType，默认为TEXT/HTML。

108. 下面程序的运行结果为（ ）

a = 10 
def setNumber():
	a = 100 
setNumber() 
print(a)
1
2
3
4
5

A 10
B 100
C 10100
D 10010

正确答案是：A， 您的选择是：A
解析：考查局部变量和全局变量。

• 局部变量：在某个函数内部定义，作用在函数内部。
  • 生命周期：从变量被创建开始到函数结束死亡。
• 全局变量：定义在.py模块内部，作用在整个.py模块。
  • 生命周期：从变量被创造开始到.py模块结束死亡

109. 构造函数是类的一个特殊函数，在python中，构造函数的名称为（ ）

A 与类同名
B __construct
C __init__
D init

正确答案是：C， 您的选择是：B

在Python中，构造函数的名称为__init__，所以选项C是正确的。构造函数是类的一个特殊函数，它在创建类的实例时被自动调用。构造函数通常用于初始化类的实例变量。例如，下面是一个简单的类定义，其中包含一个构造函数：

class MyClass:
    def __init__(self, x):
        self.x = x
1
2
3

在这个例子中，__init__函数接受一个参数x，并将其赋值给实例变量self.x。当我们创建MyClass的实例时，构造函数会被自动调用：

my_instance = MyClass(10)
1

在这个例子中，我们创建了一个MyClass的实例，并传递了一个参数10给构造函数。构造函数将这个参数赋值给实例变量self.x。

110. Python定义私有变量的方法为（ ）

A 使用__private 关键字
B 使用public关键字
C 使用__xxx__定义变量名
D 使用__xxx定义变量名

正确答案是：D， 您的选择是：D

A选项是不正确的。Python中没有__private关键字。Python中定义私有变量的方法是使用__xxx定义变量名。

B选项也是不正确的。Python中没有public关键字。在Python中，所有变量和方法默认都是公开的，可以从类的外部访问。

C选项也是不正确的。在Python中，以两个下划线开头和结尾的变量名（例如__xxx__）通常用于特殊方法，而不是私有变量。

D选项是正确的。在Python中，定义私有变量的方法是使用__xxx定义变量名。如果一个类的实例变量或方法以两个下划线开头，但不以两个下划线结尾，那么它就是一个私有变量或方法。它只能在类的内部访问，不能从类的外部访问。

111. （）函数用于将指定序列中的所有元素作为参数调用指定函数，并将结果构成一个新的序列返回

A lambda
B map
C filter
D zip

正确答案是：B， 您的选择是：D。

A选项中的lambda是一个用于创建匿名函数的关键字。它允许您快速定义一个简单的函数，而无需使用def关键字。例如，下面是一个使用lambda定义的简单函数：

squared = lambda x: x**2
1

这个函数接受一个参数x，并返回它的平方。

B选项中的map函数用于将指定序列中的所有元素作为参数调用指定函数，并将结果构成一个新的序列返回。它接受一个函数和一个或多个序列作为参数。

C选项中的filter函数用于过滤序列中的元素。它接受一个函数和一个序列作为参数。该函数对序列中的每个元素进行判断，如果返回值为真，则保留该元素，否则删除该元素。

D选项中的zip函数用于将多个序列中的元素配对。它接受多个序列作为参数，并返回一个由元组组成的序列。每个元组包含来自所有输入序列的对应位置的元素。

---

list_1 = [1, 2, 3, 4]
list_2 = [5, 6, 7, 8]

tuple_1 = (1, 2, 3, 4)
tuple_2 = (5, 6, 7, 8)

# 1. lambda函数
concat_func = lambda x, y: x + y
res_1_1 = concat_func(list_1, list_2)
res_1_2 = concat_func(tuple_1, tuple_2)
print(f"[list]res_1_1: {res_1_1}")
print(f"[tuple]res_1_2: {res_1_2}\n")


# 2. map函数(函数, 序列)
mult_2_1 = map(lambda x: x * 2, list_1)  # list中每个数*2
mult_2_2 = map(lambda x: x * 2, tuple_1)  # tuple中每个数*2
res_2_1 = list(mult_2_1)
res_2_2 = list(mult_2_2)
print(f"[list]res_2_1: {res_2_1}")
print(f"[tuple]res_2_2: {res_2_2}\n")


# 3. filter函数(条件, 序列)
odd_1 = filter(lambda x: x%2 == 0, list_1)
odd_2 = filter(lambda x: x%2 == 0, tuple_1)
res_3_1 = list(odd_1)
res_3_2 = list(odd_2)
print(f"[list]res_3_1: {res_3_1}")
print(f"[tuple]res_3_2: {res_3_2}\n")


# 4. zip函数(序列1, 序列2)  -> 序列必须是可迭代的
for x, y in zip(list_1, list_2):
    print(f"[list] (x, y): {x, y}")
    

for x, y in zip(tuple_1, tuple_2):
    print(f"[tuple] (x, y): {x, y}")

    
"""
    [list]res_1_1: [1, 2, 3, 4, 5, 6, 7, 8]
    [tuple]res_1_2: (1, 2, 3, 4, 5, 6, 7, 8)

    [list]res_2_1: [2, 4, 6, 8]
    [tuple]res_2_2: [2, 4, 6, 8]

    [list]res_3_1: [2, 4]
    [tuple]res_3_2: [2, 4]

    [list] (x, y): (1, 5)
    [list] (x, y): (2, 6)
    [list] (x, y): (3, 7)
    [list] (x, y): (4, 8)
    [tuple] (x, y): (1, 5)
    [tuple] (x, y): (2, 6)
    [tuple] (x, y): (3, 7)
    [tuple] (x, y): (4, 8)
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

112. （）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

A lambda
B map
C filter
D zip

正确答案是：D， 您的选择是：B

113. 若 a = ‘abcd’ ，若想将 a 变为 ‘ebcd’ ，则下列语句正确的是

A a[0] = ‘e’
B a.replace(‘a’, ‘e’)
C a[1] = ‘e’
D a = ‘e’ + a[1:]

正确答案是：D， 您的选择是：B
解析：Python 的字符串是不可变的。通过索引来改变一个字符串内部的字符是错误的，不允许的。
字符串的改变，通常只能通过创建新的字符串来完成，例如使用’+’拼接原字符串的切片或者使用replace()。

• A 选项是错误的，因为字符串在 Python 中是不可变的，所以不能直接修改字符串中的某个字符。
• B 选项也是错误的，因为 replace 函数会将字符串中所有出现的 ‘a’ 字符都替换为 ‘e’，而不仅仅是第一个字符。
• C 选项也是错误的，因为它试图将字符串 a 的第二个字符替换为 ‘e’，而不是第一个字符。此外，由于字符串在 Python 中是不可变的，所以这种方法也是不可行的。

a = "abcd"

# A选项
try:
    a[0] = "e"  # 这只是取了一个索引，因为str是不可变类型，所以这样对原str没影响
except Exception  as e:
    print(f"A选项报错：{e}")
finally:
    print(f"[A] {a}")

    
# B选项
a.replace("a", "e")  # 没有变量接收！
print(f"[B] {a}")
# 正确写法:
# a = a.replace("a", "e")


# C选项 -> pass


# D选项
a = "e" + a[1:]  # 对于两个字符串，+号就是拼接 <=> os.path.join(str_1, str_2)
print(f"[C] {a}")


"""
    A选项报错：'str' object does not support item assignment
    [A] abcd
    [B] abcd
    [C] ebcd
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

114. 执行以下两条语句后，lst的结果是

lst = [3, 2, 1] 
lst.append(lst)
1
2

A [3, 2, 1, [3, 2, 1]]
B [3, 2, 1, […]]，其中“…”表示无穷递归
C 抛出异常
D [3, 2, 1, lst]

正确答案是：B， 您的选择是：A

执行这两条语句后，lst 的结果是 B 选项：[3, 2, 1, […]]，其中“…”表示无穷递归。

在执行 lst.append(lst) 语句时，列表 lst 被添加到了它自身的末尾。这意味着 lst 的最后一个元素是它自身的一个引用。因此，当我们尝试访问 lst 的最后一个元素时，我们会发现它仍然是 lst 列表本身。这就形成了一个无穷递归。

A 选项是错误的，因为它没有考虑到列表可以包含它自身作为元素的情况。

C 选项也是错误的，因为这两条语句都是合法的 Python 代码，不会抛出异常。

D 选项也是错误的，因为它没有正确描述列表中的无穷递归。

# 错误的写法1
ls = [3, 2, 1]
ls.append(ls)
print(ls,"\n")  # [3, 2, 1, [...]]

# 错误的写法2
ls = [3, 2, 1]
temp_ls = ls
ls.append(temp_ls)
print(ls,"\n")  # [3, 2, 1, [...]]


# 正确的写法1
import copy
ls = [3, 2, 1]
ls.append(copy.copy(ls))
print(ls,"\n")  # [3, 2, 1, [3, 2, 1]]


# 正确的写法2
import copy
ls = [3, 2, 1]
ls.append(copy.deepcopy(ls))
print(ls,"\n")  # [3, 2, 1, [3, 2, 1]]


"""
    [3, 2, 1, [...]] 

    [3, 2, 1, [...]] 

    [3, 2, 1, [3, 2, 1]] 

    [3, 2, 1, [3, 2, 1]]
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

115. 在读写文件之前，必须通过以下哪个方法创建文件对象：

A create
B folder
C File
D open

正确答案是：D， 您的选择是：D

在读写文件之前，必须通过 D 选项中的 open 方法创建文件对象。

open 函数用于打开一个文件，并返回一个文件对象。我们可以使用这个文件对象来读取或写入文件。例如，下面的代码展示了如何使用 open 函数打开一个文件，并读取其中的内容：

with open('file.txt', 'r') as f:
    content = f.read()
    print(content)
1
2
3

A、B 和 C 选项都不是用来创建文件对象的方法。在 Python 中，没有名为 create、folder 或 File 的内置函数或方法。

116. 对于一个列表aList和一个元组bTuple，以下函数调用错误的选项是哪一个？

A sorted(aList)
B sorted(bTuple)
C aList.sort()
D bTuple.sort()

正确答案是：D， 您的选择是：D
解析：sort 与 sorted 区别：

1. sort 是应用在 list 上的方法，sorted 可以对**所有可迭代的对象(包括tuple)**进行排序操作。
2. list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

ls = [1, 3, 5, 2, 4, 8, 6, 9, 7, 10]
tp = (1, 3, 5, 2, 4, 8, 6, 9, 7, 10)

# sorted(可迭代对象)
sorted_1 = sorted(ls)
sorted_2 = sorted(tp)
print(f"sorted(ls): {sorted_1}\nsorted(tp): {sorted_2}\n")


# 列表.sort
ls.sort()  # inplace操作，返回值为None
try:
    tp.sort()  # inplace操作，返回值为None
except Exception as e:
    print(f"tuple.sort()报错了： {e}")

print(f"list.sort(): {ls}\ntuple.sort(): {tp}")


"""
    sorted(ls): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    sorted(tp): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    tuple.sort()报错了： 'tuple' object has no attribute 'sort'
    list.sort(): [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    tuple.sort(): (1, 3, 5, 2, 4, 8, 6, 9, 7, 10)
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

117. 以下关于Python自带数据结构的运算结果中错误的是哪一项？

A s = [1, 2, 3, 4]; s.reverse(); 则s[1]为3
B s = [1, 2, 3, 4]; s.pop(1); 则s为[1, 3, 4]
C s = [1, 2, 3, 4]; s.pop(); 则s.index(3) 结果为2。
D s = [1, 2, 3, 4]; s.insert(2, -1); 则s为 [1, 2, -1, 4]

正确答案是：D， 您的选择是：C
解析：

• list.reverse() 倒排列表中的元素。
• list.pop(i) 从列表的索引为i处移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。
• list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
• list.insert(i, x) 在索引为i处插入元素x。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。

# A选项
s = [1, 2, 3, 4]
s.reverse()
print(f"[A] s[1]: {s[1]}\n")


# B选项
s = [1, 2, 3, 4]
s.pop(1)
print(f"[B] s: {s}\n")


# C选项
s = [1, 2, 3, 4]
s.pop()
res = s.index(3)
print(f"[C] s.index(3): {res}\n")


# D选项
s = [1, 2, 3, 4]
s.insert(2, -1)
print(f"[D] s: {s}")


"""
    [A] s[1]: 3

    [B] s: [1, 3, 4]

    [C] s.index(3): 2

    [D] s: [1, 2, -1, 3, 4]
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

118. 当在一个决策树中划分一个节点时，以下关于“信息增益”的论述正确的是

1. 纯度高的节点需要更多的信息来区分
2. 信息增益可以通过熵来推导
3. 信息增益偏向于选择大量值的属性

A. 1
B. 2
C. 2和3
D. 所有都对

正确答案是：C， 您的选择是：B
解析：正确的选项是 C，即 2 和 3 都是正确的。

1. 纯度高的节点需要更多的信息来区分。这个说法是错误的。纯度高的节点意味着该节点中包含的样本属于同一类别，因此不需要更多的信息来区分。

2. 信息增益可以通过熵来推导。这个说法是正确的。信息增益衡量了划分前后数据集的不确定性减少程度，可以通过计算划分前后数据集的熵来推导。

3. 信息增益偏向于选择大量值的属性。这个说法也是正确的。当一个属性具有大量不同的取值时，使用该属性进行划分会产生大量子节点，每个子节点中只包含少量样本，从而导致子节点的纯度很高，熵很小。这会使得信息增益很大，从而偏向于选择这种属性进行划分。
   举个例子：假设我们有一个数据集，其中包含两个属性：颜色和编号。颜色属性只有两个取值：红色和蓝色；而编号属性有 100 个不同的取值。如果我们使用信息增益算法来选择划分属性，那么算法可能会偏向于选择编号属性进行划分，因为编号属性具有更多的取值，使用它进行划分会产生更多的子节点，从而使得信息增益更大。