પાયથોનમાં સ્ટ્રીંગ્સ (એરે)ની સૂચિ અને સંખ્યાઓની સૂચિને એકબીજામાં રૂપાંતરિત કરવી

નીચેની સામગ્રીઓ, નમૂના કોડ સાથે, પાયથોનમાં સ્ટ્રીંગ્સ (str) ની સૂચિઓ (એરે) અને સંખ્યાઓની સૂચિ (int, float) ને એકબીજામાં કેવી રીતે કન્વર્ટ કરવી તે સમજાવે છે.

• સંખ્યાઓની સૂચિને શબ્દમાળાઓની સૂચિમાં કન્વર્ટ કરો
  • સંખ્યાને દશાંશ શબ્દમાળામાં કન્વર્ટ કરો
  • આંકડાકીય મૂલ્યોને બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલ સ્ટ્રિંગમાં રૂપાંતરિત કરે છે
  • સંખ્યાત્મક મૂલ્યને ઘાતાંકીય સંકેતમાં સ્ટ્રિંગમાં રૂપાંતરિત કરે છે
• શબ્દમાળાઓની સૂચિને સંખ્યાઓની સૂચિમાં કન્વર્ટ કરો
  • દશાંશ શબ્દમાળાને આંકડાકીયમાં કન્વર્ટ કરો
  • દ્વિસંગી, અષ્ટક અને હેક્સાડેસિમલ સ્ટ્રિંગ્સને સંખ્યામાં રૂપાંતરિત કરે છે
  • ઘાતાંકીય સંકેતમાં સ્ટ્રિંગ્સને સંખ્યાત્મક મૂલ્યોમાં રૂપાંતરિત કરે છે
  • ફક્ત સ્ટ્રિંગ્સને કન્વર્ટ કરો જે નંબરોમાં રૂપાંતરિત થઈ શકે છે

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

• સંબંધિત:પાયથોન સૂચિ સમજણનો ઉપયોગ કેવી રીતે કરવો

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

• હું એવી પ્રક્રિયાઓને હેન્ડલ કરવા માંગુ છું કે જેને મેમરી સાઈઝ અને મેમરી એડ્રેસની જરૂર હોય.
• મોટા ડેટા સેટ્સ વગેરેની સંખ્યાત્મક પ્રક્રિયા માટે એરેને હેન્ડલ કરવા માંગો છો.

સંખ્યાઓની સૂચિને શબ્દમાળાઓની સૂચિમાં કન્વર્ટ કરો

સંખ્યાને દશાંશ શબ્દમાળામાં કન્વર્ટ કરો

આંકડાકીયમાંથી સ્ટ્રિંગમાં કન્વર્ટ કરવા માટે str() નો ઉપયોગ કરો.

પાયથોનમાં, સંખ્યાઓને ઘાતાંકીય, હેક્સાડેસિમલ અને બાઈનરી (હેક્સાડેસિમલ અને બાઈનરી નોટેશન) સહિત વિવિધ ફોર્મેટમાં વ્યક્ત કરી શકાય છે. str() રૂપાંતરણ સામાન્ય દશાંશ સંકેતમાં સ્ટ્રિંગમાં પરિણમે છે.

અંકોની સંખ્યાના આધારે, ઘાતાંકીય સંકેતનો આપમેળે ઉપયોગ થઈ શકે છે.

l_n = [-0.5, 0, 1.0, 100, 1.2e-2, 0xff, 0b11]

l_n_str = [str(n) for n in l_n]
print(l_n_str)
# ['-0.5', '0', '1.0', '100', '0.012', '255', '3']

આંકડાકીય મૂલ્યોને બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલ સ્ટ્રિંગમાં રૂપાંતરિત કરે છે

દ્વિસંગી, ઓક્ટલ અથવા હેક્સાડેસિમલ (દ્વિસંગી સંકેત, અષ્ટાંક સંકેત, અથવા હેક્સાડેસિમલ નોટેશન) શબ્દમાળામાં કન્વર્ટ કરવા માટે, નીચેની પદ્ધતિઓ ઉપલબ્ધ છે.

• bin()
• oct()
• hex()
• format()
• str.format()

ફોર્મેટ() ફંક્શન સાથે, શૂન્ય ભરવાનું અને અંકોને સમાયોજિત કરવાનું શક્ય છે.

l_i = [0, 64, 128, 192, 256]

l_i_hex1 = [hex(i) for i in l_i]
print(l_i_hex1)
# ['0x0', '0x40', '0x80', '0xc0', '0x100']

l_i_hex2 = [format(i, '04x') for i in l_i]
print(l_i_hex2)
# ['0000', '0040', '0080', '00c0', '0100']

l_i_hex3 = [format(i, '#06x') for i in l_i]
print(l_i_hex3)
# ['0x0000', '0x0040', '0x0080', '0x00c0', '0x0100']

સંખ્યાત્મક મૂલ્યને ઘાતાંકીય સંકેતમાં સ્ટ્રિંગમાં રૂપાંતરિત કરે છે

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

• format()
• str.format()

format() ફંક્શન અને સ્ટ્રિંગ મેથડ str.format() પર વધુ માહિતી માટે, નીચેનો લેખ જુઓ.

• સંબંધિત:પાયથોનમાં ફોર્મેટ કન્વર્ઝન, ફોર્મેટ (0-ફિલિંગ, ઘાતાંકીય સંકેત, હેક્સાડેસિમલ, વગેરે)

મન્ટિસા ભાગના અંકોની સંખ્યા સ્પષ્ટ કરી શકાય છે. જો અપરકેસ E નો ઉપયોગ દલીલ તરીકે થાય છે, તો આઉટપુટ સ્ટ્રિંગ પણ અપરકેસ E છે.

l_f = [0.0001, 123.456, 123400000]

l_f_e1 = [format(f, 'e') for f in l_f]
print(l_f_e1)
# ['1.000000e-04', '1.234560e+02', '1.234000e+08']

l_f_e2 = [format(f, '.3E') for f in l_f]
print(l_f_e2)
# ['1.000E-04', '1.235E+02', '1.234E+08']

શબ્દમાળાઓની સૂચિને સંખ્યાઓની સૂચિમાં કન્વર્ટ કરો

દશાંશ શબ્દમાળાને આંકડાકીયમાં કન્વર્ટ કરો

સ્ટ્રિંગમાંથી નંબરમાં કન્વર્ટ કરવા માટે int() અથવા float() નો ઉપયોગ કરો.

int() એ પૂર્ણાંકમાં રૂપાંતર છે, અને float() એ ફ્લોટિંગ-પોઇન્ટ નંબરમાં રૂપાંતર છે.

ફ્લોટ() માં, પૂર્ણાંક ભાગ અવગણવામાં આવેલ શબ્દમાળાઓ પૂર્ણાંક ભાગ માટે 0 સાથે પૂરક છે.

l_si = ['-10', '0', '100']

l_si_i = [int(s) for s in l_si]
print(l_si_i)
# [-10, 0, 100]

l_sf = ['.123', '1.23', '123']

l_sf_f = [float(s) for s in l_sf]
print(l_sf_f)
# [0.123, 1.23, 123.0]

દ્વિસંગી, અષ્ટક અને હેક્સાડેસિમલ સ્ટ્રિંગ્સને સંખ્યામાં રૂપાંતરિત કરે છે

int() ની બીજી દલીલ મૂલાંક હોઈ શકે છે: દ્વિસંગી માટે 2, અષ્ટક માટે 8 અને હેક્સાડેસિમલ માટે 16, સ્ટ્રિંગને સંખ્યામાં રૂપાંતરિત કરે છે.

જો 0 ઉલ્લેખિત હોય, તો નીચેની દરેક ઉપસર્ગ સ્ટ્રીંગને પૂર્ણાંકમાં રૂપાંતરિત કરવામાં આવે છે.

• 0b
  • દ્વિસંગી અંકો
• 0o
  • ઓક્ટલ
• 0x
  • હેક્સાડેસિમલ

• સંબંધિત:પાયથોનમાં બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલ નંબરો અને સ્ટ્રીંગ્સને એકબીજામાં કન્વર્ટ કરો

l_sb = ['0011', '0101', '1111']

l_sb_i = [int(s, 2) for s in l_sb]
print(l_sb_i)
# [3, 5, 15]

l_sbox = ['100', '0b100', '0o77', '0xff']

l_sbox_i = [int(s, 0) for s in l_sbox]
print(l_sbox_i)
# [100, 4, 63, 255]

ઘાતાંકીય સંકેતમાં સ્ટ્રિંગ્સને સંખ્યાત્મક મૂલ્યોમાં રૂપાંતરિત કરે છે

ઘાતાંકીય નોટેશનમાં સ્ટ્રિંગ્સને વિશેષ સ્પષ્ટીકરણની જરૂર વગર ફ્લોટ() સાથે સીધા જ રૂપાંતરિત કરી શકાય છે.

l_se = ['1.23e3', '0.123e-1', '123']

l_se_f = [float(s) for s in l_se]
print(l_se_f)
# [1230.0, 0.0123, 123.0]

ફક્ત સ્ટ્રિંગ્સને કન્વર્ટ કરો જે નંબરોમાં રૂપાંતરિત થઈ શકે છે

સંખ્યાને int() અથવા float() માં રૂપાંતરિત કરી શકાતી નથી તે સ્ટ્રિંગને પસાર કરવાથી મૂલ્ય ભૂલ થશે.

જો કોઈ નવું ફંક્શન વ્યાખ્યાયિત કરવામાં આવ્યું હોય જે ભૂલ પર ખોટું પાછું આપે છે, તો માત્ર રૂપાંતરિત કરી શકાય તેવા ઘટકોને નંબરોમાં રૂપાંતરિત કરી શકાય છે અને સૂચિના ઘટકો બની શકે છે.

def is_int(s):
    try:
        int(s)
    except ValueError:
        return False
    else:
        return True

def is_float(s):
    try:
        float(s)
    except ValueError:
        return False
    else:
        return True

l_multi = ['-100', '100', '1.23', '1.23e2', 'one']

l_multi_i = [int(s) for s in l_multi if is_int(s)]
print(l_multi_i)
# [-100, 100]

l_multi_f = [float(s) for s in l_multi if is_float(s)]
print(l_multi_f)
# [-100.0, 100.0, 1.23, 123.0]