A python list can contain disparately typed objects, e.g. X = ['apples', 'oranges',10]. If you do type([10]) you'll see the Python type for the container is technically called a list, not an array.

In contrast, in a numpy array all objects are of the same type, the dtype.

The docs are telling you that on creation of a numpy array, the dtype is set to the type that will hold all of the existing objects.

See, look:

the type will be determined as the minimum type required to hold the objects in the sequence

The writers perhaps should have added "and not their values"

We can make a uint8 ten easily enough:

ten = np.uint8(10)

If that is put into a Python list, it retains its type because Python lists preserve types. If that list is sent to numpy.array() to make a numpy array, then the numpy array will use dtype np.uint8 because it is big enough to hold all (1) of the pre-existing Python list objects.

In [49]: np.array([ten]).dtype
Out[49]: dtype('uint8')

But if we use a literal 10, python will create an int object for it instead of an np.uint8 because np.uint8 is peculiar to numpy and all 10 does is invoke python to create that number.

If we make a Python list containing a literal 10, we duplicate your result (with machine-architecture ints):

In [50]: np.array([10]).dtype
Out[50]: dtype('int64')

And if we put the two types together in a python list, and send that list to np.array for creation of a numpy array, then the dtype must be big enough to hold both objects, in this case int64.

In [51]: np.array([ten, 10]).dtype
Out[51]: dtype('int64')

Discovered that, despite not having dictionary methods like .items(), you can still call dtype['<column_name>'].

column_names = list(arr.dtype.names)
dtypes = [str(arr.dtype[n]) for n in column_names]

>>> dtypes

['float64', 'float64']

The following code might help:

import numpy as np

dt = np.dtype([('name1', '|S10'), ('name2', '<f8')])
tuplelist=[
    ('n1', 1.2),
    ('n2', 3.4),    
     ]
arr = np.array(tuplelist, dtype=dt)

print(arr['name1'])
# ['n1' 'n2']
print(arr['name2'])
# [ 1.2  3.4]

Your immediate problem was that np.dtype expects the format specifiers to be numpy types, such as '|S10' or '<f8' and not Python types, such as str or float. If you type help(np.dtype) you'll see many examples of how np.dtypes can be specified. (I've only mentioned a few.)

Note that np.array expects a list of tuples. It's rather particular about that.

A list of lists raises TypeError: expected a readable buffer object.

A (tuple of tuples) or a (tuple of lists) raises ValueError: setting an array element with a sequence.

The shape of an array is the number of elements, not bytes it contains. If your elements are all 57 bytes in size, then a 300x57 byte buffer is just the right size to initialize an array of size 300:

buff1_np = np.ndarray(300, dtype=onebuffdtype, buffer=shared_buff1.buf)