The Pythonic way is to write a generator function. Since this generator handles a file resource which needs to be closed afterwards, we should wrap it in a contextmanager, and consume the chunks within a with block.

from contextlib import contextmanager

@contextmanager
def file_chunks(filename, chunk_size):
    f = open(filename, 'rb')
    try:
        def gen():
            b = f.read(chunk_size)
            while b:
                yield b
                b = f.read(chunk_size)
        yield gen()
    finally:
        f.close()

Usage:

with file_chunks('test.raw', 160) as chunks:
    for chunk in chunks:
        # process the chunk
        print(chunk)

You can read your data as a text file instead of binary file.

Here's how:

file = open("/dev/rtlightsensor0", "r")
line = file.readline()
data = [int(each) for each in line.split())

Original answer:

You didn't describe your question clearly enough, but I'm guessing that you have four 32-bit (4 bytes) int in your file, which you want to read into your program.

os.read is a binary file read function, so the variable data you got is bytes instead of a list of numbers.

Python can't infer the length your number as it can be four 32-bit numbers, one 128-bit number, or something else. You need to define it explicitly.

There is also the issue of whether your data are big endian or little endian.

If your data doesn't come from a network communication, it's likely to be little endian. If you find the result from the following code is wrong (for example, unbelievably large), you can try to convert 'big' into 'little'.

You can finish your code like this:

dev = os.open("/dev/rtlightsensor0", os.0_RDWR)
raw_data = os.read(dev,16)
data = []
data.append(int.from_bytes(raw_data[0:4], 'little'))
data.append(int.from_bytes(raw_data[4:8], 'little'))
data.append(int.from_bytes(raw_data[8:12], 'little'))
data.append(int.from_bytes(raw_data[12:16], 'little'))
print(data)

However, DO NOT do it like that because it's really silly. If you can understand the code above, then you can write it better like this:

dev = os.open("/dev/rtlightsensor0", os.0_RDWR)
raw_data = os.read(dev, 16)
data = [int.from_bytes(raw_data[i * 4: (i + 1) * 4], 'little') for i in range(4)]
print(data)

By the way, it's not wise to read binary data like this. Generally speaking, the package numpy is recommended.

with open('binary.txt',"rb",buffering=-1) as f:
    for line in f:
        for c in line:
            print(c)

With a file like:

"abcde"

Produces

>>> 
97
98
99
100
101

The optional buffering argument is described here:

buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:

•Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s “block size” and falling back on DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.

Python io.open

And if you were really keen and planned on manipulating them, you can convert each line into a bytearray

line = bytearray(line)

To answer your comment this demonstrates how to filter out which characters you iterate over:

with open('binary.txt',"rb",buffering=-1) as f:
    for line in f:
        for c in [b for b in line if b in range(663,765)]: #in a certain range
            print(c)
        for c in [b for b in line if b == 5]: #is a certain number
            print(c)

What you're doing is already the right way. Quoting from this answer: How to read large file, line by line in python

The with statement handles opening and closing the file, including if an exception is raised in the inner block. The for line in f treats the file object f as an iterable, which automatically uses buffered IO and memory management so you don't have to worry about large files.

You want readlines (plural), not readline.
readline reads one line and returns it (so you wind up iterating over the characters in a string, one at a time), while readlines returns each line of the file, one after another.
Line-by-line iteration is the default for file objects (and StringIO objects), so you could just use

for x in buf:
    print(x)  # you may want to print x[:-1] to avoid extra newlines

You can use buffered input from io with bytearray:

import io

buf = bytearray(1024)
with io.open(filename, 'rb') as fp:
    size = fp.readinto(buf)
    if not size:
       break

    # do things with buf considering the size