Python编程快速上手第章4章列表

列表数据类型
整型，浮点型，字符串，bool型，None型

>>> [1, 2, 3]
[1, 2, 3]
>>> ['cat', 'bat', 'rat', 'elephant']
['cat', 'bat', 'rat', 'elephant']
>>> ['hello', 3.1415, True, None, 42]
['hello', 3.1415, True, None, 42]
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam
['cat', 'bat', 'rat', 'elephant']

用下标取得列表中的单个值

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0]
'cat'
>>> spam[1]
'bat'
>>> spam[2]
'rat'
>>> spam[3]
'elephant'
>>> ['cat', 'bat', 'rat', 'elephant'][3]
'elephant'
>>> 'Hello ' + spam[0]
'Hello cat'
>>> 'The ' + spam[1] + ' ate the ' + spam[0] + '.'
'The bat ate the cat.'

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

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

负数下标

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[-1]
'elephant'
>>> spam[-3]
'bat'
>>> 'The ' + spam[-1] + ' is afraid of the ' + spam[-3] + '.'
'The elephant is afraid of the bat.'

利用切片取得子列表
 spam[2]是一个列表和下标（一个整数）。
 spam[1:4]是一个列表和切片（两个整数）。(包前不包后)

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']

注意：0表示开头或结尾
用 len()取得列表的长度

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

用下标改变列表中的值

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1] = 'aardvark'
>>> spam
['cat', 'aardvark', 'rat', 'elephant']
>>> spam[2] = spam[1]
>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']
>>> spam[-1] = 12345
>>> spam
['cat', 'aardvark', 'aardvark', 12345]

列表连接和列表复制
+操作符可以连接两个列表，得到一个新列表，就像它将两个字符串合并成一个新字符串一样。
*操作符可以用于一个列表和一个整数，实现列表的复制。

>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']

用 del 语句从列表中删除值

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

注意：del 语句也可用于一个简单变量，删除它，作用就像是“取消赋值”语句。
如果在删除之后试图使用该变量，就会遇到NameError 错误，因为该变量已不再存在。
使用列表

catNames = []
while True:
	print('Enter the name of cat ' + str(len(catNames) + 1) +
	' (Or enter nothing to stop.):')
	name = input()
	if name == '':
		break
	catNames = catNames + [name] # list concatenation
print('The cat names are:')
for name in catNames:
	print(' ' + name)

列表用于循环

for i in [0, 1, 2, 3]:
print(i)

supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
for i in range(len(supplies)):
	print('Index ' + str(i) + ' in supplies is: ' + supplies[i])

in 和 not in 操作符

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True

多重赋值技巧

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

增强的赋值操作

针对+、-、*、/和%操作符和等号
spam += 1  ---spam = spam + 1
spam -= 1  ---spam = spam - 1
spam *= 1  ---spam = spam * 1
spam /= 1  ---spam = spam / 1
spam %= 1  ---spam = spam % 1

方法

• 用 index()方法在列表中查找值
  列表值有一个 index()方法，可以传入一个值，如果该值存在于列表中，就返回它
  的下标。如果该值不在列表中，Python 就报ValueError。

>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> spam.index('hello')
0
>>> spam.index('heyas')
3
>>> spam.index('howdy howdy howdy')
Traceback (most recent call last):
File "", line 1, in <module>
spam.index('howdy howdy howdy')
ValueError: 'howdy howdy howdy' is not in list

• 用 append()和 insert()方法在列表中添加值
  要在列表中添加新值，就使用 append()和 insert()方法。在交互式环境中输入以
  下代码，对变量 spam 中的列表调用 append()方法：

>>> spam = ['cat', 'dog', 'bat']
>>> spam.append('moose')
>>> spam
['cat', 'dog', 'bat', 'moose']
>>> spam = ['cat', 'dog', 'bat']
>>> spam.insert(1, 'chicken')
>>> spam
['cat', 'chicken', 'dog', 'bat']

注意：只能在列表上调用 ，否则AttributeError 错误信息。
用 remove()方法从列表中删除值

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('bat')
>>> spam
['cat', 'rat', 'elephant']

试图删除列表中不存在的值，将导致 ValueError 错误。
已知列表中的下标，del 语句就很好用。
已知列表中删除的值，remove()方法就很好用。
用 sort()方法将列表中的值排序

>>> spam = [2, 5, 3.14, 1, -7]
>>> spam.sort()
>>> spam
[-7, 1, 2, 3.14, 5]
>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']
>>> spam.sort()
>>> spam
['ants', 'badgers', 'cats', 'dogs', 'elephants']

将关键字参数key 设置为 str.lower。
sort()方法将列表中所有的表项当成小写，但实际上并不会改变它们在列表中的值。

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

sorted() 函数

sorted(iterable, key=None, reverse=False)  

参数说明：
iterable – 可迭代对象。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，
指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

主要区别：list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。

>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

利用key进行倒序排序

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]
>>>

类似列表的类型：字符串和元组
列表并不是唯一表示序列值的数据类型。
可变和不可变数据类型
列表是“可变的”数据类型，的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改。
尝试对字符串中的一个字符重新赋值，将导致 TypeError 错误。

“改变”一个字符串的正确方式，是使用切片和连接。构造一个“新的”字符
串，从老的字符串那里复制一些部分。

>>> name = 'Zophie a cat'
>>> newName = name[0:7] + 'the' + name[8:12]
>>> name
'Zophie a cat'
>>> newName
'Zophie the cat'

元组数据类型

元组像字符串一样，是不可变的。元组不能
让它们的值被修改、添加或删除。
如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种
情况。否则，Python 将认为，你只是在一个普通括号内输入了一个值。

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

用 list()和 tuple()函数来转换类型

>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

引用
变量保存字符串和整数值。

>>> spam = 42
>>> cheese = spam
>>> spam = 100
>>> spam
100
>>> cheese
42

当你将列表赋给一个变量时，实际上是将列表的“引用”赋给了该变量。引用是一个值，指向某些数据。列表引用是指向一个列表的值。

>>> spam = [0, 1, 2, 3, 4, 5]
>>> cheese = spam
>>> cheese[1] = 'Hello!'
>>> spam
[0, 'Hello!', 2, 3, 4, 5]
>>> cheese
[0, 'Hello!', 2, 3, 4, 5]

当创建列表时，你将对它的引用赋给了变量。但下一行只是将 spam 中的列表引用拷贝到 cheese，而不是列表值本身。这意味着存储在 spam 和 cheese 中的值，现在指向了同一个列表。底下只有一个列表，因为列表本身实际从未复制。所以当你修改 cheese 变量的第一个元素时，也修改了 spam 指向的同一个列表。
变量包含对列表值的引用，而不是列表值本身。但对于字符串和整数值，变量
就包含了字符串或整数值。在变量必须保存可变数据类型的值时，例如列表或字典，
Python 就使用引用。对于不可变的数据类型的值，例如字符串、整型或元组，Python
变量就保存值本身。
传递引用
要理解参数如何传递给函数，引用就特别重要。当函数被调用时，参数的值被
复制给变元。对于列表（以及字典，我将在下一章中讨论），这意味着变元得到的
是引用的拷贝。
指向的是同一个指针。

def eggs(someParameter):
	someParameter.append('Hello')
spam = [1, 2, 3]
eggs(spam)
print(spam)

copy 模块的 copy()和 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']

copy和deepcopy区别：
deepcopy是独立的，接近于我们想要的效果。

>>> import copy
>>> origin = [1, 2, [3, 4]]
#origin 里边有三个元素：1， 2，[3, 4]
>>> cop1 = copy.copy(origin)
>>> cop2 = copy.deepcopy(origin)
>>> cop1 == cop2
True
>>> cop1 is cop2
False 
#cop1 和 cop2 看上去相同，但已不再是同一个object
>>> origin[2][0] = "hey!" 
>>> origin
[1, 2, ['hey!', 4]]
>>> cop1
[1, 2, ['hey!', 4]]
>>> cop2
[1, 2, [3, 4]]
#把origin内的子list [3, 4] 改掉了一个元素，观察 cop1 和 cop2

项目1：逗号代码
假定有下面这样的列表：
spam = [‘apples’, ‘bananas’, ‘tofu’, ‘cats’]
编写一个函数，它以一个列表值作为参数，返回一个字符串。该字符串包含所
有表项，表项之间以逗号和空格分隔，并在最后一个表项之前插入 and。例如，将
前面的 spam 列表传递给函数，将返回’apples, bananas, tofu, and cats’。但你的函数应
该能够处理传递给它的任何列表。
解答：

spam = ['apples', 'bananas', 'tofu', 'cats']
newSapm = []
#index（）
for temp in spam:
    if spam.index(temp) == len(spam) - 1:
        temp = 'and ' + temp
    newSapm.append(temp)
'''range（）
for temp in range(len(spam)):
    if temp == len(spam) - 1:
        temp = 'and ' + temp
    newSapm.append(temp)
'''
#print(newSapm)
print(', '.join(newSapm))

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

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', '.', '.', '.'],
['.', '.', '.', '.', '.', '.']]

输出效果：

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

解答：

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', '.', '.', '.'],
['.', '.', '.', '.', '.', '.']]
#把列当做内层循环，行做外层
#一共有多少列，从0列开始
for i in range(len(grid[0])):
    for j in range(len(grid)):
        print(grid[j][i],end='')
    print()