Python第二次作业
目录
一、编写程序实现对称数字图案打印功能
输入一个正整数 k（2≤k≤5），使用 嵌套 for 循环 打印对称数字图案，
规则：
共 k 行，第 i 行（从 1 开始）打印 i 个数字，数字从 1 递增到 i；
每行数字之间用空格分隔。
示例：
输入 k=3，
输出：
1
1 2
1 2 3
1. 题目分析
（1）输入要求：需输入一个正整数 k，且 k 的取值范围限定为 2≤k≤5。
（2）核心规则：使用嵌套 for 循环打印对称数字图案，具体要求为 “共 k 行，第 i 行（从 1 开始计数）打印 i 个数字，数字从 1 递增到 i”。
（3）格式要求：每行中的数字之间必须用空格分隔，确保图案整洁易读。
2. 程序分析
（1）输入处理：通过 input() 函数获取用户输入的内容，再用 int() 函数将其转换为整数类型，赋值给变量 k，确保后续循环逻辑可基于整数正常执行。
（2）外层循环（控制行数）：使用 for i in range(1, k+1) 构建外层循环，其中变量 i 表示当前行数（取值从 1 到 k），直接决定总打印行数为 k 行，符合 “共 k 行” 的规则。
（3）内层循环（控制每行数字）：针对第 i 行，通过 for j in range(1, i+1) 构建内层循环，变量 j 表示当前行需打印的数字（取值从 1 到 i），实现 “第 i 行打印 i 个递增数字” 的需求。
（4）格式控制：内层循环中，print(j, end=" ") 通过 end=" " 参数让每个数字打印后紧跟一个空格，保证数字间的分隔；内层循环结束后执行 print()（无参数），触发换行操作，确保每行图案独立显示，符合格式要求。
3.代码
k = int(input("请输入一个正整数k（2≤k≤5）："))
for i in range(1,k+1):
for j in range(1,i+1):
print(j,end=" ")
print()4. 运行结果示例
二、编写程序实现数字密码锁模拟功能
模拟一个数字密码锁的工作过程，规则如下：
1.初始密码为四位数：1234
2.用户有3次输入密码的机会
3.每次输入后：
若密码正确，提示“密码正确，锁已打开”并结束程序
若密码错误，提示“密码错误，剩余x次机会”
若输入的不是四位数，提示“请输入四位数密码”，不消耗尝试次数
4.额外功能：
连续输错3次后，提示“密码错误次数过多，锁已锁定”锁定后询问是否重置（y/n），输入y则重新获得3次机会，输入n则退出程序
1. 题目分析
（1）初始设置：数字密码锁的初始密码固定为四位数 1234，用户初始拥有 3 次输入密码的机会。（2）输入验证规则：
- 若输入为四位数：进一步判断密码是否正确；
- 若输入非四位数：提示 “请输入四位数密码”，且不消耗尝试次数，需重新输入。
（3）密码判断逻辑：
- 密码正确：提示 “密码正确，锁已打开”，直接结束程序；
- 密码错误：尝试次数减 1，提示 “密码错误，剩余 x 次机会”（x 为当前剩余次数）。
（4）锁定与重置功能：
当连续输错 3 次后，提示 “密码错误次数过多，锁已锁定”；锁定后询问用户是否重置（输入 y 或 n），输入 y 则重新获得 3 次机会，输入 n 则退出程序。
2. 程序分析
（1）变量初始化：用字符串 passwd = "1234" 存储初始密码（避免整数类型无法直接判断位数），用 chance = 3 记录剩余尝试次数。
（2）循环控制：通过 while chance > 0 构建循环，确保只有剩余次数大于 0 时，用户才能继续输入密码。
（3）输入处理与位数验证：
- 用
input()获取用户输入的密码user_input_passwd； - 通过
len(user_input_passwd) != 4判断是否为四位数，若不是则提示并执行continue，跳过后续逻辑，不消耗尝试次数。
（4）密码正确性判断：
- 若
user_input_passwd == passwd：打印正确提示，程序后续随循环结束自然终止； - 若密码错误：
chance减 1，若剩余次数>0，提示剩余次数；若次数耗尽，触发锁定逻辑。
（5）锁定与重置逻辑：
- 锁定时提示 “密码错误次数过多，锁已锁定”，通过
input()获取用户重置选择reset_choice； - 输入
y：将chance重置为 3，提示 “已重置，重新获得 3 次机会”，循环继续； - 输入
n：提示 “程序退出”，循环随后续chance为 0 终止。
3. 代码
passwd = "1234"
chance = 3
while chance > 0:
user_input_passwd = input("请输入四位数密码：")
if len(user_input_passwd) != 4:
print("请输入四位数密码：")
continue
if user_input_passwd == passwd:
print("密码正确，锁已打开")
else:
chance -=1
if chance > 0:
print(f"密码错误，剩余{chance}次机会")
else:
print("密码错误次数过多，锁已锁定")
reset_choice = input("是否重置密码？（y/n）")
if reset_choice == "y":
chance = 3
print("已重置，重新获得3次机会")
else:
print("程序退出")4. 运行结果示例
三、编写程序实现统计特定数字功能（while 循环版）
输入一个正整数 n，使用 while 循环统计 1 到 n 之间（含 n）所有 “既是偶数又能被 4 整除” 的数，并打印：
这些数的总和；
这些数的个数。
示例：输入 n=10，符合条件的数为 4、8，总和 12，个数 2。
1. 题目分析
（1）输入要求：需输入一个正整数 n，程序将遍历 1 到 n 之间（包含 n 本身）的所有整数。
（2）统计规则：筛选出 “既是偶数又能被 4 整除” 的数字。
（3）输出要求：最终需打印两个结果
① 符合条件数字的总和；
② 符合条件数字的个数。
2. 程序分析
（1）变量初始化：
total = 0：用于存储符合条件数字的总和，初始值设为 0（避免初始值影响累加结果）；count = 0：用于统计符合条件数字的个数，初始值设为 0；m = 1：作为 while 循环的计数器，从 1 开始（对应 “1 到 n” 的遍历起点）。
（2）循环控制逻辑：通过 while m <= n 构建循环，确保计数器 m 遍历从 1 到 n 的所有整数，直到 m 超过 n 时循环终止。
（3）条件判断：使用 if m % 2 == 0 and m % 4 == 0 判断数字是否符合要求
m % 2 == 0：判断数字是否为偶数；m % 4 == 0：判断数字是否能被 4 整除；- 两者用
and连接，仅当同时满足时才执行后续操作。
（4）循环内操作：若数字符合条件，将其值累加到 total（total += m），同时将计数 count 加 1（count += 1）；无论是否符合条件，计数器 m 均需自增 1（m += 1），确保遍历不中断。
（5）结果输出：通过格式化字符串 print(f"...") 清晰打印总和与个数，符合题目输出要求。
3. 代码
n = int(input("请输入一个正整数："))
total = 0
count = 0
m = 1
while m <= n:
if m % 2 == 0 and m % 4 == 0:
total += m
count += 1
m += 1
print(f"这些数的总和为：{total}")
print(f"这些数的个数为：{count}")
4. 运行结果示例
四、编写程序实现找零最少硬币组合功能
输入商品价格 price（整数，0 < price < 100）和支付金额 payment（整数，payment ≥ price），
计算找零金额并使用最少硬币数组合：
（硬币面额：1 元、5 元、10 元、20 元）。
示例：找零 36 元，最优组合为 20+10+5+1（共 4 枚）。
1. 题目分析
（1）输入要求：需输入两个整数
① 商品价格 price（范围：0 < price < 100）；
② 支付金额 payment（要求：payment ≥ price，确保找零金额非负）。
（2）核心需求：
① 计算找零金额（找零金额 = 支付金额 - 商品价格）；
② 用最少硬币数组合找零，硬币面额固定为 1 元、5 元、10 元、20 元（优先使用大面额硬币可保证硬币数最少，即贪心算法逻辑）。
（3）输出要求：需打印两个关键信息
① 实际找零金额；
② 最优硬币组合（格式如 “20+10+5+1”）及总硬币数（如 “共 4 枚”）。
2. 程序分析
（1）变量初始化：
price/payment：通过input()获取用户输入，用int()转换为整数，分别存储商品价格和支付金额；change：计算并存储原始找零金额（change = payment - price），用于最终输出（避免后续计算修改原始值）；left：存储实时剩余待找零金额（初始值等于change），后续循环中会逐渐递减至 0，避免修改change；coins = [20, 10, 5, 1]：按从大到小顺序存储硬币面额，核心逻辑是 “优先用大面额硬币”，确保总硬币数最少；combination：空列表，用于存储最终的硬币组合（存储为字符串类型，方便后续用 “+” 拼接）。
（2）循环逻辑（贪心算法实现）：
- 外层
for coin in coins：遍历每种面额的硬币，从 20 元开始依次处理； - 内层
while left >= coin：只要剩余待找零金额left大于等于当前硬币面额，就用该面额硬币找零
① left -= coin：剩余金额减去当前面额；
②combination.append(str(coin))：将当前面额转为字符串存入组合列表，直到 left 小于当前面额，再切换到下一个小面额硬币。
3. 代码
price = int(input("请您输入商品价格（整数，0 < price < 100）："))
payment = int(input("请您输入支付金额（整数，payment ≥ price）："))
change = payment - price
left = change
coins = [20,10,5,1]
combination = []
for coin in coins:
while left >=coin:
left -= coin
combination.append(str(coin))
print(f"找零{change}元")
print(f"最优组合为 {'+'.join(combination)}（共 {len(combination)} 枚）")
4. 运行结果示例
五、编写程序实现简易 ATM 机操作功能
初始化账户信息：余额（如 1000 元）、当前账号；
主菜单阶段：用 while True 循环持续显示选项，用户输入选项后，用 if/elif 分支执行对应功能；
各功能逻辑：
存款 / 取款 / 转账：用 if 判断输入金额是否为正整数（简化处理，假设输入合法），取款 / 转账需额外判断金额≤余额；
转账需验证目标账号非空（if target_account.strip() == ""）；
输入 “退出” 时，用 break 退出主循环，程序结束。
1. 题目分析
（1）登录验证需求：
- 预设固定账号（
"123456"）和密码（"654321"）； - 允许最多 3 次输入错误，若连续 3 次错误则锁定 ATM 机（直接退出程序）；
- 仅登录成功后，才能进入主菜单操作。
（2）主菜单功能需求：登录成功后显示 5 个操作选项：1.查询余额、2.存款、3.取款、4.转账、5.退出，且用 while 循环控制主菜单持续运行，仅输入 “退出”（对应选项 5）时结束程序。
（3）核心功能规则：
- 查询余额：直接显示当前账户余额（初始余额预设为 1000 元）；
- 存款：输入正整数金额，余额随存款金额累加，存款后显示更新后的余额；
- 取款：输入正整数金额，需先判断 “金额是否 ≤ 余额”，若余额不足则提示 “余额不足”，否则余额递减并显示更新后余额；
- 转账：需先输入目标账号（判断非空，空则提示 “目标账号不能为空”），再输入正整数金额；金额需 ≤ 余额（不足则提示），转账后余额递减并显示更新后余额；
- 退出：选择该选项时，提示 “程序结束” 并退出主菜单循环，最终结束程序。
2. 程序分析
（1）变量初始化：
account = "123456"/passwd = "654321"：存储预设的正确账号和密码；chance = 3：记录登录剩余尝试次数（初始为 3 次）；balance = 1000：存储账户初始余额（固定为 1000 元，后续随操作更新）。
（2）登录阶段逻辑（外层 while 循环）：
- 循环条件
while chance > 0：仅剩余尝试次数 > 0 时，允许输入账号密码； - 输入判断：通过
input()获取用户输入的账号（user_input_accout）和密码（user_input_passwd），对比预设值：- 若匹配：提示 “登录成功”，进入主菜单循环；
- 若不匹配：
chance -= 1（次数减 1），提示剩余次数；
- 次数耗尽处理：
while循环的else分支（当chance减至 0 时触发），提示 “错误次数过多，锁已锁定”，用exit()强制退出程序。
（3）主菜单阶段逻辑（内层 while True 循环）：
- 菜单显示：每次循环先打印 “主菜单” 标题和 5 个操作选项，引导用户选择；
- 选项处理（
if/elif分支）：- 选项 1（查询余额）：直接打印
balance的当前值； - 选项 2（存款）：
input()获取存款金额（转为整数），balance += save更新余额，打印结果； - 选项 3（取款）：先判断金额是否 > 余额（是则提示 “余额不足”），否则
balance -= amount更新余额，打印结果； - 选项 4（转账）：先判断目标账号是否为空（
target.strip() == ""），空则提示；非空则输入转账金额，判断余额是否足够，足够则更新余额并打印结果； - 选项 5（退出）：提示 “程序结束”，用
break跳出主菜单循环，程序随外层登录循环结束而终止。
- 选项 1（查询余额）：直接打印
3. 代码
account = "123456"
passwd = "654321"
chance = 3
balance = 1000
while chance > 0:
user_input_accout = input("请输入账号：")
user_input_passwd = input("请输入密码：")
if user_input_accout == account and user_input_passwd == passwd:
print("登录成功")
while True:
print("----------------主菜单-----------------")
print("1.查询余额 2.存款 3.取款 4.转账 5.退出")
choice = input("请选择操作：")
if choice == "1":
print(f"当前余额：{balance}元")
elif choice == "2":
save = int(input("请输入存款金额："))
balance +=save
print(f"存款成功，当前余额：{balance}元")
elif choice == "3":
amount = int(input("请输入取款金额："))
if amount > balance:
print("余额不足")
elif amount > 0:
balance -= amount
print(f"取款成功，当前余额：{balance}元")
elif choice == "4":
target = input("请输入目标账号：")
if target.strip() == "":
print("目标账号不能为空")
else:
amount = int(input("请输入转账金额："))
if amount > balance:
print("余额不足")
elif amount > 0:
balance -= amount
print(f"转账成功，当前余额：{balance}元")
elif choice == "5":
print("程序结束")
break
else:
chance -= 1
print(f"账号或密码错误，剩余{chance}次机会")
else:
print("错误次数过多，锁已锁定")
exit()
4. 运行结果示例
六、编写程序实现猜数字游戏功能
程序随机生成1-20的整数作为答案，玩家有5次猜测机会，规则如下：
用for循环控制5次猜测机会，每次输入猜测的数，
若猜对，打印“恭喜！第x次猜对了”并提前结束游戏；
若猜错，提示“猜大了”或“猜小了”，并显剩余次数；
5次都猜错，打印“游戏结束，正确答案是xx”。
1. 题目分析
（1）核心规则：程序随机生成 1-20 之间的整数作为 “答案”，玩家拥有 5 次猜测机会，通过 for 循环严格控制猜测次数。
（2）交互逻辑：
- 每次猜测：玩家输入一个整数，程序对比输入值与答案；
- 猜对处理：打印 “恭喜！第 x 次猜对了”（x 为当前猜测次数，1-5），并提前结束游戏（终止循环）；
- 猜错处理：提示 “猜大了” 或 “猜小了”，同时显示剩余猜测次数（如第 1 次猜错，剩余 4 次）；
- 次数耗尽：若 5 次均猜错，打印 “游戏结束，正确答案是 xx”（xx 为随机生成的答案）。
（3）技术要求：需使用 random 模块生成随机答案，用 for 循环控制次数，通过 if/elif/else 判断猜测结果。
2. 程序分析
（1）随机答案生成：通过 random.randint(1,20) 生成 1-20 范围内的整数，赋值给 answer，确保每次运行游戏答案不同。
（2）循环控制：for i in range(1,6) 构建循环，i 表示当前猜测次数（从 1 到 5，共 5 次机会），无需额外计数变量。
（3）输入与判断逻辑：
- 输入处理：
int(input(f"第{i}次猜："))获取玩家输入，转为整数类型（假设输入合法，聚焦核心逻辑）； - 猜对判断：若
user_guess_input == answer，打印恭喜信息，用break终止for循环，提前结束游戏； - 猜错判断：
- 输入 > 答案：提示 “猜大了”，剩余次数为
5 - i（如第 3 次猜，剩余5-3=2次）； - 输入 <答案：提示 “猜小了”，剩余次数计算方式同上；
- 输入 > 答案：提示 “猜大了”，剩余次数为
（4）次数耗尽处理：for 循环的 else 分支（仅当循环未被 break 中断时执行，即 5 次均猜错），打印游戏结束信息和正确答案。
3. 代码
import random
answer = random.randint(1,20)
for i in range(1,6):
user_guess_input = int(input(f"第{i}次猜："))
if user_guess_input == answer:
print(f"恭喜！第{i}次猜对了")
break
elif user_guess_input > answer:
print(f"猜大了，剩余{5-i}次机会")
else:
print(f"猜小了，剩余{5-i}次机会")
else:
print(f"游戏结束，正确答案是{answer}")4. 运行结果示例
七、编写程序实现星号菱形打印功能（嵌套 for 循环版）
输入一个正整数 k（k 为奇数，3≤k≤7）， 使用 嵌套 for 循环 打印由星号（*）组成的菱形， 菱形的对角线长度为 k。示例：输入 k=5，输出： * *** ***** *** *
1. 题目分析
（1）输入要求：需输入一个奇数 k，且 k 的取值范围限定为 3≤k≤7（保证菱形结构对称，对角线长度等于 k）。
（2）核心规则：使用嵌套 for 循环打印星号（*）组成的菱形，菱形的 “水平对角线” 和 “垂直对角线” 长度均为 k（中间行的星号数量等于 k，是菱形最宽的一行）。
（3）结构拆解：菱形可分为 “上半部分（含中间行）” 和 “下半部分” 两部分，上半部分星号数量逐行递增，下半部分星号数量逐行递减，且每行星号均居中显示（通过打印前置空格实现）。
2. 程序分析
（1）变量初始化：通过 input() 获取用户输入的奇数 k，转换为整数类型，作为菱形对角线长度的核心参数。
（2）上半部分打印逻辑（含中间行）：
- 行数计算：上半部分（含中间行）的行数为
upper_rows = (k + 1) // 2（如k=5时，(5+1)//2=3行；k=3时，(3+1)//2=2行）。 - 外层 for 循环：
for i in range(1, upper_rows + 1)控制上半部分的行数，i表示当前是上半部分的第i行。 - 内层空格循环：每行星号前的空格数为
spaces = (k - (2*i - 1)) // 2（2*i - 1是当前行的星号数量，用总长度k减去星号数，再除以 2，得到每行两侧对称的空格数，确保星号居中）；通过for _ in range(spaces)打印对应数量的空格。 - 内层星号循环：当前行的星号数量为
stars = 2*i - 1（第 1 行 1 个、第 2 行 3 个... 中间行k个，逐行递增 2）；通过for _ in range(stars)打印对应数量的星号。 - 换行处理：每行空格和星号打印完成后，执行
print()（无参数）实现换行，进入下一行。
（3）下半部分打印逻辑：
- 行数计算：下半部分的行数为
lower_rows = (k - 1) // 2（如k=5时，(5-1)//2=2行；k=3时，(3-1)//2=1行），比上半部分少 1 行（不含中间行）。 - 外层 for 循环：
for i in range(1, lower_rows + 1)控制下半部分的行数，i表示当前是下半部分的第i行。 - 内层空格循环：每行星号前的空格数为
spaces = i（第 1 行 1 个、第 2 行 2 个... 逐行递增 1，与上半部分空格数变化相反）；通过for _ in range(spaces)打印空格。 - 内层星号循环：当前行的星号数量为
stars = k - 2*i（从k-2开始，逐行递减 2，如k=5时，第 1 行 3 个、第 2 行 1 个）；通过for _ in range(stars)打印星号。 - 换行处理：同前，每行结束后执行
print()换行。
3. 代码
k = int(input("请输入一个奇数k（3≤k≤7）："))
# 打印上半部分（包括中间行）
upper_rows = (k + 1) // 2
for i in range(1, upper_rows + 1):
# 打印每行的空格
spaces = (k - (2 * i - 1)) // 2
for _ in range(spaces):
print(" ", end="")
# 打印每行的星号
stars = 2 * i - 1
for _ in range(stars):
print("*", end="")
print() # 换行，进入下一行
# 打印下半部分
lower_rows = (k - 1) // 2
for i in range(1, lower_rows + 1):
# 打印每行的空格
spaces = i
for _ in range(spaces):
print(" ", end="")
# 打印每行的星号
stars = k - 2 * i
for _ in range(stars):
print("*", end="")
print() # 换行，进入下一行4. 运行结果示例
原文地址：https://blog.csdn.net/2302_79970768/article/details/153046411
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！