Python最常考的面试题——内存模型深度解剖：从地址、堆栈到深浅拷贝的底层逻辑

x = 10
print(f"x的值：{x}")
print(f"x的内存地址（id）：{id(x)}")  # 输出示例：140703383430720

y = x
print(f"y的值：{y}")
print(f"y的内存地址：{id(y)}")  # 与x的id完全相同：140703383430720
print(f"x和y是否是同一个对象？{x is y}")  # 输出：True

def func():
    a = [1,2,3]  # 栈上存储a指向的内存地址，堆上存储[1,2,3]对象
    print(f"函数内a的地址：{id(a)}")  # 示例：140703383221696

func()  # 函数执行完毕后，栈上的a被销毁，但堆上的[1,2,3]对象若没有其他引用，会被GC回收

a = [1,2,3]  # 堆上再次创建[1,2,3]对象，但地址与函数内不同
print(f"函数外a的地址：{id(a)}")  # 示例：140703383221760

x = 256
y = 256
print(f"x的地址：{id(x)}")  # 示例：140703383430720
print(f"y的地址：{id(y)}")  # 与x相同：140703383430720
print(f"x is y：{x is y}")  # True

x = 257
y = 257
print(f"x的地址：{id(x)}")  # 示例：140703383430752
print(f"y的地址：{id(y)}")  # 示例：140703383430784（不同地址）
print(f"x is y：{x is y}")  # False（257不在小整数池内）

x = "abc123"
y = "abc123"
print(f"x is y：{x is y}")  # True（满足驻留条件）

x = "abc 123"  # 包含空格，不满足驻留条件
y = "abc 123"
print(f"x is y：{x is y}")  # False

x = 10
print(f"x=10的地址：{id(x)}")  # 示例：140703383430720
x += 5  # 修改不可变类型，创建新对象
print(f"x=15的地址：{id(x)}")  # 示例：140703383430880（新地址）
print(f"x的当前值：{x}")  # 15

s = "hello"
print(f"s='hello'的地址：{id(s)}")  # 示例：140703383221696
s += " world"  # 创建新字符串对象
print(f"s='hello world'的地址：{id(s)}")  # 示例：140703383221760（新地址）

t = (1,2)
print(f"t=(1,2)的地址：{id(t)}")  # 示例：140703383221824
# t[0] = 3 → 报错：TypeError: 'tuple' object does not support item assignment（不可修改）

a = [1,2,3]
print(f"a=[1,2,3]的地址：{id(a)}")  # 示例：140703383221888
a.append(4)  # 修改可变类型，更新原对象
print(f"a=[1,2,3,4]的地址：{id(a)}")  # 仍然是140703383221888
a[0] = 10  # 修改元素，地址不变
print(f"a=[10,2,3,4]的地址：{id(a)}")  # 140703383221888

d = {"name": "张三", "age": 20}
print(f"d的地址：{id(d)}")  # 示例：140703383221952
d["age"] = 21  # 修改值，地址不变
print(f"d的地址：{id(d)}")  # 140703383221952
d["city"] = "北京"  # 添加键值对，地址不变
print(f"d的地址：{id(d)}")  # 140703383221952

t = ([1,2], 3)  # tuple包含一个list
print(f"t的地址：{id(t)}")  # 示例：140703383222080
print(f"t的内容：{t}")  # ([1,2], 3)

# 修改tuple里的list内容
t[0].append(3)
print(f"t的地址：{id(t)}")  # 仍然是140703383222080
print(f"t的内容：{t}")  # ([1,2,3], 3)（内容变了！）

# 尝试修改tuple的元素引用 → 报错
# t[0] = [4,5] → TypeError: 'tuple' object does not support item assignment

a = [1,2,3]
b = a  # 拷贝a的引用，b与a指向同一个对象
print(f"a的地址：{id(a)}")  # 示例：140703383222144
print(f"b的地址：{id(b)}")  # 140703383222144
print(f"a is b：{a is b}")  # True

# 修改b，a也会变
b.append(4)
print(f"a的内容：{a}")  # [1,2,3,4]
print(f"b的内容：{b}")  # [1,2,3,4]

def modify_list(lst):
    lst.append(4)  # 修改原对象

a = [1,2,3]
modify_list(a)
print(f"外部a的内容：{a}")  # [1,2,3,4]（被修改了！）

def modify_int(x):
    x += 5  # 创建新对象，不会影响外部

b = 10
modify_int(b)
print(f"外部b的内容：{b}")  # 10（未被修改）

a = [1,2,3]
b = [1,2,3]
print(f"a == b：{a == b}")  # True（内容相同）
print(f"a is b：{a is b}")  # False（不同内存地址）

x = None
y = None
print(f"x is y：{x is y}")  # True（None是单例对象，只有一个内存地址）

import copy

# 嵌套列表
a = [[1,2], [3,4]]
b = copy.copy(a)  # 浅拷贝

print(f"a的地址：{id(a)}")  # 示例：140703383222208
print(f"b的地址：{id(b)}")  # 示例：140703383222272（新地址，浅拷贝成功）
print(f"a is b：{a is b}")  # False

# 嵌套对象的引用仍然相同
print(f"a[0]的地址：{id(a[0])}")  # 示例：140703383222336
print(f"b[0]的地址：{id(b[0])}")  # 140703383222336（同一个地址）
print(f"a[0] is b[0]：{a[0] is b[0]}")  # True

# 修改b的嵌套对象，a也会变
b[0][0] = 5
print(f"a的内容：{a}")  # [[5,2], [3,4]]（a被修改了！）
print(f"b的内容：{b}")  # [[5,2], [3,4]]

import copy

a = [[1,2], [3,4]]
c = copy.deepcopy(a)  # 深拷贝

print(f"a的地址：{id(a)}")  # 示例：140703383222208
print(f"c的地址：{id(c)}")  # 示例：140703383222400（新地址）
print(f"a is c：{a is c}")  # False

# 嵌套对象也被拷贝了
print(f"a[0]的地址：{id(a[0])}")  # 示例：140703383222336
print(f"c[0]的地址：{id(c[0])}")  # 示例：140703383222464（新地址）
print(f"a[0] is c[0]：{a[0] is c[0]}")  # False

# 修改c的嵌套对象，a不变
c[0][0] = 1
print(f"a的内容：{a}")  # [[5,2], [3,4]]（a未被修改）
print(f"c的内容：{c}")  # [[1,2], [3,4]]

a = [[1,2], [3,4]]
b = a.copy()       # 浅拷贝
c = a[:]           # 浅拷贝
d = list(a)        # 浅拷贝
print(f"b[0] is a[0]：{b[0] is a[0]}")  # True
print(f"c[0] is a[0]：{c[0] is a[0]}")  # True
print(f"d[0] is a[0]：{d[0] is a[0]}")  # True

import copy
import time

# 创建一个复杂的嵌套列表（1000×1000）
a = [[i for i in range(1000)] for _ in range(1000)]

# 浅拷贝时间
start = time.time()
b = copy.copy(a)
end = time.time()
print(f"浅拷贝时间：{end - start:.4f}秒")  # 约0.0001秒

# 深拷贝时间
start = time.time()
c = copy.deepcopy(a)
end = time.time()
print(f"深拷贝时间：{end - start:.4f}秒")  # 约0.1秒（慢1000倍！）

import copy

def process_config(config):
    # 深拷贝，避免修改外部配置
    config_copy = copy.deepcopy(config)
    config_copy["db"]["port"] = 3307  # 修改数据库端口
    return config_copy

# 原配置
config = {"db": {"host": "localhost", "port": 3306}}
service_config = process_config(config)
print(f"原配置端口：{config['db']['port']}")  # 3306（未被修改）
print(f"服务配置端口：{service_config['db']['port']}")  # 3307

def func(lst=[]):
    lst.append(1)
    return lst

print(func())  # [1]
print(func())  # [1,2]（共享同一个列表！）
print(func())  # [1,2,3]

def func(lst=None):
    if lst is None:
        lst = []  # 每次调用都创建新列表
    lst.append(1)
    return lst

print(func())  # [1]
print(func())  # [1]
print(func())  # [1]

# 全局配置
global_config = {
    "server": {"port": 8080},
    "log": {"level": "INFO"}
}

# 服务1配置：完全独立，修改不影响全局
import copy
service1_config = copy.deepcopy(global_config)
service1_config["server"]["port"] = 8081

# 服务2配置：仅第一层独立，日志配置与全局共享
service2_config = copy.copy(global_config)
service2_config["server"]["port"] = 8082

print(f"全局端口：{global_config['server']['port']}")  # 8080
print(f"服务1端口：{service1_config['server']['port']}")  # 8081
print(f"服务2端口：{service2_config['server']['port']}")  # 8082