day6-7列表

列表

使用列表保存变量便于处理多个数据的变动与使用。

1 认识列表

• 列表是容器类数据类型(序列):将[]作为容器的标志，其中多个数据用逗号隔开：
  [数据1, 数据2, 数据3, ……]

• 列表是可变的(列表中元素的个数和元素的值可变)

• 列表是有序的(元素有顺序对应的位置信息；元素的顺序影响结果 — 列表支持索引操作)

• 列表对元素没有要求，任何类型数据都可以作为列表的元素
  元素：容器中每一个独立的数据，就是这个容器的元素

1) 空列表

list1=[]

list2=[   ] # 这个和list1都是空列表，此点和字符串不同

2） 列表是有序的

print([10,20,30] == [30,20,10]) # False
print({1,2} == {2,1}) # True (集合是无序的，顺序不影响结果)

3) 列表元素可以是任何类型的数据

list2 = ['abc', 'jkl', '10', 10, None]
# 同一个列表中可以是多个相同类型的数据，也可以是多个不同类型的数据

# 列表中的元素也可以是列表
list3 = [10, 20, [30, 40]] # 其中有三个元素：10、20、[30, 40]

2. 列表—查

获取列表中元素的值

1）查单个 — 一次获取一个元素

• 语法：
  列表[索引] — 获取列表中指定索引对应元素

• 说明
  列表 — 需要获取元素的列表对象(可以是保存一个列表的变量，也可以是具体的列表)
  [] — 固定写法
  索引 — 又叫下标；指的是元素在列表中的位置。
  列表一旦确定，列表中每个元素对应的索引就确定：
  从0开始(从前到后不断增加1)；或 从-1开始(从后往前不断减少1)

# nums[索引]
nums = [1, 4, 2, 7, 3]
print(nums[-1])
print(nums[0])
# [1, 4, 2, 7, 3][索引]
print([1, 4, 2, 7, 3][0])
print([1, 4, 2, 7, 3][-1])

# 下标不能越界，索引值必须在列表中存在
# print(num[100])  nums中并没有下标为100的元素，最多为4 ，故此处下标越界会报错

2) 切片

切片— 同时获取多个元素(列表切片的结果仍是列表)

• 完整语法：
  列表[开始下标：结束下标：步长]

• .说明：
  列表 — 需要获取元素列表
  [] — 固定写法
  开始下标、结束下标、步长 — 都必须是整数
  开始下标 — 决定从哪里开始取，开头第一个取得到
  结束下标 — 决定取到哪儿结束，最后一个取不到
  步长 — 怎么取(一个一个取或跳着取；为正从前往后取；为负从后往前取)

• 使用切片
  a. 确定切片结果
  第一步：想确定结果是否为空，看开始下标对应的位置到结束下标对应的位置的方向和步长的方向是否一致
  一致则不为空，不一致，结果一定为空
  第二步:如果结果不为空，再确定切片的有效范围，开始下标对应的元素能取到，结束下标对应的元素取不到
  第三步：在有效范围内，按照步长方向与绝对值获取元素
  方向：步长为正，从开始下标到结束下标从前往后取；步长为负，从后往前取
  绝对值：绝对值为1—>一个一个的取
  绝对值为2—>取一个跳一个再取一个再跳一个
  绝对值为3—>取一个，跳两个再取一个，跳两个

  b. 怎么写切片代码获取指定元素
  确定开始下标：需要的数据中第一个数据在列表的下标
  确定结束下标：结束下标是结果数据中最后一个数据在原列表中的后一个或前一个数据
  确定步长：正负看趋势(从前往后取还是从后往前取);再看绝对值(看取的时候是一个一个的取还是跳着取)

# 前两个数决定一个方向以及有效范围，最后一个数的正负决定另一个方向

# print(movies[3:4:1])
# print(movies[3:5:1])
# print(movies[0:-1:2])

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:-1:1])    # ['霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神']
print(movies[-1:1:-2])   # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传']
print(movies[-2:5:2])    # []
print(movies[0:-2:4])    # ['肖生克的救赎','蜘蛛侠']
print(movies[5:-1:2])    # ['蝙蝠侠', '雷神']
print(movies[6:-6:-1])   # ['蚁人','蝙蝠侠','蜘蛛侠']
print('------------------------------------------------------------分割线来啦！-----------------------------------------')
print(movies[0:-2:3])    # ['肖生克的救赎', '钢铁侠', '蚁人']
print(movies[-1:-5:-1])  # ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[3:0:-2])    # ['钢铁侠', '霸王别姬']
print(movies[-2:-7:-2])  # ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[1:-3:4])    # ['霸王别姬', '蝙蝠侠']

• 切片省略的写法

  a.省略步长： — 相当于步长为1，！！注意不是-1，而是从前往后的取1！
  列表[开始下标：结束下标] — 只有省略步长的时候才会省略冒号，另外两种省略都不会省略相应的冒号

  b. 省略开始下标 — 获取元素时从头开始取(步长为正，从第一个元素开始；步长为负，从最后一个元素开始取)
  列表[:结束下标：步长] — 冒号不能省，此时开始的下标可能是0,可能是-1，由步长的方向决定

  c. 省略结束下标 — 获取元素时从开始下标开始取完为止(有可能取到最后一个，也可能取到第一个，这由步长的正负决定)
  列表[开始下标::步长] – 冒号不省略

  movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
  print(movies[:-2:2])  # ['肖生克的救赎', '阿甘正传','蜘蛛侠','蚁人']
  print(movies[:2:-2])  # ['复仇者联盟', '蚁人', '蜘蛛侠']
  print(movies[:4])     # ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠']
  
  print('------------------------------------------------------------分割线来啦！-----------------------------------------')
  
  print(movies[2::2])   # ['阿甘正传', '蜘蛛侠', '蚁人','复仇者联盟']
  print(movies[4::-1])  # ['蜘蛛侠','钢铁侠','阿甘正传','霸王别姬','肖生克的救赎']
  print(movies[3:])     # ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
  
  print(movies[::-2])  # 有效范围时整个movies原列表，任何从后往前按步长取
  

  3. 遍历

  • 方法1：-- 直接获取元素
    for 变量 in 列表：
    循环体(变量依次获取到的就是列表中的每个元素)

  • 方法2：-- 通过获取所有元素的下标来获取元素
    [10,20,30] --> 0_2;-1-3 正向的下标和对应的负向下标绝对值刚好差1

    for 变量 in range(len(列表)):
    循环体

  • 方法3：
    for 变量1, 变量2 in enumerate(列表）：
    循环体

    变量1依次获取列表元素的下标
    变量2依次获取列表元素的值
    两个变量是对应的

  for index, item in enumerate(movies):
      print('index:', index, 'item:', item)
  

3.列表— 增删改

1）增 — 添加元素

a. 列表.append(元素) — 在列表的最后添加指定元素

hereoes = ['安琪拉','鲁班', '后裔', '王昭君','凯', '吕布']
print(hereoes)
hereoes.append('周瑜')
print(hereoes)
hereoes.append('亚瑟')
print(hereoes)

"""
输出：
['安琪拉', '鲁班', '后裔', '王昭君', '凯', '吕布']
['安琪拉', '鲁班', '后裔', '王昭君', '凯', '吕布', '周瑜']
['安琪拉', '鲁班', '后裔', '王昭君', '凯', '吕布', '周瑜', '亚瑟']
"""

练习

# 利用append删除所有奇数
nums = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
list2=[]
for i in nums:
    if i% 2 == 0:
        list2.append(i)
print(list2)

# 将所有不及格分数改为补考
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
list3=[]
for i in scores:
    if i < 60:
        list3.append('补考')
    else:
        list3.append(i)
print(list3)

b. 列表.insert(下标，元素)— 将指定元素插入到列表中指定下标前

hereoes = ['安琪拉','鲁班', '后裔', '王昭君','凯', '吕布']
print(hereoes)

hereoes.insert(2, '亚瑟')
print(hereoes)
hereoes.insert(3, '典韦')
print(hereoes)

"""
输出：
['安琪拉', '鲁班', '后裔', '王昭君', '凯', '吕布']
['安琪拉', '鲁班', '亚瑟', '后裔', '王昭君', '凯', '吕布']
['安琪拉', '鲁班', '亚瑟', '典韦', '后裔', '王昭君', '凯', '吕布']

"""

2）. 删 — 删除元素

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

print(hereoes)
del hereoes[1]
print(hereoes)
# 注意删除后 各元素的下标顺序与原来的下标顺序已经不同。

b. 列表.remove(元素) — 删除列表中指定元素

• 注意：
  若所删除元素不存在，则会报错 ： ValueEroor
  若所删元素有多个，则会删除最前面的那个元素

  hereoes.remove('王昭君')
  

c. pop — 取走元素，只是列表中没有了元素，内存中还存在

• 列表.pop() — 取出列表中最后一个元素并返回
• 列表.pop(下标) — 取出列表中指定下标对应的元素并返回

result = hereoes.pop()  # 由于pop是可以返回的故是有结果的，而这个结果即是pop取走的元素
print(result)        # 吕布
print(hereoes)

3） 改 — 修改元素

列表[下标] = 新元素 — 将列表中指定下标对应的元素改成新的元素

print(hereoes)  # ['安琪拉', '亚瑟', '典韦', '后裔', '凯']
hereoes[-1]='商启'
print(hereoes)
# ['安琪拉', '亚瑟', '典韦', '后裔', '商启']

# 练习: 将scores中所有低于60分的成绩修改为0分
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
for index, item in enumerate(scores):
    if item < 60:
        scores[index] = 0
print(scores)
# [89, 0, 99, 65, 93, 81, 0, 88, 76, 0, 66]

4. 列表相关操作

1） 列表加法运算 – 合并

列表1 + 列表2 — 将两个列表合并成一个新的列表

A = [10, 20, 30]
B = [100, 200]
C = A+B
print(C)  # [10, 20, 30, 100, 200]
print(A+A)  # [10, 20, 30, 10, 20, 30]

2） 列表乘法运算 – 重复输出

列表 * N 、 N * 列表 — 将列表中的元素重复N次产生一个新的列表

D = [100, 200, '小明', '小红']
print(D * 3)  # 重复三次列表
# [100, 200, '小明', '小红', 100, 200, '小明', '小红', 100, 200, '小明', '小红']

3）列表比较运算

a. 比较是否相等：== 、 ！=

print([100, 200] == [100, 200])
print([100, 200] == [200, 100])

b. 比较大小：> 、 < 、>=、 <=

列表1 > 列表2 比较大小时，双方类型必须是一致的
两个列表比较大小，比较的是第一对不相等的元素的大小(相同位置上的元素是一对)

print([10, 20, 30] > [1, 100, 200, 300])      # True
print([10, 20, 30] > [1, 2, 100, 200, 300])   # True

4） in 和 not in

元素 in 列表 — 判断列表中是否存在指定的元素
元素 not in 列表 — 判断列表中是否不存在指定的元素

print(10 in [10, 20, 30])        # True
print(10 in [[10, 20], 30])      # False
print([10, 20] in [10, 20, 30])  # False

print('------------------------------------------------------------分割线来啦！-----------------------------------------')

# 练习 已知列表A,B 打印两个列表中的公共元素
A = ['后羿', '甄姬', '鲁班七号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for i in A:
    if i in B:
        print(i)

5. 列表相关方法

列表.XXX()

1. 列表.clear() — 清空列表

nums = [1, 4, 2]
nums.clear()
print(nums)  # []

# 也可给列表重新赋值为空列表，但清空的方法更好

2. 列表.count(元素) — 统计列表中指定元素的个数

   nums = [10, 39, 67, 10]
   print(nums.count(100))  # 0
   print(nums.count(10))  # 2
   

3. 列表.extend(序列) — 将序列中元素全部添加到列表中

   list1 = [10, 20]
   list1.extend([100, 200])  # [10, 20, 100, 200]
   
   list2 = [10, 20]
   list2.append([100, 200])  # [10, 20, [100, 200]]
   print(list1, list2)
   
   list1.extend('abc')
   print(list1)  # [10, 20, 100, 200, 'a', 'b', 'c']
   

4. 列表.index(元素) – 获取列表中指定元素对应的下标

​ 若没有该元素则报错

​ 若有多个元素，则返回第一个的下标

nums = [10, 3, 5, 0, 10]
print(nums.index(10))  # 0

5. 列表.reverse() — 将列表倒序

   nums = [10, 3, 5, 0, 9]  # 直接修改原列表的顺序
   nums.reverse()
   print(nums)
   

6. 列表.sort() — 只针对列表；直接修改原列表中元素顺序

​ sorted ----- 针对所有序列；创建新列表排序，原列表元素顺序不变

​ 列表.sort() — 从小到大排序

​ 列表.sort(reverse=True) 从大到小

6.列表相关函数

1）sum(数字序列) — 对数字序列所有元素求数值和

scores = [98, 34, 65, 99, 78, 83]
result = sum(scores)
print(result)

2）max、min

max(序列) - 求序列中最大元素

min(序列) - 求序列中最小元素

scores = [98, 34, 65, 99, 78, 83]
result1 = max(scores)
print(result1)

# 补充：求最大值的逻辑
scores = [98, 34, 65, 99, 78, 83]
max1=scores[0]  # 一般假设第一个元素为最大值
for i in scores[1:]:
    if i > max1:
        max1 = i
print(max1)

# 求最小值的逻辑
scores = [98, 34, 65, 99, 78, 83]
min1 = scores[0]
for i in scores[1:]:
    if i < min1:
        min1 = i
print(min1)

3) sorted

sorted(序列) — 将序列中的元素按从小到大排序，创建一个新的列表
sorted(序列, reverse = True) — 新列表从大到小排序

scores = [98, 34, 65, 99, 78, 83]
result2 = sorted(scores)   # 原序列顺序未变，而是新列表按小到大顺序排列
print(result2)

4）len

len(序列) - 统计序列中元素的个数

print(len(scores))
print(len('abdfsg'))
print(len(range(1, 100, 2)))

5）list

list(序列) — 将指定序列转换成列表(任何序列都可以转换成列表，转换时会将序列中元素转换为列表中元素)

result4 = list('hjsuoa')
print(result4)  # ['h', 'j', 's', 'u', 'o', 'a']

l = list(range(5))
print(l)  # [0, 1, 2, 3, 4]

7.列表赋值问题

拷贝与直接赋值

需求： 已知一个列表，需要创建和原列表一模一样的新的列表

nums = [10, 20, 30, 40]

解决办法1 - 直接赋值:

nums2 = nums
print('nums2:', nums2)

解决办法2 - 拷贝

# 法1：
nums3 = nums * 1
print('nums3:', nums3)

# 法2：
nums4 = nums + []
print('nums4:', nums4)

# 法3： 切片
nums5 = nums[:]
print('nums5:', nums5)

# 法4：
nums6 = nums.copy()
print('nums6:', nums6)

修改原列表，直接赋值的也会跟着改变，但拷贝得到的不会改变

nums.append('abc')
print(nums)
print('nums2:', nums2)
print('nums3:', nums3)
print('nums4:', nums4)
print('nums5:', nums5)
print('nums6:', nums6)
"""
输出：
[10, 20, 30, 40, 'abc']
nums2: [10, 20, 30, 40, 'abc']
nums3: [10, 20, 30, 40]
nums4: [10, 20, 30, 40]
nums5: [10, 20, 30, 40]
nums6: [10, 20, 30, 40]

Process finished with exit code 0

"""

补充：

python 中的变量保存数据其实是保存的数据在内存中的地址(Python中变量全部都是指针变量)

总结：

直接赋值— 一个变量给另外一个变量赋值，赋的是地址，赋值后两个变量指向的是同一块内存

拷贝 — 一个变量拷贝给另一个变量，赋值时会先复制原来变量的数据，任何创建一个新的数据，将新数据的内存地址赋给新的变量

"""
直接赋值是将原列表的地址又赋给nums2，此时原列表与直接赋值后的新列表指向的是同一个地址，故而原列表改变，直接赋值的也会跟着改变

但拷贝会复制保存到一个新地址中，与原列表地址无关联。
"""

8.列表推导式

列表推导式的作用：快速创建列表的表达式（代码简洁)

1) 列表推导式结构1

• 语法：
  [表达式 for 变量 in 序列]

• 让变量去序列中一个一个取值，每取一个值就计算一次表达式的结果，并将计算结果作为列表的一个元素

result = [10 for x in range(5)]
print(result)    # [10, 10, 10, 10, 10]

result = [x*2 for x in range(5)]
print(result)   # [0, 2, 4, 6, 8]


# 案例1：将num 中所有元素乘以2
num2 = [10, 23, 89, 67]
result = [x*2 for x in num2]
print(result)   # [20, 46, 178, 134]

# 案例2：获取num 中所有元素的个位数
nums=[103, 230, 89, 67]
result = [i % 10 for i in nums]
print(result)   # [3, 0, 9, 7]

2) 列表推导式结构2

• 语法
  [表达式 for 变量 in 序列 if 条件语句]

• 让变量去序列中一个一个取值，每取一个值就判断条件是否成立
  若条件成立则计算表达式的结果，并将计算结果作为列表的一个元素
  若条件不成立，则进入下一次循环

result = [x*2 for x in range(5) if x % 2 == 0]
print(result)   # [0, 4, 8]

# 案例:删除scores中所有不及格的分数

scores = [80, 99, 23, 67, 56, 82, 76, 45]
result = [i for i in scores if i > 60]
print(result)   # [80, 99, 67, 82, 76]

# 案例：提取nums中所有奇数的各位是

nums = [103, 230, 89, 67]
result = [i % 10 for i in nums if i % 2 != 0]
print(result)   # [3, 9, 7]