总结5（列表）

总结5

1. 列表基础

1.1 使用列表

scores = [90, 87, 92, 67, 55, 69, 81, 99, 100]
print(sum(scores) / len(scores))
print(max(scores))

1.2 认识列表（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]]

2. 列表的查操作

1.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 切片 - 同时获取多个元素(列表结果的结果是列表）

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

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

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

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

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']

print(movies[1:3:1])        # ['霸王别姬', '阿甘正传']
print(movies[0:-2:2])       # ['肖生克的救赎', '阿甘正传', '蜘蛛侠', '蚁人']
print(movies[5:0:2])        # []
print(movies[3:-1:-1])      # []
print(movies[-2:2:-2])      # ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[6:2:-3])       # ['蚁人', '钢铁侠']
print(movies[1:-3:3])       # ['霸王别姬', '蜘蛛侠']


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(movies[1:4:1])

# ['阿甘正传','蜘蛛侠', '蚁人']
print(movies[2:-2:2])

# ['雷神', '阿甘正传']
print(movies[-2:1:-5])

print('---------------------------------------华丽的分割线------------------------------------')
# ['肖生克的救赎', '钢铁侠', '蚁人']
print(movies[0:-2:3])

# ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[-1:-5:-1])

# ['钢铁侠', '霸王别姬']
print(movies[3:0:-2])

# ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[-2:2:-2])

# ['霸王别姬', 蝙蝠侠']
print(movies[1:-3:4])

2.2 切片的省略的写法

完整的切片语法：列表[开始下标:结束下标:步长]

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

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

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

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']

print(movies[1:4])          # ['霸王别姬', '阿甘正传', '钢铁侠']
print(movies[-1:1])         # []

print(movies[:-2:2])        # ['肖生克的救赎', '阿甘正传',  '蜘蛛侠', '蚁人']
print(movies[:2:-2])        # [ '复仇者联盟', '蚁人', '蜘蛛侠']
print(movies[:4])           # ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠']

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

print(movies[::-2])         # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传', '肖生克的救赎']

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

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


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

scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]

# 方法1:
for x in scores:
    print(x)

# 求总分
sum1 = 0
for x in scores:
    sum1 += x
print('总分:', sum1)

# 统计90分以上的学生的人数
count = 0
for x in scores:
    if x > 90:
        count += 1
print('90分以上的学生的人数:', count)

print('---------------------------------------华丽的分割线------------------------------------')
list1 = [
    [10, 20],
    [100, 200],
    [1, 2]
]
for x in list1:
    print('x:', x[-1])

print('---------------------------------------华丽的分割线------------------------------------')
scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]
for x in range(len(scores)):
    print(x, scores[x])

print('---------------------------------------华丽的分割线------------------------------------')
for index, item in enumerate(scores):
    print('index:', index, 'item:', item)

3. 列表的增删改

3.1 增 - 添加元素

 1） 列表.append(元素)    -     在指定列表的最后添加指定的元素(不会产生新的列表，而是直接在原列表中添加)

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

heroes.append('剑圣')  
# ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女', '剑圣']
heroes.append('狐狸')
# ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女', '剑圣', '狐狸']


# :案例:提取scores中所有不及格的分数
scores=[89,45,99,65,93,81,29,88,76,59,66]
new_scores=[]
for x in scores:
    if x < 60:
        new_scores.append(x)
print(new_scores)						# [45, 29, 59]

# 练习1：利用append删除列表中所有的奇数
nums = [89,45,99,65,93,81,29,88,76,59,66]
new_nums=[]
for x in nums:
    if x%2==0:
        new_nums.append(x)
print(new_nums)  						#  88  76  66

# 练习2：将scores中所有不及格的分数改成'补考'
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
new_scores=[]
for x in scorse:
    if x < 60:
        new_scores.append('补考')
print(new_scores)						# ['补考', '补考', '补考']

2）列表.insert(下标，元素)   -    将指定元素插入到列表中指定下标对应的元素前

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

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

3.2 删 - 删除元素

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

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

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

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

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

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

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

heroes =['寒冰射手','小炮','维鲁斯','金克斯','小法','卡牌','蛇女']

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

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

3.3 改 - 修改元素的值

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

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

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


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

# 方法2
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，20o]

2．列表乘法运算
列表* N 、 N *列表    -    将列表中的元素重复N次产生一个新的列表

c=A * 3
print(c)              # [10, 20, 30, 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

2)比较大小:>、<、>=、<=
列表1>列表2
两个列表比较大小，比较的是第一对不相等的元素的大小(相同位置上的元素是一对)

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

4.in和not in
元素in 列表    -    判断列表中是否存在指定的元素
元素 notin列表   -     判断列表中是否不存在指定的元素

# 练习：已经列表A和B, 打印A和B的公共元素

A = ['后羿', '甄姬', '鲁班7号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for x in A:
    if x in B:
        print(x)     #   后羿    赵云

5.列表相关函数

# 1.Sum
# 1.sum(数字序列）   -    求数字序列中所有元素的数值和
scores=[80,49,38,57,10,90]
resul1=sum(scores)
print(resul1)


resul1=sum(range(101))
print(resul1)

# 2. max、min
# max(序列)   -   求序列中最大元素
# min(序列)   -   求序列中最小元素
scores=[80,49,38,57,10,90]
resul1=max(scores)
print(resul1)

resul1=min(scores)
print(resul1)

# 补充:求最大值的逻辑
scores=[80,49,38,57,10,90]
max1=scores[0]
for x in scores[1:]:
    if x > max1:
        max1=x          # 更新最大值
print(max1)             # 90

# 3. sorted
# sorted(序列)  -   将序列中的元素按照从小到大的方式排序，创建—个新的列表。
scores=[80,49,38,57,10,90]
result=sorted(scores)
print(result)                               # [10, 38, 49, 57, 80, 90]

# sorted(序列,reverse=True)   -   将序列中的元素按照从大到小的方式排序，创建一个新的列表并且返回
scores=[80,49,38,57,10,90]
result=sorted(scores,reverse=True)
print(result)                               # [90, 80, 57, 49, 38, 10]

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

# 5. list
#  list(序列)        -        将指定的序列转换成列表(任何序列都可以转换成列,转换的时候直接将序列中元素作为列表的元素)
result=list('sam9239,大傻子')
print(result)                # ['s', 'a', 'm', '9', '2', '3', '9', ',', '大', '傻', '子']

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

6.列表相关方法

# 列表.xxx()

# 1. 列表.clear()      -      清空列表
nums=[38,59,3,7,20]
print(nums)                 # [38,59,3,7,20]

nums.clear()
print(nums)                  # []

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


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

list1.extend([39,50])
print(list1)                        # [10, 40, 39, 50]

list1.extend('dam')
print(list1)                        # [10, 40, 39, 50, 'd', 'a', 'm']

# 4．列表.index(元素)       -      获取列表中指定元素对应的下标(返回的是从0开始的下标值)
nums = [10,9,89,23,10]
print(nums.index(9))            # 1
print(nums.index(10))           # 0

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

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

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

7. 列表的赋值问题

补充: 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)

8. 列表的推导式

列表推导式的作用: 快速创建列表的表达式（代码简洁）
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

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]