Day 24：Python 30 道高频面试题及详细解答
发布日期：2022年3月12日 18:02 阅读: 200 访问: 200
1. 一行代码生成 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]使用列表生成式，创建列表，观察元素出现规律，可得出如下代码：In [97]: a = [2*i+1 for i in range(10)] In [98]: a Out[98]: [1, 3, 5,
1. 一行代码生成 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
使用列表生成式，创建列表，观察元素出现规律，可得出如下代码：
In [97]: a = [2*i+1 for i in range(10)]
In [98]: a
Out[98]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]2. 写一个等差数列
产生一个首项为 10，公差为 12，末项不大于 100 的列表。
使用列表生成式创建：
In [1]: a = list(range(10,100, 12))
In [2]: a
Out[2]: [10, 22, 34, 46, 58, 70, 82, 94]3. 一行代码求 1 到 10000 内整数和
提供两种方法：
1. 使用 Python 内置函数 sum 求和：
In [99]: s = sum(range(10000))
In [100]: s
Out[100]: 499950002. 使用 functools 模块中的 reduce 求和：
In [101]: s = reduce(lambda x,y: x+y, range(10000))
In [102]: s
Out[102]: 499950004. 打乱一个列表
使用 random 模块，shuffle 函数打乱原来列表，值得注意是 in-place 打乱。
import random
a = range(10)
random.shuffle(a)
print(a) # [4, 6, 1, 2, 5, 3, 9, 0, 8, 7]5. 字典按 value 排序并返回新字典？
原字典：
d= {'a':12,'b':50,'c':1,'d':20} 使用 Python 内置函数 sorted 排序：
In [10]: d = dict(sorted(d.items(),key=lambda item: item[1]))
In [11]: d
Out[11]: {'c': 1, 'a': 12, 'd': 20, 'b': 50} 6. 如何删除 list 里重复元素，并保证元素顺序不变
给定列表：
a = [3,2,2,2,1,3]如果只是删除重复元素，直接使用内置 set 函数，去重，但是不能保证原来元素顺序。
不要这么做，列表删除某个元素后，后面的元素整体会向前移动。
def del_duplicated(a):
ac = a.copy()
b = []
for index, i in enumerate(ac):
if i in b:
del ac[index]
else:
b.append(i)
return ac
In [18]: r = del_duplicated(a)
In [19]: r
Out[19]: [3, 2, 2, 1] # wrong 正确做法：
def del_duplicated(a):
b = []
for i in a:
if i not in b:
b.append(i)
return b7. 怎么找出两个列表的相同元素和不同元素？
给定列表 a = [3,2,2,2,1,3]，列表 b = [1,4,3,4,5]，使用集合，找出相同元素：
def ana(a,b):
aset, bset = set(a), set(b)
same = aset.intersection(bset)
differ = aset.difference(bset).union(bset.difference(aset))
return same, differ
In [28]: ana(a,b)
Out[28]: ({1, 3}, {2, 4, 5})8. 字符串处理成字典
输入串 "k0:10|k1:2|k2:11|k3:5"，输出字典 {k0:10,k1:2,...}。
- 第一层 split，根据分隔符
|，分割出k0:10,k1:2,k2:11,k3:5 - 第二层 split，根据分隔符
:，分割出新字典的键值对
使用字典生成式，得到结果，也就是一个新字典：
In [30]: m = map(lambda x: x.split(':'),'k0:10|k1:2|k2:11|k3:5'.split('|'))
In [31]: {mi[0]:int(mi[1]) for mi in m}
Out[31]: {'k0': 10, 'k1': 2, 'k2': 11, 'k3': 5}9. 输入日期，判断这一天是这一年的第几天？
使用 datetime 模块，提取日期 date 对象，调用 timetuple() 方法，返回一个 struct_time 对象，属性 tm_yday 便是这一年的第几天：
from datetime import datetime
def get_day_of_year(y,m,d):
return datetime(y,m,d).date().timetuple().tm_yday
In [45]: get_day_of_year(2020,2,1)
Out[45]: 32
In [46]: get_day_of_year(2019,12,31)
Out[46]: 36510. 遍历目录与子目录，抓取 .py 文件
os 模块、walk 方法实现递归遍历所有文件，os.path.splitext 返回文件的名字和扩展名，如果扩展名匹配到 ext，则添加到 res 中。
import os
def get_files(directory,ext):
res = []
for root,dirs,files in os.walk(directory):
for filename in files:
name,suf = os.path.splitext(filename)
if suf == ext:
res.append(os.path.join(root,filename))
return res
get_files('D:/source/python-zhuanlan','.py')11. 单机 4G 内存，处理 10G 文件的方法？
假定可以单独处理一行数据，行间数据相关性为零。
方法一：仅使用 Python 内置模板，逐行读取到内存。
使用 yield，好处是解耦读取操作和处理操作：
def python_read(filename):
with open(filename,'r',encoding='utf-8') as f:
for line in f:
yield line以上每次读取一行，逐行迭代，逐行处理数据：
if __name__ == '__main__':
g = python_read('./data/movies.dat')
for c in g:
print(c)
# process c方法二：方法一有缺点，逐行读入，频繁的 IO 操作拖累处理效率。是否有一次 IO，读取多行的方法？
Pandas 包 read_csv 函数，参数有 38 个之多，功能非常强大。
关于单机处理大文件，read_csv 的 chunksize 参数能做到，设置为 5，意味着一次读取 5 行。
def pandas_read(filename,sep=',',chunksize=5):
reader = pd.read_csv(filename,sep=sep,chunksize=chunksize)
while True:
try:
yield reader.get_chunk()
except StopIteration:
print('---Done---')
break使用如同方法一：
if __name__ == '__main__':
g = pandas_read('./data/movies.dat',sep="::")
for c in g:
print(c)
# process c以上就是单机处理大文件的两个方法，推荐使用方法二，更加灵活。
12. 统计一个文本中单词频次最高的 10 个单词
使用 yield 解耦数据读取 python_read 和数据处理 process
- python_read：逐行读入
- process：正则替换掉空字符，并使用空格，分隔字符串，保存到 defaultdict 对象中。
from collections import Counter, defaultdict
import re
def python_read(filename):
with open(filename, 'r', encoding='utf-8') as f:
for line in f:
yield line
d = defaultdict(int)
def process(line):
for word in re.sub('\W+', " ", line).split():
d[word] += 1使用两个函数，最后，使用 Counter 类统计出频次最高的 10 个单词：
for line in python_read('write_file.py'):
process(line)
most10 = Counter(d).most_common(10)
print(most10)13. 反转一个整数，例如 -12345 --> -54321
- 如果 x 位于 (-10,10) 间，直接返回；
- 然后，将 x 转换为字符串对象 sx；
- 如果 x 是负数，截取 sx[1:]，并反转字符串；
- 如果 x 是正数，直接反转字符串；
- 最后使用内置函数 int() 转化为整数。
def reverse_int(x: int):
if -10 < x < 10:
return x
sx = str(x)
def reverse_str(sx):
return sx[::-1]
if sx[0] == "-":
sx = reverse_str(sx[1:])
x = int(sx)
return -x
sx = reverse_str(sx)
return int(sx)14. 以下代码输出结果
此题需要注意，内嵌函数 foo 使用的两个变量 i 和 x，其中 x 为其形参，i 为 enclosing 域内定义的变量。
rtn 添加三个函数 foo，但是并未发生调用。
def f():
i = 0
def foo(x):
return i*x
rtn = []
while i < 3:
rtn.append(foo)
i += 1
return rtn
# 调用函数 f
for fs in f():
print(fs(10))直到执行 fs(10) 时，内嵌函数 foo 才被调用，但是此时的 enclosing 变量 i 取值为 3：
for fs in f():
print(fs(10))所以输出结果为：
30
30
3015. 如下函数 foo 的调用哪些是正确的？
def foo(filename,a=0,b=1,c=2):
print('filename: %s \n c: %d'%(filename,c))已知 filename 为 '.'，c 为 10，正确为 foo 函数传参的方法，以下哪些是对的，哪些是错误的？
A foo('.', 10)
B foo('.', 0,1,10)
C foo('.',0,1,c=10)
D foo('.',a=0,1,10)
E foo(filename='.', c=10)
F foo('.', c=10)分析：
A 错误，a 被赋值为 10
B 正确，c 是位置参数
C 正确，c 是关键字参数
D 错误，位置参数不能位于关键字参数后面
E 正确，filename 和 c 都是关键字参数
F 正确，filename 位置参数，c 是关键字参数验证测试：
In [58]: foo('.', 10)
filename: .
c: 2
In [59]: foo('.', 0,1,10)
filename: .
c: 10
In [60]: foo('.',0,1,c=10)
filename: .
c: 10
In [61]: foo('.',a=0,1,10)
File "<ipython-input-61-e3909182c523>", line 1
foo('.',a=0,1,10)
^
SyntaxError: positional argument follows keyword argument
In [62]: foo(filename='.', c=10)
filename: .
c: 10
In [63]: foo('.', c=10)
filename: .
c: 1016. lambda 函数的形参和返回值
key 值为 lambda 函数，说说 lambda 函数的形参和返回值。
def longer(*s):
return max(*s, key=lambda x: len(x))
longer({1,3,5,7},{1,5,7},{2,4,6,7,8})lambda 函数的形参：s 解包后的元素值，可能取值为：{1,3,5,7}、{1,5,7}、{2,4,6,7,8} 三种。
lambda 函数的返回值为：元素的长度，可能取值为：{1,3,5,7}、{1,5,7}、{2,4,6,7,8} 的长度 4,3,5。
17. 正则匹配负整数
匹配所有负整数，不包括 0。正则表达式：^-[1-9]\d*$
^-表示字符串以-开头[1-9]表示数字 1 到 9，注意不要写成\d，因为负整数没有以 -0 开头的\d*表示数字 0 到 9 出现 0 次、1 次或多次$表示字符串以数字结尾
以上分布讲解的示意图，如下所示：
测试字符串：
import re
s = ['-1','-15756','9','-01','10','-']
pat = r'^-[1-9]\d*$'
rec = re.compile(pat)
rs = [i for i in s if rec.match(i)]
print(rs)
# 结果
# ['-1', '-15756']18. 正则匹配负浮点数
正确写出匹配负浮点数的正则表达式，要先思考分析。
考虑到两个实例：-0.12、-111.234，就必须要分为两种情况。
适应实例 -0.12 的正则表达式：^-0.\d*[1-9]\d*$，注意要考虑到 -0.0000 这种非浮点数，因此正则表达式必须这样写。
不要想当然地写为：^-0.\d*$，或者 ^-0.\d*[1-9]*$，或者 ^-0.\d*[0-9]*$，这些都是错误的！
适应实例 -111.234 的正则表达式：^-[1-9]\d*.\d*$，使用 |，综合两种情况，故正则表达式为：
^-[1-9]\d*\.\d*|-0\.\d*[1-9]\d*$
测试字符串：
import re
s = ['-1','-1.5756','-0.00','-000.1','-1000.10']
pat = r'^-[1-9]\d*\.\d*|-0\.\d*[1-9]\d*$'
rec = re.compile(pat)
rs = [i for i in s if rec.match(i)]
print(rs)
# 结果
# ['-1.5756', '-1000.10']19. 使用 filter() 求出列表中大于 10 的元素
filter 函数使用 lambda 函数，找出满足大于 10 的元素。
a = [15,2,7,20,400,10,9,-15,107]
al = list(filter(lambda x: x > 10, a))
In [74]: al
Out[74]: [15, 20, 400, 107]20. 说说下面 map 函数的输出结果
map 函数当含有多个列表时，返回长度为最短列表的长度；
lambda 函数的形参个数等于后面列表的个数。
m = map(lambda x,y: min(x,y), [5, 1, 3, 4], [3,4,3,2,1])
print(list(m))结果为：
[3, 1, 3, 2]21. 说说 reduce 函数的输出结果
reduce 实现对列表的归约化简，规则如下：
f(x,y) = x*y + 1因此，下面归约的过程为：
f(1,2) = 3
f(3,3) = 3*3 + 1 = 10
f(10,4) = 10*4 + 1 = 41
f(41,5) = 41*5 + 1 = 206from functools import reduce
reduce(lambda x,y: x*y+1,[1,2,3,4,5])结果为：
20622. x = (i for i in range(5))，x 是什么类型
x 是生成器类型，与 for 等迭代，输出迭代结果：
x = (i for i in range(5))
for i in x:
print(i)结果为：
0
1
2
3
423. 可变类型和不可变类型分别列举 3 个
- 可变类型：mutable type，常见的有：list、dict、set、deque 等
- 不可变类型：immutable type，常见的有：int、float、str、tuple、frozenset 等
只有不可变类型才能作为字典等的键。
24. is 和 == 有什么区别？
- is 用来判断两个对象的标识号是否相等；
- == 用于判断值或内容是否相等，默认是基于两个对象的标识号比较。
也就是说，如果 a is b 为 True 且如果按照默认行为，意味着 a==b 也为 True。
25. 写一个学生类 Student
添加一个属性 id，并实现若 id 相等，则认为是同一位同学的功能。
重写 __eq__ 方法，若 id 相等，返回 True。
class Student:
def __init__(self,id,name):
self.id = id
self.name = name
def __eq__(self,student):
return self.id == student.id判断两个 Student 对象，== 的取值：
s1 = Student(10,'xiaoming')
s2 = Student(20,'xiaohong')
s3 = Student(10,'xiaoming2')
In [85]: s1 == s2
Out[85]: False
In [86]: s1 == s3
Out[86]: True26. 有什么方法获取类的所有属性和方法？
获取下面类 Student 的所有属性和方法，使用 dir() 内置函数。
class Student:
def __init__(self,id,name):
self.id = id
self.name = name
def __eq__(self,student):
return self.id == student.id获取类上的所有属性和方法：
In [87]: dir(Student)
Out[87]:
['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']获取实例上的属性和方法：
s1 = Student(10,'xiaoming')
In [88]: dir(s1)
Out[88]:
['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',
'id',
'name']27. Python 中如何动态获取和设置对象的属性？
如下 Student 类：
class Student:
def __init__(self,id,name):
self.id = id
self.name = name
def __eq__(self,student):
return self.id == student.idPython 使用 hasattr 方法，判断实例是否有属性 x：
s1 = Student(10,'xiaoming')
In [93]: hasattr(s1,'id')
Out[93]: True
In [94]: hasattr(s1,'address')
Out[94]: False 使用 setattr 动态添加对象的属性，函数原型：
<function setattr(obj, name, value, /)>为类对象 Student 添加属性：
if not hasattr(Student, 'address'):
setattr(Student,'address','beijing')
print(hasattr(s1,'address'))28. 实现一个按照 2*i+1 自增的迭代器
实现类 AutoIncrease，继承于 Iterator 对象，重写两个方法：
- __iter__
- __next__
from collections.abc import Iterator
class AutoIncrease(Iterator):
def __init__(self, init, n):
self.init = init
self.n = n
self.__cal = 0
def __iter__(self):
return self
def __next__(self):
if self.__cal == 0:
self.__cal += 1
return self.init
while self.__cal < self.n:
self.init *= 2
self.init += 1
self.__cal += 1
return self.init
raise StopIteration调用递减迭代器 Decrease：
iter = AutoIncrease(1,10)
for i in iter:
print(i)打印结果：
1
3
7
15
31
63
127
255
511
102329. 实现文件按行读取和操作数据分离功能
使用 yield 解耦按行读取和操作数据的两步操作：
def read_line(filename):
with open(filename, 'r', encoding='utf-8') as f:
for line in f:
yield line
def process_line(line:str):
pass
for line in read_line('.'):
process_line(line)30. 使用 Python 锁避免脏数据出现的例子
使用多线程编程，会出现同时修改一个全局变量的情况，创建一把锁 locka：
import threading
import time
locka = threading.Lock()
a = 0
def add1():
global a
try:
locka.acquire() # 获得锁
tmp = a + 1
time.sleep(0.2) # 模拟 IO 操作
a = tmp
finally:
locka.release() # 释放锁
print('%s adds a to 1: %d'%(threading.current_thread().getName(),a))
threads = [threading.Thread(name='t%d'%(i,),target=add1) for i in range(10)]
[t.start() for t in threads]通过 locka.acquire() 获得锁，通过 locka.release() 释放锁。获得锁和释放锁之间的代码，只能单线程执行。
执行结果，如下：
t0 adds a to 1: 1
t1 adds a to 1: 2
t2 adds a to 1: 3
t3 adds a to 1: 4
t4 adds a to 1: 5
t5 adds a to 1: 6
t6 adds a to 1: 7
t7 adds a to 1: 8
t8 adds a to 1: 9
t9 adds a to 1: 10多线程的代码，由于避免脏数据的出现，基本退化为单线程代码，执行效率被拖累。
31. 说说死锁、GIL 锁、协程
多个子线程在系统资源竞争时，都在等待对方解除占用状态。
比如，线程 A 等待着线程 B 释放锁 b，同时，线程 B 等待着线程 A 释放锁 a。在这种局面下，线程 A 和线程 B 都相互等待着，无法执行下去，这就是死锁。
为了避免死锁发生，Cython 使用 GIL 锁，确保同一时刻只有一个线程在执行，所以其实是伪多线程。
所以，Python 里常常使用协程技术来代替多线程。多进程、多线程的切换是由系统决定，而协程由我们自己决定。协程无需使用锁，也就不会发生死锁。同时，利用协程的协作特点，高效的完成了原编程模型只能通过多个线程才能完成的任务。
小结
今天，一口气，与大家一起练习了 30 道 Python 高频面试题，如果大家一天一天好好学习专栏，坚持到现在的话，一定能解决这 30 道练习题。
与此同时，大家通过练习这些题目，进一步打牢 Python 基础，提升 Python 水平到一个新的层次，恭喜大家！这是你们辛勤付出的结果。