தீர்க்கப்பட்டது: பைத்தானில் எளிய கால்குலேட்டரை உருவாக்கவும்

பைத்தானில் ஒரு எளிய கால்குலேட்டரை உருவாக்குவது தொடர்பான முக்கிய பிரச்சனை என்னவென்றால், குறியீட்டை சரியாக எழுதுவது கடினமாக இருக்கும். Python ஒரு சக்திவாய்ந்த மொழி, ஆனால் ஆரம்பநிலையாளர்கள் புரிந்துகொள்வதற்கும் பயன்படுத்துவதற்கும் கடினமாக இருக்கலாம். கூடுதலாக, குறியீட்டு பிழைகள் தவறான முடிவுகள் அல்லது எதிர்பாராத நடத்தைக்கு வழிவகுக்கும். மேலும், பிரிவு அல்லது சதுர வேர்கள் போன்ற மிகவும் சிக்கலான செயல்பாடுகளுக்கான குறியீட்டை எழுதுவதற்கு கணிதம் மற்றும் அல்காரிதம் பற்றிய கூடுதல் அறிவு தேவைப்படலாம். இறுதியாக, குறியீட்டை பிழைதிருத்தம் செய்வது நேரத்தை எடுத்துக்கொள்வது மற்றும் சவாலானது.

# 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: பயனரிடமிருந்து ஃப்ளோட் உள்ளீட்டின் மதிப்பு எண்1க்கு ஒதுக்கப்படுகிறது
# வரி 3: பயனரிடமிருந்து ஃப்ளோட் உள்ளீட்டின் மதிப்பு எண்2க்கு ஒதுக்கப்படுகிறது
# வரி 5: num1 மற்றும் num2 ஆகியவற்றின் கூட்டுத்தொகை கணக்கிடப்பட்டு மாறித் தொகையில் சேமிக்கப்படுகிறது
# வரி 7: num1, num2 மற்றும் கூட்டுத்தொகை சரம் வடிவமைப்பைப் பயன்படுத்தி கன்சோலில் அச்சிடப்படும்

பைத்தானில் உள்ள எண்கணித ஆபரேட்டர்கள்

எண்கணித ஆபரேட்டர்கள் எண் மதிப்புகளில் (மாறிகள் மற்றும் மாறிகள்) கணித செயல்பாடுகளைச் செய்யப் பயன்படுத்தப்படுகின்றன. பைதான் பின்வரும் எண்கணித ஆபரேட்டர்களை ஆதரிக்கிறது:

– கூட்டல் (+): இரண்டு செயல்களை சேர்க்கிறது.
– கழித்தல் (-): முதல் செயலிலிருந்து இரண்டாவது செயலியைக் கழிக்கிறது.
– பெருக்கல் (*): இரண்டு செயல்களை பெருக்குகிறது.
– பிரிவு (/): முதல் செயலியை இரண்டாவதாகப் பிரிக்கிறது.
– மாடுலஸ் (%): முதல் செயலியை இரண்டாவதாக வகுத்தால் மீதியை வழங்குகிறது.
– அடுக்கு (**): ஒரு எண்ணை மற்றொரு எண்ணால் குறிப்பிடப்பட்ட சக்திக்கு உயர்த்துகிறது.
– தரைப் பிரிவு (//): ஒரு பிரிவு முடிவின் முழுப் பகுதியை மட்டும் வகுத்து வழங்கும், எந்தப் பகுதியான பகுதியையும் நிராகரிக்கிறது.

எளிய கால்குலேட்டரை எவ்வாறு உருவாக்குவது?

பைத்தானில் ஒரு எளிய கால்குலேட்டரை உருவாக்குவது நிரலாக்கத்தின் அடிப்படைகளை அறிய சிறந்த வழியாகும். அதை எப்படி செய்வது என்பது இங்கே:

1. இரண்டு எண்களை வாதங்களாக எடுத்து கணக்கீட்டின் முடிவை வழங்கும் செயல்பாட்டை உருவாக்குவதன் மூலம் தொடங்கவும். எடுத்துக்காட்டாக, நீங்கள் இரண்டு எண்களைச் சேர்க்க விரும்பினால், உங்கள் செயல்பாடு இப்படி இருக்கும்:
டெஃப் சேர்(எண்1, எண்2):
திரும்ப எண்1 + எண்2
2. பயனர் 'q' அல்லது 'வெளியேறும்' வரை எண்களை உள்ளிடுவதைத் தொடர அனுமதிக்கும் ஒரு வளையத்தை உருவாக்கவும். இந்த லூப் ஒவ்வொரு கணக்கீட்டின் முடிவையும் அச்சிட வேண்டும்.
உண்மை என்றாலும்:
எண்1 = உள்ளீடு ("முதல் எண்ணை உள்ளிடவும் (அல்லது வெளியேற q): ")

எண்1 == 'q' அல்லது எண்1 == 'வெளியேறு' என்றால்:
இடைவெளி

எண்2 = உள்ளீடு ("இரண்டாவது எண்ணை உள்ளிடவும்: ")

முடிவு = சேர்(int(num1), int(num2))

அச்சு ("முடிவு", முடிவு)
3. இறுதியாக, எந்தச் செயல்பாட்டைச் செய்ய விரும்புகிறீர்கள் என்று பயனரிடம் கேட்டு, அவர்களின் பதிலின் அடிப்படையில் பொருத்தமான செயல்பாட்டை அழைக்கவும். உதாரணத்திற்கு:
செயல்பாடு = உள்ளீடு ("நீங்கள் என்ன செயல்பாட்டைச் செய்ய விரும்புகிறீர்கள்? (+, -, *, /): ")
செயல்பட்டால் == “+”:
முடிவு = சேர்(int(num1), int(num2))
elif செயல்பாடு == “-“:
    முடிவு = கழித்தல்(int(num1), int(num2))
    # போன்றவை…