#第11期-计算阶乘

#1 问题描述

#2 解题思路

• 用input函数请用户输入一个整数，因为负数无阶乘，需使用户输入的数为自然数
• 根据阶乘的特点：n！= n × (n - 1)！= n × (n - 1) × (n - 2) ×…× 2 × 1，可用for循环、递归等方法求解
• 需考虑特殊情况：0！= 1

#3 解题方法

#方法一：for循环

a = int(input('请输入一个自然数:'))
result = 1
if a < 0:
    print('负数没有阶乘')
elif a == 0:
    print('0的阶乘为1')
else:
    for i in range(1, a + 1):
        result *= i
    print(f"{a}的阶乘为{result}")

第1行： 定义变量a，用input函数使用户输入数字，int函数将其转换为整型
第2行： 创建一个存储阶乘运算结果的变量result，变量初始值为1
第3-10行： 用if…elif…else语句对用户输入的数值进行判断。
若用户输入的数值小于0，输出“负数没有阶乘”；
若用户输入的数值等于0，输出“0的阶乘为1”；
否则用for循环遍历1 至 a 的整数，在每轮循环中，result都会与循环变量 i 相乘并将乘积结果再赋值给result，当for循环结束时，result的值就是自然数n阶乘的运算结果，最后用print函数输出阶乘结果

#方法二： 递归法

def factorial(n):
    assert n >= 0, "请输入自然数"
    if n == 0:
        return 1
    return n * factorial(n - 1)
a = int(input('请输入一个自然数:'))
print(factorial(a))

第1行： 定义函数factorial，传入参数n
第2行： 用assert断言函数限定参数n大于或等于0，若大于或等于0，执行后面的代码，否则报错“AssertionError: 请输入自然数！

第3-5行： 设定递归的结束条件，当 n 为 0时，返回值为1，否则返回值为n factorial(n - 1)
第8行： 定义变量a，用input函数使用户输入数字，int函数将其转换为整型
*第9行： 为参数n赋值为a，用print函数打印计算结果

#方法三： reduce()函数

from functools import reduce
def factorial(n):
    assert n >= 0, "请输入自然数"
    if n == 0:
        return 1
    return reduce(lambda x, y: x * y, range(1, n + 1))
a = int(input('请输入一个自然数:'))
print(factorial(a))

第1行： 从functools模块中导入reduce()函数
第4行： 定义函数factorial，传入参数n
第5行： 用assert断言函数限定参数n大于或等于0，若大于或等于0，执行后面的代码，否则报错“AssertionError: 请输入自然数！”
第6-7行： 设定递归的结束条件，当 n 为 0时，返回值为1
第8行： 调用reduce函数，使用lambda 表达式输出前n项的积
第11行： 定义变量a，用input函数使用户输入数字，int函数将其转换为整型
第12行： 为参数n赋值为a，用print函数打印计算结果

reduce() 函数
reduce() 函数是functools模块中的一个函数，其作用是对参数序列中元素进行累积。
语法：
reduce(function, iterable[, initializer])
参数说明：
function：是包含两个参数的函数
iterable ：可迭代对象
initializer ：初始参数

def prod(x, y):    
    return x + y
print(reduce(prod, [1, 2, 3, 4, 5]))  # 15

print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]))   # 15

lambda 表达式
Lambda 函数是Python中的匿名函数，也就是没有具体名称的函数，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用 。

• lambda 表达式必须使用 lambda 关键字定义。
• 在 lambda 关键字之后、冒号左边为参数列表，可不带参数，也可有多个参数。若有多个参数，则参数间用逗号隔开，冒号右边为 lambda 表达式的返回值。

#方法四： factorial()函数

import math
a = int(input('请输入一个自然数:'))
result = math.factorial(a)
print(f"{a}的阶乘为{result}")

第1行： 导入模块math
第2行： 定义变量a，用input函数使用户输入数字，int函数将其转换为整型
第3行： 创建变量result，调用math模块中的factorial函数，传入参数a
第4行： print函数输出结果

#4 视频解析

#第12期—阿姆斯特朗数

#1 问题描述

#2 解题思路

• 用input函数请用户输入查找的区间
• 用for循环遍历这个区间的数值
• 判断位数，将数值拆分，计算每个位数上数字的n次方和
• 将计算出的值与该数值进行比较，若相等，则为阿姆斯特朗数，输出结果

#3 解题方法

#方法一

lower = int(input("请输入最小值: "))
upper = int(input("请输入最大值: "))
assert lower > 0 and upper > 0, "请输入正整数！"
for num in range(lower, upper + 1):
    sum = 0
    n = len(str(num))
    temp = num
    while temp > 0:
        digit = temp % 10
        sum += digit ** n
        temp //= 10
    if num == sum:
        print(num, end=' ')

第1-2行： 定义变量lower和upper，分别用input函数获取用户输入的最小值与最大值，int函数将其转换为整型
第4行： 因为对正整数求阿姆斯特朗数，所以用assert断言函数限定变量lower和upper大于0，若大于0，执行后面的代码，否则报错“AssertionError: 请输入正整数！”
第6行： 用for循环遍历最小值与最大值之间所有的数
第7行： 创建变量sum，初始赋值为1，用于存储数值每个位数上数字的n次方和
第8行： 用len函数获取变量num的长度，也即该数值的位数
第9行： 将变量num赋值给变量temp
第11-14行： 用while循环计算每个位数上数字的n次方和，当temp > 0时，进入循环，temp除以10取余，获取该数值的个位数，计算个位数的 n 次方，继续将temp除以10，对商取整，直至temp小于或等于0时退出while循环
第16-17行： 用if语句判断，若计算出的值与该数值相等，则用print函数输出结果

#方法二

lower = int(input("请输入最小值: "))
upper = int(input("请输入最大值: "))
assert lower > 0 and upper > 0, "请输入正整数！"
for num in range(lower, upper + 1):
    sum = 0
    n = len(str(num))
    for i in str(num):
        sum += int(i) ** n
    if num == sum:
        print(num, end=' ')

第1-2行： 定义变量lower和upper，分别用input函数获取用户输入的最小值与最大值，int函数将其转换为整型
第4行： 因为对正整数求阿姆斯特朗数，所以用assert断言函数限定变量lower和upper大于0，若大于0，执行后面的代码，否则报错“AssertionError: 请输入正整数！”
第6行： 用for循环遍历最小值与最大值之间所有的数
第7行： 创建变量sum，初始赋值为1，用于存储数值每个位数上数字的n次方和，计算每个位数上数字的n次方和
第8行： 用len函数获取变量num的长度，也即该数值的位数
第10-11行： 用str函数将num转换为字符串类型，for循环遍历字符串中的每一个元素
第13-14行： 用if语句判断，若计算出的值与该数值相等，则用print函数输出结果

#4 视频解析

#第13期—温度转化

#1 问题描述

#2 解题思路

• 首先请用户输入带华氏或摄氏标志的温度值
• 然后根据温度标志选择适当的温度转换算法
• 最后输出转换后的温度

#3 解题方法

num = input("请输入带有符号的温度值: ")
if num[-1] in ['C', 'c']:
    f = 1.8 * float(num[0:-1]) + 32
    print(f"转换后的温度是{f:0.2f}华氏度")
elif num[-1] in ['F', 'f']:
    c = (float(num[0:-1]) - 32) / 1.8
    print(f"转换后的温度是{c:0.2f}摄氏度")
else:
    print("输入格式错误")

第1行： 定义变量num，用input函数获取用户输入的带有符号的温度值
第3-5行： 通过索引获取用户输入的最后一位字符，用in判断该字符是否在列表[‘C’, ‘c’]中，即判断用户输入的是不是摄氏温度。若用户输入的是摄氏温度，则通过温度转换公式将摄氏温度转换为华氏温度，用print函数输出运行结果，保留小数点后两位。
第6-8行： 用in判断用户输入的最后一位字符是否在列表[‘F’, ‘f’]中，即判断用户输入的是不是华氏温度。若用户输入的是华氏温度，则通过温度转换公式将华氏温度转换为摄氏温度，用print函数输出运行结果。
第9-10行： 否则，用print函数打印“输入格式错误”

• 由于input()函数返回的数据类型为字符串型，所以第4行需要用float函数将其转化为浮点数类型再进行计算
• 用户输入的字符串是有序的排列，如用户输入34C，则第一个字符是3，第二个是4，第三个是C
• 在 Python 中，字符串中的字符可以通过索引来提取，从前往后索引时，下标从 0 开始，从后往前索引时，下标从 -1 开始。因此num[0:-1]表示取从前往后的第一个字符到从后往前的第一个字符，但不包括从后往前的第一个字符（因为索引不包含尾下标的元素），如用户输入34C，获取的元素是34
  

#4 视频解析

#第14期-数字排列

#1 问题描述

#2 解题思路

• 嵌套for循环使填在百位、十位、个位的数字都是1、2、3、4。
• 组成所有的排列后再去掉不满足条件的排列
• 用print函数输出结果

#3 解题方法

#方法一

total = 0
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:
                print(str(i)+str(j)+str(k), end=' ')
                total += 1
print(f"\n共有{total}个数")

第1行： 创建变量total，用于存储1，2，3，4四个数字所组成三位数的个数，初始赋值位0
第3-5行： 用变量 i, j, k 分别表示这个三位数的百位、十位和个位的数字，用3重嵌套for循环分别遍历百位、十位和个位上 1 至 4 的整数
第6行： 因为要组成无重复数字的三位数，所以 i, j, k 两两不相等
第7行： 用print函数打印排列结果，end=’ ‘将结果输出到同一行，以空格结尾
第8行： 每次循环后total在原有的基础上加 1
第10行： 用print函数打印组成三位数的个数，\n换行输出

#方法二

from itertools import permutations
total = 0
for i in permutations('1234', 3):
    print(''.join(i), end=' ')
    total += 1
print(f"\n共有{total}个数")

第1行： 从itertools模块中导入permutations函数

第3行： 创建变量total，用于存储1，2，3，4四个数字所组成三位数的个数，初始赋值位0
第5行： 调用permutations排序函数，排序对象为字符串 ‘1234’ ，指定长度参数为3，用for循环遍历每一个排序
第6行： 由于permutations函数排序后会产生一个元组序列，所以用join函数将元素合并成一个新的字符串，end=’ ‘将结果输出到同一行，以空格结尾
第7行： 每次循环后total在原有的基础上加 1
第9行： 用print函数打印组成三位数的个数，\n换行输出

permutations函数
permutations函数返回可迭代对象的所有排列（顺序有关），排序后会产生一个元组序列
语法:
permutations(item [,r])
item为排序的对象
r为长度参数，用于指定长度的排列中

join()函数
join() 方法是非常重要的字符串方法，用来将列表、集合或元组中包含的多个字符串连接成一个字符串。
语法：
‘sep’.join(sequence)
参数说明:
sep：分隔符。可以为空
sequence：要连接的元素序列
上面语法的意思是：以sep作为分隔符，将sequence的所有元素合并成一个新的字符串

#4 视频解析

#第15期-反转字符串

#1 问题描述

#2 解题思路

#3 解题方法

#方法一：for循环

a = input("请输入字符串：")
b = ''
for i in a:
    b = i + b
print(b)

第1行： 用input函数获取用户输入的字符串，赋值给变量 a
第2行： 创建变量b，赋值为一个空字符串
第3行： 由于字符串是有序的排列，用for循环遍历a中的每一个元素
第4行： 每次循环都将循环变量 i 与变量 b 连接起来，再赋值给变量b，循环结束时，b 为 a 的反向字符串
第5行： 输出变量 b

#方法二：反向切片

a = input("请输入字符串：")
b = a[::-1]
print(b)

第1行： 用input函数获取用户输入的字符串，赋值给变量a
第2行： 对字符串 a 切片，步长为-1, 即字符串的反转，将反转结果赋值给变量 b
第3行： 输出变量 b

#方法三：反转列表

a = input("请输入字符串：")
b = list(a)
b.reverse()
c = ''.join(b)
print(c)

第1行： 用input函数获取用户输入的字符串，赋值给变量a
第2行： 创建变量b，将用户输入的字符串转化为字符串列表
第3行： reverse() 方法反转元素的排序顺序，用reverse()方法对列表b进行反转
第4行： 用字符串的join()方法遍历列表，合并成一个字符串
第5行： 输出变量c

#方法四：递归

a = input("请输入字符串：")
def f(x):
    if len(x) <= 1:
        return x
    return f(x[1:]) + x[0]
print(f(a))

第1行： 用input函数获取用户输入的字符串，赋值给变量a
第2行： 定义函数 f，传入参数x
第3-4行： 设定递归算法的结束条件，即当参数 x 的长度 小于或等于 1 时，返回值为 x
第5行： 否则返回值为f(x[1:]) + x[0]
第7行： 为参数 x 赋值为 a, 并输出f(a)的结果

#方法五：reduce函数

from functools import reduce
a = input("请输入字符串：")
b = reduce(lambda x, y: y + x, a)
print(b)

第1行： 从functools模块中导入reduce()函数
第2行： 用input函数获取用户输入的字符串，赋值给变量a
第3行： 调用reduce函数，使用lambda表达式输出反转字符串，并赋值给变量b
第4行： 输出变量b

第11期-计算阶乘(opens new window)中有详细讲解reduce函数和lambda表达式，大家可以查看哦~

#4 视频解析

#第16期—杨辉三角

#1 问题描述

杨辉三角的性质：

• 每行首尾的数字都是1
• 每行中间的各数都是它肩上两个数的和
• 第n行的数字有n项
• 第n行的项数总比n-1行多1个

#2 解题思路

• 用input函数使用户输入行数
• 创建两个列表，一个用于输出最后的结果，另一个输出每一行的数字，并将其添加到第一个列表中
• 根据杨辉三角形的特点输出结果：每行首尾的数字都是1；每行中间的各数都是它肩上两个数的和

#3 解题方法

n = int(input("输入需要打印的杨辉三角行数 :"))
assert n > 0, "请输入正整数！"
list1 = []
for i in range(n):
    list2 = []
    if i == 0:
        list2 = [1]
    elif i == 1:
        list2 = [1, 1]
    else:
        for j in range(i + 1):
            if j == 0 or j == i:
                list2.append(1)
            else:
                list2.append(list1[i - 1][j - 1] + list1[i - 1][j])
    list1.append(list2)
space = len(list1[-1])
for i in list1:
    print(' ' * (space * 4 // 2), end='')
    for j in i:
        print(f"{j:<4}", end='')
    print()
    space -= 1

第1行： 用input函数获取用户输入的行数，int函数将其转化为整型，并赋值给变量 n
第2行： 用assert断言函数限定变量 n 大于0，若大于0，执行后面的代码，否则报错“AssertionError: 请输入正整数！”
第4行： 创建一个空列表list1，用于完成整个序列的循环，输出杨辉三角
第5行： 用for循环控制输出的行数
第6行： 创建另一个空列表list2，用于存储每一行的数值
第7-8行： 第一次循环i == 0，输出杨辉三角第一行
第9-10行： 第二次循环i == 1，输出杨辉三角第二行
第11-12行： 接着输出杨辉三角的其他行，变量 j 表示一行中的每一个元素，用for循环遍历每一行中的每一个元素
第13-14行： 每行首尾的数字都是1，输出每行首尾的数字 1，添加到列表list2
第15-16行： 每行中间的各数都是它肩上两个数的和，通过对双重列表的索引，获取中间这个数肩上的两个数，求和后将其添加到列表list2

第17行： 将列表list2添加到列表list1
第19行： 为使杨辉三角每一行的数值能居中排列，设置每一行第一个数值前的空格数，用len函数获取list1最后一行的长度
第20行： 由于list1是二维列表，用for循环遍历list1，循环变量 i 为一维列表，即杨辉三角每一行的数值列表
第21行： 每个数值之间间隔4个空格，每一行第一个元素前的空格数为space 4 // 2， 用end将结果输出到同一行
第22行： 在第19行for循环的基础上，嵌套一个for循环，获取杨辉三角每一行中的每一个元素
第23行： 每个数值之间间隔4个空格，用end将结果输出到同一行
第24行： 一行输出后，用print()换行输出下一行
*第25行： 由于第n行的数值比n-1行多1个，所以在一次循环后，space在原有基础上减 1
运行结果如下图所示：

#4 视频解析

#第17期—奖金计算

#1 问题描述

#2 解题思路

• 首先用input函数获取用户输入的利润总额
• 然后根据奖金提成比例计算奖金
• 最后输出计算结果

#3 解题方法

#方法一

profit = float(input("请输入利润，单位为万元："))
assert profit >= 0, "请输入非负数！"
if profit <= 10:
    bonus = profit * 0.1
elif 10 < profit <= 20:
    bonus = 10 * 0.1 + (profit-10) * 0.075
elif 20 < profit <= 40:
    bonus = 10 * 0.1 + 10 * 0.075 + (profit-20) * 0.05
elif 40 < profit <= 60:
    bonus = 10 * 0.1+ 10 * 0.075 + 20 * 0.05 + (profit-40) * 0.03
elif 60 < profit <= 100:
    bonus = 10 * 0.1+ 10 * 0.075 + 20 * 0.05 + 20 * 0.03 + (profit-60) * 0.015
else:
    bonus = 10 * 0.1 + 10 * 0.075 + 20 * 0.05 + 20 * 0.03 + 40 * 0.015 + (profit-100) * 0.01
print(f"奖金为{bonus:0.2f}万元")

第1行： 用input函数获取用户输入的利润总额，float函数转化为浮点数，赋值给变量profit
第2行： 用assert断言函数限定变量profit大于0，若大于0，执行后面的代码，否则报错“AssertionError: 请输入非负数！”
第4-15行： 用if…elif…else语句对用户输入的利润总额进行判断，根据奖金提成比例计算奖金
第17行： print函数输出最终计算结果，保留两位小数

#方法二

profit = float(input("请输入利润，单位为万元："))
assert profit >= 0, "请输入非负数！"
bonus = 0
value = [100, 60, 40, 20, 10, 0]
rates = [0.01, 0.015, 0.03, 0.05, 0.075, 0.1]
for i in range(6):
    if profit > value[i]:
        temp = (profit - value[i]) * rates[i]
        bonus += temp
        profit = value[i]
print(f"奖金为{bonus:0.2f}万元")

第1行： 用input函数获取用户输入的利润总额，float函数转化为整型，赋值给变量profit
第2行： 用assert断言函数限定变量profit大于0，若大于0，执行后面的代码，否则报错“AssertionError: 请输入非负数！”
第4行： 创建存储奖金总额的变量bonus，初始赋值为0
第5行： 创建列表value，传入的参数为利润的界限值
第6行： 创建列表rates, 传入的参数为对应的奖金提成比例
第7行： 由于列表value共有6个参数，即利润总额划分为6个档位，用for循环遍历value这一列表中每一个元素的索引值
第8行： 当用户输入的利润总额大于列表value中的利润值时，进入循环
第9行： 通过列表的索引，计算每一个档位的奖金
第10行： 在每次循环中，每个档位的奖金temp与变量bonus相加，并将求和结果再赋值给变量bonus
第11行： 为变量 profit 赋值为value[i]，直到变量 profit不满足条件，退出循环
第12行： print函数输出最终计算结果，保留两位小数

#4 视频解析

#第18期-判断素数

#1 问题描述

#2 解题思路

• 首先用input函数获取用户输入的数字
• 然后根据素数的定义和特点，判断该数值是否为素数
• 最后输出判断结果

#3 解题方法

#方法一

num = int(input("请输入一个大于1的整数："))
if num > 1:
    for i in range(2, num):
        if num % i == 0:
            print(f"{num}不是素数")
            break
    else:
        print(f"{num}是素数")
else:
    print("输入错误，输入大于1的整数")

第1行： 用input函数获取用户输入的数值，int函数将其转化为整型，赋值给变量num
第2行： 由于素数是大于 1 的整数，用if…else语句对用户输入的数值进行判断，当该数值大于 1 时，继续判断是否为素数，否则转到第 9 行，用print函数打印 “输入错误，输入大于1的整数”
第3-6行： 用for循环遍历 2 至(num - 1)之间所有的数，由于素数只能被 1 和该整数整除，如果用户输入的数值能被 2 至(num - 1)之间的任意一个数整除，则不是素数，用break退出整个循环
第7-8行： 否则用print函数打印该数值是素数

#方法二

num = int(input("请输入一个大于1的整数："))
if num > 1:
    for i in range(2, int(num ** 0.5 + 1)):
        if num % i == 0:
            print(f"{num}不是素数")
            break
    else:
        print(f"{num}是素数")
else:
    print("输入错误，输入大于1的整数")

第1行： 用input函数获取用户输入的数值，int函数将其转化为整型，赋值给变量num
第2行： 由于素数是大于 1 的整数，用if…else语句对用户输入的数值进行判断，当该数值大于 1 时，继续判断是否为素数，否则转到第 9 行，用print函数打印 “输入错误，输入大于1的整数”
第3-6行： 用for循环遍历 2 至根号n 之间所有的数，如果用户输入的数值能被 2 至根号n 之间的任意一个数整除，则不是素数，用break退出整个循环
第7-8行： 否则用print函数打印该数值是素数

为什么判定一个素数只要将此数被2 至根号n 整除即可？？？
设n为合数，n=ab
若a = b, 则a 和 b 都等于根号n
若a ≠ b,则 a, b 之中总有一个小于根号n ，另一个大于根号n

#方法三

num = int(input("请输入一个大于1的整数："))
if num > 1:
    if num == 2:
        print(f"{num}是素数")
    elif num % 2 == 0:
        print(f"{num}不是素数")
    else:
        for i in range(3, int(num ** 0.5) + 1, 2):
            if num % i == 0:
                print(f"{num}不是素数")
                break
        else:
            print(f"{num}是素数")
else:
    print("输入错误，输入大于1的整数")

第1行： 用input函数获取用户输入的数值，int函数将其转化为整型，赋值给变量num
第2行： 由于素数是大于 1 的整数，用if…else语句对用户输入的数值进行判断，当该数值大于 1 时，继续判断是否为素数，否则转到第 14 行，用print函数打印 “输入错误，输入大于1的整数”
第3-4行： 若该数值等于2，则打印该数是素数
第5-6行： 偶数中除了2都不是质数，且奇数的因数也没有偶数，所以若该数值能被2整除，则打印该数不是素数
第7-13行： 用for循环遍历 3 至根号n 之间所有的数，如果用户输入的数值能被3 至根号n 之间的任意奇数整除，则不是素数，用break退出整个循环；否则用print函数打印该数值是素数

#4 视频解析

#第19期—百钱百鸡

#1 问题描述

#2 解题思路

• 假设公鸡、母鸡、小鸡的数量分别为X，Y，Z，所以X、Y、Z都大于或等于零
• 根据公鸡、母鸡、小鸡的数量关系和价格关系判断其数量，可用for循环遍历每种鸡的数量，计算结果
• 输出正确结果

#3 解题方法

#方法一：枚举法

n = 0
for x in range(21):
    for y in range(34):
        z = 100 - x - y
        if 5 * x + 3 * y + z / 3 == 100:
            print(f'公鸡{x}只，母鸡{y}只，小鸡{z}只')
            n += 1
print(f'一共有{n}种买法')

第1行： 创建变量 n, 用来存储购买的方法数，初始赋值为 0
第2行： 变量 x 表示公鸡的数量，如果用100元全部购买公鸡，最多可购买20只，用for循环遍历公鸡的数量
第3行： 变量 y 表示母鸡的数量，如果用100元全部购买母鸡，最多可购买33只，用for循环遍历母鸡的数量
第4行： 变量 z 表示小鸡的数量，三种鸡的数量共100只，所以 z = 100 - x - y
第5-6行： 每只公鸡5元，每只母鸡3元，每只小鸡 1/3 元，用 if 语句判断，若购买三种鸡花费的总额为100，则用print函数输出每种鸡的数量
第7行： 变量 n 在每次循环后都在原有的基础上加 1
第8行： 用print函数输出共有多少种购买方法

#方法二：公式推导法

n = 0
for x in range(0, 14, 4):
    y = 25 - 7 * x / 4
    z = 100 - x - y
    if 5 * x + 3 * y + z / 3 == 100:
        print(f'公鸡{x}只，母鸡{y}只，小鸡{z}只')
        n += 1
print(f'一共有{n}种买法')

第1行： 创建变量 n, 用来存储购买的方法数，初始赋值为 0
第2行： 变量 x 表示公鸡的数量，根据公鸡和母鸡的数量关系推导，可知公鸡 x 的取值范围是 0 到 14，由于 x 是4的倍数，所以range函数步长为4
第3行： 变量 y 表示母鸡的数量，根据公鸡和母鸡的数量关系推导，可知y = 25 - 7/4 x
第4行： 变量 z 表示小鸡的数量，三种鸡的数量共100只，所以 z = 100 - x - y
第5-6行： 每只公鸡5元，每只母鸡3元，每只小鸡 1/3 元，用 if 语句判断，若购买三种鸡花费的总额为100，则用print函数输出每种鸡的数量
第7行： 变量 n 在每次循环后都在原有的基础上加 1
第8行： 用print函数输出共有多少种购买方法

• x 是4的倍数
• 0<=7/4x <= 25, 即 0 <= x <= 14
• y = 25 - 7/4 x

#4 视频解析

#第20期-分数序列求和

#1 问题描述

#2 解题思路

#3 解题方法

#方法一：递归法

def f(x):
    if x == 1 or x == 2:
        return x
    return f(x - 1) + f(x - 2)
sum1 = 0
for i in range(1, 21):
    sum1 += f(i + 1) / f(i)
print(round(sum1, 2))

第1行： 定义函数 f, 传入参数 x
第2-3行： 设置递归算法的结束条件，当 x 等于 1 或 2 时，返回值为 x 本身
第4行： 否则，根据该序列分子和分母的特点，返回值为每一项数值的前两项之和
第7行： 创建变量sum1, 用于存储该序列最终的求和结果，初始赋值为 0
第8行： 求该序列前20项之和，需循环20次，用for循环控制循环次数
第9行： 该序列每一项可表示为 f(i + 1) / f(i) ，在每次循环中，将该序列的每一项与变量 sum1 相加，并将求和结果再赋值给sum1，这样当for循环结束时，sum1的值就是求和结果
第10行： 最后用print函数输出计算结果,round函数保留两位小数

#方法二：for循环

a = 2
b = 1
sum1 = 0
for i in range(20):
    sum1 += a / b
    b, a = a, a + b
print(round(sum1, 2))

第1行： 创建变量 a, 用来表示该序列的分子，初始赋值为 2
第2行： 创建变量 b, 用来表示该序列的分母，初始赋值为 1
第3行： 创建变量sum1, 用于存储该序列最终的求和结果，初始赋值为 0
第4行： 用for循环控制循环次数
第5行： 该序列每一项可表示为 a / b ，在每次循环中，将该序列的每一项与变量 sum1 相加，并将求和结果再赋值给sum1
第6行： 该序列的分子等于前一项的分子与分母之和，分母等于前一项的分子，即b, a = a, a + b
第7行： 最后用print函数输出计算结果,round函数保留两位小数

#4 视频解析