પાયથોનમાં દ્વિસંગી, અષ્ટાદિક અને હેક્સાડેસિમલ નંબરો અને સ્ટ્રિંગ્સને એકબીજામાં રૂપાંતરિત કરો

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

આ વિભાગમાં, નીચેની સામગ્રીઓ નમૂના કોડ સાથે સમજાવવામાં આવશે.

• પૂર્ણાંકોને બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલમાં લખો.
• સંખ્યાઓને દ્વિસંગી, ઓક્ટલ અને હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગમાં કન્વર્ટ કરો.
  • બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં)bin(),oct(),hex()
  • શબ્દમાળા પદ્ધતિstr.format(), બિલ્ટ-ઇન કાર્યોformat(), f શબ્દમાળા
  • બેના પૂરક ફોર્મેટમાં ઋણ પૂર્ણાંકને શબ્દમાળામાં કન્વર્ટ કરો.
• દ્વિસંગી, ઓક્ટલ અને હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગ્સને નંબરોમાં કન્વર્ટ કરો.
  • બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં)int()
• એપ્લિકેશન ઉદાહરણો
  • દ્વિસંગી શબ્દમાળા અંકગણિત
  • દ્વિસંગી, અષ્ટાકાર અને હેક્સાડેસિમલ સંખ્યાઓ વચ્ચે કન્વર્ટ કરો

પૂર્ણાંકોને બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલમાં લખો.

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

• દ્વિસંગી સંખ્યા:0bઅથવા0B
• ઓક્ટલ:0oઅથવા0O
• હેક્સાડેસિમલ સંખ્યા:0xઅથવા0X

પ્રિન્ટ() નું આઉટપુટ દશાંશ સંકેતમાં હશે.

bin_num = 0b10
oct_num = 0o10
hex_num = 0x10

print(bin_num)
print(oct_num)
print(hex_num)
# 2
# 8
# 16

Bin_num = 0B10
Oct_num = 0O10
Hex_num = 0X10

print(Bin_num)
print(Oct_num)
print(Hex_num)
# 2
# 8
# 16

ઉપસર્ગ સાથે પણ, પ્રકાર પૂર્ણાંક પૂર્ણાંક છે.

print(type(bin_num))
print(type(oct_num))
print(type(hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

print(type(Bin_num))
print(type(Oct_num))
print(type(Hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

તે પૂર્ણાંક પ્રકાર હોવાથી, તેનો નિયમિત અંકગણિત કામગીરી માટે ઉપયોગ કરી શકાય છે.

result = 0b10 * 0o10 + 0x10
print(result)
# 32

Python 3.6 થી શરૂ કરીને, સંખ્યાઓમાં અન્ડરસ્કોર્સ _ દાખલ કરવાનું શક્ય છે. અંડરસ્કોર _ ને પુનરાવર્તિત કરવાથી ભૂલ થશે, પરંતુ જ્યાં સુધી તમે તેને પુનરાવર્તન ન કરો ત્યાં સુધી તમે ગમે તેટલા દાખલ કરી શકો છો.

_ અન્ડરસ્કોર સંખ્યાને અસર કરતું નથી, તેથી જ્યારે ઘણા અંકો હોય ત્યારે તેનો વિભાજક તરીકે ઉપયોગ કરી શકાય છે. ઉદાહરણ તરીકે, દર ચાર અંકોમાં અંડરસ્કોર _ દાખલ કરવું વાંચવામાં સરળ છે.

print(0b111111111111 == 0b1_1_1_1_1_1_1_1_1_1_1_1)
# True

bin_num = 0b1111_1111_1111
print(bin_num)
# 4095

સંખ્યાઓને દ્વિસંગી, ઓક્ટલ અને હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગમાં કન્વર્ટ કરો.

સંખ્યાને દ્વિસંગી, ઓક્ટલ અથવા હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગમાં કન્વર્ટ કરવા માટે, નીચેના બિલ્ટ-ઇન ફંક્શનનો ઉપયોગ કરો.

• બિલ્ટ-ઇન ફંક્શન (દા.ત. પ્રોગ્રામિંગ ભાષામાં)bin(),oct(),hex()
• શબ્દમાળા પદ્ધતિstr.format(), બિલ્ટ-ઇન કાર્યોformat(), f શબ્દમાળા

આ વિભાગ એ પણ સમજાવે છે કે નકારાત્મક મૂલ્યો માટે બેના પૂરક ફોર્મેટમાં વ્યક્ત કરેલી સ્ટ્રિંગ કેવી રીતે મેળવવી.

બિલ્ટ-ઇન ફંક્શન્સ બિન(), ઓક્ટો(), હેક્સ()

નીચેના બિલ્ટ-ઇન ફંક્શન નંબરોને બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલ સ્ટ્રિંગમાં કન્વર્ટ કરી શકે છે.

• દ્વિસંગી સંખ્યા:bin()
• ઓક્ટલ:oct()
• હેક્સાડેસિમલ સંખ્યા:hex()

દરેક નીચેના ઉપસર્ગો સાથે એક સ્ટ્રિંગ પરત કરે છે

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

• bin() — Built-in Functions — Python 3.10.0 Documentation
• oct() — Built-in Functions — Python 3.10.0 Documentation
• hex() — Built-in Functions — Python 3.10.0 Documentation

i = 255

print(bin(i))
print(oct(i))
print(hex(i))
# 0b11111111
# 0o377
# 0xff

print(type(bin(i)))
print(type(oct(i)))
print(type(hex(i)))
# <class 'str'>
# <class 'str'>
# <class 'str'>

જો તમને ઉપસર્ગની જરૂર ન હોય, તો તેની પાછળની સ્ટ્રિંગ કાઢવા માટે સ્લાઇસ[2:] નો ઉપયોગ કરો અથવા આગળ સમજાવ્યા મુજબ ફોર્મેટ() નો ઉપયોગ કરો.

print(bin(i)[2:])
print(oct(i)[2:])
print(hex(i)[2:])
# 11111111
# 377
# ff

જો તમે તેને દશાંશ શબ્દમાળામાં રૂપાંતરિત કરવા માંગો છો, તો તમે str() નો ઉપયોગ કરી શકો છો.

• str() — Built-in Functions — Python 3.10.0 Documentation

print(str(i))
# 255

print(type(str(i)))
# <class 'str'>

બિલ્ટ-ઇન ફંક્શન ફોર્મેટ(), સ્ટ્રિંગ મેથડ str.format(), f સ્ટ્રિંગ

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

• format() — Built-in Functions — Python 3.10.0 Documentation

નીચે પ્રમાણે ફોર્મેટ() ની બીજી દલીલ સ્પષ્ટ કરીને, તેને અનુક્રમે બાઈનરી, ઓક્ટલ અને હેક્સાડેસિમલ સ્ટ્રિંગ્સમાં રૂપાંતરિત કરી શકાય છે.

• દ્વિસંગી સંખ્યા:b
• ઓક્ટલ:o
• હેક્સાડેસિમલ સંખ્યા:x

print(format(i, 'b'))
print(format(i, 'o'))
print(format(i, 'x'))
# 11111111
# 377
# ff

print(type(format(i, 'b')))
print(type(format(i, 'o')))
print(type(format(i, 'x')))
# <class 'str'>
# <class 'str'>
# <class 'str'>

જો તમે ઉપસર્ગ 0b,0o,0x સાથે સ્ટ્રિંગ મેળવવા માંગો છો, તો ફોર્મેટિંગ સ્પષ્ટીકરણ સ્ટ્રિંગમાં # ઉમેરો.

print(format(i, '#b'))
print(format(i, '#o'))
print(format(i, '#x'))
# 0b11111111
# 0o377
# 0xff

કોઈપણ સંખ્યાના અંકો સાથે 0 ભરવું પણ શક્ય છે. નોંધ કરો કે ઉપસર્ગ સાથે શૂન્ય ભરતી વખતે ઉપસર્ગ (બે અક્ષરો) માટે અક્ષરોની સંખ્યા પણ ધ્યાનમાં લેવી આવશ્યક છે.

print(format(i, '08b'))
print(format(i, '08o'))
print(format(i, '08x'))
# 11111111
# 00000377
# 000000ff

print(format(i, '#010b'))
print(format(i, '#010o'))
print(format(i, '#010x'))
# 0b11111111
# 0o00000377
# 0x000000ff

સ્ટ્રિંગ પદ્ધતિ str.format() રૂપાંતરણ માટે પણ વાપરી શકાય છે.

• str.format() — Built-in Functions — Python 3.10.0 Documentation

print('{:08b}'.format(i))
print('{:08o}'.format(i))
print('{:08x}'.format(i))
# 11111111
# 00000377
# 000000ff

Python 3.6 થી શરૂ કરીને, તમે f સ્ટ્રિંગનો પણ ઉપયોગ કરી શકો છો.f'xxx'

print(f'{i:08b}')
print(f'{i:08o}')
print(f'{i:08x}')
# 11111111
# 00000377
# 000000ff

બેના પૂરક ફોર્મેટમાં ઋણ પૂર્ણાંકને શબ્દમાળામાં કન્વર્ટ કરો.

જ્યારે bin() અથવા format() નો ઉપયોગ કરીને નકારાત્મક પૂર્ણાંકને દ્વિસંગી અથવા હેક્સાડેસિમલ સ્ટ્રિંગમાં રૂપાંતરિત કરવામાં આવે છે, ત્યારે સંપૂર્ણ મૂલ્યમાં માઈનસ ચિહ્ન હશે.

x = -9

print(x)
print(bin(x))
# -9
# -0b1001

પાયથોનમાં, નકારાત્મક પૂર્ણાંકો પર બીટવાઇઝ કામગીરી પણ બેના પૂરક રજૂઆતમાં કરવામાં આવે છે. તેથી, જો તમે બેના પૂરક સ્વરૂપમાં વ્યક્ત થયેલ સ્ટ્રિંગ મેળવવા માંગતા હો, તો તમે બીટવાઇઝ લોજિકલ OR& જરૂરી બીટ અંકોની મહત્તમ સંખ્યા સાથે, નીચે પ્રમાણે.

• 4bit:0b1111（=0xf）
• 8bit:0xff
• 16bit:0xffff

print(bin(x & 0xff))
print(format(x & 0xffff, 'x'))
# 0b11110111
# fff7

દ્વિસંગી, ઓક્ટલ અને હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગ્સને નંબરોમાં કન્વર્ટ કરો.

બિલ્ટ-ઇન ફંક્શન int()

દ્વિસંગી, ઓક્ટલ અથવા હેક્સાડેસિમલ નોટેશનમાં સ્ટ્રિંગને નંબરમાં કન્વર્ટ કરવા માટે, બિલ્ટ-ઇન ફંક્શન int() નો ઉપયોગ કરો.

• int() — Built-in Functions — Python 3.10.0 Documentation

int(string, radix) સાથે, દ્વિસંગી, ઓક્ટલ, હેક્સાડેસિમલ નોટેશન વગેરેમાં એક સ્ટ્રિંગ સ્ટ્રિંગને રેડિક્સના આધારે ન્યુમેરિક intમાં રૂપાંતરિત કરી શકાય છે. જો મૂલાંકને છોડી દેવામાં આવે તો, સંખ્યાને દશાંશ ગણવામાં આવે છે.

print(int('10'))
print(int('10', 2))
print(int('10', 8))
print(int('10', 16))
# 10
# 2
# 8
# 16

print(type(int('10')))
print(type(int('10', 2)))
print(type(int('10', 8)))
print(type(int('10', 16)))
# <class 'int'>
# <class 'int'>
# <class 'int'>
# <class 'int'>

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

• દ્વિસંગી ઉપસર્ગ:0bઅથવા0B
• ઓક્ટલ ઉપસર્ગ:0oઅથવા0O
• હેક્સાડેસિમલ ઉપસર્ગ:0xઅથવા0X

print(int('0b10', 0))
print(int('0o10', 0))
print(int('0x10', 0))
# 2
# 8
# 16

print(int('0B10', 0))
print(int('0O10', 0))
print(int('0X10', 0))
# 2
# 8
# 16

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

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

# print(int('010', 0))
# ValueError: invalid literal for int() with base 0: '010'

અન્ય કિસ્સાઓમાં, શૂન્ય-ભરેલા શબ્દમાળાઓ જેમ છે તેમ રૂપાંતરિત કરી શકાય છે.

print(int('010'))
# 10

print(int('00ff', 16))
print(int('0x00ff', 0))
# 255
# 255

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

# print(int('ff', 2))
# ValueError: invalid literal for int() with base 2: 'ff'

# print(int('0a10', 0))
# ValueError: invalid literal for int() with base 0: '0a10'

# print(int('0bff', 0))
# ValueError: invalid literal for int() with base 0: '0bff'

એપ્લિકેશન ઉદાહરણો

દ્વિસંગી શબ્દમાળા અંકગણિત

ઉદાહરણ તરીકે, ઉપસર્ગ 0b સાથે બાઈનરી નોટેશનમાં સ્ટ્રિંગ પર ઑપરેશન કરવા માટે.

તમે તેને સરળતાથી સંખ્યાત્મક મૂલ્ય (પૂર્ણાંક પ્રકાર int) માં રૂપાંતરિત કરી શકો છો, તેના પર કામગીરી કરી શકો છો, અને પછી તેને ફરીથી સ્ટ્રિંગ str માં કન્વર્ટ કરી શકો છો.

a = '0b1001'
b = '0b0011'

c = int(a, 0) + int(b, 0)

print(c)
print(bin(c))
# 12
# 0b1100

દ્વિસંગી, અષ્ટાકાર અને હેક્સાડેસિમલ સંખ્યાઓ વચ્ચે કન્વર્ટ કરો

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

ઝીરો-ફિલિંગ, પ્રિફિક્સિંગ વગેરેને ફોર્મેટિંગ સ્પષ્ટીકરણ સ્ટ્રિંગ દ્વારા નિયંત્રિત કરી શકાય છે.

a_0b = '0b1110001010011'

print(format(int(a, 0), '#010x'))
# 0x00000009

print(format(int(a, 0), '#010o'))
# 0o00000011