9.1 总结

9.1 总结

列表

1. 列表list：
   可变的有序型容器

2. 特点：可变：数据的值可以发生变化，可以修改/增加/删除

   ​ 有序: 容器存储放数据的时候，容器中有多少个数据，会给数据设置编号，编号是从0开始[左边视为开始]
   ​ 可以通过编号定位获取这个位置的数据,也可以修改。
   ​ 这个编号被称为下标/索引
   ​ 数据在进行定义的时候，数据标识是[], 在[]中定义多个数据，数据之间使用逗号分隔
   ​ 比如[19, 24, 26, 22]
   ​ 数据中的编号0 1 2 3

air_temp = 26
print(air_temp)

# 列表为：
air_temp_list = [1，2，3，4，5]
print(air_temp_list)

3. 空列表

   list0 = []
   print(list0)
   

列表元素的获取

1. 获取列表中元素的个数
   len(数据/变量名)

   airtemp_list = [17, 19, 22, 26, 30, 28, 26]
   print(len(airtemp_list))  # 7
   

数据编号

1. 下标(索引)：数据的一个编号，可以通过这个编号获取数据 也可以修改这个位置的数据
   一般的编程语言中 编号就是从左向右 从0开始 加1递增

2. Python对于下标有两种表达形式

   1. 正向索引 — 从左向右
      0,1,2,3,4,5,6，…, len(数据)-1 # 一直到长度减一

   ​ 负向索引 — 从右向左
   ​ -1，-2，-3，-4，-5， … -len(数据)
   ​ 获取数据的时候可以使用正向索引 也可以使用负向索引

3. 正向索引获取

   airtemp_list = [17, 19, 22, 26, 30, 28, 26]
   print(airtemp_list[1])  # 正向索引获取的
   

   负向索引获取

   airtemp_list = [17, 19, 22, 26, 30, 28, 26]
   print(airtemp_list[-len(airtemp_list) + 1])
   

4. 获取左边的数据用正向，获取右边的数据用负向

   获取倒数第一个位置：

   airtemp_list = [17, 19, 22, 26, 30, 28, 26]
   print(airtemp_list[len(airtemp_list) - 1])  # 正向索引
   print(airtemp_list[-1])  # 负向索引
   

修改数据

1. 修改这个位置的数据

   airtemp_list = [17, 19, 22, 26, 30, 28, 26]
   airtemp_list[-3] = 33
   print(airtemp_list)  # [17, 19, 22, 26, 33, 28, 26]
   

   列表是可变的，所有的操作都影响的数据列表本身

   操作完查看数据变化 直接打印列表本身即可

2. 切片(slice): 提取子序列

   本质上根据下标定位到容器相应的位置， 从指定的起始位置按照步长取数据元素去

   格式：
   列表数据[起始下标:结束下标:步长]
   步长为正数，代表的是正向切片 【根据位置从左向右按照步长取值】
   注意：起始下标定位的位置 要在 结束下标定位的位置 的左边
   步长为负数，代表的是负向切片 【根据位置从右向左按照步长取值】
   注意：起始下标定位的位置 要在 结束下标定位的位置 的右边

3. 解读：
   1) :步长可以省略, 步长默认为1
   列表数据[起始下标:结束下标]
   代表从起始下标对应的元素开始 逐个取值 到结束下标对应的位置[结束下标不包含]
   2) 起始下标可以省略
   看步长为正还是为负
   步长为正 代表从最左边开始
   步长为负 代表从最右边开始
   3) 结束下标也可以省略
   看步长为正还是为负
   步长为正 代表到最右边结束
   步长为负 代表到最左边结束

   等价

   1. scores = [76, 28, 39, 45, 57, 82, 91, 68]  # 8个数据
      # 0 1 2 3 4 5 6 7
      sub_scores = scores[1:7:1]
      print(sub_scores)
      

   2. 步长为1可以省略

      等价于：
      sub_scores = scores[1:7]
      print(sub_scores)
      等价于
      sub_scores = scores[1:-1]
      print(sub_scores)
      注：只是按照下标定位到列表相应的位置范围，下标可正可负
      

   起始位置，和步长省略了：

   scores = [76, 28, 39, 45, 57, 82, 91, 68]
   # 前三个数字
   sub_scores = scores[:3]
   print(sub_scores)
   

   省略了起始和步长

   scores = [76, 28, 39, 45, 57, 82, 91, 68]
   # 后三个数字
   sub_scores = scores[-3:]
   print(sub_scores)
   

   省略了起始和结束

   scores = [76, 28, 39, 45, 57, 82, 91, 68]
   # 反转，数据调了个个
   sub_scores = scores[::-1]
   print(sub_scores)
   

   增加和删除数据的操作

   1. 列表数据.append(数据) 把数据追加在列表的末尾

      列表数据.insert(指定位置, 数据) 在指定位置添加数据 ,原位置及其之 后的数据都向后移一个

   course_list = ['语文', '数学', '英语', '体育']
   course_list.append('Python')
   print(course_list)  # 增加一门科目
   
   course_list.insert(1, '政治')
   print(course_list)  # 在1的位置添加政治
   

   2. 删除数据的操作
      1. 列表数据.remove(数据) 将数据在列表中移除 如果数据有多个的话 只会移除出现的第一个
      2. 列表数据.pop() 将列表中最后一个元素移除
      3. 列表数据.pop(位置) 将列表中指定位置的元素移除
      4. 列表数据.clear() 清空列表

   course_list = ['语文', '数学', '英语', '体育']
   # 演示四种删除
   course_list.remove('英语')
   print(course_list)
   
   course_list.pop()
   print(course_list)
   
   course_list.pop(0)
   print(course_list)
   
   course_list.clear()
   print(course_list)
   

   列表的遍历

   1. 关于列表的遍历的操作：

      获取下标序列 根据下标提取数据值

      遍历列表 获取列表中的元素

   方式一：

# 生成一个下标序列
nums = [18, 29, 33, 56, 71, 28, 42, 56, 37]
for pos in range(len(nums)):  # 0 1 2 3 4 5 6 ... 长度-1
	print(nums[pos])

方式二：

# 遍历容器
for ele in nums:
    print(ele)

带条件索引

# 定义一个新的列表 用来存储所有的偶数
for n in nums:
    if n % 2 = 0:
        print(n)

# 获取所有偶数所在的位置
for i in range(len(nums)):
    if num[i] % 2 == 0:
        print(i)

容器存储例题

# 定义一个新的列表 用来存储所有的偶数
even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)

# 获取所有偶数所在的位置
pos_list = []
for i in range(len(nums)):
    if nums[i] % 2 == 0:
        pos_list.append(i)
print(pos_list)

1. 获取所有偶数及其所在的位置

# 遍历位置
for j in range(len(nums)):
    if nums[j] % 2 == 0:
        print(j, nums[j])

enumerate（列举）

1.enumerate(有序容器数据) ====》产生一个新的容器 [[位置, 元素], [位置, 元素]]

# 二维结构
for item in enumerate(nums):
    print(item)

拆包

1. 把容器中的数据赋值给N个变量，把容器拆解 这个过程叫做拆包

a, b = [11, 23] # 把对应位置的数据赋值给对应位置的变量
print(a, b)

2. 利用拆包原理:

# 利用拆包的原理
for p, e in enumerate(nums):
# p接受的位置  e接受的元素
​    if e % 2 == 0:
​        print(p, e)

列表推导公式

1.列表推导式
产生新列表 – 遍历简化的格式
[变量 for 变量 in 容器型数据 if判断条件]

2. even_list = []
   for n in nums:
       if n % 2 == 0:
           even_list.append(n)
   print(even_list)
   """
   可写为：
   result = [n for n in nums if n % 2 == 0]
   print(result)
   

3. 有些需求不一定是有判断的 if判断条件的存在是按照需求来决定有或者没有的：

   values = [1, 2, 3, 4, 5]
   # [1 4 9 16 25]
   pow_list = []
   for d in values:
       pow_list.append(d ** 2)
   print(pow_list)
   
   print([d ** 2 for d in values])
   

   最大，最小和求和

   max(容器型数据) 获取数据中的最大值
   min(容器型数据) 获取数据中的最小值
   sum(容器型数据) 对容器中数据求和

   2. print(max(scores))
      print(min(scores))
      print(sum(scores))
   

for d in values:
pow_list.append(d ** 2)
print(pow_list)

print([d ** 2 for d in values])

##  最大，最小和求和

max(容器型数据)  获取数据中的最大值
min(容器型数据)  获取数据中的最小值
sum(容器型数据)  对容器中数据求和

```python
2. print(max(scores))
   print(min(scores))
   print(sum(scores))