python考试程序题

Word count: 7.3k   |   Reading time≈ 30 min 
1
2
3
4
5
6
7
8
9
10
11
12
import math

# 输入三条边长
a, b, c = map(float, input().split(','))

# 判断是否能构成三角形
if a + b > c and a + c > b and b + c > a:
    p = (a + b + c) / 2
    area = math.sqrt(p * (p - a) * (p - b) * (p - c))
    print(f"area={area:.2f}")
else:
    print("不能构成三角形")
 3,4,5


area=6.00

  1. import math

    • 功能：导入Python的math模块，该模块提供了许多数学函数和常量。

  2. a, b, c = map(float, input().split(','))

    • 功能：从用户输入中读取三个值，并将它们转换为浮点数。具体步骤如下：
      • input()：获取用户输入的字符串。
      • .split(',')：将输入的字符串按逗号分隔成多个子字符串，返回一个列表。
      • map(float, ...)：将列表中的每个子字符串转换为浮点数。
      • a, b, c = ...：将转换后的浮点数分别赋值给变量a、b和c。

  3. if a + b > c and a + c > b and b + c > a:

    • 功能：判断三条边长是否能构成一个三角形。根据三角不等式定理，如果任意两边之和大于第三边，则这三条边可以构成一个
      三角形。

  4. p = (a + b + c) / 2

    • 功能：计算三角形的半周长p。公式为(a + b + c) / 2。

  5. area = math.sqrt(p * (p - a) * (p - b) * (p - c))

    • 功能：使用海伦公式计算三角形的面积。公式为sqrt(p * (p - a) * (p - b) * (p - c))，其中sqrt是math模块中的平
      方根函数。

  6. print(f"area={area:.2f}")

    • 功能：格式化输出三角形的面积。具体步骤如下：
      • f"area={area:.2f}"：使用Python的格式化字符串功能，将area保留两位小数。
      • print(...)：输出格式化后的字符串。

  7. else:

    • 功能：如果三条边长不能构成三角形，则执行这里的代码块。

  8. print("不能构成三角形")

    • 功能：输出提示信息，表示输入的三条边长不能构成一个三角形。
1
2
3
n = int(input("Input n:"))
sum_squares = sum(i**2 for i in range(1, n + 1))
print(f"sum={sum_squares}")
Input n: 2


sum=5

  1. n = int(input("Input n:"))

    • 功能：从用户输入中读取一个字符串，并将其转换为整数。具体步骤如下：
      • input("Input n:")：显示提示信息并 用户输入的字符串。
      • int(...)：将输入的字符串转换为整数。
      • n = ...：将转换后的整数赋值给变量n。

  2. sum_squares = sum(i**2 for i in range(1, n + 1))

    • 功能：计算从1到n的所有整数的平方和。具体步骤如下：
      • range(1, n + 1)：生成一个从1到n（包括n）的整数序列。
      • i**2 for i in range(...)：对每个整数i计算其平方，返回一个生成
        器表达式。
      • sum(...)：将生成器表达式中的所有值求和，并将结果赋值给变量
        sum_squares。

  3. print(f"sum={sum_squares}")

    • 功能：格式化输出平方和。具体步骤如下：
      • f"sum={sum_squares}"：使用Python的格式化字符串功能，将
        sum_squares插入到字符串中。
      • print(...)：输出格式化后的字符串。
1
2
3
4
5
6
7
8
9
10
11
n = int(input("input n:"))
scores = []
for _ in range(n):
    score = float(input("input the score:"))
    scores.append(score)

# 去掉一个最高分和一个最低分
scores.sort()
final_score = sum(scores[1:-1]) / (n - 2)
print(f"final score:{final_score:.2f}")

input n: 5
input the score: 99.5
input the score: 21.5
input the score: 91
input the score: 92
input the score: 93


final score:92.00

  1. n = int(input("input n:"))

    • 功能：从用户输入中读取一个字符串，并将其转换为整数。具体步骤如下：
      • input("input n:")：显示提示信息并获取用户输入的字符串。
      • int(...)：将输入的字符串转换为整数。
      • n = ...：将转换后的整数赋值给变量n。

  2. scores = []

    • 功能：初始化一个空列表scores，用于存储用户输入的分数。

  3. for _ in range(n):

    • 功能：使用for循环从用户输入中读取n个分数。具体步骤如下：
      • range(n)：生成一个从0到n-1的整数序列。
      • _：表示循环变量，这里不需要使用具体的值，所以用下划线表示。

  4. score = float(input("input the score:"))

    • 功能：在每次循环中，从用户输入中读取一个字符串，并将其转换为浮点数。
      具体步骤如下：

      • input("input the score:")：显示提示信息并获取用户输入的字符串。

      • float(...)：将输入的字符串转换为浮点数。

      • score = ...：将转换后的浮点数赋值给变量score。

  5. scores.append(score)

    • 功能：将每次循环中读取的分数添加到列表scores中。具体步骤如下：
      • scores.append(...)：将参数中的值添加到列表的末尾。
      • score：表示当前循环中读取的分数。

  6. # 去掉一个最高分和一个最低分

    • 功能：这是一个注释，说明接下来的代码将去掉一个最高分和一个最低分。

  7. scores.sort()

    • 功能：对列表scores中的分数进行排序。具体步骤如下：
      • scores.sort()：按照升序排列列表中的元素。
      • 排序后，第一个元素是最小值，最后一个元素是最大值。

  8. final_score = sum(scores[1:-1]) / (n - 2)

    • 功能：计算去掉一个最高分和一个最低分后的剩余分数的平均值。具体步骤如
      下：
      • scores[1:-1]：获取排序后列表中的第二个元素到倒数第二个元素（即去
        掉第一个和最后一个元素）。
      • sum(...)：将这些剩余分数求和。
      • (n - 2)：计算剩余分数的数量。
      • /：将总和除以剩余分数的数量，得到平均值。
      • final_score = ...：将计算出的平均值赋值给变量final_score。

  9. print(f"final score:{final_score:.2f}")

    • 功能：格式化输出去掉一个最高分和一个最低分后的平均分数。具体步骤如下
      ：
      • f"final score:{final_score:.2f}"：使用Python的格式化字符串功能，
        将final_score保留两位小数。
      • print(...)：输出格式化后的字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np

N = int(input())
arr = np.arange(1, N*N + 1).reshape(N, N)

# 取出第2行第1列的元素
element = arr[1, 0]
print(element)

# 取出第2列的元素
column = arr[:, 1]
print(column.tolist())

# 求该数组arr所有元素之和
total_sum = np.sum(arr)
print(total_sum)

# 按列求最大值
max_by_column = np.amax(arr, axis=0)
print(max_by_column.tolist())

# 该数组减去每一行的平均值
mean_by_row = np.mean(arr, axis=1, keepdims=True)
result = arr - mean_by_row
print(result.tolist())
 3


[[1 2 3]
 [4 5 6]
 [7 8 9]]
4
[2, 5, 8]
45
[7, 8, 9]
[[-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0]]

  1. import numpy as np

    • 功能：导入NumPy库，并将其命名为np。NumPy是一个用于科学计算的强大库
      ，提供了大量的数组和矩阵操作功能。

  2. N = int(input())

    • 功能：从用户输入中读取一个字符串，并将其转换为整数。具体步骤如下：
      • input()：显示提示信息并获取用户输入的字符串。
      • int(...)：将输入的字符串转换为整数。
      • N = ...：将转换后的整数赋值给变量N。

  3. arr = np.arange(1, N*N + 1).reshape(N, N)

    • 功能：创建一个从1到N*N的数组，并将其重塑为N x N的矩阵。具体步骤
      如下：

      • np.arange(1, N*N + 1)：生成一个包含从1到N*N的整数的一维数组。

      • .reshape(N, N)：将一维数组重塑为N x N的二维数组（矩阵）。

  4. # 取出第2行第1列的元素

    • 功能：这是一个注释，说明接下来的代码将取出第2行第1列的元素。

  5. element = arr[1, 0]

    • 功能：使用索引从矩阵中取出第2行第1列的元素。具体步骤如下：
      • arr[1, 0]：在NumPy数组中，索引从0开始，所以arr[1, 0]表示第二行
        第一列的元素。
      • element = ...：将取出的元素赋值给变量element。

  6. print(element)

    • 功能：输出取出的元素。

  7. # 取出第2列的元素

    • 功能：这是一个注释，说明接下来的代码将取出第2列的元素。

  8. column = arr[:, 1]

    • 功能：使用切片从矩阵中取出第2列的所有元素。具体步骤如下：
      • arr[:, 1]：在NumPy数组中，:表示所有行，所以arr[:, 1]表示第二
        列的所有元素。
      • column = ...：将取出的列赋值给变量column。

  9. print(column.tolist())

    • 功能：将取出的列转换为Python列表并输出。具体步骤如下：
      • .tolist()：将NumPy数组转换为Python列表。
      • print(...)：输出转换后的列表。

  10. # 求该数组arr所有元素之和

    • 功能：这是一个注释，说明接下来的代码将计算数组中所有元素的总和。

  11. total_sum = np.sum(arr)

    • 功能：使用NumPy函数np.sum()计算数组中所有元素的总和。具体步骤如下
      ：
      • np.sum(arr)：计算矩阵arr中所有元素的和。
      • total_sum = ...：将计算出的总和赋值给变量total_sum。

  12. print(total_sum)

    • 功能：输出数组中所有元素的总和。

  13. # 按列求最大值

    • 功能：这是一个注释，说明接下来的代码将按列求最大值。

  14. max_by_column = np.amax(arr, axis=0)

    • 功能：使用NumPy函数np.amax()按列求最大值。具体步骤如下：
      • np.amax(arr, axis=0)：计算矩阵arr每一列的最大值。参数
        axis=0表示按列操作。
      • max_by_column = ...：将计算出的最大值赋值给变量
        max_by_column。

  15. print(max_by_column.tolist())

    • 功能：将按列求得的最大值转换为Python列表并输出。具体步骤如下：
      • .tolist()：将NumPy数组转换为Python列表。
      • print(...)：输出转换后的列表。

  16. # 该数组减去每一行的平均值

    • 功能：这是一个注释，说明接下来的代码将该数组减去每一行的平均值。

  17. mean_by_row = np.mean(arr, axis=1, keepdims=True)

    • 功能：使用NumPy函数np.mean()计算每一行的平均值，并保持维度。具体
      步骤如下：
      • np.mean(arr, axis=1)：计算矩阵arr每一行的平均值。参数
        axis=1表示按行操作。
      • keepdims=True：保留原始数组的维度，使得结果是一个二维数组（每行
        一个平均值）。
      • mean_by_row = ...：将计算出的平均值赋值给变量mean_by_row。

  18. result = arr - mean_by_row

    • 功能：使用NumPy的广播机制，将原始矩阵减去每一行的平均值。具体步骤如
      下：
      • arr - mean_by_row：由于mean_by_row是一个二维数组（每行一个平
        均值），NumPy会自动将其广播到与arr相同的形状，并逐元素进行减法运算。
      • result = ...：将计算结果赋值给变量result。

  19. print(result.tolist())

    • 功能：将计算结果转换为Python列表并输出。具体步骤如下：
      • .tolist()：将NumPy数组转换为Python列表。
      • print(...)：输出转换后的列表。
1
2
3
4
5
6
7
8
9
10
11
12
import re
from collections import Counter

def WordCount(s):
    # 使用正则表达式分割字符串为单词，忽略标点符号，并转换为小写
    words = re.findall(r'\b\w+\b', s.lower())
    # 统计词频
    word_counts = Counter(words)
    return list(word_counts.items())

s = input()
print(WordCount(s))
 I'm a such beautiful girl. And I'm preaty.


[('i', 2), ('m', 2), ('a', 1), ('such', 1), ('beautiful', 1), ('girl', 1), ('and', 1), ('preaty', 1)]

  1. import re

    • 功能：导入Python内置的re模块，该模块提供了正则表达式的支持。

  2. from collections import Counter

    • 功能：从Python的collections模块中导入Counter类。Counter是一个
      用于计数的字典子类，可以方便地统计元素出现的频率。

  3. def WordCount(s):

    • 功能：定义一个名为WordCount的函数，该函数接受一个字符串参数s并返
      回一个包含单词及其频率的列表。

  4. # 使用正则表达式分割字符串为单词，忽略标点符号，并转换为小写

    • 功能：这是一个注释，解释接下来的代码将如何处理输入字符串。

  5. words = re.findall(r'\b\w+\b', s.lower())

    • 功能：使用正则表达式从字符串中提取单词。具体步骤如下：
      • s.lower()：将输入字符串转换为小写，以确保统计时不区分大小写。
      • re.findall(r'\b\w+\b', ...)：使用正则表达式\b\w+\b匹配单词。
        \b表示单词边界，\w+表示一个或多个字母、数字或下划线。
      • words = ...：将匹配到的单词列表赋值给变量words。

  6. # 统计词频

    • 功能：这是一个注释，解释接下来的代码将如何统计每个单词出现的频率。

  7. word_counts = Counter(words)

    • 功能：使用Counter类统计单词的频率。具体步骤如下：
      • Counter(words)：创建一个Counter对象，该对象会自动计算并存储每
        个单词在列表words中出现的次数。
      • word_counts = ...：将Counter对象赋值给变量word_counts。

  8. return list(word_counts.items())

    • 功能：返回一个包含单词及其频率的列表。具体步骤如下：
      • word_counts.items()：获取Counter对象中的所有键值对（即单词及其
        对应的频率）。
      • list(...)：将键值对转换为一个列表。
      • return ...：从函数中返回该列表。

  9. s = input()

    • 功能：从用户输入中读取一行字符串，并将其赋值给变量s。

  10. print(WordCount(s))

    • 功能：调用WordCount函数处理输入的字符串，并将结果打印到控制台。具
      体步骤如下：
      • WordCount(s)：调用WordCount函数，传入用户输入的字符串。
      • print(...)：将函数返回的结果（即单词及其频率的列表）打印到控制
        台。
1
2
3
4
5
6
7
8
9
import random

seed = int(input())
random.seed(seed)

with open('data.txt', 'w') as file:
    for _ in range(10):
        num = random.randint(1, 100)
        file.write(f"{num}\n")
 42

  1. import random

    • 功能：导入Python内置的random模块，该模块提供了生成随机数的功能。

  2. seed = int(input())

    • 功能：从用户输入中读取一行字符串，并将其转换为整数。这个整数将作为随
      机数生成器的种子值。
      • input()：从标准输入（通常是键盘）读取一行文本。
      • int(...)：将输入的字符串转换为整数。

  3. random.seed(seed)

    • 功能：使用用户提供的种子值初始化随机数生成器。具体步骤如下：
      • seed：传递给seed()函数的参数，即之前从用户输入中读取并转换的整
        数。
      • random.seed(...)：设置随机数生成器的种子值，使得后续生成的随机数
        序列可重复。

  4. with open('data.txt', 'w') as file:

    • 功能：使用上下文管理器打开一个名为data.txt的文件，并以写模式（
      ‘w’）进行操作。具体步骤如下：
      • 'data.txt'：指定要打开或创建的文件名。
      • 'w'：表示以写模式打开文件，如果文件已存在则会清空原有内容，如果
        不存在则会创建新文件。
      • with ... as file:：使用上下文管理器语法打开文件，确保在代码块执
        行完毕后自动关闭文件。

  5. for _ in range(10):

    • 功能：使用for循环重复执行其内部的代码块10次。具体步骤如下：
      • _：表示一个临时变量，用于接收循环次数，但不实际使用该变量。
      • range(10)：生成从0到9的整数序列。

  6. num = random.randint(1, 100)

    • 功能：生成一个在1到100之间的随机整数。具体步骤如下：
      • random.randint(1, 100)：调用randint()函数，生成一个范围在1到
        100（包括1和100）之间的随机整数。
      • num = ...：将生成的随机整数赋值给变量num。

  7. file.write(f"{num}\n")

    • 功能：将生成的随机数写入文件中，并在每个数字后添加一个换行符。具体步
      骤如下：
      • f"{num}\n"：使用格式化字符串（f-string）将变量num插入到字符串
        中，并在末尾添加一个换行符\n。
      • file.write(...)：调用文件对象的write()方法，将字符串写入文件。
1
2
3
n = int(input("请输入正整数n: "))
formatted_str = "{:*^20}".format(f"{n:,.0f}")  
print(formatted_str)
请输入正整数n:  12345


*******12,345*******

  1. n = int(input("请输入正整数n: "))

    • 功能：从用户输入中读取一行字符串，并将其转换为整数。具体步骤如下：
      • input("请输入正整数n: ")：提示用户输入一个正整数，并读取用户输入
        的一行文本。
      • int(...)：将输入的字符串转换为整数。
      • n = ...：将转换后的整数赋值给变量n。

  2. formatted_str = "{:*^20}".format(f"{n:,.0f}")

    • 功能：将变量n格式化为一个在20个字符宽度的字符串，其中数字居中对齐
      ，两侧用星号（*）填充。具体步骤如下：
      • f"{n:,.0f}"：使用格式化字符串（f-string）将变量n转换为带有千位
        分隔符的整数字符串。

        • n：表示要格式化的变量。

        • :,：在数字中插入千位分隔符，例如1234567会被格式化为1,234,567。

        • .0f：将浮点数格式化为整数形式，即去掉小数部分。

      • "{:*^20}"：定义了一个字符串格式化模板，用于生成最终的字符串。
        • *：表示用星号（*）字符填充空白区域。
        • ^20：表示总宽度为20个字符，并且内容居中对齐。
      • .format(...)：调用字符串对象的format()方法，将格式化字符串应用

到指定的内容上。

  1. print(formatted_str)
    • 功能：将格式化后的字符串输出到标准输出（通常是终端或控制台）。具体步
      骤如下：
      • formatted_str：表示要输出的变量。
      • print(...)：调用内置函数print()，在控制台上打印指定的内容。
1
2
3
n = int(input("请输入正整数n: "))
formatted_str = "{:*>20}".format(f"{n:,.0f}")
print(formatted_str)
请输入正整数n:  12345


**************12,345

1
2
3
n = int(input("请输入正整数n: "))
formatted_str = "{:*<20}".format(f"{n:,.0f}")
print(formatted_str)
请输入正整数n:  12345


12,345**************

1
2
3
4
n = int(input("Input n:"))
m = n if n % 2 == 0 else n - 1  
result = sum(i**2 for i in range(2, m + 1, 2))
print(f"result={result}")
Input n: 9


result=120

1
n = int(input("Input n: "))
  • input("Input n: "): 这是一个内置函数，用于从用户那里获取输入。它
    会显示提示信息 “Input n:”，并等待用户输入一个字符串。
  • int(...): 这是另一个内置函数，将传入的字符串转换为整数类型。这里
    将用户输入的字符串转换为整数并赋值给变量 n。
1
m = n if n % 2 == 0 else n - 1
  • n % 2 == 0: 这是一个条件表达式，用于检查 n 是否为偶数。如果
    n 是偶数（即 n 除以 2 的余数为 0），则返回 True。
  • m = n if n % 2 == 0 else n - 1: 这是一个三元运算符（也称为条件表
    达式）。如果 n % 2 == 0 为真（即 n 是偶数），则将 n 赋值给变量
    m；否则，将 n - 1 赋值给变量 m。这样确保了 m 总是偶数。
1
result = sum(i**2 for i in range(2, m + 1, 2))
  • range(2, m + 1, 2): 这是一个内置函数，用于生成一个从 2 到 m（包
    括 m）的数字序列。这里使用步长为 2，即每次增加 2，因此生成的是偶数序列
    。
  • i**2 for i in range(2, m + 1, 2): 这是一个生成器表达式，用于计算
    每个 i 的平方（i**2），其中 i 是从 2 到 m（包括 m）的偶数。
  • sum(...): 这是另一个内置函数，将生成器表达式中的所有值相加。这里
    它计算的是从 2 到 m（包括 m）的所有偶数的平方和。
1
print(f"result={result}")
  • f"result={result}": 这是一个 f-string，用于格式化字符串。其中
    {result} 会被变量 result 的值替换。
  • print(...): 这是另一个内置函数，将括号内的内容输出到控制台。这里
    它会显示格式化后的字符串 “result=…”，其中 ... 是 result 的实际值。
1
2
3
4
5
6
7
8
9
10
11
12
13
score = float(input("Input score:"))
if score > 100 or score < 0:
    print("Input error!")
elif 90 <= score <= 100:
    print("A")
elif 80 <= score < 90:
    print("B")
elif 70 <= score < 80:
    print("C")
elif 60 <= score < 70:
    print("D")
else:
    print("E")
Input score: 99


A

1
score = float(input("Input score:"))
  • input("Input score:"): 这是一个内置函数，用于从用户那里获取输入。
    它会显示提示信息 “Input score:”，并等待用户输入一个字符串。
  • float(...): 这是另一个内置函数，将传入的字符串转换为浮点数类型。
    这里将用户输入的字符串转换为浮点数并赋值给变量 score。
1
2
if score > 100 or score < 0:
    print("Input error!")
  • if score > 100 or score < 0:: 这是一个条件语句，用于检查
    score 是否超出有效范围（即大于 100 或小于 0）。如果满足条件，则执行后续
    的代码块。
  • print("Input error!"): 如果 score 不在有效范围内，此函数会将字
    符串 “Input error!” 输出到控制台。
1
2
elif 90 <= score <= 100:
    print("A")
  • elif 90 <= score <= 100:: 这是另一个条件语句，用于检查 score 是
    否在 90 到 100（包括 90 和 100）的范围内。如果满足条件，则执行后续的代码
    块。
  • print("A"): 如果 score 在这个范围内，此函数会将字符串 “A” 输出
    到控制台。
1
2
elif 80 <= score < 90:
    print("B")
  • elif 80 <= score < 90:: 这是另一个条件语句，用于检查 score 是否
    在 80 到 90（包括 80，不包括 90）的范围内。如果满足条件，则执行后续的代码
    块。
  • print("B"): 如果 score 在这个范围内，此函数会将字符串 “B” 输出
    到控制台。
1
2
elif 70 <= score < 80:
    print("C")
  • elif 70 <= score < 80:: 这是另一个条件语句，用于检查 score 是否
    在 70 到 80（包括 70，不包括 80）的范围内。如果满足条件，则执行后续的代码
    块。
  • print("C"): 如果 score 在这个范围内，此函数会将字符串 “C” 输出
    到控制台。
1
2
elif 60 <= score < 70:
    print("D")
  • elif 60 <= score < 70:: 这是另一个条件语句，用于检查 score 是否
    在 60 到 70（包括 60，不包括 70）的范围内。如果满足条件，则执行后续的代码
    块。
  • print("D"): 如果 score 在这个范围内，此函数会将字符串 “D” 输出
    到控制台。
1
2
else:
    print("E")
  • else:: 这是最后一个条件语句，如果前面的所有条件都不满足，则执行后
    续的代码块。
  • print("E"): 如果 score 不在任何上述范围内，此函数会将字符串
    “E” 输出到控制台。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
nums = []
while True:
    try:
        num = int(input())
        if num == -1:
            break
        nums.insert(0, num)
    except ValueError:
        continue

to_remove = int(input())
if to_remove in nums:
    nums.remove(to_remove)

print(" ".join(map(str, nums)))

 9
 8
 -1
 -1


8 9

1
nums = []
  • nums = []: 这行代码创建了一个空列表 nums。列表是一种可以存储多
    个元素的数据结构。
1
while True:
  • while True:: 这是一个无限循环，会一直执行其内部的代码块，直到遇到
    break 语句为止。
1
try:
  • try:: 这是异常处理的开始部分。如果在 try 块内的代码执行过程中发
    生错误，则程序会跳转到对应的 except 块。
1
num = int(input())
  • num = int(input()): 使用 input() 函数从用户那里获取输入，并使用
    int() 将其转换为整数。将结果赋值给变量 num。
1
2
if num == -1:
    break
  • if num == -1:: 这是一个条件语句，用于检查 num 是否等于 -1。如
    果满足条件，则执行后续的代码块。
  • break: 如果 num 等于 -1，则会跳出当前的无限循环。
1
nums.insert(0, num)
  • nums.insert(0, num): 使用 insert() 方法将 num 插入到列表
    nums 的第一个位置（即索引 0）。这使得每次输入的新数字都添加到列表的开头
    。
1
except ValueError:
  • except ValueError:: 这是异常处理的一部分，用于捕获 ValueError
    类型的错误。当用户输入的值不能被转换为整数时，会抛出这个类型的错误。
  • continue: 如果发生 ValueError，则执行 continue 语句，跳过当前
    循环的剩余部分，并继续下一次循环。
1
to_remove = int(input())
  • to_remove = int(input()): 使用 input() 函数从用户那里获取输入，
    并使用 int() 将其转换为整数。将结果赋值给变量 to_remove。
1
2
if to_remove in nums:
    nums.remove(to_remove)
  • if to_remove in nums:: 这是一个条件语句，用于检查 to_remove 是
    否存在于列表 nums 中。如果满足条件，则执行后续的代码块。
  • nums.remove(to_remove): 如果 to_remove 存在于列表中，则使用
    remove() 方法将其从列表中删除。
1
print(" ".join(map(str, nums)))
  • map(str, nums): 使用 map() 函数将列表 nums 中的每个元素转换为
    字符串。
  • " ".join(...): 使用 join() 方法将字符串列表连接成一个单一的字符
    串，元素之间用空格分隔。
  • print(...): 使用 print() 函数将最终生成的字符串输出到控制台。
1
2
3
4
5
6
7
8
9
10
dic1 = {'Tom': 21, 'Bob': 18, 'Jack': 23, 'Ana': 20}
dic2 = {'李雷': 21, '韩梅梅': 18, '小明': 23, '小红': 20}

n = int(input())

sorted_keys_dic1 = sorted(dic1.keys())[:n]
sorted_items_dic2 = sorted(dic2.items(), key=lambda item: item[1])[:n]

print(sorted_keys_dic1)
print(sorted_items_dic2)
 2


['Ana', 'Bob']
[('韩梅梅', 18), ('小红', 20)]

1
2
dic1 = {'Tom': 21, 'Bob': 18, 'Jack': 23, 'Ana': 20}
dic2 = {'李雷': 21, '韩梅梅': 18, '小明': 23, '小红': 20}
  • dic1 = {'Tom': 21, 'Bob': 18, 'Jack': 23, 'Ana': 20}: 创建一个字
    典 dic1，其中包含名字和年龄的键值对。
  • dic2 = {'李雷': 21, '韩梅梅': 18, '小明': 23, '小红': 20}: 创建另
    一个字典 dic2，其中包含名字和年龄的键值对。
1
n = int(input())
  • n = int(input()): 使用 input() 函数从用户那里获取输入，并使用
    int() 将其转换为整数。将结果赋值给变量 n。
1
sorted_keys_dic1 = sorted(dic1.keys())[:n]
  • dic1.keys(): 获取字典 dic1 的所有键，返回一个视图对象。
  • sorted(...): 使用 sorted() 函数对键进行排序，返回一个排序后的列
    表。
  • [:n]: 切片操作，获取排序后列表的前 n 个元素。最终结果赋值给变量
    sorted_keys_dic1。
1
sorted_items_dic2 = sorted(dic2.items(), key=lambda item: item[1])[:n]
  • dic2.items(): 获取字典 dic2 的所有键值对，返回一个视图对象。
  • sorted(...): 使用 sorted() 函数对键值对进行排序。这里使用
    key=lambda item: item[1] 指定排序的依据是字典项中的第二个元素（即年龄）
    。
  • [:n]: 切片操作，获取排序后列表的前 n 个元素。最终结果赋值给变量
    sorted_items_dic2。
1
2
print(sorted_keys_dic1)
print(sorted_items_dic2)
  • print(sorted_keys_dic1): 使用 print() 函数将
    sorted_keys_dic1 的内容输出到控制台。
  • print(sorted_items_dic2): 使用 print() 函数将
    sorted_items_dic2 的内容输出到控制台。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np

N = int(input("请输入整数N (N>=2): "))

# 生成全是1的N维数组
ones_array = np.ones(N)

# 生成N*N的矩阵
matrix = np.arange(N**2).reshape((N, N))

# 打印N维数组
print(ones_array)

# 打印矩阵
print(matrix)

# 打印矩阵所有元素的和
print(matrix.sum())

# 打印每一行的和
print(matrix.sum(axis=1))
请输入整数N (N>=2):  3


[1. 1. 1.]
[[0 1 2]
 [3 4 5]
 [6 7 8]]
36
[ 3 12 21]

1
import numpy as np
  • import numpy as np: 这行代码导入了 numpy 库，并将其命名为
    np。numpy 是一个用于科学计算的强大库，提供了多维数组对象（即矩阵）以
    及各种数学函数和操作。
1
N = int(input("请输入整数N (N>=2): "))
  • input("请输入整数N (N>=2): "): 使用 input() 函数从用户那里获取
    一个字符串输入，并提示用户输入一个整数 N，且要求 N 大于等于 2。
  • int(...): 将用户输入的字符串转换为整数类型。最终结果赋值给变量
    N。
1
2
# 生成全是1的N维数组
ones_array = np.ones(N)
  • np.ones(N): 使用 numpy 库中的 ones() 函数，创建一个包含 N 个
    元素的一维数组，且每个元素都是 1。最终结果赋值给变量 ones_array。
1
2
# 生成N*N的矩阵
matrix = np.arange(N**2).reshape((N, N))
  • np.arange(N**2): 使用 numpy 库中的 arange() 函数，创建一个包
    含从 0 到 (N^2 - 1) 的一维数组。
  • .reshape((N, N)): 对上述数组进行重塑操作，将其转换为 N 行 N 列的
    二维矩阵。最终结果赋值给变量 matrix。
1
2
# 打印N维数组
print(ones_array)
  • print(ones_array): 使用 print() 函数将 ones_array 的内容输出
    到控制台，显示一维数组中的所有元素。
1
2
# 打印矩阵
print(matrix)
  • print(matrix): 使用 print() 函数将 matrix 的内容输出到控制台
    ，显示 N 行 N 列的二维矩阵及其所有元素。
1
2
# 打印矩阵所有元素的和
print(matrix.sum())
  • matrix.sum(): 使用 numpy 库中的 sum() 方法计算矩阵中所有元素
    的总和。最终结果赋值给变量 matrix.sum()。
  • print(...): 将上述总和结果输出到控制台。
1
2
# 打印每一行的和
print(matrix.sum(axis=1))
  • matrix.sum(axis=1): 使用 numpy 库中的 sum() 方法计算矩阵中每
    一行元素的总和。参数 axis=1 指定了沿着行方向进行求和操作。最终结果赋值
    给变量 matrix.sum(axis=1)。
  • print(...): 将上述每一行的和结果输出到控制台。
1

Donate
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.

扫一扫，分享到微信

微信分享二维码
  • Copyrights © 2023-2025 John Doe
  • Visitors: | Views:

请我喝杯茶吧~

支付宝
微信