2024.9.27 Python面试八股文

1.列表操作：

1.列表.pop(index)
这样可以pop指定下标的元素
2.列表.reverse()
列表翻转
3.列表名.count(数据)：数据在列表中出现的次数。

In [56]: a = [11, 22, 11, 33, 11]
In [57]: a.count(11)
Out[57]: 3

4.列表名.index(数据)：数据在列表中首次出现时的索引，没有查到会报错。
In [59]: a = [11, 22, 33, 44, 22]
In [60]: a.index(22)
Out[60]: 1
5.请写出一段 Python 代码实现删除一个 list 里面的重复元素?
如果想要保持他们原来的排序：用 list 类的 sort 方法：

l1=['b','c','d','b','c','a','a']
l2=list(set(l1))
l2.sort(key=l1.index)
print(l2)
#或者下面
l1=['b','c','d','b','c','a','a']
l2=[]
for item in l1:
	if item not in l2:
		l2.append(item)

2.集合操作

#交集
A&B
#并集
A|B
#差集
A-B#A里有的，B里也有的，减掉A中的元素，B里有A里没有的，不管，A里有B里没有的，留下
#对称差集
A^B#A|B-A&B

3.文件操作

with open('file.txt', 'r') as f:
    for i in range(4):  # 假设文件有 4 行
        line = f.readline()
        if i in [1, 2]:  # 读取第 2 行和第 3 行
            print(f"Line {i}: {line.strip()}")

这个例子就表明了，正常情况下我们如何调用某一行

4.strip()

strip说白了就是给你去除多余的空格和回车，文件中是有回车字符的，这样就可以让文件或者输入更干净

line = "   Hello, World!   \n"
line = line.strip()  # 赋值给 line
print(line)  # 输出 "Hello, World!"

5.浅拷贝和深拷贝

# 一维列表
original = [1, 2, 3]
shallow_copy = original[:]
shallow_copy[0] = 99
print(original)  # 输出 [1, 2, 3]，两者独立

# 多维列表
original = [[1, 2], [3, 4]]
shallow_copy = original[:]
shallow_copy[0][0] = 99
print(original)  # 输出 [[99, 2], [3, 4]]，因为共享了可变对象

import copy
original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)
deep_copy[0][0] = 99
print(original)  # 输出 [[1, 2], [3, 4]]

6.回调函数

def process_data(data, callback):
    result = [x * 2 for x in data]
    callback(result)

def my_callback(result):
    print("处理后的结果:", result)

def save_to_file(result):
    with open('output.txt', 'w') as f:
        f.write(str(result))

data = [1, 2, 3, 4, 5]

# 使用不同的回调函数
process_data(data, my_callback)  # 打印结果
process_data(data, save_to_file)  # 保存到文件

回调函数就是把函数当成参数随着函数带入进去。这个例子中你完全可以在process_data里把两个函数都写进去，但是你的灵活性就降低了。使用回调函数的方法就可以灵活的修改本函数中使用具体哪个块来操作。这个逻辑不是内联函数，仍然是函数的调用，是把函数的指针(地址)作为参数传递给另一个函数，将整个函数当作一个对象，赋值给调用的函数。

这样你可以通过传入不同的回调函数来完成不同的任务，而不需要修改 process_data 本身的实现。
使用回调函数作为参数的设计使得你的代码更加灵活、可扩展、且不同部分可以独立演进。在简单的场景下，可以直接写死回调函数，但在复杂项目中，回调函数作为参数能带来更多的灵活性和可维护性。