假定列表['cat','bat','rat','elephant']保存在变量spam中。python代码spam[0]将求值为'cat',spam[1]将求值为'bat',以此类推。列表后的方括号内的整数被称为“下标”。列表的第一个下标是0。下标只能是整数。

列表也可以包含其他列表值。这些列表的列表中的值，可以通过多重下标来访问。

>>> spam= [['cat','bat'],[10,20,30,40,50]]
>>> spam[0]
['cat', 'bat']
>>> spam[0][1]
'bat'
>>> spam[1][4]
50
>>> 

虽然下标从0开始并向上增长，但也可以用负整数作为下标。整数值-1指的是列表中的最后一个下标，-2指的是列表中的倒数第二个下标，以此类推。

切片可以从列表中取得多个值，结果是一个新列表。切片输入在一对方括号中，像下标一样，但他有两个冒号分隔的整数。

• spam[2]是一个列表和下标（一个整数）
• spam[1:4]是一个列表和切片（两个整数）

在一个切片中，第一个整数是切片开始处的下标，第二个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。

len()函数将返回传递给他的列表中值得个数，就像他能计算字符串中字符串的个数一样。

>>> spam=['cat','dog','moose']
>>> len(spam)
3
>>> 

一般情况下，赋值语句左边是一个变量名，就像spam=4.但是，也可以使用列表的下标来改变下标处的值。

>>> spam=['cat','dog','moose']
>>> spam[1] = 'bat'
>>> spam
['cat', 'bat', 'moose']
>>> 

+操作符可以连接两个列表，得到一个新的列表。*操作符可以用于一个列表和一个整数，实现列表的复制，得到一个新列表。

del语句将删除列表中下标处的值，表中被删除值后面的所有值，都将向前移动给一个下标。

>>> spam=['cat','dog','moose']
>>> del spam[1]
>>> spam
['cat', 'moose']
>>> 

del语句也可以用于删除一个简单变量，之后该变量将不再存在。

一个python技巧，在for循环中使用range(len(someList))，迭代列表的每一个下标。

>>> supplies = ['pen','staplers','flam_throwers','binders']
>>> for i in range(len(supplies)):
	print('Index '+ str(i) + ' in supplies is: '+supplies[i])

Index 0 in supplies is: pen
Index 1 in supplies is: staplers
Index 2 in supplies is: flam_throwers
Index 3 in supplies is: binders
>>> 

利用in和not in操作符，可以确定一个值是否在列表中。像其他操作符一样，in和not in用在列表中，连接两个值：一个要在列表中查找的值以及待查找的列表。这些表达式将求值为布尔值。

>>> spam=['cat','dog','moose']
>>> 'cat' in spam
True
>>> cat not in spam
False
>>> 

多重赋值技巧是一种快捷方式，让你在一行代码中，用列表中的值为多个变量赋值.变量的数目和列表的长度必须相等。

>>> cat = ['fat','black','loud']
>>> size, color,disposition = cat

方法和函数是一回事，只是它调用在一个值上。每种数据类型都有他自己的一组方法。

列表值有一个index()方法，可以传入一个值，如果该值存在于列表中，就返回它的下标。如果该值不在列表中，python就报ValueError。如果列表中存在重复的值，他就返回它第一次出现的下标。

>>> spam=['cat','dog','moose']
>>> spam.index('cat')
0

append()方法将参数添加到列表末尾。 insert()方法可以在列表的任意下标处插入一个值。insert()方法的第一个参数是新值的下标，第二个参数是要插入的新值。

方法属于单个数据类型。append()和insert()方法是列表方法，其返回值是None，只能在列表上调用，不能在其他值上调用。

给remove()方法传入一个值，它将从被调用的列表中删除。

>>> spam=['cat','dog','moose']
>>> spam.remove('cat')
>>> spam
['dog', 'moose']
>>> 

如果该值在列表中出现多次，只有第一次出现的值会被删除。

数值的列表或字符串的列表，能用sort()方法排序，可以指定关键字reverse=Tue让sort()逆序排序

sort()方法对字符串排序时，使用“ASIC2字符顺序表”，如果需要按照普通的字典顺序来排序，可以在调用sort()方法时，将关键字参数key设置为str.lower.

>>> spam = [2,5,-14,-7,12,3]
>>> spam.sort()
>>> spam
[-14, -7, 2, 3, 5, 12]
>>> spam.sort(reverse=False)
>>> spam
[-14, -7, 2, 3, 5, 12]
>>> spam.sort(reverse=True)
>>> spam
[12, 5, 3, 2, -7, -14]

>>> spam=['a','Z','A','Z']
>>> spam.sort(key=str.lower)
>>> spam
['a', 'A', 'Z', 'Z']
>>> 

列表并不是唯一表示序列值的数据类型。对于列表的许多操作，也可以作用于字符串：按下标取值，切片，用于for循环，用于len()以及用于in和not in操作符

>>> name='Zophie'
>>> name[0]
'Z'
>>> name[-2]
'i'
>>> name[0:4]
'Zoph'
>>> 'Zo' in name
True
>>> 'p' not in name
False
>>> for i in name:
	print('* * ' + i + ' * *')

* * Z * *
* * o * *
* * p * *
* * h * *
* * i * *
* * e * *
>>> 

列表是“可变的”数据类型，它的值可以添加，删除或者改变。但是字符串是“不可变的”。
“改变”一个字符串的正确方式，是使用切片和连接。构造一个“新的”字符串。

除了一下几点元组数据类型和列表一样。

• 元组输入时用圆括号(),而不是用方括号[]
• 元组像字符串一样是不可变的。
• 如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这个情况。

• list()可以将返回值传递给它们的值的列表
• tuple()可以将返回值传递给它们的值的元组

>>> spam=['a','Z','A','Z']
>>> tuple(spam)
('a', 'A', 'Z', 'Z')
>>> list(spam)
['a', 'A', 'Z', 'Z']
>>> 

当将列表赋值给一个变量时，实际上是将列表的“引用”赋给了该变量。 在变量必须保存可变数据类型的值时，例如列表或者字典，python就使用引用。对于不可变得数据类型值，例如字符串，整型或元组，python变量就保存值本身。

当函数被调用时，参数的值就被赋值给变元，对于列表以及字典，这意味着变元得到的是引用拷贝。

def eggs(someParameter):
    someParameter.append('Hello')

spam = [1, 2, 3]
eggs(spam)
print(spam)

>>>[1,2,3,'Hello']

copy模块包含copy()和deepcopy()函数，第一个函数copy.copy(),可以用来复制列表或者字典这样的可变值，而不是复制引用。

如果复制的列表中包含了列表，那就使用copy.deepcopy()函数来替代。deepcopy()函数将同时复制他们内部的列表。

>>> import copy
>>> spam=['A','B','C','D']
>>> cheese =copy.copy(spam)
>>> cheese [1]=42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']
>>> 

假定有下面这样的列表： spam = ['apples', 'bananas', 'tofu', 'cats']

编写一个函数，它以一个列表值作为参数，返回一个字符串。该字符串包含所 有表项，表项之间以逗号和空格分隔，并在最后一个表项之前插入and。例如，将前面的 spam 列表传递给函数，将返回'apples, bananas, tofu, and cats'。但你的函数应该能够处理传递给它的任何列表。

代码如下：

def change(listValue):
    listValue[-1] = 'and ' + listValue[-1]
    print(','.join(listValue))
    

spam = ['apples', 'bananas', 'tofu', 'cat']

change(spam)

假定有一个列表的列表，内层列表的每个值都是包含一个字符的字符串，像这样：

grid = [['.', '.', '.', '.', '.', '.'],

       ['.', 'O', 'O', '.', '.', '.'],

       ['O', 'O', 'O', 'O', '.', '.'],

       ['O', 'O', 'O', 'O', 'O', '.'],

       ['.', 'O', 'O', 'O', 'O', 'O'],

       ['O', 'O', 'O', 'O', 'O', '.'],

       ['O', 'O', 'O', 'O', '.', '.'],

       ['.', 'O', 'O', '.', '.', '.'],

       ['.', '.', '.', '.', '.', '.']]

你可以认为grid[x][y]是一幅“图”在x,y坐标处的字符，该图由文本字符组成。原点（0，0）在左上角，向右x坐标增加，向下y坐标增加。复制前面的网格值，编写代码用它打印图像。

..OO.OO..
.OOOOOOO.
.OOOOOOO.
..OOOOO..
...OOO...
....O....

提示：你需要使用循环嵌套循环，打印出grid[0][0],然后grid[1][0],然后grid[2][1],以此类推，知道grid[8][0]。这就完成第一行，所以接下来打印换行。然后程序将打印出grid[0][1],然后grid[1][1],然后grid[2][1],以此类推。程序最后将打印出grid[8][5]。 而且，如果你不希望在每次print()调用后都自动打印换行，记得向print()传递end关键字参数。

代码如下：

grid = [['.', '.', '.', '.', '.', '.'],

       ['.', 'O', 'O', '.', '.', '.'],

       ['O', 'O', 'O', 'O', '.', '.'],

       ['O', 'O', 'O', 'O', 'O', '.'],

       ['.', 'O', 'O', 'O', 'O', 'O'],

       ['O', 'O', 'O', 'O', 'O', '.'],

       ['O', 'O', 'O', 'O', '.', '.'],

       ['.', 'O', 'O', '.', '.', '.'],

       ['.', '.', '.', '.', '.', '.']]


for y in range(len(grid[0])):
    for x in range(len(grid)):
        print(grid[x][y], end='')
    print('\n')