25道Python练手题（附详细答案），赶紧收藏！Python入门|Python学习
题目 1：水仙花数
水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number）
水仙花数是指一个 3 位数，它的每个位上的数字的 3 次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。
for i in range(100, 1000):
i1 = i // 100 # 取百位数字 123//100=1
i2 = i // 10 % 10 # 取十位数字 123//10=12 12%10=2
i3 = i % 10 # 取个位数字 123%10=3
if i1 ** 3 + i2 ** 3 + i3 ** 3 == i:
print(f"{i}是水仙花数")
# 153 是水仙花数
# 370 是水仙花数
# 371 是水仙花数
# 407 是水仙花数
题目 2：四叶玫瑰数
四叶玫瑰数是 4 位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。
（例如：当 n 为 3 时，有 1^3 + 5^3 + 3^3 = 153，153 即是 n 为 3 时的一个自幂数，3 位数的自幂数被称为水仙花数）。
for i in range(1000,10000):
i1 = i // 1000 # 取千位数字 1234//1000=1
i2 = i // 100 % 10 # 取百位数字 1234//100=12 12%10=2
i3 = i // 10 % 10 # 取十位数字 1234//10=123 123%10=3
i4 = i % 10 # 取个位数字 1234%10=4
# print(i,i1,i2,i3,i4)
if i1 ** 4 + i2 ** 4 + i3 ** 4 + i4 ** 4 == i:
print(f'{i}是四叶玫瑰数')
# 1634 是四叶玫瑰数
# 8208 是四叶玫瑰数
# 9474 是四叶玫瑰数
题目 3：逆序输出字符串
- 写法 1：切片方式
str = input("请输入字符串") print(str[::-1])- 写法 2：循环转换
str = input("请输入字符串") list = [] for x in range(len(str) -1,-1,-1): list.append(str[x]) print(''.join(list))题目 4：猜数字小游戏
需求分析：
随机生成一个 100 以内的整数，共有 10 次机会开始游戏，输入猜测的数字。
-
如果猜小了，则提示：猜小了
-
如果猜大了，则提示：猜大了
-
猜对了，则提示：猜对了，并且结束游戏
-
10 次机会用完还没猜对，提示：游戏结束，没有猜到。
import random as rd number = rd.randint(0,100) for i in range(10): choice = int(input("请输入你要猜测的数字：")) if choice > number: print("你猜大了") elif choice题目 5：百鸡百钱
需求分析：
公鸡每只 5 元，母鸡每只 3 元，小鸡 3 只一元，现要求用 100 元钱买 100 只鸡(三种类型的鸡都要买)，问公鸡、母鸡、小鸡各买几只?
数学方程：
-
设公鸡买了 x 只，母鸡买了 y 只，小鸡买了 z 只
-
x+y+z= 100
-
5x+3y+z/3 = 100
算法思路
-
以公鸡为突破点，公鸡 5 元一只，100 元最多只能买 20 只，
-
由于三种鸡都要买，所以公鸡数一定是小于 20 的。
-
母鸡每只 3 元，100 全拿来买母鸡，最多也不能超过 33 只
-
设公鸡数为 x，母鸡数为 y，小鸡 z 只
-
只要满足 5x+3y+z/3=100 和 x+y+z==100 就可以输出此种组合的结果.
count = 0 for x in range(1,20): for y in range(1,33): z = 100 - x -y if z > 0 and 5 * x + 3 * y + z / 3 == 100: count += 1 print("="*60) print(f'第{count}种买法，公鸡买了{x}只，母鸡买了{y}只，小鸡买了{z}只') # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第1种买法，公鸡买了4只，母鸡买了18只，小鸡买了78只 # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第2种买法，公鸡买了8只，母鸡买了11只，小鸡买了81只 # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第3种买法，公鸡买了12只，母鸡买了4只，小鸡买了84只题目 6：闰年问题升级版
输入年月日，输出该日期是否是闰年，并且输出该日期是此年份的第几天
闰年判断条件：
-
能被 4 整除，并且不能被 100 整除
-
能被 400 整除
-
两个条件满足任意一个就为闰年
算法思路：
-
接收用户输入的年月日，创建保存 12 个月份天数的列表
-
根据年份判断是否是闰年，如果是把二月份设为 29 天，否则把二月份设为 28 天
-
根据月份和日期统计是当年的第几天
year = int(input("请输入年份")) month = int(input("请输入月份")) day = int(input("请输入日期")) date_list = [31,29,31,30,31,30,31,31,30,31,30,31] count_day = day if year % 4 == 0 and year % 100 !=0 or year % 400 == 0: print(f'{year}年是闰年') date_list[1]=29 else: print(f'{year}年是平年') date_list[1]=28 for i in range(month-1): count_day += date_list[i] print(f'{year}年{month}月{day}日是当年的第{count_day}天')题目 7：猴子吃桃问题
需求分析：
-
猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。
-
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
-
以后每天早上都吃了前一天剩下的一半零一个。到第 10 天早上想再吃时，见只剩下一个桃子了。
-
求原来它一共摘了多少个桃子。
这题可以用递归思想倒着推。
-
第 10 天还没吃，就剩 1 个，说明第 9 天吃完一半再吃 1 个还剩 1 个。
-
假设第 9 天还没吃之前有桃子 p 个
-
可得：p/2 - 1 = 1，得出第九天的桃子数 p=4。
-
以此类推，即可算出第一天摘了多少桃子.
算法思路：
-
第 10 天还没吃之前的桃子数量初始化 p=1
-
从 9 至 1 循环 9 次，根据上述公式反推为 p=(p+1)*2 可得第 1 天还没吃之前的桃子数量
p = 1 print(f'第10天还剩下{p}个桃子') for i in range(9,0,-1): p = (p + 1) * 2 print(f'第{i}天还剩下{p}个桃子') print(f'第一天一共摘了{p}个桃子') # 第10天还剩下1个桃子 # 第9天还剩下4个桃子 # 第8天还剩下10个桃子 # 第7天还剩下22个桃子 # 第6天还剩下46个桃子 # 第5天还剩下94个桃子 # 第4天还剩下190个桃子 # 第3天还剩下382个桃子 # 第2天还剩下766个桃子 # 第1天还剩下1534个桃子 # 第一天一共摘了1534个桃子题目 8：冒泡排序
冒泡排序算法由来：这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”
从前到后(即从下标较小的元素开始) 依次比较相邻元素的值，若发现比后一个值大则交换位置，使值较大的元素逐渐从前移向后部。
假设有一个列表 [29 ,12 ,19 ,37 ,14] 想按升序排列
第一轮：初始列表为 [29 ,12 ,19 ,37 ,14]
-
比较 29 > 12 交换位置：[12,29,19,37,14]
-
比较 29 > 19 交换位置：[12,19,29,37,14]
-
比较 29 > 37 不大于，不交换：列表同上不变
-
比较 37 > 14 交换位置：[12,19,29,14,37]
第二轮：列表继承上一轮为 [12,19,29,14,37]
-
比较 12 > 19 不大于，不交换：列表同上不变
-
比较 19 > 29 不大于，不交换：列表同上不变
-
比较 29 > 14 交换位置：[12,19,14,29,37]
第三轮：列表继承上一轮为 [12,19,14,29,37]
-
比较 12 > 19 不大于，不交换：列表同上不变
-
比较 19 > 14 交换位置：[12,14,19,29,37]
第四轮：列表继承上一轮为 [12,14,19,29,37]
-
比较 12 > 14 不大于，不交换：列表同上不变
-
列表排序完成：[12,14,19,29,37]
import numpy as np pop_list = np.random.randint(100,size=6) # pop_list = [82,15,15,41,37,31] # pop_list = [29,12,19,37,14] count = len(pop_list) print('没排序之前的列表',pop_list) for i in range(count-1): for j in range(count-i-1): if pop_list[j] > pop_list[j + 1]: # 如果要降序就是改成题目 9：二分查找法
二分法是一种效率比较高的搜索方法
回忆之前做过的猜数字的小游戏，预先给定一个小于 100 的正整数 x，让你猜，猜测过程中给予大小判断的提示，问你怎样快速地猜出来？我们之前做的游戏给定的是 10 次机会，如果我们学会二分查找法以后，不管数字是多少，最多只需要 7 次就能猜到数字
- 二分查找法
首先先猜 50，如果猜对了，结束；如果猜大了，往小的方向猜，再猜 25；如果猜小了，往大的方向猜，再猜 75；…每猜测 1 次就去掉一半的数，这样我们就可以逐步逼近预先给定的数字.这种思想就是二分法。
二分法适用情况
-
必须是有序的序列。
-
对数据量大小有要求。
-
数据量太小不适合二分查找，与直接遍历相比效率提升不明显。
-
数据量太大也不适合用二分查找，因为数组需要连续的存储空间，若数据量太大，往往找不到存储如此大规模数据的连续内存空间
算法思路：
假设有一个有序列表：[5,7,11,22,27,33,39,52,58]
请问数字 11 是否在此列表中，如果在它的索引值为多少？
-
首先我们取有序列表的中间位置 27 和 11 进行比较 我们发现 11 是小于 27 的
-
所以我们排除 27 右边的数字，保留列表为：[5,7,11,22]
-
接着我们取 [5,7,11,22] 位置中间的 7 和 11 比较 发现 11 是大于 7 的 所以我们排除 7 左边的数字，保留列表为：[11,22]
-
最后我们取 11 和 22 的中间位置
-
刚好到了 11 这时候就可以返回 11 的索引值了，如果没有找到就提示不存在
第1种 纯算法的方式
arr_list = [5,7,11,22,27,33,39,52,58] number = 11 count = 0 left = 0 right = len(arr_list)-1 while left arr_list[middle]: left = middle +1 elif number第2种 递归函数的方式
arr_list = [5,7,11,22,27,33,39,52,58] def binary_search(number,left,right): if left arr_list[middle]: left = middle + 1 else: return middle return binary_search(number,left,right) else: return -1 print(binary_search(11,0,len(arr_list)-1))题目 10：选择排序
基本思想：从未排序的序列中找到一个最小的元素，放到第一位，再从剩余未排序的序列中找到最小的元素，放到第二位，依此类推，直到所有元素都排序完毕
-
若列表为 [6, 8, 3, 5, 9, 10, 7, 2, 4, 1],先找到 1 最小 调换到第 1 个位置
-
得到列表[1, 8, 3, 5, 9, 10, 7, 2, 4, 6]，接着是 2 最小 调换到第 2 个位置
-
得到列表[1, 2, 3, 5, 9, 10, 7, 8, 4, 6]，接着是 3 最小 位置不变
-
得到列表[1, 2, 3, 5, 9, 10, 7, 8, 4, 6]，接着是 4 最小 调换到第 4 个位置
-
得到列表[1, 2, 3, 4, 9, 10, 7, 8, 5, 6]，接着是 5 最小 调换到第 5 个位置
-
得到列表[1, 2, 3, 4, 5, 10, 7, 8, 9, 6]，接着是 6 最小 调换到第 6 个位置
-
得到列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，接着是 7 最小 位置不变
-
得到列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，接着是 8 最小 位置不变
-
得到列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，接着是 9 最小 位置不变
-
得到列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，接着是 10 最小 位置不变，排序完成
import random as rd sec_list = [rd.randint(1,100) for i in range(8)] # sec_list = [91,30,93,98,26,98,20,90] length = len(sec_list) print(f'未排序的列表为：{sec_list}') for i in range(length -1): min_index = i for j in range(i + 1,length): if sec_list[min_index] > sec_list[j]: min_index = j sec_list[min_index],sec_list[i] = sec_list[i],sec_list[min_index] print(f'第{i+1}轮排好序是：{sec_list}') print(f'最终排好序的列表为：{sec_list}') # 未排序的列表为：[91, 30, 93, 98, 26, 98, 20, 90] # 第1轮排好序是：[20, 30, 93, 98, 26, 98, 91, 90] # 第2轮排好序是：[20, 26, 93, 98, 30, 98, 91, 90] # 第3轮排好序是：[20, 26, 30, 98, 93, 98, 91, 90] # 第4轮排好序是：[20, 26, 30, 90, 93, 98, 91, 98] # 第5轮排好序是：[20, 26, 30, 90, 91, 98, 93, 98] # 第6轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98] # 第7轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98] # 最终排好序的列表为：[20, 26, 30, 90, 91, 93, 98, 98]题目 11：剪刀石头布
-
游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
-
当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
-
当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
-
1 代表剪刀 2 代表石头 3 代表布
import random as rd print('=' * 60) print(' ' * 20, '剪刀石头布游戏') print('1代表剪刀 2代表石头 3代表布') game_info = {1: "剪刀", 2: "石头", 3: "布"} score = 100 while True: robots_choice = rd.randint(1, 3) user_choice = input("请出拳") if user_choice not in '123': print('出拳错误，请重新出拳') continue user_choice = int(user_choice) print('*' * 60) print(f'电脑出{game_info[robots_choice]}') print(f'你出{game_info[user_choice]}') print('*' * 60) if user_choice == 1 and robots_choice == 3 or user_choice == 2 \ and robots_choice == 1 or user_choice == 3 and robots_choice == 2: score += 10 print(f'你赢得本轮游戏，当前分数为{score}') elif user_choice == robots_choice: print(f'本轮游戏平局，当前分数为{score}') else: score -= 10 print(f'你输了本轮游戏，当前分数{score}') if score >= 200: print('游戏结束，你赢得比赛') break elif score 5 # 递归前-> 4 # 递归前-> 3 # 递归前-> 2 # 递归前-> 1 # 递归后-> 1 # 递归后-> 2 # 递归后-> 3 # 递归后-> 4 # 递归后-> 5题目 20：斐波那契递归函数
斐波那契数列(Fibonacci sequence)，又称黄金分割数列，因数学家莱昂纳多·斐波那契(Leonardo Fibonacci)以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、…
这个数列，前两项都是数字 1，从第三项开始，每一项数字是前两项数字之和
数学表达式：f(n) = f(n-1)+f(n-2)
def fib(n): if n b: max_num = a else: max_num = b if max_num题目 22：因子之和“完数”
-
什么是因子？因子就是所有可以整除这个数的数字，包括 1 但不包括这个数自身。比如 8 的因子有 1，2，4
-
什么是完数？一个数如果恰好等于它的因子之和，这个数就称为“完数”，打印输出 1000 以内的完数，例如 6=1+2+3，6 就是“完数
def factor_sum(n): s_sum = 0 for i in range(1, n): if n % i == 0: s_sum += i return s_sum for j in range(1, 1000): if j == factor_sum(j): print(j) # 6 # 28 # 496题目 23：递归阶乘求和
一个正整数的阶乘(factorial)是所有小于及等于该数的正整数之积，并且 0 的阶乘为 1
如 5!=1_2_3_4_5 计算 1!+2!+3!+4!+5!+…+10! 数学表达式：f(n) = n*f(n-1)：
def factor(n): if n题目 24：有效的括号
给定一个只包括’(‘，’)‘，’{‘，’}‘，’[‘，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
-
左括号必须用相同类型的右括号闭合
-
左括号必须以正确的顺序闭合
-
空字符串可被认为是有效字符串
-
示例 1：
输入：“()”
输出：True
- 示例 2：
输入：“()[]{}”
输出：True
- 示例 3：
输入：“(]”
输出：False
- 示例 4：
输入：“([)]”
输出：False
- 解法一：字符串替换法 在字符串中找成对的()、[]、{}，找到后替换成空 使用 while 循环，不停判断是否存在成对的小括号中括号大括号，如果存在就使用 replace 替换成空 直到无法再替换的时候，再判断下当前的字符串是否为空，如果为空说明字符串是有效的，如果不为空说明字符串是无效的
def valid_str(string): if len(string) % 2 == 1: return False while '()' in string or '[]' in string or '{}' in string: string = string.replace('()', '') string = string.replace('[]', '') string = string.replace('{}', '') return string == '' print(valid_str('()')) # True print(valid_str('()[]{}')) # True print(valid_str('()[]{[()]}')) # True print(valid_str('()[]{[(}]}')) # False- 解法二：利用栈的后进先出原则 先去定义一个空栈，对当前栈进行循环遍历，遇到左括号我们就把当前的左括号添加到栈里面，遇到右括号，我们就和栈顶元素进行比对 看它们是不是成对的括号，如果是，就把当前的元素出栈，直到字符串遍历结束之后，我们再来看下字符串是不是空的，如果是空的说明字符串是有效的，如果不为空说明字符串是无效的
def valid_str(string): if len(string) % 2 == 1: return False stack = [] char_dict = { ')': '(', '}': '{', ']': '[' } for char in string: if char in char_dict: # 右括号 if not stack or char_dict[char] != stack.pop(): return False else: # 左括号 stack.append(char) return not stack print(valid_str('(){}[({[]})]')) # True print(valid_str('(){}[({[)})]')) # False print(valid_str('')) # True题目 25：回文数的两种解法
回文数是指正序(从左向右)和倒序(从右向左)都是一样的整数。例如，1221 是回文，而 1222 不是。
- 解法一：通过逆转字符串进行比对
def is_palindrome(x): if x 0 and x % 10 == 0: return False str_x = str(x) return str_x == str_x[::-1] print(is_palindrome(121)) # True print(is_palindrome(120)) # False- 解法二：反转一半数字和前半部分的数字进行比较
流程
-
对于整数 x，将后半部分反转，保存到变量 reverted
-
每次循环 x%10 拿到末尾数字
-
然后 x/10 去除末尾的数字
-
循环结束条件 x 0 and x % 10 == 0: return False reverted = 0 while x > reverted: # 我们看下 1221 # 第一次循环我们需要把末尾数字1取出来 第二次取末尾数字2 我们需要把21变成12 reverted = reverted * 10 + x % 10 # 把x的末尾数字删除掉 x //= 10 return x == reverted or x == reverted // 10 print(is_palindrome(1221)) # True print(is_palindrome(1223)) # False print(is_palindrome(123321)) # True
希望这篇文章对正在学习编程的你有所帮助，如果你想学习编程，那给大家分享一份Python学习资料，里面的内容都是适合零基础小白的笔记和资料，不懂编程也能听懂、看懂。如果需要的话直接划到文末免费获得，让我们一起学习！
如果你也想和我一起学习Python，欢迎关注我留个言
-
- 解法二：反转一半数字和前半部分的数字进行比较
- 解法一：通过逆转字符串进行比对
- 解法二：利用栈的后进先出原则 先去定义一个空栈，对当前栈进行循环遍历，遇到左括号我们就把当前的左括号添加到栈里面，遇到右括号，我们就和栈顶元素进行比对 看它们是不是成对的括号，如果是，就把当前的元素出栈，直到字符串遍历结束之后，我们再来看下字符串是不是空的，如果是空的说明字符串是有效的，如果不为空说明字符串是无效的
- 解法一：字符串替换法 在字符串中找成对的()、[]、{}，找到后替换成空 使用 while 循环，不停判断是否存在成对的小括号中括号大括号，如果存在就使用 replace 替换成空 直到无法再替换的时候，再判断下当前的字符串是否为空，如果为空说明字符串是有效的，如果不为空说明字符串是无效的
- 示例 4：
- 示例 3：
- 示例 2：
-
-
-
-
-
-
- 二分查找法
-
-
-
-
-
-
-
-
-
-
-
-
- 写法 2：循环转换
