列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。
不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）

特点

  • 有序，可通过索引取值。
  • 可变，可以添加、修改、删除元素。

1.定义

定义空列表

  1. a = [] # 语法一
  2. a = list() # 语法二

定义非空列表

  1. user_list = ["大老师", "小老师", "小泽玛丽"]
  2. number_list = [66, 8, 666, 9, -1]
  3. data_list = [1, True, "ecithy", "沐风",]

我们发现，列表的元素数据类型可以不相同。

2.操作

2.1.增

追加

在原列表中尾部追加值。

list.append(x) 在列表末尾添加一个元素，相当于 a[len(a):] = [x]

  1. data_list = []
  3. v1 = input("请输入姓名")
  4. data_list.append(v1)
  6. v2 = input("请输入姓名")
  7. data_list.append(v2)
  9. print(data_list) # ["mufeng","deepwind"]

批量追加

将一个列表中的元素逐一添加另外一个列表。

list.extend(iterable) 用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable 。

  1. tools = ["上班", "搬砖", "下班"]
  2. value = [111, 222, 333]
  3. tools.extend(value)  # value 中的值逐一追加到tools中
  4. print(tools)  # ["上班","搬砖","下班",11,22,33]

拼接

两个列表相加获取生成一个新的列表。

  1. data = ["张三", "李四"] + ["王二", "金莲"]
  2. print(data)  # ["张三","李四","王二","金莲"]
  4. v1 = ["张三", "李四"]
  5. v2 = ["王二", "金莲"]
  6. v3 = v1 + v2
  7. print(v3)  # ["张三","李四","王二","金莲"]

插入

在原列表的指定索引位置插入值

list.insert(i, x) 在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0, x) 在列表开头插入元素， a.insert(len(a), x) 等同于 a.append(x) 。

  1. user_list = ["大老师", "中老师", "小老师"]
  2. user_list.insert(0, "沐风")
  3. user_list.insert(2, "精易")
  4. print(user_list)  # ['沐风', '大老师', '精易', '中老师', '小老师']

2.2.删

根据值删除

list.remove(x) 从列表中删除第一个值为 x 的元素。未找到指定元素时，触发 ValueError 异常

  1. user_list = ["大老师", "中老师", "小老师", "沐风", "精易"]
  2. user_list.remove("精易")
  3. print(user_list)  # ['大老师', '中老师', '小老师', '沐风']

根据索引删除

list.pop([i])，等效于del user_list[i] 删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，a.pop() 删除并返回列表的最后一个元素。（方法签名中 i 两边的方括号表示该参数是可选的，不是要求输入方括号。这种表示法常见于 Python 参考库）。

  1. # 删除
  2. user_list = ["大老师", "中老师", "小老师", "沐风", "精易"]
  3. user_list.pop(1)
  4. print(user_list)  # ['大老师', '小老师', '沐风', '精易']
  6. user_list.pop()  # 移除末尾元素
  7. print(user_list)  # ['大老师', '小老师', '沐风']
  1. # 批量删除
  2. user_list = ["金莲", "门庆", '大郎', "盖伦", "宝玉"]
  3. #              0      1      2       3      4
  4. del user_list[1:]
  5. print(user_list)  # ['金莲']

清空列表

删除列表里的所有元素，相当于 del a[:] 。

  1. user_list = ["大老师", "中老师", "小老师", "沐风", "精易"]
  2. user_list.clear()
  3. print(user_list)  # []

2.3.改

根据索引修改值

  1. user_list = ["王二", "金莲", '门庆']
  2. user_list[2] = "沐风"
  3. print(user_list)  # ['王二', '金莲', '沐风']

重复

列表*整型 将列表中的元素再创建N份并生成一个新的列表。

  1. v1 = ["王二","金莲"]
  2. v2 = v1 * 2
  3. print(v2)  # ['王二', '金莲', '王二', '金莲']

2.4.查

根据索引获取值

  1. # 一个元素的操作
  2. user_list = ["王二", "金莲", '门庆']
  3. print(user_list[0])
  4. print(user_list[2])
  5. print(user_list[3])  # 报错
  1. # 多个元素的操作
  2. user_list = ["金莲", "门庆", '大郎', "盖伦", "宝玉"]
  3. #              0      1      2       3      4
  4. print(user_list[1:4:2])  # ['门庆', '盖伦']
  5. print(user_list[0::2])   # ['金莲', '大郎', '宝玉']
  6. print(user_list[1::2])   # ['门庆', '盖伦']
  7. print(user_list[4:1:-1]) # ['宝玉', '盖伦', '大郎']

根据值获取索引

list.index(x[, start[, end]]) 返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时，触发 ValueError 异常。

可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。

  1. user_list = ['精易', '沐风', '小老师', '中老师', '大老师']
  2. #               0       1      2       3      4
  3. if "沐风" in user_list:
  4.     index = user_list.index("沐风")
  5.     print(index)  # 2
  6. else:
  7.     print("不存在")

遍历

元组和列表是类似的数据结构，遍历方式一样，这里演示遍历列表皆可

  1. # 得到值
  2. words = ['cat', 'window', 'defenestrate']
  3. for v in words:
  4.     print(v)

输出:
cat
window
defenestrate

  1. # 得到索引和值
  2. words = ['cat', 'window', 'defenestrate']
  3. for v in enumerate(words):
  4.     print(v)

输出:
(0, ‘cat’)
(1, ‘window’)
(2, ‘defenestrate’)

  1. for index, v in enumerate(words):
  2.     print(index, v)

输出:
0 cat
1 window
2 defenestrate

2.5.排序

list.sort(*, key=None, reverse=False) 就地排序列表中的元素（要了解自定义排序参数，详见 sorted()）。

数字排序

  1. num_list = [11, 22, 6, 5, 11, 33, 88]
  2. num_list.sort()  # 让num_list从小到大排序
  3. print(num_list)  # [5, 6, 11, 11, 22, 33, 88]
  4. num_list.sort(reverse=True)  # # 让num_list从大到小排序
  5. print(num_list)  # [88, 33, 22, 11, 11, 6, 5]

字符串排序

从前到后依次对比每个元素的ASCII值。
得到字符ASCII

  1. print('老', ord('老'))  # 老 32769
  2. print('精', ord('精'))  # 老 31934
  3. print('沐', ord('沐'))  # 老 27792
  4. print('小', ord('小'))  # 小 23567
  5. print('大', ord('大'))  # 老 22823
  6. print('中', ord('中'))  # 老 20013
  7. print('老', ord('老'))  # 老 32769
  1. # eg.1
  3. user_list = ["大老师", "中老师", "小老师", "沐风", "精易"]
  4. user_list.sort()
  5. print(user_list)  # ['中老师', '大老师', '小老师', '沐风', '精易']
  1. # eg.2
  2. # 解析：'大小老师'和'大老师'的第一个字符都是'大'，则继续往后比较前者的'小'和后者的'老'
  3. user_list = ["大老师", "中老师", "大小老师", "沐风", "精易"]
  5. user_list.sort()
  6. print(user_list)  # ['中老师', '大小老师', '大老师', '沐风', '精易']
  8. user_list.sort(reverse=True)  # # 让num_list从大到小排序
  9. print(user_list)  # ['精易', '沐风', '大老师', '大小老师', '中老师']

反转

  1. user_list = ["大老师", "中老师", "小老师", "沐风", "精易"]
  2. user_list.reverse()
  4. print(user_list)  # ['精易', '沐风', '小老师', '中老师', '大老师']

2.6.统计

某个元素个数

list.count(x) 返回列表中元素 x出现的次数。

  1. score_list = [66, 88, 99, 66, 10]
  2. print(score_list.count(66))  # 2

列表长度

  1. v1 = ["王二", "金莲"]
  2. print(len(v1))  # 2
  4. v2 = v1 * 2
  5. print(v2)  # ['王二', '金莲', '王二', '金莲']
  6. print(len(v2))  # 4

是否存在

  1. score_list = [66, 88, 99, 66, 10]
  2. print(66 in score_list)  # True
  3. print('hi' in score_list)  # False
  5. score_list = [66, [88, 99], 66, 10]
  6. print([88, 99] in score_list)  # True

2.7.类型转换

int、bool无法转换成列表

str转list

  1. name = "沐风开发与分析"
  3. data = list(name)  # ['沐', '风', '开', '发', '与', '分', '析']
  4. print(data)

tuple转list

  1. v1 = (11, 22, 33, 44)  # 元组
  2. vv1 = list(v1)  # 列表 [11,22,33,44]

dict转list

  1. info = {'age': '16', 'name': 'ecithy', 'gender': '男'}
  2. print(list(info.keys()))  # ['age', 'name', 'gender']
  3. print(list(info.values()))  # ['16', 'ecithy', '男']

set转list

  1. v2 = {"deepwind", "ecithy", "mufeng"}  # 集合
  2. vv2 = list(v2)  # 列表 ['ecithy', 'deepwind', 'mufeng']

3.拓展

之前我们已经发现，列表的元素数据类型可以不相同。
其实，列表的元素不仅仅可以是一个简单类型：比如数字，字符串，还可以是复杂类型：比如列表，元组，字典，集合等。如：

  1. data = ["mufeng", ["海燕", "赵本山"], True, [11, 22, [999, 123], 33, 44], ["王二", "金莲"]]