8.遍历列表&列表系统功能&列表推导式&列表拷贝

Chiayi_init_

已于 2022-12-17 21:30:49 修改

阅读量366

点赞数 2

分类专栏： Python--全栈开发 Python--基础语法文章标签： python pycharm 开发语言

于 2022-11-13 17:20:59 首次发布

本文链接：https://blog.csdn.net/m0_57975635/article/details/127834191

版权

Python--全栈开发同时被 2 个专栏收录

37 篇文章 1 订阅

订阅专栏

Python--基础语法

21 篇文章 0 订阅

订阅专栏

本文详细介绍了Python中遍历列表的四种方法，并展示了列表的增删改查功能，包括append、extend、insert、remove、pop、clear等操作。此外，还探讨了列表推导式的使用，以及浅拷贝与深拷贝的区别。最后，提供了列表拷贝的相关示例，强调了is和isnot、id函数在判断列表引用与值上的作用。

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

一、遍历列表

# 遍历：依次获取迭代器【列表，字符串，元组，字典，集合...】中的每个元素

# 1.访问列表中的元素
list1 = [34,5,6,67]
# print(list1[0])
# print(list1[1])
# print(list1[2])
# print(list1[3])

# 2.遍历列表
# 方式一
i = 0
while i < len(list1):
    print(list1[i])
    i += 1

# 方式二:直接获取元素        ******
for n in list1:
    print(n)

# 方式三：获取索引             ******
for i in range(len(list1)):
    print(i,list1[i])

# 方式四：同时获取索引和元素
# r = enumerate(list1)    # enumerate(x)将x容器转换为一个新的容器【枚举】，新的容器中的元素包括索引和元素
# print(list(r))   # [(0, 34), (1, 5), (2, 6), (3, 67)]
for index,ele in enumerate(list1):
    print(index,ele)

# a,b = (10,20)   # 拆包
# print(a,b)  # 10  20

二、列表系统功能

函数说明
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() 清空列表

函数	说明
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()	清空列表

1.增

# 列表是可变的，所以涉及到列表元素的增，删或改的操作，基本都是在原列表内部进行的，并没有生成一个新的列表

# 1.append(obj):在列表末尾追加新的元素,注意：obj可以是任意的类型          ******
list1 = [11,22,33]
print(list1)
list1.append(44)
print(list1)
list1.append('aaa')
print(list1)
list1.append(True)
print(list1)
list1.append([55,66])
print(list1)

# 2.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list2 = [11,22,33]
print(list2)
# list2.extend(10)   # TypeError: 'int' object is not iterable可迭代对象
# print(list2)
list2.extend('abc')
print(list2)   # [11, 22, 33, 'a', 'b', 'c']
list2.extend([55,66])
print(list2)
list2.extend((55,66))
print(list2)
list2.extend(range(3))
print(list2)

"""
注意
    a.列表.append()可以添加任意类型的元素
      列表.extend()只能添加可迭代对象的元素，可迭代对象：本质是一个容器，可以通过for循环遍历其中的元素，如：列表，字符串，元组，字典，集合.....
    b.列表.append()：如果添加的是容器，则整个容器会被添加到原列表中
      列表.extend()：只会将指定容器中的元素添加到原列表中
"""

# 3.insert(index,obj)：将元素插入到列表的指定位置
# 注意：在指定列表的指定索引处插入一个元素，原来的元素向后顺延
list3 = [11,22,33]
print(list3)
list3.insert(1,44)
print(list3)   # [11, 44, 22, 33]

# 注意：insert(index,obj),index可以越界，如果越界，默认将指定元素插入到末尾
list3.insert(10,55)
print(list3)   # [11, 44, 22, 33, 55]

list3.insert(0,66)
print(list3)

2.删

# 1.remove(元素):移除列表中某个值的第一个匹配项          *******
list1 = [23,5,34,5,5,10]
print(list1)
list1.remove(5)
print(list1)

# list1.remove(100)   # ValueError: list.remove(x): x not in list

# 2.pop(索引):移除列表中指定索引处的元素（默认最后一个元素），并且返回该元素的值     *****
list2 = [23,5,34,5,5,10]
print(list2)
# a.如果未指定索引，默认删除最后一个元素
# list2.pop()
# print(list2)
# b.如果指定索引，则删除指定索引处的元素
# list2.pop(1)
# print(list2)
# c.区别于remove，pop只是将元素从列表中移除，但是在内存中存在,所以可以用变量将值接出来
# r1 = list2.remove(5)
# print(r1)   # None
r2 = list2.pop(1)
print(r2)

# 3.clear()：清空列表
list3 = [23,5,34,5,5,10]
print(list3)
list3.clear()
print(list3)   # []

# 4.del  xxx
# a.del 列表[索引]
list3 = [23,5,34,5,5,10]
print(list3)
del list3[1]    # 等价于list3.pop(1)
print(list3)

# b.del 列表
del list3
# print(list3)   # NameError: name 'list3' is not defined

3.改

# 1.reverse():反转/翻转                 *******
list1 = [34,45,5,67,100,50]
print(list1)
list1.reverse()
print(list1)

# 2.sort():排序                       ********
# a.升序
list1 = [34,45,5,67,100,50]
print(list1)
list1.sort()
print(list1)

# b.降序，sort(reverse=True)
list1 = [34,45,5,67,100,50]
print(list1)
list1.sort(reverse=True)
print(list1)

# 注意：关于sort(),目前升序和降序的用法只适用于数字或者字符串类型的列表进行排序，如果有其他的排序规则，需要借助于函数

4.查

numlist = [34,6,56,6,6,7,6,134,50,30]

# 1.len():获取列表的长度                       ******
print(len(numlist))

# 2.max()/min():获取列表中元素的最值
print(max(numlist))
print(min(numlist))

# 3.index(ele,[start,end]):获取一个元素在列表中第一次出现的索引           *****
r1 = numlist.index(6)
print(r1)
# r1 = numlist.index(100)   # ValueError: 100 is not in list

numlist = [34,6,56,20,7,6,134,50,30]
# a.全局查找
r1 = numlist.index(6)
print(r1)

# b.局部查找,仍然符合包头不包尾的规则，返回的仍然是原列表中的索引
r1 = numlist.index(6,1,5)
print(r1)    # 1
# r1 = numlist.index(6,2,5)
# print(r1)    # ValueError: 6 is not in list

# 4.count():统计一个元素在列表中出现的次数             ******
r = numlist.count(6)
print(r)

# 5.list(x)：将x转换为列表，但是x只能是容器
print(list('abc'))
print(list(range(5)))

三、列表推导式

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

列表推导式/列表生成式:是Python特有的语法，通过循环和if语句专门用来创建列表特点：根据一个已知的Iterable,使用一行代码实现简单的逻辑，生成一个新的列表

语法：[新列表中的元素规律 for循环 if语句]

工作原理：执行for循环，获取已知Iterable的元素，结合if判断，最终得到新的列表中元素的规律

# 1.已知一个列表list1 = [3,5,23,10],生成一个新的列表，新列表中的元素是list1中元素的2倍
list1 = [3,5,23,10]
# 方式一
list11 = []
for ele in list1:
    list11.append(ele * 2)
print(list11)

# 方式二
list12 = [ele * 2 for ele in list1]
print(list12)

# 2.已知列表list2 = [34,56,6,7,7,12,34,4,5,10,39,34],将其中的偶数元素挑出，生成一个新的列表
list2 = [34,56,6,7,7,12,34,41,53,10,39,35]
# 方式一
list21 = []
for num in list2:
    if num % 2 == 0:
        list21.append(num)
print(list21)

# 方式二
list22 = [num for num in list2 if num % 2 == 0]
print(list22)

# 3.在列表推导式中，for语句和if语句都可以书写多个,从左到右是相互嵌套的关系
# a
list31 = [m + n for m in 'abc' for n in '123']
print(list31)

# 工作原理
list31 = []
for m in 'abc':
    for n in '123':
        list31.append(m + n)    # 字符串+表示拼接
print(list31)

# b.
list32 = [n for n in range(1,100) if n % 3 == 0 if n % 7  == 0]
print(list32)

# 工作原理
list32 = []
for n in range(1,100):
    if n % 3 == 0:
        if n % 7 == 0:
            list32.append(n)
print(list32)

# 练习：生成一个新的列表，将已知列表中['abc',True,34,13.19,'hello',40]中的数字挑出
list1 = ['abc',True,34,13.19,'hello',40]
list2 = [ele for ele in list1 if type(ele) == int or type(ele) == float]
print(list2)

四、列表拷贝

# 地址的概念
# 1.变量中存储的是数据的地址
num = 10
print(id(num),id(10))

# 2.列表中存储的是数据的地址
numlist = ['abc',10,True]
print(id(numlist))
print(id(numlist[0]),id('abc'))
print(id(numlist[2]),id(True))

# 3.is和is not
"""
is:判断两个变量的地址是否相同
==：判断两个变量的值是否相同
"""
# a.不可变的数据类型：int/float/bool/str/tuple
n1 = 10
n2 = 10
# 比较值
print(n1 == n2)  # True
# 比较地址
print(n1 is n2)  # True
print(id(n1) == id(n2))  # True

n2 = 20
# 比较值
print(n1 == n2)  # False
# 比较地址
print(n1 is n2)  # False
print(id(n1) == id(n2))  # False

print("*" * 50)

# b.可变的数据类型：list/dict/set
list1 = [10,20,30]
list2 = [10,20,30]
# 比较值
print(list1 == list2)   # True
# 比较地址
print(list1 is list2)   # False
print(id(list1) == id(list2)) # False

list2 = [10,60,30]
# 比较值
print(list1 == list2)   # False
# 比较地址
print(list1 is list2)   # False
print(id(list1) == id(list2)) # False

"""
结论：
    两个变量的地址相同，则这两个变量的值一定相同
    两个变量的值相同，则这两个变量的地址不一定相同
"""

print("*" * 80)

# 二.列表拷贝
# 1.=引用赋值
# a.一维列表
list1 = [11,22,33]
list2 = list1
print(list1 is list2)  # True
list1[1] = 100
print(list1 is list2)  # True
print(list1)    # [11, 100, 33]
print(list2)    # [11, 100, 33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = list1
print(list1 is list2)  # True
list1[0][1] = 100
print(list1 is list2)  # True
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论1：
    无论是一维列表还是多维列表，如果使用引用赋值的方式操作，
    只要通过一个变量修改了列表中的元素，则另一个变量访问的列表也会随着修改
"""

print("*" * 80)

# 浅拷贝:只拷贝列表的最外层
# 2.列表.copy():浅拷贝
# a.一维列表
list1 = [11,22,33]
list2 = list1.copy()
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = list1.copy()
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

print("*" * 80)

import  copy
# 3.copy.copy()：浅拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.copy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.copy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论2：列表.copy() 和 copy.copy(列表) 和 切片
    一维列表：如果一个变量修改列表中的元素，对另一个列表没有任何影响
    二维列表：如果一个变量修改内层列表中的元素，则另一个列表中的元素会随着发生修改    
"""

print("*" * 80)

# 深拷贝：不管列表嵌套了几层，都会拷贝
# 4.copy.deepcopy()：深拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.deepcopy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.deepcopy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,22,33],[44,55]]

"""
结论3：copy.deepcopy()
    无论是一维列表还是多维列表，如果使用copy.deepcopy()的方式操作，
    通过一个变量修改了列表中的元素，另一个变量访问的列表没有影响
"""

# 注意：不管是浅拷贝还是深拷贝，都会生成一个新的列表，所以列表的地址都会发生改变