列表

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

列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式： a = [10,20,30,40] 其中，10,20,30,40 这些称为：列表 a 的元素。

方法	要点	描述
list.append(x)	增加元素	将元素 x 增加到列表 list 尾部
list.extend(aList)	增加元素	将列表 alist 所有元素加到列表 list 尾部
list.insert(index,x)	增加元素	在列表 list 指定位置 index 处插入元素 x
list.remove(x)	删除元素	在列表 list 中删除首次出现的指定元素 x
list.pop([index])	删除元素	删除并返回列表 list 指定为止 index 处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表所有元素，并不是删除列表对象
list.index(x)	访问元素	返回第一个 x 的索引位置，若不存在 x 元素抛出异常
list.count(x)	计数	返回指定元素 x 在列表 list 中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝

Python 的列表大小可变，根据需要随时增加或缩小。

range()创建整数列表

ange()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：

range([start,] end [,step])

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

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

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

切片操作

切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：

[起始偏移量 start:终止偏移量 end[:步长 step]]

注：当步长省略时顺便可以省略第二个冒号

典型操作(三个量为正数的情况)如下：

操作和说明	示例	结果
[:]     提取整个列表	[10,20,30][:]	[10,20,30]
[start:]从 start 索引开始到 结尾	[10,20,30][1:]	[20,30]
[:end]从头开始知道 end-1	[10,20,30][:2]	[10,20]
[start:end]从 start 到 end-1	[10,20,30,40][1:3]	[20,30]
[start:end:step] 从 start 提 取到 end-1，步长是 step	[10,20,30,40,50,60,70][1:6: 2]	[20, 40, 60]

其他操作（三个量为负数）的情况：

示例	说明	结果
[10,20,30,40,50,60,70][-3:]	倒数三个	[50,60,70]
10,20,30,40,50,60,70][-5:-3]	倒数第五个到倒数第三个(包头不包尾)	[30,40]
[10,20,30,40,50,60,70][::-1]	步长为负，从右到左反向提取	[70, 60, 50, 40, 30, 20, 10]

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

偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成”长度-1”。例如：

>>> [10,20,30,40][1:30]

[20, 30, 40]

我们发现正常输出了结果，没有报错。

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

>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a.sort()	#默认是升序排列
>>> a
[10, 20, 30, 40]
>>> a = [10,20,30,40]
>>> a.sort(reverse=True)	#降序排列
>>> a
[40, 30, 20, 10]
>>> import random
>>> random.shuffle(a)	#打乱顺序
>>> a
[20, 40, 30, 10]

二维列表

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

元组

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如下操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

元组的创建

1. 通过()创建元组。小括号可以省略。
   1. = (10,20,30)     或者       a = 10,20,30

如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,) 解释为元组。

>>> a = (1)

>>> type(a)

<class 'int'>

         >>> a = (1,)         #或者    a = 1,

>>> type(a)

<class 'tuple'>

1. 通过 tuple()创建元组 tuple(可迭代的对象) 例如：
   1. = tuple()  #创建一个空元组对象 b = tuple("abc") b = tuple(range(3)) b = tuple([2,3,4])

总结： tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。

list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

 元组的元素访问和计数

1. 元组的元素不能修改
2. 元组的元素访问和列表一样，只不过返回的仍然是元组对象。
3. 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

zip

zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

>>> a = [10,20,30]

>>> b = [40,50,60]

>>> c = [70,80,90]

>>> d = zip(a,b,c)

>>> list(d)

[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

元组总结

1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

随堂训练

#创建列表
a = list(range(10))
print(a)

#通过if过滤，循环创建多个变量
b = [x*2 for x in range(0,10,2)if x%8 == 0]
print(b)

#列表添加、删除
c=[20,40]
c.append(80)
print(c)
del c[1]
print(c)
#删除指定位置并返回该元素
d=c.pop()
print(c)
print(d)

#打印二维列表
a= [
    ["ding1",18,"shang hai"],
    ["ding2",19,"hang zhou"],
    ["ding3",20,"bei jing"]
]
for m in range(3):
    for n in range(3):
        print(a[m][n],end="\t")
    print("")