Python变量的管理和存储

一、python-对象

  首先，我们应该了解python中关于对象的概念
  在python中，一切皆为对象。在程序中引用任何一个数据时，python都会为之创建一个对象。
  关于数据、对象、内存（地址）、变量之间的关系：
      python为数据创建对象，即数据是对象的内容。对象分为可变对象和不可变对象。
      python为对象分配存储空间，不同的对象的分配是不同的。
      在程序中Python变量引用了对象，变量中保存的是值所在的内存地址（而不是这个对象的值）。

python对象的三要素：类型、id 、值。

二、python的可变对象与不可变对象

python将在堆中分配的数据对象分为两类：可变对象 和 不可变对象。
可变是指对象的内容（即数据）可变，而不可变对象是指对象内容不可变。
在python中除了列表型对象与字典型对象，其他数据都是不可变对象。通常，把不可变对象看作python数据对象的常例，可变对象看作特例。

   （1）不可变对象类型：int、字符串（string）、float、数值型（number）、元组（tuple）。
   （2）可变对象类型：列表型（list）、字典型（dictionary）。

三、python-数据对象的存储

1、可变和不可变对象的存储

在python中对于可变对象和不可变对象的存储分配是不相同的。

  （1）不可变对象的内存分配原则
       Python对于不可变对象只要分配了存储空间，这个空间中的值就不可以改变。
       若想要改变，就要另外分配空间，称为另一个对象。
       
       此外，对于范围在 [-5,25] 的小数或同大小的字符串，会开辟一个对象池，按值进行存储。
       对于大整数，只有在文件模式下才会按值存储。


  （2）可变对象的内存分配原则
           python对于可变对象是按照对象分配内存，并且允许该内存中的值发生变化。
           或者说：只要分配了存储空间，不管如何变化，只要认定是原来对象的变化，就不在另分配空间。

2、python不可变对象和C中变量

 在C语言中：
      全局变量：存放在内存中的静态区中；
      局部变量：代码块存放在内存的代码区中，当被调用后存放在内存栈区。
      
python的变量存储则是类似于堆的方式。

关于python中的不可变对象：

     在C和C++中赋值表达式存在副作用，（也可以说是“变量的副作用”，即：例如i++会引起变量i的自身变化）。
     因为在C语言中“值的变化”是变量的基本性质。所以所谓的赋值表达式的副作用似乎是难以克服的。
     然而这个问题在python中解决了。
     python中引入不可变对象的意义在于可以保证程序中的一个对象固定不变，消除变量赋值时的副作用。

python和C中变量的存储方式不同；
在python和C中，变量与值的关系不同。

C语言中的变量名指向内存中的一处地址，对变量赋值，则是将数值放入地址空间中。
python中的变量是指向值的名称；变量用来引用对象。允许多个变量指向同一个对象。

python为每一个数据创建一个对象，当对象被创建时，python解释器就会为其创建两个标准的头部信息：一个是类型标识符；另一个是引用计数器，用于跟踪内部变量。
当python中来了一个对象时，系统先找了一块内存，将对象存放进去，有变量引用该对象时，变量就指向了这个对象，变量就知道了对象的特征。
（见 五）

四、python的赋值操作

参考资料：
（1） https://blog.csdn.net/hohaizx/article/details/78427406
（2） https://blog.csdn.net/u014665013/article/details/85787884
（3） https://blog.csdn.net/as480133937/article/details/87305247

python中的赋值语句：

 在程序中的赋值语句：如  a=3  这样的表达式，它的意义如下：
1）创建了值为3的对象，分配存储空间。
2）用一个名字为a的变量指向它。具体参考上述链接资料，作者写的真的很棒。
3）操作符“=”称为赋值操作符，（有人说这里的“=”表示引用）它的作用就是用一个名字（变量）指向一个对象。
或者说把一个名字绑定到一个对象上。
4）在python中赋值即创建，变量是通过赋值创建的。创建一个变量就是将一个名字与一个对象相关联。

变量可以通过赋值操作改变所指对象：
举例：

>Python 3.9.0 
>>> a = 3         #001                      
>>> id(a)
2486557239664
>>> type(a)
<class 'int'>
>>> a = 1.23      #002
>>> id(a)
2486595489456
>>> type(a)
<class 'float'>
>>> a = 'abcde'     #003
>>> id(a)
2486564121584
>>> type(a)
<class 'str'>

先定义了一个变量a指向对象3，再获取它的地址和类型。
再用对象1.23对变量赋值（类型变化）------可以说是变量a重新引用了一个float型对象。
之后将字符串abcde赋值给变量a。

通过赋值改变变量的指向，上述变化如图所示：

说明：
1） 在python中变量是在第一次赋值时创建的。
2） 在python中，类型的概念存在于对象而不是变量。变量永远不会有任何与其相关联的类型或者信息约束，与C语言不同的是，它可以指向任何类型的对象。这些类型、地址等信息都是属于对象的特征，变量引用对象后便获知了对象的各种信息。
3） 当变量出现在表达式中时，即被当前所引用的对象所替代，而不管这个对象是什么类型。
4） 变量与对象之间是引用关系，即变量是指向对象的引用。
5）允许多个变量指向同一个对象。同一个对象，每增加一个指向它的变量，就表明它多了一个引用。python会为每一个对象设置一个引用计数器。所以，一个字面量只能使用一次，而变量可以使用多次。（如“a = 3”中 3 是字面量，a是变量。3在一开始被内存存储后就不可更改，但可以被多次引用）

例题：
对于代码：a = 1,下面说法不正确的是（ ）
A 对象1的类型是整型
B 变量a的类型是整型
C 变量a指向的类型是整型
D 变量a指向的对象的值是整型

变量之间赋值将用被赋值变量指向赋值变量所指向的数据对象
举例：

>>> a = 3             #创建一个变量a，使其指向对象3
>>> id(a)             #获取a所指向的对象的地址
2886050998640
>>> b = a             #定义一个变量b指向对象变量a所指向的对象
>>> id(b)             #获取b所指向的对象的地址
2886050998640

允许用多个变量指向同一个对象，本例中的a、b指向的就是同一个对象。

几种不同的赋值方式：

>>> a,b,c = 3,5,7         #定义3个变量分别指向3个对象-------多变量同时赋值，指向不同的对象
>>> a,b,c
(3, 5, 7)
>>> id(a),id(b),id(c)
(2001428965744, 2001428965808, 2001428965872)
>>> a = a + b
>>> a,b
(8, 5)
>>> d = e = a             #多目标同时赋值，指向同一个对象
>>> d,e
(8, 8)

五、python对象的生命周期

 为了保证系统的高效运行，有效的回收不再使用的对象的资源（垃圾）是非常必要的。
 python使用引用计数器这一简单技术来跟踪和回收垃圾。

python为每一个数据创建一个对象，当对象被创建时，python解释器就会为其创建两个标准的头部信息：一个是类型标识符；另一个是引用计数器，用于跟踪内部变量。然后每增加一个引用，其引用计数器就加1；每执行一次del操作，其引用计数器就减1.当引用计数器为零后解释器就会择机将这个对象所占用的资源当做垃圾回收，即将这个对象销毁。所以，对象的生命期要由其引用是否存在决定。一个字面量对象有即用即逝的特点。
del只删除变量，不删除对象。删除完变量------引用次数被删完后，不再被引用的对象会有垃圾回收机制回收。

例：

>>> a = 3; b = 5
>>> a,b
(3, 5)
>>> del a,b
>>> a                         #会报错
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    a
NameError: name 'a' is not defined
>>> b                         #会报错
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    b
NameError: name 'b' is not defined