討論python的資料類型的區別

python很重要的的那幾個資料類型：字串，列表，字典，元組，他們之間重要的區別的是什嗎？能否舉幾個例子來說明下！

共同點：
1、它們都是py的核心類型，是py語言自身的一部分。

核心類型與非核心類型
多數核心類型可通過特定文法來產生其對象，比如"spam"就是建立字串類型的對象的運算式；
非核心類型需要內建函數來建立，比如檔案類型需要調用內建函數open()來建立。
類也可以理解成自訂的非核心類型。

2、邊界檢查都不允許越界索引

3、索引方法都使用[]

   1. s = 'spam'
   2. print s[0]
   3.

   4. s = ['s', 'p', 'a', 'm']
   5. print s[0]
   6.

   7. s = {'name':'bob', 'age':'12'}
   8. print s['name']
   9.

  10. s = ('s', 'p', 'a', 'm')
  11. print s[0]

複製代碼
不同點：
1、有序性
字串、列表、元祖是序列，元祖可以理解成不可變的列表
字典是映射
序列才有有序性，字典沒有可靠的左右順序

2、可變性
字串、元祖（還有數字）具有不可變性，即賦值後對應儲存空間的內容不可變，除非這個對象被銷毀。
列表、字典具有可變性

   1. s = 'spam'
   2. s = 'z' + s[1:]

複製代碼
第一行的s的指向的記憶體空間（比如地址 0x000123）儲存了字串'spam'
第二行的s“變”成了'zpam'，但它只是重新指向了一個儲存著'zpam'字串的記憶體位址，原來0x000123出開始的記憶體空間可能還是一個 'spam'

，直到系統來清理它

3、序列操作
序列（字串、列表、元祖）支援，映射（字典）不支援
注意：序列操作產生的類型不變。

   1. col = 'spam'
   2. print col[1:]
   3. #結果是pam
   4.

   5. col = ['s', 'p', 'a', 'm']
   6. print col[1:]
   7. #結果是['p', 'a', 'm']
   8.

   9. col = ('s', 'p', 'a', 'm')
  10. print col[1:]
  11. #結果是('p', 'a', 'm')

複製代碼
4、列表解析運算式
運算式中支援序列（字串、列表、元祖），貌似也支援映射（字典）。
注意：和序列操作不同的是，
列表解析運算式產生的只能是一個列表；

   1. double = [c * 2 for c in 'spam']
   2. print double
   3. 結果為['ss', 'pp', 'aa', 'mm']
   4.

   5. L1 = [1, 2, 3]
   6. L2 = [4, 5, 6]
   7. L3 = [(a + b) for (a,b) in zip(L1, L2)]
   8. print L3
   9. #結果為[5, 7, 9]
  10.

  11. tup = (1, 2, 3)
  12. double = [c * 2 for c in tup]
  13. print double
  14. #結果為[2, 4, 6]

複製代碼
可以把字典轉化成列表，謝謝lx的提醒，呵呵

   1. a = {'a':'zw','b':'ww'}
   2. b = [i * 2 for i in a.items()]
   3. print b
   4. #結果為[('a','zw','a','zw'),('b','ww','b','ww')]
   5. #a.items()實際上是一個列表

複製代碼
下面一段代碼似乎是列表解析運算式對字典的支援，經過un兄和Nell兄的理解，對字典進行的迭代應該是對其keys的迭代，字典的items()、keys()、 values()方法都是返回的列表，所以，這裡的for i in a最好寫成for i in a.keys()，效果等同。總之，可以不追究列表解析運算式到底支不支援字典，本質上，列表解析運算式就是個對列表使用了迴圈結構，並產生新的列表的方法。先這樣理解

   1. a = {'a':'zw','b':'ww'}
   2. b = [i * 2 for i in a]
   3. print b
   4. #結果為['aa', 'bb']

複製代碼
5、嵌套
除了字串，列表、元祖、字典可以相互多層次嵌套

   1. #第一段
   2. b = [1, 2, 3]
   3. tup = (4, 5, b)
   4. print tup[2]
   5. #結果是[1, 2, 3]
   6. b[0] = 'x'
   7. print tup[2]
   8. #結果是['x', 2, 3]
   9.

  10. #第二段
  11. b = '123'
  12. tup = (4, 5, b)
  13. print tup[2]
  14. #結果是'123'
  15. b = 'xxx'
  16. print tup[2]
  17. #結果仍然是'123'

複製代碼
有上面兩段可以看出，嵌套與可變性是不衝突的。
tup = (4, 5, b)中所記憶、錄入的b是個變數指標，或者叫記憶體位址，是個數字。
第一段，b指向一個列表，列表具有可變性，所以b[0] = 'x'的操作後，所以對元祖的索引能體現出變化；
第二段，b指向一個字串，字串具有不可變性，所以b = 'xxx'的操作後，b這個指標本身就改變了，重指向另一段記憶體空間，而tup元祖中記憶的記憶體位址（那個曾經的b）所指空間並沒有變，還是字串 '123'。
所以，不管是第一段還是第二段，元祖tup始終保持不可變性，要變化也是其元素作為指標所指向記憶體的變化。

4、列表解析運算式
運算式中支援序列（字串、列表、元祖），不支援映射（字典）。

似乎字典也可以使用在列表解析中

a = {'a':'zw','b':'ww'}

[i * 2 for i in a.items()]

輸出：
[('a','zw','a','zw'),('b','ww','b','ww')]