列表的介绍

一、什么是列表

列表是可以存储不同类型数据的有序、可变的存储容器。

二、列表的格式

定义列的格式： [元素1，元素2，元素3，...,元素n]

定义变量名为arr的列表

arr=[1,'你好'，hello,[1,2,3],[3,2,1.1]]

列表中的元素类型可以不同

列表中可以存列表

列表的下标从o开始

三、获取列表下标

# 列表

arr = [1, 2, 3, 4]

print(arr) #[1, 2, 3, 4]

print(type(arr)) #

newarr=arr[1:5]

print(arr[1]) # 1

print(newarr) #[2, 3, 4]

列表的增删改查

一、添加元素

append

把新元素添加到列表末尾

# append

arr = ['1', 2, 3]

print("append前的arr：", arr)

arr.append(4)

print("append后的arr：", arr)

结果为

append前的arr： ['1', 2, 3]

append后的arr： ['1', 2, 3, 4]

insert

insert(index, object) 在指定位置index前插入元素object

# insert

inArr = [1, 2, 3]

inArr.insert(1, 'tt')

print(inArr) # [1, 'tt', 2, 3]

extend

通过extend可以将另一个集合中的元素(可迭代的对象)逐一添加到列表中

# extend

exArr = ['詹姆斯', '杜兰特', '戴维斯']

# 添加一个元组tuple

exArr.extend(('库里', '哈登')) # ['詹姆斯', '杜兰特', '戴维斯', '库里', '哈登']

print(exArr)

# 添加一个字符串

exArr.extend('你好')

print(exArr) # ['詹姆斯', '杜兰特', '戴维斯', '库里', '哈登', '你', '好']

# 添加一个列表

exArr.extend([1, 2, 3])

print(exArr) # ['詹姆斯', '杜兰特', '戴维斯', '库里', '哈登', '你', '好', 1, 2, 3]

二、修改元素

通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可。

#定义变量A，默认有3个元素

A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----修改之前，列表A的数据-----A=%s" % A)

#修改元素

A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----A=%s" % A)

三、删除元素

列表元素的常用删除方法有：

del：根据下标进行删除

# del删除

arr = ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除前

print(arr) # ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除后

del arr[2]

print(arr) # ['李青', '艾克', '赵信', '酒桶', '男枪']

pop：删除最后一个元素

# pop删除

pArr = ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除前

print(pArr) # ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除后

pArr.pop(3)

print(pArr) # ['李青', '艾克', '蔚', '酒桶', '男枪']

remove：根据元素的值进行删除

# remove删除:根据元素的值进行删除

rArr = ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除前

print(rArr) # ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 删除后

rArr.remove('男枪')

print(rArr) # ['李青', '艾克', '蔚', '赵信', '酒桶']

查找的元素

in与not in

index和count

in, not in

python中查找的常用方法为：

in(存在),如果存在那么结果为true，否则为false

not in(不存在)，如果不存在那么结果为true，否则false

#待查找的列表

nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字

findName = input('请输入要查找的姓名:')

#查找是否存在

if findName in nameList:

print('在列表中找到了相同的名字')

else:

print('没有找到')

说明：

in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

index

index(value,start,step) start开始索引，step结束索引，两个连用如两个区间没查到值报错。左开右闭区间，取到step索引之前的索引。

# index

inArr = ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

in1 = inArr.index('赵信')

print('索引为：', in1) # 索引为： 3

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

in2 = inArr2.index(3, 4)

print('索引为：', in2) # 索引为： 6

in3 = inArr2.index(1, 3, 6)

print('索引为：', in3) # 索引为： 5

count

用来计算某个元素出现的次数,未出现则为零

# count

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

c1 = countArr.count(1)

print('个数为：', c1) # 个数为： 1

# 未有的元素

c2 = countArr.count(99)

print('个数为：', c2) # 个数为： 0

# 出现多次的元素

c3 = countArr.count(3)

print('个数为：', c3) # 个数为： 2

列表的遍历

使用while循环

为了更有效率的输出列表的每个数据，可以使用循环来完成

heroList = ['李青', '艾克', '蔚', '赵信', '酒桶', '男枪']

# 获取长度

length = len(heroList)

i = 0

while i < length:

print('英雄：', heroList[i])

i += 1

# 结果为

"""

英雄： 李青

英雄： 艾克

英雄： 蔚

英雄： 赵信

英雄： 酒桶

英雄： 男枪

"""

使用for循环

while 循环是一种基本的遍历列表数据的方式，但是最常用也是最简单的方式是使用 for 循环

for i in heroList: #herolist是可迭代对象

print('英雄：', i)

# 结果上同

列表的嵌套

类似while循环的嵌套，列表也是支持嵌套的

一个列表中的元素又是一个列表，那么这就是列表的嵌套

# 列表的嵌套

list = [1, 2, 3, [3, 2, 1], [1, 2, 3]]

print(list) # [1, 2, 3, [3, 2, 1], [1, 2, 3]]

# 操作列表的索引获得元素

print(list[3]) # [3, 2, 1]

# 操作列表的索引获得元素，再次操作索引或得深成索引

print(list[3][2]) # 1

列表的推导式

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

# 列表推导式

# 基本方式

a = [x for x in range(4)]

print(a) # [0, 1, 2, 3]

b = [x for x in range(1, 9)]

print(b)

# [1, 2, 3, 4, 5, 6, 7, 8]

# 在循环的过程中使用if

c = [x for x in range(20) if x % 2 != 0]

print(c)

# [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

# 2个for循环

t2 = [(x, y) for x in range(1, 4) for y in range(1, 4)]

print(t2)

# [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

# 3个for循环

t3 = [(x, y, z) for x in range(1, 3) for y in range(1, 3) for z in range(1, 3)]

print(t3)

# [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]

列表的拷贝

列表的拷贝，即列表的复制

可分为：

浅拷贝：

1. 列表的copy方法

2. copy模块的使用

3. 切片

深拷贝：

浅拷贝

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

列表的copy方法

使用列表的copy方法，可以直接将原来的列表进行复制，变成一个新的列表，这种复制方式是浅复制。

# 列表的copy方法

cp = [1, 2, 3, [3, 2, 1], [1, 2, 3]]

cp1 = cp.copy()

# 修改cp1

cp1[1] = 22

cp1[3][1] = 22

# 修改或拷贝后的列表

print(cp) # [1, 2, 3, [3, 22, 1], [1, 2, 3]]

print(cp1) # [1, 22, 3, [3, 22, 1], [1, 2, 3]]

copy模块的使用

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

# copy模块的使用

import copy # 导入copy模块

cy = [1, 2, 3, [3, 2, 1], [1, 2, 3]]

# 调用模块中的copy方法

cy1 = copy.copy(cy)

# 修改cy1

cy1[1] = 22

cy1[3][1] = 22

# 修改或拷贝后的列表

print(cy) # [1, 2, 3, [3, 22, 1], [1, 2, 3]]

print(cy1) # [1, 22, 3, [3, 22, 1], [1, 2, 3]]

切片

列表和字符串一样，也支持切片，切片其实就是一种浅拷贝。

# 切片的浅拷贝

ct = [1, 2, 3, [3, 2, 1], [1, 2, 3]]

ct1 = ct[::]

# 修改ct1

ct1[1] = 22

ct1[3][1] = 22

# 修改或拷贝后的列表

print(ct) # [1, 2, 3, [3, 22, 1], [1, 2, 3]]

print(ct1) # [1, 22, 3, [3, 22, 1], [1, 2, 3]]

深拷贝

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

# 深拷贝

dpcopy = [1, 2, 3, [3, 2, 1], [1, 2, 3]]

# 调用copy模块的deepcopy方法

deepcopy = copy.deepcopy(dpcopy)

# 修改ct1

deepcopy[1] = 22

deepcopy[3][1] = 22

# 修改或拷贝后的列表,对copy前的列表没有影响

print(dpcopy) # [1, 2, 3, [3, 2, 1], [1, 2, 3]]

print(deepcopy) # [1, 22, 3, [3, 22, 1], [1, 2, 3]]