【Python学习】Day-008 Day-009 列表以及列表的增、删、改、查；列表的运算；in、not in；列表相关函数、方法；列表推导式

1. 什么是列表

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 (集合无序)

# 运行结果
'''
[] []
0 0
[10, 1.23, False, None, 'abc', [10, 20]]
False
True
'''

2. 查

2.1 查单个元素

一次获取一个元素

获取指定列表指定下标的对应元素

# 语法
列表名[下标]

说明:

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

注意: 下标不能越界

nums = [100, 98, 78, 99, 50]

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

# 运行结果
'''
98 98
50
IndexError: list index out of range
'''

2.2 切片

一次获取多个元素(一次有规律的获取多个元素)

根据下标和步长获取指定列表中的部分元素

# 语法
列表名[开始下标:结束下标:步长]

1. 怎么确定切片结果

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

2. 怎么写切片

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

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


# 运行结果
'''
['诸葛亮', '孙悟空', '澜']
['孙斌', '墨子', '诸葛亮']
['孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信']
['李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']
['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮']
['王昭君', '孙斌', '李白', '百里守约', '墨子', '澜', '孙悟空', '诸葛亮', '李信', '妲己']
'''

2.3 遍历

一个一个的获取列表中的所有元素

方法1

'''
for 变量 in 列表:
    循环体中的变量直接是列表的元素
'''
games = ['王者荣耀', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
for i in games:
    print(i, end='  ')

# 运行结果
'''
王者荣耀  lol  和平精英  永劫无间  apex  2k  植物大战僵尸  开心消消乐  
'''

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

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

# 运行结果
'''
0 王者荣耀  1 lol  2 和平精英  3 永劫无间  4 apex  5 2k  6 植物大战僵尸  7 开心消消乐  
'''

方法3

'''
for 变量1, 变量2 in enumerate(列表):
    循环体中变量1是每个元素的下标，变量2是每个元素
'''
for i,j in enumerate(games):
    print(i, j, end='  ')

# 运行结果
'''
0 王者荣耀  1 lol  2 和平精英  3 永劫无间  4 apex  5 2k  6 植物大战僵尸  7 开心消消乐
'''

3. 增、删、改

3.1 增

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

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

# 运行结果
'''
[10, 20, 30, 100]
'''

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

nums = [10, 20, 30]

nums.insert(-1, 100)
print(nums)

nums.insert(0, 200)
print(nums)

# 运行结果
'''
[10, 20, 100, 30]
[200, 10, 20, 100, 30]
'''

3.2 删

1. del 列表[下标]

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

# 运行结果
'''
['王者荣耀', 'lol', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
'''

2. 列表.remove(元素)

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

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

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

# 运行结果
'''
['王者荣耀', '开心消消乐', 'lol', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
['王者荣耀', 'lol', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
'''

3. 列表.pop()

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

x = games.pop(2)
print(games, x)

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

3.3 改

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

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

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

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

# 运行结果
'''
['部落冲突', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
['部落冲突', '开心消消乐', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '炉石传说']
'''

4. 列表运算

4.1 数学运算

1. +(加法)

将两个列表中的元素依次合并成一个新的列表

语法：列表1 + 列表2

list_1 = [10, 20]
list_2 = [100, 200, 300]
list_3 = list_1 + list_2
print(list_3)

# 运行结果
'''
[10, 20, 100, 200, 300]
'''

2. *(乘法)

列表中元素重复N遍产生一个新的列表

语法：列表 * n(整数)

nums = [10] * 10
print(nums)

# 运行结果
'''
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
'''

4.2 比较运算符(>、<、>=、<=)

1. ==、 !=

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

# 运行结果
'''
False
True
False
False
'''

2. >、<、>=、<=
   列表比较大小，只能是两个列表进行比较
   比较规则：比较第一对不相等的元素打大小(相同索引的元素为一对)

print([10, 2000, 30992, 42220, 522340] > [100, 1])          # False
print([10, 20, 30] > [10, 2, 300])
# print([10, 'abc', 20, 30] > [10, 23, 9]) # '>' not supported between instances of 'str' and 'int'

# 运行结果
'''
False
True
'''

5. in和not in操作

语法：元素 in(not in) 列表

判断列表中是否存在(不存在)指定元素

print(10 in [10, 20, 30])
print(10 in [20, 30, 40])
print([10, 20] in [10, 20, 30])
print(10 not in [20, 30, 40])

# 运行结果
'''
True
False
False
True
'''

6. 列表(序列)相关函数

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

scores = [100, 19, 34, 89, 67, 34, 99]
print(sum(scores))

print(sum(range(1, 101)))

# 运行结果
'''
442
5050
'''

2. max(列表)、min(列表)
   max(列表)、min(列表)

获取列表中的最大、最小元素(列表中的元素支持比较运算)

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

# 运行结果
'''
100
19
'''

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

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

# 运行结果
'''
[100, 19, 34, 89, 67, 34, 99]
[100, 99, 89, 67, 34, 34, 19]
'''

4. len()
   len(列表)

获取列表中的元素个数(列表长度)

scores = [100, 19, 34, 89, 67, 34, 99]
print(len(scores))

# 运行结果
'''
7
'''

5. list()
   list(序列)

将指定数据转换成列表
任何序列都可以转换成列表，转换的时候直接将序列中的元素作为列表的元素

print(list('abc'))
print(list(range(10, 15)))

# 运行结果
'''
['a', 'b', 'c']
[10, 11, 12, 13, 14]
'''

7. 列表相关方法

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

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

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

# 运行结果
'''
[]
'''

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

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

a = [20, 89, 23]
b = a
c = a.copy()            # 列表[:]、列表*1、列表+[] 都是浅拷贝

print('a:', a)
print('b:', b)
print('c:', c)

print('------------------------------------华丽的分割线-----------------------------------')
a.append(100)
print('a:', a)
print('b:', b)
print('c:', c)

# 运行结果
'''
a: [20, 89, 23]
b: [20, 89, 23]
c: [20, 89, 23]
------------------------------------华丽的分割线-----------------------------------
a: [20, 89, 23, 100]
b: [20, 89, 23, 100]
c: [20, 89, 23]
'''

3. 列表.count(数据) - 统计列表中指定数据出现的次数(数据的个数)

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

# 运行结果
'''
2
4
'''

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

nums = [10, 20, 30]
nums.extend('abc')
print(nums)

# 运行结果
'''
[10, 20, 30, 'a', 'b', 'c']
'''

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

nums = [10, 34, 45, 90, 10, 45, 45, 78, 45]
print(nums.index(34))
print(nums.index(45))
# print(nums.index(100))    # ValueError: 100 is not in list

# 运行结果
'''
1
2
'''

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)

列表.sort() - 将列表中的元素升序排序(直接修改原列表元素的顺序，不会产生新的列表)
列表.sort(reverse=True) …降序排列…

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

nums.sort(reverse=True)
print(nums)

# 运行结果
'''
[10, 10, 34, 45, 45, 45, 45, 78, 90]
[90, 78, 45, 45, 45, 45, 34, 10, 10]
'''

sorted(序列) - 将序列中的元素升序排序(不会修改原序列中元素的顺序，会产生一个新的列表)
sorted(序列, reverse=True) …降序排列…

8. 列表推导式

一种创建列表的表达式

8.1 结构一

[表达式 for 变量 in 序列]

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

练习1：提取nums中所有元素的个数

nums = [18, 29, 892, 78, 91, 56]
result = [x % 10 for x in nums]
print(result)

# 运行结果
'''
[8, 9, 2, 8, 1, 6]
'''

练习2：使用列表推导式让所有员工的薪资提高10%

pays = [18290, 10000, 8921, 7828, 12000, 5600]
result = [round(x*1.1, 1) for x in pays]
print(result)

# 运行结果
'''
[20119.0, 11000.0, 9813.1, 8610.8, 13200.0, 6160.0]
'''

round()函数保留一位小数

8.2 结构二

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

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

案例1：获取nums中所有的偶数

nums = [18, 90, 43, 67, 88, 19, 84]
result = [x for x in nums if x % 2 == 0]
print(result)

# 运行结果
'''
[18, 90, 88, 84]
'''

案例2：获取列表中所有数字，并且将数字都乘以10

list1 = [10, 2.25, 'abc', False, True, 'as12', 4, 2.5]
# result = [x*10 for x in list1 if type(x) == int or type(x) == float]
result = [x*10 for x in list1 if type(x) in [int, float]]
print(result)

# 运行结果
'''
[100, 22.5, 40, 25.0]
'''