day6,7-列表

day6,7-列表

列表基础

认识列表（list）

"""
1）列表是容器型数据类型（序列）；将[]作为容器的标志，里面多个数据用逗号隔开： [数据1, 数据2, 数据3, ...]
2）列表是可变的(可变指的是列表中元素的个数和元素的值可变 - 列表支持增删改)
   列表是有序的(元素有顺序对应的位置的信息；元素的顺序影响结果 - 列表支持索引操作)
3）列表对元素的要求：没有要求，任何类型的数据都可以作为列表的元素。

注: 元素  - 容器中每一个独立的数据，就是这个容器的元素
"""
# 1）空列表
list1 = []
print(list1)

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

# 3）列表元素可以是任何类型的数据
# a.一个列表中的元素可以是多个相同类型的数据
list2 = [10, 20, 40]
names = ['小明', '小花', '张三']

# b. 一个列表的元素可以是多个不同类型的数据
list3 = [10, 1.23, True, None, '小花']

# c. 列表中的元素也可以是列表
list4 = [10, 20, [30, 40]]

列表查操作

1.查单个 - 获取列表中元素的值

"""
1）语法：
列表[索引]      -       获取列表中指定索引对应元素

2）说明
列表      -       需要获取元素的列表对象(可以是保存一个列表的变量，也可以是具体的列数据)
[]       -       固定写法
索引      -       又叫下标；指的是元素在列表中的位置信息。
                 列表一旦确定，列表中的每个元素对应的索引就确定：
                 a. 元素从前往后索引从0开始不断增加
                 b. 元素从后往前从-1开始不断减少
                 
"""
nums = [10, 20, 30, 40]
print(nums[1])
print([10, 20, 30, 40][1])

print(nums[-1])
print(nums[3])

# print(nums[4])        # 报错！索引不能越界
# print(nums[-6])       # 报错！索引不能越界

2.切片 - 同时获取多个元素（结果是一个列表）

"""
1）完整语法：
列表[开始下标:结束下标:步长]

a. 说明
列表      -       需要获取元素列表
[]       -        固定写法
开始下标、结束下标、步长   -  必须是整数
开始下标  -       决定从哪儿开始取
结束下标  -       决定取到哪儿结束
步长     -        决定取的时候怎么取(是一个一个的按顺序取，还是跳着取；是从前往后取(步长为正)还是从后往前取(步长为负))

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

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

# 2)切片省略的写法
"""
完整的切片语法：列表[开始下标:结束下标:步长]

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

b.省略开始下标  -  获取元素的从头开始取（步长为为正，从第一个元素开始；步长为负，从最后一个元素开始）
列表[:结束下标:步长]

c.省略结束下标 - 获取元素时候从开始下标开始，取完为止（有可能是取到最后一个，也有可能取到第一个）
完整的切片语法：列表[开始下标::步长]
"""

3.遍历 - 一个一个的获取列表中所有的元素

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


方法2 - 通过获取所有元素的下标来获取元素
for 变量 in range(len(列表)):
    循环体(列表[变量])
    
    
方法3：
for 变量1,变量2 in enumerate(列表):
    循环体(变量1依次获取的是每个元素的下标；变量2依次获取的是每个元素)
    
注：len(列表)  -  获取列表长度
"""

列表增删改

1.增 - 添加元素

# 1）列表.append(元素)   -   在指定列表的最后添加指定的元素(不会产生新的列表，而是直接在原列表中添加)
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
print(heroes)

heroes.append('剑圣')
print(heroes)

heroes.append('琴女')
print(heroes)

2.删 - 删除元素

# 1）del 列表[下标]      -       删除列表中指定下标对应的元素
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
print(heroes)   # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

del heroes[1]
print(heroes)   # ['寒冰射手', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']

del heroes[1]
print(heroes)   # ['寒冰射手', '金克斯', '小法', '卡牌', '蛇女']

print('---------------------------------------华丽的分割线------------------------------------')
# 2) 列表.remove(元素)      -   删除列表中的指定元素(如果元素不存在会报错；如果元素有多个，只删最前面那一个)
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']
print(heroes)

heroes.remove('小炮')
print(heroes)

# heroes.remove('塔姆')       # ValueError: list.remove(x): x not in list

heroes.remove('维鲁斯')
print(heroes)       # ['寒冰射手', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']

print('---------------------------------------华丽的分割线------------------------------------')

# 3）
# 列表.pop()      -    取走列表最后一个元素，并且返回
# 列表.pop(下标)    -   取走列表中指定下标对应的元素，并且返回
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']
print(heroes)       # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']

result1 = heroes.pop()
print(heroes, result1)       # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌']  蛇女

result2 = heroes.pop(0)
print(heroes, result2)       # ['小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌']  寒冰射手

3.改 - 修改元素的值

# 列表[下标] = 新元素     -   将列表中指定下标对应的元素改成新元素
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']
print(heroes)       # ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']

heroes[1] = '孙悟空'
print(heroes)       # ['寒冰射手', '孙悟空', '维鲁斯', '金克斯', '小法', '维鲁斯', '卡牌', '蛇女']

列表相关操作

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次产生一个新的列表
C = A * 2
print(C)        # [10, 20, 30, 10, 20, 30]

print(B * 3)    # [100, 200, 100, 200, 100, 200]

print(['小明', '小花'] * 3)     # ['小明', '小花', '小明', '小花', '小明', '小花']

3.列表比较运算

# 1)比较是否相等：==、!=
print([10, 20, 30] == [10, 20, 30])     # True
print([10, 20, 30] == [10, 30, 20])     # False

# 2)比较大小：>、<、>=、<=
# 列表1 > 列表2
# 两个列表比较大小，比较的是第一对不相等的元素的大小(相同位置上的元素是一对)
print([10, 20, 30] > [1, 100, 200, 300, 400])       # True
print([10, 20, 30] > [10, 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

列表相关函数

1. sum(数字序列) - 求数字序列中所有元素的数值和

# 1. sum(数字序列)  -  求数字序列中所有元素的数值和
scores = [98, 23, 56, 88, 90, 70]
result = sum(scores)
print(result)

result = sum(range(101))
print(result)

2. max、min

# 2. max、min
# max(序列)    -  求序列中的最大元素
# min(序列)    -  求序列中的最小元素
scores = [98, 23, 56, 88, 90, 70]
result = max(scores)
print(result)

result = min(scores)
print(result)

# 补充：求最大值的逻辑
# 假设第一个元素是最大值保存到变量中，然后依次取出后面的每个元素和保存最大值的变量进行比较，如果后面取出来的值比最大值还大，就更新最大值
scores = [50, 98, 23, 56, 88, 99, 70]
max1 = scores[0]
for x in scores[1:]:
    if x > max1:
        max1 = x        # 更新最大值
print(max1)

3. sorted

# 3. sorted
# 1）sorted(序列)    -   将序列中的元素按照从小到大的方式排序，创建一个新的列表并且返回
scores = [50, 98, 23, 56, 88, 99, 70]
result = sorted(scores)
print(result)       # [23, 50, 56, 70, 88, 98, 99]

# 2）sorted(序列, reverse=True)    -   将序列中的元素按照从大到小的方式排序，创建一个新的列表并且返回
scores = [50, 98, 23, 56, 88, 99, 70]
result = sorted(scores, reverse=True)
print(result)       # [99, 98, 88, 70, 56, 50, 23]

4. len

# 4. len
# len(序列)  -  统计序列中元素的个数
print(len(scores))          # 7
print(len('abc123'))        # 6
print(len(range(1, 100, 2)))    # 50

5. list

# 5. list
# list(序列)  - 将指定的序列转换成列表(任何序列都可以转换成列表，转换的时候直接将序列中元素作为列表的元素)
result = list('abc123')
print(result)       # ['a', 'b', 'c', '1', '2', '3']

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

列表相关方法

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

# 1. 列表.clear()  - 清空列表
nums = [10, 9, 89, 23]
print(nums)     # [10, 9, 89, 23]
nums.clear()
print(nums)     # []

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

# 2. 列表.count(元素)   -   统计列表中指定元素的个数
nums = [10, 9, 89, 23, 10]
print(nums.count(100))
print(nums.count(9))
print(nums.count(10))

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

# 3. 列表.extend(序列)  -  将序列中的元素全部添加到列表中
list1 = [10, 20]

list1.extend([100, 200])
print(list1)    # [10, 20, 100, 200]

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

4. 列表.index(元素) - 获取列表中指定元素对应的下标(返回的是从0开始的下标值)

# 4. 列表.index(元素)  - 获取列表中指定元素对应的下标(返回的是从0开始的下标值)
nums = [10, 9, 89, 23, 10]
# print(nums.index(100))        # ValueError: 100 is not in list
print(nums.index(89))           # 2
print(nums.index(10))           # 0

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

# 5.列表.reverse()    -   将列表倒序
nums = [10, 9, 89, 23, 50]
nums.reverse()
print(nums)     # [50, 23, 89, 9, 10]

6.sort,sorted

# 列表.sort()                 -       将列表中的元素从小到大排序(直接修改原列表元素的顺序)
# 列表.sort(reverse=True)     -       将列表中的元素从大到小排序
nums = [10, 9, 89, 23, 50]
result = nums.sort()
print(nums)         # [9, 10, 23, 50, 89]
print(result)       # None

nums = [10, 9, 89, 23, 50]
nums.sort(reverse=True)
print(nums)         # [89, 50, 23, 10, 9]


# sorted(序列)  - 将列表中的元素从小到大排序(不修改原序列中元素的顺序，而是创建一个新的列表)
nums = [10, 9, 89, 23, 50]
result = sorted(nums)
print(nums)     # [10, 9, 89, 23, 50]
print(result)   # [9, 10, 23, 50, 89]

列表赋值问题

# 补充：python中的变量保存数据，保存的是数据在内存中的地址（Python中的变量全部都是指针变量）

# 1.拷贝和直接赋值
# 需求：已知一个列表，现在需要创建和原列表一模一样的新的列表
nums = [10, 20, 30, 40]

# 1)直接赋值  -  一个变量直接给另外一个变量赋值，赋的是地址，赋值后两个变量指向的是同一块内存
nums2 = nums
print('nums:', nums)
print('nums2:', nums2)

# 2)拷贝
# 一个变量通过拷贝的方式给另外一个变量赋值，赋值的时候会先复制原来变量中的数据，创建一个新的数据，然后将新的数据对应的内存地址给新的变量
nums3 = nums*1
print('nums3:', nums3)

nums4 = nums + []
print('nums4:', nums4)

nums5 = nums[:]
print('nums5:', nums5)

nums6 = nums.copy()
print('nums6:', nums6)

print('---------------------------------------修改后------------------------------------')
nums.append(100)
print('nums:', nums)

print('nums2:', nums2)
print('nums3:', nums3)
print('nums4:', nums4)
print('nums5:', nums5)
print('nums6:', nums6)

列表推导式

# 列表推导式：快速创建列表的表达式（代码简洁）

1.列表推导式结构1

# 1.列表推导式结构1
"""
1）语法： 
[表达式 for 变量 in 序列]

2）让变量去序列中取值，一个一个的取，取完为止，每取一个值就计算一次表达式的结果，并且将计算结果作为列表的一个元素
"""
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：将nums中所有的元素乘以2
nums = [10, 23, 89, 67]
result = [x*2 for x in nums]
print(result)       # [20, 46, 178, 134]

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

2.列表推导式结构2

# 2.列表推导式结构1
"""
1)语法：
[表达式 for 变量 in 序列 if 条件语句]

2)让变量去序列中取值，一个一个的取，取完为止，每取一个值就判断一次条件是否成立，如果成立就计算表达式值作为列表的元素
"""
result = [x * 2 for x in range(5) if x % 2 == 0]
print(result)     # [0, 4, 8]

# 案例1：删除scores中所有不及格的分数
scores = [80, 99, 23, 67, 56, 82, 76, 45]
result = [x for x in scores if x >= 60]
print(result)   # [80, 99, 67, 82, 76]

# 案例2：提取nums中所有奇数的个位数
nums = [103, 230, 89, 67, 78]
result = [x % 10 for x in nums if x % 2 != 0]
print(result)       # [3, 9, 7]