25道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 } for i in words: if i in word_dict: word_dict[i] += 1 else: word_dict[i] = 1 max_key = max(word_dict,key=word_dict.get) print(max_key) print(word_dict[max_key]) # l # 3 analyse_words('helloworld')h5font color="Red"题目 18：利用栈打印菱形/font/h5 p输入边长 n，打印对应边长的菱形/p h6分析：/h6 ulli打印几行/lili每一行打印几个空格，几个星星/lili前几行打印之前加入到栈，利用栈的后进先出原则打印后几行的内容 pre class="brush:python;toolbar:false"def diamond(n): stack = [] for i in range(1, 2 * n): if i = n: p_str = ' ' * (n - i) + '*' * (2 * i - 1) if i != n: stack.append(p_str) print(p_str) else: print(stack.pop()) diamond(5) # 为了区分我把空格换成了点 # ....* # ...*** # ..***** # .******* # ********* # .******* # ..***** # ...*** # ....* /pre h5font color="Red"题目 19：深入理解递归函数/font/h5 ulli什么是递归函数？递归函数就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。/lili需要注意：递归函数必须有结束条件。 h6设计递归函数三要素：/h6 ulli明确你这个函数想要干什么/lili寻找递归结束条件/lili找出函数的等价关系式 pre class="brush:python;toolbar:false"def p(n): if n == 0: return print('递归前-',n) p(n-1) print('递归后-',n) p(5) # 递归前-> 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所有方向的学习路线图，清楚各个方向要学什么东西
- ② 100多节Python课程视频，涵盖必备基础、爬虫和数据分析
- ③ 100多个Python实战案例，学习不再是只会理论
- ④ 华为出品独家Python漫画教程，手机也能学习
可以扫描下方二维码领取【保证100%免费】
- 最后这里免费分享给大家一份Python全套学习资料，希望能帮到那些不满现状，想提升自己却又没有方向的朋友，也可以和我一起来学习交流呀。
- 最后希望你编程学习上不急不躁,按照计划有条不紊推进,把任何一件事做到极致,都是不容易的,加油,努力！相信自己！
- 回文数是指正序(从左向右)和倒序(从右向左)都是一样的整数。例如，1221 是回文，而 1222 不是。
- 解法二：利用栈的后进先出原则 先去定义一个空栈，对当前栈进行循环遍历，遇到左括号我们就把当前的左括号添加到栈里面，遇到右括号，我们就和栈顶元素进行比对 看它们是不是成对的括号，如果是，就把当前的元素出栈，直到字符串遍历结束之后，我们再来看下字符串是不是空的，如果是空的说明字符串是有效的，如果不为空说明字符串是无效的
- 解法一：字符串替换法 在字符串中找成对的()、[]、{}，找到后替换成空 使用 while 循环，不停判断是否存在成对的小括号中括号大括号，如果存在就使用 replace 替换成空 直到无法再替换的时候，再判断下当前的字符串是否为空，如果为空说明字符串是有效的，如果不为空说明字符串是无效的
- 给定一个只包括’(‘，’)‘，’{‘，’}‘，’[‘，’]’ 的字符串，判断字符串是否有效。
- 首先先猜 50，如果猜对了，结束；如果猜大了，往小的方向猜，再猜 25；如果猜小了，往大的方向猜，再猜 75；…每猜测 1 次就去掉一半的数，这样我们就可以逐步逼近预先给定的数字.这种思想就是二分法。
- 回忆之前做过的猜数字的小游戏，预先给定一个小于 100 的正整数 x，让你猜，猜测过程中给予大小判断的提示，问你怎样快速地猜出来？我们之前做的游戏给定的是 10 次机会，如果我们学会二分查找法以后，不管数字是多少，最多只需要 7 次就能猜到数字
- 写法 2：循环转换
- 写法 1：切片方式
免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们。
