Ei vielä käännetty

Tätä sivua ei ole vielä käännetty suomeksi, joten se näytetään englanniksi. Auta kääntämään

bytes() Function Complexity¶

The bytes() function creates bytes objects from strings, iterables, or allocates empty bytes.

Complexity Analysis¶

Case	Time	Space	Notes
Empty bytes	O(1)	O(1)	bytes()
From string with encoding	O(n)	O(n)	n = string length
From iterable	O(n)	O(n)	n = iterable length
From int (size)	O(n)	O(n)	n = requested size
Copy bytes	O(n)	O(n)	n = bytes length

Basic Usage¶

Create Empty Bytes¶

# O(1)
b = bytes()       # b''
b = bytes(0)      # b'' (size 0)

From String with Encoding¶

# O(n) - where n = string length
b = bytes("hello", "utf-8")        # b'hello'
b = bytes("café", "utf-8")         # b'caf\xc3\xa9' (3 bytes for é)
b = bytes("中国", "utf-8")         # Multiple bytes per character

Allocate Bytes (Zero-filled)¶

# O(n) - where n = size
b = bytes(10)      # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b = bytes(1000)    # 1000 zero bytes

From Iterable of Integers¶

# O(n) - where n = number of items
b = bytes([65, 66, 67])         # b'ABC'
b = bytes(range(256))           # All byte values
b = bytes([0, 255, 128, 64])    # b'\x00\xff\x80@'

Copy Bytes¶

# O(n) - where n = bytes length
original = b"hello"
copy = bytes(original)  # Creates new bytes object

Complexity Details¶

String Encoding¶

# O(n) - linear in string length
short = bytes("hi", "utf-8")       # O(2)
long = bytes("a" * 1000, "utf-8")  # O(1000)

# Each character must be encoded
# ASCII characters = 1 byte each
# UTF-8 multibyte = multiple bytes

Multibyte Characters¶

# O(n) - but n = encoded byte length, not character count
english = bytes("hello", "utf-8")  # O(5) - 5 ASCII characters
# Result: b'hello' (5 bytes)

accented = bytes("café", "utf-8")  # O(4) - 4 characters
# Result: b'caf\xc3\xa9' (5 bytes!) - é = 2 bytes in UTF-8

chinese = bytes("中国", "utf-8")   # O(2) - 2 characters
# Result: 6 bytes (3 bytes per character)

From Iterable¶

# O(n) - iterate and convert
data = [65, 66, 67, 68, 69]
b = bytes(data)  # O(5)
# b'ABCDE'

# With range
b = bytes(range(256))  # O(256)

Allocating Size¶

# O(n) - allocate and zero-fill
small = bytes(10)      # O(10)
medium = bytes(1000)   # O(1000)
large = bytes(1000000) # O(1000000)

# Must initialize all bytes to zero

Common Patterns¶

Encoding Strings¶

# O(n) - convert text to bytes
text = "Hello, World!"
encoded = bytes(text, "utf-8")  # O(13)
# b'Hello, World!'

Different Encodings¶

# O(n) - same complexity, different results
text = "café"

utf8 = bytes(text, "utf-8")         # O(4) - 5 bytes result
utf16 = bytes(text, "utf-16")       # O(4) - 10 bytes result
latin1 = bytes(text, "latin-1")     # O(4) - 4 bytes result
ascii = bytes(text, "ascii")        # UnicodeEncodeError!

Converting Between Bytes and Strings¶

# O(n) - encode and decode
text = "hello"

# String -> Bytes
b = bytes(text, "utf-8")  # O(n)

# Bytes -> String
decoded = str(b, "utf-8")    # O(n)
# or
decoded = b.decode("utf-8")  # O(n) - same complexity

# Round trip
text2 = str(bytes(text, "utf-8"), "utf-8")
assert text == text2

Performance Patterns¶

Batch Encoding¶

# O(n * m) - n strings, m = avg length
texts = ["hello", "world", "python"]
encoded = [bytes(t, "utf-8") for t in texts]  # O(n * m)

# Using map - same complexity
encoded = list(map(lambda x: bytes(x, "utf-8"), texts))

File I/O¶

# O(n) - read as bytes
with open("file.bin", "rb") as f:
    data = f.read()  # bytes

# O(n) - write bytes
with open("output.bin", "wb") as f:
    f.write(bytes("hello", "utf-8"))  # O(n)

Network Transmission¶

# O(n) - convert and send
import socket

message = "Hello, Server!"
data = bytes(message, "utf-8")  # O(n)

# socket.send(data)  # Sends bytes

Edge Cases¶

Empty String¶

# O(1)
b = bytes("", "utf-8")  # b''

Zero-size Allocation¶

# O(1)
b = bytes(0)  # b'' - empty bytes

Invalid Encoding¶

# O(n) - error during conversion
try:
    b = bytes("café", "ascii")  # UnicodeEncodeError
except UnicodeEncodeError:
    pass

Invalid Iterable Values¶

# O(n) - error checking
try:
    b = bytes([0, 256, 128])  # ValueError - 256 > 255
except ValueError:
    pass

try:
    b = bytes([-1, 50, 100])  # ValueError - negative
except ValueError:
    pass

Large Allocations¶

# O(n) - allocate and zero-fill
huge = bytes(10**7)  # 10MB of zeros - slower
# Useful but memory intensive

Comparison with bytearray()¶

# bytes() - immutable
b = bytes("hello", "utf-8")
# b[0] = 65  # TypeError - can't modify

# bytearray() - mutable
ba = bytearray("hello", "utf-8")
ba[0] = 72  # OK - changed to 'H'

# Both O(n) to create, but different mutability

String Methods¶

# encode() method - equivalent to bytes()
text = "hello"
b1 = bytes(text, "utf-8")
b2 = text.encode("utf-8")
# b1 == b2 - same result

# decode() method - inverse
b = b"hello"
text = b.decode("utf-8")
# "hello"

Best Practices¶

✅ Do:

Specify encoding explicitly: bytes(text, "utf-8")
Use UTF-8 as default encoding
Handle encoding errors: errors="strict" (default) or other options
Cache encoded values if used repeatedly

❌ Avoid:

Assuming ASCII encoding (won't work with accents)
Forgetting encoding parameter in bytes()
Creating large bytes objects unnecessarily
Confusing bytes with strings in Python 3

str() - Convert to string
bytearray() - Mutable bytes
encode() - String method to bytes
decode() - Bytes method to string

Version Notes¶

Python 2.x: str is bytes, unicode is text
Python 3.x: str is text, bytes is binary data
All versions: UTF-8 is recommended encoding