ਪਾਈਥਨ ਵਿੱਚ ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰਾਂ ਅਤੇ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਇੱਕ ਦੂਜੇ ਵਿੱਚ ਬਦਲੋ

ਪਾਈਥਨ ਨੰਬਰਾਂ ਅਤੇ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਔਕਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਆਮ ਦਸ਼ਮਲਵ ਸੰਖਿਆਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈਂਡਲ ਕਰ ਸਕਦਾ ਹੈ। ਉਹਨਾਂ ਵਿਚਕਾਰ ਪਰਿਵਰਤਨ ਕਰਨਾ ਵੀ ਆਸਾਨ ਹੈ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਨਮੂਨਾ ਕੋਡ ਦੇ ਨਾਲ ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਗਰੀ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾਵੇਗੀ।

• ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਅਸ਼ਟਲ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਵਿੱਚ ਲਿਖੋ।
• ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸੰਕੇਤਾਂ ਵਿੱਚ ਸੰਖਿਆਵਾਂ ਨੂੰ ਸਤਰ ਵਿੱਚ ਬਦਲੋ।
  • ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ)bin(),oct(),hex()
  • ਸਤਰ ਢੰਗstr.format(), ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨformat(), f ਸਤਰ
  • ਇੱਕ ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨੂੰ ਦੋ ਦੇ ਪੂਰਕ ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲੋ।
• ਬਾਈਨਰੀ, ਔਕਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸੰਕੇਤਾਂ ਵਿੱਚ ਸਤਰ ਨੂੰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲੋ।
  • ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ)int()
• ਐਪਲੀਕੇਸ਼ਨ ਉਦਾਹਰਨਾਂ
  • ਬਾਈਨਰੀ ਸਤਰ ਅੰਕਗਣਿਤ
  • ਬਾਈਨਰੀ, ਅਸ਼ਟਲ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲੋ

ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਅਸ਼ਟਲ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਵਿੱਚ ਲਿਖੋ।

ਹੇਠਾਂ ਦਿੱਤੇ ਅਗੇਤਰਾਂ ਨੂੰ ਜੋੜ ਕੇ, ਪੂਰਨ ਅੰਕ ਇੰਟ ਨੰਬਰਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਬਾਈਨਰੀ, ਔਕਟਲ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਤੁਸੀਂ ਵੱਡੇ ਅੱਖਰ ਵੀ ਵਰਤ ਸਕਦੇ ਹੋ।

• ਬਾਈਨਰੀ ਨੰਬਰ:0bਜਾਂ0B
• ਅਸ਼ਟਾਲ:0oਜਾਂ0O
• ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰ:0xਜਾਂ0X

print() ਦਾ ਆਉਟਪੁੱਟ ਦਸ਼ਮਲਵ ਸੰਕੇਤ ਵਿੱਚ ਹੋਵੇਗਾ।

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

ਪਾਈਥਨ 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()

ਹੇਠਾਂ ਦਿੱਤੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਨੰਬਰਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਔਕਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸਤਰ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹਨ।

• ਬਾਈਨਰੀ ਨੰਬਰ: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

ਪਾਈਥਨ 3.6 ਨਾਲ ਸ਼ੁਰੂ ਕਰਕੇ, ਤੁਸੀਂ f ਸਤਰ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।f'xxx'

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

ਇੱਕ ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨੂੰ ਦੋ ਦੇ ਪੂਰਕ ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲੋ।

ਜਦੋਂ ਇੱਕ ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨੂੰ bin() ਜਾਂ ਫਾਰਮੈਟ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਬਾਈਨਰੀ ਜਾਂ ਹੈਕਸਾਡੈਸੀਮਲ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪੂਰਨ ਮੁੱਲ ਵਿੱਚ ਇੱਕ ਘਟਾਓ ਚਿੰਨ੍ਹ ਹੋਵੇਗਾ।

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(ਸਟ੍ਰਿੰਗ, ਰੇਡੀਕਸ) ਦੇ ਨਾਲ, ਬਾਈਨਰੀ, ਔਕਟਲ, ਹੈਕਸਾਡੈਸੀਮਲ ਨੋਟੇਸ਼ਨ, ਆਦਿ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਿੰਗ ਸਟ੍ਰਿੰਗ ਨੂੰ ਰੇਡੀਕਸ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਸੰਖਿਆਤਮਕ ਇੰਟ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਰੇਡੀਕਸ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸੰਖਿਆ ਨੂੰ ਦਸ਼ਮਲਵ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

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 ਦੇ ਨਾਲ ਬਾਈਨਰੀ ਸੰਕੇਤ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਿੰਗ ‘ਤੇ ਇੱਕ ਕਾਰਵਾਈ ਕਰਨ ਲਈ।

ਤੁਸੀਂ ਇਸਨੂੰ ਆਸਾਨੀ ਨਾਲ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ (ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਇੰਟ) ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ, ਇਸ ‘ਤੇ ਓਪਰੇਸ਼ਨ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਦੁਬਾਰਾ ਇੱਕ ਸਟ੍ਰਿੰਗ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।

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