Ik merk dat ik dingen kan doen zoals 2 << 5om 64 en 1000 >> 2om 250 te krijgen.
Ik kan ook >>gebruiken in print:
print >>obj, "Hello world"
Wat gebeurt hier?
Antwoord 1, autoriteit 100%
Ik denk dat het een belangrijke vraag is die nog niet is beantwoord (de OP lijkt al op de hoogte te zijn van ploegendiensten). Laat me proberen te antwoorden, de >> operator in uw voorbeeld wordt voor twee verschillende doeleinden gebruikt. In c++-termen is deze operator overbelast. In het eerste voorbeeld wordt het gebruikt als bitsgewijze operator (shift naar links), terwijl het in het tweede scenario alleen wordt gebruikt als uitvoeromleiding. d.w.z.
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,
voorbeeld
with open('foo.txt', 'w') as obj:
print >> obj, "Hello world" # hello world now saved in foo.txt
bijwerken:
In python 3 is het mogelijk om het bestandsargument als volgt direct te geven:
print("Hello world", file=open("foo.txt", "a")) # hello world now saved in foo.txt
Antwoord 2, autoriteit 85%
Dit zijn bitsgewijze shift-operators.
Citaat uit de docs:
x << y
Retourneert xmet de bits met y plaatsen naar links verschoven (en nieuwe bits aan de rechterkant zijn nullen). Dit is hetzelfde als xvermenigvuldigen met 2**y.
x >> y
Retourneert xmet de bits met y plaatsen naar rechts verschoven. Dit is hetzelfde als xdelen door 2**y.
Antwoord 3, autoriteit 50%
12 << 2
48
De werkelijke binaire waarde van 12 is “00 1100” wanneer we de bovenstaande instructie uitvoeren. Left shift (2 plaatsen naar links verschoven) geeft de waarde 48 als binaire waarde “11 0000”.
48 >> 2
12
De binaire waarde van 48 is “11 0000”, na het uitvoeren van bovenstaande instructie. Right shift (2 plaatsen naar rechts verschoven) retourneert de waarde 12, de binaire waarde is “00 1100”.
Antwoord 4, autoriteit 30%
Het zijn bit shift-operatoren die in veel reguliere programmeertalen voorkomen, <<is de linker shift en >>is de rechter shift, ze kunnen worden gedemonstreerd als de volgende tabel, neem aan dat een geheel getal slechts 1 byte in het geheugen in beslag neemt.
| 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 |
Antwoord 5, autoriteit 16%
Het andere geval waarbij print >>obj, "Hello World"betrokken is, is de “print chevron”-syntaxis voor de printinstructiein Python 2 (verwijderd in Python 3, vervangen door het argument filevan de print()functie). In plaats van naar de standaarduitvoer te schrijven, wordt de uitvoer doorgegeven aan de methode obj.write(). Een typisch voorbeeld zijn bestandsobjecten met een write()-methode. Zie het antwoord op een recentere vraag: Dubbel groter-dan-teken in Python.
Antwoord 6, autoriteit 11%
Dit zijn de ploegendiensten
x << y Retourneert x met de bits naar links verschoven met y plaatsen (en
nieuwe bits aan de rechterkant zijn nullen). Dit is hetzelfde als
x vermenigvuldigen met 2**y.x >> y Retourneert x met de bits verschoven naar de
vlak bij y plaatsen. Dit is hetzelfde als //’ing x door 2**y.
Antwoord 7
<< 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
Antwoord 8
Ik heb het volgende geverifieerd op zowel Python 2.7 als Python 3.8
Ik heb geprint(100<<3)
Het omzetten van 100 naar binair geeft 1100100.
Wat ik deed, is dat ik de eerste 3 bits heb laten vallen en aan het einde 3 bits heb toegevoegd met de waarde ‘0’.
Dus het zou moeten resulteren als 0100000, en ik heb dit omgezet naar Decimaal en het antwoord was 32.
Tot mijn verbazing toen ik print(100<<3) uitvoerde, was het antwoord 800. Ik was verbaasd.
Ik heb 800 naar binair geconverteerd om te controleren wat er aan de hand is.
En dit is wat ik kreeg 1100100000.
Als je ziet hoe 800 het Python-antwoord was, hebben ze de eerste 3 bits niet verschoven of weggelaten, maar de waarde ‘0’ toegevoegd aan de laatste 3 bits.
Waar als print(100>>3) , werkte perfect. Ik deed handmatige berekening en controleerde het afdrukresultaat van python. Het werkte correct. Laatste 3 bits laten vallen en waarde ‘0’ toegevoegd aan eerste 3 bits.
Het lijkt erop (100<<3) , de linker shift-operator heeft een bug in Python.
Antwoord 9
Zijn “bitsgewijze” operators.
https://wiki.python.org/moin/BitwiseOperators
>>> help("symbols")
+-------------------------------------------------+---------------------------------------+
| Operator | Description |
|=================================================|=======================================|
| "<<", ">>" | Shifts |
+-------------------------------------------------+---------------------------------------+
| "&" | Bitwise AND |
+-------------------------------------------------+---------------------------------------+
| "|" | Bitwise OR |
+-------------------------------------------------+---------------------------------------+
| "~x" | bitwise NOT |
+-----------------------------------------------------------------------------------------+
| "^" | Bitwise XOR |
+-------------------------------------------------+---------------------------------------+
x << y
Retourneert X met de bits verschoven naar links door Y-plaatsen (en nieuwe bits aan de rechterkant zijn nullen). Dit is hetzelfde als vermenigvuldigd x door 2 ** y.
x >> y
Retourneert X met de bits verschoven naar rechts door Y-plaatsen. Dit is hetzelfde als // ‘ING X by 2 ** y.
PD: in Python 3.9 De operator “|” toegepast op woordenboeken samenvoegt woordenboeken.
https://docs.python.org/3.html
>>> x = {"key1": "value1 from x", "key2": "value2 from x"}
>>> y = {"key2": "value2 from y", "key3": "value3 from y"}
>>> x | y
{'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}
>>> y | x
{'key2': 'value2 from x', 'key3': 'value3 from y', 'key1': 'value1 from x'}