>>> import struct
>>> struct.pack('f', 3.141592654)
b'\xdb\x0fI@'
>>> struct.unpack('f', b'\xdb\x0fI@')
(3.1415927410125732,)
>>> struct.pack('4f', 1.0, 2.0, 3.0, 4.0)
'\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@'

It depends what you want, and what you are going to do with it. If all you want is a bytearray then:

import struct

value = 5.1

ba = bytearray(struct.pack("f", value))  

Where ba is a bytearray. However, if you wish to display the hex values (which I suspect), then:

print([ "0x%02x" % b for b in ba ])

This gives (for value 5.1):

['0x33', '0x33', '0xa3', '0x40']

However, CPython uses the C type double to store even small floats (there are good reasons for that), so:

value = 5.1
ba = bytearray(struct.pack("d", value))   
print([ "0x%02x" % b for b in ba ])

Gives:

['0x66', '0x66', '0x66', '0x66', '0x66', '0x66', '0x14', '0x40']

For detail see Python Struct. For your specific question:

import struct

# if input is string, per @robyschek will fail on python 3
data=b'\x64\xd8\x64\x3f'  
print struct.unpack('<f', data)   #little endian
print struct.unpack('>f', data)   # big endian

#your input  
list1=[0x64, 0xD8, 0x6E, 0x3F]
# aa=str(bytearray(list1))  # edit: this conversion wasn't needed
aa= bytearray(list1) 
print struct.unpack('<f', aa)
​

output:

(0.8939268589019775,)
(3.193376169798871e+22,)
(0.9329893589019775,)

Properties of a Python float can be requested via sys.float_info. It returns information such as max/min value, max/min exp value, etc. These properties can potentially be used to calculate the byte size of a float. I never encountered anything else than 64 bit, though, on many different architectures.

The items of a NumPy array might have different size, but you can check their size in bytes by a.itemsize, where a is a NumPy array.

Using struct

Base on the struct module documentation the struct.unpack() function must have defined exact format for unpacking multiple values at once. So if you need to use struct module, then you either have to define the format using format as '<ff' or iterate over the array using struct.iter_unpack(format, buffer).

Using array

Another option is to use array module, which allows you to decode the binary data at once. You can change endianness using array.byteswap() method. The only restriction is that the whole array must have same type.

import array

arr = array.array('f', b'\x00\x00\x80?\x00\x00\x00@')

arr.tolist()
# [1.0, 2.0]

# change endianness
arr.byteswap()

arr.tolist()
# [4.600602988224807e-41, 8.96831017167883e-44]

NumPy arrays come with a tobytes method that gives you a dump of their raw data bytes:

arr.tobytes()

You can specify an order argument to use either C-order (row major) or F-order (column major) for multidimensional arrays.

Since you want to dump the bytes to a file, you may also be interested in the tofile method, which dumps the bytes to a file directly:

arr.tofile(your_file)

tofile always uses C-order.

If you need to change endianness, you can use the byteswap method. (newbyteorder has a more convenient signature, but doesn't change the underlying bytes, so it won't affect tobytes.)

import sys
if sys.byteorder=='big':
    arr = arr.byteswap()
data_bytes = arr.tobytes()

Finally, I have also found this message by Ehud Karni on the mailing list. Indeed that code also gives you the correct numbers in hexadecimal. I will paste it here (it does not work when directly copy pasting from the mailing list message)

(defvar IEEE-sign-mlt 128 "multiplier for sign")                       ;  1 bits
(defvar IEEE-exp-bias 127 "exponent bias for float")                    ;  8 bits
(defvar IEEE-mantissa-divisor ?\x800000 "mantissa divisor for float")  ; 23 bits
(defvar IEEE-float-mantissa-divisor (/ 1.0 (float IEEE-mantissa-divisor))
  "floated 1 / mantissa divisor")


(defun IEEE-float-2-hex (FNUM)
  "Convert a floating point number FNUM to 8 Hex digits string (big endian)"
  (interactive "nEnter float to convert: ")
  (or (floatp FNUM)
      (setq FNUM (float FNUM)))
  (let ((IEEE-sign 0)
        (IEEE-exp  0)
        (IEEE-mantissa 0)
        hex)
    (and (< FNUM 0)                         ; negative
         (setq IEEE-sign IEEE-sign-mlt)      ; yes, sign=1 (* 2**7)
         (setq FNUM (- FNUM)))               ; negate (abs) it
    (cond
     ((= FNUM 0))                        ; Zero - we all set
     ((= FNUM 1e+INF)                    ; infinite ?
      (setq IEEE-exp IEEE-exp-bias))  ; exp = max, mantissa = 0

     (t                                  ;; real float
      (setq IEEE-exp (floor (log FNUM 2.0)))      ; exponent [ log 2 FNUM ] - integer
     (if (<= IEEE-exp (- IEEE-exp-bias))         ; check for De-normalized number
         (setq IEEE-exp 0                        ; really - 
           IEEE-exp-bias
               IEEE-mantissa (truncate (* IEEE-mantissa-divisor
                      0.5 FNUM (expt 2.0 IEEE-exp-bias))))
         ;; normal float
         (setq IEEE-mantissa (truncate (* IEEE-mantissa-divisor
                      (- (/ FNUM (expt 2.0 IEEE-exp)) 1))))
         (setq IEEE-exp (+ IEEE-exp IEEE-exp-bias))) ;; offset-ed exp
     ))
  (setq hex (format "%02X%06X" (+ IEEE-sign (/ IEEE-exp 2))
                    (+ IEEE-mantissa
                       (* (% IEEE-exp 2) 
              IEEE-mantissa-divisor))))

  ;;         (message "Float=%f sign=%d, exp=%d, mant=%d  HEX=%s"
  ;;                  FNUM IEEE-sign IEEE-exp IEEE-mantissa hex)

  (print hex)))

(defun IEEE-hex-2-float (HEX)
  "Convert an 8 Hex digits string (big endian) to floating point number"
  (interactive "sEnter hex value (8 hex digits): ")
  (if (or (not (stringp HEX))
          (/= (length HEX) 8)
          (string-match "[^0-9a-fA-F]" HEX))
      (error "Arg must be a string of EXACTLY 8 hex (1-8, a-f, A-F) 
digits"))

  (let ((S-EXP (string-to-number (substring HEX 0 2) 16))
        (MANTISSA (string-to-number (substring HEX 2) 16))
        (RSLT 1)
        IEEE-sign
        IEEE-exp
        IEEE-mantissa
        )
    (setq IEEE-mantissa (logior MANTISSA IEEE-mantissa-divisor)) ; always set upper bit
    (if (= IEEE-mantissa IEEE-mantissa-divisor)             ; = --> zero mantissa, check special cases
        (cond
         ((string-equal HEX "00000000")
          (setq RSLT (float 0)))      ; Zero
         ((string-equal HEX "3F800000")
          (setq RSLT  1e+INF))        ; + infinity
         ((string-equal HEX "BF800000")
          (setq RSLT -1e+INF))        ; - infinity
         ))
    (print (if (/= RSLT 1)
               RSLT                                            ; special cases (0, infinity)

         (setq IEEE-sign (ash S-EXP -7))                     ; shift right 7 bits
         (setq IEEE-exp (+ (ash (% S-EXP IEEE-sign-mlt) 1)   ; shift (part) exp 1
                               (ash MANTISSA -23)))              ; 1 bit from mantissa
         (if (= IEEE-exp 0)                                  ; De-normalized ?
         (setq IEEE-mantissa (ash
                      (logxor IEEE-mantissa IEEE-mantissa-divisor) 1))) ; clear upper bit
         ;;             (message "Hex=%s sign=%d, exp=%d, mant=%d"
         ;;                      HEX IEEE-sign IEEE-exp IEEE-mantissa)

         (*                                                  ; result float
          (- 1 IEEE-sign IEEE-sign)                       ; sign
          (expt 2.0 (- IEEE-exp IEEE-exp-bias))           ; 2 ** exponent (un-biased)
          (float IEEE-mantissa)                           ; mantissa part
          IEEE-float-mantissa-divisor                     ; 1 / mantissa divisor
          )))))

You will get the bytes in hexadecimal representation as a string. Unfortunately I don't know how to 'convert' those strings to hexadecimal numbers (starting with #x), but if you find a way to convert the hexadecimal strings to numbers, then you could use this solution also.