0901笔记

24_回顾

for-in range

break – 结束所在的循环
continue – 结束当前次 跳转到循环条件位置 [条件成立/容器中还有数据可取 继续下一次 否则结束循环]

while和for循环的对比
1. while也可以完成for-in循环场景[循环次数确定的情况下]
while的实现会比较麻烦 – 建议使用for-in
2. 循环次数不确定 - 使用while
while 循环条件:
循环体的代码块

​ 只要条件成立 就一直做这件事

25_循环作业

# 1. 使用range生成1999年到2023年，获取其中闰年的个数
leap_count = 0  # 记录闰年的个数
# 遍历range序列
for year in range(1999, 2024):
    # 判断
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        leap_count += 1
print('在1999年到2023年中间有', leap_count, '个闰年')

# 2. 录入一个正整数，判断其是否是完美数
# 【完美数：该数所有真因子[除了自身以外的因子]之和等于该数本身 比如6的真因子有1 2 3； 1+2+3 = 6  因此6是完美数】
#    提示: 我们需要获取1-N的数，找到N的真因数[相除余数为0]，然后累加后判断
"""
遍历 获取的范围 不用到 N  最大的真因数 就到数据的一半
    比如10 ====  5
    100 ==== 50
"""
num = int(input('请输入一个正整数:'))
# 需要一个变量 记录真因子之和
factor_total = 0
# 遍历数据范围  找到数据的真因子
for ele in range(1, num // 2 + 1):  # range生成的是整数的等差数列
    # 判断ele是否是num的因子  num除以ele 查看余数是否为0
    if num % ele == 0:
        # 给和进行累加
        factor_total += ele
# 遍历完成 就找到所有的因子之和
if factor_total == num:
    print(num, '是完美数')
else:
    print(num, '不是完美数')

# 3. 录入一个正整数，求该数的阶乘 [比如5的阶乘=`5*4*3*2*1`]
# 设置一个变量记录累乘的结果
factorial = 1  # 因为乘的运算
num1 = int(input('请输入一个正整数:'))
for i in range(num1, 0, -1):
    factorial *= i
print(num1,'的阶乘结果是', factorial)

# 4. 每个苹果0.8元，第一天买2个苹果，第二天开始，每天买前一天的2倍，
# 直至购买的苹果个数达到不超过100的最大值。编写程序求每天平均花多少钱
# 每天平均花的钱数 = 总消费/总天数
# 需要计算总消费 和 总天数
"""
使用while 
1. 重复做的事情： 每天购买苹果  这一天苹果的个数前一天的基础上*2
2. 结束状态： >100的时候结束  [<=100就需要每天购买]
"""
"""
数据准备：
1. 记录苹果的个数
2. 记录天数 [循环一次天数+1]
3. 记录总消费[每天苹果数*金额 进行累加]
"""
apple_count = 2  # 苹果个数初始值是2  代表第一天买了苹果
day = 1  # 天初始值从1开始
total = 0.8 * apple_count
# 开始每天购买循环操作  第二天购买的数量在100以下 才能进行购买
# 第二天的数量=前一天的2倍  在循环条件进行校验：第二天的数量是否是小于等于100的
while apple_count * 2 <= 100:
    # 每天购买的苹果数量
    apple_count *= 2  # 每天是前一天的两倍
    # 天数 +1
    day += 1
    # 金额
    total = total + apple_count * 0.8
# 当循环结束的时候 代表今天的苹果数量到达了目的需求
# 求平均金额
day_avg = total / day
print(day_avg)

# 5. 我国1991年有11.6亿人口，要求根据人口平均年增长率0.4%，计算从1991年算起经过多少年后我国的人口增加15亿
"""
while循环
1. 重复的操作 每年增加0.4%
2. 结束状态  到26.6结束  <26.6的就得循环
"""
"""
数据准备
1. 人口初始值  
2. 记录年数
"""
people_count = 11.6
year_count = 0
# 循环
while people_count < 26.6:
    people_count += people_count * 0.004
    year_count += 1
print(year_count, '年后人口数量增加15亿')

# 6. 输入两个正整数 n和 m，找它们的最大公因数key
#    提示：获取最小的数 从最小的数递减，找到那个能同时整除的数即为最大公因数
"""
n = 8
m = 4
"""
n = int(input('请输入第一个整数：'))
m = int(input('请输入第二个整数：'))
# 找到最小的数
if n < m:
    min_num = n
else:
    min_num = m
# 遍历
for e in range(min_num, 0, -1):
    if n % e == 0 and m % e == 0:
        # 如果同时满足这个要求 代表已经找到公因数
        print(n,'和', m, '的最大公因数是', e)
        # 第一次找到就退出
        break

# 最小公倍数key === key%n == 0 and key % m == 0
# 他俩倍数中最小的那个
"""
3和4    ====》 12
3和6   =====》 6
"""
if n > m:
    max_num = n
else:
    max_num = m
# 遍历
for k in range(max_num, n * m + 1):
    if k % n == 0 and k % m == 0:
        print(n,'和', m, '的最小公倍数是', k)
        break

# 7. 找出100到999之间的水仙花数
for p in range(100, 1000):
    unit = p % 10
    decade = p // 10 % 10
    hundred = p // 100
    if unit ** 3 + decade ** 3 + hundred ** 3 == p:
        print(p)

# 8. 将数字的反转：比如 1234====4321
#    提示：逐个将每位上的数据变成个位上的数，获取个位上的数据，将记录者*10+个位数据
"""
result = 0
num = 1234
    unit = num % 10 = 4
    result = result * 10 + unit    === 4
    num //= 10  ====> 123
    
    
    unit = num % 10 = 3
    result = result * 10 + unit ====> 43
    num //= 10 ====> 12
    
    
    unit = num % 10 = 2
    result = result * 10 + unit ====> 432
    num //= 10 ====> 1
    
    
    unit = num % 10 = 1
    result = result * 10 + unit ====> 4321
    num //= 10 ====> 0
"""
"""
循环次数不确定,使用while循环
1. 重复的操作  获取个位  将记录者*10 + 个数   将源数据//10
2. 结束的状态  num的结果为0 的时候   换句话说 num!=0
"""
"""
数据的准备:
1. 记录者
"""
num2 = int(input('请输入一个正整数：'))
num3 = num2  # 保留源数据
result = 0  # 反转之后的记录者
# 开启循环
while True:
    # 获取个位上的数据
    unit = num2 % 10
    # 将其拼接在记录者身上
    result = result * 10 + unit
    # 更新数据 将上一位移动到个位上
    num2 //= 10
    # 什么情况下不用再操作了
    if num2 == 0:
        break
print(num3, '反转之后的数据是', result)

26_列表的介绍

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

1.列表list：

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

air_temp = 19

air_temp = 24
print(air_temp)

air_temp = 26
print(air_temp)

air_temp = 22
print(air_temp)

air_temp_list = [19, 24, 26, 22, 19, 17]
print(air_temp_list)

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

27_列表

airtemp_list = [17, 19, 22, 26, 30, 28, 26]
"""
1. 获取列表中元素的个数
    len(数据/变量名)
"""
print(len(airtemp_list))  # 7

2. 下标（索引）：

数据的一个编号，可以通过这个编号获取数据 也可以修改这个位置的数据
一般的编程语言中 编号就是从左向右 从0开始 加1递增
Python对于下标有两种表达形式
1. 正向索引 — 从左向右
0,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]
# 列表是可变的，所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可

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 = ['语文', '数学', '英语', '体育']
# 增加一门Python课程
course_list.append('Python')
print(course_list)
# 在1的位置添加政治
course_list.insert(1, '政治')
print(course_list)

5. 删除数据的操作

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)

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判断条件]

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]
pass_score = [s for s in scores if s >= 60]
print(pass_score)

# 利用列表推导式 获取 1-100中个位数是1 且是3的倍数的数据
res = [g for g in range(1, 101) if g % 10 == 1 and g % 3 == 0]
print(res)

8. 容量型数据

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

print(max(scores))
print(min(scores))
print(sum(scores))