当前位置：首页 > news >正文

@value 静态变量_Python彻底搞懂：变量、对象、赋值、引用、拷贝

news 来源：原创 2024/4/26 16:21:27

Python3学习笔记：Python中的赋值操作

python中的变量，赋值等详细解析

秒懂Python 赋值，浅拷贝，深拷贝

在Python里，一切皆对象，完全的面向对象。

1 Python为动态解释性语言

在赋值操作时，

类型是在运行过程中自动决定的，而不是通过代码声明，没有必要事先声明变量。

（静态编译类型语言C++或Java，在使用变量前，需声明变量的类型。）

2 变量和对象之间的关系为引用。

1 变量

1 第一次赋值时，即创建，之后再次赋值将会改变变量的值。
2 变量名本身是没有类型的，类型只存在对象中，变量只是引用了对象。
3 所有的变量，必须 在使用前赋值，使用未赋值的变量会产生错误。

2 对象

1 对象是有类型的。

2 对象是分配的一块内存空间，来表示它的值。

3 每一个对象都具有两个标准的头部信息：

类型标志符：标识对象的类型。

引用计数器：用来决定对象是不是进行回收。

Python对象三要素：Id，Type，Value

Id：唯一标识一个对象

Type：标识对象的类型

Value：对象的值

3 引用

1 在Python中，从变量到对象的连接，称为引用。
2 引用是一种关系，以内存中的指针的形式实现。
3 赋值操作时，自动建立变量和对象之间的关系，即引用。

赋值和引用

python中赋值语句，

总是建立对象的引用值，而不是复制对象。

因此，python变量更像是指针，而不是数据存储区域。

简单引用：

例1

a = 3

步骤：

创建一个对象来代表值3。

创建一个变量a，如果它还没有创建的话。

将变量a 与新的对象3 相连接。

如图：

例2

a = 1
a = 'python'
a = 1.2

这里的变量a 被多次赋值，

并不是修改的对象，而是修改的引用，

a指向1，然后修改引用指向 'python'，

最后指向1.2。

1 和 'python' 被放在内存空间内，

在没有其他变量引用时，引用计数为0，

这个对象的内存空间就会自动回收。

这里也并不是修改变量 a 的类型，

因为变量没有类型，只是它指向的对象具有类型，

即对象头部信息的类型标志符。

共享引用

例1:

a = 3
b = a

a 指向对象3，

b = a 赋值操作，

b 也指向3。

可以看出，a和b都引用了同一个对象。

例2：

a = 3
b = a
a = 'spam'

a 重新指向另一个对象。

== 和 is

== 指值相等。is 指地址相等，即指引用相等。

a == b

判断 a 对象的值是否和 b 对象的值相等。通过Value 值来判断。

a is b

判断 a 对象是否就是 b 对象。通过 Id 来判断。

对象的数据类型：列表list

赋值相同，引用不同。

例1

lst1 = [1, 2, 3]
lst2 = lst1
lst3 = [1, 2, 3]

print(lst1,id(lst1)) #查看列表、引用地址 Id()函数
print(lst2,id(lst2))
print(lst3,id(lst3))

lst2[0] = 10

print()

print(lst1,id(lst1)) #查看列表、引用地址 Id()函数
print(lst2,id(lst2))
print(lst3,id(lst3))

输出结果

[1, 2, 3] 4434387024

[1, 2, 3] 4478611696

[10, 2, 3] 4434387024

[1, 2, 3] 4478611696

例2

lst1 = [1, 2, 3]
lst2 = lst1
lst3 = [1, 2, 3]

print(lst1 == lst2)
print(lst1 is lst2)
print(lst1 == lst3)
print(lst1 is lst3)

输出结果

True

False

总结：

lst1 和 lst2 指向同一个对象。

lst1 和 lst3 不指向同一个对象(Id不同)，lst3 指向另一对象，

两个对象只是值(value)相等(==)。

对象的数据类型：整数int。

赋值相同，则引用相同。

a = 9
b = a
c = 9

print(a,id(a))
print(b,id(b))
print(c,id(c))

print()

print(a == b)
print(a is b)
print(a == c)
print(a is c)

输出结果

9 4393189392

True

a、b、c 指向 同一个对象。

因为小的整数和字符串被缓存并复用，

所以 is 指明 a 和 c ，引用一个相同的对象。

a = 1
a = 'python'

这里的 1 并没有被直接回收，虽然它的计数减一，但是在系统代码中却被大量引用。

查看引用计数如下：

import sys

print(sys.getrefcount(1))

输出结果：

717

变量是一个系统表的元素，拥有指向对象的连接的空间。

对象是分配的一块内存，有足够的空间去表示它们所代表的值。

引用是自动形成的从变量到对象的指针。

赋值、浅拷贝、深拷贝

python中的变量，赋值等详细解析

可以说 Python 没有赋值，只有引用。

Python 没有「变量」，我们平时所说的变量其实只是「标签」，是引用。

values = [0, 1, 2]
values = [3, 4, 5]
values[1] = values

values = [0, 1, 2]

Python 做的事情是首先创建一个列表对象 [0, 1, 2]，然后给它贴上名为 values 的标签。

values = [3, 4, 5]

创建另一个列表对象 [3, 4, 5]，然后把刚才那张名为 values 的标签从前面的 [0, 1, 2] 对象上撕下来，重新贴到 [3, 4, 5] 这个对象上。

至始至终，并没有一个叫做 values 的列表对象容器存在。

Python 也没有把任何对象的值复制进 values 去。

过程如图所示：

values[1] = values

把 values 这个标签所引用的列表对象的第二个元素指向 values 所引用的列表对象本身。

执行完毕后，values 标签还是指向原来那个对象，只不过那个对象的结构发生了变化，

从之前的列表 [0, 1, 2] 变成了 [0, ?, 2]，而这个 ? 则是指向那个对象本身的一个引用。

如图所示：

得到 [0, [0, 1, 2], 2] 这个对象，

你不能直接将 values[1] 指向 values 引用的对象本身，

而是需要吧 [0, 1, 2] 这个对象「复制」一遍，得到一个新对象，

再将 values[1] 指向这个复制后的对象。

Python 里面复制对象的操作因对象类型而异，复制列表 values 的操作是：

values[:] #生成对象的拷贝或者是复制序列，不再是引用和共享变量，但此法只能顶层复制

values[1] = values[:]

先 dereference 得到 values 所指向的对象 [0, 1, 2]，然后执行 [0, 1, 2][:] 复制操作得到一个新的对象，内容也是 [0, 1, 2]，

然后将 values 所指向的列表对象的第二个元素，指向这个复制二来的列表对象，最终 values 指向的对象是 [0, [0, 1, 2], 2]。

过程如图所示：

values[:] 复制操作是所谓的「浅复制」(shallow copy)，

当列表对象有嵌套的时候也会产生出乎意料的错误。

a = [0, [1, 2], 3]
b = a[:]
a[0] = 8
a[1][1] = 9

a 为 [8, [1, 9], 3]，

b 为 [0, [1, 9], 3]。

b 的第二个元素也被改变了。想想是为什么？

正确的复制嵌套元素的方法是进行「深复制」(deep copy)

import copy
 
a = [0, [1, 2], 3]
b = copy.deepcopy(a)
a[0] = 8
a[1][1] = 9

引用 VS 拷贝：

没有限制条件的分片表达式（L[:]）能够复制序列，但此法只能浅层复制。
字典 copy 方法，D.copy() 能够复制字典，但此法只能浅层复制。
有些内置函数，例如 list，能够生成拷贝 list(L)。
copy 标准库模块能够生成完整拷贝：deepcopy 本质上是递归 copy。
对于不可变对象和可变对象来说，

浅复制都是复制的引用。

只是因为复制不变对象和复制不变对象的引用是等效的

（因为对象不可变，当改变时，会新建对象重新赋值）。

看起来浅复制只复制不可变对象（整数，实数，字符串等），

对于可变对象，

浅复制其实是创建了一个对于该对象的引用，

也就是说只是给同一个对象贴上了另一个标签而已。

遗漏待补充：