一、单选题
1、以下不符合 Python 语言变量命名规则的是（ ）。
A k
B 2_k
C _k
D ok
解析：【喵呜刷题小喵解析】：在Python语言中，变量名必须遵循一定的规则。根据Python的命名规则，变量名必须以字母或下划线开头，不能以数字开头。选项D中的"ok"以字母"o"开头，符合命名规则。选项A中的"k"、选项B中的"2_k"和选项C中的"_k"都是以字母或下划线开头，也符合命名规则。因此，不符合Python语言变量命名规则的是选项D。
2、已知：s = python，执行 print( s[-1] )语句后，输出的结果是（ ）。
A python
B p
C nohtyp
D n
解析：【喵呜刷题小喵解析】在Python中，字符串的索引是从0开始的。`s[-1]`表示取字符串`s`的最后一个字符。由于`s = python`，所以`s[-1]`的值是`n`，因此输出的结果是`p`。
3、运行 print(type(str(3.14)))语句后，输出的是（ ）。
A class ‘int’
B class ‘complex’
C class ‘float’
D class ‘str’
解析：【喵呜刷题小喵解析】：在这个问题中，我们有一个`print(type(str(3.14)))`语句。首先，`str(3.14)`将浮点数3.14转换为字符串`'3.14'`。然后，`type()`函数返回该对象的类型。在这种情况下，该对象是一个字符串，所以`type(str(3.14))`将返回字符串类型的类。因此，`print(type(str(3.14)))`将输出`'class ‘str’'`。所以，正确答案是D。
4、在 Python 中，以下哪个选项可以用来遍历一个字典的键和值？（ ）
A for key, value in dict.items()
B for key, value in dict.keys_values()
C for key, value in dict.iter()
D for key, value in dict.loop()
解析：【喵呜刷题小喵解析】在Python中，遍历字典的键和值通常使用`dict.items()`方法。这个方法返回一个包含字典中所有键-值对的视图对象，可以直接在for循环中使用。因此，选项A中的`for key, value in dict.items()`是正确的。选项B中的`dict.keys_values()`并不是Python字典的有效方法，选项C中的`dict.iter()`也不是，选项D中的`dict.loop()`同样不是Python字典的有效方法。
5、在 Python 中，以下哪个选项用于获取一个文件的大小？（ ）
A os.path.size()
B os.path.getsize()
C os.path.length()
D os.path.filesize()
解析：【喵呜刷题小喵解析】：在 Python 中，获取文件大小的函数是 `os.path.getsize()`，因此正确答案是 B。`os.path.size()` 并不是 Python 的标准库函数，`os.path.length()` 和 `os.path.filesize()` 也不是标准库中的函数。因此，选项 A、C 和 D 都是错误的。
二、实操题
6、编程实现：
给定一个字符，连续输出 3 个该字符。
例如：字符为 A，连续 3 个字符为 AAA。
输入描述：
输入一个字符
输出描述：
输出连续 3 个该字符（字符之间没有空格）
样例输入：
A
样例输出：
AAA
参考答案：```pythonchar = input("请输入一个字符：")print(char * 3)```
解析：【喵呜刷题小喵解析】：
这个题目要求编写一个程序，输入一个字符，然后连续输出3个该字符。我们可以使用Python编程语言来实现这个需求。
首先，我们使用`input()`函数获取用户输入的字符，并将其存储在变量`char`中。
然后，我们使用字符串的乘法操作符`*`将字符`char`重复3次，得到一个新的字符串`char * 3`。
最后，我们使用`print()`函数输出这个新的字符串。
在输出时，字符之间没有空格，所以直接用`print()`函数输出即可。
需要注意的是，这个程序没有对输入进行校验，如果用户输入的不是单个字符，程序可能会出现问题。如果需要，可以添加输入校验的代码来确保程序的正确性。
7、编程实现：
给定一个字符串 S（3≤S 长度≤1000），输出字符串 S 的最后两个字符。
例如：S =“abcd”，abcd 最后两个字符为“cd”，则输出 cd。
输入描述：
输入一个字符串 S（3≤S 长度≤1000）
输出描述：
输出一个字符串，表示字符串 S 的最后两个字符
样例输入：
abcd
样例输出：
cd
参考答案：br />```pythondef get_last_two_chars(s):if len(s) < 3:return ""else:return s[-2:]# 测试s = input("请输入字符串：")print(get_last_two_chars(s))```
解析：【喵呜刷题小喵解析】
首先，我们定义了一个函数`get_last_two_chars`，它接受一个字符串`s`作为输入。在函数内部，我们首先检查字符串`s`的长度是否小于3，如果是，那么直接返回空字符串。否则，我们返回字符串`s`的最后两个字符，这是通过切片操作`s[-2:]`实现的。
然后，我们调用`input`函数获取用户输入的字符串，并将其传递给`get_last_two_chars`函数。最后，我们打印出函数返回的结果。
在样例输入中，用户输入了字符串"abcd"，函数返回了"cd"，这正是我们期望的输出。
8、编程实现：
给定一个正整数 N（100≤N≤1000000），分别将 N 中奇数位上的数字相加，偶数位上的数字相加，最后将两个相加的和相乘，并输出相乘的结果（奇数位包含个位、百位、万位、百万位，偶数位包含十位、千位、十万位）。
例如：N=1234，奇数位上的数字为 4、2，相加的和为 6；偶数位上的数字为 3、1，相加的和为 4；最后相乘的结果为 24（24=64）。
输入描述：
输入一个正整数 N（100≤N≤1000000）
输出描述：
输出一个整数，表示奇数位和与偶数位和相乘的结果
样例输入：
1234
样例输出：
24
参考答案：br />```pythondef calculate(N):odd_sum = 0even_sum = 0for i in range(len(str(N))):if i % 2 == 0:even_sum += int(str(N)[i])else:odd_sum += int(str(N)[i])return odd_sum * even_sumN = int(input())print(calculate(N))```
解析：【喵呜刷题小喵解析】
首先，我们定义一个函数`calculate`，它接受一个正整数`N`作为输入。
在函数内部，我们初始化两个变量`odd_sum`和`even_sum`，分别用于存储奇数位和偶数位上数字的和。
然后，我们遍历`N`的每一位数字，将其转化为字符串后通过索引访问。对于每一位数字，如果其索引`i`是偶数，则将其加入到`even_sum`中；否则，将其加入到`odd_sum`中。
最后，我们返回`odd_sum`和`even_sum`的乘积。
在主程序中，我们先读取输入的正整数`N`，然后调用`calculate`函数计算结果，并将结果打印输出。
样例输入1234时，奇数位上的数字为4、2，相加的和为6；偶数位上的数字为3、1，相加的和为4；最后相乘的结果为24（24=6*4）。
9、编程实现：
有 1 个细胞，从第二天开始，它每天早上会分裂出 1 个新的细胞（分裂这天算新细胞的第一天）。每个新分裂的细胞从它出生的第 3 天开始，每天早上也会分裂出 1 个细胞。
请计算出到第 N（2≤N≤30）天晚上共有多少个细胞（假设细胞不会死亡）。
例如：N = 5，第 5 天晚上共有 8 个细胞。
输入描述：
输入一个正整数 N（2≤N≤30）
输出描述：
输出一个整数，表示到第 N 天晚上细胞的总个数
样例输入：
5
样例输出：
8
参考答案：```pythondef count_cells(n):if n == 2:return 2elif n == 3:return 4else:return 2 + 2 * count_cells(n - 2)N = int(input())print(count_cells(N))```
解析：【喵呜刷题小喵解析】：
本题可以使用递归方法解决。
首先，对于给定的天数N，我们需要找到第N天晚上细胞的总个数。
根据题目描述，我们知道：
1. 第1天晚上有1个细胞。
2. 第2天早上细胞分裂，所以第2天晚上有2个细胞。
3. 从第3天开始，每个细胞每天早上都会分裂出1个新的细胞。
因此，我们可以使用递归的思想来求解。
具体地，我们可以定义一个函数`count_cells(n)`，表示第n天晚上细胞的总个数。
如果n等于2，那么直接返回2；
如果n等于3，那么直接返回4；
否则，返回2 + 2 * `count_cells(n - 2)`，其中2表示第2天晚上已经存在的细胞个数，2 * `count_cells(n - 2)`表示第n-1天晚上分裂出的细胞个数。
最后，我们只需要调用`count_cells(N)`即可得到第N天晚上细胞的总个数。
10、编程实现：
在一个 M 行 N 列的网格中放有若干个坚果（一个小格子里最多放一个坚果），第 X 行 Y 列的小格子是小松鼠的家。
小松鼠可以向上下左右的格子移动寻找坚果，但它每次从家出发后，最多可以移动 K 个小格子，发现格子中有坚果，就会将其运回家储藏起来（运回家所移动的格子不做计算），然后再从家出发寻找其他坚果。小松鼠最多可以储藏几个坚果。
例如：M=7，N=6，X=3，Y=4，K=3，在 7 行 6 列的网格中有若干个坚果（如下图），小松鼠的家在第 3 行，第 4 列的位置，最多可以移动 3 个小格。
小松鼠最多可以储藏 7 个坚果（小格子底色为绿色的坚果）。
输入描述：
第一行输入两个正整数 M 和 N（2≤M≤30，1≤N≤30），表示 M 行 N 列的网格，两个正整数之间以一个英文逗号隔开；
第二行输入两个正整数 X 和 Y（1≤X≤M，1≤Y≤N），表示小松鼠家的位置在第 X 行第 Y 列，两个正整数之间以一个英文逗号隔开；
第三行输入一个正整数 K（1≤K≤max(M, N)-1），表示小松鼠从家出发后，最多可以移动的小格子数第四行开始，输入 M 行，每行 N 个整数，除了第 X 行 Y 列的小格子用 2 表示小松鼠的家，其他小格子的整数只能是 0 或者 1。0 表示小格子中没有坚果，1 表示小格子中有 1 个坚果，整数之间以一个英文逗号隔开。
输出描述：
输出一个整数，表示小松鼠最多可以储藏的坚果数量。
样例输入：
7,6 3,4 3 0,0,1,0,1,0 0,0,0,0,1,0 0,1,0,2,0,0 1,0,0,1,0,1 0,0,1,0,0,0 0,0,0,0,0,1 1,0,0,1,0,0
样例输出：
7
参考答案：```pythondef max_nuts(M, N, X, Y, K):grid = [[0] * N for _ in range(M)]for i in range(M):grid[i] = list(map(int, input().split()))visited = [[False] * N for _ in range(M)]visited[X-1][Y-1] = Truestack = [(X-1, Y-1)]nuts = 0directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]while stack:x, y = stack.pop()for dx, dy in directions:nx, ny = x + dx, y + dyif 0 <= nx < M and 0 <= ny < N and not visited[nx][ny] and abs(nx-x) + abs(ny-y) <= K:if grid[nx][ny] == 1:visited[nx][ny] = Truenuts += 1stack.append((nx, ny))return nutsM, N = map(int, input().split())X, Y = map(int, input().split())K = int(input())print(max_nuts(M, N, X, Y, K))```
解析：【喵呜刷题小喵解析】：
本题是一个典型的广度优先搜索（BFS）问题。我们可以使用队列来实现BFS。
首先，我们定义一个二维数组grid来存储网格中的坚果，其中0表示没有坚果，1表示有一个坚果。
然后，我们定义一个二维数组visited来记录每个格子是否被访问过，初始时只有小松鼠的家被标记为已访问。
接着，我们定义一个队列stack，并将小松鼠的家作为起点加入队列。
然后，我们定义一个变量nuts来记录小松鼠最多可以储藏的坚果数量，初始值为0。
最后，我们定义一个变量directions来存储四个方向的偏移量，即上、下、左、右。
在BFS的过程中，我们每次从队列中取出一个格子，然后遍历其四个相邻的格子。如果相邻的格子没有被访问过，且小松鼠可以到达该格子（即小松鼠从家出发后，最多可以移动的小格子数不超过K），则将该格子加入队列，并将其标记为已访问。如果该格子中有坚果，则将该格子中的坚果数量加入nuts。
最后，我们返回nuts即为小松鼠最多可以储藏的坚果数量。
11、编程实现：
蚂蚁王国住着 N 只蚂蚁，每只蚂蚁都有自己的领地，领地之间可以直接到达或经过其他领地间接到达，可以直接到达的领地之间的道路距离都为 1，但所有领地都有一条唯一的最短路径可以相互到达。
现要在 N 块领地（依次编号为 1~N）中，选出一块领地建立游乐场，使得所有蚂蚁到游乐场的最小距离总和是 N 种情况中最小的。
例如：N = 8，1~8 号领地之间的连接关系为：1 和 5、2 和 6、3 和 6、4 和 5、5 和 6、4 和 7、5 和 8。
如果将游乐场创建在 5 号领地，最小距离总和为 10。
1 号到 5 号距离为 1；2 号到 5 号距离为 2；3 号到 5 号距离为 2；4 号到 5 号距离为 1；6 号到 5 号距离为 1；
7 号到 5 号距离为 2；8 号到 5 号距离为 1。
如果将游乐场创建在 6 号领地，最小距离总和为 12。
1 号到 6 号距离为 2；2 号到 6 号距离为 1；3 号到 6 号距离为 1；4 号到 6 号距离为 2；5 号到 6 号距离为 1；
7 号到 6 号距离为 3；8 号到 6 号距离为 2。
……
可以发现，将游乐场创建在 5 号领地，最小距离总和 10 是最小的，故输出 10。
输入描述：
第一行输入一个正整数 N（2≤N≤20），表示领地数量
接下来输入 N-1 行，每行包含两个正整数（1≤正整数≤N，两个正整数不相同），表示两块领地相互之间可以直接到达，正整数之间以一个英文逗号隔开（数据保证 N 块领地相互之间可以到达）
输出描述：
输出一个整数，表示 N 种情况中最小距离总和的最小值
样例输入：
8 1,5 2,6 3,6 4,5 5,6 4,7 5,8
样例输出：
10
参考答案：```pythonfrom collections import defaultdictdef min_distance_sum(N, edges):# 构建邻接矩阵graph = defaultdict(list)for u, v in edges:graph[u].append(v)graph[v].append(u)# 使用 Floyd-Warshall 算法计算任意两点间的最短距离dist = [[float('inf')] * (N + 1) for _ in range(N + 1)]for i in range(1, N + 1):dist[i][i] = 0for k in range(1, N + 1):for i in range(1, N + 1):for j in range(1, N + 1):dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])# 遍历每个点作为游乐场，计算最小距离总和min_sum = float('inf')for i in range(1, N + 1):total_dist = 0for j in range(1, N + 1):total_dist += dist[i][j]min_sum = min(min_sum, total_dist)return min_sumN = int(input())edges = [tuple(map(int, input().split(','))) for _ in range(N - 1)]print(min_distance_sum(N, edges))```
解析：【喵呜刷题小喵解析】：
首先，我们需要构建邻接矩阵来表示领地之间的连接关系。在这个问题中，我们使用 Python 的 defaultdict 数据结构来创建邻接矩阵。对于输入的每对连接，我们将其添加到邻接矩阵中。
然后，我们使用 Floyd-Warshall 算法来计算任意两点间的最短距离。Floyd-Warshall 算法是一种动态规划算法，可以计算出任意两点间的最短路径。
最后，我们遍历每个点作为游乐场，计算最小距离总和。对于每个点，我们计算从该点到所有其他点的距离之和，并更新最小距离总和。
在 Python 中，我们可以使用 input() 函数来读取输入，并使用 print() 函数来输出结果。在这个问题中，我们读取领地数量和连接关系，然后调用 min_distance_sum() 函数来计算最小距离总和，并将结果输出到控制台。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
