第五课的笔记

第五课的笔记

1.列表的介绍

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

1.列表list：
  可变的有序型数据。
       可变：数据的值可以发生变化，可以修改/增加/删除
       有序：容器存储放数据的时候，容器中有多少个数据，会给数据设置编号，编号是从0开始
            可以通过编号定位获取这个位置的数据，也可以修改。
            这个编号被称为下标/索引
  数据在进行定义的时候，数据标识是[],在[]中定义多个数据，数据之间使用逗号分隔
       比如[19,24,26,]
  """
air_temp = 19

air_temp = 24
print(air_temp)

air_temp = 26
print(air_temp)

air_temp = 22
print(air_temp)

2.列表的操作

airtemp_list = [17, 19, 22, 26, 30, 28, 26]
"""
1. 获取列表中元素的个数
    len(数据/变量名)
"""
print(len(airtemp_list))  # 7
"""
2. 下标(索引)：数据的一个编号，可以通过这个编号获取数据 也可以修改这个位置的数据
    一般的编程语言中 编号就是从左向右 从0开始 加1递增
    Python对于下标有两种表达形式
        1. 正向索引 --- 从左向右
                0,1,2,3,4,5,6，..., len(数据)-1
        2. 负向索引 --- 从右向左
                -1，-2，-3，-4，-5， ... -len(数据)
    获取数据的时候可以使用正向索引 也可以使用负向索引
    格式：
        列表数据[下标]  ====> 代表的是获取这个位置的数据
        列表数据[下标] = 数据值  ====》 修改这个位置的数据
    注意：
        下标不能超过编号的界限，否则报错
"""
# 7点  9点  11点  1点  2点  4点 6点
# 0    1     2    3    4    5    6 正向索引
# -7   -6    -5   -4   -3   -2   -1  负向索引
airtemp_list = [17, 19, 22, 26, 30, 28, 26]
# 获取9点  【第二个位置的数据】
print(airtemp_list[1])  # 正向索引获取的
# 使用负向索引
print(airtemp_list[-len(airtemp_list) + 1])

# 获取左边的使用正向  获取右边的使用负向
# airtemp_list.pop() # 把最后一个删除了   [17, 19, 22, 26, 30, 28]
# airtemp_list[6]  #  IndexError: list index out of range
# 获取倒数第一个位置
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]
# 列表是可变的，所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可

"""
切片(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)

"""
增加数据的操作
   1.列表数据.append(数据)  把数据追加在列表的末尾
   2.列表数据.insert(指定位置，数据) 在指定位置添加数据，原位置机器之后的数据都向后移一个
   
"""
course_list = ['语文','数学','英语','体育']
#增加一门Python课程
course_list.append('Python')
print(course_list)
#在1的位置添加政治
course_list.insert(1,'政治')
print(course_list)

"""
删除数据的操作
    1. 列表数据.remove(数据)  将数据在列表中移除  如果数据有多个的话 只会移除出现的第一个
    2. 列表数据.pop()  将列表中最后一个元素移除
    3. 列表数据.pop(位置)  将列表中指定位置的元素移除
    4. 列表数据.clear()   清空列表
"""
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.获取下标序列 根据下标提取数据值
  
  2.遍历列表 获取列表中的元素
"""
nums = [18,29,33,56,71,28,42,56,37]

for pos in range(len(nums)): #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)

"""
列表推导式
    产生新列表 -- 遍历简化的格式
    [变量 for 变量 in 容器型数据 if判断条件]
"""
"""
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)

# 有些需求不一定是有判断的  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])

"""
练习：
   1.scores = [82,79,65,47,58,91,66]
   利用列表推导式获取60及其以上的成绩
   
   2.利用推导式 获取1- 100 中个位数是1 且是3的倍数的数据
"""

scores = [82,79,65,47,58,91,66]
scores_list = []
for n in scores:
    if n >= 60:
        scores_list.append(n)
print(scores_list)

print('==================================')
result= [ n for n in  scores if n >= 60]
print(result)

print('==================================')
result = [ i for i in range(1,101) if i % 10 == 1 and i% 3 == 0]
print(result)


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