Buy Me a Coffee☕

*Memo for a bytes, bytearray and string:

• My post explains the bytes with indexing and slicing.
• My post explains bytes().
• My post explains a bytearray.
• My post explains a string.

*Memo for bytes and bytearray functions:

• My post explains encode() and decode().
• My post explains upper(), lower() and casefold().
• My post explains swapcase(), title() and capitalize().
• My post explains isupper(), islower() and istitle().
• My post explains count().
• My post explains index().
• My post explains rindex().
• My post explains find().
• My post explains rfind().
• My post explains split().
• My post explains rsplit().
• My post explains splitlines().
• My post explains partition().
• My post explains rpartition().
• My post explains join().
• My post explains replace().
• My post explains removeprefix() and removesuffix().
• My post explains startswith().
• My post explains endswith().
• My post explains center().
• My post explains ljust().
• My post explains rjust().
• My post explains zfill().
• My post explains expandtabs().
• My post explains strip().
• My post explains lstrip().
• My post explains rstrip().
• My post explains maketrans().
• My post explains translate().
• My post explains isdecimal(), isdigit() and isnumeric().
• My post explains isalpha() and isalnum().
• My post explains isascii(), isspace(), isprintable() and isidentifier().
• My post explains iskeyword() and issoftkeyword().
• My post explains ord(), sorted() and reversed().

*Memo for bytearray functions:

• My post explains append(), extend(), insert(), remove(), clear(), pop() and reverse().

*Memo for others:

• 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 dictionary (1).
• My post explains an iterator (1).

A bytes:

• is the sequence of zero or more bytes represented with ASCII characters and whose type is bytes for computer to understand:
  • Each byte must be between [0, 255] from 256 ASCII characters.
  • It's for computer to understand.
  • It's also called a byte string.
• shouldn't be huge not to get I/O error.
• is immutable so it cannot be changed.
• can be created by the bytes literal b or B with '', "", '''''' or """""" or bytes() with or without several types of values:
  • A bytes literal cannot be used for a docstring because it gets None.
  • b or B with '' or "" are for one line.
  • b or B with '''''' or """""" are for one or more lines.
  • For bytes(), 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 they're empty.
• can be checked if a specific element is or isn't in it with in keyword or not and in keyword respectively.
• can be checked if it is or isn't referred to by two variables with is keyword or not and is keyword respectively.
• can be enlarged with * and a number.
• can be read but cannot be changed by indexing or slicing.

Be careful, a huge byte string gets I/O error.

b or B with '', "", '''''' or """""" can create a bytes as shown below:

*Memo:

• \' is the escape sequence to output '.

v = b'' # Empty bytes v = b"Hello World" v = B'I\'m John.' v = B"I'm John." v = b'''I'm John.''' v = b"""I'm John.""" v = B'''Apple Orange Banana Kiwi''' v = b'Apple' b" Orange" b'''Banana''' B"""Kiwi""" v = b'''Apple Orange Banana Kiwi''' v = b""" Apple Orange Banana Kiwi """ b'These above get no error' b"These above get no error" b'''These above get no error''' b"""These above get no error""" b''' These above get no error ''' b""" These above get no error """ # No error  for v in b'ABC': pass v1, v2, v3 = b'ABC' v1, *v2, v3 = b'ABCDEF' for v1, v2, v3 in [b'ABC', b'DEF']: pass for v1, *v2, v3 in [b'ABCDEF', b'GHIJKL']: pass print([*b'ABC', *b'DE']) print(*b'ABC', *b'DE') v = b'ABC' * 3 v = b'012' * 3 v = b'' * 3 # No error  v = b"Lёт's gφ!" # Let's go! print(**b'ABCDEF') v = b'ABC' * 100000000 # Error 

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

v = b'' # Empty bytes  print(v) # b''  print(type(v)) # <class 'bytes'> 

v = b"Hello World" print(v) # b'Hello World' 

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

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

v = b'''Apple Orange Banana Kiwi''' print(v) # b'Apple\nOrange\nBanana\nKiwi' 

v = b""" Apple Orange Banana Kiwi """ print(v) # b'\nApple\n Orange\n Banana\n Kiwi\n' 

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

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

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

v1, v2, v3 = b'ABC' print(v1, v2, v3) # 65 66 67 

v1, *v2, v3 = 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 [b'ABC', b'DEF']: print(v1, v2, v3) # 65 66 67 # 68 69 70 

for v1, *v2, v3 in [b'ABCDEF', 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(*b'ABCD', *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 Nothing # a b [0, 1, 2, 3]  func(*b'ABCD', *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([*b'ABC', *b'DE']) # [65, 66, 67, 68, 69] 

print(*b'ABC', *b'DE') # 65 66 67 68 69 

print(**b'ABCDEF') # TypeError: print() argument after ** must be a mapping, not bytes 

An empty bytes is False as shown below:

print(bool(b'')) # Empty bytes # False  print(bool(b' ')) # bytes # True 

A bytes can be checked if a specific element is or isn't in it with in keyword or not and in keyword respectively as shown below:

v = b'ABCD' print(b'B' in v) # True  print(b'CD' in v) # True  print(b'b' in v) # False 

v = b'ABCD' print(b'B' not in v) # False  print(b'CD' not in v) # False  print(b'b' not in v) # True 

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

v = b'ABC' * 3 print(v) # b'ABCABCABC' 

v = b'012' * 3 print(v) # b'012012012' 

v = b'' * 3 print(v) # b'' 

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

v = b'ABC' * 100000000 print(v) # OSError: [Errno 29] I/O error