1. 解釋

1.1 不可變類型

? 在id不變的情況下，value可以改變

? 在熟知的類型中，整數(shù)，浮點數(shù)，復(fù)數(shù)，布爾值，字符串，元組和凍結(jié)集合屬于不可變類型

? 對不可類型的變量重新賦值，實際上是重新創(chuàng)建一個不可變類型的對象，并將原來的變量重新指向新創(chuàng)建的對象

1.2 可變類型

? value一旦改變，id也跟著改變

? 在熟知的類型中，列表，字典，集合屬于可變類型

2. 舉例

會通過大量的例子來幫助自己記憶。文章來源地址http://www.zghlxwxcb.cn/news/detail-647883.html

2.1 不可變類型舉例

2.1.1 數(shù)字舉例

# 數(shù)字舉例
a = 11
print(id(a))
a +=1
print(id(a))
# 140729053930600

# 140729053930664

2.1.2 字符串舉例

# 字符串舉例
str1 = 'abcdef'
print(f'{str1} id = {id(str1)}')
str1 = str1[4:]
str1 += 'hello world'
print(f'{str1} id = {id(str1)}')

2.1.3 元組舉例

# 元組
# 在 Python 中，元組是一種不可變序列，即元組一旦被創(chuàng)建就不能更改它的內(nèi)容。這表明在原有的元組上新增元素是不允許的
my_tuple = (1,2,3,4)
my_tuple1 = my_tuple
print(f'value = {my_tuple}, id = {id(my_tuple)}')
print(f'value1 = {my_tuple1}, id = {id(my_tuple1)}')

# 通過+ 將舊有元組與需要添加的值拼接形成新的元組
my_tuple = my_tuple + (11,22)
print(f'value = {my_tuple}, id = {id(my_tuple)}')

# 通過*解包舊有元組，然后和新的元素組成新的元組
my_tuple = (*my_tuple, 33)
print(f'value = {my_tuple}, id = {id(my_tuple)}')

# 值發(fā)生改變同時id也發(fā)生改變。

2.1.4 凍結(jié)集合舉例

# 凍結(jié)集合
# 凍結(jié)集合是不可變的，凍結(jié)集合在被定義后我們就不能再修改里面的元素了。凍結(jié)集合除了不能修改元素以外，其他的性質(zhì)和集合一樣。
my_f_set = frozenset(range(3))
print(f'value={my_f_set},id={id(my_f_set)}')
# 凍結(jié)集合的其它操作就不介紹了

2.2 可變類型舉例

2.2.1 列表舉例

# 列表
# 列表是一個可以包含任何類型數(shù)據(jù)的有序集合，比如數(shù)字、字符串甚至是其他列表。
# 列表是可變的，也就是說你可以改變一個列表的內(nèi)容。
# 創(chuàng)建一個列表很簡單，只需要將一些值用逗號隔開，然后用方括號括起來即可
# 常用的三種列表的創(chuàng)建方式
my_list = [1,2,3,4]
my_list1 = list(range(5))
my_list2 = [x for x in range(3)]
print(f'value = {my_list}, id = {id(my_list)}')
my_list.insert(0,11)
print(f'value = {my_list}, id = {id(my_list)}')
my_list.append(22)
print(f'value = {my_list}, id = {id(my_list)}')
my_list.remove(11)
print(f'value = {my_list}, id = {id(my_list)}')

# 可以看到我們向列表添加元素和刪除元素（改變列表的內(nèi)容），id均未發(fā)生變化
# value = [1, 2, 3, 4], id = 1181715063808
# value = [11, 1, 2, 3, 4], id = 1181715063808
# value = [11, 1, 2, 3, 4, 22], id = 1181715063808
# value = [1, 2, 3, 4, 22], id = 1181715063808

2.1.2 字典舉例

# 字典
# 字典是python當中的一種數(shù)據(jù)類型，字典內(nèi)部是一個一對一映射的數(shù)據(jù)關(guān)系。
import itertools
my_dict = {'1':1, '2':2}
my_dict1 = {x:x**2 for x in range(4)}
my_dict2 = dict(zip([1,2,3,4,5],[chr(x) for x in range(97,102)]))
my_dict3 = dict(itertools.product(range(3), range(3)))
print(f'value = {my_dict}')
print(f'value = {my_dict1}')
print(f'value = {my_dict2}')
print(f'value = {my_dict3}')
print(f'value = {my_dict},id = {id(my_dict)}')
my_dict['key'] = 'value'
print(f'value = {my_dict},id = {id(my_dict)}')

del my_dict['1']
print(f'value = {my_dict},id = {id(my_dict)}')

# 我們往字典里添加元素和從字典里刪除元素，字典的id均未發(fā)生改變
# value = {'1': 1, '2': 2}
# value = {0: 0, 1: 1, 2: 4, 3: 9}
# value = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}
# value = {0: 2, 1: 2, 2: 2}
# value = {'1': 1, '2': 2},id = 1497832590976
# value = {'1': 1, '2': 2, 'key': 'value'},id = 1497832590976
# value = {'2': 2, 'key': 'value'},id = 1497832590976

2.1.3 集合舉例

# 集合
# 集合是python當中一種無序的、不重復(fù)的數(shù)據(jù)序列

my_set = {1,2,3,4}
my_set1 = set(range(5))
print(f'value = {my_set}')
print(f'value = {my_set1}')

print(f'value = {my_set}, id = {id(my_set)}')
my_set.add(12)
print(f'value = {my_set}, id = {id(my_set)}')

my_set.remove(12)
print(f'value = {my_set}, id = {id(my_set)}')

# value = {1, 2, 3, 4}
# value = {0, 1, 2, 3, 4}
# value = {1, 2, 3, 4}, id = 2059410018752
# value = {1, 2, 3, 4, 12}, id = 2059410018752
# value = {1, 2, 3, 4}, id = 2059410018752

2.1.4 可變類型參數(shù)

# 不可變類型參數(shù)
# 函數(shù)內(nèi)部修改參數(shù)的值，只是修改另一個復(fù)制對象，不會影響變量本身
# 可變類型參數(shù)
# 函數(shù)將實參本體傳遞過去，修改后函數(shù)外部的變量也會受到影響

def my_func(list1:list,dict1:dict, set1:set):
    list1.pop()
    dict1.pop(1)
    set1.remove(22)

def my_func1(list1:list,dict1:dict, set1:set):
    list1 = list1[1:]
    dict1 = dict(zip(range(3),range(3)))
    set1 = set(range(3))    
my_list = list(range(4))
my_dict = {x:x**2 for x in range(1,4)}
my_set = set(range(20,24))

print(f'value = {my_list}, id = {id(my_list)}')
print(f'value = {my_dict}, id = {id(my_dict)}')
print(f'value = {my_set}, id = {id(my_set)}')

my_func(my_list, my_dict, my_set)
print(f'value1 = {my_list}, id = {id(my_list)}')
print(f'value1 = {my_dict}, id = {id(my_dict)}')
print(f'value1 = {my_set}, id = {id(my_set)}')

# 這樣操作，沒有影響到外面
# 嘗試這樣解釋，由于在函數(shù)內(nèi)使用了等號，相當遠新建了一個變量，而局部變量在函數(shù)結(jié)束時就已經(jīng)無了
my_func1(my_list, my_dict, my_set)
print(f'value2 = {my_list}, id = {id(my_list)}')
print(f'value2 = {my_dict}, id = {id(my_dict)}')
print(f'value2 = {my_set}, id = {id(my_set)}')

# value = [0, 1, 2, 3], id = 3112078428416
# value = {1: 1, 2: 4, 3: 9}, id = 3112077352960
# value = {20, 21, 22, 23}, id = 3112078346944
# value1 = [0, 1, 2], id = 3112078428416
# value1 = {2: 4, 3: 9}, id = 3112077352960
# value1 = {20, 21, 23}, id = 3112078346944
# value2 = [0, 1, 2], id = 3112078428416
# value2 = {2: 4, 3: 9}, id = 3112077352960
# value2 = {20, 21, 23}, id = 3112078346944

到了這里，關(guān)于python的可變類型和不可變類型的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！