Python之第六章 内置容器 --- 列表（2）_头歌平台python列表推导式

目录

Python之第六章 内置容器 --- 列表（2）

1.列表元素的添加和删除

2.列表元素统计

3.列表的排序

排序归类

4.列表的查找

5.列表逆置（颠倒顺序）

6.列表的元素组合

7.列表的浅拷贝与深拷贝

        列表之间的赋值

浅拷贝

深拷贝

8.列表的推导式

根据就列表生成指定新列表

从旧列表中选择符合条件的元素组成新列表

9.程序实例

---

Python之第六章 内置容器 --- 列表（2）

1.列表元素的添加和删除

        添加元素 --- listname.append(obj)

        例1 将值为奇数、索引为偶数的元素存储到另一个列表中

# 例1 将值为奇数、索引为偶数的元素存储到另一个列表中
import random
​
t1 = random.sample(range(10, 30), 10)
t2 = []
print(t1)
for index, item in enumerate(t1):
    if item % 2 == 0 and index % 2 == 1:
        t2.append(item)
print(t2)
​
结果
[14, 24, 18, 15, 17, 25, 19, 21, 13, 12]
[24, 12]

        删除元素 --- 根据索引删除 --- del listnname[index]

                       --- 根据内容删除 --- listname.remove(下标)

        例2 删除指定元素

#方法一
import random
​
t1 = random.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值'))
for i in t1:
    if i == n:
        t1.remove(i)
​
print(t1)
​
结果：
[23, 26, 18, 21, 10, 22, 25, 15, 13, 16]
请输入需要删除的元素的值10
[23, 26, 18, 21, 22, 25, 15, 13, 16]
​
#方法二
import random
​
t1 = random.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值'))
t1.remove(n)
print(t1)
​
结果：
[28, 18, 12, 25, 26, 24, 14, 23, 29, 27]
请输入需要删除的元素的值12
[28, 18, 25, 26, 24, 14, 23, 29, 27]

2.列表元素统计

        格式 --- listname.count(obj)

        作用 --- 获取元素在列表中的出现的次数，只能精确匹配

        注意 --- count（）方法一般与remove（）方法配合使用，即删除前先统计元素是否存在

        例：

#完善1中的例2
import random
​
t1 = random.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值'))
if t1.count(n) > 0:
    t1.remove(n)
    print(t1)
else:
    print('请输入的元素不在列表中')
结果：
[13, 29, 22, 25, 15, 28, 14, 20, 11, 17]
请输入需要删除的元素的值50
请输入的元素不在列表中

3.列表的排序

        例1 选择法排序 --- 有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束，大于号为升序，小于号为降序

# 例1 选择法排序 --- 有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束
import random
​
t1 = random.sample(range(10, 30), 10)
print('排序前：', t1)
​
for i in range(len(t1) - 1):
    for j in range(i + 1, len(t1)):
        if t1[i] > t1[j]:
            t1[i], t1[j] = t1[j], t1[i]
print('排序后：', t1)
​
结果：
排序前： [12, 17, 15, 29, 13, 25, 27, 22, 16, 10]
排序后： [10, 12, 13, 15, 16, 17, 22, 25, 27, 29]

        例2 插入排序

# 例2 插入排序
import random
​
t1 = random.sample(range(10, 30), 10)
print('排序前：', t1)
for i in range(1, 10):
    t = t1[i] # t为待插入元素
    j = i - 1
    # while 循环作用：将比当前元素大的值向右移动
    while j >= 0 and t < t1[j]:
        t1[j + 1] = t1[j]
        j = j - 1
    t1[j + 1] = t # 插入备份的元素
print('排序后:', t1)
​
结果：
排序前： [24, 16, 28, 15, 25, 17, 13, 10, 29, 18]
排序后: [10, 13, 15, 16, 17, 18, 24, 25, 28, 29]

排序归类

使用sort（）方法排序

        格式 --- listname.sort(key = None,reverse = False)

key --- 元素排序时比较的关键字 --- 如：key = str.lower --- 排序时不区分大小写字母

reverse --- 排序规则，Ture表示降序，False表示升序，默认为升序

sort( ) --- 该方法会修改列表的内容，返回值为None

        例 对列表进行升序

import random
​
list1 = random.sample(range(0, 20), 20)
print('排序前：', list1)
list1.sort()
print("升序排序为：", list1)
list1.sort(reverse=True)
print("降序排序为：", list1)
​
结果:
排序前： [15, 17, 14, 0, 1, 7, 13, 4, 10, 3, 2, 18, 6, 5, 16, 11, 9, 19, 8, 12]
升序排序为： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
降序排序为： [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

使用内置的sorted( )

        用法 --- 参照上述sort（）

        注意 --- 不改变列表的顺序，会生成副本

        例 对列表进行降序排序

# 使用sorted()方法进行降序排列
import random
​
list1 = random.sample(range(0, 20), 20)
print(list1)
print(sorted(list1, reverse=True))
print(list1)
​
结果：
[7, 18, 5, 16, 14, 13, 4, 19, 17, 8, 1, 0, 9, 12, 3, 15, 2, 11, 6, 10]
[19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[7, 18, 5, 16, 14, 13, 4, 19, 17, 8, 1, 0, 9, 12, 3, 15, 2, 11, 6, 10]

4.列表的查找

index( )方法

        定义 --- 用来查找某个元素在列表中第一次出现的位置（索引） --- 若果没有该元素，会导致ValueError错误 ，所以需要配合count( )方法判断是否存在该元素

        格式 --- listname.index（obj,start,end）

listname --- 列表名

obj --- 查找的元素对象

start --- 起始索引

end --- 终止索引（不包含）

返回值 --- 索引

list1 = [40, 36, 38, 89, 2, 36, 100, 7, -20, 20.5, -999]
print(list1.index(2))  # 查找数据2
print(list1.index(100, 3, 7))  # 在[3,7)索引中查找100
print(list1.index(7, 4))  # 从4索引开始到结束查找7
print(list1.index(89, 0, 2))  # 0索引到1索引查找89，未找到报错
​
结果：
Traceback (most recent call last):
  File "E:\pythontext\test3.py", line 1381, in <module>
    print(list1.index(89, 0, 2))  # 0索引到1索引查找89，未找到报错
ValueError: 89 is not in list
4
6
7

        例 有列表andy，内容包含名称和一系列的比赛的分，计算他在第几场得到最高分

andy = ['andy', 23, 19, 22, 31, 18, 15]
print(andy)
scorce_max = max(andy[1:])
i = andy.index(scorce_max)
print(andy[0], "在第%d场的最高分数%d" % (i - 1, scorce_max))
​
结果：
['andy', 23, 19, 22, 31, 18, 15]
andy 在第3场的最高分数31

        使用 in 和not in查找列表元素

list1 = [40, 36, 89, 2, 36]
print(2 in list1)
print(100 not in list1)
​
结果：
True
True

        二分法查找（折半查找）--- 要求必须是有序（升序）序列，若为无序序列则应该先排序

# 二分查找法
import random
​
list1 = random.sample(range(0, 20), 20)
list1.sort()
print(list1)
​
n = int(input('请输入要查找的值：'))
i = 0
j = 20 - 1
while i <= j:
    mid = (i + j) // 2 #计算中间数索引
    if list1[mid] == n:
        print('找到了')
        break
    else:
        if n < list1[mid]:
            j = mid - 1 #向左折半
        else:
            i = mid + 1 #向右折半
if i > j:
    print('未找到')
    
结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
请输入要查找的值：9
找到了

5.列表逆置（颠倒顺序）

        格式 --- listname.reverse

        例

import random
​
list1 = random.sample(range(0, 20), 10)
print(list1)
list1.reverse()
print(list1)
​
结果：
[13, 4, 9, 1, 14, 17, 10, 11, 5, 0]
[0, 5, 11, 10, 17, 14, 1, 9, 4, 13]

注意：

        永久性的改变，若需要使用原始数据则只需要再执行一次

6.列表的元素组合

        作用 --- 将列表的元素组成一个字符串

        格式 --- char.join(seq)

char --- 组合后元素的分隔符

seq --- 表示处理的对象，必须为列表、元组等序列数据

        例

char = '-'
list1 = ['silicon', 'stone', 'education']
print(char.join(list1))
print('=='.join(list1))
print('\n'.join(list1))
​
结果：
silicon-stone-education
silicon==stone==education
silicon
stone
education

7.列表的浅拷贝与深拷贝

        列表之间的赋值

list1 = [1, 2, 3, 4]
list2 = list1
print(id(list1), id(list2))
for i in range(len(list1)):
    list1[i] += 1  # list1中所有元素值加1
print(list1)
print(list2)
​
结果：
1132680788160 1132680788160
[2, 3, 4, 5]
[2, 3, 4, 5]

注意：

        列表复制相当于取别名，即两者都指向同一个堆栈区的地址列表对象，操作任意一个，另一个同步变化

浅拷贝

list1 = [1, 2, 3, 4]
list2 = list1.copy()  # list2是list1的浅拷贝结果
print(id(list1), id(list2))
for i in range(len(list1)):
    list1[i] += 1  # list1中所有元素值加1
print(list1)
print(list2)
​
结果：
1799131117824 1799131118080
[2, 3, 4, 5]
[1, 2, 3, 4]
​

分析：

         list2是list1列表的浅拷贝，id与list1不同，这是因为通过浅拷贝，产生的一段新的内存地址空间，与list2绑定，虽然内容相同但地址不同，相互隔离，互补影响，--- 列表中出现可变类型时则浅拷贝无效

        例

list1 = [1, 2, [3, 4]]
list2 = list1.copy()  # list2是list1的浅拷贝结果
print(id(list1), id(list2))
list1[0] += 1
list1[1] += 1
list1[2][0] += 1
list1[2][1] += 1
​
print(list1)
print(list2)
print(id(list1[2]), id(list2[2]))
​
结果：
2688355350976 2688355364736
[2, 3, [4, 5]]
[1, 2, [4, 5]]
2688355350784 268835535078

分析

        list1列表两个不可变元素1和2没有改变，并且没有影响list2，但list1的可变类型元素[3,4]改为[4,5]list2列表中的字列表也一同改变，说明list1与list2并没有完全隔离开来，虽然list1和list2的内存地址相互独立，但列表第三项绑定的是同一个子列表地址，如果原列表包含了可变类型元素，通过浅拷贝得到的新列表，不能实现与原列表完全各路，若完全隔离需要使用深拷贝

深拷贝

import copy
​
list1 = [1, 2, [3, 4]]
list2 = copy.deepcopy(list1)  # list2是list1的深拷贝结果
print(id(list1), id(list2))
list1[0] += 1
list1[1] += 1
list1[2][0] += 1
list1[2][1] += 1
​
print(list1)
print(list2)
print(id(list1[2]), id(list2[2]))
​
结果：
2239442863744 2239442464000
[2, 3, [4, 5]]
[1, 2, [3, 4]]
2239443485760 2239442463680

分析

        通过深拷贝，子列表完全隔离，从而实现了与原列表真正的完全区分隔离

8.列表的推导式

        作用 --- 可以疏通推导式生成新列表

        格式 --- listname = [表达式，for，循环变量，in range()]

        例1 创建数值为0-19的列表

list1 = [x for x in range(20)]
print(list1)
​
#相当于：
​
list1 = []
for x in range(20):
    list1.append(x)
print(list1)
​
结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

        例2 创建100-200间30个数的随机数列表

# 创建100-200间30个数的随机数列表
import random
​
list1 = [random.randint(100, 200) for i in range(30)]
print(list1)
​
结果：
[158, 105, 170, 101, 158, 144, 118, 141, 133, 148, 185, 120, 134, 115, 146, 189, 150, 194, 187, 131, 142, 181, 167, 148, 144, 141, 108, 136, 125, 168]

        randint(x,y) 表示产生一个随机数，范围在x与y之间

根据就列表生成指定新列表

        格式 --- newlistname = [表达式，for 循环变量 in 旧列表]

        例 根据原列表生成数值折半列表

# 例 根据原列表生成数值折半列表
import random
​
list1 = [random.randint(0, 100) for i in range(20)]
print(list1)
list2 = [x / 2 for x in list1]
print(list2)
​
结果：
[59, 85, 12, 1, 23, 85, 38, 8, 59, 88, 29, 50, 100, 18, 42, 29, 67, 84, 34, 38]
[29.5, 42.5, 6.0, 0.5, 11.5, 42.5, 19.0, 4.0, 29.5, 44.0, 14.5, 25.0, 50.0, 9.0, 21.0, 14.5, 33.5, 42.0, 17.0, 19.0]
​

从旧列表中选择符合条件的元素组成新列表

        格式 --- newlistname = [表达式，for 循环变量 in 旧列表名 if 条件表达式 ]

        例 创建1-10之间的偶数列表

# 例 创建1-10之间的偶数列表
import random
​
list1 = [random.randint(0, 100) for i in range(10)]
print(list1)
list2 = [x for x in list1 if x % 2 == 0]
print(list2)
​
结果：
[21, 22, 49, 77, 56, 44, 30, 48, 37, 55]
[22, 56, 44, 30, 48]
​

注意

        只用列表推导式来创建新列表，并且竟可能保持简短

        如果列表推导式的代码超过2行，则代码可读性大大降低，应考虑写成循环

9.程序实例

        例1 将20个十进制整数存储在xx列表中，计算系列表的奇数平均值，偶数平均值、偶数的方差

# 例1 将20个十进制整数存储在xx列表中，计算系列表的奇数平均值，偶数平均值、偶数的方差
# 方法一
import numpy
import random
​
xx = random.sample(range(0, 30), 20)
ave1 = []
ave2 = []
for i in xx:
    if i % 2 == 1:
        ave1.append(i)
    else:
        ave2.append(i)
print('奇数平均值：', numpy.mean(ave1))
print('偶数平均值：', numpy.mean(ave2))
print('偶数方差：', numpy.var(ave2))
​
# 方法二
import numpy
import random
​
xx = random.sample(range(0, 30), 20)
ave1 = [i for i in xx if i % 2 == 1]
ave2 = [i for i in xx if i % 2 == 0]
print('奇数平均值：', numpy.mean(ave1))
print('偶数平均值：', numpy.mean(ave2))
print('偶数方差：', numpy.var(ave2))
​
结果：
奇数平均值： 14.6
偶数平均值： 13.8
偶数方差： 77.16

        例2 将输入一行空格作为分隔符的数字去重后输出

# 例2 将输入一行空格作为分隔符的数字去重后输出
# split() 将空格分隔的字符串切片后转化为字符串列表
list1 = input('请输入空格分隔的数字内容：').split()
for i in range(len(list1)):
    list1[i] = int(list1[i])
print(list1)
list2 = []
for i in list1:
    if list2.count(i) == 0:  # 统计接收列表 若为0表示唯一，则追加
        list2.append(i)
print(list2)
​
结果：
请输入空格分隔的数字内容：6 1 0 6 0 2 85 1 89 22 6 5
[6, 1, 0,   6, 0, 2, 85, 1, 89, 22, 6, 5]
[6, 1, 0, 2, 85, 89, 22, 5]
​

        例3 合并2个有序列表构成一个新的有序列表

#   例3 合并2个有序列表构成一个新的有序列表
list1 = list(eval(input("请输入第一个列表：")))
list2 = list(eval(input("请输入第二个列表：")))
# extend()在列表尾部，追加一个完整列表
list1.extend(list2)
list1.sort()
print(list1)
​
结果：
请输入第一个列表：1,5,5,8,9,5,6,25,16,51
请输入第二个列表：6,5,4,8,1,2,3,4,8
[1, 1, 2, 3, 4, 4, 5, 5, 5, 5, 6, 6, 8, 8, 8, 9, 16, 25, 51]
​
​

        例4 编写程序实现判断 列表是否为升序

# 例4 编写程序实现判断列表是否为升序
list1 = list(eval(input("请输入第一个列表：")))
f = 1  # 默认认为为升序，标志位 --- 表示程序的可能性
for i in range(len(list1) - 1):
    if list1[i] > list1[i + 1]:
        f = 0
        break
if f == 1:
    print('该列表为升序')
else:
    print('该列表无序')
    
结果：
请输入第一个列表：1,2,3,4,5,6
该列表为升序

        例5 输入一个十进制数转换为二进制数输出

# 例5 输入一个十进制数转换为二进制数输出
# 方法一
list1 = []
num = int(input('请输入一个十进制整数：'))
if num == 0:
    print('0000')
else:
    while num != 0:
        list1.append(num % 2)
        num = num // 2
list1.reverse()
print(list1)
​
# 方法二
list1 = []
num = int(input('请输入一个十进制整数：'))
if num == 0:
    print('0000')
else:
    while num != 0:
        num, r = divmod(num, 2)  # 计算num%2得到的商和余数
        list1.append(r)
list1.reverse()  # reverse()内置方法将列表颠倒
print(list1)
​
结果：
请输入一个十进制整数：6
[1, 1, 0]

        例6 将列表的前p的元素平移到列表尾部后输出

# 例6 将列表的前p的元素平移到列表尾部后输出
import random
​
list1 = random.sample(range(0, 50), 10)
print('随机的列表为：', list1)
p = int(input('请输入移动元素个数：'))
for i in range(p):
    list1.append(list1[i])
list1 = list1[p:]
print(list1)
​
结果：
随机的列表为： [22, 19, 11, 23, 7, 8, 46, 48, 17, 40]
请输入移动元素个数：2
[11, 23, 7, 8, 46, 48, 17, 40, 22, 19]
​