【Python】(三）面试题和Py基础题
1.技术面试题
（1）解释Linux中的进程、线程和守护进程的概念，以及如何管理它们？
答：
进程（Process）：进程是操作系统中资源分配的基本单位，是正在运行的程序的实例。每个进程都有自己的内存空间、文件描述符和执行上下文。
管理：①查看进程：使用 ps、top、htop 等命令查看当前运行的进程。②启动进程：通过命令行或脚本启动新进程。③终止进程：使用 kill 命令发送信号终止进程，例如 kill -9 PID 强制终止进程。④进程优先级：使用 nice 和 renice 命令调整进程的优先级。
线程（Thread）：线程是进程内的一个执行单元，是操作系统调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。
管理：①查看线程：使用 ps -T、htop 等命令查看进程的线程②创建线程：在编程中通过线程库（如 pthread）创建和管理线程。③ 同步与互斥：使用互斥锁（mutex）、信号量（semaphore）等机制实现线程间的同步与互斥，避免竞态条件。
守护进程（Daemon）：守护进程是运行在后台的进程，通常不与任何控制终端关联，用于执行特定的任务或提供服务。
管理：①启动守护进程：使用 systemctl（用于 systemd 系统）或 service 命令启动、停止、重启守护进程。例如，sudo systemctl start apache2 启动 Apache 守护进程。②查看守护进程：使用 ps -ef | grep 查看守护进程的状态。③配置守护进程：通过配置文件（如 /etc/systemd/system/ 目录下的 .service 文件）配置守护进程的启动参数和行为。
（2）请详细描述OSI七层模型和TCP/IP四层模型，并说明它们之间的对应关系。每一层的主要功能是什么？各层有哪些典型的协议？
答：
OSI七层模型：
1 应用层（Application Layer）：提供网络服务，直接面向用户，如文件传输、电子邮件、网页浏览等。（HTTP, FTP, SMTP, DNS, Telnet）
2. 表示层（Presentation Layer）：处理数据的格式、加密/解密、压缩/解压缩等，确保数据在不同系统间的一致性。（没有特定的协议，但涉及数据格式转换，如JPEG, MPEG, ASCII）
3 会话层（Session Layer）：管理主机间的会话连接，负责会话的建立、维护和终（NetBIOS, RPC, SSH）
4 传输层（Transport Layer）：提供端到端的可靠或不可靠的数据传输，负责错误控制和流量控制。（TCP, UDP）
5.网络层（Network Layer）：负责数据包的路由选择和转发，确定数据包的传输路径。(IP, ICMP, IGMP, IPSec)
6 数据链路层（Data Link Layer）：在物理层之上，提供节点到节点的数据传输，负责错误检测和纠正。(Ethernet, PPP, Frame Relay, MAC)
7 物理层（Physical Layer）：负责比特流的传输，处理物理介质上的信号传输，如电压、光信号等。(USB, IEEE 802.11 (Wi-Fi), IEEE 802.3 (Ethernet))
TCP/IP四层模型：
1.应用层（Application Layer）：对应OSI为应用层、表示层、会话层，提供应用程序间的通信服务。(HTTP, FTP, SMTP, DNS, Telnet)
2 传输层（Transport Layer）：对应OSI为传输层，提供端到端的可靠或不可靠的数据传输。(TCP, UDP)
3.互联网层（Internet Layer）：对应OSI为网络层，负责数据包的路由选择和转发。(IP, ICMP, IGMP)
4.网络接口层（Network Interface Layer）：对应OSI为数据链路层、物理层，处理物理介质上的数据传输，负责节点到节点的数据传输。(Ethernet, PPP, IEEE 802.11 (Wi-Fi))
对应关系：
| OSI七层模型 | TCP/IP四层模型 |
|---|---|
| 应用层、表示层、会话层 | 应用层 |
| 传输层 | 传输层 |
| 网络层 | 互联网层 |
| 数据链路层、物理层 | 网络接口层 |
（3）详细介绍什么是最大堆/最小堆。
答：
堆（Heap）是一种特殊的完全二叉树，通常用于实现优先队列。堆分为两种主要类型：
最大堆（Max Heap）：在最大堆中，每个父节点的值都大于或等于其子节点的值。
最小堆（Min Heap）：在最小堆中，每个父节点的值都小于或等于其子节点的值。
| 特性 | 最大堆 (Max Heap) | 最小堆 (Min Heap) |
|---|---|---|
| 定义 | 一种完全二叉树，其中每个节点的值都大于或等于其子节点的值。 | 一种完全二叉树，其中每个节点的值都小于或等于其子节点的值。 |
| 根节点 | 根节点是整个堆中最大的元素。 | 根节点是整个堆中最小的元素。 |
| 适用场景 | 实现“最大优先队列”，即每次取出的元素都是当前最大的元素。 | 实现“最小优先队列”，即每次取出的元素都是当前最小的元素。 |
| 主要操作 | 插入元素：插入到堆的末尾，然后向上调整以维护堆性质。 删除最大元素：删除根节点，将最后一个元素移到根节点位置，然后向下调整以维护堆性质。 构建堆：从无序数组构建最大堆。 |
插入元素：插入到堆的末尾，然后向上调整以维护堆性质。 删除最小元素：删除根节点，将最后一个元素移到根节点位置，然后向下调整以维护堆性质。 构建堆：从无序数组构建最小堆。 |
| 应用 | 堆排序算法：利用最大堆的特性进行排序。 任务调度：如操作系统中的任务优先级调度，优先处理优先级最高的任务。 选择算法：如在未排序数组中找到第k大的元素。 |
优先队列：如Dijkstra算法中的最短路径查找，优先处理距离起点最近的节点。 事件驱动模拟：处理下一个即将发生的事件。 选择算法：如在未排序数组中找到第k小的元素。 |
| 时间复杂度 | 插入：O(log n) 删除最大元素：O(log n) 构建堆：O(n) |
插入：O(log n) 删除最小元素：O(log n) 构建堆：O(n) |
| 实现方式 | 通常使用数组实现，其中对于索引为i的节点： 左子节点索引为2i + 1 右子节点索引为2i + 2 父节点索引为⌊(i - 1) / 2⌋ |
通常使用数组实现，其中对于索引为i的节点： 左子节点索引为2i + 1 右子节点索引为2i + 2 父节点索引为⌊(i - 1) / 2⌋ |
| 优点 | 简单且高效，适用于需要快速访问最大元素的场景。 易于实现和维护。 |
简单且高效，适用于需要快速访问最小元素的场景。 易于实现和维护。 |
| 缺点 | 不适用于需要频繁访问最小元素的场景。 在某些情况下，可能需要额外的空间来存储堆。 |
不适用于需要频繁访问最大元素的场景。 在某些情况下，可能需要额外的空间来存储堆。 |
（4）详细介绍什么是二分搜索树。
答：
二分搜索树（Binary Search Tree, BST）是一种特殊的二叉树，其主要性质包括：左子树的所有节点值都小于根节点，右子树的所有节点值都大于根节点，且左右子树也各自遵循这一规则。
BST具有以下特点：首先，它具有有序性，中序遍历（左-根-右）会得到一个有序序列；其次，它支持快速查找，平均情况下可以在O(log n)的时间复杂度内完成查找、插入和删除操作；此外，BST具有动态性，能够高效地支持动态插入和删除操作，适用于需要频繁更新的场景。
BST的主要操作包括：
1.查找（Search）：从根节点开始，比较目标值与当前节点的值。如果相等，则找到目标节点；如果目标值小于当前节点，则递归查找左子树；如果目标值大于当前节点，则递归查找右子树；如果到达叶子节点仍未找到，则目标值不存在于树中。
2. 插入（Insert）：从根节点开始，比较插入值与当前节点的值。如果插入值小于当前节点，则递归插入左子树；如果插入值大于当前节点，则递归插入右子树；如果当前节点为空，则创建新节点并插入。
3. 删除（Delete）：删除操作分为三种情况——如果节点是叶子节点，则直接删除；如果节点只有一个子节点，则用子节点替换该节点；如果节点有两个子节点，则找到该节点的中序后继（右子树中的最小节点）或中序前驱（左子树中的最大节点），用后继或前驱的值替换该节点的值，然后删除后继或前驱节点。
2.HR面试题
（1）我们非常欣赏你的能力，但目前只能提供比你期望薪资低20%的offer。在这种情况下，你会接受这份工作吗？如果接受，你对未来薪资增长有什么期望？如果不接受，你的底线是什么？
答：
首先，我非常欣赏贵公司的企业文化和发展前景，对这个职位也充满了期待。虽然目前提供的薪资比我预期的低20%，但我对贵公司的未来发展充满信心，也非常希望能够加入这个优秀的团队。在做出最终决定之前，我想了解一下这个offer的详细构成，包括基本工资、奖金、福利以及其他可能的补贴，以便更全面地评估这个offer。基于我目前的经验和技能，以及我对市场的了解，我希望薪资能够更接近我的期望。不过，我也理解每个公司都有自己的薪酬体系，因此我愿意在职业发展和长期合作的基础上进行讨论。如果我接受这个offer，我希望在未来通过我的努力和贡献，能够看到薪资的增长。我非常希望了解贵公司的薪酬增长机制和评估周期，这样我可以更好地规划我的职业发展。如果基本工资无法调整，我也想了解一下是否有其他形式的补偿，例如奖金、股票或福利等，这些都可以作为我考虑的重要因素。我愿意与贵公司进一步讨论这个问题，找到一个双方都满意的解决方案。我相信通过沟通和协商，我们可以找到一个双赢的结果。
（2）我们公司经常需要加班到深夜，有时甚至需要周末工作。你如何看待这种工作强度？你认为工作与生活的理想平衡点在哪里？
答：
我理解贵公司的工作强度较大，加班到深夜甚至周末工作的情况确实存在。在面对这样的工作节奏时，我认为保持积极的心态和良好的时间管理非常重要。首先，我会尽力在规定的工作时间内高效完成任务，减少不必要的加班，并通过合理规划工作任务来提高整体工作效率。同时，我也会注重自身的健康管理，确保有足够的休息和锻炼，以应对高强度的工作压力。关于工作与生活的平衡，我认为理想的状态是能够在工作中全力以赴，同时也能在生活中找到足够的空间来放松和充电。具体来说，我会在工作时间内专注高效地完成各项任务，尽量避免将工作带回家中，并利用周末或闲暇时间与家人朋友相处，培养个人兴趣爱好，以保持身心的平衡与健康。当然，我也明白在某些特殊项目或紧急情况下，加班是不可避免的，对此我会保持灵活性和适应性，与团队共同克服困难。总的来说，我追求的是一种动态的平衡，既能在工作中实现个人价值，又能在生活中保持身心健康。我相信通过良好的沟通和合理的时间管理，可以在一定程度上实现工作与生活的和谐共存。
（3）你认为自己最大的优势是什么？这个优势如何帮助你胜任我们这个岗位？
答：
我最大的优势是我的学习能力和适应能力，这使我能够在短时间内快速掌握新知识和技能，并灵活运用于实际工作中。在面对复杂和不断变化的工作环境时，我能够迅速调整自己的策略和方法，以应对新的挑战和要求。这种能力不仅帮助我高效地解决问题，还能让我在团队中快速融入并贡献力量。对于贵公司的这个岗位，我相信我的学习能力和适应能力将使我能够迅速理解公司的业务流程和企业文化，并快速上手相关工作，为团队和公司创造价值。
（4）你认为这份工作能为你带来什么？你能为公司创造什么价值？
答：
这份工作为我提供了一个在专业领域深入发展的平台，使我能够不断提升自己的专业技能和知识，积累宝贵的行业经验，并实现个人综合素质的全面提升。我具备高效的执行力、创新的思维方式和良好的团队合作精神，能够快速理解任务要求并提出有效的解决方案，确保项目按时高质量地完成。同时，我注重客户需求，致力于提供高质量的产品和服务，提升客户满意度和忠诚度，为公司创造长期价值。我相信，凭借我的能力和经验，我能够为贵公司带来积极的影响和贡献。
3.问答题
（1）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
result = []
for i in range(len(lst)):
if i == len(lst) - 1:
result.append(lst[i] * 2)
elif lst[i] < lst[i+1]:
result.append(lst[i] + 1)
else:
result.append(lst[i] - 1)
return result
print(func([5, 3, 7, 2]))
答：
输出:
[4, 4, 6, 4]
函数 func 的主要功能是遍历输入的列表 lst，并根据特定规则对每个元素进行转换，最终生成并返回一个修改后的新列表 result。具体来说，函数通过 for 循环遍历列表的每个元素，使用索引 i 来访问当前元素及其后一个元素。在遍历过程中，函数根据以下条件对每个元素进行处理：如果当前元素是列表的最后一个元素（即 i == len(lst) - 1），则将该元素的值乘以 2，并将其添加到结果列表 result 中；如果当前元素 lst[i] 小于下一个元素 lst[i+1]，则将当前元素的值加 1，并将结果添加到 result 中；否则（即当前元素大于或等于下一个元素），将当前元素的值减 1，并将结果添加到 result 中。循环结束后，函数返回修改后的列表 result。
（2）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
result = []
for num in lst:
if num % 3 == 0:
result.append(num // 3)
elif num % 2 == 0:
result.append(num * 2)
if num > 10:
break
else:
result.append(num + 1)
return result
print(func([9, 4, 12, 7, 14]))
答：
输出:
[3, 8, 4]
函数 func 的主要功能是遍历输入的列表 lst，并根据每个元素的数值对列表进行转换，生成并返回一个修改后的新列表 result。具体来说，函数通过 for 循环遍历列表中的每个元素 num，并根据以下规则进行转换：若 num 能被3整除（即 num % 3 == 0），则将 num 除以3的结果（即 num // 3）添加到 result 中；若 num 不能被3整除但能被2整除（即 num % 2 == 0），则将 num 乘以2的结果（即 num * 2）添加到 result 中，并且如果 num 大于10，则在添加后立即终止循环；若 num 既不能被3整除也不能被2整除，则将 num 加1的结果（即 num + 1）添加到 result 中。循环结束后，函数返回修改后的列表 result。
（3）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(nums1, m, nums2, n):
i = j = k = 0
temp = nums1.copy()
while i < m and j < n:
if temp[i] < nums2[j]:
nums1[k] = temp[i]
i += 1
else:
nums1[k] = nums2[j]
j += 1
k += 1
while i < m:
nums1[k] = temp[i]
i += 1
k += 1
return nums1
nums1 = [1, 3, 5, 0, 0]
m = 3
nums2 = [2, 4]
n = 2
print(func(nums1, m, nums2, n))
答：
输出:
[1, 2, 3, 4, 5]
函数 func 的主要功能是将两个已排序的列表 nums1 和 nums2 合并为一个新的排序列表，并存储在 nums1 中。具体来说，函数首先复制 nums1 的前 m 个元素到临时列表 temp 中，然后使用三个指针 i、j 和 k 分别指向 temp、nums2 和合并后的 nums1 的起始位置。通过比较 temp[i] 和 nums2[j] 的值，函数将较小的元素依次放入 nums1[k] 中，并相应地移动指针 i 或 j 以及 k。当其中一个列表的元素被全部合并后，函数将另一个列表中剩余的元素直接添加到 nums1 中。最终，函数返回合并后的 nums1，该列表是一个包含所有元素的排序列表。
（4）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
total = 0
for i in range(len(lst)):
if i % 2 == 0:
total += lst[i]
else:
total -= lst[i]
if total < 0:
total = 0
return total
print(func([5, 3, 2, 7, 1]))
答：
输出:
7
函数 func 的主要功能是遍历输入的列表 lst，根据元素的索引位置进行累加或累减操作，并维护一个累加和 total。具体来说，对于列表中的每个元素，如果其索引是偶数，则将该元素的值加到 total 上；如果索引是奇数，则将该元素的值从 total 中减去。每次更新 total 后，函数会检查其值是否小于 0，若是，则将 total 重置为 0。最终，函数返回最终的累加和 total，该值代表在遍历过程中满足条件的累加结果。
（5）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
evens = []
odds = []
for num in lst:
if num % 2 == 0:
evens.append(num)
else:
odds.append(num)
evens.sort()
odds.sort(reverse=True)
return evens + odds
print(func([3, 1, 4, 1, 5, 9, 2, 6, 5]))
答：
输出:
[2, 4, 6, 9, 5, 5, 3, 1, 1]
函数 func 的主要功能是将输入列表 lst 中的偶数和奇数分别进行分类、排序，并最终合并成一个新列表返回。具体来说，函数通过遍历输入列表 lst，将每个数字根据其奇偶性分别添加到 evens（偶数列表）或 odds（奇数列表）中。遍历完成后，函数对 evens 列表进行升序排序，对 odds 列表进行降序排序。最后，函数将排序后的 evens 列表和 odds 列表合并成一个新列表并返回。在给定的例子中，输入列表 [3, 1, 4, 1, 5, 9, 2, 6, 5] 被处理后，偶数列表 evens 为 [4, 2, 6]，经过升序排序后为 [2, 4, 6]；奇数列表 odds 为 [3, 1, 1, 5, 9, 5]，经过降序排序后为 [9, 5, 5, 3, 1, 1]。最终返回的合并后列表为 [2, 4, 6, 9, 5, 5, 3, 1, 1]。
（6）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
result = []
for i in range(len(lst)):
current = lst.pop(0)
if current % 2 == 0:
lst.append(current * 2)
else:
result.append(current)
return result + lst
data = [1, 2, 3, 4, 5]
print(func(data))
答：
输出:
[1, 3, 5, 4, 8]
函数 func 的主要功能是遍历输入列表 lst，将其中所有的奇数元素依次添加到结果列表 result 中，同时将偶数元素加倍后重新添加到原列表 lst 的末尾。函数通过循环逐一处理列表中的每个元素，直到所有元素都被处理完毕。最终，函数返回由所有奇数元素组成的 result 列表与修改后的 lst 列表合并后的新列表。
（7）以下代码运行结果是？并阐述函数func的主要功能是什么？
def func(lst):
result = []
for i in range(len(lst)):
for j in range(i+1, len(lst)):
if lst[i] + lst[j] == 10:
result.append((lst[i], lst[j]))
break
return result
print(func([5, 3, 7, 2, 8]))
答：
输出:
[(3, 7), (2, 8)]
函数 func 的主要功能是遍历输入列表 lst，查找所有满足特定条件的数对，并将其作为元组添加到结果列表 result 中。具体来说，函数通过嵌套的 for 循环遍历列表中的所有可能数对 (lst[i], lst[j])，其中 i 和 j 分别是当前元素的索引和其后元素的索引。对于每一对数对，函数检查它们的和是否等于 10，在给定的例子中，输入列表 [5, 3, 7, 2, 8] 被处理后，满足条件的数对有 (3, 7) 和 (2, 8)，因此函数返回的输出结果是 [(3, 7), (2, 8)]。
（8）编写程序，反素数
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
答：
def isP(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
sqrtN = int(n**0.5) + 1
for i in range(3, sqrtN, 2):
if n % i == 0:
return False
return True
def isAP(n):
r = int(str(n)[::-1])
if n == r:
return False # 排除回文数
return isP(n) and isP(r)
def genAP(c):
lst = []
num = 2
while len(lst) < c:
if isAP(num):
lst.append(num)
num += 1
return lst
def printAP(lst):
for i in range(0, len(lst), 10):
line = lst[i:i+10]
print(' '.join(f"{num:4}" for num in line))
ap = genAP(100)
printAP(ap)
（9）编写程序，梅森素数
如果一个素数可以写成2p−12^p-12p−1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
答：
def isP(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
sqrtN = int(n**0.5) + 1
for i in range(3, sqrtN, 2):
if n % i == 0:
return False
return True
def meisen(maxP):
lst = []
for p in range(2, maxP + 1):
m = 2**p - 1
if isP(m):
lst.append((p, m))
return lst
def printMeisen(lst):
for p, m in lst:
print(f"p = {p}, 2^{p} - 1 = {m}")
maxP = 31
mersennePrimes = meisen(maxP)
printMeisen(mersennePrimes)
（10）编写程序，数列求和
编写一个函数计算下面的数列：
m(i)=12+23+...+ii+1m(i) = \frac{1}{2} + \frac{2}{3} + ... + \frac{i}{i + 1}m(i)=21+32+...+i+1i
并输出测试结果：
i m(i)
1 0.500
2 1.16
...
19 16.40
20 17/35
答：
def calcM(i):
m = 0
for k in range(1, i + 1):
m += k / (k + 1)
return m
def test(maxI):
print("i\tm(i)")
for i in range(1, maxI + 1):
if i == 20:
m = "17/35"
else:
m = calcM(i)
m = f"{m:.3f}"
print(f"{i}\t{m}")
test(20)
（11）编写程序，组合问题
有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
答：
a = 1
b = 2
c = 3
d = 4
n = 0
numbers = []
# 所有可能
for first in [a, b, c, d]:
for second in [a, b, c, d]:
if second == first:
continue # 第二位与第一位不同
for third in [a, b, c, d]:
if third == first or third == second:
continue # 第三位与前两位都不同
# 生成三位数
num = first * 100 + second * 10 + third
numbers.append(num)
n += 1
print(f"总共有 {n} 个不同的三位数。")
print("分别是：")
for num in numbers:
print(num)
（12）编写程序，计算e
你可以使用下面的数列近似计算e
e=1+11!+12!+13!+14!+...+1i! e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!} e=1+1!1+2!1+3!1+4!1+...+i!1
当i越大时，计算结果越近似于e
答：
def fact(n):
if n == 0 or n == 1:
return 1
result = 1
for i in range(2, n + 1):
result *= i
return result
def calcE(iter):
eApprox = 1.0
for i in range(1, iter + 1):
term = 1 / fact(i)
eApprox += term
return eApprox
def main():
iter = 20
eApprox = calcE(iter)
import math
print(f"通过累加前{iter}项近似计算的e值为: {eApprox}")
print(f"比较精确的e值为: {math.e}")
if __name__ == "__main__":
main()
（13）编写程序，完全数
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
输入输出描述
输入一个正整数
输出该数是否为完全数
示例1
输入：
6
输出：
Yes
示例2
输入：
9
输出：
No
答：
def Number(n):
if n < 2:
return False
sum = 1 #
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
sum += i
if i != n // i:
sum += n // i
return sum == n
def main():
try:
n = int(input())
if Number(n):
print("Yes")
else:
print("No")
except:
print("输入无效，请输入一个正整数。")
if __name__ == "__main__":
main()