પાયથોન બીટવાઇઝ ઓપરેટર્સ (લોજિકલ પ્રોડક્ટ, લોજિકલ અથવા, એક્સક્લુઝિવ અથવા, વ્યુત્ક્રમ, શિફ્ટ)

પાયથોન નીચેના બીટવાઇઝ ઓપરેટરો પૂરા પાડે છે, જે અનુક્રમે દ્વિસંગી પૂર્ણાંક પ્રકાર ઇન્ટ વેલ્યુના દરેક બીટ પર લોજિકલ જોડાણ, લોજિકલ ડિસજંક્શન, એક્સક્લુઝિવ ડિસજંક્શન, બીટવાઇઝ ઇન્વર્ઝન, લેફ્ટ બીટ શિફ્ટ અને જમણું બીટ શિફ્ટ કરે છે.

• &
• |
• ^
• ~
• <<
• >>

આ વિભાગમાં, અમે પ્રથમ નીચેની બાબતો સમજાવીએ છીએ.

• આંતરછેદ(AND) :&
• વિભાજન(OR) :|
• એક્સક્લુઝિવ-અથવા ઓપરેશન(XOR) :^

આગળ, આપણે નીચેની ચર્ચા કરીશું.

• નકારાત્મક પૂર્ણાંકો પર બિટવાઇઝ કામગીરી
• બીટ ફ્લિપ( NOT) :~
• બીટ શિફ્ટ:<<,>>

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

• bin()
• oct()
• hex()
• format()

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

ઉપરાંત, બીટવાઇઝ કામગીરીને બદલે બુલિયન મૂલ્યો (સાચા, ખોટા) પર લોજિકલ ઓપરેશન્સ (બુલિયન ઓપરેશન્સ) માટે, નીચેના લેખનો સંદર્ભ લો. &,| ને બદલે અને,અથવા ઉપયોગ કરો.

• સંબંધિત લેખો:પાયથોનના લોજિકલ ઓપરેટર્સ અને, અથવા, અને નહીં (લોજિકલ જોડાણ, વિભાજન, નકાર)

આંતરછેદ(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 ના દરેક બીટ માટે ઇનપુટ અને આઉટપુટ વચ્ચેનો સંબંધ નીચેના કોષ્ટકમાં બતાવવામાં આવ્યો છે.

નકારાત્મક પૂર્ણાંકો પર બિટવાઇઝ કામગીરી

જ્યારે ઋણ પૂર્ણાંક પર બીટવાઇઝ ઑપરેશન કરવામાં આવે છે, ત્યારે મૂલ્ય પર પ્રક્રિયા કરવામાં આવે છે જાણે કે તે બેના પૂરક સ્વરૂપમાં વ્યક્ત કરવામાં આવી હોય.

• Two’s complement – Wikipedia

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

જો તમે બેના પૂરક પ્રતિનિધિત્વ સાથે સ્ટ્રિંગ મેળવવા માંગતા હો, તો નીચે બતાવ્યા પ્રમાણે, જરૂરી બીટ અંકોની મહત્તમ સંખ્યા સાથે 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)

• 6.6. Unary arithmetic and bitwise operation — Expressions — Python 3.10.1 Documentation

-(x+1)આ મૂલ્ય ઇનપુટ મૂલ્ય x ને બેના પૂરક સ્વરૂપ તરીકે ધ્યાનમાં લેવા અને તમામ બિટ્સને ઉલટાવી દેવાની સમકક્ષ છે.

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

x = 9  # 0b1001

print(~x)
print(bin(~x))
# -10
# -0b1010

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

વધુમાં, ઉદાહરણ તરીકે, બીટ સ્ટ્રિંગ મેળવવા માટે જે 4-અંકની બિટ સ્ટ્રિંગ છે જે ઊંધી છે (સાઇન બીટ અવગણવામાં આવી છે), નીચે પ્રમાણે ANDed મૂલ્ય માટે શૂન્ય ભરવા માટે format() નો ઉપયોગ કરો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

નકારાત્મક મૂલ્યો માટે, સાઇન બીટ વિસ્તૃત અને સ્થાનાંતરિત થાય છે, અને હકારાત્મક/નકારાત્મક ચિહ્ન સમાન રહે છે. નેગેટિવ વેલ્યુ એ બધી રીતે ડાબી તરફ 1 સે ની રેખાની છબી છે.

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

બેના પૂરક અભિવ્યક્તિઓના શબ્દમાળાઓના સંદર્ભમાં વિચારવું વધુ સારું છે, કારણ કે સંખ્યાઓની દ્રષ્ટિએ વિચારવું સ્પષ્ટ નથી.