列表（list）类型是用来储存有序列表的。
先举一个例子吧：金庸小说《射雕英雄传》里的江南七怪，老大是柯镇恶（Ke Zhene），老二是朱聪（Zhu Cong），老三是南希仁（Nan Xiren），老四是韩宝驹（Han Baoju），老五是张阿生（Zhang Asheng）、老六是全金发（Quan Jinfa）、老七是韩小莹（Han Xiaoying）。
如若想把他们的名字按顺序存储到python变量中，按之前学的知识，则如下：
name1 = "Ke Zhene" name2 = "Zhu Cong" name3 = "Nan Xiren" name4 = "Han Baoju" name5 = "Zhang Asheng" name6 = "Quan Jinfa" name7 = "Han Xiaoying"
虽然这只是7个变量，但是已然显得不够唯美。因此，更好的方式是用列表（list）类型，可以将上述所有内容存储到指定的1个列表变量中即可；如下所示使用中括号[ 列表项1, 列表项2, ... ]的方式来构建一个有序队列，即列表（list）对象：
names = [ "Ke Zhene", "Zhu Cong", "Nan Xiren", "Han Baoju", "Zhang Asheng", "Quan Jinfa", "Han Xiaoying" ]
该列表对象若用示意图来表示，则如下所示。
如上所示，变量names是一个列表对象，该列表的第一项是字符串对象"Ke Zhene"，其索引为0；第二项是字符串对象"Zhu Cong"，其索引为1；剩下的皆可以此类推。若想获取names变量指定项的内容，则可在names变量后的方括号里放上该项的索引：
>>> names = [ "Ke Zhene", "Zhu Cong", "Nan Xiren", "Han Baoju", "Zhang Asheng", "Quan Jinfa", "Han Xiaoying" ] >>> names[0] 'Ke Zhene' >>> names[1] 'Zhu Cong'
列表的索引可以为负数，-1就代表倒数第一个，-2就代表倒数第二个，依此类推。
>>> names = [ "Ke Zhene", "Zhu Cong", "Nan Xiren", "Han Baoju", "Zhang Asheng", "Quan Jinfa", "Han Xiaoying" ] >>> names[-1] 'Han Xiaoying' >>> names[-2] 'Quan Jinfa'
在python中，列表的索引不可以超出边界，否则会报错的。
>>> names = [ "Ke Zhene", "Zhu Cong", "Nan Xiren", "Han Baoju", "Zhang Asheng", "Quan Jinfa", "Han Xiaoying" ] >>> names[72] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range
在python中，列表可以为空，即列表长度为零；如下所示，变量a就是一个空列表。
a = []
列表可以含有任何类型的数据（整型、浮点型、字符串、列表等），而且是可以同时包含不同的数据类型。如下所示的列表中同时包含了整型、浮点型、字符串类型的对象。
>>> a = [ 100, 99.99, "zhuanfou" ] >>> a[0] 100 >>> a[2] 'zhuanfou'
想要修改列表指定项，对该索引位置的列表项进行赋值即可。
>>> a = [ 0, 1, 2, 3 ] >>> a[1] = 666 >>> a [0, 666, 2, 3]
Python的内置函数len()可以获取指定列表对象的长度，即该列表的元素个数。
>>> a = [ 0, 1, 2, 3 ] >>> len( a ) 4
除了上述的len()函数，python中还有一些针对列表对象的内置函数，如下表所示：
| 内置函数 | 函数说明 |
|---|---|
len() |
返回列表的元素个数 |
max() |
返回数字列表中的最大项 |
min() |
返回数字列表的最小项 |
sum() |
返回数字列表所有项的和 |
示例：
>>> a = [ 0, 1, 2, 3 ] >>> max( a ) 3 >>> min( a ) 0 >>> sum( a ) 6
Python列表对象之间的+运算符，代表的是列表的连接，如下：
>>> a = [ 0, 1, 2 ] >>> b = [ 3, 4 ] >>> c = a + b >>> c [0, 1, 2, 3, 4]
列表对象常用的内置方法如下表所示：
| 方法 | 说明 |
|---|---|
L.reverse() |
将列表L中的元素倒序排列 |
L.append(e) |
在列表L的结尾添加新的元素e |
L.insert(i, e) |
在列表L的索引i位置插入新的元素e，同时将其后的元素往后移动，从而腾出位置 |
L.pop() |
移除并返回列表L的最后一个元素（该列表不得为空列表） |
L.remove(e) |
从列表L中移除第一次出现的元素e |
L.count(e) |
返回列表L中出现元素e的次数 |
L.sort() |
对列表L中的元素进行排序（默认为升序排列、若是字符串则以字母表顺序为准） |
通过列表对象的内置方法reverse可以将指定列表倒序排列，如下所示：
>>> a = [ 0, 1, 2, 3 ] >>> a.reverse() >>> a [3, 2, 1, 0]
通过列表对象的内置方法append可以添加新的元素到列表的结尾，如下所示：
>>> a = [ 0, 1, 2, 3 ] >>> a.append( 9 ) >>> a [0, 1, 2, 3, 9]
通过列表对象的内置方法insert可该列表指定索引位置添加新元素；该方法的第一个参数指插入到列表的指定位置，第二个参数代表被插入的新元素。
>>> a = [ 0, 1, 2, 3 ] >>> a.insert( 1, 666 ) >>> a [0, 666, 1, 2, 3]
通过列表对象的内置方法pop即可从列表结尾取出一个元素，如下所示：
>>> a = [0, 1, 2, 3, 9] >>> a.pop() 9 >>> a [0, 1, 2, 3]
通过列表对象的内置方法remove即可从删除该列表中指定元素，但是若该列表中出现此元素不只一次，则只会删除第一次出现位置的该元素。
>>> a = [ 0, 1, 0, 1, 9 ] >>> a.remove( 1 ) >>> a [0, 0, 1, 9]
通过列表对象的内置方法count可以统计指定元素在列表中出现的次数，若没有出现过，则返回0。
>>> a = [ 1, 9, 9, 0 ] >>> a.count( 9 ) 2 >>> a.count( 6 ) 0
通过列表对象的内置方法sort可快速将该列表排序。
>>> a = [ 1, 9, 9, 0 ] >>> a.sort() >>> a [0, 1, 9, 9]
若想从大到小进行排序，则将参数reverse设置成True即可。
>>> a.sort( reverse=True ) >>> a [9, 9, 1, 0]
请特别注意：sort方法返回的肯定是None，其排序的结果就是原始的列表对象。更多详情可查看这个错例分析。
所谓切片，也就是针对一个列表，指定起始索引位置，截取部分列表。切片的方式是在指定列表后以中括号加冒号的方式进行切片。冒号左边的整数代表切片的开始位置，其右侧数字代表切片的结束位置。冒号左侧的索引位置元素会被切片包含在内，冒号右侧的索引位置元素不被切片包含。若冒号左侧缺省，则代表起始位置从列表的最左侧开始；若冒号右侧缺省，则代表切片的结束位置到整个列表结束而结束。
>>> a = [ 0, 1, 2, 3, 4, 5, 6 ] >>> a[1:] [1, 2, 3, 4, 5, 6] >>> a[6:] [6] >>> a[:6] [0, 1, 2, 3, 4, 5] >>> a[:1] [0] >>> a[1:6] [1, 2, 3, 4, 5] >>> a[2:4] [2, 3]
使用负数索引，也是生效的：
>>> a = [ 0, 1, 2, 3, 4, 5, 6 ] >>> a[:-1] [0, 1, 2, 3, 4, 5] >>> a[-5:] [2, 3, 4, 5, 6] >>> a[-5:-1] [2, 3, 4, 5]
切片而得的列表是新列表，切片不会修改原始列表。
这里延伸说一下for循环迭代处理列表项元素，如下所示，在每次循环过程中，自定义变量i的值依次等于列表中的元素值。
>>> a = [ 666, "zhuanfou", 3.1415926 ] >>> for i in a: ... print i ... 666 zhuanfou 3.1415926
再延伸展示一下for循环的嵌套，后面说到循环语句的时候还会继续深入的。
a = [ "Li", "Wu", "Dai" ]
b = [ "Yang", "Xi" ]
for i in a:
for j in b:
print i, j
如下所示的例子中，b = a并非意味着深度复制，变量b和变量a指向的是内存中同一个位置；因此对变量b进行修改，变量a的值也发生了“改变”；而实质是变量a和变量b互为别名，变量名不一样而已，实质是一样的。（在python中若想深度复制列表对象，请查看这里）
>>> a = [ 0, 1, 2 ] >>> a [0, 1, 2] >>> b = a >>> b [0, 1, 2] >>> b[1] = "zhuanfou" >>> b [0, 'zhuanfou', 2] >>> a [0, 'zhuanfou', 2]
列表的元素不仅可以为整型、字符串类型、浮点型，还可以为列表类型；如此就形成了列表嵌套列表。淡然视之即可，列表也是一种数据类型。
>>> a = [ 0, [1, 2], 3] >>> a[1] [1, 2] >>> a[1][0] 1
通过列表的嵌套，即可构建多维列表。（如果列表中全是数字，也可称之为多维数组；因为不同的编程语言的命名方式与数据结构上会有点区别，但是终究会有异曲同工的地方。叫什么不重要，重要的是理解不同的数据结构，以后好在不同的算法中应用合适于该算法的数据结构；编程是一门艺术，也是一种与生俱来的直觉。）
如下所示，利用两层for循环，输出二维数组中的每个数字。
>>> a = [ [ 1, 2 ], [ 3, 4 ] ] >>> for i in a: ... for j in i: ... print j ... 1 2 3 4