Python基础知识六 列表

一、序列（sequence）

1、基本概念

• 序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引。
• 数据结构指计算机中数据存储的方式。

2、序列的分类

2.1 可变序列

• 序列中的元素可以改变，例如：列表（list）、字典（dict）

2.2 不可变序列

• 序列中的元素不能改变，例如：字符串（str）、元组（tuple）

二、列表（list）

1、基本概念

1.1 列表是Python中的一个对象

1.2 列表的作用

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

2、列表的使用

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

# 创建一个空列表
lst_a = []

# 创建一个列表
lst_b = [1, 2, 3, 4, 5, 6]

# 列表可以保存任意对象
lst_c = [1, 'Python', None, True, max(1, 2, 3)]
print(lst_c, type(lst_c))    # [1, 'Python', None, True, 3] <class 'list'>

• 通过索引（index）来获取列表中的元素。索引就是元素在列表中的位置，列表当中每一个位置都会有一个索引。索引是从0开始，列表的第一个位置就是0，第二个位置是1……以此类推。

lst = [10,20,30,40,50,60]
# 获取列表中的第一个元素
print(lst[0])    # 10

# 不能超过最大索引值
print(lst[6])    # IndexError: list index out of range

# 获取列表中的倒数第二个元素
print(lst[-2])    # 50

3、切片

• 切片是指从现有列表中获得一个子列表
• 通过切片来获取指定的元素
• 语法：列表名[起始 : 结束 : 步长]
• 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
• 起始位置和结束位置的索引可以不写
  • 如果省略结束位置，则会从当前的开始位置一直截取到最后
  • 如果省略开始位置，则会从第一个元素截取到结束位置的元素，但是不包括结束位置的元素
• 步长表示每次获取元素的间隔，默认是1（可以省略不写）
• 步长不能是0，但可以是负数，负数表示对列表从后往前切

fruits = ['apple','orange','banana','pear','cherry','peach']
# 通过切片会获取一个新的列表，不会影响原来的列表
print(fruits[0:2])    # ['apple', 'orange']
print(fruits[2:4])    # ['banana', 'pear']
print(fruits)    # ['apple', 'orange', 'banana', 'pear', 'cherry', 'peach']

# 省略结束位置，则从当前的位置会一直截取到最后
print(fruits[1:])    # ['orange', 'banana', 'pear', 'cherry', 'peach']

# 省略开始位置 则会从第一个元素截取到结束位置，但是不包括结束位置的元素
print(fruits[:3])    # ['apple', 'orange', 'banana']

# 开始位置和结束位置都省略，则会从第一个位置截取到最后一个位置上面的元素（全部）
print(fruits[:])    # ['apple', 'orange', 'banana', 'pear', 'cherry', 'peach']

# 步长可以省略默认值为1
print(fruits[0:5:1])    # ['apple', 'orange', 'banana', 'pear', 'cherry']
print(fruits[0:5:2])    # ['apple', 'banana', 'cherry']
print(fruits[0:5:3])    # ['apple', 'pear']
print(fruits[::2])    # ['apple', 'banana', 'cherry']

# 步长可以为负数但是不能为0
print(fruits[::-1])    # ['peach', 'cherry', 'pear', 'banana', 'orange', 'apple']
print(fruits[4:1:-1])    # ['cherry', 'pear', 'banana']
print(fruits[::0])    # ValueError: slice step cannot be zero

三、通用操作

1、 +和*

• + 可以将两个列表拼接成一个列表
• * 可以将列表重复指定的次数（注意：2个列表之间不能做乘法，要列表和整数做乘法运算）

# + 可以将两个列表拼接成一个列表
lst = [1,2,3] + [4,5,6]     # [1, 2, 3, 4, 5, 6]
# * 可以将列表重复指定的次数
lst = [1,2,3] * 5   # [1, 2, 3, 1, 2, 3, 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'

2、 in和not in

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

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

3、 len( )、max( )和min( )

• len( ) 获取列表中元素的个数
• max( ) 获取列表中的最大值
• min( ) 获取列表中的最小值

lst = [1,2,3,4,5,6]
print(len(lst))    # 6
print(max(lst))    # 6
print(min(lst))    # 1

4、 list.index(x[, start[, end]])

• 第一个参数 获取指定元素在列表中的位置
• 第二个参数 表示查找的起始位置
• 第三个参数 表示查找的结束位置

5、 list.count(x)

• 统计指定元素在列表中出现的个数

lst = ['a','b','c','d','e','f','c','c','c']
print(lst.index('c'))    # 2
print(lst.index('c',3,7))    # 6
print(lst.count('c'))    # 4
print(lst.count('g'))    # 0

四、修改列表

• 通过索引来修改列表中的某个元素

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

• 通过切片来修改（其实就是给切片的内容重新赋值，但是赋值的内容必须是一个序列）

# 通过切片来修改
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[0:3] = 'abcd'    # ['a', 'b', 'c', 'd', '黑寡妇', '蚁人']

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[0:3] = 123    # TypeError: can only assign an iterable

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[0:2] = ['黑豹','雷神','灭霸']    # ['黑豹', '雷神', '灭霸', '蜘蛛侠', '黑寡妇', '蚁人']

# 向索引为0的位置插入了一个元素
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[0:0] = ['雷神']    # ['雷神', '钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']

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

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

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[::2] = ['雷神','灭霸','黑豹']    # ['雷神', '绿巨人', '灭霸', '黑寡妇', '黑豹']

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

# 通过 del 关键字 来删除元素
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
del hero[2]    # ['钢铁侠', '绿巨人', '黑寡妇', '蚁人']

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
del hero[1:3]    # ['钢铁侠', '黑寡妇', '蚁人']

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero[1:3] = []    # ['钢铁侠', '黑寡妇', '蚁人']

五、列表的方法

1、添加

1.1 append( )

• 向列表的末尾添加一个元素

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero[3] = '蝙蝠侠'    # IndexError: list assignment index out of range
hero.append('蝙蝠侠')    # ['钢铁侠', '绿巨人', '蜘蛛侠', '蝙蝠侠']

1.2 insert(arg1,arg2)

• 向列表指定位置插入一个元素
• 参数1：要插入的位置
• 参数2：要插入的元素

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.insert(2,'蝙蝠侠')    # ['钢铁侠', '绿巨人', '蝙蝠侠', '蜘蛛侠']

1.3 extend( iterable)

• 使用一个新的序列来扩展当前序列（它会将该序列中的元素添加到列表中），参数需要传递一个序列。

hero = ['钢铁侠','绿巨人','蜘蛛侠']
hero.extend(['黑寡妇','蚁人'])    # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人']

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

2、删除

2.1 pop( )

• 根据索引删除并返回指定元素
• 不传递索引默认删除最后一个元素

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
r = hero.pop()    # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇']
print(hero)    # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇']
print(r)    # 蚁人

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
r = hero.pop(1)
print(hero)    # ['钢铁侠', '蜘蛛侠', '黑寡妇', '蚁人']
print(r)    # 绿巨人

2.2 remove( )

• 删除指定元素（如果相同值的元素有多个，只会删除第一个）

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero.remove('蜘蛛侠')    # ['钢铁侠', '绿巨人', '黑寡妇', '蚁人']

2.3 clear( )

• 清空列表

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero.clear()    # []

3、翻转

3.1 reserve( )

• 翻转列表

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
hero.reverse()    # ['蚁人', '黑寡妇', '蜘蛛侠', '绿巨人', '钢铁侠']

4、排序

4.1 sort(key=None,reserve=False)

• 用来对列表中的元素进行排序
• reserve=
  • True 反序
  • False 正序

lst = list('qwerasdfzxcv')
lst.sort()    # ['a', 'c', 'd', 'e', 'f', 'q', 'r', 's', 'v', 'w', 'x', 'z']
lst.sort(reverse=True)    # ['z', 'x', 'w', 'v', 's', 'r', 'q', 'f', 'e', 'd', 'c', 'a']

六、遍历列表

1、 for循环

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

for 变量 in 序列（遍历的规则）：
	代码块

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

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人']
for i in hero:
    print(i)

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

# 获取列表中的奇数
lst = [1,2,3,4,5,6,7,8,9]
for i in range(0,9,2):
    print(lst[i])

七、浅拷贝和深拷贝

1、赋值

a = [1,2,3,[4,5]]
b = a

b[1] = 20
print('a =',a,id(a))    # a = [1, 20, 3, [4, 5]] 2281700492168
print('b =',b,id(b))    # b = [1, 20, 3, [4, 5]] 2281700492168

b[3][0] = 10
print('a =',a,id(a))    # a = [1, 20, 3, [10, 5]] 2281700492168
print('b =',b,id(b))    # b = [1, 20, 3, [10, 5]] 2281700492168
print(id(a[3]))    # 2281700491976
print(id(b[3]))    # 2281700491976

2、切片 [:]

• 用切片[:]拷贝是一种浅拷贝，只会复制列表本身，不会复制列表中的子列表。

a = [1,2,3,[4,5]]
b = a[:]

b[1] = 20
print('a =',a,id(a))    # a = [1, 2, 3, [4, 5]] 2113364657032
print('b =',b,id(b))    # b = [1, 20, 3, [4, 5]] 2113364658312

b[3][0] = 10
print('a =',a,id(a))    # a = [1, 2, 3, [10, 5]] 2113364657032
print('b =',b,id(b))    # b = [1, 20, 3, [10, 5]] 2113364658312
print(id(a[3]))    # 2113364656840
print(id(b[3]))    # 2113364656840

3、copy()

• copy()是一种浅拷贝，只会复制列表本身，不会复制列表中的子列表。

a = [1,2,3,[4,5]]
b = a.copy()

b[1] = 20
print('a =',a,id(a))    # a = [1, 2, 3, [4, 5]] 3279480456072
print('b =',b,id(b))    # b = [1, 20, 3, [4, 5]] 3279480457352

b[3][0] = 10
print('a =',a,id(a))    # a = [1, 2, 3, [10, 5]] 3279480456072
print('b =',b,id(b))    # b = [1, 20, 3, [10, 5]] 3279480457352
print(id(a[3]))    # 3279480455880
print(id(b[3]))    # 3279480455880

4、copy.deepcopy()

• deepcopy()是一种深拷贝，列表中的子列表也会被复制。

import copy
a = [1,2,3,[4,5]]
b = copy.deepcopy(a)

b[1] = 20
print('a =',a,id(a))    # a = [1, 2, 3, [4, 5]] 2435489956744
print('b =',b,id(b))    # b = [1, 20, 3, [4, 5]] 2435489958024

b[3][0] = 10
print('a =',a,id(a))    # a = [1, 2, 3, [4, 5]] 2435489956744
print('b =',b,id(b))    # b = [1, 20, 3, [10, 5]] 2435489958024
print(id(a[3]))    # 2435489956552
print(id(b[3]))    # 2435489957960