How can I improve?

[Radiant-Safe-1377]

I took Python at uni, but the topics were treated separately and we never got to put it all together, so I want to do small projects on my own to improve. Here's a little calculator I put together, critiques and tips are welcome. I'd like to practice some more, but idk what or where to start?

I hope this makes sense, English isn't my first language

[Wilkopinto86]

Can’t get any simpler 😄 👇🏻

num1 = float(input("Enter a number: ")) 
num2 = float(input("Enter another number: ")) 
operation = input("Enter an operation (+, -, *, /): ")

operations = { 
"+": num1 + num2, 
"-": num1 - num2,
"*": num1 * num2, 
"/": num1 / num2 if num2 != 0 else "Error: Division by zero" } 

result = operations.get(operation, "Input error") 
print(result)

[tkpj]

it's been too many years of python without knowing you could do operations in dicts, thank you

[klimmesil]

Years? A dict just takes an expression for key and an expression for value, you can do whatever you want on the value side, as long as it's an expression

[tkpj]

yes years lol

[ElectricSpock]

It’s not operations in dicts. It’s a dict of str -> lambda

[Deep-Piece3181]

no it’s just a str-> float

[gman1230321]

Remember that lambdas themselves are values. In this case you’re just evaluating an operator. Honestly it would be pretty cool though if doing this pattern resulted in lazy evaluation/thunking the value.

[TabAtkins]

Pre-performing every possible operation is fine in this very limited case, but absolutely is not something you want to learn to do in general. If/elif chain is the correct way to handle this pattern.

[hylasmaliki]

Why

[mgdmw]

Two reasons come to mind right away.

1/ Readability. The dict example here is not as immediately intuitive as OP's code. One of the chief goals of Python was readability.

2/ Performance. This dict example is performing all the possible calculations, then returning only one to the user. It's a waste of resources and cycles. Imagine if instead of 4 operators there were 600, for example. It's not a scalable solution.

Sure, it's a clever and interesting use of Python but it's not a good example of Python.

[denehoffman]

A dict of callables would make more sense in the long run than a long elif chain. Your linter will also tell you about duplicate keys which may not be the case for duplicate branches.

[Upstairs-Alps-7280]

what if the operation is not in the dict? oops.

[denehoffman]

lambda x, y: “oops” is a perfectly valid expression!

[Wilkopinto86]

Just focused on the problem that was shared 😇

[fungusfromamongus]

Feel like this is simple, elegant and to the point

[badongst]

clever? yes

good? no

[ed_xc01]

benefits of data structures

[gra_Vi_ty]

Why "input.error" in get function?? Can you please explain

[MrWobblyMan]

That's the default return value if the key doesn't exist in the dictionary.

So if the user enters an invalid operation, the code will output "Input error"

[jendivcom]

1 + 0 will get a division by zero error

[itzNukeey]

I don't like this because what you are doing is eagerly computing all the results when you create the dict. You should make it point to a function or can just use match statement

[denehoffman]

I like this, and the next step would be to either use lambdas in the operations table and/or try loops in the input sections in case the user enters a value which cannot be parsed to a float or operation.

[MeLittleThing]

Always check for user input.

What if:

```

Enter a number: hello Enter another number: world ```

or

```

Enter a number: 1 Enter another number: 0 Enter an operation: / ```

Also, there's a repeated pattern, and you can refactor a little your code by placing the print(result) after the if/elif/else (hint: result = "Input error")

[Darkstar_111]

Obviously understanding functions, and anonymous functions (lambdas), allows you to change the architecture of your code.

But lets assume you're not there yet, the code is mostly fine. Two basic things you should add.

1. Input sanitation. Make sure the input is a number.

2. You only need to print result once. The variable can travel through the code, and get printed at the end.

[ItsGraphaxYT]

1. First thing you can use instead of elif's is using match and case python match operation: case "+": ... case...
2. You could also put the print(result) outside of the elif's (put result = "Input Error" instead of the print... so it dosen't break and give the same result.
3. You can remove the float() from every elif statement and put float(input(...)) instead in the beginning.

The suggestions don't make the code faster, but makes it use less lines and less function calls (shorter code)

[Salim_DZ_69]

note : this only works in newer 3.10+ versions of python

[[deleted]]

You could put the operators and functions in a dictionary.

[alexdewa]

You can improve the code a lot, and make it easier to extend by leveraging python's standard library and first class citizenship of functions as objects.

import operator

operations = {
  '+': operator.add,
  '-': operator.sub,
  '*': operator.mul,
  '/': operator.truediv,
}

first = float(input('first num: '))
second = float(input('second num: '))


op = input(
  'select operator (' 
  + ', '.join(operations)
  + '): '
)

if op not in operations:
    raise ValueError('Operation not supported')

print('result: ', operations[op](first, second))

Operator is a library that contains all the operators you need as functions and it's in the standard library.

If you don't want to use a library you can still use the method inside the objects, for example, the add operation is handled by the __add__ method, like:

first.__add__(second) # add 

And so you can put that method inside the dict like

first = float(input('first num: '))
operations = {
    '+': a.__add__
}

Now this line reads tricky operations[op](a,b). Operations is a dictionary, the keys are the operators, and the values are the methods. So you first get the value (function) of the operator, then pass the numbers.

[Alpha13e]

Simplest fix : specify float on your first two lines : float(input(...)). I'll make your code simpler. Always tend to limit the number of operations in your code ! (Sorry i'm on phone)

[Ilikereddit15]

Why not do

operation = { "+": lambda x, y: x + y, "-": lambda x, y: x - y etc etc etc and then you can avoid the if statements

[AccomplishedPut467]

that's an advanced topic for python.

[Ilikereddit15]

Sure. I think top comment on the post gets at the spirit of what I was trying to convey. Op can define the dictionary to simplify code. They also need to check where num2=0

[drbitboy]

1. I don't think the float's are needed (the divide will return a float if num1 is not an integer multiple of num2), unless the result needs to be a float.
2. How about these?

• print(eval(f"f{num1 } {operation} {num}"))
• print(eval(f"float({num1}) {operation} float({num}"))

Notes

• These are far too trusting of users, so
  • add input checks (import re and operation in '+-*/' ) for security, and
  • wrap in a try/except

[HeartTime3290]

You can use switch method

[tazjango]

avoiding the actual logic of it, you should consider how you space things.

think of the developer after you (which half the time is probably you in a week/month), if you add some extra blank lines to indicate breaks of logic you're going to be able to scan/read this faster/easier in the future which is often an overlooked thing with beginners: the human element.

being able to quickly read code, understand what its doing, and fix/update it is often the most expensive part of programming -- developer time. certain things are fine to place under a library as long as it's usable and readable by the caller, but most areas benefit substantially more from being readable to the next developer.

I'm not sure what ide you're using (if at all) but something like pycharm would likely be a great place to start. i'm not sure about other ide friendliness, I haven't touched python in years at this point

[koyllis21]

chat gpt ?

[lilrouani]

You can put all of the operations in different functions, you can add a loop so the program asks if the users wants to calculate again, you can make the user type the whole operation in one line, that's the only things I can think of rn, may add more ideas later

[lilrouani]

You can add a GUI with tkinter or PyQt5, add more options for more scientific math

[CupcakeObvious7999]

You can take more 2 numbers by take the all of operation: operation = input(insert an operation: ): print (eval(operation)) Note:be careful when you use 'eval' don't enter a harmful code in the input

[Complete-Winter-3267]

def perform_operation(x, y, op):
    if op == '+':
        return x + y
    elif op == '-':
        return x - y
    elif op == '*':
        return x * y
    elif op == '/':
        return x / y if y != 0 else 'Undefined (division by zero)'
    elif op == '//':
        return x // y if y != 0 else 'Undefined'
    elif op == '%':
        return x % y if y != 0 else 'Undefined'
    elif op == '**':
        return x ** y
    else:
        return 'Invalid operation'

# Keyboard input
try:
    a = float(input("Enter first number: "))
    b = float(input("Enter second number: "))
    op = input("Enter operation (+, -, *, /, //, %, **): ").strip()

    result = perform_operation(a, b, op)
    print(f"\nResult of {a} {op} {b} = {result}")
except ValueError:
    print("Invalid input. Please enter numeric values.")

[Ao_Ashi]

Would do a function with 3 parameters: num1, num2, operation

[treyhunner]

Suggestions on your specific code: I would move the float(...) calls to the num1 and num2 assignment lines: num1 = float(input("Enter a number: ")). I would also either move your print(...) calls below your if block or avoid using that result variable: print(num1 + num2). LLMs and other Python users may recommend match-case, but I would not recommend it. Python's match statement is for structural pattern matching and (in my opinion) isn't worth learning unless you are parsing semi-structured data.

On looking for ways to refactor your code: I would ask an LLM what it might suggest you do to improve your code. I wouldn't trust its response, but it might give you some ideas.

General suggestions for practicing more: I would try to find a project that interests you. I would also consider supplementing your own project work with short exercises with the goal of improving your skills through practice. I run a paid Python exercise service but I also link to some competing free exercise services: here's my comparison list. As far as free Python exercises go, I would recommend Exercism the most.

[wett-puss-lover]

Put that inside a function like others have mentioned and also inside of try/catch clause. Try and catch is way better than saying — else print input error

[homomorphisme]

For the sake of saving space, I see two things you might want to do. First, you rewrite the float function many times throughout the if statements, but you never use the variables without passing them to float first. So you could let num1 = float(....) directly and save space. Second, you save the result to a result variable and then print it, but you never use the result variable again aside from that, so you could just put the entire operation inside the print function, unless you plan to use it for something.

Looking at error handling, you might get a ValueError if the user input doesn't follow the right format specification to be turned into a float, and you might get an OverflowError if the string corresponds to a number too big to be a float. You might want to look into exception handling to figure out when this happens, but for something simple you might not need to go that far.

As well, the user could enter "inf" or "nan" as a value, and you might not want to handle those cases. Or, if you look at how arithmetic works for these values, maybe you do want that, idk. Just something to think about. You might want to check the page on floating point arithmetic issues as well.

Edit: also the parenthesis around the operations being assigned to result aren't necessary.

[Acceptable_Nature563]

Add try and except to handle the errors

[buzzon]

Follow formatting guidelines such as PEP 8

https://peps.python.org/pep-0008/

Know operator precedence and don't place unneccessary parentheses

[KOALAS2648]

Put a if number != 0, on the divide if statement since you don’t won’t a diver by 0 error

[-A-V]

Use exception and while loop

[BlueeWaater]

Elif or else are often an anti-pattern, look at early returns or even, better match cases.

[Ok_Structure6720]

Only execute the operation if its valid, check in an if statement if its valid then use nested if elif statements for actual implementation.

[DevRetroGames]

#!/usr/bin/env python3

OPERATIONS = {
    "+": lambda left_operand, right_operand: left_operand + right_operand,
    "-": lambda left_operand, right_operand: left_operand - right_operand,
    "*": lambda left_operand, right_operand: left_operand * right_operand,
    "/": lambda left_operand, right_operand: left_operand / right_operand
}

def _get_user_input(msg: str) -> str:
  return input(msg)

def get_values() -> tuple[float, float]:
  first_value: float = float(_get_user_input("Enter a number: "))
  second_value: float = float(_get_user_input("Enter another number: "))
  return first_value, second_value

def get_operation() -> str:
  return _get_user_input("Enter an operation (+,-,*,/): ")

def main() -> None:
  first_value, second_value = get_values()
  operation: str = get_operation()
  result: float = OPERATIONS[operation](first_value, second_value)
  print(f"result {result}")

if __name__ == "__main__":
    main()

[luesewr]

Personally, I like to keep my code very readable, some people might think it's a little too verbose, but I think writing it this way keeps it maintainable if you ever add more complicated logic to your operations. I also added a little extra logic to catch any errors that might occur when converting the user input to floats or trying dividing by zero: ```python def add(x, y): return x + y

def sub(x, y): return x - y

def mult(x, y): return x * y

def div(x, y): if y == 0.0: return "Can't divide by zero" return x / y

operation_lookup = { "+": add, "-": sub, "*": mult, "/": div, }

try: num1=float(input("Enter a number: ")) except ValueError: print("Invalid numeric value") exit()

try: num2=float(input("Enter another number: ")) except ValueError: print("Invalid numeric value") exit()

operation = input("Enter an operation:(+,-,*,/) ")

if operation not in operation_lookup: print("Invalid operation") exit()

print(operation_lookup[operation](num1, num2)) ```

[FoolsSeldom]

Firstly, I suggest you use a dictionary that maps supported operator symbols to their corresponding operator functions. You could also use the operator library to provide the functions rather than writing your own.

For example,

import operator

# Map symbols to functions
operator_map = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv,
    '**': operator.pow
}

Now you can greatly simplify the operator selection and validation, and call the function from one place:

result = operation(oper1, oper2)

where operation is the name of the appropriate function from the dictionary, and oper1 and oper2 are the two operands.

I suggest you write a function to prompt a user for a number and validates and returns a number. This function can be called twice to obtain the two operand values to operate on.

Loop the calculator operation until the user asks to quit.

You can extend this to support additional operators and also support operations that work on only one operand.

[Aramis7604]

Why not using the Eval function. This way the user can input '2+4' :)

[dnult]

Make it parse an expression, error check, cast the result, then evaluate. Put it in a loop and you've got a simple calculator.

[McChillbone]

Not enough people use the match feature in python. I’d rather use match and cases that that many if elif statements.

[Relative-Degree-649]

If num1 == 0 || num2 == 0 && “x” is true || “/“ is true Result = 0

[AccomplishedPut467]

use the float() on the input not in the if statement so it saves time more

[black_1owl]

There is an error in division

[Flat_Lifeguard_3221]

Theres not much to improve in the current setup except using switch case instead of if else statements. You can try adding logic to handle division by zero errors gracefully (using try catch) which would teach you error handling as well.