python习题(期末复习可借鉴食用版)

实验复习

---

根据学校实验报告内容要求整理的，谨慎食用！

实验一

主要内容:运算符，表达式，内置对象

1.输入任意大的自然数，输出各位数字之和：

a = input("请输入一个自然数:")
b = 0
for t in a:
    t = int(t)
    b = b + t
print(f"各位数字的和为:{b}")

2.输出两集合的交集、并集和差集

setA = eval(input("请输入集合A:"))
setB = eval(input("请输入集合B:"))
print("交集:", setA & setB)
print("并集:", setA | setB)
print("差集:", setA - setB)
"""两个集合的差集包含了第一个集合中存在，但是第二个集合中不存在的所有元素。"""
​

补充：eval函数

eval函数在计算过程具有int函数、float函数功能，将字符串str当成有效的表达式来求值并返回计算

3.输出一个数的二进制、八进制，十六进制

i = eval(input("请输入一个自然数:"))
a = bin(i)
b = oct(i)
c = hex(i)
print("该自然数转换为二进制为:", a)
print("该自然数转换为八进制为:", b)
print("该自然数转换为十六进制为:", c)
# python中进制转换(未完待续)
# 1.整数转换为二进制：bin()
# 2.整数转换为八进制：oct()
# 3.整数转换为十六进制：hex()
​

4.原列表中的偶数

listA = eval(input("请输入一个列表:"))
listB = []
for i in listA:
    if i % 2 == 0:
        listB.append(i)
print("原列表中的偶数有:", listB)

5.将两个列表中的数配对为字典并输出(元素数量取决于最少的列表数量)

A = eval(input("请输入一个列表:"))
B = eval(input("请输入一个列表:"))
dic = dict(zip(A, B))
print(dic)

6.编写程序，输入一个包含若干整数的列表，输出新列表、要求新列表中的所有元 素来自于输入的列表，并且降序排列

listA = eval(input("请输入一个列表:"))
listB = sorted(listA, reverse=True)
print(f"排序后的列表为:{listB}")

另：sorted（）函数默认升序排列（即reverse=False），如需降序排列，则需规定reverse=True。

sorted（)函数用于对可迭代对象进行排序，返回一个新的已排序列表，而不修改原始的可迭代对象。

格式：sorted(iterable, key=None, reverse=False)

iterable: 必需，要排序的可迭代对象，如列表、元组、字符串等。 key: 可选，用于指定一个自定义函数来提取用于排序的比较键。默认为 None，表示直接对元素进行比较。 reverse: 可选，如果设置为 True，则降序排序；默认为 False，表示升序排序。

#使用key参数进行排序，按字符串的长度升序排列
words = ["banana", "orange", "apple"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)
# 输出结果为['apple', 'banana', 'orange']

7.编写程序，输入一个包含若干整数的列表，输出列表中所有整数连乘的结果、

listA = eval(input("请输入一个列表:"))
a = 1
for i in listA:
    a = a * i
print(f"列表中所有整数连乘的结果为:{a}")

8.编写程序，输入包含若干集合的列表，输出这些集合的并集。要求使用reduce() 函数和lambda表达式完成。

from functools import reduce
listA = eval(input("请输入一个列表:"))
listB = reduce(lambda x, y: x | y, listA)
print(f"列表中集合的并集为:{listB}")

reduce函数:

在python3中被移到functools模块。

reduce函数先从列表（或序列）中取出2个元素执行指定函数，并将输出结果与第3个元素传入函数，输出结果再与第4个元素传入函数，…，以此类推，直到列表每个元素都取完。

常见用法：

（1）对列表元素求和：

from functools import reduce
listA = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, listA)
print(sum)
# 15

（2）求列表中元素的积：

from functools import reduce
listA = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, listA)
print(product)
# 120

（3）查找列表中的最值：

from functools import reduce
listA = [1, 2, 3, 4, 5]
max = reduce(lambda x, y: x if x > y else y, listA)
print(max)
# 5

（4）串联列表中的字符串：

from functools import reduce
words = ["Hello", " ", "world", "!"]
sentence = reduce(lambda x, y: x + y, words)
print(sentence)
# Hello world!

注意：reduce函数执行上述部分操作时虽比for循环更加简洁，但运行速度不如for循环。

9.编写程序，输入一个字符串，输出其中出现次数最多的字符及其出现的次数。 要求使用字典

strA = input("请输入字符串:")
dictA = {}
for i in strA:
    if i not in dictA:
        dictA[i] = 1
    else:
        dictA[i] += 1
a = max(dictA.values())
for k, v in dictA.items():
    if v == a:
        print(f"出现了最多的字符是{k},出现了{v}次")

items()函数：返回一个包含所有字典键值对的列表，其中每个键值对是一个元组。常用于循环中同时遍历键及其对应的值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(key, value)
# a 1
# b 2
# c 3

常见用例：

1.遍历字典

2.搜索一个值并获得键：

my_dict = {'a': 1, 'b': 2, 'c': 3}
target_value = 2
for key, value in my_dict.items():
    if value == target_value:
        print(f"目标值对应的键为:{key}")    
# b

3.基于条件的过滤字典：

my_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = {key: value for key, value in my_dict.items() if value > 1}
print(new_dict)
# {'b': 2, 'c': 3}

items()提供了一种在字典中同时处理键和值的方便方法,方便了键值对的迭代和操作。

实验二 序列结构与程序控制结构

元组、列表、字典、集合的用法。选择语句、循环语句的使用

（1）编写程序，判断今天是今年的第几天。

a = int(input("请输入年份："))
b = int(input("请输入月份："))
c = int(input("请输入日期："))
dic = {1: 31, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
if a % 400 == 0:
    dic[2] = 29
elif a % 4 == 0 and a % 100 != 0:
    dic[2] = 29
else:
    dic[2] = 28
t = 0
for i in range(1, b):
    t += dic[i]
count = c + t
print(f"今天是{a}年的第{count}天")

（2） 编写程序，输入一个数值序列,用冒泡和选择法对其排序。

def bubble_sort(alist):
    n = len(alist)
    count = 0
    for i in range(0, n-1):  # 外层循环控制排序循环的次数为n-1次
        for j in range(0, n-1-i):  # 内层循环控制每次排序比较的次数n-1-i
            if alist[j] > alist[j+1]:
                alist[j], alist[j+1] = alist[j+1], alist[j]  # 交换
                count += 1
        if count == 0:
            break
    return alist
​
​
blist = eval(input("请输入一个序列:"))
bubble_sort(blist)
print(f"排序后的序列为:{blist}")
​

def select_sort(alist):
    n = len(alist)
    #  需要进行n-1次选择操作
    for i in range(0, n-1):
        min_index = i  # 记录最小元素的位置
        # 从i+1位置到末尾选择出最小数据
        for j in range(i+1, n):
            if alist[j] < alist[min_index]:
                min_index = j
        # 如果选择出的数据不在正确位置，进行交换
        if min_index != i:
            alist[i], alist[min_index] = alist[min_index], alist[i]
    return alist
​
​
blist = eval(input("请输入一个序列:"))
select_sort(blist)
print(f"排序后的序列为:{blist}")

（3） 编写程序，输入一个大于2的自然数，输出小于该数字的所有素数组成的集合。

def isprime(n):
    for i in range(2, n):
        if n % i == 0:
            return 0
    return 1
​
​
a = int(input("请输入一个数:"))  # 注意要进行数据类型转换
setA = set()
for j in range(2, a):
    if isprime(j) == 1:
        setA.add(j)
print(f"小于该数字的所有素数的集合为:{setA}")
​

（4）编写程序，输入一个已经排序好的序列，再输入一个值，通过折半查找的方式查找其在序列中的位置，若不存在给出提示。

def binary_search(alist, num):
    left = 0
    right = len(alist) - 1
    mid = 0
    while right >= left:
        mid = (left + right) // 2
        if alist[mid] > num:
            right -= 1
        elif alist[mid] < num:
            right += 1
        else:
            break
    if right < left:
        print("序列中没有要查找的值")
    else:
        print(f"要查找的值在序列中的位置为{mid + 1}")
​
​
blist = eval(input("请输入一个序列:"))
value = int(input("请输入要查找的值:"))
binary_search(blist, value)
​

实验三 函数与面向对象实验

函数的定义、函数参数传递、函数内变量作用域，lambda表达式、函数递归、生成器设计。

（1）编写程序，模拟内置函数sorted（）和reversed（）

模拟sorted（）：

def new_sorted(alist):
    t = alist[::]  # 使用切片
    v = []
    while t:
        tt = min(t)
        v.append(tt)
        t.remove(tt)
    return v
​
​
blist = eval(input("请输入一个序列:"))
clist = new_sorted(blist)
print(f"排序后的序列为{clist}")
​

模拟reversed（）：

def new_reversed(alist):
    t = alist[::-1]
    return t
​
​
blist = eval(input("请输入一个序列:"))
clist = new_reversed(blist)
print(f"翻转后的序列为:{clist}")

python中的切片:

切片是对序列型对象(如list, string, tuple)的一种高级索引方法，切片可以取出序列中自己需要的一个范围内对应的元素。

1）切片的索引方式：

切片中有正索引和负索引，正索引从零开始，负索引从最后负一开始，且从最后一个元素开始。

列表	[1,2,3,4]
正索引	1对应0, 2对应1...
负索引	4对应-1, 3对应-2,...1对应-4

2)切片的基本表达方式:

[start：end：step]

分别对应为初始位置(没有值的话从头开始)，结束位置(没有值的话切到结束为止)和步长(默认值为1，步长为正表示从左向右切，步长为负表示从右向左切)。

(3) 编写程序，定义一个三维向量类（如x、y、z），并定义实现特殊方法。方法一：实现对象之间的加法运算（即对象做加法但实际是三个维度的加法）；方法二：对象之间的减法运算；方法三：对象（就是向量）与一个标量相乘（即是标量对向量各个维度的乘法）。

class Vector3D:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
 
    def __add__(self, other):
        return Vector3D(self.x + other.x, self.y + other.y, self.z + other.z)
 
    def __sub__(self, other):
        return Vector3D(self.x - other.x, self.y - other.y, self.z - other.z)
 
    def __mul__(self, scalar):
        return Vector3D(self.x * scalar, self.y * scalar, self.z * scalar)
 
    def __str__(self):
        return f"({self.x}, {self.y}, {self.z})"
 
# 使用示例
v1 = Vector3D(1, 2, 3)
v2 = Vector3D(4, 5, 6)
 
# 加法
print(v1 + v2)  # 输出: (5, 7, 9)
 
# 减法
print(v1 - v2)  # 输出: (-3, -3, -3)
 
# 数乘
print(v1 * 2)  # 输出: (2, 4, 6)

实验四 字符串与正则化表达式

正则化表达式元字符、子模式和利用正则化表达式对象处理字符串。

（1）编写程序，有一段英文文本，其中有个单词连续重复了2次，利用正则化表达式检查单词，并去掉重复。

import re
​
​
def repeat(s):
    return re.sub(r'(\b\w+) \1', r'\1', s) # 注意(/b/w+)后边要留空格
​
​
strs = input("请输入一段字符:")
str_1 = repeat(strs)
print(str_1)
# 输入:hello hello world
# 输出:hello world
# "hello "与"hello "匹配,去掉了一个"hello "

(2) 编写程序，用户输入一段英文，输出这段英文中所有长度是3个字母的单词。

import re
Eng = input('请输入一段英文：')
print(re.findall(r'\b[a-zA-Z]{3}\b', Eng))

（3）编写程序，利用异或运算实现字符串的加密和解密。

def xor_encrypt(data, key):
    return ''.join(chr(ord(x) ^ key) for x in data)
 
def xor_decrypt(data, key):
    return ''.join(chr(ord(x) ^ key) for x in data)
 
# 使用示例
plaintext = "hello world"
key = 0xff  # 密钥
 
# 加密
ciphertext = xor_encrypt(plaintext, key)
print("Encrypted:", ciphertext)
 
# 解密
decryptedtext = xor_decrypt(ciphertext, key)
print("Decrypted:", decryptedtext)