ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਗਰੀ, ਨਮੂਨਾ ਕੋਡ ਦੇ ਨਾਲ, ਪਾਇਥਨ ਵਿੱਚ ਸਤਰ (str) ਦੀਆਂ ਸੂਚੀਆਂ (ਐਰੇ) ਅਤੇ ਨੰਬਰਾਂ ਦੀਆਂ ਸੂਚੀਆਂ (ਇੰਟ, ਫਲੋਟ) ਨੂੰ ਇੱਕ ਦੂਜੇ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ, ਬਾਰੇ ਦੱਸਦਾ ਹੈ।
- ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਸਤਰ ਦੀ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ
- ਕਿਸੇ ਸੰਖਿਆ ਨੂੰ ਦਸ਼ਮਲਵ ਸਤਰ ਵਿੱਚ ਬਦਲੋ
- ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ
- ਘਾਤਕ ਸੰਕੇਤ ਵਿੱਚ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ
- ਤਾਰਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ
- ਦਸ਼ਮਲਵ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸੰਖਿਆਤਮਕ ਵਿੱਚ ਬਦਲੋ
- ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ
- ਘਾਤਕ ਸੰਕੇਤ ਵਿੱਚ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ
- ਸਿਰਫ਼ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਹੀ ਬਦਲੋ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ
ਜਦੋਂ ਇੱਕ ਸੂਚੀ ਤੋਂ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਲੂਪਸ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਲਿਖਣ ਲਈ ਆਸਾਨ ਹੁੰਦੀ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ ਨਮੂਨਾ ਕੋਡ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰਦਾ ਹੈ। ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਵੇਰਵਿਆਂ ਲਈ, ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
ਨੋਟ ਕਰੋ ਕਿ ਸੂਚੀਆਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਐਰੇ ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹਨ। ਹੇਠਾਂ ਦਿੱਤੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਐਰੇ (ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ) ਜਾਂ 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()
ਫਾਰਮੈਟ() ਫੰਕਸ਼ਨ ਅਤੇ ਸਟ੍ਰਿੰਗ ਵਿਧੀ str.format() ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਮੈਨਟੀਸਾ ਭਾਗ ਦੇ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਜੇਕਰ ਇੱਕ ਵੱਡੇ ਅੱਖਰ 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- octal
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() ਵਿੱਚ ਇੱਕ ਸੰਖਿਆ ਵਿੱਚ ਤਬਦੀਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ValueError ਹੋਵੇਗਾ।
ਜੇਕਰ ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਗਲਤੀ ‘ਤੇ ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਤਾਂ ਸਿਰਫ ਉਹ ਤੱਤ ਜੋ ਬਦਲੇ ਜਾ ਸਕਦੇ ਹਨ, ਨੂੰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਸੂਚੀ ਦੇ ਤੱਤ ਬਣ ਸਕਦੇ ਹਨ।
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]