Tuple、list的区别以及dict和set

元组（Tuple）：

定义方法：使用小括号()

使用方法：

count：可以统计某个元组段在整个元组中出现的次数

index：可以查询某个元组段在整个元组中的元组号

name_tuple = ('xiaoming','xiaohong','xiaoli','xiaozhang','xiaoming')
#统计xiaoming出现的次数
print name_tuple.count('xiaoming')
#统计xiaoming在元组中的下标，默认从0开始计算
print name_tuple.index('xiaoming')
#统计xiaoming在元组中的下标，从指定的小标1，开始计算
print name_tuple.index('xiaoming',1)

返回结果：

2
0
4

列表（list）：

1.可以增加列表内容 append

2.可以统计某个列表段在整个列表中出现的次数 count

3.可以插入一个字符串，并把整个字符串的每个字母拆分当作一个列表段追加到列表当中 extedn

4.可以查询某个列表段在整个列表的位置 index

5.可以在指定位置插入一个列表段 insert

6.可以删除列表的最后一个列表段 pop

7.可以删除指定列表中的某个列表段 remove

8.可以正向反向排序 reverse

9.可以按字母或数字排序 sort

10.定义列表时候使用中括号"[]"

name_list = ['sean','tom','jack','Angelia','Daisy','jack']
print name_list
#增加david列表
name_list.append('david')
print name_list
#统计jack出现的次数
print name_list.count('jack')
#使用extend向列表中增加一个列表
name_list.extend(['hello','world'])
print  name_list
#使用extend向列表中增加列表段
name_list.extend('sean')
print  name_list
#这里统计的是第一个为jacak的id号
print name_list.index('jack')
#在索引号为2的地方插入Adam
name_list.insert(2, 'Adam')
print name_list
#删除最后一个列表段
name_list.pop()
print name_list
#删除指定列表段，如果存在多个，删除第一个
name_list.remove('jack')
print name_list
#列表倒置
name_list.reverse()
print name_list
name_list.reverse()
#对整个列表进行列表段的首字母进行排序
name_list.sort()
print name_list

结果：

['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack']   #原始结果
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david']   #增加david后的结果
2  #统计jack出现次数
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world'] # 使用extend向列表中增加一个列表
['sean', 'tom', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a', 'n']   #使用extend向列表中增加列表段
2   #统计的是第一个为jacak的id号
['sean', 'tom', 'Adam', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a', 'n']   #在索引号为2的地方插入Adam
['sean', 'tom', 'Adam', 'jack', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a']  #删除最后一个列表段
['sean', 'tom', 'Adam', 'Angelia', 'Daisy', 'jack', 'david', 'hello', 'world', 's', 'e', 'a']   #删除指定列表段，如果存在多个，删除第一个
['a', 'e', 's', 'world', 'hello', 'david', 'jack', 'Daisy', 'Angelia', 'Adam', 'tom', 'sean']  #列表倒置
['Adam', 'Angelia', 'Daisy', 'a', 'david', 'e', 'hello', 'jack', 's', 'sean', 'tom', 'world']   #对整个列表进行列表段的首字母进行排序

相同点：都是序列类型

两者区别：tuple是不可变类型，大小固定，而 list 是可变类型、数据可以动态变化

1、元组是不可变对象，对象一旦生成，它的值将不能更改；列表是可变对象，对象生成后，可以对其元素进行更改、添加、删除、清空、排序等操作。

2、可哈希和不可哈希
可哈希对象就是能映射成内存地址的对象。在Python基本数据类型中，只有列表、字典和可变集合是不可哈希的。说元组是可哈希也不对，如果元组中某个元素是列表、字典或可变集合，那么这个元组也是不可哈希的。可哈希对象和不可哈希对象的区别体现在：可哈希对象可以作为字典的键和集合的元素，不可哈希对象则不可以。

tuple 用于存储异构(heterogeneous)数据，当做没有字段名的记录来用，比如用 tuple 来记录一个人的身高、体重、年龄。

person = (“zhangsan”, 20, 180, 80) 
比如记录坐标上的某个点

point = (x, y) 
而列表一般用于存储同构数据(homogenous)，同构数据就是具有相同意义的数据，比如下面的都是字符串类型

[“zhangsan”, “Lisi”, “wangwu”] 
再比如 list 存放的多条用户记录

[(“zhangsan”, 20, 180, 80), (“wangwu”, 20, 180, 80)] 
数据库操作中查询出来的记录就是由元组构成的列表结构。

字典（dict）

字典的基本操作

如何访问字典中的值？
adict[key]
    形式返回键key对应的值value，如果key不在字典中会引发一个KeyError,如何检查key是否在字典中？
has_key()
    形如：adict.haskey(‘name') 有–>True，无–>False
    b、in 、not in   形如：'name' in adict      有–>True，无–>False
如何更新字典？
    a、添加一个数据项（新元素）或键值对
adict[new_key] = value 形式添加一个项
    b、更新一个数据项（元素）或键值对
adict[old_key] = new_value
    c、删除一个数据项（元素）或键值对
del adict[key] 删除键key的项 / del adict 删除整个字典
adict.pop(key) 删除键key的项并返回key对应的 value值

字典的方法：

dict.keys() 返回一个包含字典所有KEY的列表；
dict.values() 返回一个包含字典所有value的列表；
dict.items() 返回一个包含所有（键，值）元祖的列表；
dict.clear() 删除字典中的所有项或元素；
dict.copy() 返回一个字典浅拷贝的副本；
dict.fromkeys(seq, val=None) 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；
dict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；
dict.has_key(key) 如果key在字典中，返回True，否则返回False。 现在用 in 、 not in；
dict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；
dict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；
dict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] = default 为它赋值；
dict.update(bdict) 将字典bdict的键值对添加到字典adict中。

集合（set）

s1={0}
s2={i / 2 for i in range(10)}
print s1,s2
s=set('hi')
t=set(['h','e','l','l','o'])
print s,t

print(s.intersection(t), s & t)     # 交集
print(s.union(t), s | t)            # 并集
print(s.difference(t), s - t)       # 差集
print(s.symmetric_difference(t), s ^ t)   # 对称差集
print(s1.issubset(s2), s1 <= s2)          # 子集
print(s1.issuperset(s2), s1 >= s2)        # 包含

结果：

set([0]) set([0, 1, 2, 3, 4])
set(['i', 'h']) set(['h', 'e', 'l', 'o'])
(set(['h']), set(['h']))
(set(['e', 'i', 'h', 'l', 'o']), set(['e', 'i', 'h', 'l', 'o']))
(set(['i']), set(['i']))
(set(['i', 'e', 'l', 'o']), set(['i', 'e', 'l', 'o']))
(True, True)
(False, False)