【一】用代码实现堆和栈

【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': 'Dream', 'sex': 'male', 'age': 18}

print(id(dic))  # 1499123688064

# 修改字典中的值
dic['age'] = 19
print(dic)  # {'name': 'Dream', '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', 'Dream']
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 = "Dream"
print(id(name))  # 1751102989232

name = "Hope"
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】不可变类型的参数传递

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