分析Python中List、Tuple、字典、Set的区别和用法

列表(List)

列表的特点
1.用来储存多个数据的数据结构
2.储存的数据是有序的，可使用位置索引
3.列表长度和元素都是可变的
4.可储存不同类型的数据
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

 a = [1, 'abc', 12.12,3,4,5,6]

可以看到并不要求元素的类型都是一样的。当然也可以定义一个空的List:

 b = []

Python中的List是有序的，所以要访问List的话显然要通过序号来访问，就像是数组的下标一样，一样是下标从0开始,也可以使用方括号的形式截取字符：

a [0]
a [1:5]

List也可以倒序访问，通过“倒数第x个”这样的下标来表示序号，比如-1这个下标就表示倒数第一个元素：

print a[-1]
>> 6

List通过内置的append()方法来添加到尾部，通过insert()方法添加到指定位置（下标从0开始）：

a = [1, 'abc', 12.12,3]
a.append('Jack')
print a
[ 1, 'abc', 12.12,3,'Jack']

a.insert(1, 3.14)
print a
[ 1,3.14, 'abc', 12.12,3,'Jack']

通过pop()删除最后尾部元素，也可以指定一参数删除指定位置：

a = [1, 'abc', 12.12,3]
a.pop()
print a
[ 1, 'abc', 12.12]

a = [1, 'abc', 12.12,3]
a.pop(0)
print a
[ 'abc', 12.12,3]

可以使用 del语句来删除列表的元素，如下实例：

list1 = [1,2,3,4,5]
del list1[2]
print list1
[1,2,4,5]

元组（Tuple）

Python的元组与列表类似，不同之处在于元组的元素不能修改,长度不可改变,常用于安全级别较高的场景应用。
元组使用小括号（），列表使用方括号[ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
Tuple可以看做是一种“不变”的List，访问也是通过下标，用小括号（）表示：

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (1,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等,但是没有pop和insert、append方法。
那么tuple这个类型到底有什么用处呢？

要知道如果你希望一个函数返回多个返回值，其实只要返回一个tuple就可以了，因为tuple里面的含有多个值，而且是不可变的（就像是java里面的final）。当然，tuple也是可变的，比如:

t  = (3.14, 'China', 'Jason', ['A', 'B'])
a = t[3]
a[0] = 12
a[1]= 13
print t
(3.14, 'China', 'Jason', [12, 13])

这是因为Tuple所谓的不可变指的是指向的位置不可变，因为本例子中第四个元素并不是基本类型，而是一个List类型，所以t指向的该List的位置是不变的，但是List本身的内容是可以变化的，因为List本身在内存中的分配并不是连续的。

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

• len()
  计算元素个数：len((1, 2, 3))结果是3
• +
  合并两个元组： (1, 2, 3) + (4, 5, 6)，结果是(1,2,3,4,5,6)
• *n
  元素复制n次：(‘Hi!’,) * 4，结果是(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
• in
  元素是否存在元组中，有就返回ture：3 in (1, 2, 3)，结果是True
• for x in (1, 2, 3):
  迭代 :for x in (1, 2, 3)：print x,结果是1 2 3

字典（Dict）

Dict是Python中非常重要的数据类型，就像它的字面意思一样，它是个活字典，其实就是Key-Value键值对，类似于HashMap，可以用花括号{}通过类似于定义一个C语言的结构体那样去定义它：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

dict = {'a': 1, 'b': 2, 'b': '3'}
dict['b']
//      3
dict
//     {'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
创建字典：

dict1 = {'abc': 456}
dict2 = {'abc': 123, 'def': 567}

可以直接通过键值对方式添加dict中的元素：

a = {'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
a['Jone'] = 99
print a
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下标来访问内容，而Dict用Key来访问： (字符串、整型、浮点型和元组tuple都可以作为dict的key):

print a['Adam']
95

如果Key不存在，会报错：
所以访问之前最好先查询下key是否存在：

if 'Adam' in a :   
    print 'exist key'
//    exist key

或者直接用保险的get方法：

print d.get('Adam')
95

至于遍历一个dict，实际上是在遍历它的所有的Key的集合，然后用这个Key来获得对应的Value:

for key in a : print key, ':', a.get(key)

Lisa : 85
Paul : 75
Adam : 95
Bart : 59

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

结果：
dict['Age']:  8
dict['School']:  RUNOOB

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del dict['Name']  # 删除键是'Name'的条目
dict.clear()      # 清空字典所有条目
del dict          # 删除字典

print "dict['Age']: ", dict['Age'] 
print "dict['School']: ", dict['School']

但这会引发一个异常，因为用del后字典不再存在：

dict['Age']:
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print "dict['Age']: ", dict['Age'] 
TypeError: 'type' object is unsubscriptable

字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会覆盖前一个值，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 
print "dict['Name']: ", dict['Name']

dict['Name']:  Manni 

2. 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

dict = {['Name']: 'Zara', 'Age': 7} 
print "dict['Name']: ", dict['Name']

结果就会报错：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Zara', 'Age': 7} 
TypeError: list objects are unhashable

合并两个字典
如何将两个Dict合并为一个，可以用dict函数：

d1 = {'mike':12, 'jack':19}
d2 = {'jone':22, 'ivy':17}
d3 = dict(d1.items() + d2.items())
print d3

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

或者

d4 = dict(d1, **d2)
print d4

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

后一个方法比前一个方法速度快很多，方法2等同于：

d3 = dict(d1)
d3.update(d2)
print d3

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

字典包含了以下内置方法：

• dict.clear()
  删除字典内所有元素

• dict.copy()
  返回一个字典的浅复制

• dict.fromkeys(seq[, val])
  创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

• dict.get(key, default=None)
  返回指定键的值，如果值不在字典中返回default值

• dict.has_key(key)
  如果键在字典dict里返回true，否则返回false

• dict.items()
  以列表返回可遍历的(键, 值) 元组数组

• dict.keys()
  以列表返回一个字典所有的键

• dict.setdefault(key, default=None)
  和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

• dict.update(dict2)
  把字典dict2的键/值对更新到dict里

• dict.values()
  以列表返回字典中的所有值

• pop(key[,default])
  删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。
  否则，返回default值。

• popitem()
  返回并删除字典中的最后一对键和值。

Dict具有的特点：

• 查找速度快。无论是10个还是10万个，速度都是一样的，但是代价是耗费的内存大。List相反，占用内存小，但是查找速度慢。这就好比是数组和链表的区别，数组并不知道要开辟多少空间，所以往往开始就会开辟一个大空间，但是直接通过下标查找速度快；而链表占用的空间小，但是查找的时候必须顺序的遍历导致速度很慢。
• 没有顺序。Dict是无顺序的，而List是有序的集合，所以不能用Dict来存储有序集合
• Key不可变，Value可变。一旦一个键值对加入dict后，它对应的key就不能再变了，但是Value是可以变化的。所以List不可以当做Dict的Key，但是可以作为Value。

Set（集合）

储存形式与列表相似：
1.集合中保存的数据具有唯一性，不可重复
2.集合中保存的数据是无序的
3.往集合中添加重复数据，集合将只保留一个
集合常被用来去重或者过滤
set就像是把Dict中的key抽出来了一样，类似于一个List，但是内容又不能重复，通过调用set()方法创建：

s = set(['A', 'B', 'C'])

就像dict是无序的一样，set也是无序的，也不能包含重复的元素。
对于访问一个set的意义就仅仅在于查看某个元素是否在这个集合里面：

print 'A' in s
True

print 'D' in s
False

也通过for来遍历：

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for x in s:
    print x[0],':',x[1]


Lisa : 85
Adam : 95
Bart : 59

通过add和remove来添加、删除元素（保持不重复），添加元素时，用set的add()方法：

添加元素用add()方法

s = set([1, 2, 3])
s.add(4)
print s

set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

s = set([1, 2, 3])
s.add(3)
print s

set([1, 2, 3])

删除元素用remove()方法

s = set([1, 2, 3, 4])
s.remove(4)
print s

set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

s = set([1, 2, 3])
s.remove(4)

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 4

所以如果我们要判断一个元素是否在一些不同的条件内符合，用set是最好的选择，举例说明：

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
x1 = 'Feb'
x2 = 'Sun'

if x1 in months:
    print 'x1: ok'
else:
    print 'x1: error'

if x2 in months:
    print 'x2: ok'
else:
    print 'x2: error'


x1: ok
x2: error

集合的应用

s1 = {1,2,3}，s2 = {3,4,5}，s3 = {3,1,6}

集合的并集
newSet = s1 | s2 | s3
或
newSet = s1.union(s2, s3)

集合的交集
newSet = s1 & s2 & s3
或
newSet = s1.intersection(s2, s3)

集合的差集
newSet = s1 - s2 - s3
或
newSet = s1.difference(s2, s3)

判断是否是超集
s1.issuperset(s2)

判断是否是子集
s2.issubset(s1)

判断两个集合是否相交
s1.isdisjoint(s2)

注意：
集合的遍历与列表的遍历方法相同

Python中List、Tuple、字典、Set的区别和用法就说到这里，以后还会补充Python其它的基础只是给大家，记得关注小编！