Python bytes

The bytes type in Python is an immutable sequence of integers in the range 0 <= x < 256. It is the fundamental built-in data structure for representing raw binary data, contrasting directly with the str type, which represents sequences of Unicode characters.

Instantiation and Syntax

Byte Literals Prefixing a string literal with b or B creates a bytes object. Only ASCII characters are permitted within byte literals. Bytes with numeric values of 128 or greater must be expressed using hexadecimal, octal, or other escape sequences.

# ASCII literal
b_data = b'hello'


# Hexadecimal escape sequence representing the same data
b_hex = b'\x68\x65\x6c\x6c\x6f'

The bytes() Constructor The constructor instantiates bytes objects from iterables of integers (where 0 <= x < 256), integers, strings (which strictly require an encoding argument), or objects implementing the buffer protocol.

# From an iterable of integers
b_iter = bytes([104, 101, 108, 108, 111])


# Zero-filled bytes object of a specific length
b_zeros = bytes(5)  # b'\x00\x00\x00\x00\x00'


# From a string (encoding is mandatory in the constructor)
b_from_str = bytes("hello", encoding="utf-8")

Encoding Strings Converting a Unicode str to bytes can also be achieved using the string’s encode() method. In Python 3, this method defaults to the UTF-8 encoding scheme and can be called without arguments, though alternative encodings can be explicitly provided.

# String to bytes using default UTF-8 encoding
b_encoded = "Python".encode()


# Bytes back to string
s_decoded = b_encoded.decode('utf-8')

Core Characteristics

Immutability Like str and tuple, bytes objects are immutable. They cannot be modified in place. Any operation that alters the data will allocate and return a new bytes object in memory. Indexing and Slicing Because bytes are fundamentally sequences of integers, indexing a single position evaluates to an int. Conversely, slicing a bytes object evaluates to a new bytes object.

b_data = b'Python'

# Indexing returns an integer (the ASCII/byte value of 'P')
char_val = b_data[0]  # 80

# Slicing returns a bytes object
slice_val = b_data[0:2]  # b'Py'

Method Parity with str The bytes class implements a nearly identical API to the str class, including methods like split(), find(), replace(), and upper(). However, passing a str to these methods will raise a TypeError. The argument requirements depend strictly on the method:

Methods like split() can be called without arguments to split on ASCII whitespace. If a delimiter is provided to split() or a substring to replace(), it must be a bytes-like object. Passing an integer or string will raise a TypeError.
Methods like find() and count() accept either bytes-like objects or an integer representing a single byte value (0 <= x < 256).
Methods like upper() and lower() take no arguments and operate directly on the underlying byte values.

b_text = b'foo bar baz'

# split() without arguments defaults to splitting on whitespace
b_split_default = b_text.split()  # [b'foo', b'bar', b'baz']

# split() with a specific delimiter requires a bytes-like object
b_split_delim = b_text.split(b' ')  # [b'foo', b'bar', b'baz']

# replace() requires bytes-like objects
b_replaced = b_text.replace(b'foo', b'qux')  # b'qux bar baz'

# find() accepts a bytes-like object or an integer
idx = b_text.find(98)  # 4 (index of 'b', which is ASCII 98)

# upper() takes no arguments
b_upper = b_text.upper()  # b'FOO BAR BAZ'

Tired of Poor Python Skills? Fix That With Deep Grasping!Learn More

Functions

Decorators

Methods

Comprehensions

Classes

Constructors

Context Managers

Pattern Matching

Generics

Type Declarations

Type Aliases

Type Expressions

Type Qualifiers

Type Narrowing

Variables

Attributes

Properties

Parameters

Error Handling

Annotation Syntax

Conditional Statements

Control Flow Statements

Loops

Imports

Built-In Types

Comments & Documentation

Access Operators

Arithmetic Operators

Assignment Operators

Comparison Operators

Logical Operators

Membership Operators

Identity Operators

Unary Operators

Bitwise Operators

Shift Operators

Instantiation and Syntax

Core Characteristics

​Instantiation and Syntax

​Core Characteristics

Instantiation and Syntax

Core Characteristics