function01

# 定义 fun 函数，接收一个正整数 x 作为输入，并返回其逆序数
def fun(x):
    # 将输入的正整数 x 转换为字符串，然后使用 [::-1] 对字符串进行逆序
    # 最后，将逆序后的字符串转换回整数并返回
    return int(str(x)[::-1])

# 定义 find_palindromes 函数，接收两个参数 start 和 end，表示搜索回文数的范围
def find_palindromes(start, end):
    # 创建一个空列表，用于存储找到的回文数
    palindromes = []

    # 使用 for 循环遍历范围内的每一个整数
    for i in range(start, end + 1):
        # 如果当前整数 i 与其逆序数相等，说明它是一个回文数
        if i == fun(i):
            # 将回文数添加到列表中
            palindromes.append(i)
    
    # 返回找到的回文数列表
    return palindromes

# 指定搜索回文数的范围为 1000 到 9999
start = 1000
end = 9999

# 调用 find_palindromes 函数，传入搜索范围，获取回文数列表
palindromes = find_palindromes(start, end)

# 输出找到的回文数列表
print(palindromes)

import random

# 生成 30 个随机成绩 (0~100 之间) 放入列表 a 中
# 使用列表推导式和 random.randint 生成 30 个 0 到 100 之间的随机整数
a = [random.randint(0, 100) for _ in range(30)]

# 定义 MyFun 函数，接收一个成绩列表 scores 和一个默认值参数 grade
def MyFun(scores, grade=5):
    # 初始化各等级人数计数器
    excellent, good, average, pass_grade, fail = 0, 0, 0, 0, 0
    
    # 使用 for 循环遍历成绩列表
    for score in scores:
        # 根据成绩判断并统计各等级人数
        if score >= 90:
            excellent += 1
        elif score >= 80:
            good += 1
        elif score >= 70:
            average += 1
        elif score >= 60:
            pass_grade += 1
        else:
            fail += 1
    
    # 根据 grade 参数的值返回相应的人数
    if grade == 5:
        return excellent
    elif grade == 4:
        return good
    elif grade == 3:
        return average
    elif grade == 2:
        return pass_grade
    elif grade == 1:
        return fail

# 调用 MyFun 函数的三种方式

# 1. 不指定关键字 (grade 默认为 5)
# 调用 MyFun 函数时未指定 grade 参数，因此 grade 使用默认值 5
excellent_count = MyFun(a)
print("Excellent students count:", excellent_count)

# 2. 指定关键字
# 调用 MyFun 函数时，明确指定 grade 参数的值为 4
good_count = MyFun(a, grade=4)
print("Good students count:", good_count)

# 3. 不给默认值参数值 (grade 传递 1)
# 调用 MyFun 函数时，直接传递 grade 参数的值为 1，而不使用关键字
fail_count = MyFun(a, 1)
print("Fail students count:", fail_count)

import math

# 定义 s 函数，接受一个正实数 x 作为输入
def s(x):
    total = 0  # 初始化总和为 0
    sign = 1  # 初始化符号为 1（正数）
    i = 0  # 初始化循环变量 i
    epsilon = 1e-6  # 设置最后一项的绝对值小于 10^-6 时结束循环的条件

    # 使用 while 循环来计算每一项的值
    while True:
        term = (x ** (2 * i + 1)) / math.factorial(2 * i + 1)  # 计算当前项的值
        
        # 当最后一项的绝对值小于 epsilon 时，结束循环
        if abs(term) < epsilon:
            break
        
        total += sign * term  # 将当前项（带符号）累加到总和中
        sign *= -1  # 在每次迭代时改变符号（正数变负数，负数变正数）
        i += 1  # 更新循环变量 i
    
    return total  # 返回计算得到的级数和

# 使用示例
x = 1.2
result = s(x)
print("The sum of the series is:", result)

# 定义多项式函数，输入 x 值，返回多项式的结果
def polynomial(x):
    return 2 * x**3 - 4 * x**2 + 3 * x - 6

# 定义二分法函数
# p：多项式函数
# a, b：求解区间的端点
# tol：容差，用于确定计算精度，默认值为 1e-8
# max_iter：最大迭代次数，用于限制算法执行的次数，默认值为 1000
def bisection(p, a, b, tol=1e-8, max_iter=1000):
    # 检查端点处的函数值是否具有不同的符号，否则无法使用二分法求解
    if p(a) * p(b) > 0:
        raise ValueError("The function should have different signs at the interval endpoints.")

    iter_count = 0  # 初始化迭代计数器
    c = a  # 初始化根的估计值
    # 当区间宽度的一半大于容差（精度要求）且未达到最大迭代次数时，继续迭代
    while (b - a) / 2 > tol and iter_count < max_iter:
        c = (a + b) / 2  # 计算区间的中点
        if p(c) == 0:  # 如果中点处的函数值为 0，则已找到精确的根
            break
        if p(a) * p(c) < 0:  # 如果 a 和 c 处的函数值具有不同的符号，说明根位于这个新的区间
            b = c
        else:  # 否则根位于 c 和 b 之间
            a = c
        iter_count += 1  # 增加迭代计数器

    return c, iter_count

a, b = -10, 10  # 求解区间
root, iterations = bisection(polynomial, a, b)  # 调用二分法函数求解根
print("Root:", root)
print("Iterations:", iterations)