列表基础及相关

一、列表使用【重点掌握】

1.概念

变量：使用变量存储数据，但是，缺点:一个变量每次只能存储一个数据

思考：如果一次性存储多个数据，怎么做？

实际问题：存储5个人的年龄，求他们的平均年龄，按照以前的方式解决：

age1 = 10
age2 = 18
age3 = 9
age4 = 15
age5 = 20
average = (age1 + age2 + age3 + age4 + age5) / 5

继续思考：如果要存储100，甚至1000个人的年龄呢？

解决方案：此时采用定义变量的方式会显得很麻烦，而Python提供了一种解决方案，使用列表进行多个数据的存储

作用：列表相当于是一个容器，可以同时存储多个数据

本质：列表是一个有序的集合

说明：有序指的就是有顺序【数据的存放的顺序和底层存储的顺序是相同的】

2.基本使用

2.1定义列表

1.定义列表
 列表是一种数据类型，定义列表相当于定义一个列表的变量
 语法：列表名  = [数据1....]
 说明：列表使用list表示，但是，列表名不要直接使用list【list()】,建议listxxx或者xxxlist
​
a.定义空列表
 list1 = []
 print(list1)
​
b.定义非空列表
 *注意：列表是有序的集合，数据的存放顺序和内存中的存储顺序相同
 list2 = [34,6,56,57,7]
 print(list2)
​
c.列表中可以存储重复数据
 list3 = [22,33,44,22,22,22,22]
 print(list3)
​
d.列表中可以同时存储不同类型的数据
 list4 = ["hello",10,45.9,True]
 print(list4)

2.2列表元素获取

2.列表元素的访问
​
"""
注意：
 a.列表中存储的数据被称为元素
 b.列表是有序的，所以列表中的元素被依次进行了编号，编号从0开始，
   这个编号被称为索引，下标或者角标
 c.索引的取值范围:
         0 ~ 列表元素个数 - 1
         -1 ~ -(元素个数)
 d.如果超出索引的范围，则会报错IndexError
"""
nameList = ["tom","jack","bob","rose","zhangsan"]
print(nameList)
​
a.获取元素
 语法：列表名[索引]
 n1 = nameList[2]
 print(n1)
 print(nameList[2])
 print(nameList[4])
​
*注意1:如果使用了超出范围的下标，则会报错
 print(nameList[10]) #IndexError: list index out of range 索引越界
​
*注意2：下标的表示可以使用正数【从左向右】，也可以使用负数【从右向左】
print(nameList[-1])
print(nameList[-5])
​
#print(nameList[-6]) #IndexError: list index out of range
​
​
nameList = ["tom","jack","bob","rose","zhangsan"]
print(nameList)
​
b.修改元素
 语法：列表名[索引] = 值
 print(nameList[1])
 nameList[1] = "蔡徐坤"  #注意：修改列表元素相当于给变量重新赋值
 print(nameList[1])
​
 print(nameList)
​
#结论：列表是一种可变的数据类型，其中的元素可以随时修改
​

2.3列表基本操作

列表基本操作
​
​
#1.列表组合：+
list1 = [2,3,4]
list2 = [7,8]
print(list1 + list2)
print(list1)
​
#2.列表元素的重复：*
print(list1 * 3)
print(list1)
​
#结论：列表组合和列表元素的重复都是生成了一个新的列表，对原列表没有任何影响
​
print("=" * 30)
​
​
#3.判断元素是否在列表中：
# a.成员运算符【in , not in】，一般结合if语句和for循环使用
list3 = [2, 3, 4, 7, 8]
print(3 in list3)  #True
print(6 in list3)  #False
​
print(3 not in list3)  #False
print(6 not in list3)  #True
​
if 3 in list3:
 print("3在列表中")
​
# b.身份运算符【is , is not】,判断两个变量的地址是否是同一个
a = 10
b = 10
print(a is b)   #True
​
list1 = [1,2,3]
list2 = [1,2,3]
print(list1 is list2)  #False
print(list1 == list2)  #True
​
"""
注意：
 a.变量中实际存储的是地址
 比如：10的地址假设为:2343455
 a和b中存储的是2343455
 
 list1和list2是两个容器，只是其中的内容相同

2.4列表切片

4.列表切片
 概念：通过开始下标，结束下标以及步长获取一个子列表
 语法：列表名[start:end:step]
​
 a.start可以省略，默认从0开始
 b.end可以省略，默认为最后一个下标
 c.step可以省略，默认为1
 d.可以根据具体的情况选择性省略
 e.注意：前闭后开区间【包头不包尾】
 list1 = [11,22,33,44,55,66,77,88,99]
​
a.获取指定区间，而且下标都是正数，省略step
 sublist1 = list1[1:4]    #指定区间
 sublist1 = list1[1:]    #从指定下标开始到结尾
 sublist1 = list1[:4]    #从开头到指定下标
​
b.获取指定区间，而且下标都是正数，定义step
 sublist1 = list1[1:4:2]
 sublist1 = list1[1::2]
 sublist1 = list1[:4:2]
​
 list1 = [11,22,33,44,55,66,77,88,99]
​
c.获取指定区间，而且下标都是负数
 sublist1 = list1[-1:-4]   #[]
 sublist1 = list1[-1:]   #只获取最后一个元素
 sublist1 = list1[:-4]  #[11, 22, 33, 44, 55]
​
 sublist1 = list1[-1:-4:-1]
 print(sublist1)
 sublist1 = list1[-1::-1]
 print(sublist1)
 sublist1 = list1[:-4:-1]
 print(sublist1)
​
 sublist1 = list1[-4:-1:-1]
 print(sublist1)
 sublist1 = list1[-4::-1]
 print(sublist1)
 sublist1 = list1[:-1:-1]
 print(sublist1)
​
 list1 = [11,22,33,44,55,66,77,88,99]
​
 print(list1[::])
 print(list1[::1])
 print(list1[::-1])   #倒序

切片

list1 = [11,22,33,44,55,66,77,88,99]

print(list1[-1])  #获取元素
​
一、一般情况
 *注意：start和end写出来，遵循前闭后开
... -4 -3 -2 -1 0 1 2 3 4 ...
1.省略step
 print(list1[0:3])   #[11, 22, 33]
 print(list1[:3])    #[11, 22, 33]
 print(list1[0:])   #[11, 22, 33, 44, 55, 66, 77, 88, 99]

list1 = [11,22,33,44,55,66,77,88,99]
​
2.start和end为负数
 print(list1[-1:-4:1])
 print(list1[-1:-4:])
 print(list1[-1:-4:-1])
​
 print(list1[-4:-1:1])   #[66 77 88]
 print(list1[-4:-1:])    #[66 77 88]
 print(list1[-4:-1:-1])  #[]

 list1 = [11,22,33,44,55,66,77,88,99]
​
3.start和end为正数
 print(list1[1:4:1])  #[22, 33, 44]
 print(list1[1:4:])   #[22, 33, 44]
 print(list1[1:4:-1])   #[]
​
​
4.start和end可以为正数，也可以为负数【特殊情况】
 11 22 33 44 55 66 77 88 99   元素
 0   1 2 3   4   5   6   7   8   正索引
 -9 -8 -7 -6   -5 -4 -3 -2 -1   负索引

print(list1[1:-4])   #[22, 33, 44, 55]
print(list1[1:-4:-1])  #[]
​
print(list1[-1:4])   #[]
print(list1[-1:4:-1]) #[99, 88, 77, 66]
print(list1[-1:-5:-1]) #[99, 88, 77, 66]
​
总结：如果start和end没有省略，start + step的结果判断是否在指定区间内
​
​
二、特殊情况
 list1 = [11,22,33,44,55,66,77,88,99]
1.
 print(list1[100:])    # []
​
2.
 print(list1[0:-1])   #[11, 22, 33, 44, 55, 66, 77, 88]
 print(list1[0:8])    #[11, 22, 33, 44, 55, 66, 77, 88]
​
​
3.
 print(list1[4:100])  #[55, 66, 77, 88, 99]
 print(list1[4:])  #[55, 66, 77, 88, 99]

4.
 print(list1[::1])  #[11, 22, 33, 44, 55, 66, 77, 88, 99]
 print(list1[::-1]) #[99, 88, 77, 66, 55, 44, 33, 22, 11] 【面试题】，倒序
​
5
 print(list1[-1:0])  #[]
 print(list1[-1:0:-1]) #[99, 88, 77, 66, 55, 44, 33, 22]

6.
 print(list1[-4::-1])

3.系统功能

函数	说明
len(list)	获取列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(seq)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.pop(index)	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort(key=None,reverse=False)	对原列表进行排序
list.copy()	复制列表
list.clear()	清空列表

Python中系统提供了一些操作列表的系统功能【函数】，可以帮助完成一些操作
​
列表是一种可变的数据类型，可以进行增删改的操作
​
1.增
 a.list.append(x),在列表末尾追加一个元素,x可以是任意类型
 list11 = [1,2,3]
 list11.append(4)
 list11.append(False)
 list11.append("abc")
 list11.append([33,55])
 print(list11)

b.list.extend(x),在列表末尾追加一个元素，x必须是一个容器【集合，序列】
 list12 = [1,2,3]
 print(list12)
 *注意：可迭代对象包括字符串，列表，元组，字典，集合
 list12.extend(5)   #TypeError: 'int' object is not iterable可迭代对象
 print(list12)
​
 list12.extend([5])
 print(list12)
​
 list12.extend("abc")
 print(list12)
​
总结；append和extend如果添加的是容器，append将容器直接添加进去，而extend只添加元素

c.list.insert(index,x),在列表的指定为值上插入指定的元素
 list13 = [1,2,3]
 print(list13)
 list13.insert(1,10)
 print(list13)
​
 *注意：如果插入的时候index超出下标范围，则默认在列表末尾插入元素
 list13.insert(6,8)
 print(list13)
​
 list13.insert(2,[33,55])
 print(list13)
​
 list13.insert(3,"hello")
 print(list13)
​
总结：extend只能添加容器，而且将容器中的数据打碎加入，
 append和insert可以添加任意类型的数据，直接加入
​
2.删
a.list.remove(x),移除列表中的指定元素，如果出现重复元素，只会删除一个
 list21 = [1, 10, 2, 3, 8,2,2,2]
 print(list21)
 list21.remove(2)
 print(list21)
​
*注意：如果元素不存在，则报错
 list21.remove(666) #ValueError: list.remove(x): x not in list
 print(list21)
​
b.list.pop(index=-1) ,删除指定位置上的元素，如果不给值，则默认删除最后一个元素
 list22 = [1, 10, 2, 3, 8]
 print(list22)
 list22.pop()
 print(list22)
​
 list22.pop(1)
 print(list22)
​
*注意1：使用了超出范围的下标，则报错
 list22.pop(9) #IndexError: pop index out of range
 print(list22)
​
*注意2：pop（）返回被删除的元素
 list22 = [1, 10, 2, 66, 8]
 print(list22)
 num = list22.pop(3)
 print(num)
 print(list22)
​
 result = list22.remove(2)  #None
 print(result)
​
总结：pop返回被删除的元素，remove返回为None
​
​
c.list.clear() ,清空
 list22 = [1, 10, 2, 66, 8]
 print(list22)
 list22.clear()
 print(list22)
​
3.改
a.list.reverse() ,反转【倒序】
 list31 = [34,56,56,67,100,200]
 list31.reverse()
 print(list31)
​
list31 = [34,56,56,67,100,200]
print(list31[::-1])
​
b.list.sort(),排序，默认为升序排序
 list32 = [100,34,200,56,56,67]
 print(list32)
升序
 list32.sort()
 print(list32)

降序
 list32.sort(reverse=True)
 print(list32)
​
字符串列表排序
 list33 = ["456","abc","Kuf","helloabcbbv","xvya","888"]
 print(list33)
 list33.sort()
 print(list33)
​
不同类型的元素是否可以排序----》不可以，因为sort底层采用的是关系运算符，不同类型无法比较
# list34 = [45,"faf","lll","5757",False,"你好"]
# list34.sort() #TypeError: '<' not supported between instances of 'str' and 'int'

4.查
a.len(list):获取列表中的元素个数/获取列表的长度
 list41 = [4,6,56,56,76,6]
 print(len(list41))
​
b.max(list)：获取列表中的元素的最大值

 print(max(list41))

c.min(list)：获取列表中的元素的最小值
 print(min(list41))
​
d.list.count(x)，获取元素x在列表中出现的次数
 print(list41.count(56))
 c = list41.count(56)
 print(c)
​
e.list.index(x),获取元素x在列表中第一次出现的下标【从左往右】
 list41 = [4,6,56,56,76,6]
 i1 = list41.index(56)
 print(i1)
​
*注意：如果元素不存在，则报错
# i1 = list41.index(100)   #ValueError: 100 is not in list

4.列表嵌套

列表的嵌套，其实就是一个列表中的元素又是一个列表

注意：操作嵌套列表，只要把要操作元素的下标当作变量名来使用即可

二、列表相关

1.列表拷贝

1.1内存中的变量

Python中的数据都是保存在内存中

Python中的数据分为两大类：

不可变数据类型：数字，布尔，元组，字符串

可变数据类型：列表，字典，集合

1.不可变数据类型
 a = 10
 b = a
 print(a,b)
 print(id(a),id(b))
 a = 20
 print(a,b)   #20 10
 print(id(a),id(b))
​
​
2.可变数据类型
 list1 = [22,33,44]
 list2 = list1
 print(list1,list2)
 print(id(list1),id(list2))
*注意：更改的是容器的内容，并不是容器本身
 list1[1] = 100
 list1 = [45,6,7]
 print(list1,list2)
 print(id(list1),id(list2))
​
3.id(x)：获取变量x在内存中的地址
 如果两个变量的id()值相等，则说明表示同一个数据
​
 ①变量其中实际存储了一个数据的地址
​
 ②变量被称为引用
 a------》4362284320 10的地址
 b------》4362284320 10的地址
 
 a------》4362284640   20的地址
 b------》4362284320   10的地址
 
 list1,list2----->4363800456
 list1,list2----->4363800456
 
 对于不可变数据类型，如果修改值，内存地址会发生改变
 对于可变数据类型，如果修改值【容器中的元素】。内存地址不会发生改变

1.2copy和=

1.=
a.单列表
 list1 = [1,2,3]
 list2 = list1
 print(list1,list2)
 list1[1] = 100
 print(list1,list2)

​
b.嵌套列表
 list1 = [[1,2,3],[4,5]]
 list2 = list1
 print(list1,list2)
 list1[1][1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​
2.copy()
a.单列表copy
 list1 = [1,2,3]
 list2 = list1.copy()
 print(list1,list2)
 list1[1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​
b.嵌套copy
 list1 = [[1,2,3],[4,5]]
 list2 = list1.copy()
 print(list1,list2)
 list1[1][1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​

总结：前提：不管是基层列表 ，都更改最里层的数据
 =：不管是单层列表还是嵌套列表，只要其中一个更改，另一个随着更改
 copy:对于单层列表，其中一个更改，另一个不受影响
     对于嵌套列表，其中一个更改，另一个随着更改
 copy只拷贝最外层

1.3浅拷贝和深拷贝【面试题】

Python提供了copy模块来复制一个对象。copy模块提供了浅复制和深复制两种方式，它们的使用方式相同，但是执行的效果有一定的差异

浅拷贝:是对于一个对象的顶层拷贝，通俗的理解是：拷贝了引用，并没有拷贝内容

深拷贝：是对于一个对象所有层次的递归拷贝

import  copy
copy.copy()表示浅拷贝，copy.deepcopy()表示深拷贝
​
1.浅拷贝
a.单层浅拷贝
 list1 = [1,2,3]
 list2 = copy.copy(list1)
 print(list1,list2)
 list1[1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​
b.嵌套浅拷贝
 list1 = [[1,2,3],[4,5]]
 list2 = copy.copy(list1)
 print(list1,list2)
 list1[1][1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​
2.深拷贝
a.单层深拷贝
 list1 = [1,2,3]
 list2 = copy.deepcopy(list1)
 print(list1,list2)
 list1[1] = 100
 print(list1,list2)
 print(id(list1),id(list2))
​
b.嵌套深拷贝
 list1 = [[1,2,3],[4,5]]
 list2 = copy.deepcopy(list1)
 print(list1,list2)
 list1[1][1] = 100
 print(list1,list2)
 print(id(list1),id(list2))

总结：
 copy.copy(列表)/列表.copy():对于单层列表，其中一个更改，另一个不受影响
                       对于嵌套列表，其中一个更改，另一个随着更改
             
 copy.deepcopy(列表):对于所有列表，其中一个更改，另一个不受影响

2.列表推导式

列表推导式，就是指的轻量级循环创建列表

​
语法：[元素的规律  for循环  if条件]
作用：简化代码
特点：本质生成一个列表
​
1.生成列表[1,2,3,4....9]
 list(x)将容器x转化为列表
 list1 = list(range(1,10))
 print(list1)
​
2.生成列表[1,4,9,16....81]
#方式一
 list21 = []
 for i in range(1,10):
 list21.append(i ** 2)
 print(list21)
​
#方式二
 list22 = [i ** 2 for i in range(1,10)]
 print(list22)
 print(type(list22))
​
3.生成列表[1,9,25,49,81]
#方式一
 list31 = []
 for i in range(1,10):
 if i % 2 == 1:
     list31.append(i ** 2)
 print(list31)
​
#方式二
list32 = [i ** 2 for i in range(1,10) if i % 2 == 1]
print(list32)
​
例：生成一个列表，列表中的元素为1~30之间3的倍数
list33 = [n for n in range(1,31) if n % 3 == 0]
print(list33)
​
4.可以使用两个for循环
#方式一
 list41 = []
 for i in "ABC":
 for j in "XYZ":
     list41.append(i + j)     #举例："a" + "b" ---->"ab" 拼接
 print(list41)
​
#方式二:在列表推导式中，平行书写的for循环实际相当于嵌套for循环
 list42 = [i + j for i in "ABC" for j in "XYZ"]
 print(list42)
​
 list43 = [[i,j,k] for i in range(3) for j in range(2) for k in range(2)]
 print(list43)
​
例：已知一个数字列表，生成一个新的列表，列表中的元素为原列表的2倍
 numlist = [34,6,6,56,5]
 newlist = [num * 2 for num in numlist]
 print(newlist)

3.简单算法

1.1冒泡排序

排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）

[12,9,13,7,5]----->[5,7,9,12,13]
​
0        1        2        3         4
​
12       9       13       7         5
​
比较的轮数       参与比较的下标         每一轮比较的次数     结果
第0轮           0-1 1-2 2-3 3-4         4           得到了最大值
第1轮           0-1 1-2 2-3             3           得到了第二大值
第2轮           0-1 1-2                 2
第3轮           0-1                       1
​
0   3
1   2
2   1
3   0
​
规律：
 a.使用嵌套循环：for循环
 b.外层循环：控制比较的轮数
   内层循环：控制每一轮比较的次数兼顾参与比较的下标
​
 c.外层循环的取值范围：0~3---》0 ~ len - 2---->range(0,len - 1)--->range(len - 1) i
   内层循环的取值范围：0 ~ (3 - i)---->0~(len - 2 - i)---->range(len - 1 - i) j

list1 = [45,2,100,56,6,55,70]
​
for i in range(len(list1) - 1):
 for j in range(len(list1) - 1 - i):
     #比较：如果下标小的元素 > 下标大的元素，则交换位置.升序
     if list1[j] > list1[j + 1]:
         list1[j],list1[j + 1] = list1[j + 1],list1[j]
print(list1)

1.2选择排序

排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较，最值出现在头角标位置上

[12,9,13,7,5]----->[5,7,9,12,13]
​
0        1        2        3         4
​
12       9       13       7         5
​
比较的轮数       参与比较的下标             每一轮比较的次数     结果
第0轮           0-1 0-2 0-3 0-4               4           得到了最小值【最左边】
第1轮           1-2 1-3 1-4                   3           。。。。
第2轮           2-3 2-4                       2
第3轮           3-4                           1
​
规律：
 a.使用嵌套循环：for循环
 b.外层循环：控制比较的轮数
   内层循环：控制每一轮比较的次数兼顾参与比较的下标
​
 c.外层循环的取值范围：0~3---》0 ~ len - 2---->range(0,len - 1)--->range(len - 1) i
   内层循环的取值范围：i + 1 ~ 4---->i + 1 ~ len - 1---->range(i + 1,len) j
​
 d.参与比较的下标：i 和 j

list1 = [45,2,100,56,6,55,70]
​
#选择排序：升序
for i in range(len(list1) - 1):
 for j in range(i + 1,len(list1)):
     if list1[i] > list1[j]:
         list1[i],list1[j] = list1[j],list1[i]
​
print(list1)

1.3二分法查找

查找思路：将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找

注意：前提是列表是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率

#二分法查找：列表必须是有序的
​
list1 = [45,65,6,7,100,45,65,47]
list1.sort()  #升序
print(list1)
​
#待查找的元素
key = 45
​
#初始值
left = 0
right = len(list1) - 1
​
#说明：当left == right，还未找到元素，则说明不存在
while left <= right:
 middle = (left + right) // 2
​
 #左半部分
 if list1[middle] > key:
     #给right重新赋值
     right = middle - 1
 #右半部分
 elif list1[middle] < key:
     #给left重新赋值
     left = middle + 1
 #找到了
 else:
     print("待查找元素的下标为：%d" % (middle))
     #如果查找到，则可以提前结束循环
     break
else:
 print("待查找元素不存在")