python基础语法学习笔记五

最新推荐文章于 2024-06-27 16:01:16 发布

LCZLYZ

最新推荐文章于 2024-06-27 16:01:16 发布

阅读量34

点赞数

文章标签： python 学习数据分析

本文链接：https://blog.csdn.net/LCZLYZ/article/details/129537173

版权

DAY 5、6

列表

一、列表基础

1.认识列表（list）

1）列表是容器型数据类型（序列）；将[]作为容器的标志，里面多个数据的时候用逗号隔开：[数据1,数据2,数据3,…]

2）列表是可变的（列表中元素的个数和元素的值可变 - 列表支持增删改）；列表是有序的（元素的顺序对应的位置信息；元素的顺序影响结果 - 列表支持索引操作）

3）列表对元素的要求：没有要求，任何类型的数据都可以作为列表的元素

注:元素 - 容器中每一个独立的数据，就是这个容器的元素

# 1）空列表
list1 = [] / 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,[10,20]]

二、列表查操作 - 获取列表中元素的值

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])   #报错！索引不能越界

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

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

#####    b.说明：

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

2)使用切片

a.确定切片的结果

第一步：先确定结果是否为空，看开始下标对应的位置到结束下标对应的位置的方向和步长的方向是否一致，一致结果不为空，不一致结果一定为空；
第二步：如果结果不为空，再确定切片的有效范围：开始下标对应的元素能取到，结束下标对应的元素取不到；
第三步：在有效范围内，按照步长的方向和绝对值获取元素。

方向：步长为正，从开始下标到结束下标从前往后取；步长为负就从后往前取

绝对值：绝对值为1，就一个一个的取；绝对值为2，取1个跳1个再取1个；绝对值为3，取1个跳2个再取1个…

b.怎么写切片代码获取指定元素

1)确定开始下标：需要的结果中的第一个数据在列表的下标

2)确定结束下标：结束下标是结果中最后一项的后一个数据或者前一个数据的下标（方向）

3)确定步长：正负看趋势（从前往后取还是从后往前取）；再看绝对值（看取的时候是一个一个取的，还是跳着取的）

movies = ['肖申克的救赎','霸王别姬','阿甘正传','钢铁侠','蜘蛛侠','蝙蝠侠','蚁人','雷神','复仇者联盟']
print(movies[1:3:1])
print(movies[0:-2:2])   #结束下标 取不到

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[0:7:3])      #['肖申克的救赎', '钢铁侠', '蚁人']
print(movies[-1:-5:-1])   #['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[3:0:-2])    #['钢铁侠', '霸王别姬']
print(movies[-2:2:-2])   #['雷神', '蝙蝠侠', '钢铁侠']
print(movies[1:-3:4])    #['霸王别姬', '蝙蝠侠']

3)切片省略的写法

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

省略步长 - 相当于步长为1

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

列表[:结束下标:步长]

省略结束下标 - 获取元素的时候，从开始下标开始，取完为止（有可能是取到最后一个，也有可能取到第一个）

列表[开始下标::步长]

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])   #['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传', '肖申克的救赎']

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

方法1:
for 变量 in 列表:
    循环体（变量依次获取到的就是列表中的每个元素）

方法2  -  通过获取所有元素的下标来获取元素
for 变量 in range(列表长度):     列表长度 = len(列表)
    循环体(列表[变量])

方法3:
for 变量1，变量2 in enumerate（列表）:
    循环体（变量1依次获取到的是每个元素的下标；变量2依次获取的是每个元素）
注： len(列表)  -  获取列表长度

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

scores = [90,89,87,79,93,67,56,43,99]
# 方法1：
for x in scores:
    print(x)
# 求总分
sum1 = 0
for x in scores:
    sum1 +=x
print(sum1)
# 统计90分以上的学生人数
scores = [90,89,87,79,93,67,56,43,99]
count = 0
for x in scores:
    if x > 90:
        count += 1
print('90分以上的学生人数:',count)

list1 =[[10,20],[100,200],[1,2]]
for x in list1:
    print('x:',x[-1])


scores = [90,89,87,79,93,67,56,43,99]
for x in range(len(scores)):   #下标为等差数列
    print(x,scores[x])

for x,y in enumerate(scores):
    print('x:',x,'y:',y)

三、列表的增删改

1. 增 - 添加元素

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

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

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

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

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

# 练习：利用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)

# 练习2：将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('补考')
    else:
        new_scores.append(x)
print(new_scores)
# 2)列表.insert(下标，元素) -  将指定元素插入到列表中指定下标对应的元素前
heroes = ['寒冰射手','小炮','维鲁斯','金克斯','小法','卡牌','蛇女']
print(heroes)

heroes.insert(-1,'亚索')
print(heroes)

heroes.insert(0,'石头人')
print(heroes)

2.删 - 删除元素

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

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

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


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

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

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

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

# heroes.remove('塔姆')  #元素不存在，报错

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

3）列表.pop() - 取出列表最后一个元素,并且返回

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

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

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

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

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

result3 = heroes.pop(5)
print(heroes,result3)

del heroes[3]
print(heroes)

3 改 - 修改元素的值

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

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

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

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# for x,y in enumerate(scores):
#     if y < 60:
#         scores[x] = 0
# print(scores)

# 方法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)

# 方法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)

四、列表的相关操作

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,200,300,400])  # True

4. in 和 not in

元素 in 列表 - 判断列表中是否存在指定的元素

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

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

# 练习：已经列表A和B, 打印A和B的公共元素
A = ['后羿', '甄姬', '鲁班7号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for x in A:
    if (x in B) == True:  #存在优先级问题
        print(x)

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

五、列表相关函数

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

scores = [98,23,56,88,90,70]
result = sum(scores)
print(result)

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

2.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,90,70]
max1 = scores[0]
for x in scores[1:]:
    if x > max1:
        max1 = x   #更新最大值
print(max1)

3.sorted

sorted(序列) - 将序列中的元素按照从小到大的方式排序，创建一个新的列表。

sorted(序列,reverse = True)

scores = [50,98,23,56,88,90,70]
result = sorted(scores)
print(result)   #[23, 50, 56, 70, 88, 90, 98]

scores = [50,98,23,56,88,90,70]
result = sorted(scores,reverse = True)
print(result)   #[98, 90, 88, 70, 56, 50, 23]

4.len

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

print(len(scores))       #7
print(len('ABC213'))     #6
print(len(range(1,100,2)))   #50

5.list

list(序列) - 将指定的序列转换成列表（任何序列都可以转换成列表,转换时直接将序列中的元素作为列表中的元素） - 可将陌生容器转换成列表

result = list('adjs123')
print(result)   #['a', 'd', 'j', 's', '1', '2', '3']

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

六、列表相关方法

列表.xxx()

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

nums = [10,9,89,23]
print(nums)

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,20]

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

list1.extend('asd')
print(list1)    #[10, 20, 100, 200, 'a', 's', 'd']

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

nums = [10,9,89,23,10]
# print(nums.index(100))   #报错
print(nums.index(89))   #2

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

nums = [10,9,89,23,10]
nums.reverse()
print(nums)

6.列表.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]

七、列表赋值问题

1.拷贝和直接赋值

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

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)

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

八、列表推导式 - 快速创建列表的表达式（代码简洁）

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
num2 = [10,23,89,67]
result = [x*2 for x in num2]
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]

LCZLYZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础语法学习笔记五

二、列表查操作 - 获取列表中元素的值1.查单个 - 获取一个元素1)语法:列表[索引] - 获取列表中指定索引对应元素2）说明列表 - 需要获取元素的列表对象（可以是保存一个列表的变量，也可以是具体的列数据）[] - 固定写法索引 - 又叫下标；指的是元素在列表中的位置信息。列表一旦确定，列表中的每个元素对应的索引就确定： a.元素从前往后索引从0开始不断增加
复制链接

扫一扫