python學習——一些有趣的討論

由於底層的c實現,python中的指針問題也成爲了一個大問題,得好好研究

1) 共享引用

由於python中,萬物皆對象,所以賦值總是代表着引用的copy,很好的一個例子

python 代碼
  1. >>> X = [1, 2, 3]   
  2. >>> L = ['a', X, 'b']   
  3. >>> D = {'x':X, 'y':2}   
  4. >>> L   
  5. ['a', [1, 2, 3], 'b']   
  6. >>> D   
  7. {'y': 2, 'x': [1, 2, 3]}   
  8. >>> X[1] = 'aha'   
  9. >>> X   
  10. [1, 'aha', 3]   
  11. >>> L   
  12. ['a', [1, 'aha', 3], 'b']   
  13. >>> D   
  14. {'y': 2, 'x': [1, 'aha', 3]}  

有程序設計經驗的人很容易明白上面的代碼,當我們在L,D中使用X時,實際上是把[1, 2, 3]這個列表的地址放到了L,D中X的位置上,當[1, 2, 3]中元素改變時,地址並沒有變,所以L,D也跟着變。

python 代碼
  1. >>> s = 'abc'   
  2. >>> l = [1, 2, s]   
  3. >>> l   
  4. [1, 2, 'abc']   
  5. >>> s = 'def'   
  6. >>> l   
  7. [1, 2, 'abc']  

這段代碼有人就該迷糊了,s不是指向的是一個字符串地址嗎,l中相應的位置也是這個地址啊,s改變了,爲什麼l不變?呵呵,原因就是字符串是不可遍的,當我們把'def'賦給s時,s所指向的地址就變了,而l中s的位置還是存的'abc'的地址,這就是l不變的原因。

還有一個有趣的例子

python 代碼
  1. >>> L = [1, 2]   
  2. >>> X = L * 2   
  3. >>> X   
  4. [1, 2, 1, 2]   
  5. >>> Y = [L] * 2   
  6. >>> Y   
  7. [[1, 2], [1, 2]]   
  8. >>> L[1] = 'aha'   
  9. >>> X   
  10. [1, 2, 1, 2]   
  11. >>> Y   
  12. [[1, 'aha'], [1, 'aha']]  

實際上X的效果類似[1, 2] + [1, 2],Y的效果類似[L] + [L] = [L, L],這回該明白了吧。

2)比較

java中比較有==,<=,>=,equals,comparaTo等等。python中比較是==,<=,>=,is,is not。當我們使用python的比較時,它會自動比較兩個對象中內部的數據結構。啥也不說了,例子是最好的teacher

python 代碼
  1. >>> L1 = [1, ('a', 3)]   
  2. >>> L2 = [1, ('a', 3)]   
  3. >>> L1 == L2   
  4. True  
  5. >>> L1 is L2   
  6. False  
  7. >>> L1 < L2   
  8. False  
  9. >>> L1 > L2   
  10. False  
  11. >>> L2[1] = ('a', 2)   
  12. >>> L2   
  13. [1, ('a', 2)]   
  14. >>> L1 < L2   
  15. False  
  16. >>> L1 > L2   
  17. True  

3) 消除指針影響

對於向列表和字典那樣的可變類型來說,有時我們不需要指針式的引用(在java中,也有類似的需求),實際上解決起來很簡單,例子說明一切

python 代碼
  1. >>> L = [1, 2, 3]   
  2. >>> M = ['x', L[:], 'y']   
  3. >>> M   
  4. ['x', [1, 2, 3], 'y']   
  5. >>> L[1] = 'aha'   
  6. >>> L   
  7. [1, 'aha', 3]   
  8. >>> M   
  9. ['x', [1, 2, 3], 'y']  
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章