列表类型也是序列式的数据类型。和字符串类型一样，可以通过下标或者切片操作来访问一个或者一段连续的元素。不同的是，字符串是不可变的，而列表具有可变容器的特性，使用起来比较灵活，列表容器的元素的数据类型可以是任意类型。

列表(list)

列表类型也是序列式的数据类型。和字符串类型一样，可以通过下标或者切片操作来访问一个或者一段连续的元素。不同的是，字符串是不可变的，而列表具有可变容器的特性，列表可以添加或者删除元素，此外列表类型的元素还可以是任意类型组合的。

列表的创建

创建一个列表比较简单，和创建一个字符串是类似的，只不过列表是由([])来定义的，元素类型可以是整形，浮点型，字符串，甚至还可以是列表。

>>> aList = ['abc',123,4.56,['xyz',789,-28]]
>>> aList
['abc', 123, 4.56, ['xyz', 789, -28]]

列表的访问

列表的访问和字符串的访问方法是一样的，都可以通过下标或者切片操作来访问一个或者一段连续的数据元素。

>>> aList = ['abc',123,4.56,['xyz',789,-28]]
>>> aList[3]
['xyz', 789, -28]
>>> aList[0:3]
['abc', 123, 4.56]
>>> aList[3][2]
-28

列表的更新

与字符串不同的是，列表具有可变性，所以，列表可以更新某一元素的值，还可以通过append()或者insert()方法来添加新的元素到列表中，同样地，可以通过pop()或remove()方法删除某一元素。

• list.append(x)方法是把一个元素添加到链表的结尾
• list.insert(index,x)方法是在指定位置插入一个元素
• list.remove(x)方法是删除列表中值为x的元素
• list.pop([index])方法是删除列表中索引为index的元素

代码：

>>> aList = ['abc',123,4.56,['xyz',789,-28]]
>>> aList[0] = 'lmn'
>>> aList
['lmn', 123, 4.56, ['xyz', 789, -28]]
>>> aList.append('abc')
>>> aList
['lmn', 123, 4.56, ['xyz', 789, -28], 'abc']
>>> aList.remove('lmn')
>>> aList
[123, 4.56, ['xyz', 789, -28], 'abc']
>>> aList.pop(0)
123
>>> aList
[4.56, ['xyz', 789, -28], 'abc']

注意：pop()方法和remove()方法不同之处在于pop()方法是通过列表的索引进行删除元素并且返回删除的元素值，而remove()是直接删除一个元素值得。

列表类型操作符

因为列表是属于序列的一类，所以序列中常见的操作符（成员关系操作符（in 、not in）、连接操作符（+）、重复操作符（*）、切片操作符（[]、[:]、[::]））都适用于字符串。

列表解析

列表除了常见的序列类型的操作符之外，列表拥有只属于自己的方法——列表解析。列表解析来自于函数式编程Haskell。它是一种非常有用、简单、而且灵活的工具，可以用来动态地创建列表。

因为Python支持函数式编程特性，所以类似map()、filter()、reduce()之类的方法可以通过列表解析，简化成一个列表解析式子。

列表解析的语法：

[expr for iter_var in iterable]

该语法的核心在于for循环，它迭代iterable对象的所有条目，expr应用于序列的每个成员，最后的结果值应该是该表达式产生的列表。

# 求0-9的平方和
>>> [x ** 2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

此外，还有一个类似的拓展版本较为常用 [expr for iter_var in iterable if cond_expr]

# 求0-9的平方和为偶数的数值
>>> [x ** 2 for x in range(10) if x % 2 == 0]
[0, 4, 16, 36, 64]

常用函数式编程工具

• filter(function,sequence)方法是返回一个sequence(序列)，包括了给定序列中所有调用function(item)后返回值为true的元素。

代码：

>>> def div_3_or_div_5(x):
    return x % 3 == 0 or x % 5 == 0

>>> filter(div_3_or_div_5,range(0,21))
[0, 3, 5, 6, 9, 10, 12, 15, 18, 20]

• map(function,sequence)方法是为每一个元素调用function(item)并将返回值组成一个新的列表返回。

代码：

>>> def cube(x):
    return x * x * x

>>> map(cube,range(0,4))
[0, 1, 8, 27]

• reduce(function,sequence)方法是返回一个单值，他的构造方法是：首先以序列的前两个元素调用函数function，再以返回值和第三个参数调用，依次下去。

代码：

>>> def sum(seq):
        def add(x, y):
            return x + y
        return reduce(add, seq, 0)

>>> sum(range(1,101))
5050

内建函数

对于cmp()、len()、max()、min()、enumerate()以及zip()方法和字符串中的使用相同，在这里就不做具体说明了。

序列类型函数

sorted()方法可以实现以ASCII码值大小来排序列表中的成员。

>>> aList = ['cool','is','Python']
>>> sorted(aList)
['Python', 'cool', 'is']

reversed()方法可以实现列表的反转。

>>> aList = ['cool','is','Python']
>>> for x in reversed(alist):
    print x,


Python is cool

列表类型的内建函数

• list.append(x)方法是把一个元素添加到链表的结尾
• list.insert(index,x)方法是在指定位置插入一个元素
• list.remove(x)方法是删除列表中值为x的元素
• list.pop([index])方法是删除列表中索引为index的元素
• list.count(obj)返回一个对象在列表中出现的次数
• list.extend(seq)把序列seq的内容添加到列表中
• list.reverse()原地反转列表
• list.sort(func=None,key=None,reverse=False)以指定的方式排序列表中的成员，如果func和key参数指定，则按照指定的方式比较各个元素，如果reverse标志置为True，则列表以反序排列。

列表的特殊特性

因为列表是有容器和可变的特性，所以我们经常用它来创建Python数据结构中的堆栈和队列。

堆栈的实现

堆栈的实现方式主要为“先进后出”，类似于我们清洗饭后的碗碟。

源代码：

class Stack():
    def __init__(self,size):
        self.list = []
        self.size = size
        self.top = -1
    def _Full(self):
        if self.top == self.size - 1:
            return True
        else:
            return False
    def _Empty(self):
        if self.top == -1:
            return True
        else:
            return False
    def instack(self,_list):
        if self._Full():
            print 'The stack is Full.'
        else:
            self.list.append(_list)
            self.top = self.top + 1
    def outstack(self):
        if self._Empty():
            print 'The stack is empty.!'
        else:
            self.list.pop()
            self.top = self.top - 1
# test

s = Stack(10)
print s._Full()
print s._Empty()
for i in range(10):
    s.instack(i)
print s._Full()
for i in range(10):
    s.outstack()
print s._Empty()

队列的实现

队列的实现方式主要为“先进先出”，类似于我们生活中排队。

源代码：

class Queue():
    def __init__(self,size):
        self.list = []
        self.size = size
        self.front = -1
        self.rear = -1
    def _Empty(self):
        if self.front == self.rear:
            return True
        else:
            return False
    def _Full(self):
        if self.rear - self.front + 1 == self.size:
            return True
        else:
            return False
    def inqueue(self,_list):
        if self._Full():
            print 'The Queue is full.'
        else:
            self.list.append(_list)
            self.rear = self.rear + 1
    def outqueue(self):
        if self._Empty():
            print 'The Queue is empty.'
        else:
            self.list.pop()
            self.front = self.front + 1
#test

q = Queue(10)
print q._Empty()
print q._Full()
for i in range(10):
    q.inqueue(i)
print q._Full()
for i in range(10):
    q.outqueue()
print q._Empty()

堆栈和队列的容器均之所以选择列表list，而不选择元组tuple,主要是因为列表具有可以进行动态修改，元组不允许修改。