Python面向对象实验

最新推荐文章于 2024-10-02 14:12:16 发布

@简单就好

最新推荐文章于 2024-10-02 14:12:16 发布

阅读量2.4k

点赞数 6

分类专栏： python面向对象文章标签： python 开发语言

本文链接：https://blog.csdn.net/weixin_53269843/article/details/124649511

版权

python面向对象专栏收录该内容

7 篇文章 1 订阅

订阅专栏

实验一、面向过程编程（字符串操作）

请设计如下功能的 Python 代码并进行验证：

1、要求输入多个字符串，字符串中包含各种数字以及字母的组合，每个组合以“，” 隔开；

2、输入的字符串中只能包含数字和字母以及“，”，否则抛出异常并给出提示，并要求用户重新输入；

3、将输入的字符串按“，”进行分割，并将数字串和非数字串进行分离，如有空串则要删除空串，并给出提示信息；

4、数字串请按照数字的大小由大到小进行排序，非数字串请按照长度有短到长进行排序，若长度相等，则按照字符串的固有排序准则降序排序，并进行输出；

5、将数字串放在前面，非数字串放在后面，依次输出。

示例（加粗字体表示用户输入）：请输入字符串，每个字符串以“，”隔开：abx,2as,234,456,23,1,b,Ac,56,sd,%5

输入格式不正确，请重新输入！

请输入字符串，每个字符串以“，”隔开：abx,2as,234,456,23,1,b,Ac,56,sd

你输入的数字串有：234,456,23,1,56

你输入的非数字串有：abx,2as,b,Ac,sd

最终的输出结果为：456,234,56,23,1,b,sd,Ac,abx,2as

程序运行完毕！

代码如下：

list1=[]
while True:
    flag=0                              #用flag = 0作为输入的格式正确的标记，如果格式错误，则无法退出while循环，继续输入
    list1=input("请输入字符串，用','进行分隔:").split(',')
    for i in list1:
        if str.isalnum(i) != True:
            flag=1
    if flag == 1:
        print("输入的格式有误，请重新输入")
    else:
        break
list2=[]
list3=[]
for i in list1:
    if i =='':
        del list1[i]
        print('空串已被删除')
    elif str.isdigit(i):                #数字串
        list2.append(i)
    else:                               #非数字串
        list3.append(i)
print('你输入的数字串有:',','.join(str(i) for i in list2))
print('你输入的非数字串有:',','.join(str(i) for i in list3))

out_list1=list(map(int,list2))          #将列表中的字符型数字转化为整型数字

out_list1.sort(reverse=True)            #对只包含数字的列表进行降序排列
list3.sort( key=lambda x: len(x),reverse=True)#对只有非字符型的列表按其长度排列
list3.reverse()

print(','.join(str(i) for i in out_list1 + list3))#join将列表的中括号去除

运行结果（截图）：

实验二、文件操作与异常处理

请设计如下功能的 Python 代码并进行验证（以下每个步骤均需要考虑异常！）：

1、请在 D 盘（Windows 系统）或者/usr/local（Linux）下创建一个新的文件 test.txt，若文件存在则需要给出是否要进行删除的提示，若用户输入 y，则删除原来的 test.txt，并新建一个新的 test.txt，否则转步骤 3；

2、在 test.txt 文件中随机写入 10 个-1-1 的小数，保留 2 位小数点，并进行检查，若随机生成的数据中没有负数则重新随机，直到序列中至少有 2 个负数，文件中每行写 1 个数字，写完之后，安全关闭文件，并给出完成提示；

3、请打开按上述方法生成的 test.txt 文件，读取该文件中每行的小数，并将这些数字按照从大到小的顺序进行排列形成一个字符串，并输出该字符串；

4、将 3 中得到的字符串中的小数点”.”以及小数点之前的“0”全部删除，得到一个新的字符串，并输出该字符串；

5、计算 4 中得到的字符串对应的表达式的值，将该值以”,”进行格式化后输出并追加到 test.txt 的最后，安全关闭 test.txt，并给出提示。

6、将 test.txt 移动至当前目录，并改名为 test_solved.txt，给出提示。

示例（加粗字体表示用户输入）：已创建文件 D:\test.txt 并已写入 10 个随机数据！

从 D:\test.txt 中读取到的数据为： 0.23,0.21,0.89,0.78,-0.98,-0.45,0.23,0.11,-0.78,-0.66

排序之后得到的字符串为： 0.890.780.230.230.210.11-0.45-0.66-0.78-0.98

经过处理之后的字符串为： 897823232111-45-66-78-98

最终得到的值为：897,823,231,824

已追加该数值！

已移动到当前目录！

已改名！

程序运行完毕

代码如下：

import tempfile,random
import os
import shutil
if os.path.exists("D:\ test.txt"):
    while True:
        x = input('文件已经存在，是否要进行删除[y]/n:')
        flag = 0
        if x == 'y':
            os.remove("D:\ test.txt")                              #删除指定文件
            fp = open('D:\ test.txt','w')
            fp.close()
            print('文件已删除\n文件重新创建成功')
        elif x == 'n':
            pass
        else:
            print('输入有误，请重新输入')
            flag = 1
        if flag == 0:
                break
list1 = []
list2 =[]
count = 0
with open('D:\ test.txt', 'w') as fp:
    while True:
        for i in range(10):
            data = random.uniform(-1, 1)
            data1 = round(data, 2)            #保留两位小数round()
            if data1 <0:
                count+=1#保留两位小数
            list1.append(data1)
        if count >= 2 :
            list2 = list1
            flag = 0
        else:
            list1.clear()                    #将列表置空，重新装入符合的数据（至少两个负数）
            flag =1
        if flag == 0:
            break
    fp.write(str(','.join(str(i) for i in list2)))
print('已创建文件D:\ test.txt并已经写入10个随机数据！')
with open('D:\ test.txt', 'r') as fp:  # 读取test文本文件
    print('从D:\ test.txt中读取到的数据为：')
    print('\t', ','.join(str(i) for i in fp.readlines()) )

list1.sort(reverse=True)                                        # 排序
print('排序之后的字符串为：')
print('\t', ''.join(str(i) for i in list1))

list3 = []                                                      # 将”.“以及小数点之前的"0"全部删除，得到一个新的字符串
for i in list1:
    j = str(i).replace('0.', '')  # 将”0.“去掉
    j = int(str(j))                                             #将整数前面的‘0’去掉
#    j = str(j).replace('0', '')  # 将数字前面的”0“去掉
    list3.append(j)
str1 = ''.join(str(i) for i in list3)
print('处理之后的字符串为:')
print('\t', str1)
                                                               # 计算字符串表达式的值，将该值进行格式化后输出并追加到test.txt的最后
str2 = eval(str1)                                              # 用eval函数实现计算字符串表达式的值
str3 = format(str2, ',')
print('最终得到的值：')
print(str3)
with open('D:\ test.txt', 'a') as fp:                          #将计算出的结果追加到文件中
    if fp.write(','+str3):
        print('已追加该数值！')
                                                               # 移动文件并改名：
f1 = 'D:\ test.txt'
f2 = os.getcwd()
if os.path.exists('D:\Mianxiangduixiang_hw\ test.txt'):        #若当前路径已经有这个文件，将原本存在的文件删除，将移动进来的文件改名
    os.remove('D:\Mianxiangduixiang_hw\ test.txt')

shutil.move(f1, f2)
print('已经将文件移动到当前目录')
#print(f2)                                                      #当前路径

if os.path.exists('D:\Mianxiangduixiang_hw\ test_solved.txt'):
    os.remove('D:\Mianxiangduixiang_hw\ test_solved.txt')
#    print("已将原文件删除")
os.renames('D:\Mianxiangduixiang_hw\ test.txt','D:\Mianxiangduixiang_hw\ test_solved.txt')
print('已改名！')
print('程序运行完毕!')

运行结果：

实验三、面向对象编程（栈操作）

请利用面向对象的思想完成栈这种数据结构的编写，编写一个类 Stack，实现入栈、出栈、判栈空、判栈满的操作！Stack 类须包含如下成员：

1、私有成员 content，为一个列表，代表栈里的数据；

2、私有成员 size，要求为整型，代表栈的容量，请定义为固定值 10；

3、私有成员 current，要求为整型，代表栈当前数据的个数；

4、方法 isempty，判断栈是否为空，返回 True/False；

5、方法 empty,置空栈；

6、方法 isFull，判断栈是否为满，返回 True/False；

7、方法 push，入栈，输入参数为新的元素；

8、方法 pop，出栈；

9、方法 show，打印当前栈的数据。设计完该类之后，请将所有功能放开供用户调试，用户界面应如如下示例：

示例（加粗字体表示用户输入）：

当前栈状态（0/10）：

empty 请输入需要的操作（0、退出 1、入栈 2、出栈）：2

错误操作！当前栈为空，无可出元素！

请输入需要的操作（0、退出 1、入栈 2、出栈）：1

请输入数据：3

当前栈状态（1/10）：[3]

请输入需要的操作（0、退出 1、入栈 2、出栈）：1

请输入数据：6

当前栈状态（2/10）：[3,6] 请输入需要的操作（0、退出 1、入栈 2、出栈）：2

已出栈：6

当前栈状态（1/10）：[3]

请输入需要的操作（0、退出 1、入栈 2、出栈）：0

程序运行完毕

代码如下：（这里我将Stack类作为一个模块，使用的时候直接调用）

class Stack():
    # 初始化栈为空列表
    def __init__(self, size=10):
        self.__content = []  # 使用列表存放栈的元素
        self.__size = size  # 栈的大小
        self.__current = 0  # 栈中元素的个数

    # 判断栈是否为空，返回布尔值
    def empty(self):
        self.__content = []
        self.__current = 0

    def isempty(self):
        return not self.__content

    def setSize(self, size):
        # 如果缩小栈的空间，则删除指定大小之后已有的元素
        if size < self.__current:
            for i in range(size, self.__current)[::-1]:
                del self.__current[i]
            self.__current = size
        self.__size = size

    # 栈满
    def isFull(self):
        return self.__current == self.__size

    def size(self):
        return self.__size
    # 入栈
    def push(self, x):
        if len(self.__content) < self.__size:
            self.__content.append(x)
            self.__current += 1  # 栈中元素加一
        else:
            print('栈满')

    # 出栈
    def pop(self):
        if self.__content:
            self.__current -= 1
            return self.__content.pop()
        else:
            print('栈空')
    def showcurrent(self):
        return self.__current
    # 栈的元素个数
    def show(self):
        return self.__content

    def showRemainderSpace(self):  # 当前栈的大小
        print('栈还可以输入', self.__size - self.__current,'个数据')


if __name__ == '__main__':
    print('Please use me as a module')

import Stack1
if __name__ == '__main__':
    # 初始化一个栈对象
    s = Stack1.Stack()
    if s.isempty():
        print("当前栈状态（0/10）：empty")
    while True:
        x = input ('请输入需要的操作（0、退出 1、入栈 2、出栈）：')
        if x == '0':
            print("程序运行完毕！")
            break
        elif x == '1':
            info = eval(input('请输入数据'))
            s.push(info)
            print('栈当前状态(',s.showcurrent(),'/',s.size(),'):',s.show())
        elif x == '2':
            if s.isempty():
                print('错误操作！当前栈为空，无可出元素！')
            else:
                print('已出栈:',s.pop())
                print('栈当前状态(', s.showcurrent(), '/', s.size(),'):', s.show())
        else:
            print("你输入的操作有误，请重新输入！")

实验四、多线程与多进程编程

请分别利用线性算法、多线程编程（开 10 个线程）以及多进程编程（开 10 个进程）计算 1 到 500000000（5亿）的连加的和，并比较这 3 者的运行时间！请分别编写线性运算、多线程运算以及多进程运算的相应函数，并分别输出 3 种运算最终的运行结果以及运行需要的时间（结果精确到秒）

代码如下：


import threading
from multiprocessing.dummy import Pool
from multiprocessing import pool
import time

result = 0
tasklist = []

                                                               # 判断线程是否结束
def isThreadingsEnd(tasklist):
    for t in tasklist:
        if t.is_alive() == True:
            return False
    return True

                                                         # 线程/进程单位任务
def sum_task(start):
    global result
    sum = 0
    for i in range(start, 500000001, 10):
        sum += i
    result += sum

                                                             # 线性计算方法
def sum_linear():
    global result
    t1 = time.time()
    for i in range(1, 500000001):
        result += i
    t2 = time.time()
    print('线性计算：', result, 'time =', round(float(t2 - t1), 6), '\bs')

                                                                 # 线程计算方法（10线程）
def sum_threading():
    global result
    t1 = time.time()
    for i in range(10):
        t = threading.Thread(target = sum_task, args = (i + 1,))  #判断线程是否结束
        tasklist.append(t)
        t.start()
    while isThreadingsEnd(tasklist) == False:
        pass
    t2 = time.time()
    print('多线程计算：', result, 'time =', round(float(t2 - t1), 6), '\bs')

                                                    # 进程计算方法（10进程）
def sum_process():
    global result
    pool = Pool(10)
    t1 = time.time()
    for i in range(10):
        pool.apply(sum_task, args = (i + 1,))
    pool.close()
    pool.join()
    t2 = time.time()
    print('多进程计算：', result, 'time =', round(float(t2 - t1), 6), '\bs')


result = 0
sum_linear()                                   #线性计算
result = 0
sum_threading()                                #线程计算
result = 0
tasklist = []
sum_process()                                  #进程计算

不同的电脑运行时间不一样，好的会快一点：

运行结果：