Python 世界的开端：四则运算（python4则运算）

25-04-14 1

如果您想了解Python世界的开端：四则运算的相关知识，那么本文是一篇不可错过的文章，我们将对python4则运算进行全面详尽的解释，并且为您提供关于1037四则运算、201571030314四则运算

如果您想了解Python 世界的开端：四则运算的相关知识，那么本文是一篇不可错过的文章，我们将对python4则运算进行全面详尽的解释，并且为您提供关于1037 四则运算、201571030314 四则运算、20165318 结对编程项目 - 四则运算阶段总结、20165322 第一周结队编程 - 四则运算的有价值的信息。

本文目录一览：

Python 世界的开端：四则运算（python4则运算）
1037 四则运算
201571030314 四则运算
20165318 结对编程项目 - 四则运算阶段总结
20165322 第一周结队编程 - 四则运算

Python 世界的开端：四则运算（python4则运算）

编者按：本文基于Python2.x，与Python3.x存在差异。时间仓促未能及时更新，请观看时注意分辨。我们将尽快更新。

用Python计算

一提到计算机，当然现在更多人把她叫做电脑，这两个词都是指computer。不管什么，只要提到她，普遍都会想到她能够比较快地做加减乘除，甚至乘方开方等。乃至于，有的人在口语中区分不开计算机和计算器。

那么，做为零基础学习这，也就从计算小学数学题目开始吧。因为从这里开始，数学的基础知识列为肯定过关了。

复习

还是先来重温一下伟大时刻，打印hello world.

打开电脑，让Python idle运行起来，然后输入：

 print 'Hello, World'Hello, World

细心的看官，是否注意到，我在这里用的是单引号，上次用的是双引号。两者效果一样，也就是在这种情况下，单引号和双引号是一样的效果，一定要是成对出现的，不能一半是单引号，另外一半是双引号。

四则运算

按照下面要求，在ide中运行，看看得到的结果和用小学数学知识运算之后得到的结果是否一致

 2+57 5-23 10/25 5*210 10/5+13 2*3-42

上面的运算中，分别涉及到了四个运算符号：加(+)、减(-)、乘(*)、除(/)

另外，我相信看官已经发现了一个重要的公理：

在计算机中，四则运算和小学数学中学习过的四则运算规则是一样的

要不说人是高等动物呢，自己发明的东西，一定要继承自己已经掌握的知识，别跟自己的历史过不去。伟大的科学家们，在当初设计计算机的时候就想到列为现在学习的需要了，一定不能让后世子孙再学新的运算规则，就用小学数学里面的好了。感谢那些科学家先驱者，泽被后世。

下面计算三个算术题，看看结果是什么

4 + 24.0 + 24.0 + 2.0

看官可能愤怒了，这么简单的题目，就不要劳驾计算机了，太浪费了。

别着急，还是要在ide中运算一下，然后看看结果，有没有不一样？要仔细观察哦。

 4+26 4.0+26.0 4.0+2.06.0

不一样的地方是：第一个式子结果是6，后面两个是6.0。

现在我们就要引入两个数据类型：整数和浮点数

对这两个的定义，不用死记硬背，google一下。记住爱因斯坦说的那句话：书上有的我都不记忆（是这么的说？好像是，大概意思，反正我也不记忆）。后半句他没说，我补充一下：忘了就google。

定义1：类似4、-2、129486655、-988654、0这样形式的数，称之为整数
定义2：类似4.0、-2.0、2344.123、3.1415926这样形式的数，称之为浮点数

比较好理解，整数，就是小学学过的整数；浮点数，就是小数。如果整数写成小数形式，比如4写成4.0，也就变成了浮点数。

爱学习，就要有探索精神。看官在网上google一下整数，会发现还有另外一个词：长整数（型）。顾名思义，就是比较长的整数啦。在有的语言中，把这个做为单独一类区分开，但是，在Python中，我们不用管这个了。只要是整数，就只是整数，不用区分长短（以前版本区分），因为区分没有什么意思，而且跟小学学过的数学知识不协调。

还有一个问题，需要向看官交代一下，眼前可能用不到，但是会总有一些人用这个来忽悠你，当他忽悠你的时候，下面的知识就用到了。

整数溢出问题

对于其它语言，整数溢出是必须正视的，但是，在Python里面，看官就无忧愁了，原因就是Python为我们解决了这个问题。

ok!看官可以在IDE中实验一下大整数相乘。

 123456789870987654321122343445567678890098876*1233455667789990099876543332387665443345566152278477193527562870044352587576277277562328362032444339019158937017801601677976183816L

看官是幸运的，Python解忧愁，所以，选择学习Python就是珍惜光阴了。

上面计算结果的数字最后有一个Ｌ，就表示这个数是一个长整数，不过，看官不用管这点，反正是Python为我们搞定了。

在结束本节之前，有两个符号需要看官牢记（不记住也没关系，可以随时google，只不过记住后使用更方便）

整数，用int表示，来自单词：integer浮点数，用float表示，就是单词：float

可以用一个命令：type(object)来检测一个数是什么类型。

 type(4)type 'int' #4是int，整数 type(5.0)type 'float'　#5.0是float，浮点数type(988776544222112233445566778899887766554433221133344455566677788998776543222344556678)type 'long' #是长整数，也是一个整数

几个常见函数

在这里就提到函数，因为这个东西是经常用到的。什么是函数？如果看官不知道此定义，可以去google。貌似是初二数学讲的了。

有几个常用的函数，列一下，如果记不住也不要紧，知道有这些就好了，用的时候就google。

求绝对值

 abs(10)10 abs(-10)10 abs(-1.2)1.2

四舍五入

round(1.234)
1.0
round(1.234,2)
1.23

#如果不清楚这个函数的用法，可以使用下面方法看帮助信息
help(round)

Help on built-in function round in module __builtin__:

round()
round(number[, ndigits]) – floating point number

Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number. Precision may be negative.

幂函数

 pow(2,3) #2的3次方8

math模块（对于模块可能还有点陌生，不过不要紧，先按照下面代码实验一下，慢慢就理解了）

 import math #引入math模块 math.floor(32.8) #取整，不是四舍五入32.0 math.sqrt(4) #开平方2.0

总结

Python里的加减乘除按照小学数学规则执行不用担心大整数问题，Python会自动处理type(object)是一个有用的东西

————

本文完，如果你想继续学习，可以点击下面的链接，继续看：

1037 四则运算

题目描述

给你一个简单的四则运算表达式，包含两个实数和一个运算符，请编程计算出结果

输入

表达式的格式为：s1 op s2， s1和s2是两个实数，op表示的是运算符(+,-,*,/)，也可能是其他字符。注意运算符两侧各有一个空格。

输出

如果运算符合法，输出表达式的值；若运算符不合法或进行除法运算时除数是0，则输出"Wrong input!"。最后结果小数点后保留两位。

样例输入 Copy

1.0 + 1.0

样例输出 Copy

2.00

#include <stdio.h>	
#include<stdlib.h>
#include<math.h>

int main()
{

double a;
double b;
double result;
char op;
int error=0;
scanf("%lf %c %lf",&a,&op,&b);
switch(op)
{
case ''+'':
result=a+b;
break;
case ''-'':
result=a-b;
break;
case ''*'':
result=a*b;
break;
case ''/'': 
if(fabs(b)<1e-10)
error=1;
else result=a/b;
break;
default :
error=1;
break;

}
if(error==1)
{

 printf("Wrong input!")	;	
} 
else if (error==0)
{
printf("%.2lf",result);	
}


return 0;
}

201571030314 四则运算

一、个人项目 github 地址展示

https://github.com/manzhiyanlan/sizeyunsuan.git

即使用 Java 编程语言随机产生 n 个小学生四则运算练习题。

二、个人项目报告展示

1、需求分析

程序可接收一个输入参数 n，然后随机产生 n 道加减乘除练习题，每个数字在 0 和 100 之间，运算符在 3 个到 5 个之间。
为了让小学生得到充分锻炼，每个练习题至少要包含 2 种运算符。同时，由于小学生没有分数与负数的概念，你所出的练习题在运算过程中不得出现负数与非整数，比如不能出 3/5+2=2.6，2-5+10=7 等算。

2、功能设计：输入一个参数 n, 随机生成 n 道算式，即当输入生成式子个数为 5 时，产生五个具有运算符和数字组成的算式如下所示。

3、设计实现

在设计的开始要想随机输出算式就得先了解随机数的定义生成随机数，生成随机数的函数就是 math.random，还有运算符的随机产生，要想随机产生运算符就要从加减乘除四个运算符号中产产生，即先对其进行定义再调用，最后将所产生的随机式输出。另外，小学生的概念里没有负数，我将随机数定义为正整数输出。我根据学生学习程度的不同，对算式进行了难易分类，让不同程度的学生得到有效的学习。在随机产生题目做完题后，能判断答案是否正确。并输出错误的项。最后，实现避免产生重复的项的功能。

4、测试运行

我的测试结果如下所示，对于输出的算式，随便输入答案，对其进行正误判断。

5、PSP 展示

PSP2.1	任务内容	计划完成需要的时间 (min)	实际完成需要的时间 (min)
Planning	计划	20	20
Estimate	估计这个任务需要多少时间，并规划大致工作步骤	15	20
Development	开发	300	360
Analysis	需求分析 (包括学习新技术)	15	15
Design Spec	生成设计文档	10	10
Design Review	设计复审 (和同事审核设计文档)	5	5
Coding Standard	代码规范 (为目前的开发制定合适的规范)	10	10
Design	具体设计	20	20
Coding	具体编码	180	200
Code Review	代码复审	8	6
Test	测试（自我测试，修改代码，提交修改）	20	25
Reporting	报告	10	15
Test Report	测试报告	10	10
Size Measurement	计算工作量	2	1
Postmortem & Process Improvement Plan	事后总结 , 并提出过程改进计划	30	25

7、总结与问题

由于 Java 基础太薄弱，这么久才完成了作业，而且完成的还不全面，比如随机产生的式子中，数字是随机产生的整数，在有的运算符为除法的情况下，结果就会有余，尝试解决这个问题，参考了别人的代码，最终却没有实现。其次，题目要求以文档的形式输出结果，却实现的时候忽略了一点，在 GitHub 里面上传了代码，却才发现这个遗漏点，需求分析不够全面，检讨后会在以后的项目中改进。在项目的开发过程中，先进行需求分析，对项目的需求有个了解，然后进行功能设计、设计实现，最后对代码进行修改与测试。在代码编写的过程中遇到了很多阻碍，需要在课余时间里提高自己的知识与操作技能。在今后的学习中也会更加努力。

20165318 结对编程项目 - 四则运算阶段总结

一、需求分析

能随机生成 n 道四则运算题目，n 由使用者输入
支持整数和分数
支持多运算符
能够判断正误，错误时能提醒并输出正确答案
能计算出正确率
能多次生成题目，直到使用者选择退出

后续拓展的可能
题目去重
文件：
- 处理生成题目并输出到文件
- 完成题目后从文件读入并判题
多语言支持：简体中文，繁體中文，English

返回目录

二、设计思路（同时输出 UML 类图）

1、首先考虑生成题目。随机生成题目，用到 Random 函数，生成题目应该是同时随机生成数字和四则运算符号，此处用 MakeQuestions 子类，新建一个空字符串用于存放生成的题目；

2、考虑到用户的需求设计从键盘输入来控制生成的题目数量和题目复杂度（也就是四则运算的符号数）；

3、生成题目之后进行运算，要求用逆波兰算法来运算题目，此处参考了逆波兰算法实现四则运算，将中缀表达式变成后缀表达式，再调用计算的类进行运算。

4、RationalNumber 实现真分数的计算。

5、题目输出后就从键盘输入结果进行答题，eqauls 比较录入的结果和经过运算的值，答对一题记正确题目数加一，最后用该值除以题目数得到正确率，实现判题功能。

UML 图

返回目录

三、实现过程中的关键代码解释

中缀转后缀方法实现 参考 2016-2017-2 《Java 程序设计》课堂实践项目：设立一个栈，存放运算符，首先栈为空；从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。当栈变成空时，输出的结果即为后缀表达式。

public void conversion(String expr) {   //中缀转后缀
        String token;
        StringTokenizer tokenizer = new StringTokenizer(expr);

        while (tokenizer.hasMoreTokens()) {
            //当tokenizer有下一个值时，进行循环，并把值赋给token
            token = tokenizer.nextToken();

            if (token.equals("(")) {
                //如果是左括号，入栈
                stack.push(token);
            }else if (token.equals("+") || token.equals("-")) {
                //如果是“+”或“-”，继续判断栈是否为空
                if (!stack.empty()){
                    //如果栈非空，判断栈顶元素是什么
                    if (stack.peek().equals("(")) {
                        //如果栈顶为“（”，运算符入栈
                        stack.push(token);
                    }else{
                        //否则先把栈顶元素移除，加到列表中，再将运算符入栈
                        list.add(stack.pop());
                        stack.push(token);
                    }
                }else {
                    //若栈为空，运算符入栈
                    stack.push(token);
                }
            }else if (token.equals("*") || token.equals("÷")){
                //如果是“*”或“÷”，继续判断栈是否为空
                if (!stack.empty()) {
                    //如果栈非空，判断栈顶元素是什么
                    if (stack.peek().equals("*") || stack.peek().equals("÷")) {
                        //如果栈顶为“*”或“÷”，先把栈顶元素移除，加到列表中，再将运算符入栈
                        list.add(stack.pop());
                        stack.push(token);
                    }else {
                        //如果栈顶为其他，运算符直接入栈
                        stack.push(token);
                    }
                }else {
                    //如果栈为空，运算符直接入栈
                    stack.push(token);
                }
            } else if (token.equals(")")) {
                //如果遇到“）”，开始循环
                while (true) {
                    //先把栈顶元素移除并赋给A
                    String A = stack.pop();
                    if (!A.equals("(")) {
                        //如果A不为“（”，则加到列表
                        list.add(A);
                    } else {
                        //如果A为“（”，退出循环
                        break;
                    }
                }
            }else {
                //如果为操作数，进入列表
                list.add(token);
            }
        }
        while (!stack.empty()) {
            //将栈中元素取出，加到列表中，直到栈为空
            list.add(stack.pop());
        }
        ListIterator<String> li = list.listIterator();//返回此列表元素的列表迭代器（按适当顺序）。
        while (li.hasNext()) {
            //将迭代器中的元素依次取出，并加上空格作为分隔符
            Message += li.next() + " ";
            li.remove();
        }
        message = Message;
    }

返回目录

四、测试方法

NifixToSuffer 类方法的测试（中缀转后缀）

Calculator 类方法的测试（四则运算）

RationalNumber 类方法的测试（有理数及真分数的计算）

返回目录

五、运行过程截图

返回目录

六、代码托管

码云链接

七、遇到的困难及解决方法

Q1：在计算统计正确率时，输出正确率都是 0%，如下图：
解决方法：仔细查看代码后，我们发现，在进行小数运算的时候，没有将 int 型的 j 转换为 double 型，导致只要不是 100%，在进行小数运算时计算结果都会是 0%
Q2：在编写 Calculator 类方法的测试代码时，遇到了 Expected 与 Actual 表达式相同，但测试失败的问题，如图：

解决方法：在我们多次观察产品代码，并查阅相关资料，参考 Junit 单元测试框架的使用中的提示，我们意识到可能是 Expected 和 Actual 的类型不同，查看代码得知，Expected 为 String 类型，而 Actual 为 RationalNumber 类型。我们调用 RationalNumber 类中的 toString 方法，将 RationalNumber 类型转换为 String 类型，问题得以解决。
Q3：在编写 RationalNumber 类的测试方法时，出现了与 Q2 相似的问题，如下图：

解决方法：有了上面的经验，我们意识到问题应该也和上面类似，查阅代码后发现果然如此，Expected 为 String 类型，而 Actual 为 int 类型，将 String 类型转换为类型 int 型就可以解决了。

返回目录

八、对结对的小伙伴做出评价

在结对编程中，我承担驾驶员的角色，我的队友是领航员的角色，我主要负责代码的输入，如代码文件的创建及配置、UML 图的制作等，我的队友主要起到引领的作用，由于我们对基础知识都掌握的不是很牢固，想实现一些功能时，总是不知道使用什么方法，这时候队友的工作就很起作用，她在旁边搜查相关知识点的资料，告诉我下一步要实现什么功能，然后我们一起讨论解决过程中遇到的问题。相对比第一次一起写代码，我们的默契度有了一定的提高，但是有时候想问题，思想还是不会同步，但是我相信我们的默契度以后还会得到更大的提高。

九、参考代码

由于对堆栈以及中缀转后缀不是很了解，我和我的小组成员参考了逆波兰算法实现四则运算，仔细理解这个代码之后，将 NifixToSuffix 写出。

十、PSP

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划
· Estimate	・估计这个任务需要多少时间	30	50
Development	开发
·Analysis	・需求分析 (包括学习新技术)	60	100
·Design Spec	・生成设计文档	50	60
·Disign Review	・设计复审 (和同事审核设计文档)	20	40
·Code Standard	・代码规范	30	40
·Design	・具体设计	40	80
·Coding	・具体编码	60	140
·Code Review	・代码复审	30	30
·Test	・测试 (自我测试，修改代码，提交修改)	30	90
Reporting	报告
·Test Report	・测试报告	60	100
·Size Measurement	・计算工作量	30	30
·Postmortem&Process Improvement Plan	・事后总结，并提出过程改进计划	30	50
	合计	470	800

返回目录

参考资料

2017-2018-2 165X 『Java 程序设计』课程结对编程练习_四则运算结对编程项目 - 四则运算现代软件工程讲义个人项目和结对项目练习四则运算逆波兰算法实现四则运算

20165322 第一周结队编程 - 四则运算

结队编程 - 四则运算阶段总结

学习笔记
中缀表达式转换为后缀表达式
- 如果遇到数字，我们就直接将其输出。
- 如果遇到非数字时，若栈为空或者该符号为左括号或者栈顶元素为括号，直接入栈。
- 如果遇到一个右括号，持续出栈并输出符号，直到栈顶元素为左括号，然后将左括号出栈（注意，左括号只出栈，不输出），右括号不入栈。
- 如果遇到运算符号且栈非空，查看栈顶元素，如果栈顶元素的运算优先级大于或者等于该运算符号，则持续出栈，直到栈顶元素优先级小于该运算符。最后将该元素入栈。
- 如果我们读到了输入的末尾，则将栈中所有元素依次弹出。
生成随机数的运用
- Random ran = new Random(); 随机数方法创建对象
- int B = ran.nextInt(2); 生成 0—1 之内的随机数
需求分析
- 随机生成题目
  - 生成题目数量根据用户需求输入
  - 自动生成小学四则运算题目 (加、减、乘、除)
  - 支持整数和真分数
  - 支持多运算符（比如生成包含 100 个运算符的题目）
- 统计正确率
- 能多次生成题目
- 扩展需求
  - 题目去重
  - 支持多语言
  - 处理生成题目并输出到文件
  - 完成题目后从文件读入并判题
设计思路
- 实验首先是完成一个计算器的功能，可以实现简单的 +、-、*、/ 运算
- 实现多运算符，编入四个类分别实现整数运算、真分数运算、判断结果正确并计算正确率
- 利用 JUnit 检测非法输入
- 设计一个主类生成随机数，生成题目，并判断正确率
- 设计测试类，利用 JUnit 测试整数类与分数类的四则运算

uml 图：

核心代码及注释

public class Calculate {
    public static void main(String[] args) {
        NumberFormat number = NumberFormat.getPercentInstance();
        Random ran = new Random();
        Scanner scan = new Scanner(System.in);
        while (true) {
            System.out.print("请输入您所需要生成的题目数量：");
            int A = scan.nextInt();                        //A:题目数量
            for (int i = 0; i < A; i++) {
                int B = ran.nextInt(2);                //生成随机数0/1，随机挑选整数或分数运算
                int C = ran.nextInt(4);                //生成随机数0-3，随机挑选4种运算符
                IntNumber in1 = IntNumber.obj();               //整数运算
                IntNumber in2 = IntNumber.obj();
                Fraction score1 = Fraction.obj();              //分数运算
                Fraction score2 = Fraction.obj();
                if (B == 0) {
                    switch (C) {                                //整数加减乘除运算
                        case 0:
                            int num = in1.add(in2);
                            String num1 = "" + num;
                            int n = scan.nextInt();
                            Judgement.judge(n == num, num1);
                            break;
                        case 1:
                            num = in1.subtract(in2);
                            num1 = "" + num;
                            n = scan.nextInt();
                            Judgement.judge(n == num, num1);
                            break;
                        case 2:
                            num = in1.multiply(in2);
                            num1 = "" + num;
                            n = scan.nextInt();
                            Judgement.judge(n == num, num1);
                            break;
                        case 3:
                            num1 = in1.divide(score1);
                            String Q = scan.next();
                            Judgement.judge(Q.equals(num1), num1);
                            break;
                    }
                } else {
                    switch (C) {                                           //分数加减乘除运算
                        case 0:
                            Fraction num2 = score1.add(score2);
                            String num1 = num2.toString();
                            String s = scan.next();
                            Judgement.judge(s.equals(num1), num1);
                            break;
                        case 1:
                            num2 = score1.subtract(score2);
                            num1 = num2.toString();
                            s = scan.next();
                            Judgement.judge(s.equals(num1), num1);
                            break;
                        case 2:
                            num2 = score1.multiply(score2);
                            num1 = num2.toString();
                            s = scan.next();
                            Judgement.judge(s.equals(num1), num1);
                            break;
                        case 3:
                            num2 = score1.divide(score2);
                            num1 = num2.toString();
                            s = scan.next();
                            Judgement.judge(s.equals(num1), num1);
                            break;
                    }
                }
            }

测试代码

运行结果截图

码云链接

实验过程

实验要求生成随机四则运算，最难的在于真分数与多运算符的实现，以及分多个类来实现算法。
我们参考了邹欣老师的学生编写的代码《编写一个能自动生成小学四则运算题目的程序》尝试写了生成随机数的代码。但是对后续代码依然不知从何下手。
我们选择请教了其他同学，并且参考了他们的代码。其中在利用生成随机数和 switch 语句来实现随机四则运算的巧妙方法使我印象十分深刻。
但是我在真分数类的部分代码我还不太明白。以及如何实现计算题随机的长度也没弄懂。
我尝试了往代码里加入题目去重功能，但是还没有成功。其他几个扩展需求太难了怕是做不了 QWQ...

评价我的结队小伙伴

这个其实我觉得没啥好评价的 =-= 本来就是好朋友兼舍友。睡前吧唧吧唧讨论几句，看到优秀的代码就分享给对方。虽然都还很菜编不出那么难的代码。但是一起学习带来了很大的快乐，讨论中交换了很多新鲜的思路。相信我们会一起慢慢学的很好的。
结队学习照片（上次比较枯燥这次弄个有趣的 > - <）

总结

这次结队学习任务虽然对我们来说难度大了点，但是锻炼了我们的思维。通过一个项目也更有利于积极主动地去查找学习一些知识。
时间没有认真统计，代码我们没有自己编写出来。我感觉结对学习最大的好处就是可以随时随地讨论起来，利用零散的时间也能一起学习。等啥时候我们自己能编写一个项目了大概也能画出漂亮的时间表吧 0-0

今天关于Python 世界的开端：四则运算和python4则运算的分享就到这里，希望大家有所收获，若想了解更多关于1037 四则运算、201571030314 四则运算、20165318 结对编程项目 - 四则运算阶段总结、20165322 第一周结队编程 - 四则运算等相关知识，可以在本站进行查询。

本文标签：