十九.循环作业
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)
二十.列表的介绍
为什么会使用容器型数据???
变量 : 变化的数据
在编程中的操作 定义一个标识符 记录变化的数据
有些时候 需要记录数据的变化,变化的数据都保存起来,就需要容器型数据来进行数据存储
- 列表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)
二十一.列表的操作
1.获取列表中元素的个数
len(数据/变量名)
airtemp_list = [17, 19, 22, 26, 30, 28, 26]
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]
# 列表是可变的,所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可
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) # [28, 39, 45, 57, 82, 91]
d# 等价于
sub_scores = scores[1:7]
print(sub_scores) # [28, 39, 45, 57, 82, 91]
# 等价于 只是按照下标定位到列表相应的位置范围
sub_scores = scores[1:-1]
print(sub_scores) # [28, 39, 45, 57, 82, 91]
# 前3个
sub_scores = scores[:3]
print(sub_scores) # [76, 28, 39]
# 后三个
sub_scores = scores[-3:]
print(sub_scores) # [82, 91, 68]
# 反转
sub_scores = scores[::-1]
print(sub_scores) # [68, 91, 82, 57, 45, 39, 28, 76]
# 步长为2,隔一个取一个
sub_scores = scores[::2]
print(sub_scores) # [76, 39, 57, 91]
4.增加数据的操作
1.列表数据.append(数据) 把数据追加在列表的末尾
2.列表数据.insert(指定位置, 数据) 在指定位置添加数据, 原位置及其之后的数据都向后移一个
course_list = ['语文', '数学', '英语', '体育']
# 增加一门Python课程
course_list.append('Python')
print(course_list) # ['语文', '数学', '英语', '体育', 'Python']
# 在1的位置添加政治
course_list.insert(1, '政治')
print(course_list) # ['语文', '政治', '数学', '英语', '体育', 'Python']
5.删除数据的操作
- 列表数据.remove(数据) 将数据在列表中移除 如果数据有多个的话 只会移除出现的第一个
- pop() 将列表中最后一个元素移除
- 列表数据.pop(位置) 将列表中指定位置的元素移除
- 列表数据.clear() 清空列表
course_list.remove('英语')
print(course_list) # ['语文', '政治', '数学', '体育', 'Python']
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])
for ele in nums:
print(ele)
# 获取列表中所有的偶数
# 定义一个新的列表 用来存储所有的偶数
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)
# 获取所有的偶数及其对应的位置
# 遍历位置
for j in range(len(nums)):
if nums[j] % 2 == 0:
print(j, nums[j])
# 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]
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)
max(容器型数据) 获取数据中的最大值
min(容器型数据) 获取数据中的最小值
sum(容器型数据) 对容器中数据求和
print(max(scores))
print(min(scores))
print(sum(scores))