python面试题

python部分

1.可变数据类型和不可变数据类型

可变数据类型：当该数据类型对应的变量的值发生改变时，它对应的内存地址不变 。 如 列表、字典、集合
不可变数据类型：当该数据类型对应变量的值发生改变时，对应的内存地址改变。 如 整型、字符串、元组

2.深拷贝和浅拷贝

浅拷贝: 没有拷贝子对象，改变子对象会改变原始列表的子对象 copy.copy()
深拷贝: 包含对象里面的子对象，原始对象的改变不会造成深拷贝里任何子元素的改变 copy.deepcopy()

a = [1,2,3,[1,2]]
b = copy.copy(a)
c = copy.deepcopy(a)
b[3].append(3)
c[3].append(4)
print(a,b,c)
# [1, 2, 3, [1, 2, 3]]
# [1, 2, 3, [1, 2, 3]]
# [1, 2, 3, [1, 2, 4]]

3.new()和init()的区别

用法

1.new()用来创建实例，是类级别的方法，在实例创建之前被调用
2.init()用例初始化实例，是实例级别的方法，在实例对象创建后被调用，用于设置对象属性的一些初始值

参数

3.new()至少有一个参数cls，代表当前类
4.init()至少有一个参数self,就是这个__new__()返回的实例

返回值

5.new()必须返回实例对象
6.init()不需要返回值

4.一行代码实现1+2+3+4+…+10的8次方

sum((x for x in range(10**8+1)))

5.python装饰器作用，实现一个装饰器，在函数前后打印一行Log

装饰器作用：在不改变函数本身的情况下提供额外的功能

# 前后打印Log
def log(func):
	def wrapper(*args,**kwargs):
		print('before func')
		ret = func(*args,**kwargs)
		print('after func')
		return ret
	return wrapper

@log
def test():
	print('execute func')

6.什么是python自省

自省就是面对对象的语言所写的程序在运行时，能知道对象的类型

7.手写邮箱正则表达式

r'^[a-zA-Z0-9_]{1,19}@[a-zA-Z0-9]{1,19}\.(net|cn|com)$'

8.python实现单例的四种模式

1.new
2.共享属性
3.import
4.装饰器

# 装饰器实现单例代码
def single(cls):
	instance = {}
	def wrapper(*args,**kwargs):
		if cls not in instance:
			instance[cls] = cls(*args,**kwargs)
		return instance[cls]
	return wrapper

@single
class Myclass:
	a = 1

9.垃圾回收机制

1.引用计数 2.分代回收 3.孤立引用环

1.引用计数：分配对象和取消分配对象差值达到一定阈值时，会进行垃圾回收 gc.get_threshold()=(700,10,10)
2.分代回收：该策略基本的假设是存活越久的对象，越不可能在后面的程序中变成垃圾，我们将所有的对象分为0、1、2三代
第一次扫描: 只扫描第0代的对象
第二次扫描: 0、1代的对象
第三次扫描: 0、1、2代的对象
3.孤立引用环 a = [] b = [a] a.append(b)

10.如何遍历一个内部未知的文件夹

path = os.walk(r’d:\AFS’)
os.walk()返回的是一个生成器 对象是三元组(root,dirs,file)

11.CPU密集型和IO密集型

CPU密集型适合C语言
IO密集型适合python

12.线程和进程的区别

进程是CPU分配的最小单位，线程是CPU调度的最小单位，一个进程可以有多个线程
多进程的稳定性高（其中一个子进程崩溃，不会影响其他进程和主进程）、创建进程的代价大（操作系统能运行的进程数是有限的）
多线程的效率高，但稳定性低（任何一个线程挂掉都会直接造成整个进程崩溃，因为所有线程共享进程的内存）

13.协程为何比线程快

协程看上去是子程序，但执行过程中，在子程序内部可以中断，转而执行别的程序，在适当的时候再返回来继续执行。

1. 协程执行效率极高，子程序切换不是线程切换，而是程序在切换。因此，没有线程切换的开销。
2. 不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突