ಪರಿಹರಿಸಲಾಗಿದೆ: ಪೈಥಾನ್‌ನಲ್ಲಿ ಸರಳ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ರಚಿಸಿ

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸರಳವಾದ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ರಚಿಸುವುದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಮುಖ್ಯ ಸಮಸ್ಯೆ ಎಂದರೆ ಕೋಡ್ ಅನ್ನು ಸರಿಯಾಗಿ ಬರೆಯಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಪೈಥಾನ್ ಪ್ರಬಲ ಭಾಷೆಯಾಗಿದೆ, ಆದರೆ ಆರಂಭಿಕರಿಗಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಬಳಸಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಕೋಡಿಂಗ್ ದೋಷಗಳು ತಪ್ಪಾದ ಫಲಿತಾಂಶಗಳು ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಇದಲ್ಲದೆ, ವಿಭಾಗ ಅಥವಾ ವರ್ಗಮೂಲಗಳಂತಹ ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಕೋಡ್ ಬರೆಯಲು ಗಣಿತ ಮತ್ತು ಕ್ರಮಾವಳಿಗಳ ಹೆಚ್ಚುವರಿ ಜ್ಞಾನದ ಅಗತ್ಯವಿರುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಸಹ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸವಾಲಾಗಿದೆ.

# This program adds two numbers 
num1 = float(input("Enter first number: ")) 
num2 = float(input("Enter second number: ")) 
  
# Adding the two numbers 
sum = num1 + num2 
  
# Display the sum 
print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))

# ಸಾಲು 1: ಈ ಪ್ರೋಗ್ರಾಂ ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ
# ಸಾಲು 2: ಬಳಕೆದಾರರಿಂದ ಫ್ಲೋಟ್ ಇನ್‌ಪುಟ್‌ನ ಮೌಲ್ಯವನ್ನು num1 ನಿಗದಿಪಡಿಸಲಾಗಿದೆ
# ಸಾಲು 3: ಬಳಕೆದಾರರಿಂದ ಫ್ಲೋಟ್ ಇನ್‌ಪುಟ್‌ನ ಮೌಲ್ಯವನ್ನು num2 ನಿಗದಿಪಡಿಸಲಾಗಿದೆ
# ಸಾಲು 5: num1 ಮತ್ತು num2 ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ ಮತ್ತು ವೇರಿಯಬಲ್ ಮೊತ್ತದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ
# ಸಾಲು 7: num1, num2 ಮತ್ತು ಮೊತ್ತದ ಮೊತ್ತವನ್ನು ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿಕೊಂಡು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ

ಪೈಥಾನ್‌ನಲ್ಲಿ ಅಂಕಗಣಿತದ ನಿರ್ವಾಹಕರು

ಅಂಕಗಣಿತದ ನಿರ್ವಾಹಕರನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ (ಸ್ಥಿರಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳು). ಪೈಥಾನ್ ಕೆಳಗಿನ ಅಂಕಗಣಿತದ ನಿರ್ವಾಹಕರನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ:

– ಸೇರ್ಪಡೆ (+): ಎರಡು ಒಪೆರಾಂಡ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.
– ವ್ಯವಕಲನ (-): ಮೊದಲನೆಯದರಿಂದ ಎರಡನೇ ಒಪೆರಾಂಡ್ ಅನ್ನು ಕಳೆಯುತ್ತದೆ.
– ಗುಣಾಕಾರ (*): ಎರಡು ಒಪೆರಾಂಡ್‌ಗಳನ್ನು ಗುಣಿಸುತ್ತದೆ.
– ವಿಭಾಗ (/): ಮೊದಲ ಒಪೆರಾಂಡ್ ಅನ್ನು ಎರಡನೆಯದರಿಂದ ಭಾಗಿಸುತ್ತದೆ.
– ಮಾಡ್ಯುಲಸ್ (%): ಮೊದಲ ಒಪೆರಾಂಡ್ ಅನ್ನು ಎರಡನೆಯದರಿಂದ ಭಾಗಿಸುವ ಶೇಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
– ಘಾತ (**): ಮತ್ತೊಂದು ಸಂಖ್ಯೆಯಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಶಕ್ತಿಗೆ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
– ಮಹಡಿ ವಿಭಾಗ (//): ವಿಭಜನೆಯ ಫಲಿತಾಂಶದ ಪೂರ್ಣಾಂಕ ಭಾಗವನ್ನು ಮಾತ್ರ ವಿಭಜಿಸುತ್ತದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಯಾವುದೇ ಭಾಗಶಃ ಭಾಗವನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ.

ಸರಳವಾದ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ಹೇಗೆ ತಯಾರಿಸುವುದು?

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸರಳವಾದ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ತಯಾರಿಸುವುದು ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಕಲಿಯಲು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ. ಇದನ್ನು ಹೇಗೆ ಮಾಡುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

1. ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ವಾದಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಕಾರ್ಯವನ್ನು ರಚಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ. ಉದಾಹರಣೆಗೆ, ನೀವು ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಿಮ್ಮ ಕಾರ್ಯವು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:
ಡೆಫ್ ಆಡ್(ಸಂಖ್ಯೆ1, ಸಂಖ್ಯೆ2):
num1 + num2 ಹಿಂತಿರುಗಿ
2. ಬಳಕೆದಾರರು 'q' ಅಥವಾ 'ಕ್ವಿಟ್' ಅನ್ನು ನಮೂದಿಸುವವರೆಗೆ ಸಂಖ್ಯೆಗಳನ್ನು ನಮೂದಿಸುವುದನ್ನು ಮುಂದುವರಿಸಲು ಅನುಮತಿಸುವ ಲೂಪ್ ಅನ್ನು ರಚಿಸಿ. ಈ ಲೂಪ್ ಪ್ರತಿ ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶವನ್ನು ಅದು ಹೋದಂತೆ ಮುದ್ರಿಸಬೇಕು.
ನಿಜವಾಗಿದ್ದರೂ:
num1 = ಇನ್ಪುಟ್ ("ಮೊದಲ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ (ಅಥವಾ ತೊರೆಯಲು q): ")

num1 == 'q' ಅಥವಾ num1 == 'ನಿರ್ಗಮಿಸಿ':
ಬ್ರೇಕ್

num2 = ಇನ್ಪುಟ್ ("ಎರಡನೇ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ: ")

ಫಲಿತಾಂಶ = ಸೇರಿಸು(ಇಂಟ್(ಸಂಖ್ಯೆ1), ಇಂಟ್(ಸಂಖ್ಯೆ2))

ಮುದ್ರಣ ("ಫಲಿತಾಂಶವಾಗಿದೆ", ಫಲಿತಾಂಶ)
3. ಅಂತಿಮವಾಗಿ, ಅವರು ಯಾವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಬಯಸುತ್ತಾರೆ ಮತ್ತು ಅವರ ಉತ್ತರದ ಆಧಾರದ ಮೇಲೆ ಸೂಕ್ತವಾದ ಕಾರ್ಯವನ್ನು ಕರೆಯಲು ಬಳಕೆದಾರರನ್ನು ಕೇಳಿ. ಉದಾಹರಣೆಗೆ:
ಕಾರ್ಯಾಚರಣೆ = ಇನ್ಪುಟ್ ("ನೀವು ಯಾವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡಲು ಬಯಸುತ್ತೀರಿ? (+, -, *, /): ")
ಕಾರ್ಯಾಚರಣೆ ವೇಳೆ == “+”:
ಫಲಿತಾಂಶ = ಸೇರಿಸು(ಇಂಟ್(ಸಂಖ್ಯೆ1), ಇಂಟ್(ಸಂಖ್ಯೆ2))
elif ಕಾರ್ಯಾಚರಣೆ == "-":
    ಫಲಿತಾಂಶ = ಕಳೆಯಿರಿ(int(num1), int(num2))
    # ಇತ್ಯಾದಿ...