列表 (list)

python列表 (list)

python的列表(list)是使用频率最高的一种数据结构， 很像C++中的vector 和 java 中的ArrayList， 是大小可动态变换的数组。 单个列表可以同时存储多种数据类型， 而不一定非得是同一种数据类型。
列表是有序的， 它根据确定的序列对列表里的数据进行索引， 和其他语言一样， 索引从0开始， 列表里每个数据都有自己确切的位置， 对列表里元素的任何操作都离不开索引， 因此， 对列表进行迭代是非常常见的操作。

1. 创建列表

list1 = [1, 2, 3, 4, 5 ]
list2 = [1, 2, '3', True]
list3 = [[1,2,3], True, 1]

列表里可以存放任意类型的数据，每个数据之间，用逗号分隔，整个列表被包裹在一对中括号[]里，如果你定义lst = [],[]表示一个空列表。

2. 索引的概念

列表是数据的有序集合，对于列表里数据的操作，都必须通过索引来完成，回想一下上一篇的智力测试，所有的小球按顺序排放，顺序就是小球的索引，你可以将索引就理解为顺序，只是有一点务必牢记，计算机里的索引，或者说顺序，都是从0开始的

lst = [2, 3, 5, 6]

下面这张图很好的阐述了索引的概念

所谓正序索引，就是从左向右看，倒序索引就是从右向坐看，由左至右，从0开始递增，从右向左，从-1开始递减，python既支持正序索引，也支持倒序索引。

3.向列表中新增数据

向列表中新增数据有两种方法，一个是insert,一个是append,前者需要指定插入的位置，而append则默认在列表的尾部插入数据，下面的代码演示如何使用这两个方法新增数据

lst = [3, 5, 8, 1, 2, 6, 9]
lst.insert(2, 22)  # 将22插入到索引为2的位置上
lst.append(33)     # 将33增加到列表尾部
print(lst)

下图很好的解释了这两种新增方法的区别

4. 访问列表里的数据

访问列表里的数据，必须提供索引，假设你想输出列表里的第0个元素，和倒数第一个元素，你应该这样操作

lst = [3, 5, 8, 1, 2, 6, 9]
print(lst[0])
print(lst[-1])

程序输出结果为

3
9

根据索引获取列表里的数据，需要使用中括号[],在[]里填写你想要获取数据的索引，如果这个索引超出了范围，就会报错

lst = [3, 5, 8, 1, 2, 6, 9]
print(lst[12])

报错内容为

Traceback (most recent call last):
  File "/Users/kwsy/PycharmProjects/pythonclass/wx_monitor/main.py", line 2, in <module>
    print(lst[12])
IndexError: list index out of range

这是因为列表里根本没有这个索引，你想要找的索引已经超出了列表索引的范围。

5. 遍历列表

请注意, for循环的内容要等到第5章程序控制章节才会讲解, 如果你还没有掌握for循环, 这段内容你可以等到学完第5章循环控制以后在来学习
遍历索引，需要使用for循环，你可以写出至少3种for循环，每一个都可以遍历列表里所有的元素
方法1，通过索引遍历

lst = [3, 5, 8, 1, 2, 6, 9]
for i in range(len(lst)):
    print(lst[i])

方法2，通过迭代器遍历

lst = [3, 5, 8, 1, 2, 6, 9]
for item in lst:
    print(item)

方法3， 通过enumerate函数遍历

lst = [3, 5, 8, 1, 2, 6, 9]
for index, item in enumerate(lst):
    print(index, item)

关于enumerate函数，可以在内置函数章节里学习

6. 删除列表里的元素

删除列表里的元素有两种方法，一种是根据索引来删除，一种是根据值来删除，先说根据索引删除

根据索引删除列表里的元素

列表的pop方法可以删除指定索引位置上的数据

lst = [3, 4, 1, 4, 2]
lst.pop(0)     # 删除索引为0的元素
print(lst)

pop只会删除指定索引位置的元素，程序输出结果为

[4, 1, 4, 2]

除了使用pop方法，你还可以使用del 关键字

lst = [3, 4, 1, 4, 2]
del lst[0]
print(lst)

del lst[0] 等价于 lst.pop(0)

根据值删除列表里的元素

根据值删除，使用remove方法，remove会删除列表里指定的值，比如你想删除4

lst = [3, 4, 1, 4, 2]
lst.remove(4)
print(lst)

需要注意的是，remove方法一次只会删除一个值，列表里有两个4，它会删除索引最小的那个4，程序输出结果为

[3, 1, 4, 2]

7. 和列表相关的几个重要内置函数

7.1 len,计算列表长度

len函数已经不是第一次接触了，len函数不仅能求列表的长度，还能求字符串的长度，集合的长度，元组的长度，字典的长度，他们的用法如此统一，减轻了我们学习的难度

lst = [3, 4, 1, 4, 2]
print(len(lst))

7.2 max，返回数列的最大值

max不仅可以作用于列表，也可以作用于元组，它会返回数列里的最大值

lst = [3, 4, 1, 4, 2]
print(max(lst))

肉眼可见，4是列表的最大值，max函数返回值为4

7.3 min, 返回数列的最小值

min可以作用于列表，也可以作用于元组，它返回数列里的最小值

lst = [3, 4, 1, 4, 2]
print(min(lst))

1是列表的最小值，min函数返回值为1

7.4 sum，返回数列里所有数据的和

同样，sum函数可以作用于列表，也可以作用于元组，它返回数列里所有数的总和

lst = [3, 4, 1, 4, 2]
print(sum(lst))

列表里所有元素的总和是14，这正是sum函数的返回值

8. 列表操作符

列表对 + 和 * 的操作符与字符串相似,现在，在交互式解释器里跟随我一起操作

>>> lst1 = [1, 2, 3]
>>> lst2 = [4, 5, 6]
>>> lst1 + lst2
[1, 2, 3, 4, 5, 6]
>>> lst1*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> 3 in lst1
True
>>> 4 not in lst2
False

python嵌套列表

python嵌套列表是一个对初学者稍有困难的知识点，因此，我专门用一篇教程来对它进行讲解。所谓嵌套，是指列表里出现了其他容器类型数据，比如下面的例子

lst = [1, [1, 5], 3, [9, 8, [1, 3]], 5]
print(lst[3][2][0])
print(lst[1:4])

面对这种嵌套的列表，很多人表示很懵逼，现在，跟着我的节奏，一点点搞清楚它。
编程是一件很枯燥的事情，因为它要求你逻辑严谨，一丝不苟，这样，肯定没有天马行空的幻想来的让人舒服。
在前面讲列表的创建时，特别强调了，列表用中括号创建，列表里的数据用逗号分隔，从左往右看，第一个数据是1， 这个没有问题，关键是第二个数据，到底是[1, 5], 还是[1 ? 他们都被逗号分隔了
如果你认真思考就明白，第二个数据是[1, 5],因为[1, 5]是一个列表，是一个数据，而[1 不是一个数据，我们已经学过的数据类型里没有这种数据类型。
按照上面的思路去思考，列表里的数据如下

在此基础上理解lst[3][2][0]

1. lst[3] 的值是[9, 8, [1, 3]]
2. [9, 8, [1, 3]] 是一个列表，列表里有3个数据，索引为2的数据是[1, 3]
3. [1, 3]是一个列表，列表里有两个数据，索引为0的数据是1
4. print(lst[3][2][0]) 语句输出的结果是1

现在，请不用代码，自己手写出下面语句的结果

1. print(lst[1:4])
2. print(lst[3][2:])
3. print(lst[-2][1:2])

答案是

[[1, 5], 3, [9, 8, [1, 3]]]
[[1, 3]]
[8]

python列表切片操作

python列表的切片操作，是一个使用频率非常高的技术，你应该认真学习掌握
所谓切片，就是从列表中截取某一部分，它的一般形式为 [start:end), 左闭右开. 对于列表的操作，离不开索引，做切片操作时，就必须指定截取的起始位置和结束位置

1. 指定开始和结束位置

lst = [3, 4, 1, 4, 2, 5, 8]
lst1 = lst[3:6]
print(lst1)

程序输出结果为

[4, 2, 5]

切片操作的一般模式是[start:end],shart 和 end 所指的都是索引，截取时，end索引位置的元素不会被截取，这一点尤其要注意，比如上面的示例中

lst1 = lst[3:6]

索引为6的元素是8，8没有出现在结果里，截取范围是3到6，6-3=3，最终切片截取的列表长度也正好是3
在使用切片时，也可以使用倒序索引

lst = [3, 4, 1, 4, 2, 5, 8]
lst1 = lst[2:-2]
print(lst1)

程序输出结果

[1, 4, 2]

2. 指定开始位置，不指定结束位置

lst = [3, 4, 1, 4, 2, 5, 8]
lst1 = lst[2:]
print(lst1)

如果不指定结束位置，那么切片操作会从开始位置截取到列表末尾，程序输出结果为

[1, 4, 2, 5, 8]

3. 指定结束位置，不指定开始位置

lst = [3, 4, 1, 4, 2, 5, 8]
lst1 = lst[:5]
print(lst1)

如果不指定开始位置，那么默认开始位置为0，程序输出结果为

[3, 4, 1, 4, 2]

4. 切片操作允许索引超出范围

lst = [3, 4, 1, 4, 2, 5, 8]
lst1 = lst[:11]
print(lst1)

上面的代码中，结束位置的索引设置为11，显然已经超出了列表索引的范围，但是却没有引发错误，对于这种情况，切片操作自身做了处理，如果结束位置的索引超出索引范围，那么就以列表长度作为结束位置

5. 指定切片间隔

关于切片间隔，已经在字符串切片操作做过讲解，本文不做赘述，只给出示例代码，想要了解切片间隔，可以去看这篇文章。

lst = [1, 2, 3, 4, 5]
print(lst[::-2])    # [5, 3, 1]
print(lst[::-1])    # [5, 4, 3, 2, 1]

6. 切片操作应用示例—-分组

lst = [2, 3, 4, 1, 5, 2, 7, 1, 8, 9, 10, 31, 22, 34]

上面定义了一个列表，现在要求你从第一个元素开始，每三个一组求和，将所求得的和放入新列表sum_lst
示例代码

lst = [2, 3, 4, 1, 5, 2, 7, 1, 8, 9, 10, 31, 22, 34]
step = 3
sum_lst = []
for i in range(0, len(lst), step):
    tmp = lst[i: i+step]
    sum_lst.append(sum(tmp))
print(sum_lst)

python列表方法详解

下表是列表方法及功能说明