1.名词解释

以下所有的内容都是基于内存地址来说的。

不可变数据类型： 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。

可变数据类型 ：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型。

总结：不可变数据类型更改后地址发生改变，可变数据类型更改地址不发生改变

2.数据类型分类

在python中数据类型有：整型，字符串，元组，集合，列表，字典。接下来我们用例子来一一查看他们分别属于不可变数据类型还是可变数据类型。

2.1 整型

a = 1

print(id(a),type(a))

a = 2

print(id(a),type(a))

1912499232

1912499264

我们可以发现，当数据发生改变后，变量的内存地址发生了改变，那么整型就是不可变数据类型。

2.2 字符串

b = 'djx'

print(id(b),type(b))

b = 'djx1996'

print(id(b),type(b))

535056476344

535056476624

我们可以发现，当数据发生改变后，变量的内存地址发生了改变，那么字符串就是不可变数据类型。

2.3 元组

元组被称为只读列表，即数据可以被查询，但不能被修改,但是我们可以在元组的元素中存放一个列表，通过更改列表的值来查看元组是属于可变还是不可变。

c1 = ['1','2']

c = (1,2,c1)

print(c,id(c),type(c))

c1[1] = 'djx'

print(c,id(c),type(c))

result:

(1, 2, ['1', '2']) 386030735432

(1, 2, ['1', 'djx']) 386030735432

我们可以发现，虽然元组数据发生改变，但是内存地址没有发生了改变，但是我们不可以以此来判定元组就是可变数据类型。我们回头仔细想想元组的定义就是不可变的。我们修改了元组中列表的值，但是因为列表是可变数据类型，所以虽然在列表中更改了值，但是列表的地址没有改变，列表在元组中的地址的值没有改变，所以也就意味着元组没有发生变化。我们就可以认为元组是不可变数据类型，因为元组是不可变的。

2.4 集合

集合我们常用来进行去重和关系运算，集合是无序的。

s = {1,'d','34','1',1}

print(s,type(s),id(s))

s.add('djx')

print(s,type(s),id(s))

result:

{'d', 1, '34', '1'} 870405285032

{1, '34', 'djx', '1', 'd'} 870405285032

2.5 列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，它是以[]括起来，每个元素以逗号隔开，而且它里面可以存放各种数据类型。

list = [1,'q','qwer',True]

print(list,type(list),id(list))

list.append('djx')

print(list,type(list),id(list))

result:

[1, 'q', 'qwer', True] 808140621128

[1, 'q', 'qwer', True, 'djx'] 808140621128

虽然列表数据发生改变，但是内存地址没有发生了改变，那么列表就是可变数据类型。

2.6 字典

字典是python中唯一的映射类型，采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的。但是在3.6版本后，字典开始是有序的，这是新的版本特征。

字典的key值可以是整型，字符串，元组，但是不可以是列表，集合，字典。

tuple = (1)

dic = {1:2}

d = { tuple:1,'key2':'djx','key3':'li'}

print(d,type(d),id(d))

d['key4'] = 'haha'

print(d,type(d),id(d))

result:

{1: 1, 'key2': 'djx', 'key3': 'li'} 256310956320

{1: 1, 'key2': 'djx', 'key3': 'li', 'key4': 'haha'} 256310956320

虽然字典数据发生改变，但是内存地址没有发生了改变，那么字典就是可变数据类型。

图片.png

python中列表长度可变，可变类型指的是内存id不变，type也不变的前提下，value是否是可变的。列表和字典都是可变类型，对于可变对象，比如list，对list进行操作，list内部的内容是会变化的。

python中列表长度可变吗？下面给大家介绍一下python中可变和不可变的类型：

可变、不可变

可变/不可变类型,指的是：内存id不变，type也不变的前提下，value是否是可变的。

int()和str()都是不可变类型

列表、字典是可变类型

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']>>> a.sort()>>> a

['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'>>> a.replace('a', 'A')'Abc'>>> a'abc'

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？

我们先把代码改成下面这样：

>>> a = 'abc'>>> b = a.replace('a', 'A')>>> b'Abc'>>> a'abc'

要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

阅读：次

一、python中的变量与对象

首先在理解python的可变对象和不可变对象时，要理解python的赋值操作。在python中，一切事物皆是对象，变量是对象在内存中的存储和地址的抽象

对变量的理解

在Python中，类型是属于对象的，而不是变量, 变量和对象是分离的，对象是内存中储存数据的实体，变量则是指向对象的指针。

“=”(赋值号)是将右侧对象的内存地址赋值给左侧的变量。

当我们写下面语句时

a = "abc"

Python解释器其实顺序干了两件事情：

1 在内存中创建一个字符串“abc”;

2 在内存中创建一个名为“a”的变量，并将“a”指向字符串“abc”(将“abc”的地址保存到“a”中)。

这样我们就能通过操作“a”而改变内存中的“abc”。

二、什么是可变对象/不可变对象

不可变对象 该对象所指向的内存中的值不能被改变当改变一个变量的时候，由于改变量所指向的内存中的值不能被改变，因此会将原来的值复制一份后再改变，具体做法是重新开辟一块空间存放新的值，并将该变量指向这个空间。原来空间中的值如果没有变量指向它，会被当做垃圾回收。数值类型(int float), 字符串str, 元组tuple是不可变的数据类型

可变对象 该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的出地址，通俗点说就是原地改变。列表list, 字典dist, 集合set是可变的数据类型

举例说明

不可变对象的例子

>>> a = 'hello'

>>> id(a)

1921615688624

>>> a = 'world'

>>> id(a)

1921615689744

# 重新赋值之后，变量a的内存地址已经变了

# 'hello'是str类型，不可变，所以赋值操作重新创建了str对象 'world'对象，

# 然后将变量a指向了它

可变对象的例子

>>> lst = [1, 2, 3]

>>> id(lst)

1921615726216

>>> lst.append(4)

>>> id(lst)

1921615726216

# list重新赋值之后，变量lst的内存地址并未改变

# [1, 2, 3]是可变的，append操作只是改变了其value，变量lst指向没有变

三、python引用

python一般内部赋值变量的时候，都是传递一个引用变量，和C语言的传地址的概念差不多， 比如：

>>> a = [1,2,3] # 表示变量a保存了这个列表的地址

# python里可以用id()来查询下a在内存的地址是:1921615756616

>>> id(a)

1921615756616

>>> b = a

# 那b的内容是什么,地址又是什么呢?

# 用print 输出下b的内容也是[1,2,3]

# 然后我们查看下b的地址看下能否验证我们的结论

>>> b

[1, 2, 3]

# 果然b的地址也是:1921615756616

>>> id(b)

1921615756616

这样会带来一个问题，因为变量a,和变量b都是保存了同一个列表的地址。如果我改变a指向的列表的值的话，那b指向的列表的值也同时改变

>>> a[1] = 6

>>> a

[1, 6, 3]

>>> b

[1, 6, 3]

如果我们只想修改a列表里面的内容。而不想修改b的内容，那就要用到python的拷贝了

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

>>> b = a[:]

>>> a[1] = 6

>>> a

[1, 6, 3]

>>> b

[1, 2, 3]

四、函数值传递

首先来看一个例子

def func_int(a):

a += 4

def func_list(lst):

lst[0] = 4

t = 0

func_int(t)

print t

# output: 0

t_list = [1, 2, 3]

func_list(t_list)

print t_list

# output: [4, 2, 3]

主要是因为可变对象和不可变对象的原因：对于可变对象，对象的操作不会重建对象，而对于不可变对象，每一次操作就重建新的对象。

在函数参数传递的时候，Python其实就是把参数里传入的变量对应的对象的引用依次赋值给对应的函数内部变量。参照上面的例子来说明更容易理解，func_int中的局部变量"a"其实是全部变量"t"所指向对象的另一个引用，由于整数对象是不可变的，所以当func_int对变量"a"进行修改的时候，实际上是将局部变量"a"指向到了整数对象"1"。所以很明显，func_list修改的是一个可变的对象，局部变量"a"和全局变量"t_list"指向的还是同一个对象。

五、深拷贝 & 浅拷贝

接下来的问题是：如果我们一定要复制一个可变对象的副本怎么办？简单的赋值已经证明是不可行的，所以Python提供了copy模块，专门用于复制可变对象。

copy中有两个方法：copy()和deepcopy()，前一个是浅拷贝，后一个是深拷贝。

浅拷贝仅仅复制了第一个传给它的对象，下面的不管了；而深拷贝则将所有能复制的对象都复制了。

>>> import copy

>>> a = [[1,2,3], [4,5,6]]

>>> b = a

>>> c = copy.copy(a)

>>> d = copy.deepcopy(a)

>>>

>>> a.append(15)

>>> a[1][2] = 10

>>> a

[[1, 2, 3], [4, 5, 10], 15]

>>> b

[[1, 2, 3], [4, 5, 10], 15]

>>> c

[[1, 2, 3], [4, 5, 10]]

>>> d

[[1, 2, 3], [4, 5, 6]]

六、作用域

在Python程序中创建、改变或查找变量名时，都是在一个保存变量名的地方进行中，那个地方我们称之为命名空间。作用域这个术语也称之为命名空间。

变量名引用分为三个作用域进行查找：首先是本地，然后是函数内(如果有的话)，之后是全局，最后是内置。在默认情况下，变量名赋值会创建或者改变本地变量。全局声明将会给映射到模块文件内部的作用域的变量名赋值。Python 的变量名解析机制也称为 LEGB 法则，具体如下：

当在函数中使用未确定的变量名时，Python搜索4个作用域：

本地作用域(L)

上一层嵌套结构中 def 或 lambda 的本地作用域(E)

全局作用域(G)

内置作用域(B)。

按这个查找原则，在第一处找到的地方停止。如果没有找到，Python 会报错的。