列表
元组
集合
字典
英文
list
tuple
set
dict
定义
定义[],数据之间使用,分割
定义()，数据之间用,分割
定义用 {} 或 set()
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割
是否可读写
读写
只读
读写
读写
可否重复
是
是
否
是
数据类型
任意类型对象
任意类型对象
任意类型对象
任意类型对象
存储方式
值
值
键（不能重复）
键值对（键不能重复）
是否有序
有序
有序
无序
无序，自动正序
初始化
[1,'a']
(1,'a')
{1,2}
{'a':1,'b':'kk'}
空值的定义
[] 或者 list()
()或 tuple()
set()
{}或者dict()
支持的操作
索引，切片，合同，删除，修改
索引
 
S | T 并   S - T 差
 
S & T 交  S ^ T 补
 
S <= T 或 S < T
 
S >= T 或 S > T
 
S |= T 并
 
S &= T 交
 
S ^= T 补
 
 
增、删、改、查
 
key in d:键值key是否在d中，是返回True，否则返回False。
 
读取
通过偏移读取 
通过偏移读取 
S.pop()随机返回S的一个元素，更新S，若S为空产生KeyError异常
 
通过键而不是偏移量来读取 
 
查 get(),setdefault(),has_key()
 
通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value
 
d[k]:返回关键字对于的值
 
添加
 
append（object）函数 向列表中追加据，
 
会把添加的数据放在列表中的最后一个位置
 
insert（index，object）函数 向列表中插入一条数据
 
extend(iterable)函数  可以将另外一个列表中的数据添加到该表中
 
             iterable：可迭代对象  列表、字符串、字典、元组
 
不能修改
S.add(x) 如果x不在集合S中，将x增加到S
d['sex'] = 'man'
修改
 
列表[索引]=数据 classname[1]='new'
 
index(object：数据, start：开始搜索的位置，stop：结束搜索的位置) 
 
不能修改
集合元素不可更改
d['Age'] = 8;
删除
 
pop删除末尾元素 classname.pop()
 
pop删除指定元素pop(i) classname.pop(1)
 
del list_1[4]
 
使用remove(object)函数，根据数据内容删除  要删除的内容必须在列表中，否则会报错
 
移除列表中所有的数据
 
list_1.clear()
 
不能修改
 
S.discard(x)移除S中元素x，如果x不在集合S中，不报错
 
S.remove(x)移除S中元素x，如果x不在集合S中，产生KeyError异常
 
S.clear()移除S中所有元素
 
 
 
 
删 pop()
 '''通过指定的key值，删除字典的一个键值对
 返回被删除的key对应的value
 
del dict['Name']; # 删除键是'Name'的条目
 dict.clear();     # 清空词典所有条目
 del dict ;        # 删除词典
 
排序
 
升序  列表.sort()
 
降序 列表.sort(reverse=True）
 
倒序，反转 列表.reverse()
 
不能修改
无
无
统计
 
len（列表） 列表的长度
 
列表.count(数据)  数据在列表中出现的次数
 
 
len（元组） 元组的长度
 
列表.count(数据)  数据在元组中出现的次数
 
len(S)返回集合S的元素个数
 
len()：返回字典中键—值对的数量
 
 
 
应用场景
 
1、列表存储相同类型的数据
 2、通过迭代遍历，在循环内部，
 
针对列表中的每一项元素，执行相同的操作
 
 
 
1.查找和插入的时间随着元素的增加而增加 
 2.占用空间小，浪费内存很少 
 所以，dict是用空间来换取时间的一种方法
 
 
1、函数的参数和返回值，一个函数可以接收任意多个参数，一次返回多个数据
 2、格式字符串，格式化字符串后面的（）本质就是一个元组
 3、让列表不可以被修改（保护数据安全）
 
 
 
1.比列表操作速度快 
 2.对数据“写保护“ 
 3.可用于字符串格式化中 
 4.可作为字典的key
 
 
包含关系比较
 
x in S 判断S中元素x， x在集合S中，返回True，否则返回False
 
x not in s
 
数据去重：集合类型所有元素无重复
 
set(x)将其他类型变量x转变为集合类型
 
 
 
 
zip函数可以实现两个类别组合成字典
 
1.查找和插入的速度极快，不会随着key的增加而增加 
 2.需要占用大量的内存，内存浪费多 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
序列 ： 序列是一个基类类型   可以衍生为字符串类型、元组类型、列表类型
 
通用操作符： x in s 如果x是序列s的元素，返回True，否则返回False
 
                      x not in s 如果x是序列s的元素，返回False，否则返回True
 
                     s + t 连接两个序列s和t
 
                     s*n 或 n*s 将序列s复制n次
 
                    s[i] 索引，返回s中的第i个元素， i是序列的序号
 
                  s[i: j] 或 s[i: j: k] 切片，返回序列s中第i到j以k为步长的元素子序列
 
通用方法和函数： len(s) 返回序列s的长度，即元素个数
 
                           min(s) 返回序列s的最小元素， s中元素需要可比较
 
                           max(s) 返回序列s的最大元素， s中元素需要可比较
 
                            s.index(x) 或
                              s.index(x, i, j) 返回序列s从i开始到j位置中第一次出现元素x的位置
 
                            s.count(x) 返回序列s中出现x的总次数
 
 
 
如有疑问或者不对的地方，欢迎留言评论

 
 
   
 
列表：清单可重复，类型可不同 list
 
元组:  类似列表不可修改类型  tuple
 
集合：就是我们数学学的集合应用是去重 set
 
字典：字典存储键值对数据价值是查询，通过键，查找值 dict
 
 
 
 
 
列表元组字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础，但确实能反映出面试者的基础水平。
 
    （1）列表
 
    什么是列表呢？我觉得列表就是我们日常生活中经常见到的清单。比如，统计过去一周我们买过的东西，把这些东西列出来，就是清单。由于我们买一种东西可能不止一次，所以清单中是允许有重复项的。如果我们扩大清单的范围，统计我们过去一周所有的花费情况，那么这也是一个清单，但这个清单里会有类别不同的项，比如我们买东西是一种花费，交水电费也是一种花费，这些项的类型是可以使不同的。python的列表个跟清单的道理是一样的，特点就是：可重复，类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示：　　
 
lst = ['arwen',123]
 print lst[0] 
 print lst[1]
 
lst[0] = 'weiwen'
 
　　向list中添加项有两种方法：append和extend。append
 
　　（2）元组
 
　　元组和列表在结构上没有什么区别，唯一的差异在于元组是只读的，不能修改。元组用“()”表示，如：
 
tup =('arwen',123)
 print tup[0]   可以用切片的方法读取（切片是指顺序）
 print tup[1]   而可不可以修改是指能不能重新赋值
 
　　（3）集合就是我们数学学的集合，没有什么特殊的定义。集合最好的应用是去重。集合没有特殊的表示方法，而是通过一个set函数转换成集合，如：
 
lst = [ 1, 1, 0]
 
lst_set = set( lst )  #lst_set  为1 , 0
 
tup = (2, 2, 1)
 
tup_set = set( tup) # tup_set为2 , 1
 
for item in lst_set:
 
print item
 
　　（4）最后一个是字典。字典存储键值对数据，如：
 
{1:a,2:b,3:c}
 
　　字典最外面用大括号，每一组用冒号连起来，然后各组用逗号隔开。
 
　　字典最大的价值是查询，通过键，查找值。
 
 

Python数据结构(列表、字典、集合、元组)详细解析
 

 
 
  
Python数据结构列表字典集合元组详细解析
列表
    
基本操作函数
迭代操作
列表加深学习
字典和元组交互
 
元组
    
基本操作函数
 
集合
    
基本操作函数
 
字典
    
基本操作函数
字典加深学习
 
列表元组集合字典相互转换
    
列表元组转其他
字典转其他
字符串转其他
 
 
 
 
 
列表
 
1.列表是Python中使用最频繁的数据类型 
 2.列表可以完成大多数集合类的数据结构实现。 
 3.列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套） 
 4.和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表 
 5.List内置了有很多方法，例如append()、pop()等等 
 6.List可以使用+操作符进行拼接 
 7.[注意]与Python字符串不一样的是，列表中的元素是可以改变的 
 
基本操作函数
 
1.索引，切片，加，乘，检查成员 
 2.增加、删除、连接分割、排序倒序 
 
list1=[1,2,3.0,4,5.0]
list2=['6','7','8','8','8']
list3=['One','Two','Three']
list4=[1,2,3]
print(len(list1))
print(list2.count('8'))
print(list1[0])
print(list1[-1])
print(list1[1:3])
print(list1[1:])
print(list1*2)
print(list1+list2)

if(1 in list1):
    print("1在列表list1中")

print('list1中最大元素对应下标为{0}'.format(list1.index(max(list1))))
print([list1,list2,list3])
##增加
list1.append(6)
list1.insert(2,2.5)
list1.extend([7,8])
print(list1)
##减小
del list1[2],list1[5]
list1.remove(7) #删除具体的值
pop_value=list1.pop(5)
print('pop_value={0}'.format(pop_value))
print(list1)
##连接与分割
join_list='--'.join(list2)  #join只能了解全是字符串的列表
print(join_list)
split_list=join_list.split('--',2)  #最后一个数字代表分割的次数，如果想全部分割则使用-1（默认）
print(split_list)

list1.reverse() #反向
print(list1)
list1.sort()    #排序
print(list1)

list_copy=list1.copy() 返回列表的浅复制，等于a[:]
 
5
3
1
5.0
[2, 3.0]
[2, 3.0, 4, 5.0]
[1, 2, 3.0, 4, 5.0, 1, 2, 3.0, 4, 5.0]
[1, 2, 3.0, 4, 5.0, '6', '7', '8', '8', '8']
1在列表list1中
list1中最大元素对应下标为4
[[1, 2, 3.0, 4, 5.0], ['6', '7', '8', '8', '8'], ['One', 'Two', 'Three']]
[1, 2, 2.5, 3.0, 4, 5.0, 6, 7, 8]
pop_value=8
[1, 2, 3.0, 4, 5.0]
6--7--8--8--8
['6', '7', '8--8--8']
[5.0, 4, 3.0, 2, 1]
[1, 2, 3.0, 4, 5.0]
 
迭代操作
 
1.zip两个列表操作 
 2.list映射解析 
 3.创建二维列表 
 
for q,a in zip(list3,list4):
    print('{0}:{1}'.format(q,a))
    print('%s:%s'%(q,a))

print([elem*2 for elem in list1]) #list 的映射解析
print([[x, x**2] for x in list1])

def _add_str(str):
    return str+'_add'
print([_add_str(add_str) for add_str in list2])

list_filter=[elem for elem in list1 if elem !=2]
print(list_filter)

list5=['One','Two','Three']
list6=[1,2,3]
print(["{0}-{1}".format(x,y) for x in list5 for y in list6])

print(["{0}-{1}".format(list5[i],list6[i]) for i in range(len(list5))])

print([str(i) for i in range(1, 6)])

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v,end=";")
print('')
for i in reversed(range(1, 10, 2)):
    print(i,end=';')
print('')
for i in sorted(range(1, 10, 2)):
    print(i,end=';')
print('')   
print([i for i in range(4)])

a = (i for i in range(4))
print(next(a))
print(next(a))
 
One:1
One:1
Two:2
Two:2
Three:3
Three:3
[2, 4, 6.0, 8, 10.0]
[[1, 1], [2, 4], [3.0, 9.0], [4, 16], [5.0, 25.0]]
['6_add', '7_add', '8_add', '8_add', '8_add']
[1, 3.0, 4, 5.0]
['One-1', 'One-2', 'One-3', 'Two-1', 'Two-2', 'Two-3', 'Three-1', 'Three-2', 'Three-3']
['One-1', 'Two-2', 'Three-3']
['1', '2', '3', '4', '5']
0 tic;1 tac;2 toe;
9;7;5;3;1;
1;3;5;7;9;
[0, 1, 2, 3]
0
1
 
列表加深学习
 
列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边#第一条语句是最后一层 
 [x*y for x in range[1,5] if x > 2 for y in range[1,4] if x < 3] 
 他的执行顺序是 
 for x in range[1,5] 
 #if x > 2 
 #for y in range[1,4] 
 #if x < 3 
 #x*y 
 
matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
print(matrix)
print([[row[i] for row in matrix] for i in range(4)])
transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
print(transposed)

#创建二维列表格式：list_2d = [[0 for col in range(cols)] for row in range(rows)]
list_2d = [ [0 for i in range(5)] for i in range(5)]  #创建
print(list_2d)
list_2d[0].append(3)
list_2d[0].append(5)
print(list_2d)

 
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[0, 0, 0, 0, 0, 3, 5], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
 
字典和元组交互
 
##列表与字典
params_dict={'One':1,'Two':2,'Three':3}
list_parse_dict=['%s=%s'%(k,v) for k,v in params_dict.items()]
print(list_parse_dict)
##列表与元组
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) #元组
tuple_to_list=list(tuple)
print(tuple_to_list)
 
['One=1', 'Two=2', 'Three=3']
['abcd', 786, 2.23, 'runoob', 70.2]
 
元组
 
元组与列表的区别，元组它的关键是不可变性，元组提供了一种完整的约束。 
 1.[注意]元组（tuple）与列表类似，不同之处在于元组的元素不能修改 
 2.元组写在小括号(())里，元素之间用逗号隔开 
 3.元组中的元素值是不允许修改的，但我们可以对元组进行连接组合 
 4.函数的返回值一般为一个。而函数返回多个值的时候，是以元组的方式返回的 
 
基本操作函数
 
tuple1 = ( '1', 'a' , 2.0, 'b', 3 )
#索引操作与列表一致
tuple0 = ()    # 空元组
tuple2 = (20,) # 一个元素，需要在元素后添加逗号
 
('abcd', 786, 2.23, 'runoob', 70.2)
 
集合
 
集合（set）是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素 
 1.可以使用大括号{}或者set()函数创建集合，注意：创建一个空集合必须用 set() 而不是{}，因为{}是用来创建一个空字典 
 
基本操作函数
 
set1 = {'One', 'One', 'Two', 'Two', 'Three', 'Four','Five'}
print(set1) #输出集合，重复的元素被自动去掉
if('One' in set1) :
    print('One在集合set1中')
#集合运算
set2=set('abracadabra')
set3=set('alacazam')
print(set2)
print(set2 - set3) # a和b的差集
print(set2 | set3) # a和b的并集
print(set2 & set3) # a和b的交集
print(set2 ^ set3) # a和b中不同时存在的元素

 
{'Two', 'One', 'Four', 'Five', 'Three'}
One在集合set1中
{'c', 'd', 'r', 'a', 'b'}
{'b', 'd', 'r'}
{'c', 'd', 'l', 'r', 'm', 'z', 'a', 'b'}
{'c', 'a'}
{'d', 'b', 'm', 'l', 'z', 'r'}
{'c', 'd', 'r', 'a', 'b'}
 
字典
 
d = {key1 : value1, key2 : value2 } 
 1.字典是无序的对象集合，列表是有序的对象结合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。 
 2.键(key)必须使用不可变类型。 
 3.管字典中有多少项，in操作符花费的时间都差不多 
 def example(d): 
 for c in d: 
 print(c) 
 其中：d 是一个字典对象 
 
基本操作函数
 
dict = {}
dict['One'] = 1
dict[2] = 'Two'
dict['Three']=3
dict['Five']=5
dict2={'ONE':1, 'TWO':2, 'THREE': 3}

print(dict)
print(dict2)
del dict['Five']
print(dict)

print(dict['One'])
print(dict.keys())
print(dict.values())
for k,v in dict2.items():
    print(k,":",v)
dict.clear() #清空字典
del dict #删除字典
type(dict2)

dict_pop_key,dcit_pop_value=dict2.popitem()
print('pop-{0}:{1}'.format(dict_pop_key,dcit_pop_value))#随机返回并删除字典中的一对键和值(一般删除末尾对)
for k, v in dict2.items():
    print(k, v,end=";")


dict4={2:'Two',3:'Three',1:'One'}
sorted(dict4.keys())
 
{'One': 1, 2: 'Two', 'Three': 3, 'Five': 5}
{'ONE': 1, 'TWO': 2, 'THREE': 3}
{'One': 1, 2: 'Two', 'Three': 3}
1
dict_keys(['One', 2, 'Three'])
dict_values([1, 'Two', 3])
ONE : 1
TWO : 2
THREE : 3
pop-THREE:3
ONE 1;TWO 2;




[1, 2, 3]
 
字典加深学习
 
#字典是支持无限极嵌套的
citys={
    '北京':{
        '朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
        '海淀':['圆明园','苏州街','中关村','北京大学'],
        '昌平':['沙河','南口','小汤山',],
        '怀柔':['桃花','梅花','大山'],
        '密云':['密云A','密云B','密云C']
    },
    '河北':{
        '石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
        '张家口':['张家口A','张家口B','张家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}
for i in citys['北京']:
    print(i)
print('-----------------------')
for i in citys['北京']['海淀']:
    print(i)
 
朝阳
海淀
昌平
怀柔
密云
-----------------------
圆明园
苏州街
中关村
北京大学
 
列表、元组、集合、字典相互转换
 
列表元组转其他
 
###列表转集合(去重)
list1 = [1,2,3,4]
print(set(list1))
#两个列表转字典
list1 = ['key1','key2','key3']
list2 = ['1','2','3']
print(dict(zip(list1,list2)))
#嵌套列表转字典
list3 = [['key1','value1'],['key2','value2'],['key3','value3']]
print(dict(list3))
# 列表、元组转字符串
list2 = ['a', 'a', 'b']
print(''.join(list2))
tup1 = ('a', 'a', 'b')
print(''.join(tup1))
 
{1, 2, 3, 4}
{'key1': '1', 'key2': '2', 'key3': '3'}
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
aab
aab
 
字典转其他
 
# 字典key和value互转
dic2 = {'a': 1, 'b': 2, 'c': 3}
print({value:key for key, value in dic2.items()})
 
{1: 'a', 2: 'b', 3: 'c'}
 
字符串转其他
 
# 字符串转列表
s = 'aabbcc'
print(list(s))
# 字符串转元组
print(tuple(s))
# 字符串转集合
print(set(s))
# 字符串转字典
dic = eval("{'name':'ljq', 'age':24}")
print(dic)
# 切分字符串
a = 'a b c'
a.split(' ')
 
['a', 'a', 'b', 'b', 'c', 'c']
('a', 'a', 'b', 'b', 'c', 'c')
{'b', 'a', 'c'}
{'name': 'ljq', 'age': 24}





['a', 'b', 'c']
 
辛苦总结:)，第一次写博客。如果写的好，请支持我下面的资源
 
pycharm工程python调用OpenCV实现USB摄像头实时人脸检测 
 http://download.csdn.net/download/zou19900101/10208407 
 pycharm工程pyQt5使用matplotlib绘图源码 
 http://download.csdn.net/download/zou19900101/10207077 
 pyqt5快速入门教程 
 http://download.csdn.net/download/zou19900101/10197371 
 Qt编写高逼格弹幕 
 http://download.csdn.net/download/zou19900101/10145524 
 Qt高仿360界面设计 
 http://download.csdn.net/download/zou19900101/10145518 
 Qt编写跨平台串口通信（Window+Linux） 
 http://download.csdn.net/download/zou19900101/10145513 
 OpenCV两种方法显示中文 
 http://download.csdn.net/download/zou19900101/10010181 
 wrote by zoushaoyuan 2018-01-19

理解Python中列表，元组，字典，集合的区别
 
列表，元组，字典，集合的区别是python面试中最常见的一个问题。这个问题虽然很基础，但确实能反映出面试者的基础水平。
 
1.列表（List）
 
什么是列表呢？我觉得列表就是我们日常生活中经常见到的清单。比如，统计过去一周我们买过的东西，把这些东西列出来，就是清单。
 由于我们买一种东西可能不止一次，所以清单中是允许有重复项的。如果我们扩大清单的范围，统计我们过去一周所有的花费情况，
 那么这也是一个清单，但这个清单里会有类别不同的项，比如我们买东西是一种花费，交水电费也是一种花费，这些项的类型是可以使不同的。
 python的列表个跟清单的道理是一样的，特点就是：可重复，类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示。
 
#定义一个列表
 listA = [‘a’, ‘b’, ‘c’, 1, 2]
 
listA[1] # ‘b’
 
向 list 中增加元素
 
1.使用append 向list 的末尾追加单个元素。(把列表当做堆栈使用——后进（后出）)
 
#listA = [‘a’, ‘b’, ‘c’, 1, 2, 3]
 listA.append(3)
 
2.使用 insert 将单个元素插入到list 中。数值参数是插入点的索引
 
在下标为3处插入一个元素，listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3]
 
listA.insert(3, ‘d’)
 
3.使用 extend 用来连接 list
 
listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3, 7, 8]
 
listA.extend([7, 8])
 
获取列表的长度
 
print len(listA) # 9
 
在 list 中搜索
 
listA.index(3) # index 在 list 中查找一个值的首次出现并返回索引值。
 listA.index(‘100’) # 如果在 list 中没有找到值，Python 会引发一个异常。
 
print 5 in listA # 要测试一个值是否在 list 内，使用 in。如果值存在，它返回 True，否则返为 False 。
 
从 list 中删除元素
 
listA.remove(3) # remove 从 list 中 仅仅 删除一个值的首次出现。如果在 list 中没有找到值，Python 会引发一个异常
 
print listA.pop() # pop 它会做两件事：删除 list 的最后一个元素，然后返回删除元素的值。(把列表当做堆栈使用——（后进）后出)
 
还有一种把列表当做队列使用，最先进入的元素最先释放（先进先出）
 
不过，列表这样用效率不高。相对来说从列表末尾添加和弹出很快；
 
在头部插入和弹出很慢（因为，为了一个元素，要移动整个列表中的所有元素）。
 
遍历list
 
for item in listA:
 print item
 
extend (扩展) 与 append (追加) 的看起来类似，但实际上完全不同。
 
extend 接受一个参数，这个参数总是一个 list，并且把这个 list 中的每个元素添加到原 list 中。
 append 接受一个参数，这个参数可以是任何数据类型，并且简单地追加到 list 的尾部。
 
2.元组(Tuple)
 
元组和列表在结构上没有什么区别，唯一的差异在于元组是只读的，不能修改。元组用“()”表示
 
#定义一个元组
 tuple1 = (1,2,‘a’,4,‘5’,6)
 
定义了一个元组之后就无法再添加或修改元组中的元素
 
print tuple1[2] # ‘a’ 元组的元素都有确定的顺序。元组的索引也是以0为基点的
 print tuple1[-1] # ‘5’ 负的索引从元组的尾部开始计数
 print tuple1[1:3] # (2, ‘a’) 元组也可以进行切片操作。对元组切片可以得到（返回）新的元组，原元组不变
 
可以使用 in 运算符检查某元素是否存在于元组中。
 
print 1 in tuple1 # True
 
#使用for in 进行遍历元组
 for item in tuple1:
 print item
 
如果需要获取item的序号 可以使用下面的遍历方法：
 
for index in range(len(tuple1)): #range(len(tuple1))就是生成一个自然排序列表
 print tuple1[index]
 
还可以使用内置的enumerate函数
 
for index, item in enumerate(tuple1):
 print ‘%i, %s’ % (index, item)
 
3.字典(Dictionary)
 
字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。 Python 中的 dictionary 像 Java 中的 Hashtable 类的实例。定义 Dictionary 使用一对大(花)括号” { } “
 
Dictionary 不只是用于存储字符串。Dictionary 的值可以是任意数据类型，包括字符串、整数、对象，甚至其它的 dictionary。
 在单个 dictionary 里，dictionary 的值并不需要全都是同一数据类型，可以根据需要混用和匹配。
 
定义一个字典
 
dict1 = {‘name’ : ‘yeoman’, ‘age’ : 24, ‘sex’ : ‘Male’}
 
dict1[‘name’] = ‘yuanm’ # 为一个已经存在的 dictionary key 赋值，将简单覆盖原有的值。
 dict1[‘Age’] = 25 # 在 Python 中是区分大小写的 age和Age是完全不同的两个key
 
从字典中删除元素
 
del dict1[‘sex’] # del 允许您使用 key 从一个 dictionary 中删除独立的元素
 
dict1.clear() # clear 从一个 dictionary 中清除所有元素
 
4.集合（Set）
 
Python的集合(set)和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.
 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.由于集合是无序的,所以，sets 不支持 索引, 分片, 或其它类序列（sequence-like）的操作。
 
集合也存在不可变形式,frozenset为固定集合.
 set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
 注意：想要创建空集合，你必须使用 set() 而不是 {} ，后者用于创建空字典
 可以通过一个set函数转换成集合，如：
 
lst = [ 1, 1, 0]
 
lst_set = set( lst ) #lst_set 为1 , 0
 
tup = (2, 2, 1)
 
tup_set = set( tup) # tup_set为2 , 1
 
for item in lst_set:
 print item
 
使用 set 函数创建集合
 
list1 = [6, 7, 7, 8, 8, 9]
 set2 = set(list1)
 
set2.add(10) # 添加新元素
 print set2 # set([8, 9, 10, 6, 7]) 去掉重复内容,而且是无序的
 
set3 = frozenset(list1)
 #set3.add(10) # 固定集合不能添加元素，会报错AttributeError: ‘frozenset’ object has no attribute ‘add’
 
集合有并集，交集，求差操作
 
a & b 并集：intersection() 方法返回一个新集合，包含在两个集合中同时出现的所有元素。
 
a | b 交集：union() 方法返回一个新集合，包含在两个 集合中出现的元素。
 
a - b 差集：difference() 方法返回的新集合中，包含所有在 集合A出现但未在集合B中的元素。
 
a ^ b 对称差集：symmetric_difference() 方法返回一个新集合，包含所有只在其中一个集合中出现的元素。
 
删除元素
 
set2.discard(6) # 当元素不存在时,不会引发异常
 set2.remove(6) # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常
 set2.pop() # 因为set是无序的，所以pop会随机的从set中删除一个元素