You don't necessarily have to convert the image to normalised floats. You have it in the correct shape (MxNx3) and in the correct range (0-255), but it must be of type np.uint8. From the documentation

X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4)

Display the image in X to current axes. X may be a float array, a uint8 array or a PIL image. If X is an array, it can have the following shapes:

MxN – luminance (grayscale, float array only)
MxNx3 – RGB (float or uint8 array)
MxNx4 – RGBA (float or uint8 array)

However, your array data is in BGR format, so you need to reverse the third dimension to bring it to RGB format.

image = np.array(M, dtype=np.uint8)[...,::-1]

Another aspect that caught my attention is your definition of the data. The list of lists represents the rows first, so M actually has red/green in the first row and blue/black in the second. If you want the pixels in the order you stated them, i.e., red/blue and green/black, you have to transpose the rows with the columns.

image_transp = np.transpose(image, (1, 0, 2))

Now you can plot whichever image representation is the correct one (image or image_transp). For the latter, you get

plt.imshow(image_transp, interpolation='none')

See How do I convert a numpy array to (and display) an image?

from PIL import Image
import numpy as np

w, h = 512, 512
data = np.zeros((h, w, 3), dtype=np.uint8)
data[256, 256] = [255, 0, 0]
img = Image.fromarray(data, 'RGB')
img.save('my.png')
img.show()

PIL and numpy are your friends here:

from PIL import Image
import numpy as np


pixels = [
   [(54, 54, 54), (232, 23, 93), (71, 71, 71), (168, 167, 167)],
   [(204, 82, 122), (54, 54, 54), (168, 167, 167), (232, 23, 93)],
   [(71, 71, 71), (168, 167, 167), (54, 54, 54), (204, 82, 122)],
   [(168, 167, 167), (204, 82, 122), (232, 23, 93), (54, 54, 54)]
]

# Convert the pixels into an array using numpy
array = np.array(pixels, dtype=np.uint8)

# Use PIL to create an image from the new array of pixels
new_image = Image.fromarray(array)
new_image.save('new.png')

EDIT:

A little fun with numpy to make an image of random pixels:

from PIL import Image
import numpy as np

def random_img(output, width, height):

    array = np.random.random_integers(0,255, (height,width,3))  

    array = np.array(array, dtype=np.uint8)
    img = Image.fromarray(array)
    img.save(output)


random_img('random.png', 100, 50)

You can do it with Pillow (PIL) library:

from PIL import Image
import numpy as np

path = 'image.png'
image = Image.open(path)
image = np.asarray(image)

Notice that returned arrays have a length of 4 because the ".png" format supports an additional Alpha channel (transparency), so it's RGBA. To get rid of this extra channel, you need to convert an image to RGB format first.

from PIL import Image
import numpy as np

path = 'image.png'
image = Image.open(path).convert('RGB')
image = np.asarray(image)

It is not efficient to place each pixel into an image with pillow. Creating an image from a numpy array is significantly faster than before. By faster, I mean the 3840x2160 image took minutes, but now takes 0.0117 seconds.

To create an array that can be converted to an image:

import numpy
pixels = numpy.zeros((height, width, 3), dtype=numpy.uint8)

Here, I run calculations on the GPU to create an image with the pixels array. To efficiently convert an array of pixels into an image:

from PIL import Image
image = Image.fromarray(pixels)