day07 列表：相关操作（比较运算）、序列相关函数、列表相关方法、列表推导式

列表：相关操作（比较运算）、序列相关函数、列表相关方法、列表推导式

列表的相关函数

1. 列表的比较运算：==、！=、>、<、>=、<=

   1)== 、!=

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

   2)>、<、>=、<=

   ​ 注意：列表比较大小，只能是两个列表进行比较
   ​ 比较规则：比较第一对不相等的元素的大小（相同位置的元素是一对儿）

   print([0, 20, 30, 40, 50] > [100, 1])  # False
   print([10, 20, 30] > [10, 2, 300])  # True
   # print([10, 'abc', 20, 30] > [10, 23, 9])  # 报错
   

2. 列表（序列）相关函数

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

   scores = [19, 34, 89, 67, 34, 99]
   print(sum(scores))  # 342
   print(sum(range(1, 101)))  # 5050
   

   2)max,min

   ​ max(列表) - 获取列表中的最大元素（列表中的元素支持比较运算）
   ​ min(列表) - 获取列表中的最小元素（列表中的元素支持比较运算）

   scores = [19, 34, 89, 67, 34, 99]
   print(max(scores), min(scores))
   

   sorted(列表) - 将列表中的元素从小到大排序，产生一个新的列表
   sorted(列表, reverse=True) - 将列表中的元素从大到小排序，产生一个新的列表

   scores = [100, 19, 34, 89, 67, 34, 99]
   new_scores = sorted(scores)
   new_scores1 = sorted(scores, reverse=True)
   print(scores)  # [100, 19, 34, 89, 67, 34, 99]
   print(new_scores)  # [19, 34, 34, 67, 89, 99, 100]
   print(new_scores1)  # [100, 99, 89, 67, 34, 34, 19]
   

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

   5)list(序列) - 将指定序列转换成列表
   任何序列都可以转换成列表，转换的时候直接将序列中的元素作为列表的元素

   print(list('abc'))  # ['a', 'b', 'c']
   print(list(range(10, 15)))  # [10, 11, 12, 13, 14]
   

列表相关方法

​ 方法的使用套路：列表.xxx()

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

   nums = [20, 89, 23]
   print(nums)  # [20, 89, 23]
   
   nums.clear()
   print(nums)  # []
   

2. 列表.copy() - 拷贝（浅拷贝）原列表，产生一个一模一样的新列表，将新列表返回

   列表[:],列表+[],列表*1都是浅拷贝

   用变量保存数据的时候，变量真正保存的其实是数据在内存中的地址；
   当用一个变量直接给另外一个变量赋值的时候，赋的其实是变量中保存的地址，赋值后两个变量指向的是同一块内存

   a = [20, 89, 23]
   b = a
   c = a.copy()
   print(a)  # [20, 89, 23]
   print(b)  # [20, 89, 23]
   print(c)  # [20, 89, 23]
   print('--' * 50)
   a.append(100)
   print(a)  # [20, 89, 23, 100]
   print(b)  # [20, 89, 23, 100]
   print(c)  # [20, 89, 23]
   

   深拷贝（子序列也会被复制，浅拷贝不会复制子序列，只会指向子序列）

   from copy import deepcopy
   
   a = [20, 89, 23, [10, [10, 20]]]
   b = deepcopy(a)
   c = a.copy()
   

3. 列表.count(数据)

   nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
   print(nums.count(10))  # 2
   print(nums.count(45))  # 4
   print(nums.count(100))  # 0
   

4. 列表.extend(序列) - 将序列中所有的元素全部添加到列表的最后

   nums = [10, 20, 30]
   nums.extend('abc')
   print(nums)  # [10, 20, 30, 'a', 'b', 'c']
   
   nums = [10, 20, 30]
   nums.extend([100, 200])
   print(nums)  # [10, 20, 30, 100, 200]
   

5. 列表.index(数据) - 获取指定数据在列表中的第一个下标(如果数据不存在会报错)

   nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
   print(nums.index(34))  # 1
   print(nums.index(45))  # 2
   # print(nums.index(100))  # 报错
   

6. 列表.reverse() - 列表倒序

   nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
   nums.reverse()
   print(nums)  # [45, 78, 45, 45, 10, 90, 45, 34, 10]
   

7. 列表排序

   列表.sort() - 将列表中的元素升序排列（直接修改原列表元素的顺序，不会产生新的列表）
   列表.sort(reverse=True)
   优点：节省内存
   sorted(序列) - 将列表中的元素升序排列（不会修改原列表元素的顺序，会产生新的列表）
   sorted(序列,reverse=True)
   优点：速度快

   nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
   nums.sort()
   print(nums)  # [10, 10, 34, 45, 45, 45, 45, 78, 90]
   
   nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
   new_nums = sorted(nums)
   print(new_nums)  # [10, 10, 34, 45, 45, 45, 45, 78, 90]
   

列表推导式

​ 列表推导式：一种创建列表的表达式

1. 结构1

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

   list1 = [10 for i in range(5)]
   print(list1)  # [10, 10, 10, 10, 10]
   
   list2 = [x + 2 for x in range(5)]
   print(list2)  # [2, 3, 4, 5, 6]
   
   list3 = [x * 2 for x in [1, 2, 7, 'abc']]
   print(list3)  # [2, 4, 14, 'abcabc']
   
   # 应用：对序列中的原理进行统一变换（变型）
   # 练习1：提取nums中所有元素的个位数
   # [18, 29, 892, 78, 91, 56] -> [8, 9, 2, 8, 1, 6]
   nums = [18, 29, 892, 78, 91, 56]
   nums_new = [x % 10 for x in nums]
   print(nums_new)  # [8, 9, 2, 8, 1, 6]
   # 练习2：使用列表推导式让所有员工的薪资提高10%
   pays = [18290, 10000, 8921, 7828, 12000, 5600]
   pays_new = [x + x * 0.1 for x in pays]
   print(pays_new)  # [20119.0, 11000.0, 9813.1, 8610.8, 13200.0, 6160.0]
   

2. 结构2

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

   原理：让变量去序列中取值，一个一个取，取完为止，每取一次就判断一次条件语句是否成立，如果成立就计算一次表达式的结果，并且将结果作为列表的元素

   list1 = [x for x in range(5, 15) if x % 2]
   print(list1)
   
   # 应用：数据筛选
   # 案例1：获取nums中所有的偶数
   nums = [18, 90, 43, 67, 88, 19, 84]
   # [18, 90, 88, 84]
   list1 = [x for x in nums if x % 2 == 0]
   print(list1)
   # 案例2：获取列表中所有数字，并且将数字都乘以10
   list1 = [10, 2.25, 'abc', False, True, 'as12', 4, 2.5]
   # [20, 4.5, 8, 5]
   list2 = [10 * x for x in list1 if type(x) in [int, float]]
   print(list2)