4.18 列表学习日记及答案

认识列表

1.容器型数据类型(序列)

变量从是否是容器分为：非容器型数据类型的变量和容器型数据类型的变量;

非容器型数据类型的变量 - 一个盒子里面只有一个格子，所以同一时间只能保存一个数据。eg:int,float,bool,None

容器型数据类型的变量 - 一个盒子里面有多个格子，每个格子可以存储不一样的数据，所以同一时间就可以保存多个数据。

eg: list、dict、tuple、set、str等

scores = [89, 30, 20, 39, 73, 45, 3]
print(sum(scores))
print(sum(scores) / len(scores))

ave = sum(scores) // len(scores)
print(ave)

print(len(scores))
print(max(scores),min(scores))

2) 什么是列表(list)

1)列表是容器型数据类型(可以同时保存多个数据);

2)将[]作为容器标志，里面多个元素用逗号隔开:[元素1, 元素1, 元素3, …]

3)列表是可变的(指的是元素的个数、值和顺序可变 - 支持增删改查);

列表是有序的(支持下标操作)

4)列表中元素:任何类型的数据都可以作为列表中的元素

元素 - 指的是容器中每一个独立的数据

空列表

list1 = []
print(list1)

list2是一个列表，列表只有一个元素

list2 = [19]

list3 = [11, 22, 33]

相同类型元素的类型

list5 = [29, 49, 56, 67]
print(list5)

同一个列表中元素可以是不同类型的数据

list4 = [11, 'abc', 3.14, [22, 33], True]
print(list4)

# 3.列表是有序

print([10, 20, 30] == [10, 30, 20]) # False

# 集合无序
print({10, 20, 30} == {10, 30, 20}) # True

获取元素

1.获取单个元素

语法：列表[下标] - 获取指定下标的元素

说明:

1)列表 - 任何结果是列表的表达式,例如:保存列表的变量或者具体的列表数据

2)[] - 固定写法

3)下标 - 整数，下标(index)是有序序列中元素的位置信息。

Python中有序序列中元素的下标有两种:

第1种:从前往后从0开始依次增加

第2种:从后往前从-1开始依次减少

注意：下标不能越界

games = ['英雄联盟', '王者荣耀', '开心消消乐', '炉石传说', '部落冲突', '原神','绝地求生']
print(games[1])
print(games[-6])
print(['英雄联盟', '王者荣耀', '开心消消乐', '炉石传说', '部落冲突', '原神','绝地求生'][1])
# print(games[100])   IndexError: list index out of range

list1 = [10, 20, 30]
print(list1[2])
print(list1[-2])

2.切片 - 获取部分元素

1)完整语法：

列表[开始下标:结束下标:步长 ]

2)切片过程:

第一步:确定结果是否为空:从开始下标到结束下标的方向如果和步长对应的方向(步长为正表示从前往后，步长为负表示从后往前)一致就可以获取数据，否则无法获取数据

第二步:确定有效范围:开始下标对应元素可以取到，结束下标对应元素取不到 -> [开始下标, 结束下标)

第三步:获取元素:步长的正负确定获取方向;步长绝对值确定获取时是否跳着取(在有效范围内按照步长绝对值取数据；绝对值为1就一个一个取，绝对值为2就跳一个取一个)

3)写切片表达式获取指定的结果

第一步:确定开始下标:看结果中第一个在原列表的下标

第二步:确定步长:看获取元素方向来确定正负;看取值的时候跳过情况确定绝对值

第三步:确定结束下标:[开始下标, 结束下标)对应的范围能够包含所有情况

heroes = ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉', '瑶', '孙膑']
games = ['诛仙', '英雄联盟', '王者荣耀', '开心消消乐', '炉石传说', '部落冲突', '原神','绝地求生']

print(games[1:-1: 3])
print(games[2:6:-2])
print(games[0:5:4])
print(games[6:-4:-1])

print(games[1:5:1])   # ['英雄联盟', '王者荣耀', '开心消消乐', '炉石传说']
print(games[-3:1:-3]) # ['部落冲突', '王者荣耀']
print(games[2:-1:2])  # ['王者荣耀', '炉石传说', '原神']
print(games[-1:0:-3]) # ['绝地求生', '炉石传说', '英雄联盟']

# 开始下标到结束下标方向如果和步长对应方向一直，就可以取到数据
print(heroes[0:2:1])     # ['李白', '李信']
print(heroes[0:-1:1])    # ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉', '瑶']
print(heroes[-1:2:-1])   # ['孙膑', '瑶', '安琪拉', '刘备', '关羽']

# 开始下标到结束下标的方向如果和步长对应方向不一致，一定取不到数据
print(heroes[1:4:-1])   # []
print(heroes[5:1:2])    # []

print(heroes[1:5:1])    # ['李信', '张飞', '关羽', '刘备']
print(heroes[5:1:-1])   # ['安琪拉', '刘备', '关羽', '张飞']

2)切片省略写法

列表[开始下标:结束下标:步长 ]

1.省略步长: 列表[开始下标:结束下标] -> 列表[开始下标:结束下标:1]

省略步长的时候，步长为1

2.省略开始下标: 列表[:结束下标:步长]、列表[:结束下标]

如果步长为正，从第一个元素开始往后取；如果步长为负，从最后一个开始往前取

3.省略结束下标: 列表[开始下标::步长]、列表[开始下标:]

如果步长为正，从开始下标开始往后取，一直取到最后一个元素；如果步长为负，从开始下标开始往前取，取到第一个元素为止

movies = ['肖申克的救赎', '双城之战', '你的名字', '海上钢琴师', '风雨哈佛路', '当幸福来敲门', '乡村老尸', '咒怨']

#  省略步长
print(movies[2:5])    # ['你的名字', '海上钢琴师', '风雨哈佛路']
print(movies[1:-2])   # ['双城之战', '你的名字', '海上钢琴师', '风雨哈佛路', '当幸福来敲门']
print(movies[-2:2])   # ['乡村老尸', '当幸福来敲门', '风雨哈佛路', '海上钢琴师', '你的名字']

# 省略开始下标
print(movies[:3])     # ['肖申克的救赎', '双城之战', '你的名字']
print(movies[:3:-1])  # ['咒怨', '乡村老尸', '当幸福来敲门', '风雨哈佛路']
print(movies[:-2:-2]) # ['咒怨']

# 省略结束下标
print(movies[2:])     # ['你的名字', '海上钢琴师', '风雨哈佛路', '当幸福来敲门', '乡村老尸', '咒怨']
print(movies[3::2])   # ['海上钢琴师', '当幸福来敲门', '咒怨']
print(movies[3::-2])  # ['海上钢琴师', '双城之战']

练习 [‘肖申克的救赎’, ‘双城之战’, ‘你的名字’, ‘海上钢琴师’, ‘风雨哈佛路’, ‘当幸福来敲门’, ‘乡村老尸’, ‘咒怨’]

print(movies[-2::-3])  # ['乡村老尸', '海上钢琴师', '肖申克的救赎']
print(movies[3:6])     # ['海上钢琴师', '风雨哈佛路', '当幸福来敲门']
print(movies[:-3])     # ['肖申克的救赎', '双城之战', '你的名字', '海上钢琴师', '风雨哈佛路']
print(movies[:4:2])    # ['肖申克的救赎', '你的名字']
print(movies[-4::2])   # ['风雨哈佛路', '乡村老尸']
print(movies[1::4])    # ['双城之战', '当幸福来敲门']
print(movies[::3])     # ['肖申克的救赎', '海上钢琴师', '乡村老尸']

print('================================================')

3.遍历 - 将列表中的元素一个一个的全部取出来

"""
方法1:
for 变量 in 列表:
    循环体
    
方法2 - 通过遍历下标来遍历元素
for 变量 in range(len(列表)):
    循环体(变量取到的是每个元素的下标，列表[下标]就可以获取到元素)
    
方法3 - 同时获取下标和元素
for 变量1,变量2 in enumerate(列表):
    循环体(变量1依次获取到每个元素的下标，变量2依次获取到每个元素)
"""

for i in games:
    print(i)

print('================================================')
nums = [28, 39, 49, 45, 20, 40]
# 练习1:求nums中所有元素和
s = 0
for x in nums:
    s += x
print(s)

print('================================================')
# 练习2: 统计nums中奇数的个数
count = 0
for x in nums:
    if x % 2:
        count += 1
print(count)

print('================================================')
for x in range(len(games)):
    print(x, games[x])

print('================================================')
for x in range(len(movies)-1, -1, -1):
    print(x, movies[x])

print('================================================')
for x, y in enumerate(games):
    print(x, y)

增删改

1.增

nums = [10, 20]
print(nums)

nums.append(100)
print(nums)

nums.append(200)
nums.append([100, 200])
print(nums)

nums.insert(1, 1000)
print(nums)

2.删除

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

列表.remove(元素) - 删除指定元素(只删除重复元素中第一个；如果列表中没有元素会报错)

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

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

del nums[2]
print(nums)

x = nums.remove(100)
print(x)
print(nums)

x = nums.pop()
print(x, 's')
print(nums)

nums.pop(2)
print(nums)

3.改

列表[下标] = 新值 - 将列表指定下标对应元素修改成指定值

games = ['诛仙', '英雄联盟', '王者荣耀', '开心消消乐', '炉石传说', '部落冲突', '原神','绝地求生']
games[1] = '红色警戒'
print(games)

4.in和not in

元素 in 列表 - 判断列表中是否存在指定元素:存在就返回True;否则返回False

print('英雄联盟' in games)
print('红色警戒' in games)

作业

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

list1 = [1, 2, 3, 4, 5]

print(list1[len(list1) // 2])

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

list2 = [11, 22, 33, 44, 55]

print(sum(list2))

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

for i in range(len(list3)):
    if list3[i] % 2:
        print(i, end=', ')
print()

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

list4 = [12, 23, 34, 45, 56, 67, 78, 89]

for i in list4:
    if i % 2:
        print(i, end=', ')
print()

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

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

list5 = [1, 2, 3, 4, 5]
for i in range(len(list5)):
    list5[i] *=2
print(list5)

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

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

方法一:

names = ['张三', '李四', '大黄', '大黄', '张三', '张三', '张三']
names1 = []
for i in names:
    if i not in names1:
        names1.append(i)
names = names1
print(names)

方法二:

names = ['张三', '李四', '大黄', '大黄', '张三', '张三', '张三']
for _ in range(len(names)):
    last_name = names.pop()
    if last_name not in names:
        names.insert(0,last_name)
print(names)

names = [‘张三’, ‘李四’, ‘大黄’, ‘大黄’, ‘张三’, ‘张三’, ‘张三’, ‘李四’, ‘大黄’, ‘大黄’]

names = list(set(names))

print(names)

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

list7 = [1, 2, 3, 4, 5, 6]
if max(list7) == min(list7):
    count = 1
else:
    count = 2
print((sum(list7) - max(list7) - min(list7)) / (len(list7) - count))

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

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

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []

for i in A:
    for j in B:
        if i == j:
            C.append(j)
print(C)

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

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

nums = [19, 89, 90, 600, 1]
max_nums = nums[0]

for i in range(len(nums)):
    if nums[i] > max_nums:
        max_nums = nums[i]
else:
    print(max_nums)

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

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

nums = [3, 1, 3, 1, 4, 2, 1, 3, 7, 3, 3]
max_nums_count = nums.count(nums[0])        # 出现次数最大元素的出现次数
count_nums = 0                              # 第一个出现次数最大元素的下标 初始下标为0
for i in range(len(nums)):
    if max_nums_count < nums.count(nums[i]):
        max_nums_count = nums.count(nums[i])
        count_nums += 1
print(nums[count_nums])