Bytearray in Python (1)

Buy Me a Coffee☕

*Memo:

• My post explains the bytearray with indexing, slicing and copy.
• My post explains bytearray().
• My post explains a bytes.
• My post explains a string.
• My post explains string, bytes and bytearray functions.
• My post explains a list and the list with indexing.
• My post explains a tuple.
• My post explains a set and the set with copy.
• My post explains a frozenset (1).
• My post explains a dictionary (1).
• My post explains an iterator (1).
• My post explains a range (1).

A bytearray:

• is the ordered collection of zero or more bytes represented with ASCII characters and whose type is bytearray:
  • Each byte must be between [0, 255] from 256 ASCII characters.
  • It's for computer to understand.
  • Ordered means that the order of each byte in a bytearray is kept so it guarantees that the order is always the same unless changed.
• cannot be huge because it gets MemoryError.
• is mutable(unhashable) so it can be changed.
• can be created by bytearray() with or without several types of values:
  • For bytearray(), the words type conversion are also suitable in addition to the word creation.
• can be encoded to from a string by encode():
  • For encode(), the words creation and type conversion are also suitable in addition to the word encoding.
• can be iterated with a for statement.
• can be unpacked with an assignment and for statement, function and * but not with **.
• is False if it's empty.
• can be checked if a specific element is in the bytearray with in keyword.
• can be checked if the bytearray is referred to by two variables with is keyword.
• can be enlarged with * and a number.
• can be used with len() to get the length.
• can be read or changed by indexing or slicing.
• can be continuously used through multiple variables.
• can be shallow-copied but cannot be deep-copied.

bytearray() can create a bytearray as shown below:

*Memo:

• \' is the escape sequence to output '.

v = bytearray(b'') # Empty bytearray
v = bytearray(b"Hello World")
v = bytearray(B'I\'m John.')
v = bytearray(B"I'm John.")
v = bytearray(b'''I'm John.''')
v = bytearray(b"""I'm John.""")
v = bytearray(B'''Apple Orange Banana Kiwi''')
v = bytearray(b'Apple' b" Orange" b'''Banana''' B"""Kiwi""")
v = bytearray(b'''Apple
Orange
Banana
Kiwi''')
v = bytearray(b"""
Apple
   Orange
       Banana
           Kiwi
""")
# No error

for v in bytearray(b'ABC'): pass
v1, v2, v3 = bytearray(b'ABC')
v1, *v2, v3 = bytearray(b'ABCDEF')
for v1, v2, v3 in [bytearray(b'ABC'), bytearray(b'DEF')]: pass
for v1, *v2, v3 in [bytearray(b'ABCDEF'), bytearray(b'GHIJKL')]: pass
print(*bytearray(b'ABCD'), *bytearray(b'EF'))
print([*bytearray(b'ABCD'), *bytearray(b'EF')])
v = bytearray(b'ABCDE') * 3
v = bytearray(b'01234') * 3
v = bytearray(b'') * 3
# No error

v = b"Lёт's gφ!" # Let's go!
v = bytearray(b'ABCDE') * 1000000000
# Error

A bytearray is the ordered collection of zero or more bytes represented with ASCII characters and whose type is bytearray as shown below:

v = bytearray(b'') # Empty bytearray

print(v)
# bytearray(b'')

print(type(v))
# <class 'bytearray'>

v = bytearray(b"Hello World")

print(v)
# bytearray(b'Hello World')

v = bytearray(B"I'm John.")
v = bytearray(B'I\'m John.')
v = bytearray(b'''I'm John.''')
v = bytearray(b"""I'm John.""")

print(v)
# bytearray(b"I\'m John.")

v = bytearray(B'''Apple Orange Banana Kiwi''')
v = bytearray(b'Apple' b" Orange" b''' Banana''' B""" Kiwi""")

print(v)
# bytearray(b'Apple Orange Banana Kiwi')

v = bytearray(b'''Apple
Orange
Banana
Kiwi''')

print(v)
# bytearray(b'Apple\nOrange\nBanana\nKiwi')

v = bytearray(b"""
Apple
   Orange
       Banana
           Kiwi
""")

print(v)
# bytearray(b'\nApple\n   Orange\n       Banana\n           Kiwi\n')

A bytearray can be iterated with a for statement as shown below:

for v in bytearray(b'ABC'):
    print(v)
# 65
# 66
# 67

A bytearray can be unpacked with an assignment and for statement, function and * but not with ** as shown below:

v1, v2, v3 = bytearray(b'ABC')

print(v1, v2, v3)
# 65 66 67

v1, *v2, v3 = bytearray(b'ABCDEF')

print(v1, v2, v3)  # 65 [66, 67, 68, 69] 70
print(v1, *v2, v3) # 65 66 67 68 69 70

for v1, v2, v3 in [bytearray(b'ABC'), bytearray(b'DEF')]:
    print(v1, v2, v3)
# 65 66 67
# 68 69 70

for v1, *v2, v3 in [bytearray(b'ABCDEF'), bytearray(b'GHIJKL')]:
    print(v1, v2, v3)
    print(v1, *v2, v3)
# 65 [66, 67, 68, 69] 70
# 65 66 67 68 69 70
# 71 [72, 73, 74, 75] 76
# 71 72 73 74 75 76

def func(p1='a', p2='b', p3='c', p4='d', p5='e', p6='f'):
    print(p1, p2, p3, p4, p5, p6)

func()
# a b c d e f

func(*bytearray(b'ABCD'), *bytearray(b'EF'))
# 65 66 67 68 69 70

def func(p1='a', p2='b', *args):
    print(p1, p2, args)
    print(p1, p2, *args)
    print(p1, p2, [0, 1, *args, 2, 3])

func()
# a b ()
# a b
# a b [0, 1, 2, 3]

func(*bytearray(b'ABCD'), *bytearray(b'EF'))
# 65 66 (67, 68, 69, 70)
# 65 66 67 68 69 70
# 65 66 [0, 1, 67, 68, 69, 70, 2, 3]

print(*bytearray(b'ABCD'), *bytearray(b'EF'))
# 65 66 67 68 69 70

print([*bytearray(b'ABCD'), *bytearray(b'EF')])
# [65, 66, 67, 68, 69, 70]

An empty bytearray is False as shown below:

print(bool(bytearray(b''))) # Empty bytearray
# False

print(bool(bytearray(b' '))) # bytearray
# True

A bytearray can be checked if a specific element is in the bytearray with in keyword as shown below:

v = bytearray(b'ABCD')

print(bytearray(b'B') in v)
# True

print(bytearray(b'CD') in v)
# True

print(bytearray(b'b') in v)
# False

A bytearray can be enlarged with * and a number as shown below:

v = bytearray(b'ABCDE') * 3

print(v)
# bytearray(b'ABCDEABCDEABCDE')

v = bytearray(b'01234') * 3

print(v)
# bytearray(b'012340123401234')

v = bytearray(b'') * 3

print(v)
# bytearray(b'')

Be careful, a huge bytearray gets I/O error as shown below:

v = bytearray(b'ABCDE') * 1000000000

print(v)
# MemoryError

A bytearray can be used with len() to get the length as shown below:

v = bytearray(b"Let's go!")

print(len(v))
# 9