列表：用于存储任意数目、任意类型的数据集合。

列表是内置可变序列，是包含多个元素的有序连续的内存空间。

特点: 有序, 可变, 中括号[]

列表的标准语法格式：a = [10,20,30,40] . 其中，10,20,30,40这些称为：列表a的元素。

注意:

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

前面学习的很多字符串的方法，在列表中也有类似的用法，几乎一模一样。

操作

列表的创建

使用list()可以将任何可迭代的数据转化成列表

range()创建整数列表

推导式生成列表

列表：用于存储任意数目、任意类型的数据集合

list()创建

import random

a = [10086, 10010, 10000, "中国移动", "中国联通", "中国电信"]

b = [] # 创建一个空列表对象

print(a)

print(b)

list()创建

使用list()可以将任何可迭代的数据转化成列表

a = list()

b = list(range(9))

c = list("中国移动,10086")

print(a)

print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8]

print(c) # ['中', '国', '移', '动', ',', '1', '0', '0', '8', '6']

range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中极其有用. 语法格式为：range([start,] end [,step])

start参数：可选，表示起始数字。默认是0

end参数：必选，表示结尾数字

step参数：可选，表示步长，默认为1

a = list(range(3, 15, 2)) # 结果：[3, 5, 7, 9,11, 13]

b = list(range(15, 9, -1)) # 结果：[15, 14, 13,12, 11, 10]

c = list(range(3, -4, -1)) # 结果：[3, 2, 1, 0,-1, -2, -3]

print(a, b, c)

推导式生成列表

使用列表推导式可以非常方便的创建列表，在开发中经常使用

a = [x * 2 for x in range(5)]

#通过if过滤元素[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

b = [x * 2 for x in range(100) if x % 9 == 0]

print(a, b)

列表的新增

append()方法( 速度最快, 推荐使用 )

+运算符操作 ( 生成新对象 )

extend()方法 ( 尾插, 不生成新对象 )

insert()插入元素 ( 插入到指定位置, 慎用 )

使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复

列表元素的增加

1. append()方法 原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

a = [20, 40] # 此列表创建可以重写为列表文字

a.append(80)

print(a) # 结果：[20, 40, 80]

2. +运算符操作 并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中

a = [20, 40]

print("测试第一次时对象的引用: ", id(a))

a = a + [50]

print("测试第二次时对象的引用: ", id(a)) # 两次地址不一样，创建了新的对象

3. extend()方法 将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

a = [20, 40]

print(id(a))

b = [50, 60]

a.extend(b) # 原对象修改

print(id(a), a)

a = a + b # 产生新对象

print(id(a), a)

4. insert()插入元素

使用 insert() 方法可以将指定的元素插入到列表对象的任意制定位置.

这样会让插入位置后面所有的元素进行移动，会影响处理速度. 涉及大量元素时，尽量避免使用。

a = [10, 20, 30]

a.insert(2, 100) # 在2号下标位置(起点为0)放入100

print(a) # 结果：[10, 20, 100, 30]

5. 乘法扩展 使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复

a = ["托尼斯塔克", "爱你三千遍"]

d = a * 30 # 3000是在太多了...

print(a)

print(d)

列表的删除:

del() 删除列表指定位置的元素

pop()删除并返回指定位置元素

删除首次出现的指定元素，若不存在该元素抛出异常

列表元素的删除

1. del删除, 删除列表指定位置的元素

a = [100, 200, 888, 300, 400]

del a[2]

print(a) # 结果：[100,200,300,400]

2. pop()方法

pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素

a = [10, 20, 30, 40, 50]

b1 = a.pop() # 结果：b1=50

print(a, b1) # 结果：[10, 20, 30, 40] 50

b2 = a.pop(1)

print(a, b2) # 结果：[10, 30, 40],20

3.remove()方法

删除首次出现的指定元素，若不存在该元素抛出异常

a = [10, 20, 30, 40, 50, 20, 30, 20, 30]

a.remove(20) # [10, 30, 40, 50, 20, 30, 20,30]

print(a)

a.remove(90) # ValueError: list.remove(x): x not in list

复制列表所有的元素到新列表对象:

复制列表所有的元素到新列表对象

只是将list2也指向了列表对象，也就是说list2和list2持有地址值是相同的. 列表对象本身的元素并没有复制。

list1 = [30, 40, 50]

list2 = list1

print(list2)

访问 & 计数

访问:

通过索引直接访问元素

index()获得指定元素在列表中首次出现的索引

列表元素访问和计数

1. 通过索引直接访问元素

我们可以通过索引直接访问元素。索引的区间在 [0, 列表长度-1] 这个范围。超过这个范围则会抛出异常。

a = [10, 20, 30, 40, 50, 20, 30, 20, 30]

print(a[2]) # 结果：30

print(a[10]) # 报错：IndexError: list index out of range

2. index()获得指定元素在列表中首次出现的索引

index() 可以获取指定元素首次出现的索引位置。语法是： index(value,[start, [end]]) 。其中， start 和 end 指定了搜索的范围。

print(a.index(20)) # 1

print(a.index(20, 3)) # 5

print(a.index(30, 5, 7)) # 6

print(a[a.index(20)])

print(a[a.index(20, 3)])

print(a[a.index(30, 5, 7)])

计数:

count()获得指定元素在列表中出现的次数

len()返回列表长度，即列表中包含元素的个数

3. count()获得指定元素在列表中出现的次数

print("20在列表中出现的次数:", a.count(20))

4. len()返回列表长度，即列表中包含元素的个数。

a = [10, 20, 30]

print(len(a))

列表的遍历:

列表的遍历

print("测试列表的遍历")

a = [10, 20, 30, 40]

for o in a:

print(o)

常见用法

列表常见方法如下图所示, 下面我们对部分用法进行操作

切片操作:

切片操作

类似字符串的切片操作，对于列表的切片操作和字符串类似.

标准格式为：[起始偏移量start:终止偏移量end[:步长step]]

切片操作时，起始偏移量和终止偏移量不在 [0,字符串长度-1] 这个范围，也不会报错。

起始偏移量 小于0 则会当做 0 ，终止偏移量 大于 “长度-1” 会被当成 ”长度-1”

print([10, 20, 30, 40][1:30])

成员资格判断:

成员资格判断

判断列表中是否存在指定的元素，我们可以使用 count() 方法，返回0则表示不存在，返回大于0则表示存在

但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回 True 或 False

a = [10, 20, 30, 40, 50, 20, 30, 20, 30]

print(20 in a)

print(20 not in a)

print(60 not in a)

列表排序:

sort(): 修改原列表，不建新列表的排序

sort(): 建新列表的排序

reversed(): 返回迭代器

列表排序

1.修改原列表，不建新列表的排序

sort() 默认升序, 参数 reverse 代表降序

a = [2, 3, 1, 5, 4]

print(id(a))

print(a.sort())

print(a)

a.sort(reverse=True)

print(a)

random.shuffle(a) # 打乱顺序

print(a)

2. 建新列表的排序

我们也可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

a = [20, 10, 30, 40]

print(id(a))

b = sorted(a)

c = sorted(a, reverse=True)

print(b, c)

3. reversed()返回迭代器

内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，

内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象

a = [20, 10, 30, 40]

b = reversed(a)

print(type(c))

print(list(c))

关于reversed()

我们打印输出c发现提示是：list_reverseiterator。也就是一个迭代对象。

同时，我们使用list(c)进行输出，发现只能使用一次。

第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。

max, min 和 sum

max, min用于返回列表中最大和最小值

sum 用于统计列表中各元素的和

列表相关的其他内置函数汇总

1. max和min

a = [3, 10, 20, 15, 9]

print(max(a))

print(min(a))

2. sum

print(sum(a))

多维列表

二维列表

一维列表可以帮助我们存储一维、线性的数据。

二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

队名 第几季 胜者

才子队 1 比尔

九头蛇队 2 皮尔斯

巨亨队 3 卡罗尔

二维表的访问方式:

a = [

["才子队", 1, "比尔"],

["九头蛇队", 2, "皮尔斯"],

["巨亨队", 3, "卡罗尔"],

]

输出单个元素

print(a[0][0], a[1][1], a[1][2])

嵌套循环打印二维列表所有的数据

for m in range(3):

for n in range(3):

print(a[m][n], end=" ")

print()