【python基础之可变和不可变数据类型】--- python堆栈的相关应用

【一】用代码实现堆和栈

【1】堆

# 堆的操作是先进先出（FIFO）
list_queue = []
for i in range(0, 5):
    print(f'{i} 已入堆(队列)')
    list_queue.append(i)
print('------入堆完毕--------')
while list_queue:
    print(f'{list_queue.pop(0)} 已出堆(队列)')
print('------出堆完毕--------')

0 已入堆(队列)
1 已入堆(队列)
2 已入堆(队列)
3 已入堆(队列)
4 已入堆(队列)
------入堆完毕--------
0 已出堆(队列)
1 已出堆(队列)
2 已出堆(队列)
3 已出堆(队列)
4 已出堆(队列)
------出堆完毕--------

【2】栈

# 栈的操作是先进后出（LIFO）
list_stack = []
for i in range(0, 5):
    print(f'{i} 已入栈')
    list_stack.append(i)
print('------入栈完毕--------')
while list_stack:
    print(f'{list_stack.pop()} 已出栈')
print('------出栈完毕--------')

0 已入栈
1 已入栈
2 已入栈
3 已入栈
4 已入栈
------入栈完毕--------
4 已出栈
3 已出栈
2 已出栈
1 已出栈
0 已出栈
------出栈完毕--------

【二】可变数据类型

• 对于可变类型（如列表、字典等），在函数中修改参数会影响原始对象。

【1】字典

dic = {'name': 'jack', 'sex': 'male', 'age': 18}

print(id(dic))  # 1499123688064

# 修改字典中的值
dic['age'] = 19
print(dic)  # {'name': 'jack', 'sex': 'male', 'age': 19}

print(id(dic))  # 1499123688064

# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

【2】元祖

t1 = ("tom", "jack", [1, 2])
t1[0] = 'TOM'  # 报错：TypeError
t1.append('lili')  # 报错：TypeError

# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
t1 = ("tom", "jack", [1, 2])
print(id(t1[0]), id(t1[1]), id(t1[2]))
# 2387573744432 2387573821232 2387573821824

# 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
t1[2][0] = 111
print(t1)  # ('tom', 'jack', [111, 2])

print(id(t1[0]), id(t1[1]), id(t1[2]))  # 查看id仍然不变
# 2387573744432 2387573821232 2387573821824

【3】列表

list1 = ['tom', 'jack', 'polo']
print(id(list1))  # 2640601108864

list1[2] = 'kevin'
print(id(list1))  # 2640601108864

list1.append('lili')
print(id(list1))  # 2640601108864

# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

【4】布尔类型

is_right = True
print(id(is_right))  # 140709061454696

is_right = True
print(id(is_right))  # 140709061454696

# 内存地址不改变，说明布尔类型是可变数据类型

【5】集合类型

my_set = {1, 2, 3}
print(id(my_set))  # 1267008236768

# 添加元素
my_set.add(4)
print(id(my_set))  # 1267008236768

# 删除元素
my_set.remove(2)
print(id(my_set))  # 1267008236768

# 内存地址不改变，说明集合类型是可变数据类型

【三】不可变数据类型

• 对于不可变类型（如数值、字符串等），在函数中修改参数不会影响原始对象。

【1】字符串

name = "jack"
print(id(name))  # 1751102989232

name = "polo"
print(id(name))  # 1751103065904

# 内存地址改变了，说明字符串是不可变数据类型

【2】数字类型

age = 18
print(id(age))  # 3179829658384

age = 20
print(id(age))  # 3179829658448

# 内存地址改变了，说明数字类型是不可变数据类型

【四】Python是值传递还是引用传递

【1】Python的传递规则

• 严格意义上来说，Python既不是值传递，也不是引用传递，python是自己的传递方式
• 规则是：
  • 如果传递的是不可变类型，在函数中修改，就不会影响原来的变量
  • 如果传递的是可变数据类型，在函数中修改，不会影响原来的变量，修改，而不是重新赋值

【2】什么是值，什么是引用

• 值就是一个变量=具体的值(一块内存空间放着这个变量的值)
• 引用是一个变量=内存地址(内存地址指向了值)
• 所有python才有了可变和不可变类型

【3】什么是值传递 什么是引用传递

• 如果是值传递，函数中修改了传递的值，不会影响原来的
• 如果是引用传递，函数中修改了传递的引用，就会影响原来的

【4】可变类型的参数传递

• 对于可变类型（如列表、字典等），在函数中修改参数会影响原始对象。

【5】不可变类型的参数传递

• 对于不可变类型（如数值、字符串等），在函数中修改参数不会影响原始对象。

扩展：这里补充一下通过deepseek解释的堆栈在python中的解释/介绍

在 Python 中，堆和栈是内存管理的两个重要概念，尽管 Python 本身不直接暴露这些细节，但理解它们有助于更好地掌握程序的内存使用和性能优化。

1. 栈（Stack）

栈是一种后进先出（LIFO）的数据结构，用于存储函数调用的上下文信息。每当函数被调用时，Python 会在栈上创建一个新的栈帧（stack frame），包含以下内容：

• 局部变量
• 函数参数
• 返回地址（函数执行完毕后应返回的位置）

栈的特点：

• 内存分配和释放速度快。
• 大小有限，通常较小（默认情况下几 MB）。
• 栈溢出（stack overflow）发生在递归过深或局部变量过多时。

示例

def foo():
    x = 10  # 局部变量存储在栈中
    print(x)

foo()

在调用 foo() 时，栈上会创建一个栈帧，存储 x 的值。函数执行完毕后，栈帧被自动释放。

---

2. 堆（Heap）

堆是用于动态内存分配的区域，存储程序运行时创建的对象（如列表、字典、类实例等）。堆的特点：

• 内存分配和释放由 Python 的内存管理器（如垃圾回收机制）管理。
• 大小通常比栈大得多，受系统内存限制。
• 堆中的对象可以被多个变量引用，生命周期由引用计数或垃圾回收机制决定。

示例

a = [1, 2, 3]  # 列表对象存储在堆中
b = a          # b 和 a 引用同一个堆对象

a 和 b 是栈上的变量，但它们指向堆中的同一个列表对象。

---

3. 栈与堆的区别

特性	栈（Stack）	堆（Heap）
存储内容	函数调用、局部变量、参数	动态分配的对象（如列表、字典等）
管理方式	自动管理（函数调用时分配，返回时释放）	手动或由垃圾回收机制管理
大小	较小（几 MB）	较大（受系统内存限制）
访问速度	快	较慢
生命周期	函数调用期间	由引用计数或垃圾回收机制决定

---

4. Python 中的内存管理

Python 通过以下机制管理堆和栈：

• 栈：由 Python 解释器自动管理，开发者无需干预。
• 堆：通过引用计数和垃圾回收机制管理。当对象的引用计数为 0 时，内存会被回收。

示例：引用计数

import sys

a = [1, 2, 3]  # 引用计数为 1
b = a          # 引用计数为 2
print(sys.getrefcount(a))  # 输出引用计数（可能比实际多 1）
del b          # 引用计数减 1
del a          # 引用计数为 0，对象被回收

---

总结

• 栈用于存储函数调用的上下文，速度快但大小有限。
• 堆用于存储动态分配的对象，大小灵活但管理复杂。
• Python 通过引用计数和垃圾回收机制管理堆内存，开发者无需手动释放内存。

理解堆和栈有助于优化程序性能和调试内存问题。