Python--数据结构

元组，创建方式一组以逗号隔开的值

a = 3,4,5
print a
#所以明显print加上逗号隔开的值并不是元组，而只是打印分隔符
print 3,4,5```
#创建元组的元组

nested_tup = (1,2,3),(4,6)
print nested_tup

调用tuple()函数将所有序列或者迭代器转换成元组

print tuple([3,4,2])
print tuple('strings')```

索引元组

print nested_tup[1][1]
#元组是不可变的，但是如果在元组插槽中的元素是可变的，也可以修改其中的可变对象，比如这样
tup = tuple(['foo',[1,2],True])
print tup
#第2个元素是个列表可变，所以可以修改列表中的元素，比如这样
tup[1].append(3)
print tup```
#元组通过加号进行产生更长的元组

对于只有一个元素的元组，必须在该元素后面加上逗号，明确表示是元组，否则就可能按其本身的数据类型进行处理了

print (3,None,'foo')+(6,0)+('bar',)

对元组乘以以个整数，相当于连接该元组的多个副本

print (3,None,'foo')*3```

元组拆包

tup = (4,5,6)
a,b,c=tup
print a,b,c
#嵌套元组也能解包
tup = (4,5,(6,7))
a,b,(c,d)=tup
print a,b,c,d
#利用解包实现数据交换
a = 5;b = 4;print a,b
a,b = b,a;print a,b
#利用解包进行迭代,对由元组或者列表组成的序列进行迭代
seq = ((1,2,3),(4,5,6),(7,8,9))
for a,b,c in seq:
    print a,b,c
#元组方法，count(),计算参数的出现次数,只能统计第一层元素出现多少次，不能具体到底层
print seq.count(1)```

#列表，序列包括，列表，元组，还有字符串，只有列表是可变的

list()函数将序列类型转换成列表

a_list = [2,3,4,None]
print a_list,list(tup),list("strings")

append()方法

a_list.append("love")

insert()方法把元素插入到指定位置

a_list.insert(4,"i")

pop()方法移除并且返回指定索引处的元素

a_list.pop(3)

remove()方法找到第一个符合要求的值并从列表删除

a_list.remove(4)

in操作符判断列表中是否含有某个值

print 4 in a_list
print a_list```

列表的合并+和extend()方法

b_list = [7,8,(2,3)]
x = [4,None,'foo']
#a.extend()调用后返回值是一个None，所以必须调用a才能显示extend()方法执行后的效果
a_list.extend([4,None,'foo'])
print a_list + b_list,a_list
#+代表的列表合并是新建一个新列表然后赋值的操作，而extend()方法是原地进行操作的，效率会好一点
#排序，sort()方法
a = [1,4,3,5,(8,6)]
#利用reverse参数，指明反向排序
a.sort(reverse=True)
#sort()方法是原地排序操作，直接改变原始的序列
print a
b = ["love","i",'you']
b.sort(key=len)
print b```

#序列的切片操作

确定传入[]的start和stop

seq = [7,2,4,5,32,6,4,7]

没有传入start或者stop的就默认从序列起始或者结束算起

print seq[1:3],seq[:5],seq[3:]
print seq[-4:],seq[-6:-2]

如果左侧元素出现比右边元素晚的话，返回空序列

print seq[-4:-5]

加上步长,实现反序

print seq[::-1],seq[3::-1]```

内置序列函数

#enumerate()函数返回序列的索引和对应索引的值
some = ["a","b","c"]
for i,value in enumerate(some):
    print "It's ",str(i),"and the value is ",value
#enumerate()还可以求取一个将序列值映射到其所在位置的字典(假定序列值是唯一的，这样字典的键才能是唯一的)
some_list = ["foo","bar","baz"]
#一个推导式
mapping = dict((v,i) for i,v in enumerate(some_list))
print mapping```

#sorted()函数

将任何序列返回一个新的有序列表，但是原列表不发生变化，但是列表的sort()方法会原地对列表进行排序

sort_some_list = sorted(some_list)
print sort_some_list,some_list,sorted("horse race")

使用sorted()函数与set结合起来得到一个由序列中唯一元素组成的有序列表

print sorted(set("this is just some string"))```

zip()函数将多个序列的元素进行配对，产生一个新序列

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
print zip(seq1,seq2)
#zip()可以接受任意数量的序列，最终得到的元组数量由最短的序列决定
#常见用法是同时迭代多个序列，结合enumerate()函数使用,典型的序列解包的应用
for i,(a,b) in enumerate(zip(seq1,seq2)):
    print ('%d: %s %s' %(i,a,b))
#对已经压缩的序列，zip()对该序列进行解压，其实是将一组行转换为一组列
pitcher = zip(seq1,seq2)
#*说明参数要传入一个元组，元组包含两个元素，因此就是把pitcher[1]作为参数传入zip了，然后zip的作用是结合产生新序列，与first和last相对应
first,last = zip(*pitcher)
print first,last```

#reversed()函数用于得到一个序列的逆序，返回一个迭代器

使用list()函数将迭代器类型转换为列表

xiter = reversed(range(10))
for i in xiter:
print "it's ",str(i)
print type(xiter)

为什么迭代之后就变成空列表了,迭代迭代器的作用就是延迟生成值，

使用for已经把迭代器迭代完了，所以肯定之后再使用这个迭代器,list()的话，就是空的

print list(xiter)```

字典

#创建字典
d1 = {'a':'some value','b':[1,2,3,4]}
#使用键来索引字典对应的值
d1[7] = 'use integer as key'
print d1,d1['a'],d1['b'],d1[7]
#判断字典中是否存在某个键
print 'b' in d1,d1.has_key('b')
#使用del关键字或者pop方法(删除指定值后把值返回)
d1['dummy'] = "it's fun"
del(d1['dummy'])
d1['pop'] = 'testing pop'
ret = d1.pop('pop')
print d1,ret
#keys()和values()方法分别按对应顺序返回键和值
print d1.keys()," and ",d1.values()
#使用update()方法将一个字典合并到另外一个字典上,原来如果有相同的键将其覆盖，若没有建立新的键值对
d1.update({'b':'it is b','c':"it is c"})
print d1```

#从序列类型创建字典

mapping = {}
for key,value in zip(range(10),reversed(range(10))):
mapping[key] = value
print mapping

使用更加简单的方法创建字典，dict()函数,接受一个二元的列表或者元组作为键值对

mapping = dict(zip(range(5),reversed(range(5))))
print mapping```

字典的get()方法和pop()方法

#如果可以得到key为a的值，则返回该值，否则返回None这个自定义默认值
value = mapping.get("a",None)
popvalue = mapping.pop("a",None)
print value,popvalue
#根据首字母对一组单词进行分类并且最终产生一个由列表组成的字典
words = ['apple','bat','bar','atom','book']
by_letter = {}
for word in words:
    letter = word[0]
    #如果by_letter中含有Letter这个键
    if letter in by_letter:
        by_letter[letter].append(word)
    else:
        #每个键对应的是一个列表
        by_letter[letter] = [word]
print by_letter```

#上述程序代码可以使用setdefault()方法实现

by_letters = {}

#这样不可以，必须得给第一次出现的键对应一个默认列表，要不无法append()

for word in words:

by_letters[word[0]].append(word)

print by_letters

所以就可以这样干,创建新键的时候赋予一个默认列表，同时将word，append()进去，

然后如果是已经存在的键，就返回对应的值，也是个列表，将最新的word用append()

for word in words:
by_letters.setdefault(word[0],[]).append(word)
print words

字典的键必须是不可变对象，利用是否可哈希来检测是否可以当成字典的键

hash("string")#可哈希，成功

hash([1,2,3])#不可哈希，失败

如果要把列表当成键，那么可以将其转化为元组

by_letters[tuple([1,3,2])] = "list transferred to tuple"
print by_letters```

集合，是由唯一元素组成的无序集

#创建方法
a = set("strings is a sequence")
# or a = set([1,2,3,4])
b = {1,2,3,4,5}
print a,b
#判断是否子集或者超集
print {1,3,4}.issubset(b), "and ",b.issuperset({1,3,4})
#如果两个集合的内容相等，那么集合就是相等的
print {1,3,4} == {1,4,3}```

#列表推导式

一个经典的例子

strings = ['a','as','bat','car','dove','python']
print [string.upper() for string in strings if len(string) > 2]

集合推导式，建立上述字符串的字符串长度的集合

print {len(string) for string in strings}

字典推导式，为字符串建立一个指向其列表索引位置的映射关系

print {val:index for index,val in enumerate(strings)}

另外一个实现版本,dict()函数接受参数为一个(key,value)的键值对，无论是元组还是列表还是字典

print dict((val,idx) for idx,val in enumerate(strings))```

嵌套的列表推导式

all_data = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
            ['Susie','Casey','Jill','Ana','Eva','Jennifer','Stephanie']]
#将名字中含有两个e的名字找出来
#初始化存储找到名字的列表
name_interested = []
for names in all_data:
    #因为是嵌套列表，所以嵌套循环，分别处理两个列表
    for name in names:
        if name.count('e') >= 2:
            name_interested.append(name)
print name_interested
#使用一个列表推导式
name_interested = []
for names in all_data:
    need_name = [name for name in names if name.count('e') >= 2]
    # name_interested.append(need_name)
    #使用extend而不是append是因为extend扩展列表去掉嵌套列表，从而使生成的列表扁平化
    name_interested.extend(need_name)
print name_interested
#使用嵌套的列表推导式
#太精简了！
result = [name for names in all_data for name in names if name.count('e') >= 2]
print result
#扁平化一个嵌套的元组列表
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
flattened = [x for tuple in some_tuples for x in tuple]
print flattened

flattened = []
for tup in some_tuples:
    result = [x for x in tup]
    flattened.extend(result)
print flattened
#下面这种写法只能是把嵌套的元组变成了嵌套的列表
print [[x for x in tup] for tup in some_tuples]```