> l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> type(l)
<type 'list'>
> el = []  # Create an empty list
> len(el)
0
> sl = [1]  # Create a single item list
> len(sl)
1
> sl = [1,]  # Create 
a single item list, as with a tuple
> len(sl)
1

> help(list)
Help on class list in module __builtin__:
class list(object)
 | list() -> new list
 | list(sequence) -> new list initialized from sequence's items
 | 
 | Methods defined here:
 | 
 | __add__(...)
 |   x.__add__(y) <==> x+y
 | 
 | __contains__(...)
 |   x.__contains__(y) <==> y in x
 | 
...

> l = list()
> type(l)
<type 'list'>
> len(l)
0
> l
[]
> l = list((0, 1, 2, 3, 4, 5, 6, 7, 
8, 9))  # Create a list from a tuple
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> len(l)
10
> l = list([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])  # Create a list from a list
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> len(l)
10
> l = list(0, 1, 2, 3, 4, 5, 6, 7, 
8, 9)   # Error: Must pass in a sequence
Traceback (most recent call last):
 File "<stdin>", line 1, in "0123456789") # Create a list from a string
> l
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
> type(l)
<type 'list'>
> len(l)
10

> l = list([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
> l[0]     # Get the first item in the list
0
> type(l[0])
<type 'int'>
> l[5]     # Get the sixth item in the list
5
> l[1:5]    # Get the second through fifth items
[1, 2, 3, 4]
> type(l[1:5])
<type 'list'>
> l[0::2]   # Get every second item 
[0, 2, 4, 6, 8]
> l[0], l[1], l[2]  
(0, 1, 2)

> l = []
> l[0] = 0   # The list is empty
Traceback (most recent call last):
 File "<stdin>", line 1, in "htmlcode">

> l=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> l[2] = 2
> type(l[2])
<type 'int'>
> l[2] = "two"   # Change the type of an element
> ,ype(l[2])
<type 'str'>
> l
[0, 1, 'two', 3, 4, 5, 6, 7, 8, 9]
> l[2] = l[2:5] * 2 
> l
[0, 1, ['two', 3, 4, 'two', 3, 4], 3, 4, 5, 6, 7, 8, 9]
> del(l[2])     # Remove single element
> l
[0, 1, 3, 4, 5, 6, 7, 8, 9]
> l[1:3] = []    # Remove a slice
> l 
[0, 4, 5, 6, 7, 8, 9]




修改 list 中的条目相当容易：您可以适当地设置条目的值，甚至设置成另一种不同的类型，如 string 或另一 list。您还可以使用重复运算符，可以将该运算符识别为乘法运算符，以便从小片段中构建更大的列表。
前面的例子向您展示了如何向 list 中添加元素，以及如何修改 list 中的条目。前一个例子还演示了如何从 list 中删除对象。删除条目的第一个方法是使用 del 方法。使用此方法可以删除一个条目或一个条目范围。您还可以使用灵活而强大的切片方法从 list 中删除切片。

数组
在前一个例子中您可以看到，list 可以包含另一个 list 作为条目。如果扩展此例子，您可能想知道每个条目由一个 list 替换将会发生什么样的事情。结果是一个数组，或者从更加数学方面来讲是一个矩阵。清单 7 展示了如何使用 list 保持二维 (2-D) 或三维 (3-D) 数组。

清单 7. list 作为一个数组


> al = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
> al
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]
> al[0][0]     # First element in 2D array
0
> al[2][2]     # Last element in 2D array
8
> al[1][2]
5
> al = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
> al
[[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
> al[0][0][1]
1
> len(al)      # Length of outer dimension
2
> len(al[0])    # Length of middle dimension
2
> len(al[0][0])   # Length of inner dimension
2




其他列表操作
list 对象具有许多可以应用于现有列表的有用方法。例如，您可以反转 list 中的所有条目或排序 list。不过，要记住这些操作的一个重点在于，它们是就地 操作，这意味着它们会修改调用它们所针对的 list。因此，如果您尝试创建新列表，并将其设置为对这些方法之一调用所产生的结果，则会得到一个空列表。
list 除可以用于模拟数组外，还可以用于模拟其他数据结构。例如，append 和 pop 方法对 list 函数的操作要么是先进先出 (FIFO) 数据结构（也称为队列），要么是后进先出 (LIFO) 数据结构（也称为堆栈）。通过允许您将条目设置为从 list 中弹出（删除并返回），pop 方法支持这些功能。如果弹出 list 的第一项，则是一个队列；反之，如果弹出 list 的最后一项，则是一个堆栈，如清单 8 所示。

清单 8. 操纵 list


> l=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> id(l) # This is the object id for our current list
4525432
> l.reverse()    # Reverse the list
> l
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
> id(l) # The id is the same, modified list in place.
4525432
> l.sort()     # Sort the list in numerical order
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> id(l) # Modified the existing list
4525432
> l.index(5)    # Same as l[5]
5
> l.count(0)    # How 
many times does '0' occur in the list
1
> l.pop()      # Take off the last item (Stack)
9
> l
[0, 1, 2, 3, 4, 5, 6, 7, 8]
> l.pop(5)     # Take out the fifth element
5
> l
[0, 1, 2, 3, 4, 6, 7, 8]
> l.pop(0)     # Take the first item off the list (Queue)
0
> l
[1, 2, 3, 4, 6, 7, 8]




列表：切片和切块
本文介绍了 list，它是一个容器对象，可以方便地进行修改，而且可以持有不同类型的数据。由于它具有相当的灵活性，因此 list 是 Python 编程语言中最常用的结构之一已不足为怪。list 像一个口袋，可以容纳不同类型的数据，并可以根据需要更改。您可以像使用数组一样使用 list，以有组织的方式容纳数据；您还可以像使用队列或堆栈一样使用 list。在以后的文章中还将更为深入地探索这一灵活性，并介绍强大的编程技术，即列表理解。