05-列表

最新推荐文章于 2024-08-22 07:51:42 发布

weixin_45741929

最新推荐文章于 2024-08-22 07:51:42 发布

阅读量161

点赞数

分类专栏：千锋 python 文章标签： python 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_45741929/article/details/129314494

版权

千锋 python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Python中列表的基本使用，包括定义、下标访问、增删改查操作如append、insert、extend、index、count、del、pop、remove，以及排序方法sort和reverse。此外，还涉及了列表的遍历、交换变量、嵌套列表和列表推导式的概念和示例。文章通过实例讲解了如何高效地管理和操作列表数据。

摘要由CSDN通过智能技术生成

列表的基本使用

想一想：

前面学习的字符串可以用来存储一串信息，那么想一想，怎样存储咱们班所有同学的名字呢？
定义100个变量，每个变量存放一个学生的姓名可行吗？有更好的办法吗？

答：

列表

一、列表的格式

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

变量tmp的类型为列表

tmp = ['xiaoWang',180, 65.0]

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

二、使用下标获取列表元素

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

结果：

xiaoWang
xiaoZhang
xiaoHua

2. 列表的增删改查

一、添加元素

方法：

append 在末尾添加元素

insert 在指定的位置插入元素

extend 合并两个列表

append

append会把新元素添加到列表末尾

    #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

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

    #提示、并添加元素
    temp = input('请输入要添加的学生姓名:')
    A.append(temp)

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

运行结果：

----添加之前列表的元素----A=['xiaowang', 'xiaozhang', 'xiaohua']
请输入要添加的姓名：xiaohuang
----添加之前列表的元素----A=['xiaowang', 'xiaozhang', 'xiaohua', 'xiaohuang']

insert

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

strs=['a','b','m','s']
strs.insert(3,'h')
print(strs)

运行结果

['a', 'b', 'm', 'h', 's']

extend

通过extend可以将另一个集合中的元素逐一添加到列表中

a = ['a','b','c']
b = ['d','e','f']
a.extend(b)
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
print(b) # ['d','e','f'] b的内容不变

运行结果：

['a', 'b', 'c', 'd', 'e', 'f']
['d', 'e', 'f']

二、修改元素

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

#定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']
    print("-----修改之前，列表A的数据-----A=%s" % A)
    #修改元素
    A[1] = 'xiaoLu'
    print("-----修改之后，列表A的数据-----A=%s" % A)

运行结果：

---修改之前---A=['xiaowang', 'xiaozhao', 'xiaozhang']
---修改之后---A=['xiaowang', 'xiaolu', 'xiaozhang']

三、查找元素

所谓的查找，就是看看指定的元素是否存在，以及查看元素所在的位置，主要包含一下几个方法：

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('没有找到')

运行结果：

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 05-in_notIn.py 
请输入要查找的姓名：xiaohua
列表中存在元素
ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 05-in_notIn.py 
请输入要查找的姓名：xiaoming
列表中不存在

说明：

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

index, count

index用来查找元素所在的位置，如果未找到则会报错；count用来计算某个元素出现的次数。它们的使用和字符串里的使用效果一致。

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a'isnotin list
>>> a.index('a', 1, 4)
3>>> a.count('b')
2>>> a.count('d')
0

四、删除元素

类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。

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

del：根据下标进行删除

pop：删除最后一个元素

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

del

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
del movieName[2]
print('------删除之后------movieName=%s' % movieName)

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 06-del.py 
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang']

pop

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.pop()
print('------删除之后------movieName=%s' % movieName)

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 07-pop.py 
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang']

remove

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.remove('指环王')
print('------删除之后------movieName=%s' % movieName)

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 08-remove.py 
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaohua']

五、排序(sort, reverse)

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

reverse方法是将list逆置。

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()  # 逆置，不排序>>> a
[3, 2, 4, 1]
>>> a.sort()  # 默认从小到大排序>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)  # 从大到小排序>>> a
[4, 3, 2, 1]

练习

请删除列表 words = ['hello','',','good','hi','','yes','','no'] 里所有的空字符串。

words=['hello','','good','hi','yes','','no']

for i in words:
    if(i==''):
        words.remove(i) 
print(words)

运行结果：

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 09.py 
['hello', 'good', 'hi', 'yes', 'no']

3. 列表的遍历

1. 使用while循环

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

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)  # 获取列表长度
i = 0
while i<length:
    print(namesList[i])
    i+=1

运行结果:

xiaoWang
xiaoZhang
xiaoHua

2. 使用for循环

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

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)

运行结果:

xiaoWang
xiaoZhang
xiaoHua

3. 交换2个变量的值

# 使用中间变量
a = 4
b = 5
c = 0

c = a
a = b
b = c

print(a)
print(b)

练习

手动实现冒泡排序(难)

nums = [5, 1, 7, 6, 8, 2, 4, 3]

for j in range(0, len(nums) - 1):
   for i in range(0, len(nums) - 1 - j):
       if nums[i] > nums[i + 1]:
           a = nums[i]
           nums[i] = nums[i+1]
           nums[i+1] = a

print(nums)

有一个列表names，保存了一组姓名names=['zhangsan','lisi','chris','jerry','henry']，再让用户输入一个姓名，如果这个姓名在列表里存在，提示用户姓名已存在；如果这个姓名在列表里不存在，就将这个姓名添加到列表里。

names=['zhangsan','lisi','chris','jerry','henry']
name=input("请输入姓名：")
if name in names:
    print("已存在")
else:
    names.append(name)
print(names)

运行结果：

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 13.py 
请输入姓名：lisi
已存在
ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 13.py 
请输入姓名：xiaosi
['zhangsan', 'lisi', 'chris', 'jerry', 'henry', 'xiaosi']

4.列表的嵌套

1. 列表嵌套

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

>>> schoolNames = [
... [1, 2, 3],
... [11, 22, 33],
... [111, 222, 333]
... ]
>>> schoolNames[1][2]  # 获取数字 3333>>> schoolNames[1][2] = 'abc'# 把 33 修改为 'abc'>>> schoolNames
[[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
>>> schoolNames[1][2][2]  # 获取 'abc' 里的字符c'c'

也就是说，操作嵌套列表，只要把要操作元素的下标当作变量名来使用即可。

2. 应用

一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

import random

# 定义一个列表用来保存3个办公室
offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

运行结果:

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 14.py 
办公室1的人数为:3
DEF

--------------------
办公室2的人数为:2
CG

--------------------
办公室3的人数为:3
ABH

--------------------

5.列表推导式

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

1. 基本的方式

>>> a=[x for x in range(4)]
>>> a
[0, 1, 2, 3]
>>> a=[x for x in range(3,4)]
>>> a
[3]
>>> a=[x for x in range(3,19)]
>>> a
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
>>> a=[x for x in range(3,19,2)]
>>> a
[3, 5, 7, 9, 11, 13, 15, 17]

2. 在循环的过程中使用if

>>> a=[x for x in range(10) if x%2==0]
>>> a
[0, 2, 4, 6, 8]
>>> a=[x for x in range(10) if x%2!=0]
>>> a
[1, 3, 5, 7, 9]
>>> a=[x for x in range(10) ]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3. 2个for循环

>>> a=[(x,y) for x in range(3) for y in range(4)]
>>> a
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]

4. 3个for循环

>>> a=[(x,y,z) for x in range(2) for y in range(2) for z in range(2)]
>>> a
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

练习

请写出一段 Python 代码实现分组一个 list 里面的元素,比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....]

参考答案：

a = [x for x in range(1,101)]
b = [a[x:x+3] for x in range(0,len(a),3)]

6.列表的复制

查看以下代码，说出打印的结果。

a = 12
b = a
b = 13
print(b)
print(a)

nums1 = [1, 5, 8, 9, 10, 12]
nums2 = nums1
nums2[0] = 100
print(nums2)
print(nums1)

ljx@ljx-virtual-machine:~/桌面/python_example/列表$ python3 15.py 
13
12
[100, 5, 8, 9, 10, 12]
[100, 5, 8, 9, 10, 12]

思考：

为什么修改了 nums2里的数据，nums1的数据也会改变？

Python中的赋值运算都是引用(即内存地址)的传递。对于可变类型来说，修改原数据的值，会改变赋值对象的值。

怎样nums1和nums2变成两个相互独立不受影响的列表？

使用列表的 copy 方法，或者 copy 模块就可以赋值一个列表。

列表的copy方法

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

nums1 = [1, 5, 8, 9, 10, 12]
nums2 = nums1.copy()  # 调用列表的copy方法，可以复制出一个新的列表

nums2[0] = 100# 修改新列表里的数据，不会影响到原有列表里的数据
print(nums2)
print(nums1)

[100, 5, 8, 9, 10, 12]
[1, 5, 8, 9, 10, 12]

copy模块的使用

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

浅拷贝

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

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 浅拷贝只会拷贝最外层的对象，里面的数据不会拷贝，而是直接指向
words2 = copy.copy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['no', 'ok'], 'bad']
# wrods2 里的 yes 被修改成了 no
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']

深拷贝

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

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 深拷贝会将对象里的所有数据都进行拷贝
words2 = copy.deepcopy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['yes', 'ok'], 'bad']
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']

切片

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

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']
words2 = words1[:]
words2[0] = '你好'
words2[2][0] = 'no'
print(words1)  # ['hello', 'good', ['no', 'ok'], 'bad']
print(words2) # ['你好', 'good', ['no', 'ok'], 'bad']