Python（10）列表例题重写＜1＞

1.创建列表

a = [2, 3, 4, 5]
b = ['china', 'hello', 'world']
c = [45.6, 'hello', '中国']
print(a)
print(b)
print(c)
# [2, 3, 4, 5]
# ['china', 'hello', 'world']
# [45.6, 'hello', '中国']

2.使用内置函数list（）创建列表

t1=list()
t2=list('china')
print(t1)
print(t2)
# []
# ['c', 'h', 'i', 'n', 'a']

3.使用range()创建数值迭代列表

t3=list(range(10,20,2))
print(t3)
# [10, 12, 14, 16, 18]

4.将列表转换为列表

t1=[1,2,3,4,5,6,7]
t6=list(t1)
print(t6)---浪费资源，无意义
# [1, 2, 3, 4, 5, 6, 7]

5.删除列表

# 5.1  del listname
team =['皇马','拜仁','利物浦','罗马']
del team
# print(team)
# 删除的是引用指向，列表还在
# 5.2 listname.clear()：清空列表内容，保留列表结构
team =['皇马','拜仁','利物浦','罗马']
team.clear()
print(team)
# []
 
# PS：python自带垃圾回收机制，会自动销毁不同列表，一般不需要手动删除

6.通过索引访问列表

t=[114,89,5,'春眠不觉晓',66]
print(t[0])   # 114
print(t[-1])   # 66

7.列表切片访问

t1 = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
#     0  1  2  3   4   5   6   7   8  9
print(t1[0:7:4])  # 0索引开始，到6索引结束，间隔4个
print(t1[1:5])  # 1索引开始，到4索引结束，间隔1个
print(t1[2:])  # 2索引开始到结束
print(t1)  # 输出全部内容
print(t1[:])  # 全部
print(t1[::])  # 全部
print(t1[0:])  # 全部
print(t1[:-1])  # 将索引下标为-1的数，即最后一个数，不输出。因为不包含
# 相当于print(t1[0:-1:1])
# print(t1[0:6:0])  # 报错
print(t1[::-1])  # 反向输出
print(t1[:-1])  # 正序，不包含最后一个数
# [2, 10]
# [4, 6, 8, 10]
# [6, 8, 10, 12, 14, 16, 18, 20]
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# [2, 4, 6, 8, 10, 12, 14, 16, 18]
# [20, 18, 16, 14, 12, 10, 8, 6, 4, 2]
# [2, 4, 6, 8, 10, 12, 14, 16, 18]

 8.列表相加

# 8.1
t1=[1,2,3]
t2=[4,5,6]
t3=['hello']
t4=['world']
t5=t1+t2
t6=t3+t4
print(t5,t6)
t7=t5+t6
print(t7)
# [1, 2, 3, 4, 5, 6] ['hello', 'world']
# [1, 2, 3, 4, 5, 6, 'hello', 'world']
# 8.2
t1=[1,2,3,4,5,6]
# print(t1+6)
t2=['hello','world']
# print(t2+'china')  # 报错
# 不能实现列表和常量的连接

9.列表相乘

# 9.1
t1=[1,2,3]
t2=['hello','world']
print(3*t1)
print(t2*4)
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
# ['hello', 'world', 'hello', 'world', 'hello', 'world', 'hello', 'world']
# 9.2 初始化长度为None的空列表
emptylist = [None]*5
print(emptylist)
# [None, None, None, None, None]

10.输出列表最大值

# 10.1
import random as r
t1 = r.sample(range(10,30),10)
# 产生10-30，10个不重复的随机数
print(t1)
print('max=',max(t1))
t1.sort()  # 将其进行排序
print(t1)
print(t1[-1])
# [20, 14, 18, 19, 21, 17, 26, 12, 25, 16]
# max= 26
# [12, 14, 16, 17, 18, 19, 20, 21, 25, 26]
# 26
# 10.2
t1 = r.sample(range(10,30),10)  # 产生10-30,10个不同的随机数
print(t1)
max = t1[0]  # max变量存储列表第一个元素
for i in t1:
    if max
        max=i
print('max=',max)
# [20, 14, 24, 15, 12, 19, 11, 23, 29, 21]
# max= 29

11.将列表中值为偶数，索引为奇数的值输出

import random as r
t1 = r.sample(range(10,30),10)  # 产生10-30,10个不同的随机数
print(t1)
for index,item in enumerate(t1):
    if item%2==0 and index%2==1:
        print(index,item)
# [18, 22, 12, 13, 17, 26, 20, 21, 23, 10]
# 1 22
# 5 26
# 9 10

12.素数判断筛选法：筛选出100以内的素数（产生2-99序列：2 3 4 5 6 7 8 9……99）

list1 = list(range(0,101))  # 产生0-100的列表
print()
i = 2  # 从最小素数2开始
while i<100:  # 遍历列表
    j = list1[i]*2  # 计算当前值的倍数
    while j<100:
        list1[j]=0  # 将倍数置为0
        j=j+list1[i]
    i+=1
    while list1[i]==0:
        i+=1  # 排除已经置为0的元素不再遍历
# 循环输出列表中不是0的素数
t = 0
for i in range(2,100):
    if list1[i]!=0:
        t = t+1
        print(list1[i],end=' ')
        if t%10==0:
            print()
# 2 3 5 7 11 13 17 19 23 29 
# 31 37 41 43 47 53 59 61 67 71 
# 73 79 83 89 97 

13.将值为奇数，索引为偶数的元素存储到另一个列表中

import random as r
 
t1 = r.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)
# [22, 29, 11, 16, 23, 13, 15, 12, 24, 18]
# [16, 12, 18]

14.根据内容删除元素：listname.remove()

import random as r
 
t1 = r.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值：'))
t1.remove(n)
print(t1)
# [19, 18, 20, 24, 26, 21, 29, 14, 23, 27]
# # 请输入需要删除的元素的值：21
# # [19, 18, 20, 24, 26, 29, 14, 23, 27]

15.列表元素统计

import random as r
t1 = r.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值：'))
if t1.count(n)>0:  # 先统计判断后再删除
    t1.remove(n)
    print(t1)
else:
    print('输入元素不在列表中')
# [10, 13, 21, 28, 12, 18, 27, 14, 22, 26]
# 请输入需要删除的元素的值：12
# [10, 13, 21, 28, 18, 27, 14, 22, 26]

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

import random as r
 
t1 = r.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)
# 排序前： [19, 16, 20, 26, 12, 11, 13, 23, 18, 28]
# 排序后： [11, 12, 13, 16, 18, 19, 20, 23, 26, 28]

17.插入排序

import random as r
 
t1 = r.sample(range(0, 10), 10)
print('排序前', t1)
for i in range(0, 10):
    t = t1[i]  # t为代插入元素
    j = i - 1
    # while循环作用，将比当前元素大的值向后移动一个位置
    while j >= 1 and t < t1[j]:
        t1[j + 1] = t1[j]
        j = j - 1
    t1[j + 1] = t  # 插入备份的元素
print('排序后', t1)
# 排序前 [5, 6, 4, 7, 8, 9, 0, 1, 2, 3]
# 排序后 [5, 0, 1, 2, 3, 4, 6, 7, 8, 9]

18.对列表进行升序和降序，使用sort()方法排序

import random as r
l1 = r.sample(range(0,10),10)
print(l1)
l1.sort()
print(l1)
l1.sort(reverse=True)
print(l1)
# [6, 4, 3, 5, 8, 1, 0, 2, 7, 9]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

19.对列表进行降序排序，使用内置sorted()

import random as r
l1 = r.sample(range(0,10),10)
print(l1)
print(sorted(l1,reverse=True))
print(l1)
# 不会改变列表的初始值，会生成相应副本
# [6, 8, 3, 9, 7, 5, 4, 1, 0, 2]
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# [6, 8, 3, 9, 7, 5, 4, 1, 0, 2]

20.列表查找，index()方法，在列表中查找数据

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 12, 90]
print(l1.index(2))  # 查找数据2  1
print(l1.index(12, 3, 10))  # 在[3,10)索引查找元素12  8
print(l1.index(6, 3))  # 从3索引开始到结束，查找数据6  5
# print(l1.index(4,0,3))  # [0,3)索引查找4，未找到，报错。可使用count()判断

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

andy = ['Andy', 23, 34, 45, 34, 56, 76]
print(andy)
score_max = max(andy[1:])
i = andy.index(score_max)
print(andy[0], '在第%d场得到最高分%d' % (i, score_max))
# ['Andy', 23, 34, 45, 34, 56, 76]
# Andy 在第6场得到最高分76

22.使用in   not in查找列表元素

l1 = [23, 34, 2, 52, 6, 78, 97]
print(2 in l1)  # True
print(100 not in l1)  # True

23.折半查找（二分法查找）：必须是有序（升序）序列，若为无序则应先排序

import random as a
 
l1 = a.sample(range(0, 10), 10)
l1.sort()
print(l1)
n = int(input('请输入待查找的值'))
i = 0
j = 9
while i <= j:
    mid = (i + j) // 2  # 若为偶数个元素，折半查找的中间数是折半后向左偏
    # 计算中间数索引
    if l1[mid] == n:
        print('已找到')
        break
    else:
        if n < l1[mid]:
            j = mid - 1  # 向左折半
        else:
            i = mid + 1  # 向右折半
if i > j:
    print('未找到')
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 请输入待查找的值6
# 已找到

24.列表的逆置（颠倒顺序）。listname.reverse()

import random as r
 
l1 = r.sample(range(0, 20), 10)
print(l1)
l1.reverse()
print(l1)
# [10, 5, 17, 14, 18, 9, 8, 4, 12, 3]
# [3, 12, 4, 8, 9, 18, 14, 17, 5, 10]

25.列表的元素组合

格式：char.join(seq)
char：组合后元素的分隔符
seq：表示处理的对象，必须为列表、元组等序列数据
char = '-'
l1 = ['hello', 'world', 'education']
print(char.join(l1))
print('=='.join(l1))
print('\n'.join(l1))
# hello-world-education
# hello==world==education
# hello
# world
# education

26. 列表之间的赋值操作

l1 = [1, 2, 3, 4, 5]
l2 = l1  # 先当于给同一段内存区域的起另一个名字
print(id(l1), id(l2))
for i in range(len(l1)):
    l1[i] += 1  # 给列表l1中所有元素加1
print(l1)
print(l2)
# 1494753826496 1494753826496
# [2, 3, 4, 5, 6]
# [2, 3, 4, 5, 6]

27.浅拷贝：浅拷贝针对不可变元素会完全隔离，有可变元素无法实现完全隔离

方法 1 ：
l1 = [1, 2, 3, 4, 5]
l2 = l1.copy()  # l2是l1的浅拷贝结果
print(id(l1), id(l2))
for i in range(len(l1)):
    l1[i] += 1  # 给列表l1中所有元素加1
print(l1)
print(l2)
# 2502509513250496 2509513250560
# [2, 3, 4, 5, 6]
# [1, 2, 3, 4, 5]
l2是l1的浅拷贝，id与l1不同，这是因为通过浅拷贝，产生一段新的内存地址空间，与l2绑定。内容相同地址不同，相互隔离，互不影响。但列表中出现可变类型时，则浅拷贝无效。
方法 2 ：
l1 = [1, 2, [3, 4, 5]]
l2 = l1.copy()  # l2是l1的浅拷贝结果
print(id(l1), id(l2))
l1[0] += 1  # 给列表l1中所有元素加1
l1[1] += 1
l2[2][0] += 1
l2[2][1] += 1
print(l1)
print(l2)
print(id(l1[2]), id(l2[2]))
# 3098922357440 3098922014464
# [2, 3, [4, 5, 5]]
# [1, 2, [4, 5, 5]]
# 3098922016896 3098922016896
l1列表两个不可变元素1和2没有改变并没有影响l2，但l1的可变类型元素[3,4]改为了[4,5]，l2列表中的子列表也一同改变，说明l1和l2并没有完全隔离开。虽然l1和l2内存地址互相独立，但列表第三项绑定的是同一个内存地址，如果原列表包含了可变类型元素，通过浅拷贝得到的新列表，不能实现与原列表完全隔离，如要完全隔离需要使用深拷贝。

28.深拷贝

import copy as c
 
l1 = [1, 2, [3, 4]]
l2 = c.deepcopy(l1)  # l2是l1的深拷贝
print(id(l1), id(l2))
l1[0] += 1
l1[1] += 1
l2[2][0] += 1
l2[2][1] += 1
print(id(l1[2]), id(l2[2]))
print(l1)
print(l2)
# 1898630689024 1898630304448
# 1898631311232 1898630304896
# [2, 3, [3, 4]]
# [1, 2, [4, 5]]
分析：通过深拷贝列表完全隔离，从而实现与原列表真正的完全区分隔离。代价：内存消耗过快

29.列表推导式，创建数值为0-19的列表

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

30.创建100-200间的30个随机数

import random as a
l1=[a.randint(100,200) for i in range(30)]
print(l1)
# [147, 187, 124, 101, 112, 132, 112, 105, 119, 112, 178, 108, 106, 103, 132, 124, 133, 186, 109, 141, 160, 124, 100, 126, 155, 173, 103, 188, 106, 127]
randint(x,y)表示产生一个随机数，范围在x与y之间

31.根据原列表生成数值折半列表，newlistname=[表达式，for 循环变量 in 旧列表]

import random as a
 
l1 = [a.randint(0, 100) for i in range(10)]
print(l1)
l2 = [x / 2 for x in l1]
print(l2)
# [8, 33, 81, 65, 29, 24, 27, 68, 31, 53]
# [4.0, 16.5, 40.5, 32.5, 14.5, 12.0, 13.5, 34.0, 15.5, 26.5]

32.创建1-10之间的偶数列表，newlistname=[表达式，for 循环变量 in 旧列表名 if 条件表达式]

import random as a
 
l1 = [a.randint(1, 10) for i in range(10)]
print(l1)
l2 = [x for x in l1 if x % 2 == 0]
print(l2)
# [2, 9, 6, 3, 8, 5, 2, 5, 2, 4]
# [2, 6, 8, 2, 2, 4]

33.将20个十进制整数存取到列表中，计算列表奇数平均值，偶数平均值，偶数方差

# 法1
import numpy as n
import random as r
 
x = r.sample(range(0, 30), 20)
a1 = []
a2 = []
for i in x:
    if i % 2 == 1:
        a1.append(i)
    else:
        a2.append(i)
print('奇数平均值：', n.mean(a1))
print('偶数平均值：', n.mean(a2))
print('偶数方差：', n.var(a2))
# 奇数平均值： 17.181818181818183
# 偶数平均值： 14.0
# 偶数方差： 26.666666666666668
# 法2
import random as r
t1 = r.sample(range(10,40),20)
t2 = []
t3 = []
for i in t1:
    if i%2==0:
        t2.append(i)
    else:
        t3.append(i)
print('偶数为',t2)
print('奇数为',t3)
sum1 = 0
sum2 = 0
ave1=0
ave2=0
t = 0
for j in t2:
    sum1 = sum1 + j
    t = t+1
    ave1 = sum1/t
print('ave1=%.6f'%ave1)
for m in t3:
    sum2 = sum2 + m
    t = t+1
    ave2 = sum2/t
print('ave2=%.6f'%ave2)
import statistics as s
totfc = s.variance(t2)
print('totfc=%.6f'%totfc)
# 偶数为 [32, 36, 28, 16, 14, 20, 18, 30, 38, 22, 24, 10]
# 奇数为 [23, 25, 29, 37, 33, 11, 39, 31]
# ave1=24.000000
# ave2=11.400000
# totfc=79.272727

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

# split():将空格分隔的字符串切片后转为字符串列表
l1=input('请输入空格分隔的数字内容:').split()
for i in range(len(l1)):
    l1[i]=int(l1[i])
print(l1)
l2=[]
for i in l1:
    if l2.count(i)==0:  # 统计接受到的列表，若为0则表示追加
        l2.append(i)
print(l2)
# 请输入空格分隔的数字内容:2 2 2 3 4 5 4 22 2
# [2, 2, 2, 3, 4, 5, 4, 22, 2]
# [2, 3, 4, 5, 22]

35.合并2个有序列表构成一个新的有序列表

l1 = list(eval(input('请输入第一个列表：')))
l2 = list(eval(input('请输入第二个列表：')))
l1.extend(l2)  # extend 尾部追加一个完整列表
l1.sort()
print(l1)
# 请输入第一个列表：1,2,4,84,6,8
# 请输入第二个列表：4,3,8,9,0,
# [0, 1, 2, 3, 4, 4, 6, 8, 8, 9, 84]

36.编写程序实现判断列表是否为升序

l1=list(eval(input('请输入第一个列表：')))
f=1  # 标志位，默认为升序
for i in range(len(l1)-1):
    if l1[i]>l1[i+1]:
        f=0
        break
if f:
    print('升序')
else:
    print('无序')
# 请输入第一个列表：1,2,4,5,7,32,8
# 无序

37.输入一个十进制转为二进制输出

# 法1
a = int(input('请输入一个十进制整数：'))
print('转为二进制为：',bin(a))
# 法2
m = int(input('请输入一个十进制整数：'))
l1=[]
if m==0:
    print('0000')
else:
    while m:
        m,r=divmod(m,2)  # divmod 计算m对2取余得到的商和余数
        l1.append(r)
    l1.reverse()
    print(l1)
# 请输入一个十进制整数：12
# 转为二进制为： 0b1100
# 请输入一个十进制整数：12
# [1, 1, 0, 0]

38.二维列表，listname=[一维列表1],[一维列表2],[一维列表3],[一维列表n]

# 法1：直接创建
l1=[[1,2,3],
    [4,5,6],
    [7,8,9]]
print(l1)
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 法2：使用for循环创建
l1=[]
for i in range(3):
    l1.append([])  # 每行添加一个空列表
    for j in range(4):
        l1[i].append(j)  # 为内层列表添加元素值
print(l1)
# [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
# 法3：使用列表推导式创建
l1=[[j for j in range(5)] for i in range(5)]
print(l1)
# [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

39.二维列表的随机数赋值

import random as a
l1=[]
for i in range(4):
    l1.append([])  # 每行添加一个空列表
    for j in range(5):
        t=a.randint(10,30)
        l1[i].append(j)  # 为内层列表添加元素值
for i in range(4):
    print(l1[i])
# [0, 1, 2, 3, 4]
# [0, 1, 2, 3, 4]
# [0, 1, 2, 3, 4]
# [0, 1, 2, 3, 4]

40.计算二维列表每行最大值和每列最小值

import random as a
 
l1 = []
max1 = []
min1 = []
 
for i in range(5):  # 二维列表随机赋值（行向遍历）
    l1.append([])
    for j in range(6):
        t = a.randint(10, 30)
        l1[i].append(t)
 
for i in range(5):  # 输出
    print(l1[i])
 
for i in range(5):  # 计算每行最大值，追加到max1中
    max1.append(max(l1[i]))
 
for j in range(6):  # 计算每列最大值，列项访问，内循环调换位置
    min1.append(l1[0][j])  # 将当前列第一个值追加到最小值数组中
    for i in range(5):
        if min1[j]>l1[i][j]:
            min1[j]=l1[i][j]
print('每列最小值：',min1)
print('每行最大值：',max1)
# [12, 15, 29, 21, 21, 12]
# [21, 13, 12, 28, 17, 14]
# [13, 14, 17, 28, 27, 13]
# [12, 16, 25, 27, 30, 13]
# [10, 19, 14, 15, 22, 23]
# 每列最小值： [10, 13, 12, 15, 17, 12]
# 每行最大值： [29, 28, 28, 30, 23]