python面试总结

1. 列表和元组的区别

• 从可变上，列表可变，元组不可变。即可以直接在列表上进行增、删、改，但元组不行，所以从某种程度上元组更安全
• 从效率上，创建元组要比创建列表块，存储空间要比列表小。当某些变量我们不再使用的时候，系统就会自动回收释放内存，以便其他程序或变量使用。对于长度为1-20的元组而言，即使不再使用，也不会马上释放内存，而是留给以后使用。当需要创建新的元组的时候，就可以直接使用这块内存，而不需要再去向系统申请内存。；由于列表可变，所以需要额外的存储空间，这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间。

列表，元组，字典，集合的同异

2. 列表插入的4种方法

1. a+b
2. a.append(value)
3. a.extend(b)
4. a.insert(n, value)

方法2和方法3都是添加到末尾，方法4是添加到指定位置。

3. 列表删除的三种方法

1. a.remove(value)——删除指定元素（用for循环删除重复元素时，要用copy）
2. del a[index]——删除指定索引的元素
3. a,pop(index)——弹出并删除指定索引的元素

4. 深copy和浅copy

import copy
a = [1, 2]

# 浅copy，a变化时，b也会变化
b = copy.copy(a)

#深copy，a变化时，c不会变化
c = copy.deepcopy(b)

5. 用python实现斐波那契数列

• 直接计算（返回第$n$个值）：

def rabbit1(n):
    f1=1
    f2=1
    if (n==1 or n==2):
        return 1
    else:
        for i in range(3,n+1):
            f1,f2=f2,f1+f2
        return f2

• 直接计算（返回列表）：

def rabbit(n):
    f1=1
    f2=1
    results = []
    if n == 1:
        return [1]
    if n == 2:
        return [1, 1]
    else:
        results.append(1)
        results.append(1)
        for i in range(3,n+1):
            f1,f2=f2,f1+f2
            results.append(f2)
        return results

• 递归方式1（速度慢）

def rabbit2(n):
    if (n==1 or n==2):
        return 1
    else:
        return rabbit2(n-1)+rabbit2(n-2)

• 递归方式2（比递归方式1快，但还是比直接计算慢）

def rabbit3(n,rabbits={1:1,2:1}):
    if n in rabbits:
        return rabbits[n]
    res=rabbit3(n-1)+rabbit3(n-2)
    rabbits[n]=res
    return res

6. 冒泡排序

比较两个相邻的元素, 如果左边比右边的大, 就交换它们.

def BubbleSort(lst):
    n=len(lst)
    if n<=1:
        return lst
    for i in range (0,n):
        for j in range(0,n-i-1):
            # 逆序排, 即从大到小
            # 如果想要从小到大排, 改为lst[j]>lst[j+1]即可
            if lst[j]<lst[j+1]:
                (lst[j],lst[j+1])=(lst[j+1],lst[j])
    return lst

7. 快速排序

def quick_sort(nums: list, left: int, right: int) -> None:
	if left < right:
		i = left
		j = right
		# 取第一个元素为枢轴量
		pivot = nums[left]
		while i != j:
			# 交替扫描和交换
			# 从右往左找到第一个比枢轴量小的元素，交换位置
			# 如果是降序, 改成nums[j] < pivot即可
			while j > i and nums[j] > pivot:
				j -= 1
			if j > i:
				# 如果找到了，进行元素交换
				nums[i] = nums[j]
				i += 1
			# 从左往右找到第一个比枢轴量大的元素，交换位置
			# 如果是降序, 改成nums[i] > pivot即可
			while i < j and nums[i] < pivot:
				i += 1
			if i < j:
				nums[j] = nums[i]
				j -= 1
		# 至此完成一趟快速排序，枢轴量的位置已经确定好了，就在i位置上（i和j)值相等
		nums[i] = pivot
		# 以i为枢轴进行子序列元素交换
		quick_sort(nums, left, i-1)
		quick_sort(nums, i+1, right)		


# 测试代码
import random

data = [random.randint(-100, 100) for _ in range(10)]
quick_sort(data, 0, len(data) - 1)
print(data)