Noto che posso fare cose come 2 << 5ottenere 64 e 1000 >> 2250.

Inoltre posso usare >>in print:

print >>obj, "Hello world"

Cosa sta succedendo qui?

Penso che sia una domanda importante e non ha ancora una risposta (l'OP sembra già conoscere gli operatori di turno). Vorrei provare a rispondere, l'operatore >> nel tuo esempio viene utilizzato per due scopi diversi. In termini c ++ questo operatore è sovraccarico. Nel primo esempio viene utilizzato come operatore bit per bit (shift a sinistra), mentre nel secondo scenario viene utilizzato semplicemente come reindirizzamento dell'output. cioè

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, 

esempio

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

aggiornare:

In python 3 è possibile dare l'argomento file direttamente come segue:

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

Questi sono operatori di spostamento bit a bit.

Citando dai documenti :

x << y

Restituisce xcon i bit spostati a sinistra di y posizioni (e i nuovi bit sul lato destro sono zeri). Questo equivale a moltiplicare xper 2**y.

x >> y

Ritorna xcon i bit spostati a destra di y posizioni. Equivale a dividere xper 2**y.

12 << 2

48

Il valore binario effettivo di 12 è "00 1100" quando si esegue l'istruzione precedente Spostamento a sinistra (2 posizioni spostate a sinistra) restituisce il valore 48 il suo valore binario è "11 0000".

48 >> 2

12

Il valore binario di 48 è "11 0000", dopo aver eseguito l'istruzione precedente Shift a destra (2 posizioni spostate a destra) restituisce il valore 12 il suo valore binario è "00 1100".

Sono operatori di spostamento di bit che esistono in molti linguaggi di programmazione tradizionali, <<è lo spostamento a sinistra ed >>è lo spostamento a destra, possono essere dimostrati come nella tabella seguente, supponendo che un numero intero richieda solo 1 byte in memoria.

| 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 |

L'altro caso che coinvolge print >>obj, "Hello World"è la sintassi "print chevron" per l' print istruzione in Python 2 (rimossa in Python 3, sostituita filedall'argomento della print() funzione ). Invece di scrivere sullo standard output, l'output viene passato al obj.write()metodo. Un tipico esempio potrebbero essere gli oggetti file con un write()metodo. Vedi la risposta a una domanda più recente: doppio segno maggiore di in Python .

Questi sono gli operatori di turno

x << y Restituisce x con i bit spostati a sinistra di y posizioni (e i nuovi bit sul lato destro sono zeri). Questo equivale a moltiplicare x per 2 ** y.

x >> y Restituisce x con i bit spostati a destra di y posizioni. È lo stesso di // 'ing x by 2 ** y.

<< 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

Ho verificato quanto segue sia su Python 2.7 che su Python 3.8

Ho stampato (100 << 3) La conversione di 100 in binario dà 1100100. Quello che ho fatto è stato eliminare i primi 3 bit e aggiunto 3 bit con il valore "0" alla fine. Quindi dovrebbe risultare come 0100000 e l'ho convertito in Decimale e la risposta era 32.

Per la mia sorpresa quando ho eseguito print (100 << 3) la risposta era 800. Ero perplesso. Ho convertito 800 in binario per controllare cosa sta succedendo. E questo è quello che ho ottenuto 1100100000.

Se vedi come 800 era la risposta di Python, non hanno spostato o rilasciato i primi 3 bit ma hanno aggiunto il valore "0" agli ultimi 3 bit.

Dove come stampa (100 >> 3), ha funzionato perfettamente. Ho eseguito calcoli manuali e verificato il risultato della stampa da Python. Ha funzionato correttamente. Eliminati gli ultimi 3 bit e il valore aggiunto "0" ai primi 3 bit.

Sembra che (100 << 3), l'operatore di spostamento a sinistra abbia un bug su Python.