Python常见面试题的详解4

1. 单例模式的实现方式

python

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        # 如果类尚未在实例字典中，就创建一个新实例
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        # 无论是否新创建，都返回对应的实例
        return instances[cls]
    return get_instance

@singleton
class MyClass:
    pass

2. Lambda 函数的概念

python

# 使用 lambda 定义一个加法函数
add = lambda x, y: x + y
print(add(2, 3))  # 输出 5，展示函数的计算结果

3. 类型转换方法

python

num_str = "123"
# 将字符串类型的数字转换为整数类型
num_int = int(num_str)  
print(num_int)  # 输出 123，验证转换结果

4. 反序迭代序列的方法

python

lst = [1, 2, 3]
# 使用 reversed() 函数反序迭代列表
for item in reversed(lst):
    print(item)  
# 输出 3, 2, 1，展示反序迭代的结果

5. Tuple 和 List 的相互转换

python

my_list = [1, 2, 3]
# 将列表转换为元组
my_tuple = tuple(my_list)  
print(my_tuple)  # 输出 (1, 2, 3)，展示转换后的元组

5. 删除列表重复元素的方法

python

def deduplicate(lst):
    seen = set()
    # 遍历列表，若元素不在已访问集合中，则保留并添加到集合中
    return [x for x in lst if not (x in seen or seen.add(x))]

6. 删除文件的方法

python

import os
# 尝试删除名为 "file.txt" 的文件
os.remove("file.txt")  

7. 生成随机数的方法

python

import random
# 生成 1 到 100 之间的随机整数并输出
print(random.randint(1, 100))  

7. 发送邮件的方法

python

import smtplib
from email.mime.text import MIMEText

# 创建邮件内容对象
msg = MIMEText("邮件内容")
msg["Subject"] = "主题"
msg["From"] = "发件人"
msg["To"] = "收件人"

# 使用上下文管理器连接邮件服务器并发送邮件
with smtplib.SMTP("smtp.example.com", 587) as server:
    server.login("user", "password")
    server.send_message(msg)

8. 静态代码分析工具

9. 交换元素使两序列和差最小

有两个序列 a，b， 大小都为 n，序列元素的值任意整形数， 无序； 要求： 通过交换 a，b 中的元素， 使[序列 a 元素的和]与[序列 b 元素的和]之间的差最小

1. 合并序列并计算总和：将序列 a 和 b 合并为一个新序列 combined，然后计算这个新序列的总和 total。

2. 确定目标和：我们的目标是从 combined 中选出 n 个元素，使得这 n 个元素的和尽可能接近 total / 2。

3. 使用动态规划：通过动态规划的方法来寻找最接近目标和的 n 个元素的组合。

4. 交换元素：根据动态规划得到的结果，确定哪些元素需要从一个序列交换到另一个序列，从而实现和差最小。

python

def minimal_diff(a, b):
    n = len(a)
    combined = a + b
    total = sum(combined)
    target = total // 2

    # 创建一个三维动态规划数组 dp
    # dp[i][j][k] 表示在前 i 个元素中选择 j 个元素，其和是否可以达到 k
    dp = [[[False] * (total + 1) for _ in range(n + 1)] for _ in range(2 * n + 1)]
    dp[0][0][0] = True

    # 填充动态规划数组
    for i in range(1, 2 * n + 1):
        for j in range(min(i, n) + 1):
            for k in range(total + 1):
                # 不选择第 i 个元素
                dp[i][j][k] = dp[i - 1][j][k]
                if j > 0 and k >= combined[i - 1]:
                    # 选择第 i 个元素
                    dp[i][j][k] = dp[i][j][k] or dp[i - 1][j - 1][k - combined[i - 1]]

    # 找到最接近目标和的和
    closest_sum = 0
    for k in range(target, -1, -1):
        if dp[2 * n][n][k]:
            closest_sum = k
            break

    # 回溯找出选择的元素
    selected = [False] * (2 * n)
    i, j, k = 2 * n, n, closest_sum
    while i > 0:
        if not dp[i - 1][j][k]:
            selected[i - 1] = True
            j -= 1
            k -= combined[i - 1]
        i -= 1

    # 根据选择的元素重新划分序列 a 和 b
    new_a = [combined[i] for i in range(2 * n) if selected[i]]
    new_b = [combined[i] for i in range(2 * n) if not selected[i]]

    return new_a, new_b

# 示例使用
a = [1, 2, 3]
b = [4, 5, 6]
new_a, new_b = minimal_diff(a, b)
print("序列 a 交换后的元素:", new_a)
print("序列 b 交换后的元素:", new_b)
print("序列 a 的和:", sum(new_a))
print("序列 b 的和:", sum(new_b))
print("和的差:", abs(sum(new_a) - sum(new_b)))

1. 动态规划数组 dp：dp[i][j][k] 表示在前 i 个元素中选择 j 个元素，其和是否可以达到 k。
2. 填充动态规划数组：通过三重循环遍历所有可能的状态，更新 dp 数组的值。
3. 找到最接近目标和的和：从目标和 target 开始递减搜索，找到第一个满足 dp[2 * n][n][k] 为 True 的 k 值。
4. 回溯找出选择的元素：根据 dp 数组的值，回溯找出哪些元素被选中。
5. 重新划分序列：根据选择的元素，重新划分序列 a 和 b。

10. 正则表达式 <.*> 和 <.*?> 的区别

python

# 对于字符串 "<a><b></b></a>"
# 贪婪匹配 <.*> 会匹配整个字符串 "<a><b></b></a>"
# 非贪婪匹配 <.*?> 会分别匹配 "<a>" 和 "<b>" 等单独的标签

作者：ylfhpy