day6 列表以及今日作业

3.1 列表

3.1.1 列表的作用

1.定义变量保存一个学生的成绩

score = 100

2.定义变量保存一个班所有学生的成绩

score1 = 56
score2 = 67
score3 = 90
score4 = 89
score5 = 34
score6 = 81
score7 = 91
score8 = 99
score9 = 85
score10 = 77

print('所有学生平均分：', (score1 + score2 + score3 + score4 + score5 + score6 + score7 + score8 + score9 + score10) / 10)

max_score = score1
if score2 > max_score:
    max_score = score2

if score3 > max_score:
    max_score = score3

if score4 > max_score:
    max_score = score4

if score5 > max_score:
    max_score = score5

if score6 > max_score:
    max_score = score6

if score7 > max_score:
    max_score = score7

if score8 > max_score:
    max_score = score8

if score9 > max_score:
    max_score = score9

if score10 > max_score:
    max_score = score10

print(max_score)


scores = [89, 56, 45, 77, 99, 82, 77, 67, 90, 91]
print('平均分:', sum(scores) / len(scores))
print(max(scores))

# 列表在需要同时处理多个数据的时候非常有用

3.1.2 列表(list)

1)列表是容器型数据类型，将[]作为容器的标志，里面多个元素用逗号隔开：[数据1, 数据2, 数据3,…]

2)特点：列表是可变的(可变指的是容器中元素的个数和值可变 - 支持增删改)
列表是有序的(支持下标操作)

3)元素的要求：没有要求（任何类型的数据都可以作为列表的元素，同一个列表中的元素的类型还可以不一样）

# 空列表
list1 = [ ]
list2 = []
print(list1, list2)                 # [] []
print(len(list1), len(list2))       # 0 0

# 列表中的元素可以是任何类型的数据
list3 = [10, 1.23, False, None, 'abc', [10, 20]]
print(list3)

# 列表是有序的(顺序影响结果)
print([10, 20, 30] == [10, 30, 20])         # False
print({10, 20, 30} == {10, 30, 20})         # True (集合无序)

3.1.3 查操作

1. 查单个元素 - 一次获取一个元素
   语法：
   列表[下标] - 获取指定列表中指定下标对应的元素

说明：
1）列表 - 需要获取元素的列表(可以是任何结果是列表的表达式，比如：保存列表的变量、具体的列表数据等)
2）[] - 固定写法
3）下标 - 下标又叫索引，是元素在列表中的位置信息。
列表中的每个元素都有两个索引值，一个是从往后从0(第1个)开始不断增加，另一个是从后往前从-1(倒数第1个)开始不断减小

注意：下标不能越界

print(nums[1], nums[-4])
print(nums[-1])
# print(nums[5])            #  IndexError: list index out of range
# print(nums[-6])           # IndexError: list index out of range

2. 切片 - 一次获取多个元素(一次有规律的获取多个元素)
   1)完整的语法
   语法：
   列表[开始下标:结束下标:步长] - 根据下标和步长获取指定列表中的部分元素

a、怎么确定切片结果
第一步：确定结果是否为空列表（看从开始下标到结束下标的方向和步长对应的方式是否一致，如果方向一致结果一定不为空，反之结果肯定是空）
步长为正：表示从前往后取
步长为负：表示从后往前取
第二步：确定有效范围 - 从开始到结束，开始下标对应的元素取得到，结束下标对应的元素取不到
第三步：在有效范围内，按照步长的绝对值确定获取内容。
如果绝对值为1，在有效范围内容一个一个按顺序获取
如果绝对值是2，在有效范围内容内取1个跳1个再取1个
如果绝对值是3，在有效范围内容内取1个跳2个再取1个
…

b、怎么写切片
第一步：确定开始下标(目标对应的第一个元素对应的下标)
第二步：确定步长
确定正负号：看目标元素在原列表中的顺序是从前往后(+)还是从后往前(-)
确定绝对值：
第三步：确定结束下标: 保证需要获取的数据全部在有效范围内

heroes = ['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']

print(heroes[1: 4: 1]) #['孙斌', '李白', '百里守约']
print(heroes[-1: 4: 1]) #[]
print(heroes[2: 6: 2]) #['李白', '墨子']
print(heroes[0:5:-2]) #[]

print(heroes[-1:1:2]) #[]
print(heroes[2:7:-2]) #[]
print(heroes[8:1:3]) #[]
print(heroes[6:0:-2]) #['孙悟空', '墨子', '李白']
print(heroes[-1:1:-1]) #['妲己', '李信', '诸葛亮', '孙悟空', '澜', '墨子', '百里守约', '李白']
print(heroes[0:7:3]) #['王昭君', '百里守约', '孙悟空']

heroes = ['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']

# ['王昭君', '孙斌', '李白']
print(heroes[0:3:1])

# ['百里守约', '墨子', '澜', '孙悟空']
print(heroes[3:-3:1])

# ['诸葛亮',  '孙悟空', '澜']
print(heroes[-3:4:-1])

# ['孙斌', '墨子', '诸葛亮']
print(heroes[1:-2:3])

# ['妲己', '澜', '孙斌']
print(heroes[-1:0:-4])

# ['孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信']
print(heroes[1:-1:1])

2）切片的省略写法

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

a.省略步长 - 相当于步长为1
列表[开始下标:结束下标]

b.省略开始下标 - 表示从头开始(看步长的正负，开始下标在第一个或者在最后一个)
列表[:结束下标:步长] 、 列表[:结束下标]

c.省略结束下标 - 如果步长为正就从开始下标开始一直取到最后一个元素；如果步长为负就从开始下标开始一直取到第一个元素
列表[开始下标::步长]

heroes = ['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']
print(heroes[1:4])  # ['孙斌', '李白', '百里守约']
print(heroes[-1:3])  # []

print(heroes[:4:2]) #['王昭君', '李白']
print(heroes[:4:-2]) #['妲己', '诸葛亮', '澜']
print(heroes[:-4]) #['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜']

print(heroes[1::2]) #['孙斌', '百里守约', '澜', '诸葛亮', '妲己']
print(heroes[-3::-1]) #['诸葛亮', '孙悟空', '澜', '墨子', '百里守约', '李白', '孙斌', '王昭君']
print(heroes[3:]) #['百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']

print(heroes[::-3]) #['妲己', '孙悟空', '百里守约', '王昭君']
print(heroes[:]) #['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']

3. 遍历 - 一个一个的获取列表中所有的元素
   补充：len(列表) - 获取列表中元素的个数
   方法1：
   for 变量 in 列表:
   循环体中的变量直接是列表的元素

方法2：通过下标来遍历列表
for 变量 in range(len(列表)):
循环体重变量获取到的是每个元素的下标，然后需要通过:列表[下标]再获取元素

方法3：同时获取下标和元素
for 变量1, 变量2 in enumerate(列表):
循环体中变量1是每个元素的下标，变量2是每个元素

games = ['王者荣耀', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']

for x in games:
    print(x)

# print(len(games))
for index in range(len(games)):
    print(index, games[index])

for index, item in enumerate(games):
    print(index, item)
#0 王者荣耀
#1 lol
#2 和平精英
#3 永劫无间
#4 apex
#5 2k
#6 植物大战僵尸
#7 开心消消乐

4.练习题

# 练习1：计算nums中所有元素的和
nums = [12, 45, 8.34, 56, 23]
sum1 = 0
for x in nums:
    sum1 += x
print(sum1) #144.34

# 练习2：统计nums中所有偶数的个数
nums = [23, 88, 90, 88, 67, 55, 11]
count = 0
for x in nums:
    if x % 2 == 0:
        count += 1
print(count) #3

# 练习3： 统计list1中字符串的个数
list1 = [109, 23.4, True, 'abc', 'helo', 23, '12', False, None]
count = 0
for x in list1:
    if type(x) == str:
        count += 1
print(count) #3

3.1.4 增删改操作

1. 增 - 添加元素
   1)列表.append(元素) - 在列表的最后添加指定元素

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

nums.append(100)
print(nums)         # [10, 20, 30, 100]

nums.append(200)
print(nums)         # [10, 20, 30, 100, 200]

2)列表.insert(下标,数据) - 在列表指定下标对应元素前插入指定数据

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

nums.insert(-1, 100)
print(nums)     # [10, 20, 100, 30]

nums.insert(0, 200)
print(nums)     # [200, 10, 20, 100, 30]

# 练习：使用一个新的列表提取nums中所有的偶数
nums = [17, 89, 90, 81, 84, 4, 56]
even_nums = []
for x in nums:
    if x % 2 == 0:
        even_nums.append(x)
print(even_nums)

2. 删 - 删除元素

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

games = ['王者荣耀', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
print(games)

del games[2]
print(games) #['王者荣耀', 'lol', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']

2）列表.remove(元素) - 删除列表中指定元素(如果元素不存在会报错；如果元素有多个，只会删除最前面的那一个)

games = ['王者荣耀', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
print(games)

games.remove('和平精英')
print(games)

# games.remove('部落冲突')      # ValueError: list.remove(x): x not in list
games.remove('开心消消乐')
print(games)

3）
列表.pop() - 取出列表最后一个元素，并且返回
列表.pop(下标) - 取出列表指定下标对应的元素，并且返回

games = ['王者荣耀', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
x = games.pop()
print(games, x) #['王者荣耀', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸'] 开心消消乐

x = games.pop(2)
print(games, x) #['王者荣耀', '开心消消乐', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸'] lol

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

games = ['王者荣耀', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
print(games)

games[0] = '部落冲突'
print(games)

games[-1] = '炉石传说'
print(games)

# 案例：将scores中所有不及格的分数全部修改成"重修"
scores = [89, 23, 79, 99, 45, 60, 78, 59]
# [89, '重修', 79, 99, '重修', 60, 78, '重修']
for index, item in enumerate(scores):
    if item < 60:
        scores[index] = '重修'
print(scores)

今日作业

1. 基础题

1. 已知一个数字列表，打印列表中所有的奇数

   list1 = [10, 20, 5, 34, 90, 8]
   list2=[]
   for i in list1:
       if i % 2 == 1:
           list2.append(i)
   print(list2)
   

2. 已知一个数字列表，打印列表中所有能被能被3整除但是不能被2整除的数

   list3=[]
   for i in list1:
       if i % 3 == 0 and i % 2 != 0:
           list3.append(i)
   print(list3)
   

3. 已知一个数字列表，计算所有偶数的和

   sum1 = 0
   for i in list1:
       sum1 += i
   print(sum1)
   

4. 已知一个数字列表，统计列表中十位数是1的数的个数

   count = 0
   for i in list1:
       if i // 10 % 10 == 1:
           count += 1
   print(count)
   

5. 已知一个列表，获取列表中下标为奇数是所有元素(从0开始的下标值)

   例如: list1 = [10, 20, 5, 34, 90, 8]

   结果：[20, 34, 8]

   print(list1[1:-1:2])
   

6. 已知一个数字列表，将列表中所有元素乘以2

   例如： nums = [10, 3, 6, 12] 乘2后: nums = [20, 6, 12, 24]

   nums = [10, 3, 6, 12]
   num1 = []
   for i in nums:
       i *= 2
       num1.append(i)
   print(num1)
   

7. 已知一个列表，获取列表的中心元素

   例如：nums = [10, 2, 6, 12] -> 中心元素为: 2和6

   ​ nums = [10, 2, 6, 12, 10] -> 中心元素为：6

   nums = [10, 2, 6, 12]
   for i in range(len(nums)):
       pass
   if (i + 1) % 2 == 0:
       print(nums[(i + 1) // 2 - 1],nums[(i + 1) // 2])
   else:
       print(nums[(i + 1) // 2])
   

8. 已知一个列表，获取列表中所有的整型元素

   例如：list1 = [10, 1.23, ‘abc’, True, 100, ‘hello’, ‘20’, 5]

   ​ 结果是: [10, 100, 5]

   list1 = [10, 1.23, 'abc', True, 100, 'hello', '20', 5]
   list2=[]
   for i in list1:
       if type(i) == int:
           list2.append(i)
   print(list2)
   

2. 进阶题

1. 定义一个列表保存多个学生的分数，删除列表中所以低于60分的值

   例如： scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66] 删除后: scores = [60, 89, 99, 80, 71, 66]

   scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   del scores[0]
   del scores[2:5]
   print(scores)
   

2. 已知一个列表保存了多个学生的姓名，要求去掉列表中重复的名字

   例如：names = [‘小明’, ‘张三’, ‘李四’, ‘张三’, ‘张三’, ‘小明’, ‘王五’, ‘王五’]

   ​ 去重后：names = [‘小明’, ‘张三’, ‘李四’, ‘王五’]

   names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
   name1 = []
   for i in names:
       if i not in name1:
           name1.append(i)
   print(name1)
   

3. 已知一个数字列表，获取列表中值最大的元素 （不能使用max函数）

   scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   for i in range(1,len(scores)):
       for j in range(0,len(scores)-i):
           if scores[j] > scores[j+1]:
               scores[j],scores[j+1]=scores[j+1],scores[j]
   print(scores[-1])
   

4. 已知两个有序列表(列表中的元素已经按照从小到大的方式排好序)，要求合并两个列表，合并后元素还是从小到大排序

   例如: list1 = [10, 23, 39, 41, 52, 55, 80] list2 = [9, 38, 55, 70]

   合并后的结果: [9, 10, 23, 38, 39, 41, 52, 55, 55, 70, 80]

   # 方法一：
   list1 = [10, 23, 39, 41, 52, 55, 80]
   list2 = [9, 38, 55, 70]
   list3 = list1 + list2
   list3.sort()
   print(list3)
   
   # 方法二：
   list1 = [10, 23, 39, 41, 52, 55, 80]
   list2 = [9, 38, 55, 70]
   list3 = list1 + list2
   for i in range(1,len(list3)):
       for j in range(0,len(list3)-i):
           if list3[j] > list3[j+1]:
               list3[j],list3[j+1]=list3[j+1],list3[j]
   print(list3)
   

5. 已知一个有序数字列表(从小到大)，输入任意一个数字，将输入的数字插入列表中，要求插入后列表仍然保持从小到大排序的关系

   例如： list1 = [10, 23, 45, 67, 91] 输入: 50 -> list1 = [10, 23, 45, 50, 67, 91]

   list1 = [10, 23, 45, 67, 91]
   a = float(input('请输入一个任意的数字：'))
   list1.insert(0,a)
   for i in range(1,len(list1)):
       for j in range(0,len(list1)-i):
           if list1[j] > list1[j+1]:
               list1[j],list1[j+1]=list1[j+1],list1[j]
   print(list1)