Python基础语法【列表】

Python基础语法【列表】

一.认识列表

1.什么是列表（list）

1）列表是python提供的容器型数据类型；将[]作为容器的标志，里面多个元素用逗号隔开：[数据1，数据2，…]

[数据1，数据2，....]

2）列表是可变的（元素的个数和值可以变化）；列表是有序的（支持下标操作）；
3）元素：任何类型的数据都可以放入作为列表的元素；

4）说明：
a.容器类型数据——可以同时保存多个数据
b.元素——容器中每个独立的数据

2.空列表

list1 = []

3.列表元素可以是任何类型的数据

a.一个列表中的元素可以是多个不同类型的数据

list2 = [10, 20, 30]

b.一个列表元素可以是多个不同类型的数据

list3 = [11, 3.4567, "abc", None, True]

c.列表中的元素也可以是列表

list4 = [10, [20, 30]]       # 这个列表的长度为2

4.列表是有序的

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

二.列表的增删改查

1.查 ——获取列表元素

1.查单个 ——一次 获取列表中的某一个元素

1）语法：列表[索引] —— 获取列表中指定下标对应的元素
2）说明：
a.列表 —— 需要获取元素的列表对象（可以是保存一个列表的变量，也可以是具体的列表数据）
b.[] —— 固定写法
c.下标 —— 又叫索引；列表的下标指的是列表中的元素在列表中的位置信息。
第一种下标（通用的）：元素从前往后对应的下标从0开始一次增加
第二种下标：元素从后往前对应的下标从-1开始依次减少
3）注意：下标不能越界

num =[10, 20, 30]
print(num[-1])
print(num[2])
# print(num[3])  # 报错index

heros = ['小乔', '大乔', '后羿', '鲁班七号', '女警', '安琪拉']
print(heros[2])
print(heros[-4])

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

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

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

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])  # ['霸王别姬', '蜘蛛侠']

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

4).切片省略的写法

完整的切片语法：列表[开始下标：结束下标：步长]
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:])  # ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']

3.遍历 —— 一个一个的获取列表中的每个元素

1)语法1：直接获取元素

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

2)语法2：通过获取所有元素的下标来获取元素

for 变量 in range(个数):
	循环体（列表[变量]）

3）

for 变量1， 变量2 in enumerate(列表):
    循环体(变量1依次获取的是每个元素的下标；变量2依次获取的是每个元素)

4）补充：len(列表) —— 获取列表中元素的个数（获取列表的长度）

for x in num:
    print(x)
for x in heros:
    print(x)

5）案例：统计scores中不及格分数的个数

scores = [90, 34, 79, 99, 100, 77, 56, 67, 55]
count = 0
for x in scores:
    if x < 60:
        count += 1
print(count)

2.改 ——修改元素的值

1)语法：列表[下标] = 新值 ——修改列表中指定下标对应的元素为指定的新值

nums = [10, 20, 30]
print(nums)
nums[0] = 40
print(nums)

2)案例：将所有的scores中所有不及格的分数改成”重修“，scores = [90, 34, 79, 99, 100, 77, 56, 67, 55]。

scores = [90, 34, 79, 99, 100, 77, 56, 67, 55]
for index in range(len(scores)):
    s = scores[index]
    if s < 60:
        scores[index] = "重修"
print(scores)

3.增 —— 添加元素

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

heroes = ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号', '小炮', '女警', '小法', '流浪法师', '蛇女']
print(heros)
heros.append("赵云")
print(heros)

a.案例：提取scores中所有不及格的分数，产生一个新列表

scores = [90, 34, 79, 99, 100, 77, 56, 67, 55]
new_scores = []
for x in scores:
    if x < 60:
        new_scores.append(x)
print(new_scores)

b.练习2：将scores中所有不及格的分数改成’补考’

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
#[89, '补考', 99, 65, 93, 81, '补考', 88, 76, '补考', 66]
new_scores = []
for x in scores:
    if x < 60:
        new_scores.append("补考")
    else:
        new_scores.append(x)
print(new_scores)

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

heroes = ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号']
heroes.insert(1, "赵云")
print(heroes)
heroes.insert(3, "小乔")
print(heroes)

4.删——删除元素

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

heroes = ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号']
del heroes[0]
print(heroes)

2)列表.remove(元素) ——删除列表中的第一个指定元素

heroes = ['王昭君', '猪八戒', '孙悟空', '王昭君','后羿', '鲁班7号']
heroes.remove("王昭君")
print(heroes)

3）

a.列表.pop() —— 取出列表中的最后一个元素，并且返回（pop操作的结果是从列表中取走的数据）

b.列表.pop(下标) —— 取出列表中指定下标元素

c.注意：pop虽然删除了列表里面的元素，但是内存里面还有。

heroes = ['王昭君', '猪八戒', '孙悟空', '王昭君','后羿', '鲁班7号']
result1 = heroes.pop()
print(heroes, result1)
result2 = heroes.pop(0)
print(heroes, result2)

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

# 方法2：
for x, y in enumerate(scores):
    if y < 60:
        scores[x] = 0
print(scores)

三.列表的相关操作

1.列表加法运算

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.列表乘法运算

1)列表 * 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.in和not in

1)数据 in 列表 —— 判断指定数据是否是列表中的元素

2)数据 not in 列表 —— 判断指定数据是否不是列表中的元素

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

print(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 = ["小乔", '孙悟空', '猪八戒', '后羿', "盾山", '赵云']
C = []
for x in A:
    for y in B:
        if x == y:
            C.append(x)
print(C)
# 方法2
for x in A:
    if x in B:
        print(x)

4.列表比较运算

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, 400])  # True
print([10, 20, 30] > [10, 2, 34, 56, 100])  # True

四.列表相关函数：sum,max,min,sorted

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

A = [10, 20, 30]
print(sum(A))  # 60

2）a. max(列表) —— 列表的最大元素

​ b. min(列表) —— 列表的最小元素

A = [60, 20, 30]
print(max(A))
print(min(A))

3）a. sorted(列表) —— 将列表中的元素从小到大排序产生一个新的列表

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

new_A = sorted(A)
print(new_A) # [20, 30, 60]
new_A = sorted(A, reverse=True)
print(new_A) # [60, 30, 20]

4). len(序列) —— 统计序列中元素的个数

print(len(scores))  # 7
print(len("123abd"))  # 6
print(len(range(1, 100, 2)))  # 50

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

name = "你真棒"
print(list(name))  # ['你', '真', '棒']

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

五.列表相关方法 —列表.xxx()

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

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

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

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

nums = [10, 9, 89, 23, 10, 9, 9]
print(nums.count(10))  # 2
print(nums.count(9))  # 3

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']

list1.extend(range(5))
print(list1)  # [10, 20, 100, 200, 'a', 'b', 'c', 0, 1, 2, 3, 4]

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

nums = [10, 9, 89, 23, 10]
print(nums.index(89))  # 2
print(nums.index(10))  # 0 返回的是最前面的
#print(nums.index(100))  #ValueError: 100 is not in list

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

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

6.列表.sort()
1） 列表.sort() —— 将列表中的元素从小到大排序（直接修改原列表元素的顺序）
2）列表.sort(reverse=True) —— 将列表中的元素从大到小排序
注意：sort没有结果，只是交换列表中的排序顺序，不会保留原来的顺序。

nums = [10, 9, 89, 23, 10, 99]
print(nums.sort())  # None
print(nums)  # [9, 10, 10, 23, 89, 99]

3）sorted(序列) —— 将列表中的元素从小到大排序（不修改原序列中元素的顺序，而是创建一个新的列表）
注意：创建一个新列表再排序，会保存原来的数据，如果后面操作还需要使用原来的数据，就适合使用sorted

nums = [10, 9, 89, 23, 10, 99]
result = sorted(nums)
print(nums)  # [10, 9, 89, 23, 10, 99]
print(result)  # [9, 10, 10, 23, 89, 99]

六.列表赋值问题

补充：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)  # [10, 20, 30, 40, 100]
print(nums2)  # [10, 20, 30, 40, 100]
print(nums3)  # [10, 20, 30, 40]
print(nums4)  # [10, 20, 30, 40]
print(nums5)  # [10, 20, 30, 40]
print(nums6)  # [10, 20, 30, 40]

七.列表推导式—快速创建列表的表达式（代码简洁）

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]

3）案例1：将nums中所有的元素乘以2

nums = [10, 23, 89, 67]
result = [x * 2 for x in nums]
print(result)  # [20, 46, 178, 134]

4）案例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】

3） 案例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]

4）案例2：提取nums中所有奇数的个位数 (只用管元素与元素的关系)

nums = [103, 230, 89, 67]
result = [x % 10 for x in nums if x % 2 != 0]
print(result)  # [3, 9, 7]