पायथन में >> और << का क्या अर्थ है?

Question 1

मैं ध्यान देता हूं कि मैं 2 << 5६४ पाने के लिए और 1000 >> 2२५० पाने के लिए काम कर सकता हूं ।

इसके अलावा, मैं उपयोग कर सकते हैं >>में print:

print >>obj, "Hello world"

यहां क्या हो रहा है?

Question 2

मुझे लगता है कि यह महत्वपूर्ण सवाल है और इसका जवाब अभी तक नहीं दिया गया है (ओपी पहले से ही शिफ्ट ऑपरेटरों के बारे में जानता है)। मुझे जवाब देने की कोशिश करें, >> आपके उदाहरण में ऑपरेटर दो अलग-अलग उद्देश्यों के लिए उपयोग किया जाता है। C ++ शब्दों में यह ऑपरेटर अतिभारित है। पहले उदाहरण में इसका उपयोग बिटवाइज ऑपरेटर (लेफ्ट शिफ्ट) के रूप में किया जाता है, जबकि दूसरे परिदृश्य में इसका उपयोग केवल आउटपुट रीडायरेक्शन के रूप में किया जाता है। अर्थात

2 << 5 # shift to left by 5 bits
2 >> 5 # shift to right by 5 bits
print >> obj, "Hello world" # redirect the output to obj,

उदाहरण

with open('foo.txt', 'w') as obj:
    print >> obj, "Hello world" # hello world now saved in foo.txt

अपडेट करें:

अजगर 3 में फ़ाइल तर्क को सीधे इस प्रकार देना संभव है:

print("Hello world", file=open("foo.txt", "a")) # hello world now saved in foo.txt

Question 3

ये बिटवाइज़ शिफ्ट ऑपरेटर हैं।

डॉक्स से उद्धरण :

x << y

xवाई स्थानों द्वारा बाईं ओर स्थानांतरित बिट्स के साथ रिटर्न (और दाईं ओर के नए बिट्स शून्य हैं)। यह गुणा करने के समान xहै 2**y।

x >> y

xबिट्स के साथ रिटर्न y स्थानों द्वारा दाईं ओर स्थानांतरित कर दिया गया। यह विभाजित करने के समान xहै 2**y।

Question 4

१२ << २

48

12 का वास्तविक बाइनरी मूल्य "00 1100" है जब हम उपरोक्त कथन को निष्पादित करते हैं तो वाम शिफ्ट (2 स्थानों को बाईं ओर स्थानांतरित कर दिया जाता है) का मान 48 देता है इसका बाइनरी मान "11 0000" है।

४। >> २

12

48 का बाइनरी वैल्यू "11 0000" है, ऊपर दिए गए स्टेटमेंट को निष्पादित करने के बाद राइट शिफ्ट (दाईं ओर शिफ्ट की गई 2) वैल्यू 12 मान देती है इसका बाइनरी वैल्यू "00 1100" है।

Question 5

वे बिट शिफ्ट ऑपरेटर हैं जो कई मुख्यधारा प्रोग्रामिंग भाषाओं में मौजूद हैं, <<बाईं ओर की शिफ्ट है और >>दाएं शिफ्ट है, उन्हें निम्न तालिका के रूप में प्रदर्शित किया जा सकता है, मान लें कि पूर्णांक केवल स्मृति में 1 बाइट लेते हैं।

| operate | bit value | octal value |                       description                        |
| ------- | --------- | ----------- | -------------------------------------------------------- |
|         | 00000100  |           4 |                                                          |
| 4 << 2  | 00010000  |          16 | move all bits to left 2 bits, filled with 0 at the right |
| 16 >> 2 | 00000100  |           4 | move all bits to right 2 bits, filled with 0 at the left |

Question 6

इसमें शामिल अन्य मामला बयान केprint >>obj, "Hello World" लिए "प्रिंट शेवरॉन" वाक्यविन्यास हैprint पायथन 2 में ( फ़ंक्शन के fileतर्क द्वारा प्रतिस्थापित पायथन 3 में हटा दिया गया है )। मानक आउटपुट पर लिखने के बजाय, आउटपुट विधि को पारित किया जाता है। एक विशिष्ट उदाहरण फ़ाइल ऑब्जेक्ट होगा जिसमें एक विधि होगी। एक और हालिया प्रश्न का उत्तर देखें: पायथन में दोगुने से अधिक चिन्ह ।print() obj.write()write()

Question 7

ये शिफ्ट ऑपरेटर हैं

x << y रिटर्न x को y स्थानों से बाईं ओर स्थानांतरित कर दिया गया है (और दाईं ओर के नए बिट्स zosos हैं)। यह x को 2 ** y से गुणा करने के समान है।

x >> y रिटर्न x सही स्थानों पर स्थानांतरित बिट्स के साथ है। यह // 'ing x 2 ** y' के समान है।

Question 8

<< Mean any given number will be multiply by 2the power
for exp:- 2<<2=2*2'1=4
          6<<2'4=6*2*2*2*2*2=64

Question 9

मैंने पायथन 2.7 और पायथन 3.8 दोनों पर निम्नलिखित का सत्यापन किया

मैंने प्रिंट किया (100 << 3) 100 को बाइनरी में परिवर्तित करने से 1100100 मिलता है। मैंने जो किया वह मैंने पहले 3 बिट्स को छोड़ दिया और अंत में '0' के साथ 3 बिट्स जोड़े। इसलिए इसका परिणाम 0100000 होना चाहिए, और मैंने इसे दशमलव में बदल दिया और उत्तर 32 था।

जब मैंने प्रिंट निष्पादित किया था, तब मेरे जवाब के लिए (100 << 3) उत्तर 800 था। मैं हैरान था। मैंने व्हाट्सएप को चेक करने के लिए 800 को बाइनरी में बदल दिया। और यही मुझे 1100100000 मिला।

यदि आप देखते हैं कि 800 पायथन जवाब था, तो वे पहले 3 बिट्स को शिफ्ट या ड्रॉप नहीं करते थे, लेकिन उन्होंने अंतिम 3 बिट्स के लिए '0' जोड़ा।

जहां प्रिंट (100 >> 3) के रूप में, सही काम किया। मैंने मैनुअल गणना की और अजगर से प्रिंट परिणाम को चबाया। इसने सही ढंग से काम किया। पिछले 3 बिट्स को गिरा दिया और पहले 3 बिट्स के लिए '0' जोड़ा।

लगता है (100 << 3), बाएं शिफ्ट ऑपरेटर के पास अजगर पर एक बग है।