在python中，万物皆对象，常见的整数、浮点数、字符串、元祖、列表等类型，以及各种class、class instance等等都是对象。这些对象在python解释器内部的地址是怎样的呢？这里我们只简单看下python对象内存地址的相关基础知识，以及编码过程中一些注意事项，关于python解释器的内存管理机制，涉及到解释器内核的内存池原理，这里不做深入探讨，有兴趣的朋友可以去阅读解释器源代码。
 
0x01 不可变对象
 
    不可变对象是指对象的内存值不能被改变。Python中变量以引用的方式指向对象，如果变量引用了不可变对象，当改变该变量时，由于其所指的对象的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址，即变量引用了新的对象。
 
    数值类型（整数和浮点）、字符串str、元组tuple都是不可变类型。比如a=1，b=[1]，c={'a':1}，id(a)、id(b[0])、id(1)、id(c['a'])将输出一样的值，因为1是不可变对象，其在内存中是不可改变的。
 
0x02 可变对象
 
    可变对象是指对象的内存值可以被改变，变量（准确的说是引用）改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的内存地址，通俗点说就是原地改变。列表list、字典dict、集合set是可变类型。
 
0x03 对象的内存地址
 
    可以使用内置函数id()查看python对象的内存地址。下面是一些注意事项：
 
    (1) python中所有数字、字符串、list等值，创建时会分配内存空间，变量通过引用的方式使用它们。比如a=1和b=1，id(a)和id(b)的输出一样，表示a和b都指向相同的内存地址，即引用了同一个不可变对象；但是a=[1]和b=[1]，id(a)和id(b)将输出不一样的值，a和b指向的是不同的内存地址，即引用了不同的可变对象，说明各可变对象是相互独立的，在内存中有独立的内存地址；
 
    (2) 可用 is 判断两个对象的id（即内存地址）是否一样，用 == 判断两个对象的值是否一样。None值也有内存地址；
 
    (3) list、set对象有各自的独立内存空间，他们的各元素以引用的方式指向可变、不可变对象；
 
    (4) 函数形参的默认值，在内存中会开辟独立的内存空间。比如测试代码中test函数的param参数，其默认值是空list，如果调用时未传参，则param指向内存中预先分配好的地址，该地址存储的是list类型的值；当调用时传参为a，则param引用了a指向的内存空间；
 
    (5) python使用引用计数和垃圾回收来释放内存对象，每个内存对象都维护了一个引用计数，包括各种数字、字符串、list、set等类型值，以及类实例对象等等，当这些对象的引用计数为 0 时，会被解释器回收内存。每次对对象进行引用操作，都会导致其引用计数加1， 如下面测试代码中的整数1，列表a、b、c、d、n都引用了整数1，以及test函数中的append操作，都会导致数字1的引用计数加1；
 
    (6) copy和deepcopy方法都创建了新的内存对象，如测试代码中的b和c都是新的变量，其各个元素可能是指向同一个内存空间。赋值操作是指向同一个内存块，同时增加引用计数。copy是浅拷贝，deepcopy是深拷贝，特别对于可变对象，copy是以引用的方式指向同一个可变对象，而deepcopy会开辟新的内存地址，也就是创建了新的可变对象。
 
0x04 测试代码
 
# -*- coding: utf8 -*-
import copy
import sys

a = [1, 2, [3, 4]]
b = copy.copy(a)
c = copy.deepcopy(a)
d = a

print 'address of a:', id(a)
print 'address of b:', id(b)
print 'address of c:', id(c)
print 'address of d:', id(d)
print 'address of 1:', id(1)
print 'address of element 0 in a:', id(a[0])
print 'address of element 0 in b:', id(b[0])
print 'address of element 0 in c:', id(c[0])
print 'a=', a
print 'b=', b
print 'c=', c
print 'd=', d

a[0] = 99
print 'a=', a
print 'b=', b
print 'c=', c
print 'd=', d

print 'address of element 0 in a:', id(a[0])
print 'address of element 0 in b:', id(b[0])
print 'address of element 0 in c:', id(c[0])

print 'address of element 2 in a:', id(a[2])
print 'address of element 2 in b:', id(b[2])
print 'address of element 2 in c:', id(c[2])

a[2].append(5)
print 'a=', a
print 'b=', b
print 'c=', c
print 'd=', d

def test(param=[]):
    print 'address of param:', id(param)
    param.append(1)
    print 'reference count of 1:', sys.getrefcount(1)
    return param

print test(a)
print test()
print test()
print 'a=', a
print 'b=', b
print 'c=', c
print 'd=', d

print 'reference count of 1:', sys.getrefcount(1)
n = 1
print 'reference count of 1:', sys.getrefcount(1)
del n
print 'reference count of 1:', sys.getrefcount(1)

 
0x06 运行结果
 
 
 
address of a: 54681224
 address of b: 54716296
 address of c: 54692104
 address of d: 54681224
 address of 1: 48258856
 address of element 0 in a: 48258856
 address of element 0 in b: 48258856
 address of element 0 in c: 48258856
 a= [1, 2, [3, 4]]
 b= [1, 2, [3, 4]]
 c= [1, 2, [3, 4]]
 d= [1, 2, [3, 4]]
 a= [99, 2, [3, 4]]
 b= [1, 2, [3, 4]]
 c= [1, 2, [3, 4]]
 d= [99, 2, [3, 4]]
 address of element 0 in a: 48260488
 address of element 0 in b: 48258856
 address of element 0 in c: 48258856
 address of element 2 in a: 54692232
 address of element 2 in b: 54692232
 address of element 2 in c: 54716360
 a= [99, 2, [3, 4, 5]]
 b= [1, 2, [3, 4, 5]]
 c= [1, 2, [3, 4]]
 d= [99, 2, [3, 4, 5]]
 address of param: 54681224
 reference count of 1: 161
 [99, 2, [3, 4, 5], 1]
 address of param: 54716424
 reference count of 1: 162
 [1]
 address of param: 54716424
 reference count of 1: 163
 [1, 1]
 a= [99, 2, [3, 4, 5], 1]
 b= [1, 2, [3, 4, 5]]
 c= [1, 2, [3, 4]]
 d= [99, 2, [3, 4, 5], 1]
 reference count of 1: 163
 reference count of 1: 164
 reference count of 1: 163
 
 
 
 

 在解释第一个问题之前，先说明一下计算机内存管理的中的四个名词：虚拟内存，虚拟内存地址，物理内存，物理内存地址。


 



 先说说为什么会有虚拟内存和物理内存的区别。正在运行的一个进程，他所需的内存是有可能大于内存条容量之和的，比如你的内存条是256M，你的程序却要创建一个2G的数据区，那么不是所有数据都能一起加载到内存（物理内存）中，势必有一部分数据要放到其他介质中（比如硬盘），待进程需要访问那部分数据时，在通过调度进入物理内存。所以，虚拟内存是进程运行时所有内存空间的总和，并且可能有一部分不在物理内存中，而物理内存就是我们平时所了解的内存条。有的地方呢，也叫这个虚拟内存为内存交换区。


 



 那么，什么是虚拟内存地址和物理内存地址呢。假设你的计算机是32位，那么它的地址总线是32位的，也就是它可以寻址0~0xFFFFFFFF（4G）的地址空间，但如果你的计算机只有256M的物理内存0x~0x0FFFFFFF（256M），同时你的进程产生了一个不在这256M地址空间中的地址，那么计算机该如何处理呢？回答这个问题前，先说明计算机的内存分页机制。


 



 计算机会对虚拟内存地址空间（32位为4G）分页产生页（page），对物理内存地址空间（假设256M）分页产生页帧（page frame），这个页和页帧的大小是一样大的，所以呢，在这里，虚拟内存页的个数势必要大于物理内存页帧的个数。在计算机上有一个页表（page table），就是映射虚拟内存页到物理内存页的，更确切的说是页号到页帧号的映射，而且是一对一的映射。但是问题来了，虚拟内存页的个数 > 物理内存页帧的个数，岂不是有些虚拟内存页的地址永远没有对应的物理内存地址空间？不是的，操作系统是这样处理的。操作系统有个页面失效（page fault）功能。操作系统找到一个最少使用的页帧，让他失效，并把它写入磁盘，随后把需要访问的页放到页帧中，并修改页表中的映射，这样就保证所有的页都有被调度的可能了。这就是处理虚拟内存地址到物理内存的步骤。


 



 现在来回答什么是虚拟内存地址和物理内存地址。虚拟内存地址由页号（与页表中的页号关联）和偏移量组成。页号就不必解释了，上面已经说了，页号对应的映射到一个页帧。那么，说说偏移量。偏移量就是我上面说的页（或者页帧）的大小，即这个页（或者页帧）到底能存多少数据。举个例子，有一个虚拟地址它的页号是4，偏移量是20，那么他的寻址过程是这样的：首先到页表中找到页号4对应的页帧号（比如为8），如果页不在内存中，则用失效机制调入页，否则把页帧号和偏移量传给MMC（CPU的内存管理单元）组成一个物理上真正存在的地址，接着就是访问物理内存中的数据了。总结起来说，虚拟内存地址的大小是与地址总线位数相关，物理内存地址的大小跟物理内存条的容量相关。


 



 转自：https://blog.csdn.net/fukaibo121/article/details/75105848

 
 
 
  

   

    

     1.内存地址用4位16进制和8位16进制表示的区别。例如经常可以看到某些书籍上写的内存地址0x0001，在另外一些书籍上写的内存地址又变成了0x00000001。都是表示的编号为1的内存地址，为什么一个是4位16进制表示，另外一个又是用8位16进制表示呢？
    
   
  
  

   

    

     

      
首先，必须要知道内存地址只是一个编号，代表一个内存空间。那么这个空间是多大呢？原来在计算机中存储器的容量是以字节为基本单位的。也就是说一个内存地址代表一个字节（8bit）的存储空间。
      
例如经常说32位的操作系统最多支持4GB的内存空间，也就是说CPU只能寻址2的32次方（4GB），注意这里的4GB是以Byte为单位的，不是bit。也就是说有4G=4*1024M（Byte）=4*1024*1024Kb(Byte)=4*1024*1024*1024Byte(8bit)，即2的32次方个8bit单位。
      
所以说用4位16进制表示的内存地址和用8位16进制表示的内存地址，其实都是代表一个8bit的存储空间而已：
      

      

      
至于说为什么会出现一种是用4位十六进制表示内存地址，另一种用8位十六进制表示内存地址，那是根据不同的硬件环境来的。个人理解：有些CPU只能寻址16位（16根地址线），所以用4位十六进制表示地址就够用了。有些CPU只能寻址32位（32根地址线），所以用8位十六进制。
      
另外记住， 210 = 1024
      
             1G  = 1024 M
      
             1M  =  1024 KB
      
             1KB = 1024 B（Byte）
      
             1Byte = 8 bit
      
2.理解内存。
      
程序和数据平常存储在硬盘等存储器上，不管你开机或关机了，它们都是存在的，不会丢失。硬盘可以存储的东西很多，但其传输数据的速度较慢。所以需要运行程序或打开数据时，这些数据必须从硬盘等存储器上先传到另一种容量小但速度快得多的存储器，之后才送入CPU进行执行处理。这中间的存储器就是内存。
      
无论何种存储器，软盘、硬盘、光盘或者内存，都有地址。因为它们要存储数据，所以就必须按一定的单位的数据分配一个地址。有了地址，程序才能找到这些数据。这很好理解，想想你们家为什么要有门牌号即可。
      
学习编程，必须对内存的地址有一个透彻的理解。我们编程中的每一行代码，代码中用到的每个数据，都需要在内存上有其映射地址。当然，我们并不需要掌握内存是如何进行编址，那是计算机系中的另外一门课：操作系统的事了。
      
内存地址：
计算机把所有的信息都给数字化了，所以它知道自已把一个数据，一条命令记到了内存中的哪个（些）位置。
看下面的例子：
如果让计算机在内存里记住“丁小明”这个名字，可以示意为：
      

      
在第一行中，每一格表示一段内存，而格子里的内容是这段内容记下的数据；第二行中每一格内数字就是对应的内存的地址。
可能有人会啄磨：为什么一个“丁”字（“小”“明”两字也一样）占用两个内存地址呢？这是因为汉字在一个地址（位置）里呆不下，必须放在连续的两个地址空间内。那么，什么东西可以放在单独的一个内存地址里呢？像英文的里字母，比如’A’, 像阿拉伯数字：比如’1’,可以，而且就是放在一个内存地址里。假设有一字符串“ABC”，被记在内存里，可示意为(这次我们假设从内存地址2000H处记起)：
      

      
现在我们提几个问题：
      
计算机记住”丁”字的内存地址是多少？ 答案是：1000H。请见上图
      
我们一直在说，在计算机中，所有信息都被数字化为2进制的0、1，所以，“丁小明”这个名字被也应该是一串：0001 0010 0111 0101……,可是在中图所画出的，计算机内存里记的，仍是“丁小明”三个字啊。
      
下面是解释，我们只举一个字”丁”讲解。我们假设在那一串里的 0001 0010 0111 0101 对应的是 “丁” 字，那么有：
      

      
让我们把字母’A’对应的图也画出来：
      

      
在上面的两个图中：
      
第一行分别是“丁”和“A”，它是给人看的。
      
第二行则是一串的的0和1，这才是计算机内存中实际存储的数据。
      
第三行是内存的地址。并不是每个0和1所占的位置都被编上地址。而是每8个才拥有一个地址。
      
关于第三行，你可以这样理解，门牌号是一个家庭分配一个，每家每户内还有客厅卧室，这些就没有地址了。
      
可见：
      
‘丁’的确是由一串0、1组成的。更确切地，从图上可以看出‘丁’是由16位0和1组成。这16数都存放在2个内存地址里。
      
‘A’也一样，它是由8位0、1组成的。占1个内存地址。
      
总结：内存地址是内存当中存储数据的一个标识，并不是数据本身，通过内存地址可以找到内存当中存储的数据。
     
    
   
  
 
 

如果地址线是32位，那可寻址的范围是4G，内存地址从0-0xffffffff。
 
BIOS在内存最高地址处，最低1M空间内又有很多固定的用途，如下图所示： 
  
 （图片出自：赵炯——Linux内核完全剖析——基于0.12内核，图2-4）
 
我原来不明白，ROM和RAM是连着的吗？还是把ROM BIOS拷贝到RAM中的指定位置。后来看到王爽老师的《汇编语言》才明白，原来上图只是个逻辑存储器，实际是由各类存储器组成的。如下图所示： 
  
 
 
上面的那些存储器，在物理上是独立的器件，但是在以下两点上相同。 
 1、都和CPU的总线相连 
 2、CPU对它们进行读或写的时候都通过控制线发出内存读写命令。
 
这也就是说，CPU在操控它们的时候，把他们都当做内存来对待，把它们总的看做一个由若干存储单元组成的逻辑存储器，这个逻辑存储器也就是我们所说的内存地址空间。