Python基础（二）集合

什么是集合？ 

　　集合是指包含一组元素的数据结构。

　　　　1、有序集合 list、tuple、 str 、unicode

　　　　2、无序集合 set

　　　　3、无序集合且具有 key-value 对：dict

      　

（一）list

　　 list 是一种有序的集合，可以随时添加和删除其中的元素。

　　（1）创建

　　 　　使用 []  将所有的元素包裹起来，便是一个list集合。

       　　students = ['jack','Tom','herry']

　　（2）访问

　　　　　list索引是从0开始的，因为可以 list[index] 获取某个值。

　　   　　但是 索引可以是负数， -1 表示最后一位，依次类推，使用这个特性，可以很方便的拿到最后几个元素的值。

L = ['Adam', 'Lisa', 'Bart']
firstItem=L[0]
L[0]='Jack'  #替换第一个元素

　　　　　值得注意的是，索引不能越界。

　　 （3）添加新元素

　　　 　　list.append(item)       　　将元素item添加至list末尾

　　　　　 list.insert(index,item) 　　将元素item添加到索引为index的位置上，后面的所有元素都自动向后移动一位。

L = ['Adam', 'Lisa', 'Bart']
L.insert(2,'Paul')

　　　　　 L结果为 ['Adam', 'Lisa', 'Paul', 'Bart']

　　 （4）删除元素　　

　　　　　  list.pop() 　　 　　删除list最后一个元素

　　　　     list.pop(index) 　　删除索引为 index 的元素。

　　　　　  注意：如果连续删除元素，元素的索引也将跟着发生变化。

L = ['Adam', 'Lisa', 'Paul', 'Bart']
L.pop(2)
L.pop(2)

　　　　　　L结果为 ['Adam', 'Lisa']

　　（5）截取元素

　　　　  获得某个范围内的元素。

　　　　  list[ startIndex : endIndex : 间隔值]

　　　　  其中间隔值是可选参数。

　　　　  startIndex,endIndex 可以为负值，倒数第一个元素的索引是-1。

　　　　  倒序取值 包含起始索引，不包含结束索引。

L[:] #从头到尾
L[::2] #隔两个元素取值
L[:3]  #从开始取值，取3个元素

 

（二）tuple

　　   元组，有序列表集合。

　　　特点：创建成功后，每个元素，指向的地址永远不变。　　   

　　 （1）创建

　　　　 使用  ()  包裹元素。

t = (0,1,2,3,4,5,6,7,8,9)
firstItem=t[0]

　    （2）修改元素  

　　　　tuple的每个元素，指向永远不变；而指向的元素本身是可以变的。

　　     元素本身是复杂类型，则都可以改变其值。如下：

t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0]='a change to c'　 　

　　　 如果是简单类型，如下：

t=(1,2,3,4,5,6,7)
t[0]=88

　　   则会抛出异常： 

　　　　　　'tuple' object does not support item assignment

　　（3）创建单元素tuple.

t = ('Adam',) #不能使用 t=('adam'),否则返回的是字符串  'adam'

　　

（三）dict

　  （1）创建

　    　　dict 是以

　　　　　　{

　　　　　　　　key1:value1，

　　　　　　　　key2:value2 ...

　　      　　} 形式保存数据的一种集合形式。

　　  　　使用 len(dict) 可以计算集合的大小。

　　  　　特点：

　　　　　　1、查找速度快，不会随着数据的增加而查找速度降低，因此，导致占用内存大。

　　　　　　2、存储的key-value序对是没有顺序的，在不同的机器打印的顺序可能不同。

　　　　　　3、key的元素的数据类型必须不可变（字符串、整数、浮点数不可变）。

　　（2) 取值 、更新、新增

　　       1、  if key in dict:

　　　　　　　  return dict[key]

   　　　 2、 dict.get(key)

　　　　 3、 dict[key]=value; 如果有key就是更新，否则便是 新增。

        (3) 遍历

　　　　 遍历key值：

　　　　　　使用 for ... in ..  遍历所有的key　　

　　　　　　for key in dict :

　　　　　　　　print key,'---',d[key]

　　　　  遍历 value 值：

 　　　　     for value in dict.values():

　　　　　　　　print value

dicts={ 'one':'1','two':'2' }
print dicts.values()

　　　　  　　结果是 ：['2', '1']

　　　　  　　dict.values() 将 dict 转换成一个包含所有value的list，因此需要额外的内存开销。

　　　　  　　因此，可以使用另外一种方法  dict.itervalues() 方法,该方法不需要转换为list。

　　　　 同时遍历 key,value

for k, v in d.items():
    print k,':',v

　　      与 .itervalues() 类似， items() 也有一个对应的 iteritems()，相对 .items() 不需要额外的内存。

（四）set

　　　　（1）创建set

　　   　　　　set也是集合的一种，存储的数据没有重复，且无序。

　　  　　　　 内部结构和dict很像，不需要存储value，因此，查找速度较快。

　　   　　　　key元素的类型必须是不变的对象。任何可变的对象不能放入set中。

　　　　　　　调用set()函数，传入list，便成功创建了一个set。

set1 = set( ['jack','Tom','Herrry'])　　　

　　　　 　　 因为set 不能包含重复的元素，所以，当我们传入重复的元素时，会自动去掉重复的元素。

　　　　　　（2）访问 set

　　　　　　　　由于set存储的是无序集合，因为无法通过索引来访问。

　　　　　　　　因此 只能通过 value in set 获取返回的True或False 进行判断。　　　 

     　　　　   (3)  新增与删除

　　　　　　　　添加元素，使用 set1.add(value)

　　　　　　　　删除元素，使用 set1.remove(value),如果不存在，删除时会报错。因此，需判断。

for item in L:
    if item in s :
       s.remove(item)
    else:
        s.add(item)

（五）集合的遍历 

　　    （1）无论是有序还是无序，都能够使用 for...in 来完成遍历取值，称之为 迭代。

　　　 （2）有序集合的索引迭代

　　　　　　迭代永远取出元素本身，而非元素的索引。

　　　　　　为了获取索引，我们可以使用 enumerate(有序集合)函数

for index,value in enumerate(L):
    print index, '-',value

　　　　　　其实，emumerate() 函数就是将集合的每个 对象转换成（index，value）形式的 tuple。如下可以验证。

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for item in enumerate(L):
    print item

　　　　　　打印出的值如下：

(0, 'Adam')
(1, 'Lisa')
(2, 'Bart')
(3, 'Paul')