String omzetten naar bytes in Python

Strings stellen leesbare tekst voor en zijn een van de meest basale en belangrijke datatypen in computerprogrammering. Toch wordt elk teken in een tekststring weergegeven door één of meer bytes binaire data. Toepassingen zoals invoer- en uitvoerbewerkingen en gegevensoverdracht vereisen dat strings met een specifieke codering naar bytes worden omgezet.

Deze tutorial behandelt technieken om strings om te zetten naar bytes in Python. Ben je geïnteresseerd in de omgekeerde bewerking? Bekijk dan mijn tutorial over hoe je bytes naar strings converteert in Python.

Voordat we de details induiken, beginnen we met een kort antwoord voor wie haast heeft.

Kort antwoord: String omzetten naar bytes in Python

Python maakt het eenvoudig om een string naar bytes te converteren met de ingebouwde methode .encode():

my_string = "Hello, world!"
bytes_representation = my_string.encode(encoding="utf-8")  
# Optional: Specify the desired encoding (UTF-8 is the default)

print(bytes_representation)
# Output: b'Hello, world!'Mogelijk gemaakt door

De methode .encode() retourneert een nieuw bytes-object dat de gecodeerde versie van de oorspronkelijke string voorstelt. Standaard wordt UTF-8 gebruikt, maar je kunt indien nodig andere coderingen opgeven, zoals 'ascii' of 'latin-1'.

Laten we dit conversieproces in meer detail bekijken.

Strings en bytes in Python begrijpen

Twee van de kern-datatypen in Python zijn str en bytes. Deze datatypen delen overeenkomsten maar hebben ook belangrijke verschillen.

Zowel str als bytes zijn immutabele sequenties, wat betekent dat we hun elementen na creatie niet kunnen wijzigen. Een string is een immutabele reeks tekens, terwijl een bytes-object een immutabele reeks gehele getallen tussen 0 en 255 is. Dit bereik van gehele getallen kan worden weergegeven door 8 bits, oftewel één byte. Daarom is een bytes-object een sequentie van bytes.

ASCII-tekencodering

Laten we eerst naar ASCII-tekens kijken. ASCII (American Standard Code for Information Interchange) is een tekencodering die slechts 128 tekens bevat. Elk ASCII-teken kan dus worden weergegeven met zeven bits, wat minder is dan één byte.

We kunnen een bytes-object maken door b voor de enkele, dubbele of drievoudige aanhalingstekens te plaatsen die we normaal voor strings gebruiken:

word_as_bytes = b"Python"
print(word_as_bytes)
print(type(word_as_bytes))Mogelijk gemaakt door

b'Python'
<class 'bytes'>Mogelijk gemaakt door

Hoewel de code de letters van het woord Python toont, is elk element in het bytes-object een geheel getal tussen 0 en 255:

print(word_as_bytes[0])
print(list(word_as_bytes))Mogelijk gemaakt door

80
[80, 121, 116, 104, 111, 110]Mogelijk gemaakt door

Het eerste element van word_as_bytes is het gehele getal 80, de ASCII-code voor een hoofdletter P:

print(chr(80))Mogelijk gemaakt door

PMogelijk gemaakt door

Als je word_as_bytes omzet naar een lijst, bevat die lijst de gehele getallen die elke byte voorstellen. De gehele getallen zijn de ASCII-codes voor de letters in het woord Python.

Maar de ASCII-tekenset is beperkt.

UTF-8-tekencodering

De meest voorkomende tekencodering is UTF-8, een 8-bits Unicode-codering. De 128 ASCII-tekens worden in UTF-8 door dezelfde gehele getallen weergegeven, maar andere tekens kunnen ook worden weergegeven met twee of meer bytes per teken.

Laten we een bytes-object maken met niet-ASCII-tekens. We moeten hiervoor de constructor bytes() gebruiken:

word_as_bytes = bytes("café", "utf-8")
print(word_as_bytes)Mogelijk gemaakt door

b'caf\xc3\xa9'Mogelijk gemaakt door

Het bytes-object toont de eerste drie letters van café direct. Maar de accentletter é is geen ASCII-teken en wordt weergegeven door twee bytes, die getoond worden als \xc3 en \xa9. Deze bytes stellen de hexadecimale getallen c3 en a9 voor, oftewel de gehele getallen 195 en 169. Deze twee bytes samen vertegenwoordigen é in UTF-8:

print(len(word_as_bytes))
print(list(word_as_bytes))Mogelijk gemaakt door

5
[99, 97, 102, 195, 169]Mogelijk gemaakt door

Een bytes-object met vijf elementen vertegenwoordigt de vierletterige string.

Strings naar bytes converteren: de methode encode()

Eerder gebruikten we de constructor bytes() om een tekststring om te zetten in een bytes-object. Een gebruikelijkere manier om Python-strings naar bytes te converteren is de stringmethode .encode(), waarmee je controle hebt over codering en foutafhandeling. Deze methode retourneert een bytes-object dat de string voorstelt:

word_as_bytes = "Hello Python!".encode()
​print(word_as_bytes)
print(type(word_as_bytes))
Mogelijk gemaakt door

b'Hello Python!'
<class 'bytes'>Mogelijk gemaakt door

De methode .encode() gebruikt standaard de UTF-8-codering. UTF-8 is de meest gebruikte coderingsindeling en ondersteunt een veel breder scala aan tekens dan ASCII. UTF-8 geeft elk teken weer met een reeks van één, twee, drie of vier bytes.

We kunnen .encode() aanroepen met een alternatieve codering als argument:

word_as_bytes = "Hello Python!".encode("utf-16")
print(word_as_bytes)Mogelijk gemaakt door

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00 \x00P\x00y\x00t\x00h\x00o\x00n\x00!\x00'Mogelijk gemaakt door

Het bytes-object ziet er in dit geval anders uit, omdat het de UTF-16-codering van dezelfde tekststring weergeeft.

Coderingsfouten

Omdat niet alle coderingen alle tekens bevatten, kunnen er fouten optreden bij het coderen van een string naar een bytes-object.

Neem de string "Café • £2.20", die drie niet-ASCII-tekens bevat. We kunnen dit coderen met de standaard UTF-8-codering:

word_as_bytes = "Café • £2.20".encode()
print(word_as_bytes)Mogelijk gemaakt door

b'Caf\xc3\xa9 \xe2\x80\xa2 \xc2\xa32.20'Mogelijk gemaakt door

De niet-ASCII-tekens worden vervangen door hun hexadecimale escapes. Maar .encode() geeft een fout als dezelfde string met ASCII wordt gecodeerd, omdat meerdere tekens niet in ASCII voorkomen:

word_as_bytes = "Café • £2.20".encode("ascii")
print(word_as_bytes)Mogelijk gemaakt door

Traceback (most recent call last):
...
word_as_bytes = "Café • £2.20".encode("ascii")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3: ordinal not in range(128)Mogelijk gemaakt door

De stringmethode .encode() heeft een parameter errors met als standaardwaarde "strict". Het argument "strict" dwingt .encode() om een UnicodeEncodeError op te werpen wanneer een teken niet kan worden gecodeerd.

Er zijn echter andere opties voor foutafhandeling. Eén optie is om fouten te negeren met het argument "ignore":

word_as_bytes = "Café • £2.20".encode("ascii", errors="ignore")
print(word_as_bytes)Mogelijk gemaakt door

b'Caf 2.20'Mogelijk gemaakt door

Deze optie veroorzaakt geen fout. In plaats daarvan retourneert .encode() een bytes-object en worden de geaccentueerde é, het opsommingsteken en het pondteken weggelaten.

Een andere optie is om tekens die niet kunnen worden gecodeerd te vervangen door iets anders. Er zijn verschillende vervangingsopties. Eén daarvan is het argument errors="replace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="replace")
print(word_as_bytes)Mogelijk gemaakt door

b'Caf? ? ?2.20'Mogelijk gemaakt door

De drie niet-ASCII-tekens, die in dit voorbeeld niet kunnen worden gecodeerd, worden vervangen door een vraagteken. Elk ontbrekend teken wordt dus vervangen door een ander enkel teken dat als placeholder fungeert.

We kunnen de ontbrekende tekens ook vervangen door informatievere tekst:

word_as_bytes = "Café • £2.20".encode("ascii", errors="backslashreplace")
print(word_as_bytes)Mogelijk gemaakt door

b'Caf\\xe9 \\u2022 \\xa32.20'Mogelijk gemaakt door

Aanroepen van .encode() met errors="backslashreplace" vervangt de tekens die niet kunnen worden gecodeerd door hun hexadecimale escape-sequenties. Het hexadecimale getal e9 staat voor de geaccentueerde é. Het opsommingsteken is het Unicode-teken u2022, en het hexadecimale getal a3 staat voor het pondteken.

We kunnen ook "xmlcharrefreplace" gebruiken om de ontbrekende tekens te vervangen door hun XML-code:

word_as_bytes = "Café • £2.20".encode("ascii", errors="xmlcharrefreplace")
print(word_as_bytes)Mogelijk gemaakt door

b'Café • £2.20'Mogelijk gemaakt door

Een andere optie is om ongeldige tekens te vervangen door hun formele naam met errors="namereplace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="namereplace")
print(word_as_bytes)Mogelijk gemaakt door

b'Caf\\N{LATIN SMALL LETTER E WITH ACUTE} \\N{BULLET} \\N{POUND SIGN}2.20'Mogelijk gemaakt door

Verschillende situaties vragen om aangepaste foutafhandeling, en de stringmethode .encode() biedt meerdere opties om met tekens om te gaan die niet kunnen worden gecodeerd.

Toepassingen van string-naar-bytesconversie in data science

String-naar-bytesconversie is een basisbewerking met toepassingen in diverse data science-domeinen:

• Natural language processing (NLP): Bij het werken met tekstdata voor taken zoals sentimentanalyse, topic modeling of machinevertaling, preprocessen we tekst vaak door deze te tokenizen in woorden of subwoorden. Dit tokenizatieproces omvat vaak het converteren van strings naar bytesequenties voor efficiënte representatie en bewerking.
• Dataschoonmaak en -voorbewerking: Operaties op byteniveau kunnen handig zijn voor het opschonen van tekstdata, zoals het verwijderen van ongeldige tekens of het normaliseren van tekst op basis van specifieke bytepatronen.
• Feature engineering: In sommige gevallen kunnen features op byteniveau (bijv. n-grams van bytes) uit tekstdata worden gehaald en gebruikt als inputfeatures voor machinelearningmodellen.
• Webscraping en data-extractie: Bij het scrapen van data van websites ontvangen we vaak HTML of andere tekstgebaseerde content die mogelijk op byteniveau geparseerd en verwerkt moet worden om relevante informatie te extraheren.
• Datacompressie: Bepaalde compressie-algoritmen werken op bytesequenties, dus het omzetten van strings naar bytes kan een noodzakelijke stap zijn voordat je compressietechnieken toepast.

Inzicht in deze toepassingen helpt om situaties te herkennen waarin het omzetten van strings naar bytes nuttig kan zijn.

Conclusie

Strings zijn reeksen leesbare tekens. Deze tekens worden gecodeerd als bytes binaire data, die kunnen worden opgeslagen in een bytes-object. Een bytes-object is een reeks gehele getallen, en elk geheel getal stelt een byte voor.

Toepassingen vereisen dat strings worden omgezet naar bytes-objecten. Dat kan met de constructor bytes() of met de stringmethode .encode(). Het beheersen van de conversie tussen strings en bytes maakt flexibelere datamanipulatie mogelijk.

Ga verder met Python leren via de volgende tutorials en cursussen:

• Cursus Inleiding tot Python
• Python-programmeren
• Python Fundamentals