Python列表基础操作汇总
1. 序列（sequence）
1.1 基本概念
序列是 Python语言 中最基本的一种数据结构。数据结构是指计算机中数据存储的方式，序列用于 保存一组有序的数据 。所有的数据在序列当中都有一个 唯一的位置（索引） ，并且序列中的数据会按照添加的顺序来分配索引。
Python语言 有6个序列的内置类型，但最常见的是 列表 和 元组 。
序列 都可以进行的操作包括 索引，切片，加，乘，检查成员。
此外，Python语言 已经内置确定序列的长度以及确定最大和最小的元素的方法。
1.2 序列的分类
可变序列（序列中的元素可以改变）：例如 列表（list）、字典(dict) …
不可变序列（序列中的元素不能改变）：例如 字符串（str）、元组（tuple）…
2. 列表(list)
列表 是最常用的 Python语言 的数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表 的数据项 不需要 具有相同的类型。
列表 是 Python语言 中的一个 对象 。
列表的作用：
1）列表中可以保存多个有序的数据；
2）列表是用来存储 对象的对象。
2.1 列表的使用
列表的创建：
通过 xxx = [ ] 来创建一个空列表。
参考案例：
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
2.2 切片（实操、面试 必备的基础技能）
切片是指从现有列表中获得一个子列表。
通过切片来获取指定的元素。
语法: 列表名[起始索引 ：结束索引 ：步长]
Python的列表截取切片与字符串操作类型，如下所示：
L=['Google', 'Runoob', 'Taobao']
Python的列表操作：
具体代码：
>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
我们看一个稍微复杂点的参考案例：
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人']
# 做切片操作时，每次获取的都是初始列表，不是切过后的列表，不会影响原始列表
# 起始位置和结束位置的索引可以不写
print(hero)
# ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']
# 切片时指定起始位置和结束位置的索引后获取的结果
print(hero[1:3])
# ['钢铁侠', '绿巨人']
# 如果省略结束位置，则会从当前位置开始一直截取到最后；
print(hero[1:])
# ['钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']
# 如果省略开始位置，则会从第一个元素开始截取到结束位置的元素，但不包含结束位置的元素；
print(hero[:3])
# ['蜘蛛侠', '钢铁侠', '绿巨人']
# 如果省略开始和结束的位置，则会从第一个元素截取到最后一个元素
print(hero[:])
# ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']
# 步长：表示每次获取元素的间隔 默认为1 可以省略
print(hero[::2])
# ['蜘蛛侠', '绿巨人', '美国队长']
# 步长不能为 0
print(hero[::0])
# ValueError: slice step cannot be zero
# 步长可以为负数，
print(hero[::-1])
# ['蚁人', '美国队长', '黑寡妇', '绿巨人', '钢铁侠', '蜘蛛侠']
通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素；
起始位置 和 结束位置 的索引可以不写；
如果省略结束位置，则会 从当前的位置开始 一直截取到最后；
如果省略开始位置，则会从第一个元素截取到结束的元素，但是不包括结束的元素；
如果开始位置和结束位置都省略, 则会从第一个元素开始截取到最后一个元素。
步长 表示每次获取元素的间隔，默认是1(可以省略不写)；
步长 不能是0,但可以是是 负数（从后向前的获取列表中的元素）。
3. 通用操作
+ 和 *
+ 可以将 两个列表 拼接成 一个列表；
* 可以将 列表内的元素重复指定的次数 (注意：2个列表不能够做乘法，要和整数做乘法运算。)
# + 表示 可以将两个列表拼接成一个列表
lst = [1,2,3] + [4,5,6]
print(lst)
# [1, 2, 3, 4, 5, 6]
# * 表示将列表中的元素指定重复次数
lst = [1,2,3] * 2
print(lst)
# [1, 2, 3, 1, 2, 3]
# 列表和列表不能相乘
lst = [1,2,3] * [4,5,6]
print(lst)
# TypeError: can't multiply sequence by non-int of type 'list'
in 和 not in
in 用来检查指定元素是否在列表当中；
not in 用来检查指定元素是否不在列表当中。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']
print('雷声' in hero)
# False
print('雷声' not in hero)
# True
len() 获取列表中元素的个数
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']
print(len(hero))
# 10
对 Python列表脚本操作符简单汇总表：
max() 获取列表中最大值
min() 获取列表中最小值
lstt = [11,2,5,999,8,3333]
print(max(lstt))
# 3333
print(min(lstt))
# 11
list.index( x[, start[, end]] )
第一个参数 获取在列表中指定的元素
第二个参数 表示查找的起始位置
第三个参数 表示查找的结束位置
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']
print(hero.index('钢铁侠',4,9))
# 6
list.count(x) 统计指定元素在列表中出现的个数
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']
print(hero.count('钢铁侠'))
# 5
print(hero.count('蝙蝠侠'))
# 0
4. 嵌套列表
使用嵌套列表即在列表里创建其它列表，例如：
>>>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'
5. 修改列表
通过 切片 来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
hero[6] = 'b'
# IndexError: list assignment index out of range
通过切片来删除列表中的元素
del list[元素索引] ：删除列表里元素索引指向的元素。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
del hero[2]
print ("删除第三个元素", hero)
# 删除第三个元素 ['蜘蛛侠', '钢铁侠', '黑寡妇']
list(seq) 方法用于将元组或字符串转换为列表。
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
# 列表元素 : [123, 'Google', 'Runoob', 'Taobao']
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
# 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
6. 对列表进行 增·删·改·查 的几种方法
6.1 增
1） append(obj) ：向列表的最后添加一个元素；
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.append('灭霸')
print('修改后',hero)
# 修改后 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '灭霸']
2） insert(arg1,arg2) ：向列表指定位置插入一个元素；参数1:要插入的位置，参数2:要插入的元素；新插入的元素 不会替换掉 原位置上的元素，而是将原位置上的元素 向后的挤 了一个位置。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.insert(2,'灭霸')
print('修改后',hero)
# 修改后 ['蜘蛛侠', '钢铁侠', '灭霸', '绿巨人', '黑寡妇']
3） extend(seq) ：使用一个新的序列来 扩展 当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列。
参数 seq ：元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
list1 = ['Google', 'Runoob', 'CSDN', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2) # 扩展列表
print ("扩展后的列表：", list1)
# 扩展后的列表： ['Google', 'Runoob', 'CSDN', 'Taobao', 0, 1, 2, 3, 4]
6.2 删
1） del list[元素索引] ：删除列表里元素索引指向的元素。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
del hero[2]
print ("删除第三个元素", hero)
# 删除第三个元素 ['蜘蛛侠', '钢铁侠', '黑寡妇']
2） pop() ：根据索引删除指定元素，并返回完成删除后的序列 (在使用 pop()函数 时没有添加指定索引，默认删除最后一个元素)；
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.pop()
print ("列表现在为 : ", hero)
# 列表现在为 : ['蜘蛛侠','钢铁侠','绿巨人']
hero.pop(1)
print ("列表现在为 : ", hero)
# 列表现在为 : ['蜘蛛侠', '绿巨人']
3） remove() ：删除 指定元素 (如果与这 指定元素 相同值的元素有多个，只会删除列表里的第一个)；
hero = ['蜘蛛侠','钢铁侠','绿巨人','绿巨人','黑寡妇','钢铁侠','钢铁侠']
print ("修改前", hero)
# 修改前 ['蜘蛛侠','钢铁侠','绿巨人','绿巨人','黑寡妇','钢铁侠','钢铁侠']
hero.remove('蜘蛛侠')
print ("列表现在为 : ", hero)
# 列表现在为 : ['钢铁侠', '绿巨人', '绿巨人', '黑寡妇', '钢铁侠', '钢铁侠']
hero.remove('钢铁侠')
print ("列表现在为 : ", hero)
# 列表现在为 : ['绿巨人', '绿巨人', '黑寡妇', '钢铁侠', '钢铁侠']
4） clear() ：函数用于 清空列表，类似于上面的 del a[:]。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.clear()
print ("列表清空后 : ", hero)
# 列表清空后 : []
6.3 改
1） reverse() ：翻转列表
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.reverse()
print ("列表现在为 : ", hero)
# 列表现在为 : ['黑寡妇', '绿巨人', '钢铁侠', '蜘蛛侠']
2） sort(key=None,reverse=False) ：用来对列表中的元素进行排序。reverse：True反序；False 正序
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.sort()
print ("列表现在为 : ",hero)
# 列表现在为 : ['绿巨人', '蜘蛛侠', '钢铁侠', '黑寡妇']
#-----------------------------------------------------------
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
# 降序
vowels.sort(reverse=True)
# 输出结果
print ( '降序输出:', vowels )
# 降序输出: ['u', 'o', 'i', 'e', 'a']
#-----------------------------------------------------------
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print ('新排序列表：', random)
# 新排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
3） copy() 函数用于 复制列表，类似于 a[:]。
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
hero2 = hero.copy()
print ("hero2 列表: ", hero2)
# hero2 列表: ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
hero.append('灭霸')
print ("hero 列表: ", hero)
# hero 列表: ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '灭霸']
print ("hero2 列表: ", hero2)
# hero2 列表: ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']
7. 遍历列表
7.1 for循环
通过 for循环 来遍历列表
for循环 语法
for 变量 in 序列(遍历的规则):
代码块
参考案例
heros = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','灭霸','钢铁侠']
for hero in heros:
if hero == '灭霸':
print('灭霸--最后的BOSS')
break
print("登场英雄：",hero)
else:
print("没有循环数据!")
print("完成循环!")
# 登场英雄： 蜘蛛侠
# 登场英雄： 钢铁侠
# 登场英雄： 绿巨人
# 登场英雄： 黑寡妇
# 登场英雄： 美国队长
# 登场英雄： 蚁人
# 登场英雄： 钢铁侠
# 登场英雄： 钢铁侠
# 登场英雄： 钢铁侠
# 灭霸--最后的BOSS
# 完成循环!
注意: for循环的代码块会执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量，所以我们可以通过变量来获取列表中的元素。
7.2 range(start, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
>>>for i in range(5):
... print(i)
...
0
1
2
3
4
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
>>>for i in range(5,9) :
... print(i)
...
5
6
7
8
>>>
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
>>>for i in range(0, 10, 3) :
... print(i)
...
0
3
6
9
>>>
start、stop、step 可以为负数
>>>for i in range(-10, -100, -30) :
... print(i)
...
-10
-40
-70
>>>
结合 range() 和 len() 函数以遍历一个序列的索引，如下案例所示：
hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
>>> for i in range(len(hero)):
... print(i, hero[i])
...
0 蜘蛛侠
1 钢铁侠
2 绿巨人
3 黑寡妇
还可以使用 range() 函数来创建一个列表：
>>>list(range(5))
[0, 1, 2, 3, 4]
>>>
总结小便条
本篇文章主要讲了以下几点内容：
-
序列是 Python语言 中最基本的一种数据结构。
-
序列分为：可变序列（序列中的元素可以改变） 和 不可变序列（序列中的元素不能改变）
2.1 可变序列 ：例如 列表（list）、字典(dict) …
2.2.不可变序列 ：例如 字符串（str）、元组（tuple）… -
我们今天除了介绍 Python语言 中的序列，更重要的讲的是列表。那什么是列表？
答：列表 是最常用的 Python语言 的数据类型，它可以作为一个方括号内的逗号分隔值的形式出现。这个样子： xxx = [ ] -
即然知道什么是列表了，那我们要怎么 使用它 ？
答：第一个，毫无疑问：切片。（这是 实操、面试 必备的基础技能）
列表切片的语法: 列表名[起始索引 ：结束索引 ：步长]
查看切出来的子元素的方式：print(列表名[起始索引 ：结束索引 ：步长])第二个，作为 “魔鬼” 的代名词的列表怎么会只有这一种简单的操作。
多列表的合并 ( lst = [1,2,3] + [4,5,6] )
列表中的元素多次的重复 ( lst = [1,2,3] * 2 )
判断元素x是否在列表中 ( print(‘x’ in/not in lst) )
列表中有多少元素 ( print(len(lst)) )
获取列表中 最大( max(lst) )/小( min(lst) )值
统计指定元素在列表中的指定区间出现的个数( list.index(‘x’,起始位置,结束位置) )
统计指定元素在列表中出现的个数( list.count(x) )第三个，列表的 增·删·改·查
我们单独的拎出了两大块，分别在 第4块 讲解了 列表的特殊“增”–嵌套列表 和 第5块 列表的特殊“删·改”–修改列表。
第4块 嵌套列表：将多个列表合并进一个大(父)列表里。
第5块 修改列表：通过“切片”的步长和指向修改列表里指定的值。
第6块 增：append(obj) ：向列表的最后添加一个元素；
insert(arg1,arg2) ：向列表指定位置插入一个元素，新插入的元素 不会替换掉 原位置上的元素；
extend(seq) ：使用一个新的序列来 扩展 当前序列；删：del list[元素索引] ：删除列表里元素索引指向的元素；
pop() ：根据索引删除指定元素，并返回完成删除后的序列 (在使用 pop()函数 时没有添加指定索引，默认删除最后一个元素)；
remove() ：删除 指定元素 (如果与这 指定元素 相同值的元素有多个，只会删除列表里的第一个)；
clear() ：函数用于 清空列表，类似于上面的 del a[:]；改：reverse() ：翻转列表；
sort(key=None,reverse=False) ：用来对列表中的元素进行排序；
copy() ：函数用于 复制列表，类似于 a[:] ；查：最简单，四个字 切片操作。
第四个，列表的循环遍历 for 循环：
for循环 的代码块会 执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量一次，所以我们可以通过变量来获取列表中的元素。 具体怎么个 for循环 看案例里的源代码。
在用 for 循环遍历列表时，使用 range()函数 和 len()函数 这两个函数来辅助遍历，打印出来的数据会更加的简介明了，阅读时会更加的方便。 具体怎么使用，回顾上面案例里的源代码。
本章回顾暂时就到这了，如果还有点晕，那就去完成作业吧。拜拜~
课程作业
1. 将本篇博客所讲的所有内容自己练习多编；
2. 现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程。
3. 实现列表推导式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4. 通过 for循环 的循环嵌套实现 [9,6,7,3,2,1,5,8] 数列的排序。(面试必考：冒泡循环。最基础的循环遍历排序)
5. 现有两个列表 i_1 = [11, 22, 33] 和 i_2 = [22, 33, 44]，获取两个列表当中相同的元素。
参考答案
# 作业 2
# 本题，与其说是计算机面试考题，不如说是是一道对语文·阅读理解的考题；本题的核心考点是：面试者对 列表的“切片操作” 的理解。
a = [1,2,3,4,5,6]
# 考点 列表当中的切片
# 起始位置和结束位置的索引可以不写
# 如果我省略结束位置，则会从当前的开始位置一直截取到最后；
print(a[1:])
# [2, 3, 4, 5, 6]
# 如果省略开始位置，则会从第一个元素截取到结束位置的元素，但是不包括结束的元素；
print(a[:3])
# [1, 2, 3]
# 如果开始位置和结束位置都省略，则会从第一个元素截取到最后一个元素。
print(a[:])
# [1,2,3,4,5,6]
# 语法 列表[起始:结束:步长]
print(a[0:5])
# [1, 2, 3, 4, 5]
print(a[0:5:1])
# [1, 2, 3, 4, 5]
print(a[::2])
# [1, 3, 5]
# 如果步长为负从右往左取值
print(a[4:1:-1])
# [5, 4, 3]
# 最后，如果想不通过函数的形式实现列表 a = [1,2,3,4,5,6] 的反转([6,5,4,3,2,1])。
print(a[::-1])
# [6, 5, 4, 3, 2, 1]
#-----------------------------------------------------------------------------------
# 3. 实现列表推导式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
i = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print([i for i in range(10)])
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([i*i for i in range(10)])
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#-----------------------------------------------------------------------------------
# 4. 通过 for循环 的循环嵌套实现 [9,6,7,3,2,1,5,8] 数列的排序。
# 对列表实现 [9,6,7,3,2,1,5,8] 数列的排序最简单的方法当然是 函数 i.sort()。
# i = [9,6,7,3,2,1,5,8]
# i.sort()
# print(i)
# 但本题的考点表达是：通过 for循环 的循环嵌套，通过 “冒泡排序” 的方式实现 [9,6,7,3,2,1,5,8] 数列的排序。所以：
def fun(arr):
n = len(arr)
# 遍历所有数组元素
for a in range(n):
# print(a)
# Last a elements are already in place
for b in range(0, n-a-1):
# print(b,end='')
if arr[b] > arr[b + 1]:
arr[b], arr[b + 1] = arr[b + 1], arr[b]
# print(arr[b], end='')
arr = [9,6,7,3,2,1,5,8]
fun(arr)
print(arr)
print("排序后的数组:")
for a in range(len(arr)):
print("%d" % arr[a])
# 输出结果你自己去测试吧。
#-----------------------------------------------------------------------------------
# 5. 现有两个列表 i_1 = [11, 22, 33] 和 i_2 = [22, 33, 44]，获取两个列表当中相同的元素。
i1 = [11, 22, 33]
i2 = [22, 33, 44]
# 方案 1.
for l1 in i1:
for l2 in i2:
if l1 == l2:
print(l1)
# 方案 2.
for l1 in i1:
if l1 in i2:
print(l1)