python学习笔记系列----（三）数据结构

    这一章主要是介绍了python一些常用的数据结构，比如list，tuple，dictionary，set，以及一些实用遍历技巧，主要讲的还是list。

3.1 list

     主要介绍了list的一些常用的使用函数。这里就不多说和举例了。

     增加：append(),insert()

     删除：pop(),remove()，del()

     查找：index()

     其他：计算item出现次数：count()；item排序：sort()；item逆序：reverse()

     其中del()较为特殊，可以根据index删除特定元素，也可以删除list内的部分切片，也可以删除整个list

3.1.1 使用list作为栈

     把list当作c++的数据结构栈（先进后出）来使用，主要还是因为list提供了2个函数：append()和pop()，append()是在list的最后一个元素后增加新元素，而pop()是返回list最后一个元素，然后删除原list中的该元素。

     list的增加和删除操作都对应有2个方法，但是append()和pop()的性能要高很多(少移动)。

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack
[3, 4, 5, 6]

3.1.2 使用list作为队列

   把list当成队列（先进先出）来使用也是可以的，但是需要引入deque类，转换成该类后使用其方法就能实现

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")          
>>> queue.popleft()                 
'Eric'
>>> queue                          
deque(['John', 'Michael', 'Terry'])

3.1.3 函数编程工具

   主要介绍与list一起使用时非常有用的3个内置函数： filter(), map(), and reduce().

    filter(function, sequence)返回的是一个序列，这个序列里的每一个值在function中都能返回ture。这个sequence不仅仅包含list类型，还可以是str或者是tuple类型或者其他类型；如果是str或者tuple，就返回str或者tuple，但是如果是list或者其他，就返回list类型。

    map(function, sequence)也是返回一个序列，这个序列里的每一个值都在function中进行过计算。

    reduce(function, sequence) 返回则是一个单一的数值，它首先以序列的前两个元素调用函数 function，然后再以返回的结果和下一个元素继续调用，依此执行下去。

>>> def f(x): return x % 3 == 0 or x % 5 == 0
...
>>> filter(f, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]
>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

    实际上，filter(),map(),reduce()都是内置的标准库，内置标准库里到底包含哪些类和方法呢？可以使用dir(__builtin__)来得知，如果想知道其中一个方法的官网的解释，打印出help(方法名)就可以了，下面是个示例：

# -*- coding: utf-8 -*-
import __builtin__

if __name__=="__main__":

    print dir(__builtin__)
    print help(map)

 其运行后部分结果，截图如下：

 

3.1.4 列表推导式

      这个翻译感觉怪怪的，阅读完整篇感觉就是怎么产生一个新的list？比如从一个list演变成另一个list，两个list的各种组合成一个新的list等等。实际上感觉部分复杂的可用用前面那3个工具代替可能能更好理解。

比如，产生一个列表，其值为0-9的平方，有3种实现方式：

    # 方式1
    list1 = []
    for i in range(0,10):
        list1.append(i**2)

    #方式2
    def square(i):
        return i**2
    list2 = map(square,range(0,10))

    #方式3
    list3 = [i**2 for i in range(0,10)]

       第三种就是这小节讲的重点，顿时~~还有一种两个list之间的组合，测试可能经常会使用到，比如list1=[1,2,3]，list2=[3,1,4] ,现在得到不同列表元素内不同值的组合列表,有2种实现方式：

    # 方式1
    for x in list1:
        for y in list2:
            if x != y:
                list3.append((x,y))

    # 方式2
    list4 = [(x,y) for x in list1 for y in list2 if x!=y]

       最后介绍了list的嵌套推导式，可以理解就是list的嵌套循环使用。如下例子所示，list1是一个二位数组，现把每列的第一个数放第一个list内，第二个放第二个list内...

    list1 =[[1, 2, 3], [4, 5, 6],[7, 8, 9]]
    list3=[]

    # 方式1
    for row in list1:
        list2 = []
        for i in range(0,3):
            list2.append(row[i])
        list3.append(list2)
    # 方式2
    list3 = [[row[i] for row in list1]for i in range(0,3)]

    # 方式3
    list3 = zip(*list1)

3.2 tuple

     tuple的基本函数使用跟list有点类似，但是它又有自己的特点：

     A. tuple 是不可变类型，一个已定义的tuple类型，企图去改变其内的值，会报错；

     B. 定义空的tuple使用语句：emptytuple = ()

     C. 定义只有一个元素的tuple使用语句：singletuple ='hello', (逗号不能漏掉，漏掉则视为一个str类型）

3.3 set 

     set类型的要求就是集合内没有重复的元素，可以从list类型使用set()转变成set类型，与其他的sequence 类型的区别是，可以对set类数据进行“取交集，差集，并集”等操作。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True

>>> a = set('abracadabra')
>>> b = set('alacazam')>>> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])

3.4 dictionary 

   dictionary与list这些sequences类（list，tuple）不同在于，它可以根据key来进行索引，key必须是唯一且不可变的值，比如number类和str类的，tuple类（不包含可变元素）就可以做key，但是list就不能做key。key()方法返回的就是这个dictionary 的所有key值，sorted()就是根据key进行排序，对dictionary 进行遍历实际是对key值进行遍历操作（顺序不确定）。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

3.5 常用的遍历技巧

1. 对sequence类型数据进行遍历，如果需要输出每个元素的下标，可以使用enumerate()函数：

    list1 = ['loleina', 'test']

    for i,item in enumerate(list1):
        print i,item

2. 倒序一个sequence，可以使用 reversed() 方法。

    for i in reversed(list1):
        print i

实际上，list1还是顺序的呢~~

3. 对sequence排序后输出，使用sorted()方法

    list2 = [1, 2, 4, 0]
    for i in sorted(list2):
        print i

4. 对字典进行遍历，同时输出key，和value，使用iteritems()方法

    dictionary1 = {'name': 'loleina', 'age': 20}
    for key,value in dictionary1.iteritems():
        print key,value

      当需要循环遍历一个list，且要改变一个list的时候，最好是在循环里创建一个新的list，上述的例子中倒序一个list或者是排序，实际上是对list的副本进行了操作，list本事并没有发生改变，如果希望list本身发生改变，可以用以下方法：

    list2 = [1, 2, 4, 0]
    list3=[]
    for i in reversed(list2):
        list3.append(i)
    list2 = list3