Blijkbaar is het volgende de geldige syntaxis:

my_string = b'The string'

Ik zou graag willen weten:

1. Wat betekent dit b-teken voor de tekenreeks?
2. Wat zijn de effecten van het gebruik ervan?
3. Wat zijn geschikte situaties om het te gebruiken?

Ik heb een gerelateerde vraaghier op SO gevonden, maar die vraag gaat echter over PHP en er staat de bwordt gebruikt om aan te geven dat de string binair is, in tegenstelling tot Unicode, wat nodig was om code compatibel te maken met de versie van PHP < 6, bij het migreren naar PHP 6. Ik denk niet dat dit van toepassing is op Python.

Ik heb deze documentatiegevonden op de Python-site over het gebruik van een u-teken in dezelfde syntaxis om een tekenreeks op te geven als Unicode. Helaas wordt het b-teken nergens in dat document genoemd.

Ook, gewoon uit nieuwsgierigheid, zijn er meer symbolen dan de ben udie andere dingen doen?

Antwoord 1, autoriteit 100%

Om de Python 2.x-documentatiete citeren:

Een voorvoegsel van ‘b’ of ‘B’ wordt genegeerd in
Python 2; het geeft aan dat de
letterlijk moet een letterlijke bytes worden
in Python 3 (bijv. wanneer code is
automatisch omgezet met 2to3). EEN
‘u’ of ‘b’ prefix kan worden gevolgd door
een voorvoegsel ‘r’.

In de Python 3-documentatiestaat:

Bytes-letterwoorden worden altijd voorafgegaan door ‘b’ of ‘B’; ze produceren een instantie van het type bytes in plaats van het type str. Ze mogen alleen ASCII-tekens bevatten; bytes met een numerieke waarde van 128 of hoger moeten worden uitgedrukt met escapes.

Antwoord 2, autoriteit 92%

Python 3.xmaakt een duidelijk onderscheid tussen de typen:

• str= '...'literals = een reeks Unicode-tekens (Latin-1, UCS-2 of UCS-4, afhankelijk van het breedste teken in de string)
• bytes= b'...'literals = een reeks octetten (gehele getallen tussen 0 en 255)

Als je bekend bent met:

• Java of C#, beschouw strals Stringen bytesals byte[];
• SQL, beschouw strals NVARCHARen bytesals BINARYof BLOB;
• Windows-register, beschouw strals REG_SZen bytesals REG_BINARY.

Als je bekend bent met C(++), vergeet dan alles wat je hebt geleerd over charen strings, want een teken is geen byte. Dat idee is al lang achterhaald.

Je gebruikt strals je tekst wilt weergeven.

print('שלום עולם')

U gebruikt byteswanneer u binaire gegevens op laag niveau wilt weergeven, zoals structs.

NaN = struct.unpack('>d', b'\xff\xf8\x00\x00\x00\x00\x00\x00')[0]

Je kunt encodereneen strnaar een bytesobject.

>>> '\uFEFF'.encode('UTF-8')
b'\xef\xbb\xbf'

En je kunt een bytesdecoderen in een str.

>>> b'\xE2\x82\xAC'.decode('UTF-8')
'€'

Maar je kunt de twee soorten niet vrijelijk mengen.

>>> b'\xEF\xBB\xBF' + 'Text with a UTF-8 BOM'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't concat bytes to str

De b'...'-notatie is enigszins verwarrend omdat de bytes 0x01-0x7F hierdoor kunnen worden gespecificeerd met ASCII-tekens in plaats van hexadecimale getallen.

>>> b'A' == b'\x41'
True

Maar ik moet benadrukken, een teken is geen byte.

>>> 'A' == b'A'
False

In Python 2.x

Pre-3.0-versies van Python misten dit soort onderscheid tussen tekst en binaire gegevens. In plaats daarvan was er:

• unicode= u'...'literals = reeks Unicode-tekens = 3.x str
• str= '...'literals = reeksen van verwarde bytes/tekens
  • Meestal tekst, gecodeerd in een niet-gespecificeerde codering.
  • maar ook gebruikt om binaire gegevens weer te geven zoals struct.packoutput.

Om de 2.x-to-3.x-overgang te vergemakkelijken, werd de b'...'Letterlijke Syntaxis backported naar Python 2.6, om onderscheidende binaire snaren te onderscheiden (welke Moet bytesin 3.x) zijn van tekststrings (die strin 3.x) moeten zijn. De bPrefix doet niets in 2.x, maar vertelt de 2to3script om het niet om te zetten in een Unicode-reeks in 3.x.

Dus ja, b'...'literalen in Python hebben hetzelfde doel dat ze doen in PHP.

Ook, gewoon uit nieuwsgierigheid, zijn er
meer symbolen dan de b en u die doen
andere dingen?

De rPrefix maakt een onbewerkte reeks (bijv. r'\t'is een backslash + tin plaats van een tabblad), en Triple Quotes '''...'''of """..."""Multi-Line String Literals toestaan.

Antwoord 3, Autoriteit 6%

De B geeft een byte-string aan.

bytes zijn de werkelijke gegevens. Snaren zijn een abstractie.

Als u meerkoppelingsstringobject had en u een enkel teken hebt genomen, zou het een touw zijn, en het kan meer dan 1 byte in grootte zijn, afhankelijk van de codering.

Indien 1 byte met een byte-string nakte, krijgt u een enkele 8-bits waarde van 0-255 en het is mogelijk geen volledig teken voor als die karakters als gevolg van codering waren en GT; 1 byte.

TBH Ik zou strings gebruiken, tenzij ik een of andere reden van een laag niveau had om bytes te gebruiken.

Antwoord 4, Autoriteit 4%

Van de serverzijde, als we een antwoord verzenden, wordt deze in de vorm van byte-type verzonden, dus het verschijnt in de client als b'Response from server'

Ongeveer verdwijnen van b'....'Gebruik eenvoudig onderstaande code:

Serverbestand:

stri="Response from server"    
c.send(stri.encode())

Clientbestand:

print(s.recv(1024).decode())

Dan drukt het Response from server

Antwoord 5, Autoriteit 3%

Hier is een voorbeeld waar de afwezigheid van been TypeErrorUitzondering in Python 3.x

zou gooien

>>> f=open("new", "wb")
>>> f.write("Hello Python!")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface

Een bPrefix toevoegen zou het probleem oplossen.

Antwoord 6, Autoriteit 2%

Het verandert het in een bytesletterlijke (of strin 2.x), en is geldig voor 2,6 +.

De rPrefix veroorzaakt backslashes om “niet-geïnterpreteerd” te worden (niet genegeerd en het verschil doet materie).

Antwoord 7, Autoriteit 2%

Naast wat anderen hebben gezegd, merk dan op dat een enkel personage in Unicode uit meerdere bytes kan bestaan.

De manier waarop Unicode werkt, is dat het het oude ASCII-formaat kostte (7-bits code die eruit ziet als 0xxx xxxx) en Multi-bytes sequenties waar alle bytes beginnen met 1 (1xxx xxxx) om karakters voorbij ASCII te vertegenwoordigen, zodat Unicode Achterwaarts-compatibel met ASCII.

>>> len('Öl')  # German word for 'oil' with 2 characters
2
>>> 'Öl'.encode('UTF-8')  # convert str to bytes 
b'\xc3\x96l'
>>> len('Öl'.encode('UTF-8'))  # 3 bytes encode 2 characters !
3

Antwoord 8, Autoriteit 2%

Het antwoord op de vraag is dat het wel:

data.encode()

en om het te decoderen (verwijder de b, want soms heb je het niet nodig)

Gebruik:

data.decode()

Antwoord 9

U kunt JSON gebruiken om het naar woordenboek te converteren

import json
data = b'{"key":"value"}'
print(json.loads(data))

{“toets”: “waarde”}

Kolf:

Dit is een voorbeeld van een fles. Voer dit uit op de terminallijn:

import requests
requests.post(url='http://localhost(example)/',json={'key':'value'})

in fles / routes.py

@app.route('/', methods=['POST'])
def api_script_add():
    print(request.data) # --> b'{"hi":"Hello"}'
    print(json.loads(request.data))
return json.loads(request.data)

{‘toets’: ‘waarde’}