铁乐学Python_day04-列表LIST

文：铁乐与猫
2018-3-21

Python内置的一种数据类型是列表：list。
list是一种有序的集合，可以随时添加和删除其中的元素。

序列中的每个元素都分配一个数字（下标） - 它的位置，或索引，
第一个索引是0，第二个索引是1，依此类推。
（这种设置下len列表的长度时比最大的索引值可以大1，用于循环判断时很有用。）

列表都可以进行的操作包括索引，切片，加，乘，检查成员等。
此外，Python已经内置确定序列的长度（len）以及确定最大（max）和最小（min）的元素的方法。

列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

今天来学习一下对列表进行的增删查改等常用的操作：

增学习了三种（动作）：

1）append 添加元素到列表结尾（最后）：

描述
append() 方法用于在列表末尾添加新的对象。
语法
append()方法语法：
list.append(obj)
参数
obj -- 添加到列表末尾的对象。
返回值
该方法无返回值，但是会修改原来的列表。

例：
li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.append('add')
print(li.append('g'))
print(li)

结果：
None
[1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True, 'add', 'g']

可以看到第一次的print返回的None，没有返回值。
第二次的print查看列表自身看到依次在元列表最后增加了要添加的元素。

2）insert 插入，因为是按索引位置插入的，所以很灵活。

要注意的是一次只能插入一个元素（对象）。

描述
insert() 函数用于将指定对象插入列表的指定位置。
语法
insert()方法语法：
list.insert(index, obj)
参数
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
返回值
该方法没有返回值，但会在列表指定位置插入对象。

例：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.insert(2,'int')
print(li)
li.insert(4, 't')
print(li)

结果：
[1, 'a', 'int', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]
[1, 'a', 'int', 'b', 't', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]

3）extend 迭代添加到最后(可以一次过添加多个元素）；

记忆：ex（扩展）用新列表扩展原来的列表
extend(self, iterable)：可迭代进行操作

描述
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
语法
extend()方法语法：
list.extend(seq)
参数
seq -- 元素列表。
返回值
该方法没有返回值，但会在已存在的列表中添加新的列表内容。

例：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.extend('sdg')
print(li)
li.extend('123')
print(li)
li.extend((67,87))
print(li)

结果：
[1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True, 's', 'd', 'g']
[1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True, 's', 'd', 'g', '1', '2', '3']
[1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True, 's', 'd', 'g', '1', '2', '3', 67, 87]

注意：上例中'123'字符串被拆分成了'1''2''3'三个单字符去迭代添加到列表最后了。
而数字类型的67、87则不会被拆成6、7、8、7。

删学习了四种：

1）pop 按索引删除，默认删除最后一个元素。

要注意的是它有返回值，并且返回的是被pop删除的元素。
记忆方法：一月霸权，pop与pip。

描述
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法
pop()方法语法：
list.pop(obj=list[-1])
参数
obj -- 可选参数，要移除列表元素的对象。
返回值
该方法返回从列表中移除的元素对象。

例：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.pop()
print(li)
li.pop(3)
print(li.pop(3))
print(li)

结果：
[1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e']]
laonanhai
[1, 'a', 'b', (5, 4, 7), ['g', 'u', 'e']]

这里要注意的是当我打print（li.pop(3))时，实则上是先执行了li.pop（3）去删除了。
然后返回的是被删除的laonanhai这个值。

2）remove 按元素去删除，默认只删除一个且是第一个匹配项，从左到右的顺序。

remove(self, value):可以看出只对值（元素）进行操作，而不能通过索引。
记忆：remove 移动，移除。

描述
remove() 函数用于移除列表中某个值的第一个匹配项。
语法
remove()方法语法：
list.remove(obj)
参数
obj -- 列表中要移除的对象。
返回值
该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

例：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.remove('b')
print(li)
li.remove((5, 4, 7))
print(li)

结果：
[1, 'a', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]
[1, 'a', 2, 'laonanhai', ['g', 'u', 'e'], True]

3）clear 清空内容，但是会保留列表本身，变成空列表。

记忆：clear，清空。清空回收站，回收站还在。

描述
clear() 函数用于清空列表，类似于 del a[:]。
语法
clear()方法语法：
list.clear()
参数
无。
返回值
该方法没有返回值。

例：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li.clear()
print(li)

结果：
[]

4）del 删除列表，特殊的直接del li方式，如同linux中del 文件一样，不过要慎用。

因为太容易误操作了。除此外，还可以切片删除（支持步长参数），一次性删除多个元素。
另外del删除引用而不是删除对象，对象由自动垃圾回收机制删除。
（关于del的扩展阅读可以放另外的博文再述，这里直接先记两种用法。）

例:

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
del li
print li 会报错，证明li（标签已被撕下来）己不存在了。

例2
li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
del li[:3]
print(li)

结果：
[2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]

上例中，切片将0，1，2索引位置的三个元素都给删除了。

改学习了两种方法（严格上来说算一种吧）：
1）按照索引位置一个元素对应（= ）赋值去修改。
2）利用切片迭代的方式去修改，修改的时候先将切片指定的索引位置清空，再逐一迭代将对象添加进去。
注意：切片迭代的同时也支持步长的参数去修改，只是元素要对应上数量！见下例2

例1：

li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li[1] = 'A'
print(li)
li[-2] = False
print(li)

结果：
[1, 'A', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]
[1, 'A', 'b', 2, 'laonanhai', (5, 4, 7), False, True]

例2:
li = [ 1, 'a', 'b', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True ]
li[:3] = 'tie' #迭代去修改了
print(li)
li[::2] = (54, 89, 4, 6) #指定步长，同时有相应数量的元素去对应步长间隔就可以成功迭代修改
print(li)

['t', 'i', 'e', 2, 'laonanhai', (5, 4, 7), ['g', 'u', 'e'], True]
[54, 'i', 89, 2, 4, (5, 4, 7), 6, True]

查主要就用两种：

1）用得最多是索引和切片加步长去查看：
类似：li［起始索引:截止索引:步长] （和前面的字符串操作类似，不详述）
2）通过 for 循环 遍历列表的元素去查看，还可以使用range配合。

类似以下，是不是和使用for循环来做输出显示字符串的每个单字符一样。
li2 = [1, 2, 3, 4, 5]
for i in li2:
print(i)

学完了列表的基本增删改查，再来看看其它常用的对列表的操作方法：

1）sort 进行排序，默认可正向（小到大），也可反向（大到小）；

sort(self, key=None, reverse=False)
注：sort的参数reverse的布尔值对True时，就是反向排序，见下例子。

def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
    """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
    pass

描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
sort()方法语法：
list.sort([func])
参数
func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
返回值
该方法没有返回值，但是会对列表的对象进行排序。

例：

li3 = [3, 5, 7, 1, 2, 3, 4, 9]
li3.sort()
print(li3)
li3.sort(reverse=True)
print(li3)

结果：
[1, 2, 3, 3, 4, 5, 7, 9]
[9, 7, 5, 4, 3, 3, 2, 1]

扩展：加key参数，有点像excel表格中的按关键列排序。

key参数的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。
对复杂对象的比较通常是使用对象的切片作为关键字。
例如：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) #按年龄排序
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

2）reverse 翻转，逆推（从右到左反过来排列）；

记忆：reverse，背面，相反，倒转。

描述
reverse() 函数用于反向列表中元素。
语法
reverse()方法语法：
list.reverse()
参数
NA。
返回值
该方法没有返回值，但是会对列表的元素进行反向排序。

例：

li3 = [3, 5, 7, 1, 2, 3, 4, 9]
li3.reverse()
print(li3)

结果：
[9, 4, 3, 2, 1, 7, 5, 3]

以下常用到各种触类旁通和字符串操作方法时己提过，一看就知道，不再详述。
3）len(list) 算长度，列表中的元素个数；
4）list.count() 统计某个元素在列表中出现的个数；
5）list.index() 通过元素找索引；

嵌套列表

列表中还有列表，犹如愚公所言，子子孙孙无穷尽也……

创建嵌套列表，例如：

>>>a = ['a', 'b', 'c']
 >>> n = [1, 2, 3] 
>>> x = [a, n] 
>>> x [['a', 'b', 'c'], [1, 2, 3]] 
>>> x[0] ['a', 'b', 'c']  #按索引位置取元素
>>> x[0][1] 'b'  # x[0]指向的是子列表，所以同样可以再加索引[1]去取出元素。

元祖-tuple：

也是列表，只不过元祖是只读列表。
安全性更高，在一些场合代码尽可能用tuple比用list好。
（辈份很高的样子）
tuple一旦生成就不能修改，
要注意的是假如定义只有1个元素的tuple的时候，必須加1个逗号来消除小括号所造成的歧义。
因为括号()除了表示tuple外，还能表示数学公式中的小括号。
同理，python在显示只有1个元素的tuple时，也会加上一个逗号，以免造成误解。
比如：
age = (18,)

end