ઉકેલાયેલ: પાયથોનમાં 2d એરેનો સરવાળો

Python માં 2D એરેના સારાંશ સાથે સંબંધિત મુખ્ય સમસ્યા એ છે કે આમ કરવા માટેની વાક્યરચના ખૂબ જટિલ અને સમજવામાં મુશ્કેલ હોઈ શકે છે. આ એટલા માટે છે કારણ કે એરેના આકાર અને કયા પ્રકારનો સરવાળો ઇચ્છિત છે તેના આધારે 2D એરેનો સરવાળો કરવાની બહુવિધ રીતો છે. ઉદાહરણ તરીકે, જો તમે 2D એરેમાં તમામ ઘટકોનો સરવાળો કરવા માંગો છો, તો તમારે લૂપ્સ માટે નેસ્ટેડનો ઉપયોગ કરવાની જરૂર પડશે. જો તમે 2D એરેમાં માત્ર અમુક ઘટકોનો સરવાળો કરવા માંગતા હો, તો તમારે સૂચિ સમજણ અથવા અન્ય વધુ અદ્યતન તકનીકોનો ઉપયોગ કરવાની જરૂર પડશે. વધુમાં, 2D એરે સાથે કામ કરતી વખતે ભૂલોને ડીબગ કરવી મુશ્કેલ બની શકે છે કારણ કે તે 1D એરે કરતાં વધુ જટિલ છે.

def sum_2d_array(arr): 
    result = 0
  
    # iterate through rows 
    for i in range(0, len(arr)): 
  
        # iterate through columns 
        for j in range(0, len(arr[i])): 
            result += arr[i][j] 

    return result

# આ કોડ sum_2d_array નામના ફંક્શનને વ્યાખ્યાયિત કરે છે જે એરેમાં દલીલ તરીકે લે છે.
# પરિણામ ચલ 0 થી શરૂ થાય છે.
# એ ફોર લૂપનો ઉપયોગ એરેની પંક્તિઓ દ્વારા પુનરાવર્તિત કરવા માટે થાય છે, અને લૂપ માટે નેસ્ટેડનો ઉપયોગ દરેક હરોળના કૉલમ દ્વારા પુનરાવર્તન કરવા માટે થાય છે.
# એરેમાંના દરેક ઘટક માટે, તેની કિંમત પરિણામ ચલમાં ઉમેરવામાં આવે છે.
# છેલ્લે, ફંક્શન એરેમાંના તમામ ઘટકોનો કુલ સરવાળો આપે છે.

એરે શું છે

?

પાયથોનમાં એરે એ ડેટા સ્ટ્રક્ચર છે જે વસ્તુઓના સંગ્રહને સંગ્રહિત કરે છે. તે સૂચિ જેવું જ છે, પરંતુ એરેમાં સંગ્રહિત વસ્તુઓ સામાન્ય રીતે સમાન પ્રકારની હોય છે અને સંખ્યાત્મક સૂચકાંકોનો ઉપયોગ કરીને ઍક્સેસ કરવામાં આવે છે. એરેનો ઉપયોગ નંબરો, સ્ટ્રીંગ્સ, ઑબ્જેક્ટ્સ અને અન્ય ડેટા પ્રકારો સ્ટોર કરવા માટે થઈ શકે છે. તેઓ ડેટાના મોટા સેટ પર ગાણિતિક ક્રિયાઓ કરવા માટે પણ ઉપયોગી છે.

પાયથોનમાં અરે વિ લિસ્ટ

એરે અને લિસ્ટ બંને પાયથોનમાં ડેટા સ્ટ્રક્ચર છે જેનો ઉપયોગ ડેટાના સંગ્રહને સ્ટોર કરવા માટે થાય છે. એરે એ એક ડેટા માળખું છે જે એક જ પ્રકારની વસ્તુઓનો સંગ્રહ કરે છે, જ્યારે સૂચિ એ વધુ લવચીક ડેટા માળખું છે જે વિવિધ પ્રકારની વસ્તુઓને સંગ્રહિત કરી શકે છે.

સૂચિઓ કરતાં ડેટા સ્ટોર કરવા અને ઍક્સેસ કરવા માટે એરે ઝડપી અને વધુ કાર્યક્ષમ છે, પરંતુ તેઓ તેમની લવચીકતામાં મર્યાદિત છે કારણ કે તમામ ઘટકો સમાન પ્રકારના હોવા જોઈએ. બીજી બાજુ, યાદીમાં વિવિધ પ્રકારના તત્વો હોઈ શકે છે, પરંતુ તેઓ વધુ મેમરી લે છે અને એરે કરતાં એક્સેસ કરવામાં ધીમી હોય છે.

પાયથોનમાં 2d એરેનો સરવાળો કેવી રીતે કરવો

Python માં 2d એરેનો સરવાળો કરવા માટે, તમે બિલ્ટ-ઇન sum() ફંક્શનનો ઉપયોગ કરી શકો છો. આ માટેની વાક્યરચના નીચે મુજબ છે:

સરવાળો(એરે, અક્ષ=કોઈ નહીં)

જ્યાં એરે એ 2d એરે છે જ્યાં તમે સરવાળો કરવા માંગો છો અને અક્ષ એ એક વૈકલ્પિક દલીલ છે જે સ્પષ્ટ કરે છે કે એરેના કયા અક્ષનો સરવાળો કરવો જોઈએ. જો ધરી માટે કોઈ મૂલ્ય આપવામાં આવ્યું નથી, તો પછી એરેના તમામ ઘટકોનો સરવાળો કરવામાં આવશે.

ઉદાહરણ તરીકે, જો અમારી પાસે 2 પંક્તિઓ અને 3 કૉલમ્સ સાથે my_array નામનું 4d એરે છે:

[[1,2,3,4],
[5,6,7,8],
[9,10,11,12]

અમે my_array ના તમામ ઘટકોનો સરવાળો કરવા માટે નીચેના કોડનો ઉપયોગ કરી શકીએ છીએ:

કુલ = સરવાળો(my_array) #કુલ = 78

અથવા અમે my_array ની દરેક પંક્તિનો સરવાળો કરવા માટે નીચેના કોડનો ઉપયોગ કરી શકીએ છીએ:

row_sums = સરવાળો(my_array ,axis=1) #row_sums = [10 26 42]