python的重要数据格式之间的转化(set,list,tuple,dict)
在 set， list， tuple，
dict中，互相转化的中心在于list，其他数据类型都可以通过转化为list进行转化为第三种数据结构，
但是，从转化意义来说，list与其他数据结构的转化才是有实际意义的。
1. tuple和list的区别就是可变和不可变的区别.
我们要改变tuple中的数据,就要利用list()内置方法转化tuple,接着改完后根据tuple()内置方法再转化为元组
2. list和set的区别就是有序和无序的区别.
我们要将list中的元素进行去重,一般采用set()内置方法转化list为set,去除掉重复元素
在去除掉重复元素后,set中的元素顺序是未知的,因此,我们再将set转化为list的时候,要采用list的index作为辅助进行排序.&&&
过程如下,已知list& a_list
set_a = set(a_list)
b_list& = list(set_a)
b_list.sort(key=a_list.index)
至此,实现了对a_list进行去重并保持元顺序的目的.
示例程序如下：
&&& a_list = [1, 3, 3, 5, 6, 19, 19, 99, 99,
&&& a_set = set(a_list)
set([1, 3, 100, 5, 6, 99, 19]) 此时原list顺序改变了
&&& list(a_set)
[1, 3, 100, 5, 6, 99, 19] 按照此时的set进行list转换，顺序不能保证
&&& b_list = list(a_set)
&&& b_list.sort(key=a_list.index) 需要按照key=a_list.index进行排序，可保证原有list顺序，原理为：排序使用的key为index函数的返回值，如比较元素3和5，不直接比较，而是比较index(3),
index(5) 后给出最终的结果
&&& b_list
[1, 3, 5, 6, 19, 99, 100]
但是，list的元素是dict类型时，由于dict类型不能hashable，就无法利用set进行去重了。需要自己写一段代码遍历列表进行去重。
3. dict和list之间的转化
原理就是通过元组对进行转化，注意，元组是n个元素，n不受限制，但是为了对应字典，这里说明的是元组对，即长度为2的元组
[(元组1),(元组2)...(元组n)]&&
===&&& 这个格式可以很轻松的转化为dict字典元素
dict.iteritimes()方法（应该为items()方法，iteritems()为迭代器）也能将字典转化为
元素为元组的列表.
它们之间的转化一般是因为要对dict中的元素进行排序等等
这几种格式是python语言的基础,需要多多留心,使用得当可以大大的减少代码量，似的代码更加清晰易懂。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Python 元组(Tuple)操作详解
字体：[ ] 类型：转载 时间：
Python的元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可
一、创建元组 代码如下:tup1 = ('physics', 'chemistry', );tup2 = (1, 2, 3, 4, 5 );tup3 = "a", "b", "c", "d";创建空元组 代码如下:tup1 = ();元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义 代码如下:tup1 = (50,);元组与字符串类似，下标索引从0开始，可以进行截取，组合等。二、访问元组元组可以使用下标索引来访问元组中的值，如下实例: 代码如下:#!/usr/bin/python
tup1 = ('physics', 'chemistry', );tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0]print "tup2[1:5]: ", tup2[1:5]#以上实例输出结果：#tup1[0]:& physics#tup2[1:5]:& [2, 3, 4, 5]三、修改元组元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例: 代码如下:#!/usr/bin/python
tup1 = (12, 34.56);tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。# tup1[0] = 100;
# 创建一个新的元组tup3 = tup1 + tup2;print tup3;#以上实例输出结果：#(12, 34.56, 'abc', 'xyz')四、删除元组元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例: 代码如下:#!/usr/bin/python
tup = ('physics', 'chemistry', );
print "After deleting tup : "#以上实例元组被删除后，输出变量会有异常信息，输出如下所示：#('physics', 'chemistry', )#After deleting tup :#Traceback (most recent call last):#& File "test.py", line 9, in &module&#&&&#NameError: name 'tup' is not defined[/code]五、元组运算符与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
六、元组索引，截取因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：元组： 代码如下:L = ('spam', 'Spam', 'SPAM!')
七、无关闭分隔符任意无符号的对象，以逗号隔开，默认为元组，如下实例： 代码如下:#!/usr/bin/python
print 'abc', -4.24e93, 18+6.6j, 'xyz';x, y = 1, 2;print "Value of x , y : ", x,y;以上实例允许结果： 代码如下:abc -4.24e+93 (18+6.6j) xyzValue of x , y : 1 2八、元组内置函数Python元组包含了以下内置函数1、cmp(tuple1, tuple2)：比较两个元组元素。2、len(tuple)：计算元组元素个数。3、max(tuple)：返回元组中元素最大值。4、min(tuple)：返回元组中元素最小值。5、tuple(seq)：将列表转换为元组。
九、另一种解读
tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字： 代码如下:&&& classmates = ('Michael', 'Bob', 'Tracy')
现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如： 代码如下:&&& t = (1, 2)&&& t(1, 2)如果要定义一个空的tuple，可以写成()： 代码如下:&&& t = ()&&& t()但是，要定义一个只有1个元素的tuple，如果你这么定义： 代码如下:&&& t = (1)&&& t1定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义： 代码如下:&&& t = (1,)&&& t(1,)Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。
在来看一个“可变的”tuple： 代码如下:&&& t = ('a', 'b', ['A', 'B'])&&& t[2][0] = 'X'&&& t[2][1] = 'Y'&&& t('a', 'b', ['X', 'Y'])这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
别急，我们先看看定义的时候tuple包含的3个元素：当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具　　序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。Python有6个序列的内置类型，但最常见的是列表list和元组tuple。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
1、list 列表
　　python内置的数据类型，有序集合，随时增删。包含的数据类型可以不同：整数、浮点数、字符串、list、tuple、dict、set、bool、空值、常量
list1=[1.2, 2.1, 3, 3.2, 5, 'a', (2, 2, 3), [1.2, 2], {1: 2, 2: 3}, set([2, 3, 2.2]), 3.14, None]
空的列表：list1=[]; list2=list()
函数：len()、append()、remove()移除列表中某个值的第一个匹配项、insert()、pop()、sort()、del、list()、reverse()、index()从列表中找出某个值第一个匹配项的索引位置、count()统计某个元素在列表中出现的次数、extend()在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
删除：del list1[0]
元祖转换为列表：tuple--&list& list(tuple)
append(value)把元素添加到末尾、insert(i,value)把元素添加到任意位置；pop(）删除末尾元素、pop(i)删除指定位置的元素、remove(value)直接删除某个元素值；list1.sort()对元素进行排序
取值：list1[0]、list1[4:]、list1[:-4]、list1[2:-3]
嵌套：list里面可以嵌套list从而形成类似于二维、三维、多维数组的东东，list1[1][2]/list1[2][3][3][5]……
修改：修改某个位置元素的值 list1[i]=value
2、tuple 元祖
　　python内置的数据类型，有序列表，一旦初始化，无法修改。tuple不可变，所以代码更安全。包含的数据类型可以不同：整数、浮点数、字符串、list、tuple、dict、set、bool、空值、常量
空的元祖：tuple1=(); tuple2=tuple()
函数：len()、del 删除整个元祖、tuple()把列表转换为元祖/append()、remove()、insert()、pop()、sort(）
取值：tuple1[0]、tuple1[-1]、tuple1[3:]、tuple1[:-1]、tuple1[2:-2]
表示：空的tuple1=()；一个元素tuple1=(2,)后面跟着一个逗号
虽然tuple不可变，但是它里面的list、dict、set是可以变的
创建：tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d";
运算符：(1, 2, 3) + (4, 5, 6)、('Hi!',) * 4、3 in (1, 2, 3)、for x in (1, 2, 3): print x,
3、dict 词典& d={'Michael': 95, 'Bob': 75, 'Tracy': 85}
python内置，键值对（key-value）方式存储，查找速度快；dict的key必须是不可变对象（字符串、数字、元祖）；value包含的数据类型可以不同：整数、浮点数、字符串、list、tuple、dict、set、bool、空值、常量
空的词典：dict1={}; dict2=dict()
函数：len()、get()、pop()、del、has_key()、items()、keys()、values()、update()、append()、remove()、insert()、sort(）
取值：d['Michael']
赋值：d['Michael']=100
添加：d['Jim']=22
删除：pop('Tracy'); del d['Jim']；del d
判断key是否存在：'Tracy' d.get('Tracy')如果key不存在，返回N d.get('Tracy', value) 如果key不存在,返回自己指定的value
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而增加；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key
4、set 无序集合、key不重复
无索引、无切片、作为一个无序的集合，set不记录元素位置或者插入点。因此，set不支持&indexing,&slicing,&或其它类序列（sequence-like）的操作
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：
&s = set([1, 2, 3]):set([1,2,3])
&s = set('boy') : set(['b','o','y'])
&s = set(('cmd','pid')) ：set(['cmd','pid'])
&s = {'txt', 'png', 'jpg', 'xls', 'csv', 'zip', 'xlsx', 'gif', 'GIF'}
空的的集合:& set1 = set();
函数：pop()、add()、remove()、update()、len()、clear()、discard()、append()、insert()、sort(）
添加：add(key)、update();区别 s.add('boy'):set(['boy',1,2,3]);s.update('boy'):set(['boy','b',1,2,3,'o','y']);s.update([23,22,32])添加多项
删除：remove(key)删除指定位置的元素,如果不存在，引发KeyError；pop()删除并且返回集合“s”中的一个不确定的元素,&如果为空则引发&KeyError；clear()删除所有元素；s.discard(x),如果在&set&“s”中存在元素&x,&则删除
交集：set1 & set2 (set1.intersection(set2))两个set的共有元素
并集： set1 | set2 （set1.union(set2)）两个set的元素相加后去重
差集：set1 - set2 (set1.difference(set2)) 集合set1去除和和集合set2相同的部分
对称差集：set1^set2 (set1.symmetric_difference(set2))
操作：key in set1; key not in set1 ；for key in set1;
　　　set1.issubset(set2)等价于set1&=set2 : 测试set1中的每一个元素是否都在set2中
　　　set1.issuperset(set2)等价于set1&=set2 : 测试set2中的每一个元素是否都在set1中　
　　　s.copy()& 返回&set&“s”的一个浅复制&&
set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错
重复元素在set中自动被过滤
应用示例：怎么去除海量列表里重复元素：
a =&[11,22,33,44,11,22]&
a = list(set(a)) : &[33, 11, 44, 22]&
总结：1、list、tuple是有序列表；dict、set是无序列表
　　&& 2、list元素可变、tuple元素不可变
　　&& 3、dict和set的key值不可变，唯一性
　　&& 4、set只有key没有value
　　&& 5、set的用途：去重、并集、交集等
　　&& 6、list、tuple：+、*、索引、切片、检查成员等
　　　7、dict查询效率高，但是消耗内存多；list、tuple查询效率低、但是消耗内存少
参考：1、/python/python-dictionary.html
　　&& 2、/wiki/095c955c1e6d8bbfac/abf734c00bba97c87f89a263b000
阅读(...) 评论()python的dict,set,list,tuple应用详解
投稿：shichen2014
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了python的dict,set,list,tuple应用详解,需要的朋友可以参考下
本文深入剖析了python中dict,set,list,tuple应用及对应示例，有助于读者对其概念及原理的掌握。具体如下：
1.字典(dict)
dict 用 {} 包围
dict.keys(),dict.values(),dict.items()
hash(obj)返回obj的哈希值，如果返回表示可以作为dict的key
del 或 dict.pop可以删除一个item,clear清除所有的内容
sorted(dict)可以把dict排序
dict.get()可以查找没存在的key，dict.[]不可以
dict.setdefault() 检查字典中是否含有某键。 如果字典中这个键存在，你可以取到它的值。 如果所找的键在字典中不存在，你可以给这个键赋默认值并返回此值。
{}.fromkeys()创建一个dict，例如:
{}.fromkeys(('love', 'honor'), True) =&{'love': True, 'honor': True}
不允许一个键对应多个值
键值必须是哈希的，用hash()测试
一个对象，如果实现_hash()_方法可以作为键值使用
2.集合(set)
集合是一个数学概念，用set()创建
set.add(),set.update.set.remove，添加更新删除，-= 可以做set减法
set.discard 和 set.remove不同在于如果删除的元素不在集合内，discard不报错，remove 报错
& &= 表示 子集，& &=表示超集
| 表示联合 & 表示交集 - 表示差集 ^ 差分集
3.列表(list)
列表是序列对象，可包含任意的Python数据信息，如字符串、数字、列表、元组等。列表的数据是可变的，我们可通过对象方法对列表中的数据进行增加、修改、删除等操作。可以通过list(seq)函数把一个序列类型转换成一个列表。
append(x) 在列表尾部追加单个对象x。使用多个参数会引起异常。
count(x) 返回对象x在列表中出现的次数。
extend(L) 将列表L中的表项添加到列表中。返回None。
Index(x) 返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。
insert(i,x) 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。
pop(x) 删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。
remove(x) 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
reverse() 颠倒列表元素的顺序。
sort() 对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。
4.元组(tuple)
tuple=(1,)，这是单个元素的元组表示，需加额外的逗号。
tuple=1，2，3，4，这也可以是一个元组，在不使用圆括号而不会导致混淆时，Python允许不使用圆括号的元组。
和列表一样，可对元组进行索引、分片、连接和重复。也可用len()求元组长度。&
元组的索引用tuple[i]的形式，而不是tuple(i)。
和列表类似，使用tuple(seq)可把其它序列类型转换成元组。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}