python 面试题（2）
文件操作
1.读取一个大文件，例如文件大小为10g，且内存为4g，该怎么读取文件内容
2.编写一个函数，这个函数接收文件夹的名称作为输入参数 返回该文件夹中文件的路径 以及其包含文件夹中文件的路径
- 使用os.listdir()返回文件名称的列表，不是全路径
from os import listdir
from os.path import isdir, isfile, join
def fun(path: str):
for dir in listdir(path):
dir_path = join(path, dir)
if isdir(dir_path):
fun(dir_path)
else:
print(dir_path)
- 使用os.walk()返回当前文件夹名称、当前文件夹下的文件夹列表、当前文件夹下的文件列表
from os import walk
from os.path import join
def fun(path: str):
for dir_name, dir_list, file_list in walk(path):
for file in file_list:
print(join(dir_name, file))
fun(r"D:\python_study\study")
- 使用pathlib下的Path.iterdir()获取当前文件夹下的文件夹
from pathlib import Path
def fun(path: str):
if not isinstance(path, Path):
path = Path(path)
for dir in path.iterdir():
if dir.is_dir():
fun(dir)
else:
print(dir)
- 使用pathlib中的Path.rglog显示文件夹下的所有文件及文件夹
from pathlib import Path
def fun(path: str):
if not isinstance(path, Path):
path = Path(path)
for dir in path.rglob("*"):
if dir.is_file():
print(dir)
3.打乱一个排好序的list对象list？
from random import shuffle
list = [1, 2, 3, 5, 7]
shuffle(list)
print(list)
[2, 7, 5, 3, 1]
4.现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
d = {"a": 24, "g": 52, "i": 12, "k": 33}
data = sorted(d.items(), key=lambda x:x[1])
print(data)
print(dict(data))
('i', 12), ('a', 24), ('k', 33), ('g', 52)]
{'i': 12, 'a': 24, 'k': 33, 'g': 52}
5.请反转字符串 "aStr"
data = "aStr"
print(data[::-1])
rtSa
6.将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典
data = "k:1 |k1:2|k2:3|k3:4"
d = {}
for item in data.split("|"):
print((item.split(":"),))
for k, v in (item.split(":"),):
d[k] = v
print(d)
print({k: v for item in data.split("|") for k, v in (item.split(":"), )})
(['k', '1 '],)
(['k1', '2'],)
(['k2', '3'],)
(['k3', '4'],)
{'k': '1 ', 'k1': '2', 'k2': '3', 'k3': '4'}
{'k': '1 ', 'k1': '2', 'k2': '3', 'k3': '4'}
7.请按alist中元素的age由大到小排序
alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
alist = [{"name": "a", "age": 20}, {"name": "b", "age": 30}, {"name": "c", "age": 25}]
data = sorted(alist, key=lambda n: n["age"], reverse=True)
print(data)
[{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]
8.判定如下结果的输出
list = ['a','b','c','d','e']
print(list[10:])
只会返回一个空列表，不会报错
9.写一个列表生成式，产生一个公差为11的等差数列
data = [i for i in range(1, 100, 11)]
print(data)
10.给定两个列表，怎么找出他们相同的元素和不同的元素？
list1 = [1, 2, 3]
list2 = [3, 4, 5]
# 取交集
data = set(list1).intersection(set(list2))
print(data)
# 取不同的合并在一起
data = set(list1).difference(set(list2)).union(set(list2).difference(set(list1)))
print(data)
# 取交集
print(set(list1) & set(list2))
# 取除交集以外的所有元素
print(set(list1) ^ set(list2))
# 并集
print(set(list1) | set(list2))
{3}
{1, 2, 4, 5}
{3}
{1, 2, 4, 5}
{1, 2, 3, 4, 5}
11.请写出一段python代码实现删除list里面的重复元素？
l1 = ["b", "c", "d", "c", "a", "a"]
# set是无序的
data = list(set(l1))
print(data)
from collections import Counter
data = list(Counter(l1).keys())
print(data)
l2 = []
for item in l1:
if l2.count(item) == 0:
l2.append(item)
print(l2)
from collections import defaultdict
d = defaultdict(int)
for item in l1:
d[item] += 1
data = list(d.keys())
print(data)
12.python新式类和经典类的区别？
a. 在python里凡是继承了object的类，都是新式类
b. Python3里只有新式类
c. Python2里面继承object的是新式类，没有写父类的是经典类
d. 经典类目前在Python里基本没有应用
e. 保持class与type的统一对新式类的实例执行a.class与type(a)的结果是一致的，对于旧式类来说就不
一样了。
f.对于多重继承的属性搜索顺序不一样新式类是采用广度优先搜索，旧式类采用深度优先搜索。
13.python中内置的数据结构有几种？
a. 整型 int、 长整型 long、浮点型 float、 复数 complex
b. 字符串 str、 列表 list、 元祖 tuple
c. 字典 dict 、 集合 set
d. Python3 中没有 long，只有无限精度的 int
14.python如何实现单例模式?请写出两种实现方式?
1.使用装饰器
使用类字典保存唯一的实例对象，根据字典中是否存在实例对象判断是否再进行初始化
from functools import wraps
def singleton(cls):
_instance = {}
@wraps(cls)
def inner(*args, **kwargs):
if not _instance.get(cls, None):
_instance[cls] = cls(*args, **kwargs)
return _instance
return inner
@singleton
class Test(object):
pass
for i in range(10):
t1 = Test()
print(id(t1))
2.使用元类
由于类和type类似于对象和类的关系，所以类()调用的是type的__call__方法，因此重写type的__call__即可
class Singleton(type):
def __call__(cls, *args, **kwds):
if not hasattr(cls, "_instance"):
cls._instance = super(Singleton, cls).__call__(*args, **kwds)
return cls._instance
class Test(metaclass=Singleton):
pass
for i in range(10):
t1 = Test()
print(id(t1))
3.使用基类
由于类的实例化对象是由__init__完成，然而__init__是由__new__实例化而成，因此重写__new__方法即可
class Singleton(object):
def __new__(cls, *args, **kwds):
if not hasattr(cls, "_instance"):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwds)
return cls._instance
class Test(Singleton):
pass
for i in range(10):
t1 = Test()
15.反转一个整数，例如-123 --> -321
data = "-123"
ret = data[0] + data[:-len(data):-1]
print(ret)
16.设计实现遍历目录与子目录，抓取.pyc文件
17..一行代码实现1-100之和
from functools import reduce
data = reduce(lambda x, y: x + y, range(101))
print(data)
from itertools import accumulate
from collections import deque
data = accumulate(range(101), lambda x, y: x + y)
print(deque(data).pop())
18.Python-遍历列表时删除元素的正确做法
a = [1, 2, 3, 4, 5, 6, 7, 8]
# 向新列表添加
list_data = []
for item in a:
if item % 2 == 0:
list_data.append(item)
print(list_data)
# 生成器
from typing import List
def delete_element(data: List):
for item in data:
if item % 2 == 0:
yield item
print(list(delete_element(a)))
# 倒序遍历删除
for item in a[::-1]:
if item % 2 != 0:
a.remove(item)
print(a)
将两个字典合并， 注意需要对于相同的key需要相加，不能覆盖
dic_data1 = {"a": 1, "b": 2}
dic_data2 = {"a": 1, "b": 2, "c": 3}
# 1
ret = {}
for k, v in dic_data1.items():
ret[k] = dic_data2.get(k, 0) + v
ret2 = {}
for k, v in dic_data2.items():
ret2[k] = dic_data1.get(k, 0) + v
ret.update(ret2)
print(ret)
# 2
data = {
**{k: dic_data2.get(k, 0) + v for k, v in dic_data1.items()},
**{k: dic_data1.get(k, 0) + v for k, v in dic_data2.items()},
}
print(data)
展开一个序列items = [1, 2, [3, 4, [5, 6], 7], 8]
普通写法
items = [1, 2, [3, 4, [5, 6], 7], 8]
new_list = []
def expand(data):
global new_list
if isinstance(data, Iterable):
for item in data:
if not isinstance(item, Iterable):
new_list.append(item)
else:
expand(item)
expand(items)
print(new_list)
[1, 2, 3, 4, 5, 6, 7, 8]
生成器写法
items = [1, 2, [3, 4, [5, 6], 7], 8]
def expand(data):
if isinstance(data, Iterable):
for item in data:
if not isinstance(item, Iterable):
yield item
else:
yield from expand(item)
print(list(expand(items)))
