Percebo que posso fazer coisas como 2 << 5obter 64 e 1000 >> 2250.

Também posso usar >>em print:

print >>obj, "Hello world"

O que esta acontecendo aqui?

Acho que é uma questão importante e ainda não foi respondida (o OP parece já saber sobre os operadores de turno). Deixe-me tentar responder, o operador >> em seu exemplo é usado para dois propósitos diferentes. Em termos de c ++, esse operador está sobrecarregado. No primeiro exemplo, ele é usado como operador bit a bit (deslocamento para a esquerda), enquanto no segundo cenário é usado apenas como redirecionamento de saída. ie

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, 

exemplo

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

atualizar:

Em Python 3, é possível fornecer o argumento do arquivo diretamente da seguinte maneira:

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

Esses são operadores de mudança bit a bit.

Citando os documentos :

x << y

Retorna xcom os bits deslocados para a esquerda em y lugares (e os novos bits no lado direito são zeros). Isso é o mesmo que multiplicar xpor 2**y.

x >> y

Retorna xcom os bits deslocados para a direita por y lugares. Isso é o mesmo que dividir xpor 2**y.

12 << 2

48

O valor binário real de 12 é "00 1100" quando executamos a instrução acima. O deslocamento à esquerda (2 casas deslocadas para a esquerda) retorna o valor 48 e seu valor binário é "11 0000".

48 >> 2

12

O valor binário de 48 é "11 0000", após a execução da instrução acima, o deslocamento para a direita (2 casas deslocadas para a direita) retorna o valor 12 e seu valor binário é "00 1100".

Eles são o operador de mudança de bit que existe em muitas linguagens de programação convencionais, <<é o deslocamento para a esquerda e >>é o deslocamento para a direita, eles podem ser demonstrados na tabela a seguir, suponha que um inteiro leve apenas 1 byte na memória.

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

O outro caso envolvendo print >>obj, "Hello World"é a sintaxe "print chevron" para a print instrução em Python 2 (removida em Python 3, substituída pelo fileargumento da print() função ). Em vez de gravar na saída padrão, a saída é passada para o obj.write()método. Um exemplo típico seria objetos de arquivo com um write()método. Veja a resposta a uma pergunta mais recente: Sinal de maior que duplo em Python .

Estes são os operadores de turno

x << y Retorna x com os bits deslocados para a esquerda por y lugares (e os novos bits no lado direito são zeros). Isso é o mesmo que multiplicar x por 2 ** y.

x >> y Retorna x com os bits deslocados para a direita por y casas. Isso é o mesmo que // 'obter x por 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

Eu verifiquei o seguinte no Python 2.7 e no Python 3.8

Eu imprimi (100 << 3) A conversão de 100 em binário resulta em 1100100. O que fiz foi eliminar os primeiros 3 bits e adicionar 3 bits com o valor '0' no final. Portanto, o resultado deve ser 0100000, converti isso para decimal e a resposta foi 32.

Para minha surpresa, quando executei print (100 << 3), a resposta foi 800. Fiquei intrigado. Converti 800 para binário para verificar o que está acontecendo. E é isso que eu tenho 1100100000.

Se você vir como 800 era a resposta do Python, eles não mudaram ou eliminaram os primeiros 3 bits, mas adicionaram o valor '0' aos últimos 3 bits.

Onde como print (100 >> 3), funcionou perfeito. Fiz cálculos manuais e verifiquei o resultado da impressão do python. Funcionou corretamente. Últimos 3 bits removidos e valor adicionado '0' aos primeiros 3 bits.

Parece com (100 << 3), o operador de deslocamento para a esquerda tem um bug no Python.