ਪਾਈਥਨ ਹੇਠਾਂ ਦਿੱਤੇ ਬਿੱਟਵਾਈਜ਼ ਓਪਰੇਟਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਕ੍ਰਮਵਾਰ ਬਾਈਨਰੀ ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਦੇ ਇੰਟ ਵੈਲਯੂ ਦੇ ਹਰੇਕ ਬਿੱਟ ‘ਤੇ ਲਾਜ਼ੀਕਲ ਜੋੜ, ਲਾਜ਼ੀਕਲ ਡਿਸਜੰਕਸ਼ਨ, ਐਕਸਕਲੂਸਿਵ ਡਿਸਜੰਕਸ਼ਨ, ਬਿਟਵਾਈਸ ਇਨਵਰਸ਼ਨ, ਖੱਬੇ ਬਿੱਟ ਸ਼ਿਫਟ ਅਤੇ ਸੱਜਾ ਬਿੱਟ ਸ਼ਿਫਟ ਕਰਦੇ ਹਨ।
&|^~<<>>
ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੇਠਾਂ ਦਿੱਤੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹਾਂ।
- ਚੌਰਾਹੇ(AND) :
& - ਵਿਛੋੜਾ(OR) :
| - ਵਿਸ਼ੇਸ਼-ਜਾਂ ਓਪਰੇਸ਼ਨ(XOR) :
^
ਅੱਗੇ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਬਾਰੇ ਚਰਚਾ ਕਰਾਂਗੇ.
- ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕਾਂ ‘ਤੇ ਬਿੱਟਵਾਈਜ਼ ਓਪਰੇਸ਼ਨ
- ਬਿੱਟ ਫਲਿੱਪ( NOT) :
~ - ਬਿੱਟ ਸ਼ਿਫਟ:
<<,>>
ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਵਿੱਚ ਪੂਰਨ ਅੰਕ ਕਿਵੇਂ ਲਿਖਣੇ ਹਨ, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰਾਂ ਅਤੇ ਸਤਰਾਂ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ, ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
bin()oct()hex()format()
ਨਾਲ ਹੀ, ਬਿੱਟਵਾਈਜ਼ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਬਜਾਏ ਬੂਲੀਅਨ ਮੁੱਲਾਂ (ਸੱਚ, ਗਲਤ) ‘ਤੇ ਲਾਜ਼ੀਕਲ ਓਪਰੇਸ਼ਨਾਂ (ਬੂਲੀਅਨ ਓਪਰੇਸ਼ਨਾਂ) ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਲੇਖ ਨੂੰ ਵੇਖੋ। ਅਤੇ, ਜਾਂ &,| ਦੀ ਬਜਾਏ ਵਰਤੋ।
ਚੌਰਾਹੇ(AND) :&ਆਪਰੇਟਰ
ਇਹ ਇੱਕ ਲਾਜ਼ੀਕਲ AND ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ & ਓਪਰੇਟਰ, ਨਤੀਜਾ bin() ਦੁਆਰਾ ਬਾਈਨਰੀ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।
x = 9 # 0b1001 y = 10 # 0b1010 print(x & y) print(bin(x & y)) # 8 # 0b1000
ਵਿਛੋੜਾ(OR) :|ਆਪਰੇਟਰ
| ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਲਾਜ਼ੀਕਲ ਉਤਪਾਦ (OR) ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਆਪਰੇਟਰ, ਨਤੀਜੇ ਨੂੰ bin() ਅਤੇ ਆਉਟਪੁੱਟ ਦੁਆਰਾ ਬਾਈਨਰੀ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।
print(x | y) print(bin(x | y)) # 11 # 0b1011
ਵਿਸ਼ੇਸ਼-ਜਾਂ ਓਪਰੇਸ਼ਨ(XOR) :^ਆਪਰੇਟਰ
^ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਲਾਜ਼ੀਕਲ ਉਤਪਾਦ (XOR) ਦੀ ਉਦਾਹਰਨ, bin() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਾਈਨਰੀ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਤਰ ਵਿੱਚ ਪਰਿਵਰਤਨ ਦੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ।
print(x ^ y) print(bin(x ^ y)) # 3 # 0b11
ਲਾਜ਼ੀਕਲ AND, OR, ਅਤੇ XOR ਦੇ ਹਰੇਕ ਬਿੱਟ ਲਈ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਵਿਚਕਾਰ ਸਬੰਧ ਹੇਠਾਂ ਦਿੱਤੀ ਸਾਰਣੀ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
| ਇਨਪੁਟ 1 | ਇਨਪੁਟ 2 | ਚੌਰਾਹੇ(AND) | ਵਿਛੋੜਾ(OR) | ਵਿਸ਼ੇਸ਼-ਜਾਂ ਓਪਰੇਸ਼ਨ(XOR) |
|---|---|---|---|---|
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
| 0 | 1 | 0 | 1 | 1 |
| 0 | 0 | 0 | 0 | 0 |
ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕਾਂ ‘ਤੇ ਬਿੱਟਵਾਈਜ਼ ਓਪਰੇਸ਼ਨ
ਜਦੋਂ ਇੱਕ ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ‘ਤੇ ਇੱਕ ਬਿੱਟਵਾਈਜ਼ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੁੱਲ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਸਨੂੰ ਦੋ ਦੇ ਪੂਰਕ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ।
ਨੋਟ ਕਰੋ, ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ bin() ਜਾਂ ਫਾਰਮੈਟ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਨੈਗੇਟਿਵ ਪੂਰਨ ਅੰਕ ਨੂੰ ਬਾਈਨਰੀ ਸਤਰ ਵਿੱਚ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਪੂਰਨ ਮੁੱਲ ਵਿੱਚ ਦੋ ਦੇ ਪੂਰਕ ਫਾਰਮੈਟ ਦੀ ਬਜਾਏ ਇੱਕ ਘਟਾਓ ਚਿੰਨ੍ਹ ਹੋਵੇਗਾ।
ਜੇਕਰ ਤੁਸੀਂ ਦੋ ਦੀ ਪੂਰਕ ਪ੍ਰਤੀਨਿਧਤਾ ਵਾਲੀ ਇੱਕ ਸਤਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ AND ਨੂੰ ਲੋੜੀਂਦੇ ਬਿੱਟ ਅੰਕਾਂ ਦੀ ਅਧਿਕਤਮ ਸੰਖਿਆ ਦੇ ਨਾਲ ਲਓ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
- 4-ਬਿੱਟ ਲਈ
0b1111(=0xf) - 8-ਬਿੱਟ ਲਈ
0xff - 16-ਬਿੱਟ ਲਈ
0xffff
ਤੁਸੀਂ ਦੋ ਦੇ ਪੂਰਕ ਪ੍ਰਤੀਨਿਧਤਾ ਦੀ ਇੱਕ ਸਤਰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ (ਹਰੇਕ ਬਿੱਟ ਉਲਟਾ ਹੈ ਅਤੇ 1 ਜੋੜਿਆ ਗਿਆ ਹੈ)।
x = -9 print(x) print(bin(x)) # -9 # -0b1001 print(bin(x & 0xff)) print(format(x & 0xffff, 'x')) # 0b11110111 # fff7
ਬਿੱਟ ਫਲਿੱਪ:~ਆਪਰੇਟਰ
~ ਆਪਰੇਟਰਾਂ ਨਾਲ ਬਿੱਟ ਫਲਿੱਪਿੰਗ ਦੀ ਉਦਾਹਰਨ।
ਬਿੱਟਵਾਈਜ਼ ਇਨਵਰਸ਼ਨ ਸਿਰਫ਼ ਹਰੇਕ ਬਿੱਟ ਉਲਟਾ ਦਾ ਮੁੱਲ ਨਹੀਂ ਹੈ। ਇਸ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਵਾਪਸੀ ਦਾ ਮੁੱਲ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ।~x#ERROR!-(x+1)
-(x+1)ਇਹ ਮੁੱਲ ਇੰਪੁੱਟ ਮੁੱਲ x ਨੂੰ ਦੋ ਦੇ ਪੂਰਕ ਰੂਪ ਵਜੋਂ ਵਿਚਾਰਨ ਅਤੇ ਸਾਰੇ ਬਿੱਟਾਂ ਨੂੰ ਉਲਟਾਉਣ ਦੇ ਬਰਾਬਰ ਹੈ।
ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਪਾਈਥਨ ਵਿੱਚ, ਜਦੋਂ ਇੱਕ ਨੈਗੇਟਿਵ ਪੂਰਨ ਅੰਕ ਨੂੰ bin(), ਫਾਰਮੈਟ(), ਆਦਿ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਬਾਈਨਰੀ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਦੋ ਦੇ ਪੂਰਕ ਰੂਪ ਵਿੱਚ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਪਰ ਇੱਕ ਘਟਾਓ ਚਿੰਨ੍ਹ ਦੇ ਨਾਲ ਪੂਰਨ ਮੁੱਲ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਇਸਲਈ, ~x ਨੂੰ ਸਿੱਧੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਮੂਲ ਮੁੱਲ ਦੇ ਬਿੱਟਾਂ ਨੂੰ ਉਲਟਾ ਕੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨਹੀਂ ਮਿਲੇਗੀ।
x = 9 # 0b1001 print(~x) print(bin(~x)) # -10 # -0b1010
ਜਦੋਂ ਅਸੀਂ AND ਸੰਚਾਲਨ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਦੋ ਦੇ ਪੂਰਕ ਪ੍ਰਤੀਨਿਧਤਾ ਦੀ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਮੂਲ ਮੁੱਲ ਦੇ ਬਿੱਟ ਉਲਟੇ ਹੋਏ ਹਨ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਬਿੱਟ ਸਟ੍ਰਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਜੋ 4-ਅੰਕ ਵਾਲੀ ਬਿੱਟ ਸਟ੍ਰਿੰਗ ਉਲਟੀ ਹੈ (ਚਿੰਨ੍ਹ ਬਿੱਟ ਛੱਡੀ ਗਈ ਹੈ), ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ANDed ਮੁੱਲ ਲਈ ਜ਼ੀਰੋ ਭਰਨ ਲਈ ਫਾਰਮੈਟ() ਦੀ ਵਰਤੋਂ ਕਰੋ04b'
print(bin(~x & 0xff)) print(format(~x & 0b1111, '04b')) # 0b11110110 # 0110
ਬਿੱਟ ਸ਼ਿਫਟ:<<,>>
ਬਿੱਟ ਸ਼ਿਫਟ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਖੱਬੀ ਬਿੱਟ ਸ਼ਿਫਟ ਅਤੇ ਸੱਜੇ ਬਿੱਟ ਸ਼ਿਫਟ ਦੀਆਂ ਉਦਾਹਰਨਾਂ।
x = 9 # 0b1001 print(x << 1) print(bin(x << 1)) # 18 # 0b10010 print(x >> 1) print(bin(x >> 1)) # 4 # 0b100
ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਲਈ, ਚਿੰਨ੍ਹ ਬਿੱਟ ਨੂੰ ਵਧਾਇਆ ਅਤੇ ਸ਼ਿਫਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਕਾਰਾਤਮਕ/ਨਕਾਰਾਤਮਕ ਚਿੰਨ੍ਹ ਇੱਕੋ ਜਿਹਾ ਰਹਿੰਦਾ ਹੈ। ਇੱਕ ਨਕਾਰਾਤਮਕ ਮੁੱਲ ਖੱਬੇ ਪਾਸੇ 1s ਦੀ ਇੱਕ ਲਾਈਨ ਦਾ ਚਿੱਤਰ ਹੁੰਦਾ ਹੈ।
x = -9 print(bin(x)) print(bin(x & 0xff)) # -0b1001 # 0b11110111 print(x << 1) print(bin(x << 1)) print(bin((x << 1) & 0xff)) # -18 # -0b10010 # 0b11101110 print(x >> 1) print(bin(x >> 1)) print(bin((x >> 1) & 0xff)) # -5 # -0b101 # 0b11111011
ਦੋ ਦੇ ਪੂਰਕ ਸਮੀਕਰਨਾਂ ਦੀਆਂ ਤਾਰਾਂ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਸੋਚਣਾ ਬਿਹਤਰ ਹੈ, ਕਿਉਂਕਿ ਸੰਖਿਆਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸੋਚਣਾ ਸਪਸ਼ਟ ਨਹੀਂ ਹੈ।
