Python中arr1 python中arr[1,2,[3,4]]

列表的介绍

一、什么是列表

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

二、列表的格式

定义列的格式： [元素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)) #<class 'list'>
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]]