python基础考试编程题

1、编写一个Python函数，接受一个字符串作为参数，判断一个字符串是不是回文字符串，返回值是一个布尔类型。

def fun(():
    s = s.replace(" ", "").lower()
    return s == s[::-1]

# 测试函数
print(is_palindrome("hello"))                       # 输出: False
print(is_palindrome("racecar"))                     # 输出: True

2、编写一个Python程序，解决以下问题：现在有三个数，分别为a,b,c，它们之间的和为19，取值范围1

# 初始化计数器
count = 0

# 遍历所有可能的组合
for a in range(1, 10):
    for b in range(1, 10):
        for c in range(1, 10):
            # 检查是否满足条件
            if a + b + c == 19 and a != b and b != c and a != c:
                count += 1
                # 打印出满足条件的组合（可选）
                print(f"a = {a}, b = {b}, c = {c}")

# 输出满足条件的组合数量
print(f"满足条件的组合数量为: {count}")

3、编写一个Python程序，使用列表推导式创建一个包含1到20之间所有平方数的列表。

# 通过列表推导式，计算1到20之间所有数的平方，并存储于squares列表中
squares = [x**2 for x in range(1, 21)]

# 打印出生成的平方数列表
print(squares)

4、编写一个递归函数，求n的阶乘。

def factorial(n):
    # 基准情况：如果n为0或1，则返回1
    if n == 0 or n == 1:
        return 1
    # 递归情况：n乘以(n-1)的阶乘
    else:
        return n * factorial(n - 1)

# 测试函数
print(factorial(5))  # 输出: 120
print(factorial(10)) # 输出: 3628800

5、编写一个python函数，计算并返回100到200之间所有的素数列表。

def is_prime(n):
    """判断一个数是否是素数"""
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def primes_between_100_and_200():
    """返回100到200之间的所有素数列表"""
    primes = []
    for num in range(100, 201):
        if is_prime(num):
            primes.append(num)
    return primes

# 测试函数
print(primes_between_100_and_200())

6、编写一个python函数，可接收一个数字列表，并返回其中的最大值和最小值， 要求：不可以在自定义函数内调用python内置函数。

def find_max_min(numbers):
    # 首先，我们检查列表是否为空
    if not numbers:
        return None, None  # 如果列表为空，则返回None对

    # 初始化最大值和最小值为列表的第一个元素
    max_value = numbers[0]
    min_value = numbers[0]

    # 遍历列表中的每一个元素
    for num in numbers[1:]:  # 从第二个元素开始遍历
        # 如果当前元素比当前最大值大，则更新最大值
        if num > max_value:
            max_value = num
        # 如果当前元素比当前最小值小，则更新最小值
        if num < min_value:
            min_value = num

    # 返回找到的最大值和最小值
    return max_value, min_value

# 测试这个函数
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
max_val, min_val = find_max_min(numbers)
print(f"最大值: {max_val}, 最小值: {min_val}")

7、编写一个python函数，可接收一个列表和要查找的值key，使用顺序查找法，输出key在列表中的下标，找不到的话，输出-1，要求：不可以在定义函数内调用python内置方法。

def sequential_search(lst, key):
    # 遍历列表中的每一个元素及其对应的下标
    for index in range(len(lst)):
        # 如果找到与key相等的元素，返回其下标
        if lst[index] == key:
            return index
    # 如果遍历完列表仍未找到key，返回-1
    return -1

# 测试这个函数
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
key_to_find = 5
index = sequential_search(my_list, key_to_find)
print(f"Key {key_to_find} found at index: {index}")

8、编写一个递归函数，返回第n项斐波那契数列的值。

def fibonacci(n):
    # 递归的基本情况：当n为1或2时，直接返回1
    if n == 1 or n == 2:
        return 1
    # 递归的递推关系：第n项是前两项之和
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# 测试这个函数
n = 10
print(f"斐波那契数列的第{n}项是: {fibonacci(n)}")

9、使用列表推导式，生成包含10个范围在[10, 30]之间随机数的列表。

import random

# 利用列表推导式和random.randint函数生成随机数列表
random_numbers = [random.randint(10, 30) for _ in range(10)]

# 打印生成的随机数列表
print(random_numbers)

10、编写一个python函数，接收一个整型变量n为参数，输出n行的九九乘法表。

def print_multiplication_table(n):
    # 外层循环：控制乘法表的行数
    for i in range(1, n + 1):
        # 内层循环：打印每一行的乘法表达式
        for j in range(1, i + 1):
            # 使用格式化字符串打印乘法表达式，确保对齐
            print(f"{j} * {i} = {j * i}", end='\t')
        # 打印完一行后换行
        print()

# 测试函数，输出n=9时的九九乘法表
n = 9
print_multiplication_table(n)

11、编写一个python函数，接收一个整型变量n为参数，输出n行的杨辉三角形。

def print_yanghui_triangle(n):
    # 初始化一个空列表来存储杨辉三角形的每一行
    triangle = []

    # 外层循环：控制杨辉三角形的行数
    for i in range(n):
        # 初始化当前行的列表，第一个元素总是1
        row = [1] * (i + 1)

        # 对于不是第一行的行，计算中间的元素
        for j in range(1, i):
            # 中间的元素等于它正上方和左上方两个元素之和
            row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]

        # 将当前行添加到杨辉三角形的列表中
        triangle.append(row)

        # 打印当前行
        print(' '.join(map(str, row)))

# 测试函数，输出n=5时的杨辉三角形
n = 5
print_yanghui_triangle(n)