20道python面试题

1.关于子进程和父进程的说法，下面哪一个是正确的

A. 子进程被撤销时，其从属的父进程也被撤销

B. 一个父进程可以创建若干个子进程，一个子进程可以从属于若干个父进程

C. 父进程被撤销时，其所有子进程也被相应撤销

D. 一个进程可以没有父进程或子进程

答：C

2.若I/O设备与存储设备进行数据交换不经过CPU，则数据交换方式是？

A. 程序查询方式

B. DMA方式

C. 无条件存取方式

D. 中断方式

答：B

3.设系统有N个进程并发，共享竞争资源x，且每个进程都需要m个资源，为使该系统不会发生死锁，则资源X最少要是多少个？

答：计算公式为

x > N(m-1)

4.确保事务可以多次从一个字段中读取相同的值，在此事务持续期间，禁止其他事务对此字段的更新是对下列选项哪一个…

A.Repeatable Read

B.Read uncommitted

C.Read committed

D.Serializable

5.有如下函数定义，执行结果正确的是？

def dec(f):
    n = 3

    def wrapper(*args, **kw):
        return f(*args, **kw) * n
    return wrapper

@dec
def foo(n):
    return n * 2

A.foo(2) == 6

B.foo(2) == 12

C.foo(3) == 12

D.foo(3) == 6

6.假如有1500盏灯，它们的开关按1-1500进行编号，一开始都是亮着灯，我们按照如下步骤操作

1. 切换编号为2的倍数的开关
2. 切换编号为5的倍数的开关
3. 切换编号为7的倍数的开关

最终还有多少盏灯亮着？

A.750

B.236

C.514

D.535

通过编程计算，得出结果为C，计算代码如下：

pool = [1] * 1500
switch = lambda x: 0 if x == 1 else 1

for i in range(1500):
  if (i + 1) % 2 == 0 or (i + 1) % 5 == 0 or (i + 1) % 7 == 0:
    pool[i] = switch(pool[i])
  
print(sum(pool))

7.并发操作会带来哪些数据不一致性？

A. 不可重复读、脏读、死锁

B. 不可修改、不可重复读、脏读、死锁

C. 丢失修改、脏读、死锁

D. 丢失修改、不可重复读、脏读

8.执行以下代码，返回结果是

x = {"姓名":"小花", "学校":"北京大学"}
print(x.pop("学校", "abcd"))

A.”abcd”

B. {”姓名”:”小花”}

C. “北京大学”

D.“小花”

答：C

9.执行以下程序，输出结果为

class Base:
    count = 0
    def __init__(self) -> None:
        pass

b1 = Base()
b2 = Base()
b1.count += 1
print(b1.count, end='')
print(Base.count, end='')
print(b2.count)

A. 1 0 1

B. 1 1 1

C. 1 0 0

D. 抛出异常

10.执行以下代码，结果输出为（）

num = 1
def fn():
    num += 1
    return lambda : print(num)

x = fn()
x()

A. None

B. 报错

C. 2

D. 1

11.下列程序运行结果为

a = [1, 2, 3, 4, 5]
sums = sum(map(lambda x: x + 3, a[1::3]))
print(sums)

12.当使用import导入模块时，按python查找模块的不同顺序可划分为以下几种

1. 环境变量中的PYTHONPATH
2. 内建模块
3. Python安装路径
4. 当前路径

其中查找顺序正确的是

A.2413

B.1423

C.2143

D.1234

13.同一进程中的线程不共享的部分是

A.代码段

B.信号

C.文件描述符

D.进程组id

E.堆

F.堆空间

14.判断闰年的代码

15.根据以下程序，下列选项中，说法正确的是

class Foo()
    def __ini__(self):
        pass
    def __getitem__(self, pos):
        return range(0, 30, 10)[pos]
foo = Foo()

A.可以使用for i in foo:print(i)来遍历foo的元素

B.foo对象表现得像个序列

C.可以使用len(foo)来查看对象foo的元素个数

D.不能使用foo[0]来访问对象foo的第一个元素

16.单链表实现的栈，栈顶指针为Top(仅仅是一个指针)，入栈一个P节点，其操作步骤为 A.p→next = Top; Top=p→next;

B.Top→next=p

C.p→next = Top→next;Top→next=p;

D.p→next=Top;Top=Top→next;

17.假设你只有100MB的内存，需要对1GB的数据进行排序，最合适的算法是

A.冒泡排序

B.归并排序

C.插入排序

D.快速排序

18.以下不能创建一个字典的语句是

A.dict3 = {[1, 2, 3]:”uestc”}

B.dict1 = {}

C.dict2 = {3 : 5}

D.dict4 = {(1,2,3) : “uestc”}

19.下列代码运行结果是

a = map(lambda x : x ** 3, [1, 2, 3])
list(a)

A. [1, 8, 27]

B. [1, 6, 9]

C.[1,12,27]

D.[1,6,9]

20.执行以下程序，输出结果为

def outer(fn):
    print("outer")
    def inner():
        print("inner")
        return fn
    return inner

@outer
def fun():
    print("fun")

A.fun

B.outer

C.inner

D.因为没有调用任何函数，所有没有输出