First of all passing an integer(say n) to bytes() simply returns an bytes string of n length with null bytes. So, that's not what you want here:

Either you can do:

>>> bytes([5]) #This will work only for range 0-256.
b'\x05'

Or:

>>> bytes(chr(5), 'ascii')
b'\x05'

As @simonzack already mentioned, bytes are immutable, so to update (or better say re-assign) its value, you need to use the += operator.

>>> s = b'\x01\x02\x03'
>>> s += bytes([5])     #or s = s + bytes([5])
>>> s
b'\x01\x02\x03\x05'

>>> s = b'\x01\x02\x03'
>>> s += bytes(chr(5), 'ascii')   ##or s = s + bytes(chr(5), 'ascii')
>>> s
b'\x01\x02\x03\x05'

Help on bytes():

>>> print(bytes.__doc__)
bytes(iterable_of_ints) -> bytes
bytes(string, encoding[, errors]) -> bytes
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
bytes(int) -> bytes object of size given by the parameter initialized with null bytes
bytes() -> empty bytes object

Construct an immutable array of bytes from:
  - an iterable yielding integers in range(256)
  - a text string encoded using the specified encoding
  - any object implementing the buffer API.
  - an integer

Or go for the mutable bytearray if you need a mutable object and you're only concerned with the integers in range 0-256.

newba += fileba [0] should be newba.append(fileba[0])

newba += baelement should be newba.append(baelement)

This is because += and .extend() expect iterables.

bytearray[x] returns an int object which is not iterable -- unless x is a slice, like [0:10], in which case another bytearray is returned.

for x in bytearray also returns int objects for x.

.append, however, will accept a non-iterable object -- in fact, .append throws if not passed an integer or string of size 1

TypeError: an integer or string of size 1 is required

.extend and += work for an iterable, though, like newba.extend(fileba[0:10]) or newba += fileba[0:10]

newba += b'\xC0' works because a str object is iterable, even if only a single character in length.

EDIT: s/length/size/

what about simply constructing your frame from a standard list ?

frame = bytes([0xA2,0x01,0x02,0x03,0x04])

the bytes() constructor can build a byte frame from an iterable containing int values. an iterable is anything which implements the iterator protocol: an list, an iterator, an iterable object like what is returned by range()...

I recently had this problem myself and this is what worked for me. Instead of instantiating a bytearray, I just initialized my buffer as a byte object:

buf = b""    #Initialize byte object

  poll = uselect.poll()
  poll.register(uart, uselect.POLLIN)

  while True:
    ch = uart.read(1) if poll.poll() else None

    if ch == b'x':
      buf += ch       #append the byte character to the buffer

    if ch == b'y':
      buf = buf[:-1]  #remove the last byte character from the buffer

    if ch == b'\015': ENTER
      break

0x01 << 8 = 0x0100
0X0100 | 0X01 = 0X0101

You can use this two operation.

<< 8 for shift 8 bit or one byte

| for merging.

a = b'0x04'
a << 8
b'0x0400'

A bytes object is immutable just like a string. Every time you do a += something, Python is creating a new object, copying a + something into it, and then assigning it to a.

You will be better using the bytearray type which is a mutable sequence and supports an append method.