python中的變數怎樣開闢記憶體

lm_y發表於2017-09-13
Python變數記憶體
python下的變數

      不需要預先宣告變數的型別，變數的型別和值在賦值的那一刻被初始化（宣告和定義的過程一起完成）

      在python中， 每一個變數在記憶體中建立，我們可以通過變數來檢視記憶體中的值

      哈哈，這裡是不是很熟悉，跟c中的指標一樣啊（訪問記憶體中的值）

         

         首先大家需要了解一點：在python中：

          x =5之後，我們要了解它的過程：系統先是找了一塊記憶體，將5儲存了進去，緊接著x指向了當前的這塊記憶體

      預測1：      python下的變數是一個指標

[python] view plain copy
  1. >>> x = 4  
  2. >>> y = 5  
  3. >>> print x  
  4. 4  
  5. >>> print y  
  6. 5  
  7. >>> id(x)  
  8. 10413988  
  9. >>> id(y)  
  10. 10413976  
  11. >>> x = y  
  12. >>> id(x)  
  13. 10413976  
  14. >>> id(y)  
  15. 10413976  
  16. >>>   


從上面我們可以看到：

x = 4        說明x指向了記憶體中儲存為4的那個地址，那個地址是10413988

y = 5        說明y指向了記憶體中儲存為5的那個地址，那個地址是10413976

 

也就是說在執行x = 4，y = 5之後，x,y分別指向了不同的地址，當執行 x = y之後：

也就是說，x指向了y所指向的記憶體了，這裡我們知道，它們都指向同一塊記憶體



哈哈，原來跟c裡面的指標真的一樣哎！！！哈哈哈

（但是，但是，但是     ：就這些嗎？？）

[python] view plain copy
  1. >>> x = 4  
  2. >>> print x  
  3. 4  
  4. >>> id(x)  
  5. 10413988  
  6. >>> x = 5  
  7. >>> print x  
  8. 5  
  9. >>> id(x)  
  10. 10413976  
  11. >>>   

好，我們大家接著看：


也就是說：開始的時候，x指向了10413988這塊記憶體，裡面儲存的是4

當執行了x = 5之後，也就變成了這樣：


 

 好，ok就是這樣了，
不知道大家注意到了嗎？
在python中，一開始初始化儲存在記憶體的東西是不可以更改的，我們所能更改的只是它的指向，
但是，但是，在c中，對於int   x= 4；   也就是說x的地址是定的，裡面儲存的東西可以更改
[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. int main(){  
  4.     int x = 4;  
  5.     printf("%p    %d\n", &x, x);  
  6.     x = 5;  
  7.     printf("%p    %d\n", &x, x);  
  8.       
  9.     return 0;  
  10. }  
我們大家再看一下執行結果：


從上面可以看到，地址並沒有變，好了，這一點，python和c的區別較大，希望大家注意。



二： 記憶體大小
     
     我們來看一下這樣的程式碼：
     
[python] view plain copy
  1. >>> x = 6  
  2. >>> id(x)  
  3. 10413964  
  4. >>> y = 7  
  5. >>> id(y)  
  6. 10413952  
  7. >>> z = 8  
  8. >>> id(z)  
  9. 10413940  
  10. >>>   
從上面的程式中，我們知道系統給分配的地址分別是：
10413964
10413952
10413940
所以我們大膽推測，python中應該給這些整數的位元組有可能就是12（哈哈，純屬個人推測）
有可能記憶體中就是這樣了的：

哈哈，也該就是這樣子了，
    

至於其他的大小，有興趣的朋友可以研究研究




三：python記憶體

        是不是說：在python中，系統將每一個值都放在了一個固定的位置，不然為什麼，每一次探究記憶體地址的時候，結果都是一樣的（數值相等，地址也相等）

     

[python] view plain copy
  1. >>> x = 4  
  2. >>> y = 5  
  3. >>> id(x)  
  4. 10413988  
  5. >>> id(y)  
  6. 10413976  
  7. >>>   
假如系統為4分配了一塊記憶體，遵循某種規則（類似於c裡面的記憶體對齊），那麼接下來為5分配了另一塊記憶體，權且分配到了10413976

那麼下面這個如何解釋：

[python] view plain copy
  1. >>> x = 4  
  2. >>> y = 6  
  3. >>> id(x)  
  4. 10413988  
  5. >>> id(y)  
  6. 10413964  
  7. >>>   
假如遵循某種規則的話，應該是6也分配到了10413976去了，可是，他被分配到了10413964

我們再來看：

[python] view plain copy
  1. >>> x = 4  
  2. >>> y = 6  
  3. >>> id(x)  
  4. 10413988  
  5. >>> id(y)  
  6. 10413964  
  7. >>> z = 5  
  8. >>> id(z)  
  9. 10413976  
  10. >>>   
這，哈哈，應該就是這樣的了的吧！！！！
也就是說：python中，系統還是python本身為其分配記憶體的時候就已經根據這個值是多少，確定了記憶體的位置了。。。

相關文章