06 列表

1. 序列（sequence）

1.1 基本概念

-序列是Python中最基本的⼀种数据结构。序列⽤于保存⼀组有序的数据，所有的数据在序列当中都有⼀个唯⼀的位置（索引）并且序列中的数据会按照添加的顺序来分配索引

• 数据结构指计算机中数据存储的⽅式

1.2 序列的分类

• 可变序列（序列中的元素可以改变）：
  例如 列表（list）字典(dict)
• 不可变序列（序列中的元素不能改变）：
  例如 字符串（str）整数 （int）元组（tuple）

2. 列表(list)

• 列表是Python中的⼀个对象
• 列表里面存储的数据我们称之为元素

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

• 列表的作⽤
  列表中可以保存多个有序的数据
  列表是⽤来存储对象的对象
  列表可以保存任意的对象

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

2.1 列表的使⽤

• 列表的创建：通过[]来创建⼀个空列表

lst = []

• 在列表当中可以通过索引(index)或者下标来获取列表中的元素
• 索引是从0开始 列表的第一个位置的索引就是0 以此类推
• IndexError: list index out of range 超出最大索引值就会报错

lst = [10,20,30,40,50]
print(lst[-1])
print(lst[2])

2.2 切⽚

• 切⽚是指从现有列表中获得⼀个⼦列表
• 通过切⽚来获取指定的元素
• 语法: 列表[起始 : 结束 : 步⻓]
• 通过切⽚获取元素时,会包括起始位置的元素,不会包括结束位置的元素
• 做切片操作时，总会返回一个新的列表，不会影响原来的列表

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero)
h = hero[0:2]
print(h) # ['钢铁侠', '葫芦娃']
print(hero) # ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']

• 起始位置和结束位置的索引可以不写
  如果省略结束位置, 则会从当前的开始位置⼀直截取到最后

print(hero[2:])

如果省略开始位置, 则会从第⼀个元素截取到结束的元素，但是不包括结束的元素

print(hero[:3])

如果开始位置和结束位置都省略, 则会从第⼀个元素开始截取到最后⼀个元素
print(hero[:])

• 步⻓表示每次获取元素的间隔，默认是1(可以省略不写)
• 步⻓不能是0,但可以是是负数

print(hero[0:5:2])
print(hero[::0]) # ValueError: slice step cannot be zero

练习：现在有 a = [1,2,3,4,5,6]，不通过函数的形式实现列表的反转([6,5,4,3,2,1])

a = [1,2,3,4,5,6]
print(a[::-1])
结果：[6, 5, 4, 3, 2, 1]

3. 通⽤操作

• '+ 和 *
  '+ 可以将两个列表拼接成⼀个列表

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

'* 可以将列表重复指定的次数
(注意2个列表不能够做乘法，要和整数做乘法运算)

lst = [1,2,3] * 2
lst = [1,2,3] * [1,2,3] # 报错

• in 和 not in
  in⽤来检查指定元素是否在列表当中
  not in ⽤来检查指定元素是否不在列表当中

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

• len() 函数获取列表中元素的个数 或可以获取列表的长度

lst = [10,20,30,40,50]
print(len(lst))

• max() 获取列表中最⼤值
• min() 获取列表中最⼩值

lst = [100,1,34,5]
print(min(lst))
print(max(lst))
结果：1 100

• list.index(x[, start[, end]])
  第⼀个参数 获取指定元素在列表中的位置
  第⼆个参数 表示查找的起始位置
  第三个参数 表示查找的结束位置

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.index('蜘蛛侠')) # 结果：2
print(hero.index('蜘蛛侠',3,7)) # 结果：6

• list.count(x) 统计指定元素在列表中出现的次数

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠']
print(hero.count('蜘蛛侠')) # 结果：3
print(hero.count('蝙蝠侠')) # 结果：0

s = 'Jerry'
print(s.count('r'))
结果：报错 SyntaxError: multiple statements found while compiling a single statement
计算的是元素的个数，不能计算一个字符串中某个字符的个数

4. 修改列表

• 通过索引来修改

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0] = '雷神'
print(hero)
结果：['雷神', '葫芦娃', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

• 通过del来修改 删除元素

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
del hero[2]
print(hero)
结果：['钢铁侠', '葫芦娃', '黑寡妇', '蚁人', '美国队长']

• 通过切⽚来修改
  (起始就是给切⽚的内容重新赋值，但是赋值的内容必须是⼀个序列)

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0:3] = 'abcd'
print(hero)
结果：['a', 'b', 'c', 'd', '黑寡妇', '蚁人', '美国队长']
hero[0:2] = 132
结果：报错，必须是可迭代的（是个序列），整数不行
TypeError: can only assign an iterable list()

• 如果替换的元素大于原有的元素，多余的元素会往后顺延

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0:2] = ['黑豹','雷神','灭霸']
hero[0:0] = ['雷神'] # 向索引为0的位置插入元素
hero[1:1] = ['雷神'] # 向索引为1的位置插入元素
结果：['黑豹', '雷神', '灭霸', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
['雷神', '钢铁侠', '葫芦娃', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
['钢铁侠', '雷神', '葫芦娃', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

• 当设置了步⻓时,序列中元素的个数必须和切⽚中元素的个数保持⼀致

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[::2]
hero[::2] = ['雷神']
hero[::2] = ['黑豹','雷神','灭霸']
结果：['钢铁侠', '蜘蛛侠', '蚁人']
报错 ValueError: attempt to assign sequence of size 1 to extended slice of size 3
['黑豹', '葫芦娃', '雷神', '黑寡妇', '灭霸', '美国队长']

• 通过切⽚来删除元素
  del list[起始 : 结束]
  ist = []

hero = ['钢铁侠','葫芦娃','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[1:3] = []
结果：['钢铁侠', '黑寡妇', '蚁人', '美国队长']

s = 'python'
s = list(s) #不转换成列表，无法更改元素
s[1] = 'j'
print(s)
结果：['p', 'j', 't', 'h', 'o', 'n']

5. 列表的⽅法

• append() 像列表的最后添加⼀个元素
  局限性：只能添加一个元素

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.append('黑寡妇')
结果：['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇']

• insert(arg1,arg2) 像列表指定位置插⼊⼀个元素
  参数1:要插⼊的位置
  参数 2:要插⼊的元素

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.insert(2,'黑寡妇')
结果：['钢铁侠', '绿巨人', '黑寡妇', '蜘蛛侠']
hero[3:3] = 'a'
结果：['钢铁侠', '绿巨人', '蜘蛛侠', 'a']

• extend(iterable) 使⽤⼀个新的序列来扩展当前序列(它会将该序列中的元素添加到列表中) 参数需要传递⼀个序列

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.extend(['黑寡妇','超人']) # 相当于 hero += ['黑寡妇','超人']
hero.extend('ab')
结果：['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '超人']
['钢铁侠', '绿巨人', '蜘蛛侠', 'a', 'b']
lst = [1,2,3] + 'ab' # 列表直接相加，会报错

• clear() 清空序列

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.clear()
结果：[]

• pop() 根据索引删除并返回指定元素

hero = ['钢铁侠','绿巨人','蜘蛛侠']
result = hero.pop(2)
print(result)
print(hero)
结果：蜘蛛侠 #删除的那个元素
['钢铁侠', '绿巨人']

• remove() 删除指定元素 (如果相同值的元素有多个，只会删除第⼀个)

hero = ['钢铁侠','绿巨人','蜘蛛侠']
result = hero.remove('绿巨人')
print(result)
结果：None # 不会返回删除的这个元素

• reverse() 翻转列表

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.reverse()
结果：['蜘蛛侠', '绿巨人', '钢铁侠']

• sort(key=None,reverse=False) ⽤来对列表中的元素进⾏排序，默认是升序
  reverse：True降序；False升序

lst = list('asndkaldwnwki')
lst.sort()
lst.sort(reverse=True)
结果：['a', 'a', 'd', 'd', 'i', 'k', 'k', 'l', 'n', 'n', 's', 'w', 'w']
['w', 'w', 's', 'n', 'n', 'l', 'k', 'k', 'i', 'd', 'd', 'a', 'a']

6. 遍历列表

6.1 for循环

• 通过for循环来遍历列表
  语法 ：

for 变量 in 序列(遍历的规则):
....代码块

• 注意: for循环的代码块会执⾏多次,序列中有⼏个元素就会执⾏⼏次。每执⾏⼀次就会将序列中的⼀个元素赋值给变量,所以我们可以通过变量来获取列表中的元素

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蝙蝠侠']
i = 0
while i < len(hero):
....print(hero[i])
....i += 1
结果：
钢铁侠
绿巨人
蜘蛛侠
黑寡妇
蝙蝠侠

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蝙蝠侠']
for h in hero:
....print(h)
结果：
钢铁侠
绿巨人
蜘蛛侠
黑寡妇
蝙蝠侠

6.2 range(start, stop[, step])

range()函数,可以用来生成一个自然数的序列
参数说明

• start: 计数从 start 开始。默认是从 0 开始。
  例如range（5）等价于 range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。
  例如：range（0， 5）是[0, 1, 2, 3, 4] 没有5
• step：步⻓，默认为1。
  例如：range（0， 5）等价于 range(0, 5, 1)

r = range(5)
print(r)
print(list(r))
结果：
range(0, 5)
[0, 1, 2, 3, 4]

for i in range(5):
....print('hello world')
结果：
hello world
hello world
hello world
hello world
hello world

作业1：给用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对

作业2：有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素