નંબર સ્ટ્રિંગને નંબર ઈન્ટમાં કન્વર્ટ કરો, પાયથોનમાં ફ્લોટ કરો

જો તમે પાયથોનમાં સંખ્યાઓની સ્ટ્રિંગને આંકડાકીય મૂલ્યોમાં રૂપાંતરિત કરવા માંગો છો, તો પૂર્ણાંકમાં રૂપાંતરિત કરવા માટે int() નો ઉપયોગ કરો અને ફ્લોટિંગ પોઈન્ટ નંબર્સમાં રૂપાંતરિત કરવા માટે float() નો ઉપયોગ કરો.

સેમ્પલ કોડ સાથે અહીં નીચેનું સમજાવ્યું છે.

• મૂળભૂત ઉપયોગ
  • સંખ્યાત્મક શબ્દમાળાઓને પૂર્ણાંકોમાં કન્વર્ટ કરો:int()
  • નંબરોની સ્ટ્રિંગને ફ્લોટિંગ પોઈન્ટ નંબર્સમાં કન્વર્ટ કરો:float()
• ખાસ ઉપયોગ
  • દ્વિસંગી, અષ્ટાકાર અને હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગ્સને સંખ્યામાં રૂપાંતરિત કરે છે
  • ઘાતાંકીય સંકેતમાં સ્ટ્રિંગ્સને સંખ્યાત્મક મૂલ્યોમાં રૂપાંતરિત કરે છે
  • પૂર્ણ-પહોળાઈવાળા અરબી અંકના શબ્દમાળાઓને સંખ્યામાં રૂપાંતરિત કરો
  • ચાઇનીઝ અક્ષરોની સ્ટ્રિંગને સંખ્યામાં કન્વર્ટ કરો

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

જો તમે સંખ્યાઓ અથવા શબ્દમાળાઓને વિવિધ ફોર્મેટમાં કન્વર્ટ કરવા માંગતા હો, તો format() ફંક્શન અથવા સ્ટ્રિંગ પદ્ધતિ str.format() નો ઉપયોગ કરો. પછી તમે 0-ફિલ, બાઈનરી, ઓક્ટલ, હેક્સાડેસિમલ, ઘાતાંકીય નોટેશન વગેરેમાં કન્વર્ટ કરી શકો છો. વિગતો માટે નીચેનો લેખ જુઓ.

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

તે શબ્દમાળાઓની સૂચિને સંખ્યાઓની સૂચિમાં પણ રૂપાંતરિત કરી શકે છે. વિગતો માટે નીચેનો લેખ જુઓ.

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

સંખ્યાત્મક શબ્દમાળાઓને પૂર્ણાંકોમાં કન્વર્ટ કરો:int()

તમે int() નો ઉપયોગ નંબરોની સ્ટ્રિંગને પૂર્ણાંક પ્રકારના નંબરોમાં કન્વર્ટ કરવા માટે કરી શકો છો.

• class int([x]) — Built-in Functions — Python 3.10.4 Documentation

print(int('100'))
print(type(int('100')))
# 100
# <class 'int'>

દશાંશ બિંદુઓ સહિત દશાંશ, અને અલ્પવિરામ દ્વારા વિભાજિત શબ્દમાળાઓ ValueError માં પરિણમશે.

# print(int('1.23'))
# ValueError: invalid literal for int() with base 10: '1.23'

# print(int('10,000'))
# ValueError: invalid literal for int() with base 10: '10,000'

રિપ્લેસ() પદ્ધતિનો ઉપયોગ કરીને અલ્પવિરામ-સીમાંકિત શબ્દમાળાઓ અલ્પવિરામને દૂર કરીને (ખાલી સ્ટ્રિંગથી બદલીને) રૂપાંતરિત કરી શકાય છે.

print(int('10,000'.replace(',', '')))
# 10000

નંબરોની સ્ટ્રિંગને ફ્લોટિંગ પોઈન્ટ નંબર્સમાં કન્વર્ટ કરો:float()

ફ્લોટ() નો ઉપયોગ નંબરોની સ્ટ્રિંગને ફ્લોટિંગ-પોઇન્ટ નંબર પ્રકારમાં કન્વર્ટ કરવા માટે કરી શકાય છે.

• class float([x]) — Built-in Functions — Python 3.10.4 Documentation

print(float('1.23'))
print(type(float('1.23')))
# 1.23
# <class 'float'>

અવગણવામાં આવેલા પૂર્ણાંક ભાગ સાથેની સ્ટ્રીંગ્સ પૂર્ણાંક ભાગને 0 સાથે પૂરક બનાવીને રૂપાંતરિત થાય છે.

print(float('.23'))
# 0.23

પૂર્ણાંક શબ્દમાળાઓ પણ ફ્લોટિંગ-પોઇન્ટ નંબરોમાં રૂપાંતરિત થાય છે.

print(float('100'))
print(type(float('100')))
# 100.0
# <class 'float'>

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

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

print(int('100', 2))
print(int('100', 8))
print(int('100', 16))
# 4
# 64
# 256

અગાઉના ઉદાહરણોની જેમ, જો અવગણવામાં આવે તો, સંખ્યાને દશાંશ સંખ્યા તરીકે ગણવામાં આવે છે.

print(int('100', 10))
print(int('100'))
# 100
# 100

જો રેડિક્સ 0 પર સેટ કરેલ હોય, તો રૂપાંતરણ શબ્દમાળા ઉપસર્ગ પર આધારિત છે. શબ્દમાળા ઉપસર્ગ માટે નીચે જુઓ.

• 0b
  • 0B
• 0o
  • 0O
• 0x
  • 0X

print(int('0b100', 0))
print(int('0o100', 0))
print(int('0x100', 0))
# 4
# 64
# 256

ઉપસર્ગ અને હેક્સ મૂળાક્ષરો કાં તો અપરકેસ અથવા લોઅરકેસ હોઈ શકે છે.

print(int('FF', 16))
print(int('ff', 16))
# 255
# 255

print(int('0xFF', 0))
print(int('0XFF', 0))
print(int('0xff', 0))
print(int('0Xff', 0))
# 255
# 255
# 255
# 255

દ્વિસંગી, અષ્ટાદિક અને હેક્સાડેસિમલ સંખ્યાઓ અને શબ્દમાળાઓના આંતરરૂપાંતરણ અંગેની માહિતી માટે નીચેનો લેખ જુઓ.

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

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

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

print(float('1.23e-4'))
print(type(float('1.23e-4')))
# 0.000123
# <class 'float'>

print(float('1.23e4'))
print(type(float('1.23e4')))
# 12300.0
# <class 'float'>

લોઅરકેસ e પણ કેપિટલાઇઝ્ડ E હોઈ શકે છે.

print(float('1.23E-4'))
# 0.000123

પૂર્ણ-પહોળાઈવાળા અરબી અંકના શબ્દમાળાઓને સંખ્યામાં રૂપાંતરિત કરો

પૂર્ણ-પહોળાઈવાળા અરબી અંકોને int() અથવા float() દ્વારા સીધા નંબરોમાં રૂપાંતરિત કરી શકાય છે.

print(int('１００'))
print(type(int('１００')))
# 100
# <class 'int'>

print(float('１００'))
print(type(float('１００')))
# 100.0
# <class 'float'>

જો કે, જો બાદબાકી અને દશાંશ અવધિ જેવા પ્રતીકો પૂર્ણ-પહોળાઈના અક્ષરો છે, તો મૂલ્ય ભૂલ જનરેટ થશે.

# print(float('ー１．２３'))
# ValueError: could not convert string to float: '１．２３'

સંખ્યાઓને સમસ્યા વિના રૂપાંતરિત કરી શકાય છે જો તે પૂર્ણ-પહોળાઈના અક્ષરો હોય, પરંતુ બાદબાકી અને દશાંશ બિંદુઓ અડધા-પહોળાઈના અક્ષરો હોય. રિપ્લેસ() પદ્ધતિનો ઉપયોગ કરીને પૂર્ણ-પહોળાઈના પ્રતીકોને અડધા-પહોળાઈના પ્રતીકો સાથે બદલીને રૂપાંતરણ શક્ય છે.

print(float('-１.２３'))
# -1.23

print(float('ー１．２３'.replace('ー', '-').replace('．', '.')))
# -1.23

ચાઇનીઝ અક્ષરોની સ્ટ્રિંગને સંખ્યામાં કન્વર્ટ કરો

યુનિકોડડેટા મોડ્યુલમાં unicodedata.numeric() ફંક્શનનો ઉપયોગ એક યુનિકોડ ચાઇનીઝ અક્ષરને ફ્લોટિંગ-પોઇન્ટ નંબર ટાઇપ નંબરમાં કન્વર્ટ કરવા માટે કરી શકાય છે.

જો તે એક અક્ષર નથી, તો ભૂલ થશે. ઉપરાંત, બિન-સંખ્યાત્મક અક્ષરો ભૂલનું કારણ બનશે.

import unicodedata

print(unicodedata.numeric('五'))
print(type(unicodedata.numeric('五')))
# 5.0
# <class 'float'>

print(unicodedata.numeric('十'))
# 10.0

print(unicodedata.numeric('参'))
# 3.0

print(unicodedata.numeric('億'))
# 100000000.0

# print(unicodedata.numeric('五十'))
# TypeError: numeric() argument 1 must be a unicode character, not str

# print(unicodedata.numeric('漢'))
# ValueError: not a numeric character