Python基础_04

Python基础_04

一、列表的介绍

• 为什么会使用容器型数据？
  变量：变化的数据
  在编程中的操作 定义一个标识符 记录变化的数据
  有些时候需要记录数据的变化，变化的数据都保存起来，就需要容器型数据来进行数据存储

• 列表list：
  可变的有序型容器
  可变：数据的值可以发生变化，可以增、删、改
  有序：容器存储放数据时，容器中有多个数据，会给数据设置编号，编号从0开始
  可以通过编号定位获取这个位置的数据，也可以修改
  这个编号被称为下标/索引
  数据在进行定义时，数据标识是[]，在[]中定义多个数据，数据之间用,
  例：[12,34,56,78]
  数据中的编号为0 1 2 3

# 空列表
list0 = []
print(list0)

二、列表的操作

1. 获取列表中的元素个数
   len（数据/变量名）
2. 下标：数据的编号，可通过编号获取数据，也可以修改这个位置数据
   一般编程语言编号从左向右，从0开始，加1递增
   Python对于下标有两种表现形式：
   1.正向索引 — 从左向右
   0,1,2，…,len(数据)-1
   2.负向索引 — 从右向左
   -1，-2，-3，…，-len(数据)
   • 格式：
     列表数据[下标] —> 获取这个位置的数据
     列表数据[下标] = 数据值 —> 修改这个位置的数据
     注意：
     下标不能超过编号的界限

例：

airtemp_list = [17, 19, 22, 26, 30, 28, 26]
# 获取第二个位置的数据
print(airtemp_list[1])   # 正向索引
print(airtemp_list[-len(airtemp_list) + 1])   # 负向索引
# 获取左边的用正向，获取右边的用负向
# 获取倒数第一上的数据
print(airtemp_list[len(airtemp_list) - 1])  # 正向索引
print(airtemp_list[-1])  # 负向索引

# 修改这个位置的数据
airtemp_list[-3] = 33
print(airtemp_list)  # [17, 19, 22, 26, 33, 28, 26]
# 列表是可变的，所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可

3. 切片(slice):提取子序列
   本质上根据下标定位到容器相应的位置，从指定的起始位置按照步长取元素

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

   • 解释：
     1）：步长可以省略，默认为1
     列表数据[起始下标：结束下标]
     2）起始下标可以省略
     看步长为正还是负
     步长为正 代表从最左边开始
     步长为负 代表从最右边开始
     3）结束下标也可以省略
     看步长为正还是负
     步长为正 代表到最右边结束
     步长为负 代表到最左边结束

例：

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)

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

# 前3个
sub_scores = scores[:3]
print(sub_scores)
# 后三个
sub_scores = scores[-3:]
print(sub_scores)

# 反转
sub_scores = scores[::-1]
print(sub_scores)

sub_scores = scores[::2]
print(sub_scores)

4. 增加数据的操作
   1. 列表数据.append(数据) 把数据追加在列表的末尾
   2. 列表数据.insert(指定位置，数据)
   在指定位置添加数据，原位置及其之后数据向后移一位

例：

course_list = ['语文', '数学', '英语']
course_list.append('python')
print(course_list)
course_list.insert(1, '政治')
print(course_list)

5. 删除数据的操作：
   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)

6. 列表的遍历操作：
   1.获取下标序列 根据下标提取数据值
   2.遍历列表 获取列表中的元素

例：

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

print('=============')
for ele in nums:
    print(ele)
print('==========')
# 获取列表中所有的偶数
# 定义一个新的列表 用来存储所有的偶数
even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)
print('====================')
# 获取所有偶数所在的位置
pos_list = []
for i in range(len(nums)):
    if nums[i] % 2 == 0:
        pos_list.append(i)
print(pos_list)


# 获取所有的偶数及其对应的位置
# 遍历位置
for j in range(len(nums)):
    if nums[j] % 2 == 0:
        print(j, nums[j])
print('=========')
# enumerate(有序容器数据) ====》产生一个新的容器  [[位置, 元素], [位置, 元素]]
# 二维结构
for item in enumerate(nums):
    print(item)

# 拆包： 把容器中的数据赋值给N个变量， 把容器拆解 这个过程叫做拆包
a, b = [11, 23]
print(a, b)
print('=======')
# 利用拆包的原理
for p, e in enumerate(nums):
    # p接受的位置  e接受的元素
    if e % 2 == 0:
        print(p, e)

7. 列表推导式
   产生新列表 — 简化遍历格式
   [变量 for 变量 in 容器型数据 if判断条件]
8. max(容器型数据) 获取数据中的最大值
   min(容器型数据) 获取数据中的最小值
   sum(容器型数据) 对容器中的数据求和