2.8.变量与内存

a = 10

Python 的变量（标签模型）:
变量 a ────→ [整数对象 10]
             (内存地址: 0x1000)

# 合法的变量名
name = "Alice"
user_age = 25
_country = "USA"
value2 = 100

# 非法的变量名
2name = "Bob"      # 错误！以数字开头
user-age = 30      # 错误！包含连字符
class = "Math"     # 错误！class 是关键字

# 推荐：蛇形命名法（snake_case）
user_name = "Charlie"
total_count = 42
file_path = "/docs/report.pdf"

# 不推荐：驼峰命名法（用于类名）
userName = "Charlie"
TotalCount = 42

# 见名知意
email_address = "user@example.com"
max_retry_count = 3

# 不清晰
e = "user@example.com"
mrc = 3

# 单下划线开头：内部使用，不建议外部访问
_internal_var = "private"

# 双下划线开头：类的私有成员
__private_var = "really private"

# 双下划线前后：魔术方法/特殊方法
__init__, __str__, __len__

# 单下划线：临时变量或不重要的变量
for _ in range(5):
    print("Hello")

# 基本类型赋值
message = "Hello, World!"
pi = 3.14159
is_active = True
count = 0

# 同时为多个变量赋同一个值
a = b = c = 100
print(a, b, c)  # 100 100 100

# 同时为多个变量赋不同的值（元组解包）
name, age, city = "Alice", 30, "Beijing"
print(name)  # Alice
print(age)   # 30
print(city)  # Beijing

# Python 方式（推荐）
x, y = 10, 20
x, y = y, x
print(x, y)  # 20 10

# 传统方式（不推荐）
x, y = 10, 20
temp = x
x = y
y = temp
print(x, y)  # 20 10

# 注意：共享同一个对象
a = b = [1, 2, 3]
a.append(4)
print(b)  # [1, 2, 3, 4] - b 也被修改了！

# 正确方式：分别赋值
a = [1, 2, 3]
b = [1, 2, 3]  # 创建新对象
a.append(4)
print(b)  # [1, 2, 3] - b 没有被修改

# 数字是对象
x = 42
print(type(x))  # <class 'int'>
print(isinstance(x, object))  # True

# 函数也是对象
def greet():
    return "Hello"

print(type(greet))  # <class 'function'>
print(isinstance(greet, object))  # True

var = 100
print(var, type(var))  # 100 <class 'int'>

var = "Now I'm a string"
print(var, type(var))  # Now I'm a string <class 'str'>

var = [1, 2, 3]
print(var, type(var))  # [1, 2, 3] <class 'list'>

var = {"key": "value"}
print(var, type(var))  # {'key': 'value'} <class 'dict'>

# id() 返回对象的唯一标识（内存地址）
a = [1, 2, 3]
print(id(a))  # 例如：140245678901234

# is 检查是否是同一个对象
b = a
c = [1, 2, 3]

print(a is b)  # True - 指向同一个对象
print(a is c)  # False - 指向不同的对象
print(a == c)  # True - 内容相同

# 查看 id
print(id(a))  # 140245678901234
print(id(b))  # 140245678901234 (相同)
print(id(c))  # 140245678905678 (不同)

a = 100
b = a

变量 a ────┐
          ↓
      [整数对象 100]
          ↑
变量 b ────┘
(地址: 0x2000)

a = 100
b = a

print(a is b)           # True - 指向同一个对象
print(id(a) == id(b))   # True - 内存地址相同

# 修改 a 会怎样？
a = 200
print(a)  # 200
print(b)  # 100 - b 仍然指向原来的对象

# 内存变化
print(a is b)  # False - 现在指向不同对象

a = [1, 2, 3]
b = [1, 2, 3]

变量 a ───→ [列表对象 [1,2,3]]
            (地址: 0x3000)

变量 b ───→ [列表对象 [1,2,3]]
            (地址: 0x4000)

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True - 值相等
print(a is b)  # False - 不是同一个对象
print(id(a), id(b))  # 两个不同的地址

# 修改 a 不会影响 b
a.append(4)
print(a)  # [1, 2, 3, 4]
print(b)  # [1, 2, 3]

# 整数缓存
a = 100
b = 100
print(a is b)  # True - 指向同一个缓存对象
# 字符串驻留
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True - 指向同一个对象

# 包含特殊字符的字符串可能不驻留
s3 = "hello"*10000
s4 = "hello"*10000
print(s3 is s4)  # 可能是 False

# 数字示例
x = 5
print(f"x 的地址: {id(x)}")

x = x + 1  # 不是修改 5，而是创建新对象 6
print(f"x 的新地址: {id(x)}")  # 地址改变了

# 字符串示例
s = "hello"
print(f"s 的地址: {id(s)}")

s = s + " world"  # 创建新字符串
print(f"s 的新地址: {id(s)}")  # 地址改变了

# 元组示例
t = (1, 2, 3)
print(f"t 的地址: {id(t)}")

# t[0] = 99  # 错误！元组不可修改

t = (1, 2, 3, 4)  # 创建新元组
print(f"t 的新地址: {id(t)}")  # 地址改变了

# 列表示例
lst = [1, 2, 3]
print(f"列表地址: {id(lst)}")

lst.append(4)  # 原地修改
print(f"append 后: {lst}")
print(f"列表地址: {id(lst)}")  # 地址不变

lst[0] = 99  # 原地修改元素
print(f"修改后: {lst}")
print(f"列表地址: {id(lst)}")  # 地址仍不变

# 字典示例
d = {"name": "Alice", "age": 25}
print(f"字典地址: {id(d)}")

d["city"] = "Beijing"  # 原地添加键值对
print(f"添加后: {d}")
print(f"字典地址: {id(d)}")  # 地址不变

# 风险示例
list1 = [1, 2, 3]
list2 = list1  # list2 和 list1 指向同一个列表

list1.append(4)
print(list2)  # [1, 2, 3, 4] - list2 也被修改了！

# 安全方式：创建副本
list1 = [1, 2, 3]
list2 = list1.copy()  # 或 list2 = list1[:]

list1.append(4)
print(list1)  # [1, 2, 3, 4]
print(list2)  # [1, 2, 3] - list2 不受影响

# 元组是不可变的，但可以包含可变对象
t = (1, 2, [3, 4])

# 不能修改元组本身
# t[0] = 99  # 错误！

# 但可以修改元组中的可变对象
t[2].append(5)
print(t)  # (1, 2, [3, 4, 5])

# 元组的 id 没变，但内容变了

def modify_list(lst):
    """修改列表（可变对象）"""
    lst.append(4)
    print(f"函数内 lst: {lst}, id: {id(lst)}")

def modify_number(num):
    """修改数字（不可变对象）"""
    num = num + 1
    print(f"函数内 num: {num}, id: {id(num)}")

def reassign_list(lst):
    """重新赋值列表"""
    lst = [7, 8, 9]  # 创建新对象
    print(f"函数内 lst: {lst}, id: {id(lst)}")

# 测试可变对象
my_list = [1, 2, 3]
print(f"调用前: {my_list}, id: {id(my_list)}")
modify_list(my_list)
print(f"调用后: {my_list}")  # [1, 2, 3, 4] - 被修改了！

# 测试不可变对象
my_num = 10
print(f"\n调用前: {my_num}, id: {id(my_num)}")
modify_number(my_num)
print(f"调用后: {my_num}")  # 10 - 没有被修改

# 测试重新赋值
print(f"\n调用前: {my_list}, id: {id(my_list)}")
reassign_list(my_list)
print(f"调用后: {my_list}")  # [1, 2, 3, 4] - 没有被修改

# 危险：可变对象作为默认参数
def add_item(item, lst=[]):
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] - 意外！
print(add_item(3))  # [1, 2, 3] - 意外！

# 正确方式
def add_item_safe(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

print(add_item_safe(1))  # [1]
print(add_item_safe(2))  # [2]
print(add_item_safe(3))  # [3]

import copy

# 原始列表（包含嵌套列表）
original = [1, 2, [3, 4]]

# 1. 直接赋值（共享引用）
assigned = original
assigned[0] = 99
print(original)  # [99, 2, [3, 4]] - 被修改了

# 2. 浅拷贝（只拷贝第一层）
original = [1, 2, [3, 4]]
shallow = copy.copy(original)
# 或 shallow = original.copy()
# 或 shallow = original[:]

print(original is shallow)  # False - 外层是新对象
print(original[2] is shallow[2])  # True - 内层是同一个对象

shallow[0] = 100
print(original)  # [1, 2, [3, 4]] - 没有被影响

shallow[2].append(5)
print(original)  # [1, 2, [3, 4, 5]] - 被影响了！

# 3. 深拷贝（完全独立的副本）
original = [1, 2, [3, 4]]
deep = copy.deepcopy(original)

print(original[2] is deep[2])  # False - 完全独立

deep[2].append(5)
print(original)  # [1, 2, [3, 4]] - 没有被影响
print(deep)     # [1, 2, [3, 4, 5]]

import gc

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
    
    def __del__(self):
        print(f"Node {self.value} 被回收")

# 创建循环引用
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1  # 形成环

# 删除引用
del node1
del node2

# 手动触发垃圾回收
print("触发垃圾回收...")
gc.collect()  # Python 的垃圾回收器会处理循环引用

# 好的命名
user_email = "user@example.com"
max_retry_count = 3
is_authenticated = True
total_price = 99.99

# 不好的命名
e = "user@example.com"
mrc = 3
flag = True
tp = 99.99

# 检查是否为 None（使用 is）
value = None
if value is None:  #  正确
    print("value 是 None")

if value == None:  #  不推荐
    print("value 是 None")

# 检查布尔值
is_active = True
if is_active:  #  简洁
    print("活跃")

if is_active == True:  #  冗余
    print("活跃")

# 比较对象身份（使用 is）
a = [1, 2, 3]
b = a
if a is b:  #  检查是否是同一个对象
    print("同一个对象")

# 比较对象值（使用 ==）
c = [1, 2, 3]
if a == c:  #  检查值是否相等
    print("值相等")

# 危险：可变默认参数
def append_to(element, target=[]):
    target.append(element)
    return target

# 安全：使用 None
def append_to_safe(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target
print(append_to(1))
print(append_to(2))
print(append_to_safe(1))
print(append_to_safe(2))

# 危险：共享可变对象
def create_matrix(rows, cols):
    return [[0] * cols] * rows  # 所有行共享同一个列表

# 安全：创建独立对象
def create_matrix_safe(rows, cols):
    return [[0] * cols for _ in range(rows)]

matrix = create_matrix(3, 3)
matrix[0][0] = 1
print(matrix)
matrix_safe = create_matrix_safe(3, 3)
matrix_safe[0][0] = 1
print(matrix_safe)

# 简单列表：使用浅拷贝
simple_list = [1, 2, 3, 4]
copy1 = simple_list.copy()
copy2 = simple_list[:]
copy3 = list(simple_list)

# 嵌套结构：使用深拷贝
import copy
nested_list = [1, [2, 3], [4, [5, 6]]]
deep_copy = copy.deepcopy(nested_list)

import sys

def analyze_object(obj, name):
    """分析对象的内存信息"""
    print(f"\n{name} 的分析:")
    print(f"  类型: {type(obj)}")
    print(f"  值: {obj}")
    print(f"  ID: {id(obj)}")
    print(f"  大小: {sys.getsizeof(obj)} bytes")
    print(f"  引用计数: {sys.getrefcount(obj)}")

# 使用示例
my_list = [1, 2, 3]
analyze_object(my_list, "my_list")

another_ref = my_list
analyze_object(my_list, "my_list (多了一个引用)")