Python引用

引用

引用就是变量指向数据存储空间的现象

内存地址是数据在物理内存中存储的位置

引用地址是对象在内存地址中的描述性地址，该地址与内存地址有区别

 

引用特征

相同数据使用同一个空间存储，节约内存占用 ；不同的变量使用相同的数据则指向相同的存储空间

变量赋值修改的是变量的引用地址

列表、集合、字典、对象的引用格式十分相似，都是指向一个存储区域，存储区域内数据发生变化，原始对象的引用不变

 

获取内存存储地址

语法格式

    id(数据名) or id(变量名)

a = 1
b = 1
print(id(a))
print(id(b))
print(id(c))

地址存储特殊性

    使用固定内存地址存储数据如下：

        -5 到 256的整数

        True 和 False

        由字母、数字、下划线组成的字符串    

 

    使用临时内存地址存储数据如下

        小于 -5 到 大于256的整数

        所有小数

        包含字母、数字、下划线之外的字符组成的字符串

 

?

引用-数字

    -5 ~ 256 单独空间保存

    如果是计算出的结果，会使用新的存储地址

    每个数字在内存中都要占用一个存储空间，而变量存储的是这个空间的地址。

 

引用-bool

    bool  不同 ，不可变类型

引用-字符串

    字母数字下划线范围内相同，其他不同

列表

    空列表 没有变量指向 引用地址始终一样

    每出现一个被引用的列表 地址都不一样

    多个变量指向同一个引用，操作的是同一个地址中的数据

列表存储空间

    无变量引用

    列表保存在临时引用地址中，该引用地址可以反复使用

    有变量引用

    列表保存在独立引用地址中，该引用地址专用，每个列表对象具有独立的引用地址

列表存储空间的变更

    1.列表变量指向引用地址，该引用地址中保存有存储列表信息的内存地址

    2.当列表中存储数据的空间不足时，会申请新的内存地址，并更新引用地址中对应的内存地址

    3.重写申请的内存地址将复制原始内存地址中的数据

列表中的数据存储

    1.列表中存储的数据都是数据对应的内存地址，没有真实数据

    2.列表中的数据是通过引用地址的形式查找真实数据

a = [1, 2, 3]
b = [1, 2, 3]
c = [1, 2, 3]
a.append(4)
b = a
b.append(5)
c = b
c.append(6)
print(a)
-------------------------------------
[1, 2, 3, 4, 5, 6]

a = [1, 2, 3]
b = [1, 2, 3]
c = [1, 2, 3]
a.append(4)
a = b
b.append(5)
b = c
c.append(6)
print(a)
---------------------------------
[1, 2, 3, 5]

列表内存底层工作原理

原始空间废弃

加入数据1列表

修改len

操作完毕

创建数据“aa”引用

重复上述过程

添加?

不通过开启内存空间申请与复制

a.__sizwof__()

40 - 72 - 104 - 168

5*8    4*8  4*8   8*8

列表的空间是可变的

8bit 一个字节

 

列表存储空间不足时，会申请新的存储空间，同时修改原始内存地址的引用。

内存地址对开发者不可见

对外呈现引用地址

 

引用 元组

空元组地址相同

带有数字的元组地址不同

带有引用的元组地址不同

 

元组存储空间

        空元组

            空元组指向统一的独立引用地址，所有空元组共用一个引用地址

        非空元组

            非空元组保存在独立引用地址中，每个元组对象具有独立引用地址

由于元组不支持修改，不存在重新申请空间的问题，元组创建的同时存储的数据已经固定，内存结构也固定。

 

    元组中的数据存储（同列表）

        1.元组中存储的数据都是数据对应的内存地址，没有真实数据

        2.元组中的数据是通过应用地址的形式查找真实数据

        3.元组不支持修改 但元组中的数据如果是引用类型的，对应的数据可以在自身的内存地址中进行数据变更，对元组不影响。

 

引用 集合

    空集合 and 没有指向的集合 引用地址相同

    带有引用后，各用各的地址

    数据查询    数据存储

         数据存储区域

                1 ：3

真是数据 规则 排序数据（有规律）

 

集合存储空间

无变量引用

集合保存在临时引用地址中，该引用地址可以反复使用

有变量引用

集合保存在独立引用地址中，该引用地址专用，每个集合对象具有独立的引用地址

 

集合存储空间变更

1.集合变量指向引用地址，该引用地址中保存有存储集合信息的内存地址。

2.当集合中存储数据的空间不足时，会申请新的内存地址，并更新引用地址中对应的内存地址。

3.重新申请的内存地址将复制原始内存地址中的数据。

 

集合中的数据存储

1.集合中存储的数据都是数据对应的内存地址，没有真实数据

2.集合中的数据是通过引用地址的形式查找真实数据

a = [1, 2, 3]
b = [1, 2, 3]
c = [1, 2, 3]
d = [a, b, c]
a.append(4)
a = b
b.append(5)
b = d
c.append(6)
c = d
d.append(7)
print(d)
-----------------------------------
[[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], 7]

 

 

字典

a = {} 默认type 是字典 dict

引用 字典

空字典地址相同

字典底层存储原理

a = {"aa" : 1, "bb": 2}

根据size动态申请空间

分配内存建立引用

修改keys区域

根据a取存储地址转化key为排序地址

字典存储空间

无变量引用

字典保存在临时引用地址中，该引用地址可以反复使用

有变量引用

字典保存在独立引用地址中，该引用地址专用，每个字典对象具有独立的引用地址

字典存储空间变更

1.字典变量指向引用地址，该引用地址中保存有存储字典信息的内存地址。

2.当字典中存储数据的空间不足时，会申请新的内存地址，并更新引用地址中对应的内存地址。

3.重新申请的内存地址将复制原始内存地址中的数据。

字典中的数据存储

1.字典中存储的数据都是数据对应的内存地址，没有真实数据

2.字典中的数据是通过引用地址的形式查找真实数据

 

引用 对象：

    对象没有引用的话是地址会被回收♻使用

    无变量引用

        对象保存在临时引用场景中，该引用地址可以反复使用

    有变量引用

        对象保存在独立引用场景中，该引用地址专用，每个列表对象具有独立的引用地址

 

    对象中的变量数据

        1.对象中的变量存储的都是对应数据的引用地址，没有真实数据

        2.对象中的变量是通过引用地址的形式查找真实数据

        3.对象中的变量存储形式是一个字典的形式，对变量的操作参照字典的操作方式，变量名为字典的key，变量的值为字典的value

引用 对象底层存储原理⚪

user1.__dict__

user1.__class__

 

可变类型与不可变类型（重要）

数据存储空间中的数据可以发生变化的数据称为可变类型数据

数据存储空间中的数据不能发生变化的数据称为不可变类型数据

 

可变类型

    列表

    集合

    字典

    对象

 

不可变?‍

    数值

    字符串

    布尔

    元组

 

⚠注意：函数实参为不可变与可变类型的区别

 

函数调用时的实参

 

    函数的实参使用可变类型数据时，在函数内部形参进行数据操作，实参将发生改变

    

    函数的实参使用不可变类型数据时，在函数内部对形参进行数据操作，实参将不会发生改变

 

函数定义时的形参

        

    函数的形参如果接收到的实参是不可变类型，函数内部的操作，不会对外部的实参产生影响

    

    函数的形参如果接收到的实参是可变类型，函数内部的操作，会对外部的实参产生影响

 

函数定义时的形参

        1.函数形参使用默认参数

        2.函数调用时未对默认参数传值

        3.函数的形参使用可变类型数据

    上述三个条件同时满足时，多次调用对应函数时，操作的形参是同一个对象

 

使用方法修改会对外面有影响，如果更换指向不会有影响

 

def test(a=[]):
    print(a)
    a.append("Py")
    print(a)
    print("--------------")

test()
test()
================================
[]
['Py']
--------------
['Py']
['Py', 'Py']
--------------

 

对默认参数的值尽量不要使用可变类型的数据(●'◡'●)

 

 

 

 

exit(?)