કમ્પ્યુટર પ્રોગ્રામિંગની દુનિયામાં, ભૂલોનો સામનો કરવો એ એક સામાન્ય ઘટના છે. ઉદાહરણ તરીકે, લો કી એરર: 'acc' in પાયથોન. આ ભૂલ ઘણીવાર ત્યારે ઉદ્ભવે છે જ્યારે આપણે શબ્દકોશમાંથી ઍક્સેસ કરવાનો પ્રયાસ કરી રહ્યા છીએ તે ચોક્કસ કી અસ્તિત્વમાં નથી. સદભાગ્યે, પાયથોન આવી સમસ્યાઓને હેન્ડલ કરવા અને તમારા કોડને ક્રેશ થતા અટકાવવા માટે છટાદાર ઉકેલ પૂરો પાડે છે. આમાં અપવાદ હેન્ડલિંગ પ્રક્રિયાઓ લાગુ કરવી, get() ફંક્શનનો ઉપયોગ કરવો, અથવા તેમને ઍક્સેસ કરતા પહેલા કીઓ તપાસવાનો સમાવેશ થાય છે. યોગ્ય અભિગમ સાથે, આ ભૂલ કુશળતાપૂર્વક સંચાલિત કરી શકાય છે.
કી ભૂલને સમજવું
કી એરર ઇન પાયથોન એ એક પ્રકારનો અપવાદ છે જે જ્યારે તમે અસ્તિત્વમાં ન હોય તેવી કી વડે શબ્દકોશને ઍક્સેસ કરવાનો પ્રયાસ કરો ત્યારે ઉભા થાય છે. તે હંમેશા સારી કોડિંગ પ્રેક્ટિસ છે અને પાયથોનના સત્તાવાર દસ્તાવેજો મુજબ, તેની કિંમતને ઍક્સેસ કરવાનો પ્રયાસ કરતા પહેલા કી હાજર છે કે કેમ તે તપાસવા માટે.
#Random example of KeyError
dict1 = {"a":1,"b":2,"c":3}
print(dict1["d"])
ઉપરના કોડમાં, 'd' ડિક્શનરી dict1 માં અસ્તિત્વમાં નથી, તેથી તે પરિણમે છે કી એરર: 'd'.
કી એરરનો ઉકેલ: 'acc'
હેન્ડલિંગ માટે ઉકેલ કી એરર તમે શબ્દકોશમાંથી આઇટમ્સને ઍક્સેસ કરવા માટે કેવી રીતે સંપર્ક કરો છો તે અસરકારક રીતે પડે છે. એક રીતે તમે આ ભૂલને ટાળી શકો છો તેનો ઉપયોગ કરીને મેળવો () કીનો સંદર્ભ આપતી વખતે પદ્ધતિ.
તમે તે કેવી રીતે કરશો તે અહીં છે:
#prints None instead of giving KeyError
print(dict1.get("d"))
કોડ કોઈ નહીં આપે છે, કારણ કે "d" શબ્દકોશમાં નથી. ઉપયોગ કરીને મેળવો () પદ્ધતિ, અમે ડિફોલ્ટ મૂલ્ય પણ પ્રદાન કરી શકીએ છીએ જે જ્યારે કી અસ્તિત્વમાં ન હોય ત્યારે પરત કરવામાં આવે છે.
#prints 'default' instead of None
print(dict1.get("d", 'default'))
અપવાદ હેન્ડલિંગ KeyError ને હેન્ડલ કરવાની બીજી ટેકનિક છે. આ નીચે બતાવ્યા પ્રમાણે બ્લોક સિવાયના પ્રયાસની મદદથી કરી શકાય છે.
try:
# code that can raise an exception
print(dict1["d"])
except KeyError:
# Execute this code in case of KeyError
print('Key does not exist')
આ કોડ સમગ્ર પ્રોગ્રામને સમાપ્ત કરતું નથી અને "કી અસ્તિત્વમાં નથી" પ્રિન્ટ કરીને અપવાદને આકર્ષક રીતે હેન્ડલ કરે છે, જે વધુ વપરાશકર્તા-મૈત્રીપૂર્ણ છે.
કોડને સ્ટેપ-બાય-સ્ટેપ સમજાવવું
KeyErrors સાથે વ્યવહાર કરવાની જટિલતાને જોતાં, ઉપરોક્ત કોડને થોડી-થોડી વારમાં તોડવો મહત્વપૂર્ણ છે.
પ્રથમ ઉદાહરણમાં, અમે {'a': 1, 'b': 1, 'c': 2}ની કી-વેલ્યુ જોડીઓ સાથે 'dict3' નામના શબ્દકોશને વ્યાખ્યાયિત કરીએ છીએ. પછી આપણે કી 'd' ને ઍક્સેસ કરવાનો પ્રયાસ કરીએ છીએ જે 'dict1' માં અસ્તિત્વમાં નથી. આ પાયથોનને સંદેશ તરીકે 'd' સાથે કી-એરર વધારવાનું કારણ બને છે.
બીજા ઉદાહરણમાં, આપણે get() પદ્ધતિનો ઉપયોગ કરીએ છીએ. આ Python શબ્દકોશ પદ્ધતિ આપેલ કી માટે મૂલ્ય પુનઃપ્રાપ્ત કરે છે. જો કી હાજર ન હોય, તો મૂળભૂત રીતે, તે 'કોઈ નહીં' પરત કરે છે. આ પાયથોનને કી એરર વધારવાથી અટકાવે છે.
ત્રીજા ઉદાહરણમાં, અમે 'કોઈ નહીં' ને બદલે ઉપયોગી સંદેશ મેળવવા માટે 'ડિફોલ્ટ' ની મૂળભૂત કિંમત સેટ કરીએ છીએ. કી હાજર ન હોવાનો સંકેત આપવાની આ વધુ માહિતીપ્રદ રીત છે.
છેલ્લે, અમે અપવાદ હેન્ડલિંગ માટે ટ્રાય-સિવાય બ્લોકનો ઉપયોગ કરીએ છીએ. અમે અમારો કોડ 'પ્રયાસ' હેઠળ લખીએ છીએ અને 'સિવાય' હેઠળ 'કી-એરર' થાય તો શું કરવું તે વ્યાખ્યાયિત કરીએ છીએ. આ કોડને તૂટવા કે ક્રેશ થવાને બદલે અંદર આવવા માટે સુરક્ષા જાળ પ્રદાન કરે છે.
તમારા પાયથોન પ્રોગ્રામિંગમાં આ યુક્તિઓનો અમલ તમારા કોડિંગ કૌશલ્યને વધારવામાં ઘણી મદદ કરી શકે છે.
