python数据类型区别

之前在没有弄清楚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')]