devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python程序设计实验报告【合集】_python课程设计报告

作者：凡人多烦事01 | 2024-06-02 13:40:00

赞

踩

python课程设计报告

博客总领目录请看这篇，不看后悔

软件工程专业大学四年学什么_大学近代史学分是多少-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_41587612/article/details/104362661B站同名up猪，欢迎关注我的账号鸽子不二的个人空间-鸽子不二个人主页-哔哩哔哩视频哔哩哔哩鸽子不二的个人空间，提供鸽子不二分享的视频、音频、文章、动态、收藏等内容，关注鸽子不二账号，第一时间了解UP主动态。icon-default.png?t=N7T8https://space.bilibili.com/204913846

课堂作业

1、词频统计：输入一个文件，程序读取文件，文件内容是英文内容，不少于500个单词的内容，统计每个单词在该短文内出现的次数。

Python统计纯文本文件中英文单词出现个数的方法总结【测试可用】_python_脚本之家

https://www.cnblogs.com/Eudemines/p/9764409.html

https://www.cnblogs.com/zhuyinyinyin/p/7596217.html

https://www.cnblogs.com/lqx12/p/7602309.html

2、用Python设计一个计算器，在实现基本功能的基础上，增加三个功能按键，实现编译原理中提到的三种表达式“先验 3 5 +；中验 + 3 5；后验 + 3 5”。报告要求：需求分析，系统设计（用例图，功能框图，流程图），实现，源码

一、需求分析

1.1系统功能需求

        本计算器需要根据用户指定的数字与运算符来进行简单的加减乘除等功能。在运算并显示结果的同时，还需要显示用户按下的数字与运算符键，从而方便用户来进行核对算式和结果。本计算器可在生活中应对普通的日常问题，病能够做到快速、正确、稳定的计算出输入的计算内容。

1.2系统性能要求

        本程序作为一个简单的计算器程序，本程序相应并返回运算结果的时间不宜过长。因此，当用户输入完数字与运算符后，得到返回结果的延时不得超过1秒。在输入数值与运算符在合法范围内时，可以返回正确的运算结果。

二、系统设计

2.1用例图

                                                                                             图2.1 计算器用例图

2.2计算器功能图

                                                                                             图2.2计算器功能图

2.3程序流程图

                                                                                             图2.3 程序流程图

三、实现程序

3.1 程序源码

  1. import tkinter as tk
  2. class Calc(tk.Frame):  # 创建Calc类继承Frame
  3.     def __init__(self, parent=None):
  4.         """简易图形用户界面计算器构造函数"""
  5.         tk.Frame.__init__(self, parent)
  6.         self.pack()
  7.         self.startOfNextOperand = True  # 开始输入下一个操作数
  8.         # 创建计算过程和结果的标签
  9.         self.expr = tk.StringVar()  # 显示运算表达式
  10.         self.expr.set('')
  11.         self.exprLabel = tk.Label(self, font=('Helvetica', 10),
  12.                            fg='#666666', width=64, anchor='e', textvariable=self.expr)
  13.         self.exprLabel.grid(row=0, column=0, columnspan=4)
  14.         self.result = tk.StringVar()  # 显示结果
  15.         self.result.set(0)
  16.         self.resultLabel = tk.Label(self, font=('Helvetica', 20), width=34, anchor='e',
  17.                                     textvariable=self.result)
  18.         self.resultLabel.grid(row=1, column=0, columnspan=4)
  19.         # 简易计算器按钮的按钮，使用一个2D列表表示
  20.         buttons = [['先验','','后验','**'],
  21.                    ['CE', 'C', '<-', '/'],
  22.                    ['7', '8', '9', '*'],
  23.                    ['4', '5', '6', '-'],
  24.                    ['1', '2', '3', '+'],
  25.                    ['±', '0', '.', '=']]
  26.  
  27.         # 然后使用嵌套的循环的方法创建和布局各个按钮
  28.         for r in range(6):
  29.             for c in range(4):
  30.                 # 定义事件处理函数cmd（），默认参数为按钮标签buttons[r][c]
  31.                 def cmd(key=buttons[r][c]):
  32.                     self.click(key)
  33.                 b = tk.Button(self, text=buttons[r][c], width=16, command=cmd)
  34.                b.grid(row=r+2, column=c)# 前两行用于结果显示，按钮从第3行开始
  35.                 
  36.     def click(self, key):
  37.         """事件处理"""
  38.         if key == '=':   #按等号键时， 求值， 并显示结果
  39.             resultExpr = self.expr.get() + self.result.get()
  40.             resultNum = eval(resultExpr)
  41.             self.result.set(resultNum)
  42.             self.expr.set(resultExpr)
  43.             self.startOfNextOperand = True
  44.         elif key in '**+-/*':
  45.             resultExpr = self.expr.get() + self.result.get() + key
  46.             self.expr.set(resultExpr)
  47.             self.startOfNextOperand = True
  48.         elif key == 'C':  # 全部清空， 回到初始状态
  49.             self.expr.set('')
  50.             self.result.set(0)
  51.         elif key == 'CE':  # 清空当前输入
  52.             self.result.set(0)
  53.         elif key == '<-':
  54.             oldnum = self.result.get()
  55.             if len(oldnum) == 1: # 只有一个字符
  56.                 newnum = 0
  57.             else:
  58.                 newnum = oldnum[:-1]
  59.             self.result.set(newnum)
  60.         elif key == '±':  # 正负号，切换正负号
  61.             oldnum = self.result.get()  # 获取原来的值
  62.             if oldnum[0] == '-':
  63.                 newnum = oldnum[1:]
  64.             else:
  65.                 newnum = '-' + oldnum
  66.             self.result.set(newnum)
  67.         else: # 按数字或者小数点键
  68.             if self.startOfNextOperand:
  69.                 self.result.set(0)
  70.                 self.startOfNextOperand = False
  71.             oldnum = self.result.get()  # 获取原来的值
  72.             if oldnum == '0':
  73.                 self.result.set(key)
  74.             else:
  75.                 newnum = oldnum + key
  76.                 self.result.set(newnum)  
  77.  
  78. if __name__ == '__main__':
  79.     root = tk.Tk()
  80.     root.title('简易计算器')
  81.     calc = Calc(root)
  82.     root.mainloop()

3.2 运行截图

                                                                                             图3.2 运行截图

四、课程感想

        本学期我们学习了Python这节课程，通过这门课我们了解到了它的语法简单，编写起来方便的优点，也使我深刻体会到学习Python的必要性。因此学好Python是我们未来工作中非常重要的事情。对于Python的其他知识还需要不断地学习，希望以后会有更多收获。

实验一 面向对象程序设计实验

 一、实验目的

  1. 了解面向对象程序设计思想
  2. 了解对象、类、封装、继承、方法、构造函数和析构函数基本概念
  3. 掌握定义类、成员变量、成员函数、静态变量和静态方法
  4. 掌握通过类定义实现继承和多态的方法
  5. 掌握对象的创建和使用方法

二、实验内容（包括分析或步骤）

1. 定义类和使用类

  • 定义交通工具（Vehicle）类，定义两个成员变量：品牌（brand）、型号（type）；定义构造函数，在其中通过静态变量方式设置品牌；
  • 定义析构函数，在其中将交通工具对象的品牌和型号清空；
  • 定义一个成员函数，在其中输出当前交通工具对象的品牌和型号；
  • 定义一个类方法，在其中更新交通工具类的静态变量品牌和型号。
  • 创建一个交通工具对象，设置其品牌为“audi”，型号为“A6”，然后通过对象调用其成员函数，输出其品牌和型号，销毁对象；
  • 设置所有交通工具对象的品牌为“大众”，通过类方法，更新品牌为“奥迪”。

2. 类的继承和多态

  • 定义一个抽象类交通工具（Vehicle）类，定义一个抽象方法（drive）；
  •  定义2个子类汽车和飞机，在子类中实现抽象方法，输出不同交通工具的驾驶情况（如果是飞机，则输出机长名字、乘务员数量和乘客数量，如果是汽车，则输出驾驶员名字，汽车型号和行驶年数）。
  • 定义一个函数，判断输入的对象是什么类型的，然后调用drive方法输出该交通工具信息。

四、实验实现

核心代码1：

  1. class Vehicle():
  2.     """def __init__(self):
  3.         self.brand
  4.         self.type"""
  5.  
  6.     def __init__(self, brand, type):
  7.         self._brand = brand
  8.         self._type = type
  9.  
  10.     def __del__(self):
  11.         print(self._brand, "is deleted")
  12.         self._brand = ''
  13.         # self._type = ''
  14.  
  15.     def set_brand(this, brand):
  16.         this._brand = brand
  17.  
  18.     def out(self):
  19.         return self._brand, self._type
  20.  
  21. def main():
  22.     v = Vehicle("audi", "A6")
  23.     print(v.out())
  24.     v.__del__()
  25.     v.set_brand('Volkswagen')
  26.     print(v.out())
  27.     v.set_brand('audi')
  28.     print(v.out())
  29.  
  30. if __name__ == '__main__':
  31.     main()

运行结果1：

核心代码2：

  1. from abc import abstractmethod, ABCMeta
  2.  
  3. class Vehicle(metaclass=ABCMeta):
  4.     @abstractmethod
  5.     def drive(self):
  6.         pass
  7.  
  8. class Car(Vehicle):
  9.     def drive(self):
  10.         print("驾驶员:%s\n汽车型号:%s\n行驶年数:%d" % ('LZG', 'AE86', 3))
  11.  
  12. class Airplane(Vehicle):
  13.     def drive(self):
  14.         print("机长:%s\n乘务员数量:%d\n乘客数量:%d" % ('lzg', 15, 66))
  15.  
  16. def run(vehicle):
  17.     print(vehicle.__class__)
  18.     vehicle.drive()
  19.  
  20. def main():
  21.     v = [Car(), Airplane()]
  22.     m = map(run, v)
  23.     list(m)
  24.  
  25. if __name__ == '__main__':
  26.     main()

运行结果2：

实验二 函数式编程实验

一、实验目的

  1. 了解什么是函数式编程
  2. 了解函数式编程的优点
  3. 掌握lambda表达式、map()函数、filter()函数、reduce()函数、zip()函数的使用方法；
  4. 掌握闭包和递归函数的设计
  5. 掌握迭代器和生成器的设计

二、实验内容（包括分析或步骤）

1. 使用lambda表达式定义函数

  • 定义函数完成z=x3+y/x3
  • 定义函数完成z=x3+ x2+ x+1

2. 使用map()函数完成函数计算

  • 使用map()函数依次计算[2，4，6，8，10]和[1，3，5，7，9]的乘积；（举例：2*1，4*3…..）
  • 编写一个判断字符串是否是回文联的函数，然后使用map()函数依次判断[“abbbabbba” ，“asababaSa”， “asffbaffssa”， “attbabtgba”]是否是回文联；

3. 使用reduce()函数完成函数计算

  • 使用reduce()函数计算[2，4，6，8，10]的乘积；
  • 使用reduce()函数计算[2，-4，6，-2，10，-8，4，-2，5]中正数的乘积；

4. 使用filter()函数完成函数计算

  • 使用filter()函数将[‘have a apple’，’you are student’，’hello world’]中，包含2个以上a字符的字符串过滤掉。

5. 使用递归函数设计完成计算

  • 求第50位斐波纳契数列的值
  • 楼梯有n阶台阶,上楼可以一步上1阶,也可以一步上2阶,利用递归算法编写程序计算共有多少种不同的走法.

三、实验实现

核心代码：

  1. # <editor-fold desc="Description">
  2. from functools import reduce
  3.  
  4. def f1():
  5.     z1 = lambda x, y: x ** 3 + y / (x ** 3)
  6.     z2 = lambda x: x ** 3 + x ** 2 + x + 1
  7.     print(z1(1, 2))
  8.     print(z2(1))
  9.  
  10. def f2():
  11.     m1 = map(lambda x, y: x * y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
  12.     m2 = map(lambda s: s[-1::-1] == s, ['abbbabbba',
  13.                                         'asababaSa', 'asffbaffssa', 'attbabtgba'])
  14.     print(list(m1))
  15.     print(list(m2))
  16.  
  17. def f3():
  18.     r1 = reduce(lambda x, y: x * y, [2, 4, 6, 8, 10])
  19.     r2 = reduce(lambda x, y: x * y if y > 0 else x,
  20.                 [2, -4, 6, -2, 10, -8, 4, -2, 5])
  21.     print(r1)
  22.     print(r2)
  23.  
  24. def f4():
  25.     f1 = filter(lambda s: s.count('a') < 2, [
  26.         'have a apple', 'you are student', 'hello world'])
  27.     print(list(f1))
  28.  
  29. def f5():
  30.     def f5_1(n=1, pre=1, pre_pre=0):
  31.         if n is 1:
  32.             return pre
  33.         else:
  34.             return f5_1(n - 1, pre + pre_pre, pre)
  35.  
  36.     def f5_2(n):
  37.         count = 0
  38.         if n >= 2:
  39.             count += f5_2(n - 1)  # 1
  40.             count += f5_2(n - 2)  # 2
  41.         elif n == 1:
  42.             count += f5_2(n - 1)
  43.         else:
  44.             count = 1
  45.         return count
  46.  
  47.     print(f5_1(50))
  48.     print(f5_2(10))
  49.  
  50. if __name__ == '__main__':
  51.     f1()
  52.     f2()
  53.     f3()
  54.     f4()
  55.     f5()
  56. # </editor-fold>

运行结果：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/662915
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号