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)))

持续更新中