【Python】（一）面试题和Py基础题
1.技术面试题
（1）TCP与UDP的区别是什么？
答：
TCP（Transmission Control Protocol，传输控制协议）提供的是面向连接，可靠的字节流服务。即客户和服务器交换数据前，必须现在双方之间建立一个TCP连接，之后才能传输数据。并且提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP（User Data Protocol，用户数据报协议）是一个简单的面向数据报的运输层协议。它不提供可靠性，只是把应用程序传给IP层的数据报发送出去，但是不能保证它们能到达目的地。由于UDP在传输数据报前不用再客户和服务器之间建立一个连接，且没有超时重发等机制，所以传输速度很快。
区别：①TCP面向连接，UDP无连接。②TCP可靠传输，使用流量控制和拥塞控制；UDP不可靠传输，不使用流量控制和拥塞控制。③TCP仅一对一；UDP可以一对一，一对多，多对一和多对多交互通信。④TCP面向字节流；UDP面向报文。⑤TCP首部最小20字节，最大60字节；UDP仅8字节。⑥TCP适用于要求可靠传输的应用，例如文件传输；UDP使用于实时应用，例如视频会议，直播等。
（2）DHCP和DNS的作用是什么？
答：
DHCP（Dynamic Host Configuration Protocol，动态主机配置协议）的作用： ① 自动分配IP地址：即网络中的设备接入网络时，DHCP服务器会自动为其分配一个可用的IP地址，无需手动配置。② 提供网络配置参数：除了IP地址，DHCP还为设备提供子网掩码、默认网关、DNS服务器等必要的网络配置信息。③ 集中管理：通过DHCP服务器集中管理网络中的IP地址分配和其他配置参数，简化网络维护工作。④ 支持即插即用：设备接入网络时无需预先配置网络参数，DHCP会自动完成配置，实现快速联网。⑤ 提高IP地址利用率：通过动态分配和租约机制，DHCP能够有效管理IP地址，避免IP冲突，优化IP地址的使用效率。
DNS（Domain Name System，域名系统）的作用：① 域名解析：即用户访问网站时，DNS服务器将用户输入的易记域名（如www.example.com）转换为计算机可识别的IP地址（如192.0.2.1）。② 负载均衡：DNS可以根据服务器的负载情况，将用户请求分发到不同的服务器上，提升服务的可用性和响应速度。③ 缓存加速：DNS服务器会缓存近期解析的域名和IP地址，减少重复查询，提高域名解析的速度。④ 反向解析与安全：DNS不仅支持域名到IP地址的解析，还支持IP地址到域名的反向查询，并可实施安全策略，如防止DNS劫持等。
（3）简述 Linux 文件系统的目录结构，其中/boot、/var、/usr目录的作用分别是什么？
答：
/boot:存放启动系统所需的文件，包括内核镜像（/boot/vmlinuz）、引导加载程序（/boot/grub）和启动配置文件。
/var:存放系统运行过程中产生的可变数据，如日志文件（/var/log）、缓存文件（/var/cache）、邮件队列（/var/spool）等。
/usr:存放用户级应用程序和文件，包括软件安装包（/usr/bin）、库文件（/usr/lib）、文档（/usr/share）等。
（4）Linux系统突然无法访问外网，但内网通信正常。请列出至少 5 个可能的故障点及排查步骤。
答：
1. DNS 配置错误 ：① 检查 /etc/resolv.conf 文件，确认 DNS 服务器地址是否正确。② 使用 nslookup 或 dig 命令测试 DNS 解析，例如 nslookup www.google.com。 ③ 如果 DNS 解析失败，尝试更换 DNS 服务器（如使用 8.8.8.8 或 1.1.1.1）。
2. 默认路由缺失或错误
① 使用 ip route 或 route -n 命令查看当前路由表。② 确认是否存在默认路由（通常为 0.0.0.0/0 或 default）。③ 如果缺少默认路由，添加正确的默认网关，例如 ip route add default via <网关IP> dev <网卡名>。
3. 防火墙规则阻止外网访问：① 检查 iptables 规则，使用 iptables -L -n 查看当前规则。② 如果使用 firewalld，使用 firewall-cmd --list-all 查看规则。③ 确认是否有规则阻止了 HTTP/HTTPS（端口 80/443）或 DNS（端口 53）等流量。 ④ 如果有必要，临时关闭防火墙进行测试，例如 systemctl stop firewalld 或 iptables -F。
4. 网络接口配置错误： ① 使用 ip addr 或 ifconfig 查看网络接口的 IP 配置。 ② 确认 IP 地址和子网掩码是否正确。③ 确认默认网关是否在同一个子网内。④ 如果配置错误，修改网络接口配置文件（如 /etc/network/interfaces 或 /etc/sysconfig/network-scripts/ifcfg-<网卡名>）并重启网络服务。
5. 网络服务异常： ① 使用 systemctl status NetworkManager 或 systemctl status systemd-networkd 查看网络服务状态。② 如果服务未启动，尝试启动服务，例如 systemctl start NetworkManager。③ 检查网络服务日志，寻找错误信息，例如 journalctl -u NetworkManager。
6. 物理连接问题：① 检查网线连接是否牢固。② 尝试更换网线或使用不同的网络端口。③ 使用 ethtool <网卡名> 检查网卡状态，确认链路是否正常。 ④ 如果使用无线网络，检查无线网卡是否正常工作。
7. SELinux 或 AppArmor 限制：① 检查 SELinux 状态，使用 sestatus 命令。② 如果 SELinux 启用，尝试临时将其设置为宽松模式（setenforce 0）进行测试。 ③ 检查 AppArmor 状态，使用 aa-status 命令。④ 如果 AppArmor 启用，查看是否有相关的网络访问限制规则。
8. 代理服务器配置问题 ： ① 检查环境变量中是否设置了 http_proxy 或 https_proxy。② 确认代理服务器地址和端口是否正确。 ③ 尝试直接连接外网，排除代理服务器问题。
2.HR面试题
（1）假如你成功入职，却发现直属领导能力远不如你，你会如何与他共事？
答：
即使发现直属领导的能力不如自己，我依然会保持尊重和专业态度，调整好我的个人心态。我会尊重领导的权威，不在公开场合质疑或挑战领导的决定，同时保持谦逊，不表现出傲慢或自负。我会积极与领导沟通，及时汇报工作进展，并提出建设性的建议和意见，在领导需要帮助时主动提供支持。在团队中，我会以团队目标为重，积极营造良好的合作氛围，并利用自己的优势帮助团队解决问题，提升工作效率。同时，我会不断提升自身能力，适应不同的领导风格和工作环境，并以建设性的方式向领导提供反馈和建议，协同领导改进工作方法。
（2）你简历上的经历并不突出，我们为什么要选你？
答：
虽然我的简历看似不突出，但我拥有快速学习新知识和技能的能力，能够迅速适应新环境和新任务，并在过往经历中成功应用新工具和技术。我始终积极主动地解决问题，乐于承担额外工作，并注重团队合作，能够与不同性格和背景的同事高效协作。我对工作充满热情，认真负责，注重细节，确保按时、高质量地完成任务。此外，我具备出色的抗压能力，能够在高压环境下保持冷静，高效工作。我始终保持开放心态，不断学习和自我提升，并乐于接受反馈，将其作为成长的机会。
备注：不能明确说自己的缺点
（3）你还面试了哪些公司？
答：
目前，我正在积极寻找新的职业机会，除了贵公司，我还面试了几家其他公司。这些公司主要集中在与我专业背景和职业目标相关的领域，不过，我目前更倾向于加入贵公司，因为贵公司在行业内的声誉和影响力，以及贵公司提供的职业发展机会，都非常吸引我。
备注：可以说明面试的领域，不要说明具体的公司
（4）如果你发现公司某项业务存在合规风险，但领导暗示‘别多管闲事’，你会怎么做？
答：
首先确认违规行为的性质和严重程度，在保护领导隐私的前提下，选择适当的时机和方式与领导沟通，提醒其改正。如果情况严重，向上级汇报并遵循公司的规定处理。
3.选择题
（1）以下哪个是合法的 Python 变量名？
A. 2var
B. _var
C. var@1
D. var-1
答：
B. _var
备注：在Python中，变量名必须以字母或下划线开头，后续字符可以是字母、数字或下划线，不能包含空格或其他特殊字符，并且不能使用保留关键字。
（2）表达式 True + 2 的结果是？
A.True
B. 3
C. 2
D. TypeError
答：
B. 3
（3）以下哪个表达式会引发错误？
A."1" + "2"
B. [1, 2] + [3, 4]
C. (1, 2) + (3, 4)
D. {1, 2} + {3, 4}
答：
D. {1, 2} + {3, 4}
（4）以下哪个是将字符串转换为整数的正确方法？
A. str(5)
B. int("5")
C. float("5")
D. bool("5")
答：
B. int("5")
（5）执行 print("Hello", "World", sep='-', end='!') 后，输出结果是？
A .Hello World
B. Hello-World
C. Hello-World!
D. Hello World!
答：
C. Hello-World!
（6）以下哪个运算符用于判断两个对象是否是同一个对象（内存地址相同）？
A. ==
B. !=
C. is
D. in
答：
C. is
（7）执行 print(f"The result is {2 + 3}") ，输出结果是？
A. The result is {2 + 3}
B. The result is 5
C. The result is 2 + 3
D. 语法错误
答：
B. The result is 5
（8）以下代码的输出结果是？
x = 5
if x > 3:
print("A")
elif x > 4:
print("B")
else:
print("C")
A. A
B. B
C. C
D. 无输出
答：
A. A
（9）以下代码是否存在错误？
A = 10
if A > 5:
print("Big")
elif A < 5:
print("Small")
else
print("Medium")
A. 无错误
B. 缩进错误
C. else 后缺少冒号
D. elif 条件错误
答：
C. else 后缺少冒号
（10）以下代码的输出结果是？
x = 0
if x:
print("True")
else:
print("False")
A. True
B. False
C. 语法错误
D. 无输出
答：
B. False
（11）以下代码的输出结果是？
A = 10
B = 20
if A > 5 and B < 15:
print("条件1")
elif A > 8 or B > 18:
print("条件2")
else:
print("条件3")
A. 条件 1
B. 条件 2
C. 条件 3
D. 无输出
答：
B. 条件 2
（12）以下代码的输出结果是？
A = 5
B = 10
if A > 3 or B / 0 > 0:
print("A")
else:
print("B")
A. A
B. B
C. 语法错误
D. 运行时错误
答：
A. A
4.问答题
（1）什么是 Python 的动态类型特性？举例说明。
答：
Python 是一种动态类型语言，这意味着变量的类型在运行时确定，而不是在编译时确定。不需要显式声明变量的类型，Python 会根据变量的赋值自动推断其类型。这种特性使得代码更加灵活和简洁，但也需要在编写代码时更加注意变量的类型变化。
举例:
x = 10 # x 是整数类型
print(type(x)) # 输出: （2）如何将字符串 “123” 转换为整数？如果字符串为 “12a3” 会发生什么？
答：
要将字符串 “123” 转换为整数，可以使用 int() 函数。如果字符串包含非数字字符（如 “12a3”），int() 函数会抛出ValueError 异常。
举例:
# 转换成功的例子
s = "123"
num = int(s)
print(num) # 输出: 123
# 转换失败的例子
s_invalid = "12a3"
try:
num_invalid = int(s_invalid)
except ValueError as e:
print(f"转换失败: {e}") # 输出: 转换失败: invalid literal for int() with base 10: '12a3'
（3）比较 Python 中的动态类型与静态类型语言（如 Java）的优缺点。
答：
动态类型语言（如 Python）的优缺点：
(一) 优点：①简洁性和灵活性：Python 不需要显式声明变量类型，代码更加简洁，同时变量可以在运行时改变类型，适应不同的需求，这使得代码在快速开发和原型设计时具有显著优势。②开发效率高：由于减少了类型声明和编译步骤，开发者可以更快地实现功能并进行测试，适合快速迭代和敏捷开发。
(二) 缺点：①类型安全性较低：由于类型在运行时确定，容易出现类型相关的错误，例如将字符串传递给期望整数参数的方法时，可能会在运行时才抛出错误，增加了调试的难度。②性能较低：动态类型检查和解释执行导致运行速度较慢，尽管 Python 有一些优化措施，但在性能关键的场景下，动态类型语言可能不如静态类型语言高效。
静态类型语言（如 Java）的优缺点
(一)优点：①类型安全性高：Java 在编译时进行类型检查，能够提前捕捉到许多类型错误，减少了运行时错误的可能性，提高了代码的可靠性。②性能优越：编译后的代码经过优化，执行效率更高，适合对性能要求较高的应用场景。
(二) 缺点：①代码冗长：Java 需要显式声明变量类型，代码较为繁琐，这可能会降低开发速度，尤其是在小型项目或快速原型开发中。②灵活性较差：变量类型在编译时确定，灵活性不如动态类型语言，开发者需要更严格地管理类型变化。
比较表格如下：
| 特性 | 动态类型语言（如 Python） | 静态类型语言（如 Java） |
|---|---|---|
| 代码简洁性 | 高 | 低 |
| 灵活性 | 高 | 低 |
| 类型安全性 | 低 | 高 |
| 调试难度 | 高 | 低 |
| 性能 | 低 | 高 |
| 开发速度 | 快 | 慢 |
| IDE 支持 | 一般 | 好 |
| 学习曲线 | 平缓 | 陡峭 |
| 代码可维护性 | 一般 | 好 |
| 适用场景 | 快速开发、原型设计、小型项目 | 大型项目、性能关键型应用 |
（4）简述 input() 函数和 eval() 函数的区别，并举例说明它们的应用场景。
答：
input() 适用于需要用户输入文本、密码、选项等场景，返回值始终为字符串。
eval() 适用于需要将用户输入的字符串当作代码执行或计算表达式的场景，但需谨慎使用以避免安全风险。
input() 函数用于从用户那里获取输入并将其作为字符串返回，无论用户输入什么内容，都不会对其进行任何计算或转换。而 eval() 函数则用于将用户输入的字符串当作有效的 Python 表达式进行求值，并返回计算结果。由于 eval() 会执行传入的字符串代码，因此在使用时需要格外小心，以避免潜在的安全风险，例如代码注入攻击。
| 特性 | input() | eval() |
|---|---|---|
| 功能 | 获取用户输入的字符串 | 将字符串当作 Python 表达式求值 |
| 返回值类型 | 始终为字符串 (str) | 根据表达式结果而定 |
| 安全性 | 安全，不执行代码 | 不安全，可能执行恶意代码 |
| 应用场景 | 获取用户输入的文本、密码、选项等 | 计算用户输入的表达式，动态执行代码 |
应用场景举例:
# 使用 input() 获取用户的基本信息
name = input("请输入您的名字: ")
age_input = input("请输入您的年龄: ")
try:
age = int(age_input) # 将年龄转换为整数
print(f"你好, {name}! 你 {age} 岁了。")
except ValueError:
print("年龄输入无效，请输入一个整数。")
# 使用 input() 创建简单的菜单界面
print("\n请选择操作:")
print("1. 添加")
print("2. 删除")
print("3. 查看")
choice = input("请输入你的选择 (1/2/3): ")
if choice == '1':
print("你选择了添加。")
elif choice == '2':
print("你选择了删除。")
elif choice == '3':
print("你选择了查看。")
else:
print("无效的选择。")
# 使用 eval() 计算用户输入的数学表达式
expr = input("\n请输入一个数学表达式 (例如: 2 + 3 * 4): ")
try:
result = eval(expr)
print(f"结果: {result}")
except Exception as e:
print(f"无效的表达式: {e}")
# 使用 eval() 动态执行简单的代码
code_input = input("\n请输入要执行的代码 (例如: print('Hello, World!') ): ")
try:
exec(code_input)
except Exception as e:
print(f"执行代码时出错: {e}")
（5）比较 == 运算符和 is 运算符的区别，并举例说明在什么情况下结果会不同。
答：
==运算符：== 运算符用于比较两个对象的 值 是否相等。它会检查两个对象的值是否相同，而不考虑它们在内存中的位置或身份。
is运算符：is 运算符用于比较两个对象的 身份 是否相同，即它们是否引用同一个内存地址。它检查两个变量是否指向同一个对象。
区别: == 运算符用于比较两个对象的值是否相等，即它们的内容是否相同，而不考虑它们在内存中的位置或身份；而 is 运算符用于比较两个对象的身份是否相同，即它们是否引用同一个内存地址或对象。在实际应用中，== 更适合用于比较对象的内容是否相等，而 is 则用于确认两个变量是否指向同一个对象或内存地址。
| 特性 | == 运算符 | is 运算符 |
|---|---|---|
| 功能 | 比较两个对象的值是否相等 | 比较两个对象的身份是否相同 |
| 比较内容 | 值是否相同 | 是否引用同一个对象 |
| 适用场景 | 需要比较对象的内容是否相同 | 需要确认两个变量是否引用同一个对象 |
| 结果 | 如果值相等，返回 True，否则返回 False | 如果引用同一个对象，返回 True，否则返回 False |
| 示例 | a = [1, 2, 3] b = [1, 2, 3] a == b→ True |
a = [1, 2, 3] b = [1, 2, 3] a is b → False |
| 注意事项 | 适用于比较对象的内容是否相同 | 适用于比较对象的身份是否相同 |
举例:
# 示例 1: 不同对象但值相同
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # 输出: True，因为 a 和 b 的值相同
print(a is b) # 输出: False，因为 a 和 b 是不同的对象
# 示例 2: 小整数缓存
c = 100
d = 100
print(c == d) # 输出: True，因为 c 和 d 的值相同
print(c is d) # 输出: True，因为小整数被缓存，c 和 d 引用同一个对象
# 示例 3: 大整数不缓存
e = 1000
f = 1000
print(e == f) # 输出: True，因为 e 和 f 的值相同
print(e is f) # 输出: False，因为 e 和 f 是不同的对象
# 示例 4: 字符串缓存
g = "hello"
h = "hello"
print(g == h) # 输出: True，因为 g 和 h 的值相同
print(g is h) # 输出: True，因为字符串被缓存，g 和 h 引用同一个对象
# 示例 5: 自定义对象
class MyClass:
def __init__(self, value):
self.value = value
obj1 = MyClass(10)
obj2 = MyClass(10)
print(obj1 == obj2) # 输出: False，因为默认的 __eq__ 方法比较的是身份
print(obj1 is obj2) # 输出: False，因为 obj1 和 obj2 是不同的对象
# 如果重写 __eq__ 方法
class MyClass:
def __init__(self, value):
self.value = value
def __eq__(self, other):
return self.value == other.value
obj1 = MyClass(10)
obj2 = MyClass(10)
print(obj1 == obj2) # 输出: True，因为重写了 __eq__ 方法
print(obj1 is obj2) # 输出: False，因为 obj1 和 obj2 是不同的对象
（6）逻辑运算符 and、or、not 的运算规则是什么？请分别举例说明。
答：
and：如果所有操作数都为真，则返回最后一个操作数的值；如果有任何一个操作数为假，则返回第一个为假的操作数的值。
or：如果有任何一个操作数为真，则返回第一个为真的操作数的值；如果所有操作数都为假，则返回最后一个操作数的值。
not：返回操作数的相反布尔值。
举例:
# and 示例
a = True and False # 返回 False
b = 5 and 0 # 返回 0
c = 5 and 10 # 返回 10
# or 示例
a = True or False # 返回 True
b = 0 or 20 # 返回 20
c = 0 or 0 # 返回 0
# not 示例
a = not True # 返回 False
b = not 0 # 返回 True
c = not 10 # 返回 False
（7）当使用 input() 函数获取用户输入的数字时，如何将其转换为整数类型？如果用户输入的不是数字，会发生什么？
答：
在 Python 中，input()函数用于从用户那里获取输入，默认情况下，input()函数返回的是字符串类型的数据。
①使用int()函数将输入转换为整数：
举例:
user_input = input("请输入一个整数: ")
num = int(user_input)
print("您输入的整数是:", num)
输出:
请输入一个整数: 123
您输入的整数是: 123
②用户输入非数字的情况：如果用户输入的不是有效的整数，int()函数会抛出 ValueError异常。
举例:
try:
user_input = input("请输入一个整数: ")
num = int(user_input)
print("您输入的整数是:", num)
except ValueError:
print("输入无效，请输入一个有效的整数。")
输出:
请输入一个整数: abc
输入无效，请输入一个有效的整数。
（8）阅读以下代码，解释输出结果并说明原因。
x = 5
if x > 3:
print("X 大于3")
if x > 4:
print("X 大于4")
if x > 5:
print("X 大于5")
答：
X 大于3
X 大于4
（9）编写代码，计算三角形的三个角
题目描述
输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
A=acos((a∗a−b∗b−c∗c)/(−2∗b∗c))B=acos((b∗b−a∗a−c∗c)/(−2∗a∗c))C=acos((c∗c−b∗b−a∗a)/(−2∗a∗b)) A=acos((a*a-b*b-c*c)/(-2*b*c)) \\ B=acos((b*b-a*a-c*c)/(-2*a*c)) \\ C=acos((c*c-b*b-a*a)/(-2*a*b)) \\ A=acos((a∗a−b∗b−c∗c)/(−2∗b∗c))B=acos((b∗b−a∗a−c∗c)/(−2∗a∗c))C=acos((c∗c−b∗b−a∗a)/(−2∗a∗b))
其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角
输入输出描述
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三行，分别为A、B、C三个角的度数，结果保留两位小数
示例
输入：
1 1 6.5 1 6.5 2.5
输出：
15.26
90.00
74.74
答：
import math
def calculate_angles(x1, y1, x2, y2, x3, y3):
a = math.hypot(x2 - x3, y2 - y3)
b = math.hypot(x1 - x3, y1 - y3)
c = math.hypot(x1 - x2, y1 - y2)
try:
A = math.degrees(math.acos((a**2 - b**2 - c**2) / (-2 * b * c)))
B = math.degrees(math.acos((b**2 - a**2 - c**2) / (-2 * a * c)))
C = math.degrees(math.acos((c**2 - b**2 - a**2) / (-2 * a * b)))
except ValueError:
return "无法计算角度"
return round(A, 2), round(B, 2), round(C, 2)
try:
x1, y1, x2, y2, x3, y3 = map(float, input("请输入六个坐标值，用空格分隔: ").strip().split())
except ValueError:
print("输入的坐标数量或格式不正确。")
exit()
result = calculate_angles(x1, y1, x2, y2, x3, y3)
if isinstance(result, tuple):
A, B, C = result
print(f"{A}\n{B}\n{C}")
else:
print(result)
（10）编写代码，解2×2线程方程
题目描述
如有一个2×2的线程方程组：
ax+by=ecx+dy=f ax+by=e \\ cx+dy=f ax+by=ecx+dy=f
你可以使用克莱姆法则解该线性方程：
x=ed−bfad−bc,y=af−ecad−bc x=\frac{ed-bf}{ad-bc},y=\frac{af-ec}{ad-bc} x=ad−bced−bf,y=ad−bcaf−ec
其中 ad−bcad-bcad−bc 为判别式，如果为零则输出无解
输入输出描述
输入a、b、c、d、e、f六个数据，数据之间用空格分隔
输出两行，第一行x的解，第二行y的解，保留一位小数
示例1
输入：
9.0 4.0 3.0 -5.0 -6.0 -21.0
输出：
-2.0
3.0
示例2
输入：
1.0 2.0 2.0 4.0 4.0 5.0
输出：
无解
答：
def solve_linear_equation(a, b, c, d, e, f):
determinant = a * d - b * c
if determinant == 0:
return "无解"
x = (e * d - b * f) / determinant
y = (a * f - e * c) / determinant
return round(x, 1), round(y, 1)
def main():
try:
input_data = input("请输入六个数值，用空格分隔: ").strip().split()
if len(input_data) != 6:
print("输入的数据数量不正确。")
return
a, b, c, d, e, f = map(float, input_data)
except ValueError:
print("输入的数据格式不正确。")
return
result = solve_linear_equation(a, b, c, d, e, f)
if result == "无解":
print("无解")
else:
x, y = result
print(f"{x}\n{y}")
if __name__ == "__main__":
main()