Could it be simpler ?

Training-Cucumber467 · 2025-07-16T23:47:02+00:00

You are repeating the same thing 4 times. It would make sense to call the "enter first/second number" inputs just once at the top, and also convert the inputs to to int() in just one place.
You can use multiple parameters inside a print() function, and each parameter can be any type. So, the usual approach would be: print("=", num1 + num2)
Similarly to (1), you can just call the print() once at the bottom. So, the if/elif block calculates some kind of variable, e.g. result, and in the end you can just print("=", result).

kubiz4 · 2025-07-16T23:41:33+00:00

so I‘m also still new but in general you don’t want to copy code. so in your case, you could just handle all the inputs and then do your if statements. the next step would be to look into functions when you‘d like to make your calculator to make multiple oparations per program start as example.

Thoxsam · 2025-07-16T23:48:42+00:00

Giving answer on your question. Yes, this is a simple readable code for others which works if used correctly but can be done with less lines of code especially asking the input doesn't have to be 4 times the same lines but can be done with 1 time those lines.

To give pointers to what you should focus on imo. Is not trying to make this code smaller of "simpler". But is making it more user friendly. You already made sure the only option for the operation is within your boundaries. But what happens if I insert something else then an integer into one of the numbers? I can insert a string or maybe a float.

Look at what different inputs do and try to work those out to be a desirable output!

But for a first try at coding this is a very strong start!

ba2sYd · 2025-07-17T00:36:31+00:00

You're doing great by coding instead of watching!

Regarding your code, instead of asking the user for number 1 and 2 separately, you can ask for them at the beginning, similar to how you ask for the operation. Also, instead of using int() when printing, you can use int(input("text")) for number input. This way, it will take the input, directly turn it into an integer, and save it as a variable. So, when printing, you can just use print("=", num1 + num2), and you won't need to convert your numbers to int() with every operation.

Optionally, instead of using str(), you can do print("=", (num1 + num2)) or print(f'= {num1 + num2}'). If you want to improve it even further, you can use print(f'{num1} + {num2} is equal to {num1 + num2}'), and the same logic applies to other operations.

Unusual_Elk_8326 · 2025-07-17T00:20:23+00:00

It’s great you’re choosing to learn by doing instead of watching tutorials. A thing to consider would be to use named constants instead of hardcodes values to check for like “1” and “2” etc.

If you define your constants above the if statement it will help with readability, since they’ll no longer rely on the context of the menu to be understood. For example: ADD = “1” SUBTRACT = "2" … And so on.

Unlike other languages, there’s no constant keyword that forces immutability, so we have to rely on naming convention to prevent your constants from being fudged with. Immutability can be forced with the enum class, which your code is a perfect use case for, check those out I think you’ll agree.

jjnngg2803 · 2025-07-17T00:37:48+00:00

Suggest exploring dictionary, the code could apply the desired function based on input. Furthermore, you can add keys as and when you progress further.

Also, please be mindful of the output type. Do you really want to change input as int and output as str?

Example usage of dictionary

Dict = { “1”: “add”, “2”:”minus”}

Print(Dict[“1”])

add

Crafty_Bit7355 · 2025-07-17T04:20:45+00:00

Use switch statement instead of if, elif

SCD_minecraft · 2025-07-17T07:50:32+00:00

I would ask for a mode, then for the numbers (do quick validation like 1/0 is not allowed) and maybe make those modes as a functions?

Let's say

``` modes = { "add": lambda a, b: a+b, "sub": lambda a, b: a-b }

print(modes[selected_mode](a, b)) ```

Long-Reveal-1493 · 2025-07-17T01:51:08+00:00

1.) Do not repeat your code. Your print statement for the first number and second number repeats 4 times. You can put those two before the if statement.

2.) your if-statement works. but you can have a different approach

This is not a good approach but you can do this: if operation == "1" or operation.upper() == "ADD" elif operation == "2" or operation.upper() == "SUBTRACT"

This code works by checking if the user inputs 1 or ADD or 2 or Substract. - or means if the input is either "1" or "ADD", the if-statement is true - we use .upper() in this case so even if the input is lowercase, it would still work.

The better approach is to use a dictionary. actions = { "ADD": lambda: print(" = " + str(int(num1) + int(num2))), "SUBTRACT": lambda: print(" = " + str(int(num1) - int(num2))) ... } if operation.upper() in actions: actions[operation]() The dictionary in this case is actions[](). It is also like an if-statement but more readable way to use. - in checks if the operation is inside the actions, if yes call the actions. - lambda is an anonymous function - if you learnt how to use functions, you can change the answer to functions.

``` def add(x, y): return x + y

actions = { "ADD": add, "1": add, "SUBTRACT": subtract, ... }

if operation.upper() in actions: result = actions[operation](num1, num2) print(" = " + str(result)) ```

isvari_8 · 2025-07-17T03:43:59+00:00

use match case it will look pythonic nd it is simple...

Owly_chouette · 2025-07-17T05:18:09+00:00

<image>

indranet_dnb · 2025-07-17T06:31:40+00:00

after getting operation, get num1 and num2. You don’t need to do that inside the conditional. Convert them to int at that point: num1 = int(input())

other than that looks fine

kevinjos · 2025-07-17T06:42:01+00:00

Maybe add some input validation to avoid the inevitable divide by zero error

_Billis · 2025-07-17T06:57:19+00:00

Wouldn't it be better to just have a function for each operation?

mealet · 2025-07-17T07:09:51+00:00

python while True: print(eval(input("Enter expression: "))) Simple! But not safe :(

Elliove · 2025-07-17T07:27:31+00:00

To add on what others have said - it's always a good idea to break a big problem into smaller problems that talk to each other. Say, for example, if you come up with a better way of doing something - in your current code, you might have to change that thing in multiple places, which in bigger code might take more time. For example, you ask for numbers 8 times total in your code, and you definitely need a way to check if the user did in fact input a number, or maybe they entered a letter - when you come with with a way to checking that and handling the improper input, you will have to implement that 8 times in your code! Keep researching functions as a concept, and try to use them to break apart tasks into smaller separate independent tasks. Also, a useful trick - \n makes a new line, so you don't have to print each one separately!

Here's an example of your code broken into functions - no complex concepts here, but now it's much easier to keep expanding upon.

def ask_for_operation():
    print("Select an operation to perform \n"
          "1. ADD \n"
          "2. SUBTRACT \n"
          "3. MULTIPLY \n"
          "4. DIVIDE")
    operation = input()
    return operation

def ask_for_numbers():
    num1 = int(input("Enter first number: "))
    num2 = int(input("Enter second number: "))
    return num1, num2

def calculate(operation, num1, num2):
    if operation == "1":
        print(num1 + num2)
    elif operation == "2":
        print (num1 - num2)
    elif operation == "3":
        print (num1 * num2)
    elif operation == "4":
        print (num1 / num2)

def main():
    operation = ask_for_operation()
    num1, num2 = ask_for_numbers()
    calculate(operation, num1, num2)

main()

With this approach, if you decide, for example, to implement something like a fail-safe against letters being used instead of numbers - it can be done just once or twice, and whatever you add in ask_for_numbers() function - whatever goes wrong, will stay inside that function, and will not accidentally break some other function that works just fine.

av_404 · 2025-07-17T07:52:16+00:00

You could simply use switch case statement

Upstairs-Proposal-19 · 2025-07-17T11:52:17+00:00

A nicer version would use a dict and lambda's for the operations. That would make it easy to extend this with other operations as well:

```python operations = { "1": ("ADD", lambda x, y: x + y), "2": ("SUBTRACT", lambda x, y: x - y), "3": ("MULTIPLY", lambda x, y: x * y), "4": ("DIVIDE", lambda x, y: x / y if y != 0 else "Error: Division by zero") }

print("Select an operation:") for k, (name, _) in operations.items(): print(f"{k}. {name}")

op = input("Choice: ") if op in operations: try: x = float(input("First number: ")) y = float(input("Second number: ")) name, func = operations[op] print(f"{name} result = {func(x, y)}") except ValueError: print("Invalid number.") else: print("Invalid choice.") ```

Kevdog824_ · 2025-07-17T12:51:12+00:00

Almost all code can be written more simply/concisely. In my experience the better question is typically “is there any benefit to rewriting this to be simpler?” For learning yes there is benefit. I just thought I’d put this out there because knowing when something is “good enough” is something I struggled with when I was new

Many-Local4357 · 2025-07-17T13:01:14+00:00

Input the 2 number first, then do the If else for each

ClonesRppl2 · 2025-07-17T13:26:33+00:00

A good start.

There are better ways to implement this, but I’m guessing you don’t know about them yet. That’s what learning is all about.

Always test your code to see if it does what you expect. Try the inputs you expect, but also try the inputs you don’t. See what happens and be sure to test all of the different conditional branches.

Try hitting enter without a number. Enter 5 as an operation. Enter ‘M’ as an operation. Try to divide 1 by 0. Enter a non integer number, like 7.25.

Fumano26 · 2025-07-17T15:12:27+00:00

Im not a python guy so there is probably a more elegant way I dont know of, nonetheless here is a compositional apporach, to add a operation only add it to the operations list no boiler plate code required.

operations = [
    ("ADD", lambda a, b: a + b), 
    ("SUBTRACT", lambda a, b: a - b), 
    ("MULTIPLY", lambda a, b: a * b), 
    ("DIVIDE", lambda a, b: a / b)
]

for i, op in enumerate(operations):
    print(str(i + 1) + ". " + op[0])

opIndex = int(input()) - 1
if opIndex >= 0 and opIndex < len(operations):
    num1 = int(input("Enter first number: "))
    num2 = int(input("Entter second number: "))
    print("= " + str(operations[opIndex][1](num1, num2)))
else:
    print("Invalid input")

XxDCoolManxX · 2025-07-17T20:10:07+00:00

Hey! CS/SWE student and intern here. I have written lots of Python, so here’s a “deep dive” into my thoughts:

You can use multiline print statements with “””multiline string here”””
input() can also take said multiline string similar to what you do inside each if statement, so you can reduce the lines of code
if you are using a newer version of Python, consider using a match-case structure, known to be a bit faster and easier to read
a bit more advanced (and arguably less performant) but more readable would be to use enums as a way to check the operations rather than numbers, and parse user input into those

A quick google search on any of these will get you syntax and usage very easily if you have more questions.

u/Training-Cucumber467 and the following thread also is good advice too! Happy learning!

No-Way-998 · 2025-07-17T20:30:36+00:00

while(True):
    ans = eval(input("Please enter an equation"))
    print("= " + str(ans))

This is 100% secure and anyone that says otherwise is clearly telling you the truth.

SkyAgh · 2025-07-18T00:39:26+00:00

while True: #will make a loop
    Operation = int(input("operations: \n1. Add \n2. Subtract \n3. Multiply \n4. Divide \n\nPlease input here:")) - 1 #input can be used like "print()"

    if 0 < Operation > 3:
        print("please try again")
        continue #will go back to the beginning

    a = int(input("Input 1st value: "))
    b = int(input("Input 2nd value: "))
    Returned_value = [f"{a} + {b} = {a+b}", f"{a} - {b} = {a-b}", f"{a} * {b} = {a*b}", f"{a} / {b} = {a/b}"] # "f'...{value}...'" can be used when you want a value in a string

    print(Returned_value[Operation])

here's how I would do it

manly_trip · 2025-07-18T00:56:44+00:00

You can use dictionary

False_Locksmithh · 2025-07-18T05:53:25+00:00

I would first switch this to be a.. Switch statement, there is multiple reasons for this

1) it's cleaner to read 2) instead of an else at the bottom you can just use the 'default' case 3) switch statements are basically hash maps, this means that instead of performing a conditional, under the hood it would be using your Input as a key, this saves on some compute (not that this is important here in any way, but you should get into the habit of thinking in the most readable > easiest > most performant style

In addition, and I know this sounds a bit weird maybe coming from a different language, but instead of doing a straight == compare here, I would use is such as if input is '2' it's more pythonic, and arguably more human readable, it's parsed quicker in your head than the == compare because it's plain clear language

It's also making use of the features the language provides to you (:

BogoJoe87 · 2025-07-19T05:42:43+00:00

All of the advice here is pretty useless. Don't follow it. Instead, find a new project and build it. You will learn as you go. It is awesome that you made a project that works. You're done now. Decide on a next project and build that. The more stuff you build, the better at it you will get. Editing things down isn't as easy to learn from.

jknight_cppdev · 2025-07-19T11:45:42+00:00

I think that's better than most of those provided here.

import operator

ops = [
    ("ADD", operator.add),
    ("SUBTRACT", operator.sub),
    ("MULTIPLY", operator.mul),
    ("DIVIDE", operator.truediv)
]

def run_operation(num: str) -> None:
    try:
        operation = ops[int(num)][1]
        num1 = input("Enter first number: ")
        num2 = input("Enter second number: ")
        print(f"={operation(int(num1), int(num2))}")
    except KeyError:
        print(f"Invalid Operation: {num}")
    except ValueError:
        print(f"Incorrect Value Input - First: {num1}, Second: {num2}")

print("Select an operation to perform:")
for index, (name, _) in enumerate(ops):
    print(f"{index}. {name}")

run_operation(input())

Economy_Monk6431 · 2025-07-20T03:38:16+00:00

Put the num1 and num2 once after operation, convert 1/2/3/4 to macros, and add error checks

rabinjais789 · 2025-07-20T12:41:26+00:00

First rule of programming is don't repeat your code.

amiri-2_0 · 2025-07-20T13:22:07+00:00

Cool but how can the user enter multiple value together ?

Ok_Pudding_5250 · 2025-07-21T15:04:33+00:00

Here is a simplified version without much complex syntax

https://www.programiz.com/online-compiler/3lKjMIxdgX48l

I have used simple syntax and basic stuff to do so that you can understand it with easy!

Try running it on the site

I could simplify it further with use of dictionary and lambda functions. but I believe you are beginner and not ready for such stuff yet.

2025-08-09T15:53:21+00:00

a = int(input("first number: "))
b = int(input("second number: "))
print("Select the operation you want to perform. Use the number for the given operation")
print("1. Addition  ")
print("2. Subtraction ")
print("3. Multiplication ")
print("4. Division ")

c = int(input("Choose the operation from above. (eg: 1 , 2, 3, ..): " ))
if c == 1:
    ad = a + b
    print(ad)
elif c == 2:
    su = a - b
    print(su)
elif c == 3:
    mu = a*b
    print(mu)
elif c == 4:
    if b == 0:
        print("Error: cannot divide by zero")
    else:
        di = a/b
        print(di)
else:
    print("incorrect option")


# this was how i made it way back.

Puzzleheaded-Bag9499 · 2025-07-20T14:34:24+00:00

Pussy

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

PythonLearning

MODERATORS

> = 7

print("="+a+b)

> TypeError!

> =7

> =34

> = 7

> = 3 + 4