పైథాన్ కింది బిట్‌వైస్ ఆపరేటర్లను అందిస్తుంది, ఇవి వరుసగా బైనరీ పూర్ణాంకాల పూర్ణాంక విలువ యొక్క ప్రతి బిట్‌పై లాజికల్ సంయోగం, లాజికల్ డిస్జంక్షన్, ఎక్స్‌క్లూజివ్ డిస్జంక్షన్, బిట్‌వైస్ ఇన్వర్షన్, లెఫ్ట్ బిట్ షిఫ్ట్ మరియు రైట్ బిట్ షిఫ్ట్‌లను నిర్వహిస్తాయి.
&|^~<<>>
ఈ విభాగంలో, మేము మొదట ఈ క్రింది వాటిని వివరిస్తాము.
- కూడలి(AND) :
& - విభజన(OR) :
| - ఎక్స్‌క్లూజివ్-లేదా ఆపరేషన్(XOR) :
^
తరువాత, మేము ఈ క్రింది వాటిని చర్చిస్తాము.
- ప్రతికూల పూర్ణాంకాలపై బిట్‌వైస్ కార్యకలాపాలు
- బిట్ ఫ్లిప్( NOT) :
~ - బిట్ షిఫ్ట్:
<<,>>
బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్‌లలో పూర్ణాంకాలను ఎలా వ్రాయాలి మరియు క్రింది ఫంక్షన్‌లను ఉపయోగించి బైనరీ, అష్టాంశ మరియు హెక్సాడెసిమల్ సంఖ్యలు మరియు స్ట్రింగ్‌లను ఎలా మార్చాలి అనే దాని గురించి మరింత సమాచారం కోసం, క్రింది కథనాన్ని చూడండి.
bin()oct()hex()format()
- సంబంధిత కథనాలు:పైథాన్‌లో బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ నంబర్‌లు మరియు స్ట్రింగ్‌లను ఒకదానికొకటి మార్చండి
అలాగే, బిట్‌వైస్ ఆపరేషన్‌లకు బదులుగా బూలియన్ విలువలపై (ఒప్పు, తప్పు) లాజికల్ ఆపరేషన్‌ల కోసం (బూలియన్ ఆపరేషన్‌లు), కింది కథనాన్ని చూడండి. &,|కి బదులుగా ఉపయోగించండి మరియు, లేదా.
- సంబంధిత కథనాలు:పైథాన్ యొక్క లాజికల్ ఆపరేటర్లు మరియు, లేదా, మరియు కాదు (లాజికల్ సంయోగం, డిస్జంక్షన్, నెగేషన్)
కూడలి(AND) :&ఆపరేటర్
ఇది తార్కిక మరియు & ఆపరేటర్, ఫలితంగా బిన్() ద్వారా బైనరీ సంజ్ఞామానంలో స్ట్రింగ్‌గా మార్చబడుతుంది.
x = 9 # 0b1001 y = 10 # 0b1010 print(x & y) print(bin(x & y)) # 8 # 0b1000
విభజన(OR) :|ఆపరేటర్
| ఉపయోగించి తార్కిక ఉత్పత్తి (OR) యొక్క ఉదాహరణ ఆపరేటర్, ఫలితంగా బిన్() మరియు అవుట్‌పుట్ ద్వారా బైనరీ సంజ్ఞామానంలో స్ట్రింగ్‌గా మార్చబడుతుంది.
print(x | y) print(bin(x | y)) # 11 # 0b1011
ఎక్స్‌క్లూజివ్-లేదా ఆపరేషన్(XOR) :^ఆపరేటర్
^ ఆపరేటర్‌ని ఉపయోగించి లాజికల్ ప్రోడక్ట్ (XOR) యొక్క ఉదాహరణ, బిన్()ని ఉపయోగించి బైనరీ సంజ్ఞామానంలో స్ట్రింగ్‌గా మార్చబడిన ఫలితంతో కలిపి ఉంటుంది.
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 |
ప్రతికూల పూర్ణాంకాలపై బిట్‌వైస్ కార్యకలాపాలు
ప్రతికూల పూర్ణాంకంపై బిట్‌వైస్ ఆపరేషన్ చేసినప్పుడు, విలువ రెండు పూరక రూపంలో వ్యక్తీకరించబడినట్లుగా ప్రాసెస్ చేయబడుతుంది.
అయితే, మీరు బిన్() లేదా ఫార్మాట్() ఉపయోగించి ప్రతికూల పూర్ణాంకాన్ని బైనరీ స్ట్రింగ్‌గా మార్చినట్లయితే, సంపూర్ణ విలువ రెండు పూరక ఆకృతికి బదులుగా మైనస్ గుర్తును కలిగి ఉంటుంది.
మీరు టూస్ కాంప్లిమెంట్ రిప్రజెంటేషన్‌తో స్ట్రింగ్‌ని పొందాలనుకుంటే, దిగువ చూపిన విధంగా, అవసరమైన గరిష్ట సంఖ్యలో బిట్ అంకెలతో మరియు తీసుకోండి.
- 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ని రెండు పూరక రూపంగా పరిగణించి, అన్ని బిట్‌లను విలోమం చేయడానికి సమానం.
పైన పేర్కొన్న విధంగా, పైథాన్‌లో, ప్రతికూల పూర్ణాంకాన్ని బిన్(), ఫార్మాట్() మొదలైన వాటిని ఉపయోగించి బైనరీ స్ట్రింగ్‌గా మార్చినప్పుడు, అది రెండు పూరక రూపంలో కాదు, మైనస్ గుర్తుతో సంపూర్ణ విలువలో ఉంటుంది. కాబట్టి, ~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
ప్రతికూల విలువల కోసం, సైన్ బిట్ పొడిగించబడింది మరియు మార్చబడుతుంది మరియు సానుకూల/ప్రతికూల సంకేతం అలాగే ఉంటుంది. ప్రతికూల విలువ అనేది ఎడమ వైపున ఉన్న 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
సంఖ్యల పరంగా ఆలోచించడం స్పష్టంగా లేనందున, రెండు పూరక వ్యక్తీకరణల తీగలతో ఆలోచించడం మంచిది.