ઉકેલાયેલ: અજગરમાં સરળ કેલ્ક્યુલેટર બનાવો

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: num1 ને વપરાશકર્તા તરફથી ફ્લોટ ઇનપુટની કિંમત અસાઇન કરવામાં આવે છે
# લાઇન 3: num2 ને વપરાશકર્તા તરફથી ફ્લોટ ઇનપુટની કિંમત અસાઇન કરવામાં આવે છે
# લાઇન 5: num1 અને num2 ના સરવાળાની ગણતરી કરવામાં આવે છે અને ચલ રકમમાં સંગ્રહિત થાય છે
# લાઇન 7: નંબર 1, num2 અને રકમનો સરવાળો સ્ટ્રિંગ ફોર્મેટિંગનો ઉપયોગ કરીને કન્સોલ પર છાપવામાં આવે છે

Python માં અંકગણિત ઓપરેટરો

અંકગણિત ઓપરેટર્સનો ઉપયોગ સંખ્યાત્મક મૂલ્યો (અચલ અને ચલ) પર ગાણિતિક ક્રિયાઓ કરવા માટે થાય છે. પાયથોન નીચેના અંકગણિત ઓપરેટરોને સપોર્ટ કરે છે:

- ઉમેરણ (+): બે ઓપરેન્ડ ઉમેરે છે.
– બાદબાકી (-): પ્રથમમાંથી બીજા ઓપરેન્ડને બાદ કરે છે.
- ગુણાકાર (*): બે ઓપરેન્ડનો ગુણાકાર કરે છે.
– વિભાગ (/): પ્રથમ ઓપરેન્ડને બીજા દ્વારા વિભાજિત કરે છે.
– મોડ્યુલસ (%): પ્રથમ ઓપરેન્ડને બીજા ઓપરેન્ડથી વિભાજિત કરવાની બાકીની રકમ પરત કરે છે.
– ઘાતાંક (**): સંખ્યાને બીજી સંખ્યા દ્વારા નિર્દિષ્ટ ઘાત પર વધે છે.
– ફ્લોર ડિવિઝન (//): કોઈપણ અપૂર્ણાંક ભાગને છોડીને, ડિવિઝન પરિણામના માત્ર પૂર્ણાંક ભાગને વિભાજિત કરે છે અને પરત કરે છે.

તમે સરળ કેલ્ક્યુલેટર કેવી રીતે બનાવશો?

Python માં સરળ કેલ્ક્યુલેટર બનાવવું એ પ્રોગ્રામિંગની મૂળભૂત બાબતો શીખવાની એક સરસ રીત છે. તે કેવી રીતે કરવું તે અહીં છે:

1. એક ફંક્શન બનાવીને પ્રારંભ કરો જે દલીલો તરીકે બે સંખ્યાઓ લેશે અને ગણતરીનું પરિણામ આપશે. ઉદાહરણ તરીકે, જો તમે બે નંબરો ઉમેરવા માંગો છો, તો તમારું કાર્ય આના જેવું દેખાશે:
def ઉમેરો(num1, num2):
num1 + num2 પરત કરો
2. એક લૂપ બનાવો જે વપરાશકર્તાને નંબરો દાખલ કરવાનું ચાલુ રાખવા દેશે જ્યાં સુધી તેઓ 'q' અથવા 'છોડો' દાખલ ન કરે. આ લૂપ દરેક ગણતરીના પરિણામની પ્રિન્ટ આઉટ પણ કરે છે કારણ કે તે આગળ વધે છે.
જ્યારે સાચું:
num1 = ઇનપુટ ("પ્રથમ નંબર દાખલ કરો (અથવા છોડવા માટે q): ")

જો num1 == 'q' અથવા num1 == 'quit':
વિરામ

num2 = ઇનપુટ ("બીજો નંબર દાખલ કરો: ")

પરિણામ = ઉમેરો(int(num1), int(num2))

છાપો ("પરિણામ છે", પરિણામ)
3. છેલ્લે, વપરાશકર્તાને પૂછો કે તેઓ કયું ઓપરેશન કરવા માંગે છે અને તેમના જવાબના આધારે યોગ્ય કાર્યને કૉલ કરો. દાખ્લા તરીકે:
ઓપરેશન = ઇનપુટ("તમે કયું ઓપરેશન કરવા માંગો છો? (+, -, *, /): ")
જો ઓપરેશન == “+”:
પરિણામ = ઉમેરો(int(num1), int(num2))
elif ઓપરેશન == "-":
    પરિણામ = બાદબાકી(int(num1), int(num2))
    # વગેરે...