Python list(3.8)

Python 之 List（3.8）

1.什么是列表

列表是容器型数据类型：将[]作为容器标志，里面多个数据用逗号隔开：[元素1，元素2，…]
列表可变（元素的个数可变，元素的值可变，元素的顺序可变），
列表有序（每个元素都有一个表示其位置信息的序号）
元素(容器中的每个独立的数据)：没有要求（任何类型的数据都可以作为列表的元素）

student=['钟XX','程X','陶X','张XX','刘X']
print(student)

student2=[] #空列表
print(student2,bool(student2))

#元素的种类，个数都没有要求
list1=[12,True,'abc',[1,2]]

2. 查 - 获取元素

2.1 查单个 - 获取列表中某一个元素

->语法：
列表[下标] - 获取列表中指定下标对应的元素
->说明：
列表 - 任何结果是列表的表达式，例如：具体的列表值，保存列表的变量
[] - 固定写法
下标 - 索引，用来描述元素在列表中的位置信息
取值方式1，从0开始，到n-1
取值方式2，从-1开始减少，其中-1表示最后一个元素（倒数第一个）

names=['赵云','貂蝉','诸葛亮','曹操','大乔','关羽','张飞','吕布','小乔']
print(names[1])
print(names[-1])
print(names[-2])
print(names)
# print(names[9]) # 报错超出范围
# print(names[-10]) # 报错潮超出范围

# 打印列表中指定下标对应的元素
num=[1,2,3]
print(num[2])
print(num[-1])
print([1,2,3][2])

2.2 切片（查部分）- 同时获取列表中的多个元素

原理：通过提供下标的范围来获取范围内对应的元素
语法：
列表[开始下标:结束下标:步长] - 从开始下标开始，下标每次增步长值
注意：
1）结束下标对应的元素一定娶不到，开始下标对应的元素可以取到
2）步长为正，从前往后取，开始下标对应位置必须在结束采编对应的位置前，否则结果为[]
3) 步长为负，从后往前取，开始下标对应位置必须在结束采编对应的位置前，否则结果为[]

names=['赵云','貂蝉','诸葛亮','曹操','大乔','关羽','张飞','吕布','小乔']
print(names[1:4:1]) #['貂蝉', '诸葛亮', '曹操']
print(names[1:-1:1]) #['貂蝉', '诸葛亮', '曹操', '大乔', '关羽', '张飞', '吕布'] 注意最后一个取不到
print(names[0:5:2])# ['赵云', '诸葛亮', '大乔']
print(names[1:5:-1]) #[]
print(names[5:0:2]) #[]

names1=['林俊杰','周杰伦','王力宏','陈奕迅','薛之谦','邓紫棋']
print(names1[1:4:2]) #['周杰伦', '陈奕迅']
print(names1[-5:4:2]) #['周杰伦', '陈奕迅']
print(names1[-1:1:-3]) #['邓紫棋', '王力宏']

1)省略步长： - 相当于步长是1

列表[开始下标：结束下标]

print(names1[1:-1]) #['周杰伦', '王力宏', '陈奕迅', '薛之谦']
print(names1[-5:3]) #['周杰伦', '王力宏']
print(names1[4:-6]) #[]

2)省略开始下标

列表[:结束下标：步长] - 步长为正，从第一个开始往后取；

步长为负，从最后一个元素开始往前取

列表[:结束下标] - 从第一个开始往后取

heros=['后裔','李元芳','诸葛亮','娜可露露','甄姬','王昭君','孙膑']
print(heros[:4:2]) #['后裔', '诸葛亮']
print(heros[:2:-1]) #注意是从最后一个开始 ：['孙膑', '王昭君', '甄姬', '娜可露露']
print(heros[:-1]) # ['后裔', '李元芳', '诸葛亮', '娜可露露', '甄姬', '王昭君']

3)结束下标省略

列表[开始下标：：步长] - 步长为正，从开始下标开始，往后取完；

步长为负，从开始下标开始往前取完

列表[开始下标：] - 开始位置取完

print(heros[1:]) #['李元芳', '诸葛亮', '娜可露露', '甄姬', '王昭君', '孙膑']
print(heros[2::-1]) # ['诸葛亮', '李元芳', '后裔']
print(heros[-1::-2]) #['孙膑', '甄姬', '诸葛亮', '后裔']

4)一起省

列表[::步长] -看步长，取值范围是整个列表

列表[:] -从前往后取完

print(heros[::-1]) #['孙膑', '王昭君', '甄姬', '娜可露露', '诸葛亮', '李元芳', '后裔']
print(heros[::2]) #['后裔', '诸葛亮', '甄姬', '孙膑']
print(heros[:]) #['后裔', '李元芳', '诸葛亮', '娜可露露', '甄姬', '王昭君', '孙膑']

2.3 遍历

方法一：
for i in 列表：
循环体
变量取到的是列表中的每个元素

games=['王者荣耀','和平精英','狼人杀','植物大战僵尸','开心消消乐']

for x in games:
    print(x)

练习：判断不及格的人数，机算及格率

scores=[90,89,67,54,32,99,67,100]
# 方法一：直接获取元素
count=0
for i in scores:
    if i<60:
        count+=1
print('不及格的人数为：{}'.format(count))

方法二：先获取每个元素对应的下标，在通过下表获取元素
用len() 返回列表元素个数

count1=0
for i in range(len(scores)):
    if scores[i]<60:
        count1+=1
print('不及格的人数为：{}'.format(count))

练习：打印给定列表中，所有3的倍数对应的元素

nums = [23, 9, 34, 5, 15, 6]
for i in range(len(nums)):
    if nums[i]%3==0:
        print(nums[i])

增删改查

1)增

1.1 列表.append(元素) - 在列表的最后添加指定的元素,放到最后

subjects=['iOS','安卓']
print(subjects)
subjects.append('h5')
print(subjects)

subjects.append(100)
print(subjects)

subjects.append([10,20])
print(subjects)  #['iOS', '安卓', 'h5', 100, [10, 20]]
print(subjects[-1][-1]) #20

1.2列表.insert(下标，元素) - 在列表的指定下标前插入元素

tvs=['甄嬛传','还珠格格','情深深雨蒙蒙','琅琊榜']
tvs.insert(1,'庆余年')
print(tvs)
tvs.insert(0,'西游记')
print(tvs)

练习：已知分数列表（已排好序），输入的成绩插入其中，不影响排序

scores = [100, 98, 97, 97, 89, 86, 72, 66, 63, 59, 42]
num=int(input('输入分数：'))
for i in range(len(scores)):
    if num>=scores[i]:
        scores.insert(i,num)
        break
else:
    scores.append(num)
print(scores)

2.删

2.1 del 列表[下标] - 删除列表中指定元素下标对应的元素

tvs=['西游记', '甄嬛传', '庆余年', '还珠格格', '情深深雨蒙蒙', '琅琊榜']
del tvs[-2]
print(tvs)

2.2 列表.remove() - 删除列表中指定的元素,如果有多个只删除第一个,

如果没有该元素，会报错

tvs=['西游记', '甄嬛传', '庆余年', '还珠格格', '情深深雨蒙蒙', '琅琊榜']
tvs.remove('情深深雨蒙蒙')
print(tvs) #['西游记', '甄嬛传', '庆余年', '还珠格格', '琅琊榜']
tvs=['西游记', '甄嬛传', '庆余年', '还珠格格','庆余年', '情深深雨蒙蒙', '琅琊榜']
tvs.remove('庆余年')
print(tvs) #['西游记', '甄嬛传', '还珠格格', '庆余年', '情深深雨蒙蒙', '琅琊榜']

2.3 列表.pop() - 取出最后一个元素

列表.pop(下标) - 取出指定下标对应的元素

tvs=['西游记', '甄嬛传', '庆余年', '还珠格格', '情深深雨蒙蒙', '琅琊榜']
print(tvs.pop())
print(tvs)

3.改

列表[下标]=新元素 修改列表中指定下标对应的元素改为新元素

tvs=['琅琊榜','庆余年','甄嬛传']
tvs[0]='生活大爆炸'
print(tvs)

练习：将分数列表中所有低于60分的分数修改成不及格

scores = [78, 90, 20, 34, 78, 99, 34, 55]
for i in range(len(scores)):
    if scores[i]<60:
        scores[i]='不及格'
print(scores)

其他重要操作

列表的数学运算:+、*

列表1+列表2 - 将两个列表合并，产生新列表

list1=[1,2,3]
list2=['a','b','c']
print(list1+list2)
print(list1,list2)

1.2 列表*N - 将列表中的元素重复N次，产生一个新的列表

print(list2*3)

比较运算：== ，!=,>,<,>=,<=

比较是否相等（长得一模一样）

print([1,2,3]==[1,2,3]) #True
print([1,2,3]==[2,1,3]) #False

比较大小(比较的是第一对儿不相等的元素的大小)

print([100,200]>[10,20,30,40]) #True
print([100,200]>[100,200,300]) #False

3.in 和 not in

元素 in 列表 - 判断元素是否在指定列表中

元素 not in 列表 - 判断元素是否不在指定列表中

nums=[10,20,30]
print(100 in [10,20,30])
print(100 not in [10,20,30])
print(10 in nums)
print([10] in nums)

相关函数：max,min,sorted,sum,list,len

4.1 max():获取列表中最大的元素 ,min()：获取列表中最小的元素

列表中的元素类型需要一致，并且元素本身支持比较元素

nums=[2,43543,534,6,2342,12]
print(max(nums))
print(min(nums))

4.2 sorted(列表) ：将列表中的元素从小到大排序，排序后产生一个新列表,原列表还在

sorted(列表,reverse=True) : 从大到小

new_nums=sorted(nums)
new_nums2=sorted(nums,reverse=True)
print(nums)
print(new_nums)
print(new_nums2)

4.3 sum(列表) - 求列表中所有元素的和（必须是数字列表）

nums=[1,2,3,4,5,6,7,8,9]
print(sum(nums))

4.4 list(序列) - 将序列转换成列表（将序列中所有的元素取出，创建一个新列表）

所有的序列都可以转换成列表

print(list('1232435262'))
print(list('abcdefghijklmnopqrstuvwxyz'))
print(list(range(1,4)))

作业

1.已知一个数字列表，求列表中心元素。

def center():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    # nums_list=list(eval(input('请输入列表：'))) #注意同样可以用eval()函数读入
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    if n%2:
        print('列表中心元素为：{}'.format(nums_list[n // 2]))
    else:
        print('列表中心元素为：{},{}'.format(nums_list[(n - 1) // 2], nums_list[n // 2]))
center()

结果：

2.已知一个数字列表，求所有元素和。

def list_sum():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    print('该列表的所有元素和为：{}'.format(sum(nums_list)))
list_sum()

结果：

3.已知一个数字列表，输出所有奇数下标元素。

def index_odd():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    print(nums_list[1::2])
    # n=len(nums_list)
    # #for 循环，把每个字符转成int值
    # nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    # for i in range(1,n,2):
    #     print(nums_list[i])
index_odd()

结果：

4.已知一个数字列表，输出所有元素中，值为奇数的元素。

def value_odd():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    for i in range(n):
        if nums_list[i]%2:
            print(nums_list[i],end=' ')
    print()
value_odd()

结果：

5.已知一个数字列表，将所有元素乘二。

例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

def value_double():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    nums_list2=[]
    for i in range(n):
        #nums_list2[i]=nums_list[i]*2  # 为什么会报错，超出索引范围:因为num_list2是空列表，所以会超出索引，直接在原数组改就不会报错了
        nums_list2.append(nums_list[i]*2)
    print(nums_list2)
value_double()

结果：

6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = [‘张三’, ‘李四’, ‘大黄’, ‘大黄’, ‘张三’, ‘张三’, ‘张三’] -> names = [‘张三’, ‘李四’, ‘大黄’]

def only_one():
    name_list=list(input('请输入数字列表（用空格隔开）:').split())
    #for 循环，把每个字符转成int值
    name_list2=set(name_list)
    print(list(name_list2))
only_one()

方法二：

def only_one2():
    # name_list=list(input('请输入数字列表（用空格隔开）:').split())
    name_list=list(eval(input('请输入列表：')))
    #定义新列表往里添加
    new_list=[]
    for x in name_list:
        if x not in new_list:
            new_list.append(x)
    print(new_list)
only_one2()

方法三：

def only_one3():
    # name_list=list(input('请输入数字列表（用空格隔开）:').split())
    name_list=list(eval(input('请输入列表：')))
    for _ in range(len(name_list)):
        item=name_list.pop()
        if item not in name_list:
            name_list.insert(0,item)
    print(name_list)
only_one3()

结果：

7.用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

def average():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    # 去掉最高分和最低分
    nums_list.remove(max(nums_list))
    nums_list.remove(min(nums_list))
    print(sum(nums_list)/(n-2))
average()

方法二：

def average2():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值，结果存到列表里
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    # 去掉最高分和最低分
    max1=min1=nums_list[0]
    sum1=count=0
    for x in nums_list:
        sum1+=x
        count+=1
        if max1>x:
            max1=x
        elif x<min1:
            min1=x
    result=(sum1-max1-min1)/(count-2)
    print(result)
average2()

结果：

8.有两个列表A和B，使用列表C来获取两个列表中公共的元素

例如: A = [1, ‘a’, 4, 90] B = [‘a’, 8, ‘j’, 1] --> C = [1, ‘a’]

def common():
    nums_list=list(input('请输入列表（用空格隔开）:').split())
    nums_list2=list(input('请输入列表（用空格隔开）:').split())
    # 转换成集合求并集
    set1=set(nums_list)
    set2=set(nums_list2)
    print(list(set1 & set2))
common()

方法二：

def common2():
    nums_list=list(input('请输入列表（用空格隔开）:').split())
    nums_list2=list(input('请输入列表（用空格隔开）:').split())
    result=[]
    # 转换成集合求并集
    for x in nums_list:
        if x in nums_list2 and x not in result:
            result.append(x)
    print(result)
common2()

结果：

9.*有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

例如: nums = [19, 89, 90, 600, 1] —> 600

def max():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split())
    n=len(nums_list)
    #for 循环，把每个字符转成int值
    nums_list=[int(nums_list[i]) for i in range(len(nums_list))]
    max=0
    for i in range(n):
        if nums_list[i]>max:
            max=nums_list[i]
    print('这个列表中的最大值为：{}'.format(max))
max()

j结果：

10.*获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3

def much():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split(','))
    nums_list2=list(set(nums_list))
    count_list=[]
    n=len(nums_list)
    n2=len(nums_list2)
    for i in range(n2):
        count=0
        #计算每一个对应数字的count
        for j in range(n):
            if nums_list2[i]==nums_list[j]:
                count+=1
        #存储每一个对应数字的count
        count_list.append(count)
    #求出现次数最多元素的下标
    for index in range(n2):
        if count_list[index]==max(count_list):
            print('这个列表中出现频次最高的值为：{}'.format(nums_list2[index]))
            break
much()

def much2():
    nums_list=list(input('请输入数字列表（用空格隔开）:').split(','))
    nums_list2=list(set(nums_list))
    count_list=[]
    for num2 in nums_list2:
        count=0
        #计算每一个对应数字的count
        for num1 in nums_list:
            if num2==num1:
                count+=1
        #存储每一个对应数字的count
        count_list.append(count)
    #求出现次数最多元素的下标
    max_count=max(count_list)
    for index in range(len(count_list)):
        if count_list[index]==max_count:
            print('这个列表中出现频次最高的值为：{}'.format(nums_list2[index]))
            break
much2()

结果：