5月29号，Python列表

1 continue和break的用法

1.1 continue用法

• 用来跳过当次循环

我们用一个例子来说明：

i=0
while i<6:
    i+=1
    if i==2:
        continue
    print(i)
else:
    print('Shero')

大家可以想一想它会输出什么？
答案是：

1
3
4
5
6
Shero

这里涉及到三个要点：

• continue只能跳过当次的循环
• while语句结束后若有else语句，恒执行else
• 多重嵌套或者多语句时，要注意代码属于哪个语句的代码块，例如这里的print(i)是while语句的代码块而不是if语句的代码块。

1.2 break用法

• 用来退出循环语句，包括else语句

这里，我们同样使用上一个例子加以改变来说明，把continue改成break：

i=0
while i<6:
    i+=1
    if i==2:
        break
    print(i)
else:
    print('Shero')

当我们把continue改成break时，结果会发生什么变化呢？看结果：

1

break的出现使得当i为2时就退出了整个while循环，且注意break的退出是包括else语句的，因此只输出一个1。

2 列表

2.1 序列基本概念

• 用于保存一组有序的位置

• 计算机中数据的存储方式，不同的存放方式就是数据结构

• 所有的数据在序列当中都有⼀个唯⼀的位置（此即索引）

• 序列中的数据会按照添加的顺序来分配索引

• 分类：
  可变序列：列表、字典
  不可变序列：字符串、元组

2.2 列表基本概念

• 一个对象，内存中的一块区域
• 作用：保存多个有序数据

我们可以将列表比作“文具盒”，则整数、bool值、空值等一个个对象类比成“铅笔”、“橡皮”、“尺子”等文具，有文具盒（列表）的存在，使得它们（一个个对象）有序摆放（类似下面这样）。

2.3 列表的使用

2.3.1 创建

• 我们通过中括号[]创建列表：

lst=[]
print(type(lst))

可以得到这里的lst就是列表类型：

<class 'list'>

若想让列表保存多个元素，可以令：

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

或者

lst=[1,'hello',None,[2,3,4],True]

其中每个元素用逗号，隔开。

• 我们可以通过索引（index）来获取列表中的元素，索引从0开始。

print(lst[0])

得到：

1

输入：

print(lst[5])

得到错误提示，索引超出列表范围：

IndexError: list index out of range

• 我们可以用len()函数获得列表的长度或元素的个数

输入：

print(len(lst))

得到列表长度为：

5

它就等于列表的最大索引值+1

另外，我们思考：索引可以为负数吗？
答案是可以的，验证如下：

lst=[1,'hello',None,[2,3,4],True]
print(lst[-4])

得到：

hello

进一步，我们输入：

lst=[1,'hello',None,[2,3,4],True]
print(lst[-1])
print(lst[-2])
print(lst[-3])
print(lst[-4])
print(lst[-5])

得到：

True
[2, 3, 4]
None
hello
1

因此，我们不难发现如下规律：

索引值为负几，对应的就是列表的倒数第几个数。

2.3.2 切片

• 理解：获取某几个元素（就像切蛋糕）
• 完整定义：从现有列表中获取一个子列表
• 切片操作不会影响原列表，而是产生一个新的列表。
• 语法：列表[开始:结束:步长]

例如输入如下：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:2])

结果为：

['钢铁侠', '绿巨人']

因此，我们可以知道为2的索引值（对应的’蜘蛛侠’）并没有取到。

切片会包含起始位置的元素，而不包含结束位置的元素。（左取右不取）

我们再来探索：起始位置和结束位置的索引可不可以不写呢？
1、省略结束位置

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[1:])

得到：

['绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

因此，结束位置可以不写，此时系统会从当前的开始位置一直截取到列表最后。

2、省略开始位置

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[:3])

得到：

['钢铁侠', '绿巨人', '蜘蛛侠']

因此，开始位置可以不写，此时系统会从第一个元素一直截取到结束位置的元素，但注意不包括结束位置的元素。

3、结束位置和开始位置都省略

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[:])

得到：

['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

这也是可以的，此时系统会从第一个元素截取到最后一个元素。

接下来，我们考量步长：

• 当步长设置为1时，

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:5:1])
print(hero[0:5])

得到：

['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']
['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']

• 当步长设置为2时，

输入：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:5:2])

得到：

['钢铁侠', '蜘蛛侠', '蚁人']

隔一个取一个。

• 当步长设置为-2时，

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[::-2])

得到;

['美国队长', '黑寡妇', '绿巨人']

此时是从后往前取，隔一取一。因此我们不难得到，

步长就是每次获取元素的间隔，默认为1，可以省略，可以为负数，此时从后往前取，不能为0。

2.4 列表的通用操作

2.4.1 +号

• 将两个列表拼接为一个列表

lst=[1,2,3]+[4,5,6]
print(lst)

得到：

[1, 2, 3, 4, 5, 6]

2.4.2 *号

• 和整数相乘，就可以把列表重复指定的次数

先尝试列表与列表相乘：

lst=[1,2,3]*[4,5,6]
print(lst)

得到：

TypeError: can't multiply sequence by non-int of type 'list'

因此，列表与字符串类似，不能与自身同类型的相乘。

再用列表与整数相乘：

lst=[1,2,3]*3
print(lst)

得到：

[1, 2, 3, 1, 2, 3, 1, 2, 3]

2.4.3 in和not in

• in：用来检查指定的元素是否在列表中，如果在就返回True，不在就返回False
• not in：用来检查指定的元素是否不在列表中，如果不在就返回True，在就返回False

输入：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print('绿巨人' in hero)
print('小飞侠' in hero)
print('绿巨人' not in hero)

得到：

True
False
False

2.4.4 min()和max()

max()：获取列表中的最小值
min()：获取列表中的最大值

先对字符串比大小，按位比较，比的是对应的ASCII码值：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(max(hero),min(hero))

得到：

黑寡妇 绿巨人

再对数字进行比较：

lst=[100,5,99,6]
print(max(lst),min(lst))

结果很显然：

100 5

2.4.5 lst.index()和lst.count()

• lst.index()：获取指定元素在列表中的位置，也就是元素对应的索引值
• lst.count()：统计指定元素在列表中出现的次数

例如：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero.index('蜘蛛侠'))

得到：

2

现在问题来了，如果列表中出现了两个或多个‘蜘蛛侠’呢？结果会是什么？
例如：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.index('蜘蛛侠'))

得到：

2

结果不变，此时还是会返回第一次出现指定元素时的索引值，那如何找到后面的第二个、第三个呢？

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.index('蜘蛛侠'))
print(hero.index('蜘蛛侠',3))

如上，我们可以从索引值为3（上一个的索引值为2，因此我们越过它）的元素开始查找，或者也可以给它一个区间：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.index('蜘蛛侠'))
print(hero.index('蜘蛛侠',3,7))

结果不变。

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.count('蜘蛛侠'))

得到：

3

2.5 列表的修改

2.5.1 通过索引

我们输入：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print('修改前:',hero)
hero[0]='雷神'
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['雷神', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

此即通过索引来修改。

2.5.2 通过del

输入：

print('修改前:',hero)
del hero[2]
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

此时索引值为2的元素，即第三个元素被删除。

2.5.3 通过切片

输入：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print('修改前:',hero)
hero[0:3]='abcd'
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['a', 'b', 'c', 'd', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

此时，前三个元素用'a', 'b', 'c', 'd'这四个元素替换了。

我们可以再尝试输入：

print('修改前:',hero)
hero[0:3]=1234
print('修改后:',hero)

得到：

TypeError: can only assign an iterable

报错！因此，通过切片进行修改时必须传递一个序列！

下面再输入：

print('修改前:',hero)
hero[0:2]=['黑豹','雷神','灭霸']
print('修改后:',hero)

这里用三个元素来替换两个元素，必须可以！结果如下：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['黑豹', '雷神', '灭霸', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

而如果改成：

print('修改前:',hero)
hero[0:0]=['黑豹']
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['黑豹', '钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

只在索引为0的位置（最前面）插入了一个’黑豹’，别的元素都没有变化。

再考虑如下：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero[::2])

由前面不难知道，结果为隔一取一：

['钢铁侠', '蜘蛛侠', '蚁人', '蜘蛛侠']

而如果我们想用一个元素代替这四个元素，可以吗？

看结果：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero[::2])
hero[::2]=['雷神']

得到：

ValueError: attempt to assign sequence of size 1 to extended slice of size 4

答案是不行的，原因是：

当我们设置了步长，序列中元素的个数必须和切片中元素的个数保持一致。

例如，把上面改成：

hero=['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
hero[::2]=['','','','']
print(hero)

这样就不会报错了，得到：

['', '绿巨人', '', '黑寡妇', '', '美国队长', '', '蜘蛛侠']

切片还可用来删除元素：

print('修改前:',hero)
hero[1:3]=[]
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']
修改后: ['钢铁侠', '黑寡妇', '蚁人', '美国队长', '蜘蛛侠', '蜘蛛侠']

索引值为1和2的被删除了，也就是原列表中第二个元素和第三个元素被删除。

值得注意的是，以上这些操作只适用于可变序列，不可变序列例如字符串：

s='Python'
s[1]='j'
print(s)

得到：

TypeError: 'str' object does not support item assignment

若想对字符串修改的话，可以将其变成可变序列：

s='Python'
s=list(s)
s[1]='j'
print(s)

结果为：

['P', 'j', 't', 'h', 'o', 'n']

2.5 列表的方法

关于列表的方法，详细可查Python官网

2.5.1 append()

• 向列表的最后添加一个元素

若通过以下方法添加：

hero=['钢铁侠','绿巨人','蜘蛛侠']
print('修改前:',hero)
hero[3]='b'
print('修改后:',hero)

系统报错：

IndexError: list assignment index out of range

因此，我们用append()方法：

print('修改前:',hero)
hero.append('黑豹')
print('修改后:',hero)

这样得到列表的最后添加了一个‘黑豹’：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑豹']

2.5.2 insert()

• 向列表指定的位置添加一个元素
• 语法：insert(参数1，参数2)。其中参数1表示要插入的位置，即索引数；参数2表示要插入的元素。

输入：

print('修改前:',hero)
hero.insert(2,'黑豹')
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人', '黑豹', '蜘蛛侠']

2.5.3 extend()

• 使用新的序列来扩展当前的序列，可以传列表或多个元素至结尾

输入：

print('修改前:',hero)
hero.extend(123)
print('修改后:',hero)

得到：

TypeError: 'int' object is not iterable

参数有问题！extend方法要求一定要传序列！我们调整如下：

print('修改前:',hero)
hero.extend(['黑豹','蚁人'])
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人', '蜘蛛侠', '黑豹', '蚁人']

我们可知这里的extend相当于hero+=['黑豹','蚁人']

注意，append方法一次只能添加一个，extend方法可以传列表或多个元素至结尾

2.5.4 clear()

• 清空集合

print('修改前:',hero)
hero.clear()
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: []

2.5.5 pop()

• 根据索引删除并返回指定的元素

print('修改前:',hero)
hero.pop(2)
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人']

第三个元素被删除了，但是注意：pop方法是有返回值的！比如：

hero=['钢铁侠','绿巨人','蜘蛛侠']
print(hero.pop(2))

得到：

蜘蛛侠

另外，当我们不传索引时，

print('修改前:',hero)
hero.pop()
print('修改后:',hero)

结果会删除最后一个元素：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '绿巨人']

2.5.6 remove()

• 根据指定的值删除元素

输入：

print('修改前:',hero)
hero.remove('绿巨人')
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠']
修改后: ['钢铁侠', '蜘蛛侠']

当有多个相同元素的值时，只会删除第一个值：

print('修改前:',hero)
hero.remove('绿巨人')
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
修改后: ['钢铁侠', '蜘蛛侠', '绿巨人']

2.5.7 reverse()

• 反转列表

print('修改前:',hero)
hero.reverse()
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
修改后: ['绿巨人', '蜘蛛侠', '绿巨人', '钢铁侠']

2.5.8 sort()

• 对列表中的元素进行排序

print('修改前:',hero)
hero.sort()
print('修改后:',hero)

得到：

修改前: ['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
修改后: ['绿巨人', '绿巨人', '蜘蛛侠', '钢铁侠']

再对字母排序：

print('修改前:',hero)
hero.sort()
print('修改后:',hero)

得到：

修改前: ['c', 'a', 'f', 'r', 'h', 'f', 'v', 's', 'd', 'g', 's', 'l']
修改后: ['a', 'c', 'd', 'f', 'f', 'g', 'h', 'l', 'r', 's', 's', 'v']

注意，reverse方法默认升序排列，如果想降序排列：

print('修改前:',hero)
hero.sort(reverse=True)
print('修改后:',hero)

得到：

修改前: ['c', 'a', 'f', 'r', 'h', 'f', 'v', 's', 'd', 'g', 's', 'l']
修改后: ['v', 's', 's', 'r', 'l', 'h', 'g', 'f', 'f', 'd', 'c', 'a']

Jerry名言：编程需要积累，切忌往前赶，多回头看！

2.6 列表的遍历

• 将列表中的元素取出来

当我们想将列表中的元素取出来时，固然可以用：

hero=['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
print(hero[0])
print(hero[1])
print(hero[2])
print(hero[3])

确实可以得到：

钢铁侠
绿巨人
蜘蛛侠
绿巨人

但是这样有一个最大的弊端：不灵活。我们首先考虑之前学过的while语句：

hero=['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
i=0
while i<4:
    print(hero[i])
    i+=1

得到遍历：

钢铁侠
绿巨人
蜘蛛侠
绿巨人

注意，这里的i<4最好不要写死了，改成i<len(hero)更好。

2.6.1 for循环

同样是上面的问题，我们考虑用for循环来遍历列表。
语法：

for 变量 in 序列:
    代码块

我们通过变量来获取列表中的每一个元素，举例如下：

hero=['钢铁侠', '绿巨人', '蜘蛛侠', '绿巨人']
for h in hero:
    print(h)

其中h对应列表里的每一个元素，得到：

钢铁侠
绿巨人
蜘蛛侠
绿巨人

注意，for循环的代码块会执行多次，序列中有几个元素，就执行几次，每执行一次就会将序列中的一个元素赋值给变量。

2.6.2 range()

• 常常和for循环配合使用
• 语法：range(开始,结束,步长)
  其中，开始默认是0，可省略，range(5)等价于range(0,5)；
  不包含结束，list(range(0,5))等价于[0,1,2,3,4]；
  步长默认为1，range(5)等价于range(0,5)等价于range(0,5,1)。

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

由此我们找到了列表中的奇数：

1
3
5
7
9

又例如：

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

得到：

1
2
3
4
5

因此，range(5)就是循环5次，括号中是几就循环几次。

3 两个小问题