python常见面试题

1 基础知识

1.1 Python中的不可变数据类型和可变数据类型是什么意思？

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

1.2 请简述Python中is和==的区别

is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；而==比较的是对象的值是否相等，其调用了对象的__eq__()方法。

1.3 function(args, **kwargs)中的args和**kwargs分别是什么意思？

*args：可选的位置参数
**kwargs: 可选的关键词参数
python中默认的函数参数顺序： 必选参数，默认参数，位置参数，关键词参数

1.4 面向对象中__new__和__init__的区别

__new__(): new的作用是创建一个类的实例化对象
__init__():对new创建的实例进行初始化

1.5 Python子类在继承多个父类时，如多个父类有同名方法，子类继承哪个方法？

默认继承第一个父类的同名方法

1.6 Python中如何避免死锁？

1 什么是锁？全局解释器锁（GIL）,在同一个进程中只要有一个线程获得了全局解释器(cpu)的使用权限,那么其他的线程就必须等到该线程的全局解释器(cpu)的使用权小时候，才能使用全局解释器。
2 全局解释器锁的好处？a. 避免了大量的加锁解锁b. 是数据更加安全，解决多线程间数据完整性和状态同步
3 全局解释器锁的缺点多核处理器退化为单核处理器，只能并发不能并行(同一时刻的某个进程下的某个线程只能被一个cpu所处理，所以在GIL锁下的线程只能被并发，不能被并行)
4 出现死锁的原因？当多个线程同时获取多个锁的时候，容易造成资源的相互竞争，一个线程一直阻塞等待另一个线程释放锁，造成死锁。

1.6.1 多线程锁示例(互斥锁)

# coding:utf-8import threading
import timeif __name__ == '__main__':x_lock = threading.Lock()y_lock = threading.Lock()# def thread_1():#     while True:#         with x_lock:#             print("thread_1 acquire x_lock, sleep: %s s" % 1)#             with y_lock:#                 print("thread_1 acquire y_lock...")#                 time.sleep(1)## def thread_2():#     while True:#         with y_lock:#             print("thread_2 acquire y_lock, sleep: %s s" % 1)#             while x_lock:#                 print("thread_2 acquire x_lock...")#                 time.sleep(1)### t1 = threading.Thread(target=thread_1)# t1.start()# t2 = threading.Thread(target=thread_2)# t2.start()x_lock = threading.Lock()y_lock = threading.Lock()def thread_3():while True:x_lock.acquire()print("thread_3 acquire x_lock, sleep: %s s" % 1)time.sleep(1)y_lock.acquire()print("thread_3 acquire y_lock...")time.sleep(1)y_lock.acquire()x_lock.acquire()def thread_4():while True:y_lock.acquire()print("thread_4 acquire y_lock, sleep: %s s" % 1)x_lock.acquire()print("thread_4 acquire x_lock...")time.sleep(1)x_lock.acquire()y_lock.acquire()t3 = threading.Thread(target=thread_3)t3.start()t4 = threading.Thread(target=thread_4)t4.start()####################################result#######################################
thread_3 acquire x_lock, sleep: 1 s
thread_4 acquire y_lock, sleep: 1 s
可以发现发生了死锁：thread_3在获取 y_lock 的锁的时候， 发现该锁已经被 thread_4 获取了， 造成 thread_3 一直在等待 y_lock.thread_4在获取 x_lock 的锁的时候， 发现该锁已经被 thread_3 获取了， 造成 thread_4 一直在等待 x_lock.

1.6.2 多线程可重入锁

1.6.3 如何避免死锁的发生？

1. 获取锁的时候加一个超时参数， 例如 lock.acquire(timeout=10)
2. 为程序中的每一个锁分配一个唯一的id方法： 使用上下文管理器

# coding: utf-8import threading
import time
from contextlib import contextmanager# Thread-local state to stored information on locks already acquired
_local = threading.local()@contextmanager
def acquire(*locks):# Sort locks by object identifierlocks = sorted(locks, key=lambda x :id(x))# Make sure lock order of previously acquired locks is not viloatedacquired = getattr(_local, "acquired", [])if acquired and max(id(lock) for lock in acquired) >= id(locks[0]):raise RuntimeError('Lock Order Violation')# Acquire all of the locksacquired.extend(locks)_local.acquired = acquiredprint("acquired: %s" % acquired)try:for lock in locks:print("acquired lock: %s" % lock)lock.acquire()yieldfinally:# Release locks in reverse order of acquisitionfor lock in reversed(locks):lock.release()del acquired[-len(locks):]if __name__ == '__main__':x_lock = threading.Lock()y_lock = threading.Lock()def thread_1():while True:try:with acquire(x_lock, y_lock):print("thread_1 acquired x_lock, y_lock: ", getattr(_local, "acquired", []))time.sleep(1)except:print("thread_1 lock error")# time.sleep(1)def thread_2():time.sleep(0.5)while True:try:with acquire(y_lock, x_lock):print("thread_2 acquired y_lock, x_lock: ", getattr(_local, "acquired", []))time.sleep(1)except:print("thread_2 lock error")# time.sleep(1)# print("_local acquired: %s" % getattr(_local, "acquired", []))t1 = threading.Thread(target=thread_1)t1.start()t2 = threading.Thread(target=thread_2)t2.start()

1.7 排序算法

1.7.1 常见的排序算法

1. 冒泡排序
2. 快速排序
3. 归并排序
4. 堆排序
5. shell排序
6. 二叉树排序

1.7.2 以上排序算法的时间/空间复杂度，稳定性如何？

2 字符串和数字

2.1 s=“hfkfdlsahfgdiuanvzx”, 对s去重并排序。adfghiklnsuvxz

s="hfkfdlsahfgdiuanvzx"# 方法 1 
result = "".join(set(s)) # 方法 2
list1 = list(set(s))
result = sorted(list1, key=lambda x: ord(x)) # 或者 sorted(list1) 从小到大
result = sorted(list1, key=lambda x: -ord(x)) # 从大到小

2.2 试判定给定的字符串 s 和 t 知否满足 s 中所有字符都可以替换为 t 中的所有的字符？

换个问法： s 和 t 是否是同构的

ssss