python期末复习
需要选择题pdf和编程题源码，见文章末尾哦
一、选择题
1、以下选项中，不属于函数的作用的是 （）
A 、提高代码执行速度
B、 降低编程复杂度
C、 增强代码可读性
D、 复用代码
2、关于 Python 语言的注释，以下选项中描述错误的是（）
A、Python 语言的单行注释以’开头
B、Python 语言的单行注释以#单引号开头
C、Python 语言的多行注释以”” (三个单引号)开头和结尾
D、Python 语言有两种注释方式:单行注释和多行注释
3、关于 Python 字符串，以下选项中措述错误的是（）
A、可以使用 datatype()测试字符串的类型
B、输出带有引号的字符串，可以使用转义字符
C、字符串是一个字符序列，字符串中的编号叫“索引”
D、字符串可以保存在变量中，也可以单独存
4、给出如下代码:
DictColor = {"seashell":"海贝色","gold":“金色","pink":"粉红色","brown":"棕色","purple":"紫","tomato":"西红柿色"}
以下选项中能输出“海贝色的是
A、print(DictColor. keys)
B、print(DictColor.[“海贝色”])
C、print(DictColor.values()
D、print(DictColr["seashell"])
5、文件 book.txt 在当前程序所在目录内,其内容是一段文本: book, 下面代码的输出结果是
txt = open("book.txt", "r')
print(txt)
txt.close()
A、book.txt
B、txt
C、book
D、以上答案都不对
6 关于 Python 组合数据类型，以下选项中描述错误的是（ ）
A、Python 的 str、tuple 和 list 类型都属于序列类型
B、Python 组合数据类型能够将多个同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易
C、组合数据类型可以分为 3 类：序列类型、集合类型和映射类型
D、序列类型是二维元素向量，元素之间存在先后关系，通过序号访问
7 下面代码的输出结果是 （ ）
d ={"大海":"蓝色", "天空":"灰色", "大地":"黑色"}
print(d["大地"], d.get("大地", "黄色"))
A、黑色 黄色
B、黑色 黑色
C、黑的 灰色
D、黑色 蓝色
8 下面代码的执行结果是：（ ）
d = {}
for i in range(26):
d[chr(i+ord("a"))] = chr((i+13) % 26 + ord("a"))
for c in "Python":
print(d.get(c, c), end="")
A、Plguba
B、Cabugl
C、Python
D、Pabugl
9 关于 Python 语言的浮点数类型，以下选项中描述错误的是 （ ）
A、Python 语言要求所有浮点数必须带有小数部分
B、浮点数类型与数学中实数的概念一致
C、小数部分不可以为 0
D、浮点数类型表示带有小数的类型
10 关于 Python 程序中与“缩进”有关的说法中，以下选项中正确的是 （）
A、缩进统一为 4 个空格
B、缩进是非强制性的，仅为了提高代码可读性
C、缩进在程序中长度统一且强制使用
D、缩进可以用在任何语句之后，表示语句间的包含关系
11 下面代码的输出结果是 （ ）
s = "The python language is a cross platform language."
print(s.find('language',30))
A、11
B、40
C、10
D、报错
12 关于 Python 循环结构，以下选项中描述错误的是 （ ）
A、Python 通过 for、while 等保留字ᨀ供遍历循环和无限循环结构
B、break 用来跳出最内层 for 或者 while 循环，脱离该循环后程序从循环代码后继续执行
C、每个 continue 语句只有能力跳出当前层次的循环
D、遍历循环中的遍历结构可以是字符串、文件、组合数据类型和 range()函数等
13 以下选项中描述正确的是 （ ）
A、条件 24<=28<25 是不合法的
B、条件 24<=28<25 是合法的，且输出为 True
C、条件 35<=45<75 是合法的，且输出为 False
D、条件 24<=28<25 是合法的，且输出为 False
14 在 Python 中，关于全局变量和局部变量，以下选项中描述不正确的是 （ ）
A、一个程序中的变量包含两类：全局变量和局部变量
B、全局变量不能和局部变量重名
C、全局变量一般没有缩进
D、全局变量在程序执行的全过程有效
15 关于 Python 文件打开模式的描述，以下选项中错误的是（）
A、只读模式 r
B、追加写模式 a
C、创建写模式 n
D、覆盖写模式 w
16．下列哪个语句在 Python 中是非法的？ （）
A、x = y = z = 1
B、x = (y = z + 1)
C、x, y = y, x
D、x += y
17．关于 Python 内存管理，下列说法错误的是 （）
A、变量不必事先声明
B、变量无须先创建和赋值而直接使用
C、变量无须指定类型
D、可以使用 del 释放资源
18.print 100 – 25 * 3 % 4 应该输出什么?()
A、1
B、97
C、25
D、0
19、下面哪个不是 Python 合法的标识符 （）
A、int32
B、40XL
C、self
D、_name
20、下列哪种说法是错误的 （）
A、除字典类型外，所有标准对象均可以用于布尔测试
B、空字符串的布尔值是 False
C、空列表对象的布尔值是 False
D、值为 0 的任何数字对象的布尔值是 False
21、下列表达式的值为 True 的是 （）
A、5+4j > 2-3j
B、3>2>2
C、1==1 and 2!=1
D、not(1==1and 0!=1)
22、Python 不支持的数据类型有 （）
A、char
B、int
C、float
D、list
23、以下不能创建一个字典的语句是 （
A、dict1 = {}
B、dict2 = { 3 : 5 }
C、dict3 = dict( [2 , 5] ,[ 3 , 4 ] )
D、dict4 = dict( ( [1,2],[3,4] ) )
24、下面不能创建一个集合的语句是 （）
A、s1 = set ()
B、s2 = set (“abcd”)
C、s3 = (1, 2, 3, 4)
D、s4 = frozenset( (3,2,1) )
25、下列 Python 语句正确的是 （）
A、min = x if x < y else y
B、max = x > y and?x : y
C、if (x > y) print x
D、while True : pass
26.以下叙述正确的是？（）
A. continue 语句的作用是结束整个循环的执行
B. 只能在循环体内使用 break 语句
C. 在循环体内使用 break 语句或 continue 语句的作用相同
D. 从多层循环嵌套中退出时，只能使用 goto 语句
27.关于 Python 的 lambda 函数，以下选项中描述错误的是?()
A. lambda 函数将函数名作为函数结果返回
B. f = lambda x,y:x+y 执行后，f 的类型为数字类型
C. lambda 用于定义简单的、能够在一行内表示的函数
D. 可以使用 lambda 函数定义列表的排序原则
28.print(“ab” + “c”*2)的结果是?
A. abc2
B. abcabc
C. abcc
D. ababcc
29.程序代码如下
try:
number = int(input(“请输入数字：”))
print(“number:”,number)
print(“=hello”)
except Exception as e: # 报错错误日志
print("打印异常详情信息： ",e)
else: print(“没有异常”)
finally:#关闭资源
print(“finally”) print(“end”)
输入的是 1a 结果是？()
A. number: 1 打印异常详情信息： invalid literal for int() with base 10:‘1a’ finally end
B. 打印异常详情信息： invalid literal for int() with base 10:‘1a’ finally end
C. hello=== 打印异常详情信息： invalid literal for int() with base 10:‘1a’ finally end
D. 以上都不正确
30.Python 中的映射类型有哪些？()
A. 列表、字典
B. 列表
C.列表、元组
D. 字典
31.关于程序的异常处理，以下选项中描述错误的是?
A. 程序异常发生经过妥善处理可以继续执行
B. 异常语句可以与 else 和 finally 保留字配合使用
C. 编程语言中的异常和错误是完全相同的概念
D. Python 通过 try、except 等保留字ᨀ供异常处理功能
32.计算机中信息处理和信息储存用?()
A. 二进制代码
B. 十进制代码
C. 十六进制代码
D. ASCII 代码
33.导入模块的方式错误的是？()
A. import numpy
B. from numpy import *
C. import numpy as np
D. import numpy from xxx
34.关于 Python 中的复数，下列说法错误的是?
A. 表示复数的语法是 real + image j
B. 实部和虚部都是浮点数
C. 虚部必须后缀 j，且必须是小写
D. 方法 conjugate 返回复数的共轭复数
35.以下关于模块说法错误的是?
A. 一个 xx.py 就是一个模块
B. 任何一个普通的 xx.py 文件可以作为模块导入
C. 模块文件的扩展名不一定是 .py
D. 运行时会从制定的目录搜索导入的模块，如果没有，会报错异常
36.以下选项中，不是 Python 对文件的打开模式的是?
A. r’
B. +’
C. ‘w’
D. c’
37.关于面向对象的继承，以下选项中描述正确的是?()
A. 继承是指一组对象所具有的相似性质
B. 继承是指类之间共享属性和操作的机制
C. 继承是指各对象之间的共同性质
D. 继承是指一个对象具有另一个对象的性质
38.关于字符串下列说法错误的是？(B)
A. 字符应该视为长度为 1 的字符串
B. 字符串以\0 标志字符串的结束
C. 既可以用单引号，也可以用双引号创建字符串
D. 在三引号字符串中可以包含换行回车等特殊字符
39.下面这段代码运行结果是？ kvps = { ‘1’ :1, ‘2’ : 2 } theCopy =kvps.copy() kvps[‘1’]
= 5 sum = kvps[‘1’]+ theCopy[‘1’] print(sum)
A. 2
B. 11
C. 15
D. 6
40.以下会出现错误的是？()
A. ‘天池’.encode()
B. ‘天池’.decode()
C. ‘天池’.encode().decode()
D. 以上都不会出错
编程题
1、数列的求和，求积
# 简单数列和积求解
def sum_and_product(n):
sum_n = sum(range(1, n+1))
product_n = 1
for i in range(1, n+1):
product_n *= i
print(f"和与积分别是{sum_n},{product_n}")
sum_and_product(10)
# 亦或是实验中的 计算表达式 a+aa+aaa+aaaa 的值
n = eval(input())
args = 0
num = 0
for i in range(1, 5):
args = args * 10 + n
num += args
print(num)
2、最大公约数，最小公倍数的求法（辗转相除法）
def gcd(a, b):
while b: # 因 b = a % b ,a % b最终都会等于0，故可以作为循环退出条件
a, b = b, a % b # 辗转相除法
return a
def lcm(a, b):
return a * b // gcd(a, b)
# 示例：求60和48的最大公约数和最小公倍数
# a,b = map(int, input().split(","))
gcd_result = gcd(60, 48) # 最大公约数
lcm_result = lcm(60, 48) # 最小公倍数
print(f"最大公约数:{gcd_result}")
print(f"最小公倍数:{lcm_result}")
3、分段函数的表示与求解
import math
def piecewise_function(x):
if x < 0:
return x**2
else:
return math.sqrt(x)
# 示例：计算x为-2和2时的函数值
piecewise_result_negative = piecewise_function(-2) # x为负数的情况
piecewise_result_positive = piecewise_function(4) # x为正数的情况
print(piecewise_result_positive)
print(piecewise_result_negative)
亦或是实验中这题
x = eval(input())
#请在这行下面补上代码
if x < 0:
y = x * x + 1
else:
y = x - 10
print (y)
4、如何求完备数
"""
完备数（完美数）是它所有真因子（即除了自身以外的约数）的和等于它本身的数
例如，6的真因子为1, 2, 3，且1+2+3=6，所以6是一个完备数
"""
# 简便式函数式编程
def is_perfect_number(n):
# sum_of_divisors = sum([i for i in range(1, n) if n % i == 0])
sum_of_divisors = sum(i for i in range(1, n) if n % i == 0)
return sum_of_divisors == n
# 测试代码
is_perfect_number_6 = is_perfect_number(6) # 测试6是否是完备数
is_perfect_number_28 = is_perfect_number(28) # 测试28是否是完备数
print(is_perfect_number_6)
print(is_perfect_number_28)
# -------------------------------------------
# 复盘式写法
input_num = eval(input())
# 1、简便式写法
sum_of_division = sum(i for i in range(1,input_num) if input_num % i == 0)
# 2、传统式写法
sum = 0
for i in range(1, input_num):
if input_num % i == 0:
sum += i
if sum_of_division == input_num:
print("True")
else:
print("False")
5、用数字产生字典的方法
def create_dict_from_numbers(numbers):
return {num: num ** 2 for num in numbers}
# 测试代码
print(create_dict_from_numbers([1, 2, 3, 4, 5])) # 以1到5的数字创建字典
# -------------------------------------------------
#亦或是实验中的
#使用给定的正整数 n，编写一个程序生成一个包含(i, i*i)的字典，该字典包含 1 到 n 之间的整数(两者都包含)。然后程序应该打印字典
n = int(input())
d = {}
for i in range(1,n+1):
d[i] = i*i
print(d)
6、文本中的单词去重（用集合），排序
def unique_sorted_words(text):
words = text.split()
unique_words = sorted(set(words))
return unique_words
# 测试代码
text = "apple banana apple orange banana grape"
print(unique_sorted_words(text))
7、凯撒密码（字符表中数字移位变换）
# 通过定义一个函数进行判断，函数的参数是文本和加密偏移数
def caesar_cipher(text, shift):
result = ""
for i in range(len(text)):
char = text[i]
if char.isupper():
result += chr((ord(char) + shift - 65) % 26 + 65) # 大写'A' -> 65
else:
result += chr((ord(char) + shift - 97) % 26 + 97) # 小写'a' -> 97
return result
input_text = input()
print(caesar_cipher(input_text, 3))
# 亦或是实验中
"""
思路：
1.输入
2.准备一个空的字符串接收转换后的每个字符拼接
3.通过遍历的方式取得每一个字符
4.通过 （x-97+n）%26+97 / （x - 65 + n）%26+65分成两类
5.拼接
"""
input_str = input()
out_str = ""
for char in input_str:
input_chr = ord(char)
if char.islower():
out_chr = chr((input_chr - ord('a') + 3) % 26 + ord('a'))
else:
out_chr = chr((input_chr - ord('A') + 3) % 26 + ord('A'))
out_str += out_chr
print(out_str)
8 、评分问题（按规则评分）
"""
输入n个评委的成绩，去掉一个最高分，一个最低分，然后求平均值（保留两位小数）
100,95,60,80 -> 87.50
"""
num = input().split(",") # 输入的是一个字符串
list = [int(x) for x in num] # 将num中的每个数字拿出来，并且转换成数字型，将其放在一个列表中
list.remove(min(list)) # 去除最小值
list.remove(max(list)) # 去除最大值
# 对list的各个数字进行求和，再求平均
sum = 0
for k in list:
sum += k
avr = sum / len(list)
print('{:.2f}'.format(avr))
# ----------------------------------------------------------------------------
# 亦或是实验中的
def c_a_s(s):
if len(s) < 3:
return 0
s.sort()
s = s[1:-1]
a_s = sum(s) / len(s)
return a_s
s_s = input()
s = [float(s) for s in s_s.split(',')]
a = c_a_s(s)
print("{:.2f}".format(a))
9、回文数的判断
# 通用型判断回文
def is_palindrome(num):
return str(num) == str(num)[::-1]
print(is_palindrome("aba"))
print(is_palindrome(123456))
print(is_palindrome(1221))
# -------------------------------------
#亦或是实验中的
str_1 = input()
str_2 = str_1.replace(" ", "").lower()
# 对输入的字符串进行格式处理
# 1、去掉多余的空格
# 2、将全部转成小写以便判断
# 3、通过切片中--> [::-1]表示列表倒叙
is_palindrome = str_2 == str_2[::-1]
print(is_palindrome)
10、素数判断求解
"""素数是只有1和它本身两个因数的自然数"""
def is_prime(num):
if num <= 1:
return False
for i in range(2, int(num**0.5) + 1):
# for i in range(2,num):
if num % i == 0:
return False
return True
print(is_prime(17))
print(is_prime(28))
# ----------------------------------------------------------
#亦或是实验中的
"""
思路：
1、准备输入的接收
2、确保输入的数字是左小右大
3、定义函数来判断每个数是否是素数
4、判断依据是若这个数可以被这个范围的任意（不含1和本身）数整除既不是
5、用一个变量来接收遍历的字符串，得到素数字符串
6、将素数字符串用空格隔开输出
"""
m, n = map(int, input().split(","))
# 确保左小右大
if m > n:
m, n = n, m
# 定义分函数来判断每个数是否是素数
def is_prime(num):
if num < 2:
return False
# 利用一个数若存在除了1和其本身外还有因子
# 这对因子一定在这个数一半的位置两侧的性质优化时间
for i in range(2, int(num * 0.5) + 1):
if num % i == 0:
return False
return True
# 准备一个str字符串来接收遍历整个范围中满足是素数的数，放到K中
k = [str(x) for x in range(m, n + 1) if is_prime(x)]
if len(k) == 0:
print(-1)
else:
print(" ".join(k))
11、特定数(按一定要求）查找
"""
类似于实验中的这题
编写一个程序。输入2个3位的正整数m,n 求他们之间的所有这些数字（均包括在内），这样数字的每个数字都是偶数。
"""
num_1, num_2 = map(int, input().split())
list = []
if num_1 > num_2:
num_1, num_2 = num_2, num_1
for i in range(num_1, num_2 + 1):
if (i // 100) % 2 == 0 and (i // 10) % 2 == 0 and (i % 2) == 0:
list.append(i)
print(list)
list_2 = [str(item) for item in list] # 将list列表转换成字符串str，通过join进行拼接
print(",".join(list_2))
12、三条线段能否构成三角形
def can_form_triangle(a, b, c):
return a + b > c and a + c > b and b + c > a
# 通过用户自己输入
a, c, b = map(float, input().split(","))
print(can_form_triangle(a, b, c))
# 示例测试
print(can_form_triangle(1, 2, 3))
print(can_form_triangle(3, 4, 5))
print(can_form_triangle(1, 2, 2))
13、自冥数的求解
# 自冥数应该是指一个n为数的各个位的位数次方之和等于其本身--简单说就是类似于水仙花数
# 水仙花数只是自幂数的一种，严格来说3位数的3次幂数才称为水仙花数。
def is_narcissistic_number(num):
num_str = str(num)
n = len(num_str)
total = 0
for digit in num_str:
total += int(digit) ** n
return total == num
narcissistic_numbers = []
for num in range(100, 1000):
if is_narcissistic_number(num):
narcissistic_numbers.append(num)
for number in narcissistic_numbers:
print(number)
# ----------------------------------------------------------------------
# 简便式实现水仙花数
for i in range(100, 1000):
(a, x) = divmod(i, 100)
(b, y) = divmod(x, 10)
c = y
if a ** 3 + b ** 3 + c ** 3 == i:
print(i)
else:
continue
# 解释 divmod(i,100) 商余函数等价于 i // 100 和 i % 100,（a,x）a为商，x为余
# -----------------------------------------------------------------------
# 简便式实现四叶玫瑰数
# for i in range(1000,10000):
# (a,x) = divmod(i,1000) #比如设i=5431 a=5,x=431
# (b,y) = divmod(x,100) #431 b=4,y=31
# (c,z) = divmod(y,10) #31 c=3,z=1
# d = z
# if a**4+b**4+c**4+d**4==i :
# print(i)
# else:
# continue
资料自提（若已过期，请留言，资料中的自冥数是错的，详见上述代码）
链接：https://pan.baidu.com/s/1cL-twWWXOo0hL7yY_5NWaQ?pwd=tnay
提取码：tnay
文章出处登录后可见！
