python编程实例50例

python编程实例50例.md2022/12/31python编程实例汇总前言本实例题目均来自网络，题目中涉及的所有代码都经过测试，注释完备，此文档会持续更新。编辑环境:python版本：python.10.2编辑器：Visual Studio Code01. 输出hello world题目: 输出hello world 这是所有编程的开始，向这个世界问好print("hello world")

02. 输出两个数字的和题目: 输出两个数字的和# 输入两个数字

num1 = input("请输入第一个数字: ")

num2 = input("请输入第二个数字: ")

# 计算两个数字的和

num_sum = float(num1) + float(num2)

# 输出两个数字的加和，浮点型

print(f"浮点数之和: {num1} + {num2} = {num_sum:0.2f}")

# 输出两个数和，整形

print(f"整形之和: {num1} + {num2} = {int(float(num1)) + int(float(num2))}")

# 不对input接收的数据进行转换，输出的就是两个数字的拼接

print(f"字符串拼接 {num1} + {num2} = {num1 + num2}")

03. 输出数字的平方根题目: 输出数字的平方根import math

# 输入两个数字

num1 = float(input("请输入一个数字: "))

/

python编程实例50例.md2022/12/31

# # 计算数字的平方根

num_sqrt = num1 ** 0.5

num_sqrt1 = (num1)

# 输出数字的平方根，浮点型，精确到小数点后2位

print(f"用**计算数字 {num1} 的平方根为: {num_sqrt:0.2f}")

print(f"用math模块计算数字 {num1} 的平方根为: {num_sqrt1:0.2f}")

04. 求三角形的面积题目: 求三角形的面积(海伦公式)"""

假设: 三角形三边为: a, b, c,

根据海伦—秦九韶公式: √￣p(p-a)*(p-b)*(p-c), 其中:p = (a + b + c)/2 可计算出面积

"""import math

""" 获取用户输入的三边长度 """

a, b, c = float(input("请输入三角形a边长度: ")), float(input('请输入三角形b边的长度: ')), float(input("请输入三角形c边的长度: "))

# 计算P值

p = (a + b + c) / 2

# 计算面积方法一

trangleArea = (p*(p-a)*(p-b)*(p-c))

# 计算面积方法二

trangleArea2 = (p*(p-a) * (p-b) * (p-c)) ** 0.5

print(f'用math函数计算的三角形面积：{trangleArea:0.2f}')

print(f'用**计算的三角形面积：{trangleArea2:0.2f}')

05. 求圆的面积题目: 求圆的面积# 圆形的面积计算公式只有一种：Π(r*r)# 其中: Π = 3.14, r就是圆的半径需要用户输入

from math import pi

# 接收用户输入的半径

r = float(input("请输入圆形的半径: "))

pi_1 = 3.14

/

python编程实例50例.md2022/12/31# 计算圆的面积

circle_area = pi_1 * (r**2)

# 计算圆的面积

circle_area2 = pi * (r ** 2)

print(f'用pi=3.14计算圆的面积: {circle_area:0.2f}')

print(f'用计算圆的面积: {circle_area2:0.2f}')

06. 摄氏度转华氏度题目: 摄氏温度转华氏温度

celsius = float(input("请输入摄氏度°C: "))

fahrenheit = 32 + celsius * 1.8

print(f'{celsius}°C 转换为华氏温度为: {fahrenheit:0.2f}')

07. 判断奇偶数题目: 输入一个整数，判断是奇数还是偶数"""

奇数偶数定义:

偶数是能够被2所整除的整数。正偶数也称双数。

[1] 若某数是2的倍数，它就是偶数，可表示为2n；

[2] 若不是2的倍数，它就是奇数，可表示为2n+1（n为整数）

例如:

x % 2 == 0, 即：x为偶数

x % 2 != 0, 即: x为奇数

"""

number = int(input("请输入一个整数: "))

if number % 2 == 0:

print(f"您输入的整数 {number} 是一个偶数。")

else:

print(f"您输入的整数 {number} 是一个奇数。")

08. 判断正数题目: 判断一个整数，判断它的类型是否是正数、零、负数 /

python编程实例50例.md2022/12/31def example01(number):

"""接收一个整数，判断它的类型是否是正数、零、负数

Args:

number (int): 接收一个整数

Returns:

str: 返回这个整数的类型: 正数、零、负数

"""

res = ''

# 判断number 是否大于0

if number > 0:

# 大于零返回正数

res = '正数'

# 判断number 是否小于0

elif number < 0:

res = '负数'

# 如果number不大于0，也不小于0，那只能是0

else:

res = '零'

# 返回判断结果

return res

def example02(number):

res = ''

# 判断number是否不等于0

if number != 0:

# 判断number 是否大于0

if number > 0:

res = '正数'

# 如果number不大于0走这里

else:

res = '负数'

# 等于零走这里

else:

res = '零'

# 返回判断结果

return res

09. 判断闰年题目: 输入一个年份，判断是否是闰年# 写法一def isLeapYear(year: int) -> bool:

"""判断输入的年份是否是闰年

如果是闰年返回：True

如果不是闰年返回: False

/

python编程实例50例.md2022/12/31

Args:

year (int): 接收用户年份

Returns:

bool: 返回布尔类型

"""

# 定义闰年标识，默认为false

res = False

# 判断year是否能被100和400整除, 如果能则修改res的值为True

if year % 400 == 0:

res = True

# 判断year是否能被4整除，不能被100整除, 如果能则修改res为True

elif year % 4 == 0 and year % 100 != 0:

res = True

# 返回判断结果

return res

# 写法二变种def isLeapYear01(year: int):

res = False

# 判断year是否能被4整除，不能被100整除 或者 判断year是否能被4整除，不能被100整除

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):

res = True

return res

# 写法三, 三目运算符def isLeapYear03(year):

return True if (year % 400 == 0) or ( year % 4 ==0 and year % 100 != 0)

else False10. 判断素数题目: 输入一个数字，判断是否为质数# 质数定义： 质数又称素数。一个大于1的整数中，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数（规定1既不是质数也不是合数）# 注意: 素数都是正整数# 质数判断： 1. 大于1， 2. 除了1和自身外不能被其他自然数整除

def isprime(num: int) -> bool:

"""判断数字是否是素数

如果是返回True,

如果不是返回False

Args:

num (int): 接收一个整数

Returns:

bool: 返回结果，True或False

"""

/

python编程实例50例.md2022/12/31 # 初始化结果

res = False

# 判断num是否是int类型且大于1

# 如果不符合不处理

if isinstance(num, int) and num > 1:

# 如果符合条件，进入遍历2~num

for i in range(2, num):

# 查看是否有能整除num的整数

if num % i == 0:

# 如果有整除num的整数则直接结束循环

break

# 如果没有整除num的整数则证明num是素数

else:

# 修改res为True

res = True

# 返回结果

return res

11. 获取区间内所有素数题目: 获取区间内所有的素数def primes(start_num: int, end_num: int) -> list:

"""获取区间内所有的素数, 这个只是实例，只编写核心代码

Args:

start_num (int): 开始数字

end_num (int): 结束数字

Returns:

list: 返回区间内所有素数列表

"""

# 定义一个数组num_list 存放所有的素数

num_list = []

# 循环遍历start_num~end_num整数,赋值给num

for num in range(start_num, end_num + 1):

# 判断num是否大于1，如果大于1继续执行，否则直接跳过

if num > 1:

# 循环遍历2~num,赋值给i

for i in range(2, num):

# 判断num 是否能整除 i 如果能整除则跳出循环

if num % i == 0:

# 跳出循环

break

# 如果所有遍历都执行完了没有跳出循环证明num是素数

else:

# 添加num到列表中

num_(num)

#返回数组

return num_list

/

python编程实例50例.md2022/12/31

# 引入素数判断模块from isprime import isprime

def primes01(start_num: int, end_num: int)->list:

"""获取区间内所有的素数，使用import引入素数的判断函数

实现代码分层

Args:

start_num (int): 开始数字

end_num (int): 结束数字

Returns:

list: 返回素数列表

"""

# 定义一个数组num_list 存放所有的素数

num_list = []

# 循环遍历start_num~end_num整数,赋值给num

for num in range(start_num, end_num + 1):

# 判断num是否是素数

if isprime(num):

# 如果数素数则添加到num_list中

num_(num)

# 返回素数列表

return num_list

12. 计算数字n的阶乘题目: 计算n的阶乘# 整数的阶乘（英语：factorial）是所有小于及等于该数的正整数的积，# 0的阶乘为1。即：n!=1×2×3×...×n。

def factorial(num: int) -> int:

"""求一个整数的阶乘

Args:

num (int): 接收一个整数类型

Raises:

ValueError: 判断接收的参数是否是数字类型且不能小于0

Returns:

int: 返回阶乘总数

"""

# 校验参数是否合法

if not isinstance(num, int) or num < 0:

# 不合法报异常，程序终止

raise ValueError("参数不正确，请输入一个大于等于0的整数")

/

python编程实例50例.md2022/12/31 # 初始化阶乘乘积

fac = 1

# 遍历每个因子，进行阶乘计算

for i in range(num):

fac *=(i + 1)

return fac

from functools import reduce

def factorial01(num: int) -> int:

"""求参数的阶乘

Args:

num (int): 接收一个参数的乘积

Raises:

ValueError: 校验参数的合法性

Returns:

int: 返回一个num的阶乘积

"""

# 校验参数是否合法

if not isinstance(num, int) or num < 0:

# 不合法报异常，程序终止

raise ValueError("参数不正确，请输入一个大于等于0的整数")

# reduce 是python内置函数, 在python.x中已经被移入functools模块中

# lambda 是匿名函数类关键字，可以理解这是一个函数,

# range(1, num + 1) 内置函数会生成一个[1, num+1)的整数序列,

return reduce(lambda x, y: x * y, range(1, num + 1))

def factorial02(num: int) -> int:

"""递归调用求一个数的阶乘

例如: 函数 factorial01(x) 用f(x) 表示

假设求5的阶乘

f(5) = 5 * f(4)

f(4) = 4 * f(3)

f(3) = 3 * f(2)

f(2) = 2 * f(1)

f(1) = 1 * f(0)

因为f(0) = 1

f(1) = 1 f(2) = 2 f(3) = 6 f(4) = 24 f(5) = 120

递归三要素:

a. 必须有一个基本结束条件(即最小规模问题的直接解决)

b. 递归算法必须改变状态

c. 递归算法必须调用自身

Args:

num (int): 接收用户输入的参数

/

python编程实例50例.md2022/12/31

Raises:

ValueError: 异常判断, 不允许输入非int类型和小于0的参数

Returns:

int: 返回num的阶乘积

"""

# 校验参数是否合法, 因为python默认递归深度是1000, 这个程序能输入的最大整数是997

if not isinstance(num, int) or num < 0 or num > 997 :

# 不合法报异常，程序终止

raise ValueError("参数不合法，请输入0-997的整数参数")

# 判断参数是否等于0

# 这个是基本结束条件

if num == 0:

# 参数为0直接返回1，因为0的阶乘为1

return 1

# 参数不为0，则递归乘积

else:

# 必须调用自身， num状态必须变化，否则程序会进入死循环

return num * factorial02(num - 1)

13. 九九乘法表题目: 打印九九乘法表说明: 代码中一共总结6中实现方法，这里只贴一种# 打印九九乘法表def multiplication():

"""打印九九乘法表 for-while

"""

# 循环遍历1, 9

# 因为range是左闭右开区间,所以代码中要写1, 10

for i in range(1, 10):

# 循环遍历1, i

for j in range(1, i+1):

# 打印乘积, i * j

print(f'{j} * {i} = {i * j}', end='t')

# 内循环结束, 换行

print()

14. 斐波那契数题目: 打印斐波那契额数列def fib_list(n: int):

"""

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,

特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。

"""

/

python编程实例50例.md2022/12/31 # 判断输入的数字是否是正整数

if n < 0 or not isinstance(n, int):

raise("请输入一个正整数")

# 初始化一个列表,存放数列，因为斐波那契数f(0) = 0, f(1) = 1,

# 因此，直接把0，1写入列表

fibo_list = [0, 1]

# 获取当前数列位数

count = len(fibo_list)

# 循环遍历，如果: count 小于等于 n,循环结束

while count <= n:

# fibo_list[count-2::] 这个是切片，就是把fibo_list后两位拿出来

# sum是python内置函数, 就是把数组内所有项相加，返回和

fibo = sum(fibo_list[count-2::])

# 将列表中倒数第一位，第二位相加，等于下一个斐波那契数

fibo_(fibo)

# count + 1, 进入下一轮循环

count += 1

# 返回数列

return fibo_list[1::] if n >= 1 else fibo_list[0:1]

15. 阿姆斯特朗数题目: 判断阿姆斯特朗数, 输出执行区间内的阿姆斯特朗数列def isArmstrongnumber(num: int) -> bool:

"""验证数字是否是阿姆斯特朗数

Args:

num (int): 要检测的整数

Returns:

bool: 返回True或者False

"""

# 初始化num位数，结果，临时变量, num所有位数之和

n, result, temp, sum = len(str(num)), False, num, 0

# 循环遍历，直到temp小于0结束

while temp > 0:

# num 每位的数字

digit = temp % 10

# num 每位数字的n平方相加

sum += digit ** n

# 去除已经计算的位数

temp //= 10

# 判断num是否和sum相等，如果相等就返回True

if num == sum:

result = True

return result

/

python编程实例50例.md2022/12/31def ArmstrongnumberList(start:int, end: int):

"""计算指定区间内的阿姆斯特朗数

Args:

start (int): 开始数

end (int): 结束数

Returns:

List: 返回区间内所有的阿姆斯特朗数组

"""

arm_list = []

for num in range(start, end + 1):

if isArmstrongnumber(num):

arm_(num)

return arm_list

16 求最大公因数题目: 求两个数的最大公因数def dcf(a:int, b:int) -> int:

"""计算两个数的最大公因数

Args:

a (int): 数字a

b (int): 数字b

Returns:

int: 返回最大公因数

"""

if not isinstance(a, int) and not isinstance(b, int):

raise ValueError("参数中存在非数字类型，请检查......")

# 获取a， b种最小的一个数字

smaler = a if a < b else b

# 初始化最小公倍数0

dcf = 0

# 遍历1 ~ smaler

for i in range(1, smaler + 1):

# 判断i 是否同时满足被a和b整除

if a % i == 0 and b % i == 0:

# 如果满足赋值给dcf

dcf = i

# 返回dcf

return dcf

题目: 求多个数的最大公因数 /

python编程实例50例.md2022/12/31def dcf1(*args) -> int:

"""求多个数字的最大公因数

Args:

*args 数量可变的位置参数，可以输入1个或多个任意参数

Returns:

int: 返回多个数字的最大公因数

"""

# 判断输入的参数是否都是数字

if not all(map(lambda x: isinstance(x, int), args)):

raise ValueError("输入的参数种存在非数字的值，请检查......")

# 获取输入参数中最小的一个值

smaler = min(args)

# 初始化最大公因数的值为0

dcf = 0

# 匿名函数，用于判断两个数是否可以整除

# 也可以将这个匿名函数抽离出去作为一个独立的函数

resl = lambda x: True if x[0] % x[1] == 0 else False

# 循环遍历1 ~ smaler

for i in range(1, smaler + 1):

# all python内置函数，

# 它以iterable作为参数，如果iterable的所有元素均为true或为空，则返回True

# map python内置函数,

# 函数是允许你使用一个函数转换整个可迭代对象, 这里也可以用for循环

if all(map(resl, [[x, i] for x in args])):

# 如果args中所有的数都能被i整除，则赋值给dcf

dcf = i

# 返回最大公约数

return dcf

17 求最小公倍数题目: 求a, b的最小公倍数# 两个或多个整数公有的倍数叫做它们的公倍数，# 其中除0以外最小的一个公倍数就叫做这几个整数的最小公倍数。# 整数a，b的最小公倍数记为[a，b]，同样的，a，b，c的最小公倍数记为[a，b，c]，多个整数的最小公倍数也有同样的记号。

"""

设计思路:

假设: 有两个数字 a, b 他们的最小公倍数是A

1. 那么主要满足 A%b == 0 且 A%a == 0 就可以了

2. 这里肯定需要遍历所有的数，但是最小的那个数就是a，b当中的最大那个数开始

多个数字的最小公倍数的原理也是一样的，只不过在找最大数和公倍数判断时候需要特殊处理下

"""

def lcm(a:int, b:int) -> int:

"""计算两个数的最小公倍数

/

python编程实例50例.md2022/12/31

Args:

a (int): 数字a

b (int): 数字b

Returns:

int: 返回最小公倍数

"""

if not isinstance(a, int) and not isinstance(b, int):

raise ValueError("参数中存在非数字类型， 请检查......")

# 回去a，b中最大的数

greater = a if a > b else b

# 初始化最小公倍数为0

lcm = 0

# 循环判断

while True:

# 判断greater 分别能被a，b整除

if greater % a == 0 and greater % b == 0:

# greater的值赋值给lcm

lcm = greater

# 跳出循环

break

# 如果 greater 不能被a, b整除, 则自增1

greater += 1

# 输出最小公倍数

return lcm

扩展题目: 求多个数字的最小公倍数def lcm1(*args) -> int:

"""求多个数字的最小公倍数

"""

# 判断输入的参数是否都是数字

if not all(map(lambda x: isinstance(x, int), args)):

raise ValueError("输入的参数种存在非数字的值，请检查......")

# 获取多个参数的最大值

greater = max(args)

# 初始化最小公倍数

lcm = 0

# 判断函数，用于判断两个数是否能整除，如果能返回True

resl = lambda x: True if x[0] % x[1] == 0 else False

# 循环判断

while True:

# 如果greater 能被所有的参数整除，则跳出循环

if all(map(resl, [[greater, x] for x in args])):

# greater 赋值给lcm

lcm = greater

# 跳出循环

break

# greter 自增1

/

python编程实例50例.md2022/12/31 greater += 1

# 返回最小公倍数

return lcm

18. 数字组合题目: 有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？def numcom():

"""数字组合问题

Returns:

list: 输出1，2，3，4 四个数字可以组成多少种三位不重复的数列

"""

num_list = []

# 遍历1-4, range(1, 5) 是[1, 5) 区间不包括5

for i in range(1, 5):

for j in range(1, 5):

for k in range(1, 5):

# 判断三位数字互补重复，如果互补重复则写入列表

if i != j and j != k and i != k:

num_(f'{i}{j}{k}')

# 返回个数和数列，return支持多个结果返回，用","隔开, 返回形式是元组

return num_list

def numcom1():

# 列表推导式写法

num = [1, 2, 3, 4]

num_list = [

f'{i}{j}{k}' for i in num for j in num for k in num

if i != j and i != k and j != k

]

return num_list

from itertools import permutations

def numcom2():

# 借助第三方模块实现

num_list = []

# permutations 是一个迭代器，所以需要for循环把数据取出来

for item in permutations(['1', '2', '3', '4'], 3):

# permutations 生成的不重复的数据格式是一个元组：('1', '2', '3')

# 这里需要用"".join() 连接函数，将内容转换成字符串

# 转换的列表内容必须都是字符串才可以

num_("".join(item))

return num_list

/

python编程实例50例.md2022/12/3119. 企业发奖金计算题目: 企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？def bouns(profit: int) -> int:

"""奖金计算

Args:

profit (int): 输入利润金额

Returns:

int: 提成金额

"""

# 初始化每个阶段的提成百分比

profit_level = {

1000000: 0.01,

600000: 0.015,

400000: 0.03,

200000: 0.05,

100000: 0.075,

0: 0.1

}

# 初始化奖金为0， temp等于利润金额

temp, sum = profit, 0

# 遍历每个阶段的利润线和提成比例

for prof, com in profit_():

# 判断利润金额是否大于当前利润线

if temp > prof:

# 如果大于大于当前利润线则，计算奖金

sum += (temp - prof) * com

# 修改利润金额继续比较

temp = temp - prof

# 返回利润金额，精确到小数点后两位

return round(sum, 2)

if __name__ == "__main__":

boun = bouns(400000)

print(boun)

20. 分解质因数题目: 分解质因数, 例如: 输入90， 输出: 90 = 2 * 3 * 3 * 5 /

python编程实例50例.md2022/12/31def reducenum(n: int) -> str:

"""分解质因数

Args:

n (int): 要分解的数据

Raises:

ValueError: 参数校验

Returns:

str: 返回 n = x * y * z 的字符串，例如: 90 = 2 * 3 * 3 * 5

"""

# 初始化一个列表，存放因数

fact_list = []

# 临时变量

temp = n

# 校验参数是否是大于1的数字

if not isinstance(temp, int) or temp <= 0:

raise ValueError("请输入一个大于0的整数......")

# 循环遍历temp, 直到temp == 1

while temp not in [1]:

# 遍历2 ~ temp

for i in range(2, temp + 1):

# 判断temp 是否能整除i

if temp % i == 0:

# temp 整除i 取整数部分, 重新赋值给temp进入下一轮判断

temp //= i

# 得出的因数存入数组

fact_(str(i))

# 跳出内层循环

break

reduces = " * ".join(fact_list)

return f'{n} = {reduces}'

if __name__ == "__main__":

print(reducenum(90))

21. 统计字符串题目: 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。def countStr(strs: str) -> str:

# 初始化各个类型的统计数据

letters, space, digit, other = 0, 0, 0, 0

/

python编程实例50例.md2022/12/31 # 循环遍历字符串

for s in strs:

# 判断每个字符串是否是数字

if t():

digit += 1

# 判断每个字符串是否是字母

elif a():

letters += 1

# 判断每个字符串是否是空格

elif e():

space += 1

# 以上都不是都归为其他

else:

other += 1

return f'字母个数: {letters}, 数字个数: {digit}, 空格个数: {space}, 其他:

{other}'

if __name__ == "__main__":

print(

countStr(

'132131231 131313 131qwqeqeqerqw!@!@!wfqefqw qweqeqqweq

qeqeq21')

)

22. 求s=a+aa+aaa+a的值题目: 求s=a+aa+aaa+a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。def num_sum(a: int, n: int) -> list:

"""求a + aa + aaa + aa...a

Args:

a (int): 数字值

n (int): 位数

Returns:

list: [a, aa, aaa, aa...a]

"""

# 初始化第0位的值是0

Tn = 0

# 初始化一个数组，用于存储每位的值

Sn = []

# 循环语句块

for i in range(n):

# 每一位数字累加a

Tn = Tn + a

/

python编程实例50例.md2022/12/31 # 每遍历一次，a 都乘10

a *= 10

# 将每位a存储到数组中

(Tn)

return Sn

def num_sum1(a: int, n: int) -> int:

"""列表推导式方法求: a + aa + aaa + aaaa + aa...a

Args:

a (int): 要计算的数字

n (int): 要计算的位数

Returns:

int: _description_

"""

# 这里每一次遍历都是把a转成str 然后重复i次

# python中字符串乘数字的含义是把某一个字符串重复n次

return [int(str(a) * i) for i in range(1, n + 1)]

def main(a, n):

"""主函数

Args:

a (_type_): 数字

n (_type_): 相加次数

"""

num_list = num_sum(a, n)

a_str = ' + '.join([str(i) for i in num_list])

print(f'{a_str} = {sum(num_list)}')

if __name__ == "__main__":

# 这里的map是python 的内置函数

# 执行逻辑: input 接收两个数字, 一定要用空格分开， split 分割两个数字

# map遍历这两个数字，把他们都用eval转换成数字类型

a, n = map(eval, input("请输入你要计算的数值和位数，用空格隔开：").split("

"))

main(a, n)

23. 球反弹高度计算题目: 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？def rebound(height: int, times: int):

"""反弹高度

/

python编程实例50例.md2022/12/31

Args:

height (int): 初始高度

times (int): 反弹次数

Returns:

list, list: 每次反弹经过的长度列表， 每次反弹的高度

"""

# 初始化反弹长度列表

reb_l = [height]

# 初始化反弹高度列表

height_l = [height]

# 循环遍历

for _ in range(times):

# 计算每次反弹高度是上一次的一半

height /= 2

# 每次反弹经过的距离是反弹高度的2倍

reb_(height * 2)

# 添加每次反弹的高度

height_(height)

return reb_l, height_l

if __name__ == "__main__":

first, count = 100, 10

reb_list, height_list = rebound(first, count)

print(f'第 {count} 次落地共经过: {sum(reb_list)} 米, 第 {count} 次反弹的高度: {height_list[-1]} 米')

24. 猴子吃桃问题题目: 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。思路:这个题目是一个简单的规律题1. 每天吃剩下的桃子的一半零一个2. 第10天剩1颗，3. 第9天： (1 + 1) * 24. 第8天： ((1 + 1) * 2 + 1) * 25. ......def monkey():

"""猴子吃桃问题

Returns:

int: 返回第10天摘桃子总数

/

python编程实例50例.md2022/12/31 """

# 第10天只有一个桃子

x2 = 1

# 循环每天，从10天开始一只到第1天

# range(start, end, step): start: 开始数字， end: 结束数字， step: 步长

for i in range(9, 0, -1):

# 计算上一天的桃子数

x = (x2 + 1) * 2

# x2 存储每天的桃子数

x2 = x

# 返回第一天的桃子树

return x2

if __name__ == "__main__":

print(monkey())

25. 阶乘之和题目: 求和 s = 1! + 2! + 3! +…+ 10! .def sumfactorial(n: int) -> int:

"""n个数字阶乘之和

Args:

n (int): 要求的数字n

Returns:

int: 返回阶乘之和

"""

# 初始化sum

fac_sum = 0

# 初始化数字阶乘，默认是1

factoriacl = 1

# 遍历1~n 获取每个数的阶乘并相加

for i in range(1, n + 1):

# 计算每个数阶乘

factoriacl *= i

# 每个数阶乘累加

fac_sum += factoriacl

return fac_sum

def sumfactorial1(n: int) -> int:

"""n个数字的阶乘

Args:

n (int): 数字n

Returns:

/

python编程实例50例.md2022/12/31 int: 返回阶乘

"""

# 闭包函数，用于获取n的阶乘

def factorial(n: int) -> int:

"""数字n的阶乘

Args:

n (int): 数字n

Returns:

int: 返回n的阶乘

"""

fac = 1

for i in range(1, n + 1):

fac *= i

return fac

return sum(map(factorial, range(1, n)))

if __name__ == "__main__":

# print(sumfactorial(5))

print(sumfactorial1(6))

26. 回文数题目: 一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。def palindrome(palinstr: str) -> bool:

"""判断回文字符串

遍历字符串的分别比较前后对应的字符是否相等

如果都相当则为回文数，

如果有一个不相等则跳出循环，不为回文数

Args:

palinstr (str): 要判断的字符串

Returns:

bool: 输出结果True 或 False

"""

# 定义第一位和最后一位的索引

a, b = 0, len(palinstr) - 1

# 标识

flag = True

# 定义while循环，结束标志为a < b

while a < b:

# 从第0位开始判断相对应的数字是否相等

if palinstr[a] != palinstr[b]:

# 如果不相等，则flag设置位False

/

python编程实例50例.md2022/12/31 flag = False

# 跳出循环

break

# a增加一位， b减少一位

a, b = a + 1, b - 1

return flag

def palindrome1(palinstr: str) -> bool:

"""回文数判断

利用字符串的切片反转

Args:

palinstr (str): 要验证的回文数的字符串

Returns:

bool: 返回结果，如果是则返回True，否则返回False

"""

# 获取列表长度

str_len = len(palinstr)

# 取中间位置

median = str_len // 2

leftstr = palinstr[:median]

# 这个是判断数字长度是否是奇数还是偶数

if str_len % 2 == 0:

# 如果是偶数就要多计算一位

rightstr = palinstr[str_len:median - 1:-1]

else:

# 如果是奇数就不用多计算一位

rightstr = palinstr[str_len: median: -1]

# 将后一半反转和前一半比较,这里需要了解列表的切片

return leftstr == rightstr

if __name__ == "__main__":

palind = input("请输入你要判断的数字: ")

print(f"数字: {palind} {'是' if palindrome1(palind) else '不是'} 回文数字")

27. 杨辉三角题目: 杨辉三角，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。帕斯卡（1623----1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。杨辉三角是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合样式:11 1 /

python编程实例50例.md2022/12/311 2 11 3 3 11 4 6 4 11 5 10 10 5 1def ptrangle(n: int):

""" 打印杨辉三角定义法

从第三行开始，每一行首位末位都是1，中间的数字是上一行相邻两个数字之和

Args:

n (int): 输入要打印的行数

"""

# 初始化一个二维数组，先把第1、2行写进去

trang_list = [[1], [1, 1]]

# 从第2行还是进行循环计算

for i in range(2, n):

# 先获取上一行内容

pre_list = trang_list[i - 1]

# 初始化当前行首位

cul = [1]

# 循环遍历每一行需要计算的个数

for j in range(i - 1):

# 上一行两个数相加

(pre_list[j] + pre_list[j + 1])

# 当前行末尾加上1

(1)

# 当前行写入到二维数组中

trang_(cul)

return trang_list

def ptrangle1(n: int):

"""杨辉三角补零法

下一行: 上一行左边补零 + 上一行右边补零

Args:

n (int): 输入要打印的行数

"""

# 初始化第一行

tran = [[1]]

# 从第2行还是遍历

for i in range(1, n):

# 每次吧上一行的内容左边补零，右边补零，然后相加

(

list(map(lambda x, y: x + y, [0] + tran[i - 1],

tran[i - 1] + [0])))

return tran

def main(n:int):

/

python编程实例50例.md2022/12/31 # 校验n是否为int类型且大于0

if not isinstance(n, int) and n <= 0:

raise ValueError("请输入一个大于1的整数")

# 杨辉三角计算

trans = ptrangle(n)

# 组装输出

for i in range(n):

print(" " * (n - i - 1), end="")

print(" ".join([str(i) for i in trans[i]]))

print()

if __name__ == "__main__":

main(5)

28. 函数调用使用题目: 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/ndef pevent(n: int):

"""计算: 1/2 + 1/4 + ... + 1/n

Args:

n (int): 输入计算要计算的值(偶数)

Returns:

float: 输出加和

"""

sum = 0

# 遍历2~n的所有偶数

for i in range(2, n + 1, 2):

# 累加每位偶数的 1/i

sum += 1.0 / i

# 输出加和

return sum

def podd(n: int):

"""计算奇数位的: 1/1+1/3+...+1/n

Args:

n (int): 输入要计算的n位(奇数)

Returns:

float: 输出加和

"""

sum = 0

for i in range(1, n + 1, 2):

sum += 1.0 / i

/

python编程实例50例.md2022/12/31 return sum

def dcall(fn, n: int) -> float:

"""中间函数，用于演示函数的调用

Args:

fn (function): 函数，python中函数可以作为参数传递

n (int): 要计算的数字

Returns:

float: 返回计算结果

"""

# 函数调用

s = fn(n)

# 返回处理结果

return s

def main(n: int):

# 校验n是否合法

if not isinstance(n, int) or n < 1:

raise ValueError("请输入一个大于1的数字")

# 初始化数据

sum = 0

# 判断n是否是偶数

if n % 2 == 0:

# 如果n是偶数, 则使用pevent函数计算

sum = dcall(pevent, n)

# 如果n不是偶数，就用podd函数计算

sum = dcall(podd, n)

# 返回sum函数

return sum

if __name__ == "__main__":

# eval python内置函数

# 计算指定表达式的值。也就是说它要执行的Python代码只能是单个运算表达式（注意eval不支持任意形式的赋值操作），而不能是复杂的代码逻辑，这一点和lambda表达式比较相似。

num = eval(input("请输入一个数字: "))

print(main(num))

29. 猴子分桃问题题目: 题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？ /

python编程实例50例.md2022/12/31分析: 根据题意可知，假设桃子的总数是p，第1次分桃后剩余: (p - 1) * 0.8第2次分桃后剩余: ((p-1) * 0.8 - 1) * 0.8第3次分桃后剩余: (((p - 1) * 0.8 - 1) * 0.8 - 1) * 0.8第4次分桃后剩余: ((((p - 1) * 0.8 -1) * 0.8 - 1) * 0.8 - 1) * 0.8第5次分桃后剩余: (((((p - 1) * 0.8 -1) * 0.8 - 1) * 0.8 - 1) * 0.8 - 1) * 0.8 规律很简单

现在要计算海滩上最少有多少桃子，最简单的方法就是从1累加

本次采用自顶向下的设计思路，用两个函数

设计思路:

首先设计主函数:

1. 主函数初始化p = 1代表桃子，循环判断 p是否满足5只猴子分桃(子函数完成判断)

2. 如果不满足，p = p + 1 继续判断

3. 如果满足则退出循环

设计子函数:

1. 接收p

2. 循环5次

3. 判断 p % 5 == 1 意味 p 除以 5 是否余 1

4. 如果判断为真，则 p = (p - 1) * 0.8 继续下一次循环

5. 如果不能整除 则 直接返回 False

6. 5次循环结束后没有返回False 则 返回Ture 证明P符合5次分桃

def devideable(p: int) -> bool:

"""猴子分桃问题子算法, 计算桃子能否被5次分掉

Args:

p (int): 桃子数量

"""

# 循环5次，每次执行 (p - 1) * 0.8

for _ in range(5):

# 验证 扔掉一个后是否能被5 整除

if p % 5 == 1:

# 如果能被5整除拿走一份, 留下4份，进行下一次循环

p = (p - 1) * 0.8

else:

# 如果不能被5整除直接返回False

return False

# 循环完成 证明p满足5次分桃，返回True

return True

def monkey_peach() -> int:

"""猴子分桃问题主算法

"""

p = 1

/

python编程实例50例.md2022/12/31 # 循环，验证p是否满足五次被分掉

while not devideable(p):

# 不满足则累加

p += 1

return p

if __name__ == "__main__":

print(monkey_peach())

30. 约瑟夫生者死者小游戏题目: 30 个人在一条船上，超载，需要 15 人下船。于是人们排成一队，排队的位置即为他们的编号。报数，从 1 开始，数到 9 的人下船。如此循环，直到船上仅剩 15 人为止，问都有哪些编号的人下船了呢？这个游戏有三个规则:1. 一共几个人2. 循环数数，数到n的人出局，不能小于等于1，要不然一轮就都出局了3. 剩余多少人这个游戏结束, 最小是1，不然这个游戏就没有意义了设计思路:接收用户输入参数: n: 总人数, out_num: 要出局的数字, surp: 剩余多少人结束1. 给每个人员进行编号，1 ~ n, 赋值给pers2. 初始化 count = 03. 循环遍历a. 判断当前pers人数是否等于surp 如果等于， 跳出循环，输出persb. 如果pers 不等于surp, count += 1，取出数组的第一个人out_per = (0)c. 判断 count == out_num, 如果等于， 这个人出局，count 重置为 0，本次循环结束, 继续下一次循环d. 如果计数器不等于out_num 把取 out_per 添加到pers最后一位，继续下一次循环def personout(n: int, out_num: int = 9, surp: int = 15) -> list:

"""约瑟夫生死者小游戏通用写法

Args:

n (int): 总人数

out_num (int, optional): 定义数数规则，数的这个数的人出局

surp (int, optional): 还剩多少人结束游戏

Returns:

list: 输出游戏最后剩余的人

"""

# 判断三个参数是否都是数字,

# 关于这块校验我也是比较纠结是不是必要有，如果各位有更好的意见请联系我,谢谢

if all(map(lambda x: isinstance(x, int), [n, out_num, surp])):

if out_num <= 1 and surp < 1:

/

python编程实例50例.md2022/12/31 raise ValueError("根据游戏规则 out_num 必须大于 1, surp 必须大于等于1")

else:

raise ValueError("所有参数只支持数字类型，请检查参数类型......")

# 给每个人编号

pers = [i for i in range(1, n + 1)]

# 初始化计数器

count = 0

# 循环语句块

while True:

# 判断剩余人数是否等于 surp

if len(pers) == surp:

# 如果剩余人数等于surp, 输出pers

print(f'剩余的人数是: {pers}')

# 跳出循环

break

else:

# 如果剩余人数不等于surp, 计数器加一

count += 1

# 取出第一个人

out_per = (0)

# 判断当前数的数字是否等于out_num

if count == out_num:

# 如果等于out_num, 计数器归零

count = 0

print(f'{out_per} 出局了')

# 循环结束

continue

else:

# 如果不等于out_num 把取出的out_per 放入到数组中

(out_per)

if __name__ == "__main__":

personout(31, out_num=3, surp=2)

31. 冒泡排序题目: 冒泡排序分析:1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。3. 针对所有的元素重复以上的步骤，除了最后一个。4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较 /

python编程实例50例.md2022/12/31def bubble_sort(num_list: list) -> list:

"""冒泡排序

Args:

num_list (list): 要排序的数组

Returns:

list: 排序好的数组

"""

# 获取数组的长度

num_len = len(num_list)

# 第一层循环，遍历数组的长度

for i in range(num_len):

# 定义是否排序过的标识

flag = False

# 第二次循环, 每循环一次比较相邻两个数值

for j in range(num_len - 1 - i):

# 判断相邻的两个数字大小

if num_list[j] > num_list[j + 1]:

# 交换相邻的两个数字

num_list[j], num_list[j + 1] = num_list[j + 1], num_list[j]

# 修改排序标识为True

flag = True

# 判断此次循环是否排序过，

# 如果没有排序过证明这个数组已经排序完成了, 跳出循环

if not flag:

break

# 返回排序后的数组

return num_list

if __name__ == "__main__":

# 初始化一个无序的列表

num_list = [t(1, 10000) for i in range(1000)]

print(num_list)

print(bubble_sort(num_list))

32. 插入排序题目: 插入排序插入排序算法的原理如下：1.从第一个元素开始，该元素可以认为已经被排序;2.取出下一个元素，在已经排序的元素序列中从后向前扫描;3.如果该元素（已排序）大于新元素，将该元素移到下一位置;4.重复步骤3, 直到找到已排序的元素小于或者等于新元素的位置; /

python编程实例50例.md2022/12/315.将新元素插入到该位置后；6.重复步骤2~5。def insertSort(num_list: list) -> list:

"""插入排序

Args:

num_list (list): 要排序的数组

Returns:

list: 排列好的数组

"""

# 从第1位开始循环遍历数组, 赋值给i

for i in range(1, len(num_list)):

# 取出第i位, 赋值给key

key = num_list[i]

# 初始化j = i - 1, 代表num_list[:i]的下标

j = i - 1

# 循环遍历num_list[:i] 每一位数据，从后往前,

# 每次判断j>=0 且 key < num_list[j] 如果不满足就退出

while j >= 0 and key < num_list[j]:

# 如果满足

# 将j位数值赋值给j + 1

num_list[j + 1] = num_list[j]

# j 递减

j -= 1

# 将key赋值给j + 1 位

# 这里主要消除while循环中j 位数据和j + 1 位数据重复的问题

# 这里可能比较难懂，需要去着重了解下while循环的机制

num_list[j + 1] = key

return num_list

if __name__ == "__main__":

# set 是去重，list是将set转换位列表

num_list = list(set([t(1, 100) for _ in range(10)]))

print(f'排列前的数组: {num_list}')

print(f'排列后的数组: {insertSort(num_list)}')

33. 快速排序def quickSort(num_list: list):

"""快速排序

Args:

num_list (list): 要排序的列表

/

python编程实例50例.md2022/12/31

Returns:

list: 返回排序后的结果

"""

lagrer = []

smaller = []

# 校验数组是否为0或者1

if len(num_list) < 2:

return num_list

# 获取数组第一个值

standed = num_list[0]

# 遍历数组第2位之后的数组

for i in num_list[1:]:

# 小于standed 的放入smaller

if i < standed:

(i)

# 大于等于standed的放入lagrer

else:

(i)

# 递归排序，最后返回

return quickSort(smaller) + [standed] + quickSort(lagrer)

if __name__ == "__main__":

num_list = [t(1, 1000) for i in range(10)]

print(num_list)

print(quickSort(num_list))

34. 归并排序def merge_sort(num_list: list) -> list:

"""归并排序

Args:

num_list (list): 要排序的数组

Returns:

list: 排序后的数组

"""

# 回环函数,也叫闭包， 用于处理左右列表

def merge(left: list, right: list):

ll, rr = 0, 0

result = []

# 循环计算，直到lift或者right有一个数组为0

while ll < len(left) and rr < len(right):

/

python编程实例50例.md2022/12/31 # left 和right对应的数值计算, 那个小哪个入result

if left[ll] < right[rr]:

(left[ll])

ll += 1

else:

(right[rr])

rr += 1

# 最后将没有计算的数写入到result中

result += left[ll:]

result += right[rr:]

# 返回排序后的结果

return result

# 校验列表长度

if len(num_list) < 2:

return num_list

# 取列表的中间位置

num = len(num_list) // 2

# 递归调用，分别获取前一半和后一半数组

left = merge_sort(num_list[:num])

right = merge_sort(num_list[num:])

# 调用回环函数merge 排序，并返回结果

return merge(left, right)

if __name__ == "__main__":

num_list = [t(1, 1000) for i in range(10)]

print(num_list)

print(merge_sort(num_list))

35. 选择排序题目: 选择排序选择排序算法是先判断最小的数的下标是不是 0，如果不是则说明最小的数不是第一个元素，则将这个数与第一个元素互换位置，这样一轮下来最小的那个数就被找到并放到了最左边。在第二轮同样先保存新序列第二个元素的下标，后面所有的数依次与第二个元素相比较，如果遇到更小的则记录更小的那个数的下标，然后后面所有的数都依次与那个更小的数比较，直到最后又找到一个最小的，此时这个最小的在整个序列中是“第二小”。然后再判断这个数的下标是否等于 1，如果不等于 1 说明“第二小”的那个数不是第二个元素，则将这个数与第二个元素互换位置，这样第二轮下来就找到了“第二小”的那个数，并将它放到了第二个位置。如此循环，直到整个序列实现从小到大排序。如果是从大到小排序，那么就记录大的那个数的下标，每一轮找出一个最大的数放到左边。从上面的分析可以看出，选择排序和冒泡排序的另一个不同点是，冒泡排序只要遇到前面比后面大的就互换，而选择排序是比较一轮才互换一次，而且如果本轮中最小的就是最左边那个数则不用互换。所以从这个角度 /

python编程实例50例.md2022/12/31看，选择排序比冒泡排序的效率要高。而且通过上面对选择排序的分析发现，从逻辑上讲，与冒泡排序相比，选择排序更符合人的思维。def selectSort(num_list: list) -> list:

"""选择排序

Args:

num_list (list): 数组

Returns:

list: 排序后的数组

"""

list_length = len(num_list)

# 判断数组长度是否小于2

if list_length < 2:

# 如果小于2直接返回

return num_list

# 循环整个数组

for j in range(list_length):

# 假设最小数索引是j

min_num_index = j

# 循环j位之后的数组

for i in range(j + 1, list_length):

# 判断 i位 与最小索引位的数值那个小

if num_list[i] < num_list[min_num_index]:

# 如果 i 位数值小， 最小索引替换为i

min_num_index = i

# 判断最小索引位是否与j相等，

if j != min_num_index:

# 不相等 交换j位和 最小索引位的数值

num_list[min_num_index], num_list[j] = num_list[j], num_list[

min_num_index]

return num_list

if __name__ == "__main__":

# set 是去重，list是将set转换位列表

num_list = list(set([t(1, 100) for _ in range(10)]))

print(f'排列前的数组: {num_list}')

print(f'排列后的数组: {selectSort(num_list)}')

36. 希尔排序希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量 /

python编程实例50例.md2022/12/31分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。def shell(num_list: list):

"""希尔排序

Args:

num_list (list): 排序前的列表

Returns:

list: 排序后的列表

"""

n = len(num_list)

gap = n // 2

while gap > 0:

for i in range(gap, n):

while i >= gap and num_list[i - gap] > num_list[i]:

num_list[i - gap], num_list[i] = num_list[i], num_list[i -

gap]

i -= gap

gap //= 2

return num_list

if __name__ == "__main__":

num_list = [t(1, 1000) for _ in range(1, 10)]

print(num_list)

print(shell(num_list))

37. 堆排序def heapSort(num_list: list) -> list:

def adjust_heap(lst, i, size):

left_index = 2 * i + 1

right_index = 2 * i + 2

largest_index = i

if left_index < size and lst[left_index] > lst[largest_index]:

largest_index = left_index

/

python编程实例50例.md2022/12/31 if right_index < size and lst[right_index] > lst[largest_index]:

largest_index = right_index

if largest_index != i:

lst[largest_index], lst[i] = lst[i], lst[largest_index]

adjust_heap(lst, largest_index, size)

def built_heap(lst, size):

for i in range(len(lst)):

adjust_heap(lst, i, size)

size = len(num_list)

built_heap(num_list, size)

for i in range(len(num_list))[::-1]:

num_list[0], num_list[i] = num_list[i], num_list[0]

adjust_heap(num_list, 0, i)

return num_list

if __name__ == "__main__":

# set 是去重，list是将set转换位列表

num_list = list(set([t(1, 100) for _ in range(10)]))

print(f'排列前的数组: {num_list}')

print(f'排列后的数组: {heapSort(num_list)}')

38. 计数排序计数排序(Counting Sort)是一种不比较数据大小的排序算法，是一种牺牲空间换取时间的排序算法。计数排序适合数据量大且数据范围小的数据排序，如对人的年龄进行排序，对考试成绩进行排序等。计数排序先找到待排序列表中的最大值 k，开辟一个长度为 k+1 的计数列表，计数列表中的所有初始值都为0。走访待排序列表，如果走访到的元素值为 i，则计数列表中索引 i 的值加1，走访完整个待排序列表，就可以统计出待排序列表中每个值的数量。然后创建一个新列表，根据计数列表中统计的数量，依次在新列表中添加对应数量的 i ，得到排好序的列表。def countSort(num_list: list) -> list:

"""计数排序

Args:

num_list (list): 要排序的列表

Returns:

list: 已排好序的列表

"""

# 校验列表长度，如果小于2直接返回, 只有0或1个数的列表无需排序

if len(num_list) < 2:

/

python编程实例50例.md2022/12/31 return num_list

# 获取最大的一个数

max_num = max(num_list)

# 生成一个列表，长度是max_num + 1, 所有元素都为0

count = [0] * (max_num + 1)

# 遍历num_list

for num in num_list:

# 获取每一位的值，给count相应的索引增加1

count[num] += 1

# 此时的count列表中只有0或者1~n 类似[0,0,1,0,2,n]

# 以上步骤就是把列表中的每一个数转换成count的索引

# 初始化一个新的列表

new_list = list()

print(count)

# 遍历count的长度, 根据索引和值过滤0的索引留下1的索引就是排序后的数组

for i, value in enumerate(count):

# 遍历count 的每一位, 如果v值为0不会进入到for循环

for _ in range(value):

# 只有v值不为0的时候进入循环，将索引放入到列表中

new_(i)

return new_list

if __name__ == "__main__":

num_list = [t(1, 100) for _ in range(1000)]

print(num_list)

print(countSort(num_list))

39. 桶排序桶排序(Bucket sort)是一种通过分桶和合并实现的排序算法，又被称为箱排序。桶排序，顾名思义，会用到「桶」，核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。def bucketSort(num_list: list) -> list:

if len(num_list) < 2:

return num_list

min_num, max_num = min(num_list), max(num_list)

bucker_num = (max_num - min_num) // 3 + 1

buckes = [[] for _ in range(bucker_num)]

/

python编程实例50例.md2022/12/31 for num in num_list:

buckes[(num - min_num) // 3].append(num)

new_array = list()

for i in buckes:

for j in sorted(i):

new_(j)

return new_array

if __name__ == "__main__":

num_list = [t(1, 1000) for _ in range(10)]

print(num_list)

print(bucketSort(num_list))

40. 基数排序基数排序（radix sort）属于“分配式排序”（distribution sort），它是透过键值的部份信息，将要排序的元素分配至某些“桶”中，以达到排序的作用。基数排序适用于所有元素均为正整数的数组。def radixSort(num_list: list) -> list:

mod = 10

div = 1

mosBit = len(str(max(num_list)))

buckets = [[] for row in range(mod)]

while mosBit:

for num in num_list:

buckets[num // div % mod].append(num)

i = 0

for bucket in buckets:

while bucket:

num_list[i] = (0)

i += 1

div *= 10

mosBit -= 1

return num_list

if __name__ == "__main__":

num_list = [t(1, 1000) for _ in range(10)]

print(num_list)

print(radixSort(num_list))

/

python编程实例50例.md2022/12/3141. 国王分金币问题题目: 国王给为他出生入死的忠诚骑士分金币, 第一天给骑士1枚金币，随后两天每天给骑士2枚金币，接着的三天每天给3枚金币，以此类推，随后的n天给n枚金币分析: 骑士每天收到金币与天数挂钩 第1天: 1 第2、3天: 2 第4、5、6天: 3 第7、8、9、10天: 4这里以10天为例, 金币总数 sum = 1^2 + 2^2 + 3^2 + 4^2, 总天数 days = 1 + 2 + 3 +

4 = 4 * (4 + 1)/2 = 10

从总天数公式可以推导出金币组数，但是我们不确定用户输入的n天是否刚好做完最后一组，假设骑士只做了8天，那么第4组金币只能是4 * 2。

因此我们需要求出n天落到哪个组了，再用天数公式求出最后一组一共工作了几天。相加即可得出总金币数

def kingCoin(days: int) -> int:

"""国王分金币问题

Args:

days (int): 工作天数

Returns:

_type_: _description_

"""

# 初始化天数

first_day = 1

# 初始化金币总数

coin_sum = 0

# 遍历天数总数，与days比较，如果first_day > days, 则: 结束循环

while (first_day + 1) * first_day / 2 <= days:

coin_sum += first_day**2

first_day += 1

# coins = sum([i**2 for i in range(1, first_day)]) +

# first_day * (days - first_day * (first_day - 1) / 2)

# 将剩余天数获得的金币相加，得出总金币数

coin_sum += first_day * int((days - first_day * (first_day - 1) / 2))

return coin_sum

if __name__ == "__main__":

print(kingCoin(7))

42. 计算某天是一年中的第几天 /

python编程实例50例.md2022/12/31def day_of_the_year1(year_num: int, month_num: int, day_num: int) -> str:

"""计算某天是一年中的第几天

Args:

year (int): 年份

month (int): 月份

day (int): 天

Returns:

str: 返回天数

"""

# 这里用到了datetime两个方法date获取当前日期，strftime 格式化输出这天是当年的第几天

# %d 月内的中的一天， %U 一年中的星期数（0-53）星期天为星期的开始

# %W 一年中的星期数（0-53）星期一为星期的开始

# %j 年内的一天（00-366）

return (year_num, month_num, day_num).strftime("%j")

def day_of_the_year2(*args) -> str:

"""计算某天式当年的第几天

Args:

year_num (int): 年

month_num (int): 月

day_num (int): 日

Returns:

str: 返回当天是第几天

"""

# 处理args前三个参数，其他参数一律不处理

year_num, month_num, day_num = [int(i) for i in args[:3]]

# 参数判断, 输入的年月日要符合规则

if year_num < 0:

raise ValueError("年必须大于0")

if month_num < 0 or month_num > 12:

raise ValueError("月份必须是 0-12 之间")

if day_num < 0 or day_num > 31:

raise ValueError("天必须在 0-31 之间")

# 判断是否是闰年, isleap 如果是闰年就是1, 不是闰年就是0

isleap = 1 if (year_num % 100 != 0

and year_num % 4 == 0) or year_num % 400 == 0 else 0

# 每月天数集

months = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

# 1 ~ month_num 之间的月份相加 + day_num + isleap

# 因为闰年的二月是29天，所以如果是闰年就需要多加1，刚好isleap就是判断是否是闰年的值也是0或1，直接利用

sum_num = sum(months[0:month_num]) + day_num + isleap

/

python编程实例50例.md2022/12/31 # 返回结果

return str(sum_num)

if __name__ == "__main__":

year, month, day = [int(i) for i in input("请输入年月日, 空格分开:

").split(" ")]

print(day_of_the_year1(year, month, day))

43. 勒索信实例题目: 给定一个勒索信内容的字符串和另一个表示杂志内容的字符串，写一个方法拍段能否通过剪下杂志中的内容构造出这封勒索信，若可以，返回True，否则返回False。注：杂志字符串中的每一个字符仅能再勒索信中使用一次。from collections import Counter

def black_mail(ransom_note: str, magazine: str) -> bool:

"""勒索信: 常规方法，初始化26个字母在上面操作

Args:

ransom_note (str): 勒索信内容

magazine (str): 杂志内容

Returns:

bool: 返回结果

"""

arr = [0] * 26

# 遍历杂志内容，获取杂志中每个字符出现的次数

for m in magazine:

arr[ord(m) - ord('a')] += 1

# 遍历勒索信内容，每次都需要减一，如果出现小于0的情况结束循环返回False

# 否则返回True

for r in ransom_note:

arr[ord(r) - ord('a')] -= 1

if arr[ord(r) - ord('a')] < 0:

return False

return True

def black_mail1(ransom_note: str, magazine: str) -> bool:

"""勒索信实例，使用map的方式比较

Args:

ransomNote (str): 信的内容

magazine (str): 杂志内容

/

python编程实例50例.md2022/12/31

Returns:

bool: 是否能构成勒索信

"""

ransom_list = list(map(lambda x: ord(x) - ord('a'), list(ransom_note)))

magaz_list = list(map(lambda x: ord(x) - ord('a'), list(magazine)))

all_result = [

False if ransom_(i) > magaz_(i) else True

for i in set(ransom_list)

]

return all(all_result)

def black_mail2(ransom_note: str, magazine: str) -> bool:

"""勒索信: 使用Counter的方式实现

Args:

ransom_note (str): 勒索信的内容

magazine (str): 杂志内容

Returns:

bool: 结果

"""

# 统计勒索信中每个字母出现的次数

ransom_dic = dict(Counter(ransom_note))

# 统计杂志中每个字母出现的次数

magaz_dict = dict(Counter(magazine))

# 比较勒索信中每个字母出现的次数是否都小于杂志中相同的字母出现的次数

# 如果不符合就返回False， 如果符合就返回True

return all([

False if value > magaz_(key, 0) else True

for key, value in ransom_()

])

if __name__ == "__main__":

print(black_mail1('', 'a'))

44. 反转一个三位整数题目: 反转一个三位整数, 例: 输入: 123, 输出: 321

ef reverse_int(num: int) -> int:

"""反转整数, 此方法只局限于三位整数，超过三位整数计算不准

此实例主要了解运算符： / % 的用法

/

python编程实例50例.md2022/12/31

Args:

num (int): 三位整数

Returns:

int: 反转后的整数

"""

# 获取每位的数字

x, y, z = int(num / 100), int(num % 100 / 10), int(num % 10)

# 反转组合

return (100 * z + 10 * y + x)

def reverse_int1(num: int) -> int:

"""反转整数, 此方法不局限于三位整数，可以反转任意长度的数字

这里实例是要学习了字符串的切片: str[x:y]

Args:

num (int): 整数

Returns:

int: 反转后的整数

"""

return int(str(num)[::-1])

if __name__ == "__main__":

print(reverse_int1(124))

45. 相对排名题目: 根据N名运动员得分，找到相对等级和获得最高分前3名的人，分别获得金牌，银牌和铜牌。N是正整数，并且不超过10000。所有运动员的成绩都保证是独一无二的。问题示例:输入[5,4,3,2,1],输出["Gold Medal","Silver Medal","Bronze Medal","4","5"]前3名运动员得分较高，根据得分依次获得金牌，银牌和铜牌。对于后两名运动员，根据分数输出相对等级。def relative_rank(arr_list: list) -> list:

"""先对排名

Args:

arr_list (list): 相对排名

Returns:

list: 相对排名

/

python编程实例50例.md2022/12/31 """

# 记录初始列表的所有位置

new_list = {value: index for index, value in enumerate(arr_list)}

# 列表从大大小排序，获取排名

sorted_socer = sorted(arr_list, reverse=True)

answser = [0] * len(arr_list)

# 遍历排序后的排名，第一名、第二名、第三名排序替换为字符串

for index, value in enumerate(sorted_socer):

# python 3.8之后的新特性，类似swith - case语法

match index:

case 0:

res = "Gold Medal"

case 1:

res = "Silver Medal"

case 2:

res = "Bronze Medal"

case _:

res = str(index + 1)

answser[new_list[value]] = res

return answser

if __name__ == "__main__":

scores = [t(1, 1000) for _ in range(5)]

print(f"原始数组: {scores}")

relative_list = relative_rank(scores)

print(f"排序后的数组: {relative_list}")

46. 下一个更大的数题目: 给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。示例 1:输入: nums1 = [4,1,2], nums2 = [1,3,4,2].输出: [-1,3,-1]解释:对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。示例 2:输入: nums1 = [2,4], nums2 = [1,2,3,4].输出: [3,-1]解释: /

python编程实例50例.md2022/12/31对于num1中的数字2，第二个数组中的下一个较大数字是3。对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。def next_great_element(num1: list[int], num2: list[int]) -> list[int]:

"""下一个更大的元素

Args:

num1 (list[int]): 子元素列表

num2 (list[int]): 数据列表

Returns:

list[int]: 返回num1中下一个更大的元素列表，没有为-1

"""

# 初始化一个字典和数组

dic, stack = {}, []

# 遍历num2 找出列表中每个数下一个更大的元素，记录到dic中

# 例如: num2： [1,2,4,3]

# dic: {1: 2, 2: 4}

for x in num2:

# 循环stack，如果stack不为空且stack[-1] 小于 x

while stack and stack[-1] < x:

# 计入dic

dic[stack[-1]] = x

# 删除最后一个元素

()

# stack 添加元素x

(x)

# 遍历num1，找出dic对应的最大的元素，没有则为-1

return [(i, -1) for i in num1]

if __name__ == "__main__":

# 随机生成一个字符串

num_2 = ([i for i in range(1, 1000)], k=100)

# e(num_2)

num_1 = (num_2, k=int(len(num_2)/10))

print(f'num_1: {num_1}')

print(f'num_2: {num_2}')

print(f'great element: {next_great_element(num_1, num_2)}')

47. 不重复的两个数题目: 给定一个数组a[]，其中除了2个数，其他均出现2此，请找到不重复的两个数并返回。给出 a = [1,2,5,5,6,6]返回 [1,2]除1和2外其他数都出现了2次，因此返回[1,2]给出 a = [3,2,7,5,5,7] 返回 [2,3] 除了2和3其他数都出现了2次，因此返回[2,3] /

python编程实例50例.md2022/12/31from functools import reduce

from collections import Counter

def the_two_numbers(num_list: list[int]) -> list[int]:

"""不重复的两个数，这种实现方法比较有局限性，只能找出两个不重复的数

若有三个不重复的数的列表就会计算错误

此方法比较抽象，使用了异或运算和与运算。

Args:

num_list (list[int]): 列表

Returns:

list[int]: 返回不重复的两个数

"""

ans = [0, 0]

# 遍历num_list 使相邻的两个数按位异或, 暂存到ans[0]

# 两种实现方法

# 方法一: 使用python内置函数reduce 遍历。效率比较快

# 相同的数异或为0

# 因为数组中只有两个数字是不重复的，所以遍历的结果就是不重复的两个数异或

ans[0] = reduce(lambda x, y: x ^ y, num_list)

# 方法二: 使用for循环, 若想尝试请自行去除注释

# for i in num_list:

# ans[0] = ans[0] ^ i

# 定义c默认为1

c = 1

# 循环左移c,直到c & ans[0] == c

# 这里可以理解为定义一个标识，<< 二进制左移，以为每次将1向左移动一位

# 例如: 1 << 1 = 10, 10 << 1 = 100, 100 << 1 = 1000

# &: 按位与 例如: 4 & 1 转换成二进制： 100 & 001 = 000 转换为十进制 0

# c & ans[0] != c 意为：c先和ans[0] 按位与然后和 c比较, 如果相等则结束

while c & ans[0] != c:

c = c << 1

# 循环num_list 获取第二个不重复的数

for i in num_list:

# 这里需要判断i中是否符合 i & c == c

if i & c == c:

# 如果符合异或

ans[1] = ans[1] ^ i

print(i, ans[1])

# 获取最终的第一个不重复的数

ans[0] = ans[0] ^ ans[1]

return ans

/

python编程实例50例.md2022/12/31def the_two_numbers2(num_list: list[int]) -> list[int]:

""" 获取两个不重复的数, 这个方法可以获取多个不重复的数

Args:

num_list (list[int]): 列表

Returns:

list[int]: 返回两个不重复的数

"""

# 校验num_list 是否小于3， 如果小于3直接返回

if len(num_list) < 3:

return num_list

# 用counter获取每个数字的频率

dic_list = Counter(num_list)

# 利用列表推导式获取不重复的数

return [key for key, value in dic_() if value == 1]

if __name__ == "__main__":

print(the_two_numbers([3, 4, 6, 6, 8, 4, 8, 9]))

48. 双胞胎字符串题目: 给定两个字符串 s和t，每次可以任意交换s的奇数位或偶数位上的字符，即奇数位上的字符能与其他奇数位的字符互换，而偶数位上的字符能与其他偶数位的字符互换，问能否经过若干次交换，使s变成t。例如: s = abcdt = cdab输出: yess = abcdt = badc输出: No这里需要注意，题目要求奇数位或者偶数位上的字符能与其他奇数位或者偶数位上的数字经过若干次互换使得s变成t，也就是说abcd中只有a,c 可以互换，bd可以互换，a,b是不能够互换的def twins(s_str: str, t_str: str) -> str:

"""双胞胎字符串

题目分析：

s字符串的奇数位和偶数位任意互换, 使s变成t

我们可以理解成，奇数位从小到大排序，偶数位从小到大排序，只要s == t 即相等

Args:

s_str (str): 要比较的字符串

t_str (str): 要比较的字符串

Returns:

str: 返回比较结果如果是双胞胎字符串返回Yes， 不是返回No

/

python编程实例50例.md2022/12/31 """

# 判断两个字符串长度是否一致

if len(s_str) != len(t_str):

return "No"

# 获取s_str奇数位和偶数位，分别排序， 这里用到了字符串的切片

odds, evends = "".join(sorted(list(s_str[::2]))), "".join(

sorted(list(s_str[1::2])))

# 获取t_str奇数位和偶数位，分别排序,这里用到了字符串的切片

oddt, evendt = "".join(sorted(list(t_str[::2]))), "".join(

sorted(list(t_str[1::2])))

# 分别比较s_str和t_str 偶数位是否相等，相等就返回yes，不相等就返回No

return "Yes" if odds == oddt and evends == evendt else "No"

if __name__ == "__main__":

s = 'acbd'

t = 'bdac'

print(twins(s, t))

49. 最接近target的值题目: 给出一个数组，在数组中找到2个数，使得它们的和最接近但不超过目标值，返回它们的和。 例: 输入target = 15，array= [1,3,5,11,7],输出14， 11+3=14，输入target=16和array=[1,3,5,11,7],输出16，11+5=16def two_sum(arr_list: list[int], target: int) -> int:

"""最接近target的值

Args:

arr_list (list[int]): 数组

target (int): 目标值

Returns:

_type_: _description_

"""

n = len(arr_list)

if n < 2:

return -1

# 排序

arr_()

# 存最小的那个数

diff = 0x7fffffff

left = 0

right = n - 1

/

python编程实例50例.md2022/12/31 # 双链路排除，节省计算空间，分别从第一位往右和最后一位往左排除

while left < right:

# 假设两个左边和右边相加大于target，右边减一，因为列表经过排序，右侧数最大

if arr_list[left] + arr_list[right] > target:

right -= 1

# 否则就进行比较，target减去右侧左侧的数和diff比较，获取最小的一个

else:

diff = min(diff, target - arr_list[left] - arr_list[right])

# 左侧位数加一

left += 1

# 返回最接近target的数，如果diff没有变则这个数不存在

return (target - diff) if diff != 0x7fffffff else -1

if __name__ == "__main__":

arr = [1, 2, 34, 5, 11]

tar = 15

print(two_sum(arr, tar))

50. 点积题目: 点积在数学中，又称数量积（dot product; scalar product），是指接受在实数R上的两个向量并返回一个实数值标量的二元运算。它是欧几里得空间的标准内积。两个向量a = [a1, a2,…, an]和b = [b1, b2,…, bn]的点积定义为：a·b=a1b1+a2b2+……+anbn。使用矩阵乘法并把（纵列）向量当作n×1 矩阵，点积还可以写为：a·b=（a^T）*b，这里的a^T指示矩阵a的转置。def dotproduct(arr_a: list[int], arr_b: list[int]) -> int:

"""点积

Args:

arr_A (list[int]): 列表1

arr_B (list[int]): 列表2

Returns:

int: 返回两个列表的点积之和

"""

# 校验两个列表是否为空或者两个量表长度不相等

if len(arr_a) == 0 or len(arr_b) == 0 or len(arr_a) != len(arr_b):

return -1

# 两个函数的点积相加

return sum(map(lambda x, y: x * y, arr_a, arr_b))

def dotproduct1(arr_a: list[int], arr_b: list[int]) -> int:

/

python编程实例50例.md2022/12/31 """点积

Args:

arr_a (list[int]): 列表1

arr_b (list[int]): 列表2

Returns:

int: 返回点积

"""

# 校验两个列表是否为空或者两个量表长度不相等

if len(arr_a) == 0 or len(arr_b) == 0 or len(arr_a) != len(arr_b):

return -1

ans = 0

for ind, value in enumerate(arr_a):

ans += value * arr_b[ind]

return ans

if __name__ == "__main__":

arr_1 = [1, 2, 34, 5, 11]

arr_2 = [4, 23, 11, 5, 12]

print(dotproduct(arr_1, arr_2), dotproduct1(arr_1, arr_2))

/