Python implementation of core fundamentals to calculate math arithmetic

In addition to the points raised in the previous answer, here are some other suggestions.

Naming

The PEP 8 style guide recommends snake_case for function and variable names. For example:

calculationSelection would be calculation_selection

selectSquareRoot would be select_square_root.

Simpler

As already suggested, in main.py, the while loop is simpler as:

while True:

Note that parentheses are commonly excluded for simple conditions like this.

Looping

It would be cleaner to allow the user to gracefully break out of the infinite while loop. You can add an option for the user to do so (such as entering 3). I will demonstrate with a complete example below.

DRY

The same message is shown twice:

print("\nPlease select the calculation that you wish to perform:")

It would be better to have 2 separate messages to the user, which I'll demonstrate below.

Comments

Expanding on the previous answer, this comment:

# Exploration of Python's fundamentals.

should be deleted because it does not describe your specific code.

PEP 8 recommends adding docstrings for the main code and functions. For example, in main.py, add this:

"""
Command-line calculator tool.

User inputs the type of calculation and the numbers to calculate.
"""

This comment has redundant use of "calculation", and there is no need' to state what is obvious from the code (that you use a match statement):

# Match Case selection for calculation selection:

This would be a more meaningful comment:

# User chooses the type of calculation:

Here is main.py with several of the above suggestions:

from modules import arithmetic 
import sys

"""
Command-line calculator tool.

User inputs the type of calculation and the numbers to calculate.
"""

# User chooses the type of calculation:
while True:
    print("\nPlease select the calculation that you wish to perform:")
    print("\n-------------------------------------------------------")
    print("0 -- Square root")
    print("1 -- Exponents")
    print("2 -- Cube Root")
    print("3 -- Exit program")
    print("-------------------------------------------------------")
    calculation_selection = int(input("\nSelect the calculation (or 3 to exit): "))

    match calculation_selection:
        case 0:
            arithmetic.selectSquareRoot()
        case 1:
            arithmetic.selectExponent()
        case 2:
            arithmetic.selectCubeRoot()
        case 3:
            sys.exit(0)
        case _:
            print("\nERROR: Invalid Selection\n")

Note that the sys module is imported to use exit to break out of the loop.

• main.py doesn't need to import math.

• programRunning never becomes False. Do you really need a named variable to control an infinite loop? You also don't need to put the condition in parentheses in Python, like you do in C++. So this should be while True:

• The select... functions are misnamed. They do not select anything. They perform (or do) something. Consider renaming.

• It is easy to make selectSquareRoot and selectExponent to throw ValueError: math domain error, which terminates the program. You may want to address this.

• Comments in arithmetic.py are noise. Docstrings would be much more useful.

A further suggestion neither toolic nor vnp have touched on: your main.py can be imported in another Python source file. If this were done, all of the code in it would be executed. To avoid this, wrap your loop in a function and call it if __name__ equals '__main__'.

Modifying toolic's suggested code slightly:

import sys

"""
Command-line calculator tool.

User inputs the type of calculation and the numbers to calculate.
"""

def main():
    # User chooses the type of calculation:
    while True:
        print("\nPlease select the calculation that you wish to perform:")
        print("\n-------------------------------------------------------")
        print("0 -- Square root")
        print("1 -- Exponents")
        print("2 -- Cube Root")
        print("3 -- Exit program")
        print("-------------------------------------------------------")
        calculation_selection = int(input("\nSelect the calculation (or 3 to exit): "))
    
        match calculation_selection:
            case 0:
                arithmetic.selectSquareRoot()
            case 1:
                arithmetic.selectExponent()
            case 2:
                arithmetic.selectCubeRoot()
            case 3:
                sys.exit(0)
            case _:
                print("\nERROR: Invalid Selection\n")

if __name__ == '__main__':
    main()

We can now start a new file and import main without causing the main function to run unless we call main.main().

I would further:

• Break out printing the menu into a function.
• Handle the exception that can be thrown on invalid input when getting the option.
• Use a list of functions rather than a match. The input option can be used as an index into this list, and on a KeyError we will know the user has not input a valid choice.

import sys

"""
Command-line calculator tool.

User inputs the type of calculation and the numbers to calculate.
"""

def print_menu():
    print("\nPlease select the calculation that you wish to perform:")
    print("\n-------------------------------------------------------")
    print("0 -- Square root")
    print("1 -- Exponents")
    print("2 -- Cube Root")
    print("3 -- Exit program")
    print("-------------------------------------------------------")

option_handlers = [
    arithmetic.selectSquareRoot,
    arithmetic.selectExponent,
    arithmetic.selectCubeRoot,
    lambda: sys.exit(0)
]

def main():
    # User chooses the type of calculation:
    while True:
        print_menu()

        try:
            calculation_selection = int(input("\nSelect the calculation (or 3 to exit): "))
        except ValueError:
            print("\nERROR: Must be numeric input\n")
            continue
    
        try:
            option_handlers[calculation_selection]()
        except IndexError:
            print("\nERROR: Invalid Selection\n")

if __name__ == '__main__':
    main()

We might combine those and handle the exceptions together, except that option_handlers[calculation_selection]() might raise ValueError as well.

I'll pick just one of the functions to review; my comments apply to all.

def selectSquareRoot(): # Square Root 
    squaredNum = int(input("\nPlease enter the square number to be rooted: "))
    squareRootNum = math.sqrt(squaredNum)
    print(f"\nThe square root of {squaredNum} is {squareRootNum}.")

If the input isn't readable, or the line can't be converted to an integer, then an exception will be thrown. Python's default exception handler is great for developers, but a little intimidating for ordinary users, so it's a good idea to catch both of these cases. I suggest catching EOFError up at the top level, and dealing with ValueError much nearer, because we can re-ask the user in the latter case:

def read_int(prompt):
    while True:
        try:
            return int(input(prompt + ": "))
        except ValueError:
            print("That was not an integer")

I don't see why we allow only integers as input. I think it's quite reasonable to want to operate on rational values such as 3.5. It's a simple change to use float instead of int, and it would make the program much more useful. We might even choose to accept complex numbers.

Another exception that can be raised is ValueError when we attempt square root of a negative value. It would be good to handle this so that we can provide a more user-friendly message without backtrace and allow the selection loop to continue.

def read_float(prompt):
    '''Read input until a float is entered'''
    while True:
        try:
            return float(input(prompt + ": "))
        except ValueError:
            print("That was not a real number")

def selectSquareRoot():
    '''Print square root of user's input'''
    x = read_float("Please enter the square number to be rooted")
    try:
        print(f"The square root of {x} is ±{math.sqrt(x)}.")
    except ValueError as e:
        print(f"Could not compute √{x}: {e}")

Alternatively, use cmath.sqrt() if we think users prefer imaginary roots to a domain error for negative inputs.