06 Python-列表

1.序列

1.1.基本概念

• 序列是Python中最基本的一种数据结构（已讲过整数、小数（浮点数）、布尔值、字符串等）。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
• 数据结构指计算机中数据存储的方式

1.2.序列的分类

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

2.列表

• 列表是Python中的一个对象
• 列表的作用
  • 列表中可以保存多个有序的数据
  • 列表是用来存储对象的对象，可以保存任意对象（可以存放不同类型的数据）

2.1.列表的使用

• 列表的创建：
  • 通过 [] 来创建一个空列表
  • [元素1,元素2,…,元素n] 元素间用逗号隔开，用方括号括起来
  • list(序列) 将序列转换成列表

list1=[]
list1 = [1,2,3]
list1= list(range(5))
list1=list("老萝卜")
list2 = [1 , 'a',None,True,max(4,5),print()]

• 可以通过索引(index)来获取列表中元素
  • 索引就是元素在列表中的位置 列表当中每一个位置都会有一个索引 索引是从0开始，列表的第一个位置就是0,第二个位置是1 以此类推,最后一个元素是len(列表)-1
  • len()函数可以获取列表的长度（列表元素的个数）
• 总结：
  • 获取列表的长度，可以是列表的最大索引值+1
  • 索引可以是负数，如果索引为负是从后往前获取元素 -1表示最后一个 -2表示倒数第二个 以此类推,第一个元素是-len(列表)
  • 下标超出列表范围时，会报错，下标负数超出范围也会报错

list3 = [10,20,30,40,50]

print(list3[0],list3[2],list3[4],list3[1],list3[3])

# print(list3[5]) # IndexError: list index out of range   下标超出列表范围时，会报错

# len()函数可以获取列表的长度（列表元素的个数）
# 总结：获取列表的长度，可以是列表的最大索引值+1
print(len(list3))
# 索引可以是负数，如果索引为负是从后往前获取元素 -1表示最后一个 -2表示倒数第二个 以此类推,第一个元素是-len(列表)
print(list3[-2])
print(list3[-3])
print(list3[-4])

# print(list3[-8])    # IndexError: list index out of range    下标负数超出范围也会报错

2.2. 切片

• 切片是指从现有列表中获得一个子列表
• 通过切片来获取指定的元素
• 语法: 列表[起始 : 结束 : 步长]
• 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素， 简称：左闭右开
• 起始位置和结束位置的索引可以不写
• 如果省略结束位置, 则会从当前的开始位置的直截取到最后
• 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
• 如果开始位置和结束位置都省略, 则则会从第一个元素开始截取到最后一个元素
• 步长表示每次获取元素的间隔，默认是1(可以省略不写)
• 步长不能是0,但可以是是负数， 注意负数，起始位值>终止值 ，否则不报错，但无法获取元素

#　起始位置和结束位置可以不写
# 如果省略结束位置 则从当前的位置会一直截取到最后
print(hero[1:])   # ['绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

# 如果省略开始位置 则会从第一个元素截取到结束位置，但是不包括结束位置的元素
print(hero[:3]) # ['钢铁侠', '绿巨人', '蜘蛛侠']

# 如果开始位置和结束位置都省略，则会从第一个位置截取到最后一个位置上面的元素 (全部)
print(hero[:]) # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

# 步长表示每次获取元素的间隔，默认值为1,可以省略
# 步长可以为负数但是不能为0
print(hero[0:5:1]) # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']
print(hero[0:5]) # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']
print(hero[0:5:2]) # ['钢铁侠', '蜘蛛侠', '蚁人']
print(hero[0:5:3])# ['钢铁侠', '黑寡妇']
print(hero[0:5:8])# ['钢铁侠']                                      #当步长过大时，仅会换序取，取不到时就不取，不会报错
print(hero[::2]) # ['钢铁侠', '蜘蛛侠', '蚁人']
print(hero[::-1]) # ['美国队长', '蚁人', '黑寡妇', '蜘蛛侠', '绿巨人', '钢铁侠']
# print(hero[::0]) # ValueError: slice step cannot be zero          #步长值为0时，程序报错
print(hero[4:1:-1]) # ['蚁人', '黑寡妇', '蜘蛛侠']

print(hero[0:5:-1])  # []           #如果结束值>起始值，且步长为负，将切不到元素，但不报错

3通用操作

3.1. + 和 *

• • 可以将两个列表拼接成⼀个列表
• • 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)

# + *  ,没有- 和  /
# 列表 + 列表 ： 可以将两个列表拼接成一个列表
lst = [1,2,3] + [4,5,6]
# 列表 * 整数 ： 可以将列表重复指定的次数
lst = [1,2,3] * 2           # [1,2,3,1,2,3]
print(20 * [1,2,3])         # [1,2,3,1,2,3]
# lst = [1,2,3] * [4,5,6] # TypeError: can't multiply sequence by non-int of type 'list'
# lst = [1,2,3,4] -[2,3]  # TypeError: unsupported operand type(s) for -: 'list' and 'list'

3.2. in 和 not in

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

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

3.3.len() 获取列表中元素的个数

3.4.max() 和 min()

-max() 获取列表中最大值

• min() 获取列表中最小值
  -数据类型应该一致，且具有可比性

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

print(min(lst),max(lst))
# 注： 列表中元素类型相同，有可比性才行
# print(max(1,"str",None)) #TypeError: '>' not supported between instances of 'str' and 'int'
# print(max(1,None)) #TypeError: '>' not supported between instances of 'NoneType' and 'int'

3.5.list.index(x) 和 list.count(x)

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

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

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

print(hero.count('蜘蛛侠'))   # 4
print(hero.count('超人'))     # 0
# print(hero.count('蜘蛛侠',3,8))   # TypeError: count() takes exactly one argument (3 given)
print(hero[3:].count('蜘蛛侠'))  #3            # s.count()无法指定区间，只有选进行切片后，再进行统计

4.修改列表（待整理）

• 通过切片来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
• 当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
  -通过切片来删除元素
  • del list[起始 : 结束]
  • list = []

# 方法一：根据索引，直接修改 list[i]=XXXX
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0] = '雷神'
print(hero) # ['雷神', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

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


# 方法二：根据索引，删除某下标元素
# 通过 del 来删除元素 关键字，不是函数
del hero[2]

print('修改后:',hero)

# 方法三：通过切片来修改
print('修改前:',hero)
hero[0:3] = 'abcd'  #['a', 'b', 'c', 'd', '蚁人', '美国队长']         #当赋值个数>切片数量时，直接用值替换切片位置，多添，少减
print('修改后:',hero)
# hero[0:3] = 123 # TypeError: can only assign an iterable 必须传递的是一个序列
# hero[0:3] = "0" # TypeError: can only assign an iterable 必须传递的是一个序列
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0:4]=["1",2]
print('修改后:',hero)


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

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[0:0] = ['雷神'] #　               向索引为０的位置插入了一个元素
print('修改后www:',hero)

# 当设置了步长的时候，序列中元素的个数必须和切片中元素的个数保持一致
# hero[::2] = ['雷神'] # ValueError: attempt to assign sequence of size 1 to extended slice of size 3
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[::2] = ['雷神','灭霸','黑豹']
print(hero[::2])

# 可以通过切片来删除元素
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
hero[1:3] = []
print('修改后:',hero)

# 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)

print('修改后:',hero)

5.列表的方法

• append() ：向列表的最后添加一个元素
• insert(arg1,arg2) 向列表指定位置插入一个元素 参数1:要插入的位置，参数2:要插入的元素
• extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
• pop() 根据索引删除并返回指定元素
• remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
• reverse() 翻转列表
• sort(key=None,reverse=False) 用来对列表中的元素进行排序 reverse：True反序；False 正序

6.遍历列表

6.1.for循环

通过for循环来遍历列表

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

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

6.2.range(start, stop[, step])

• 参数说明
  • ·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)
  • range() 返回一个range类，是一个序列