Introduction

numpy.genfromtxt can read from any file-like object, not just a real file on disk. In Python 3, io.StringIO is the standard way to wrap a text string so genfromtxt can parse it as if it were reading from a file.

The Basic Pattern

Import StringIO from io, wrap the string, and pass the resulting object to genfromtxt.

1from io import StringIO
2import numpy as np
3
4data = """1,2,3
54,5,6
67,8,9
7"""
8
9buffer = StringIO(data)
10array = np.genfromtxt(buffer, delimiter=",")
11
12print(array)

Output:

[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]

That is the core answer: in Python 3, use io.StringIO, not the older Python 2 StringIO module layout.

Why StringIO Works

StringIO gives you an in-memory text stream. From genfromtxt's point of view, it behaves enough like a file object to be read line by line.

This is useful when the source data comes from:

• an HTTP response body
• generated text in memory
• unit-test fixtures
• a larger pipeline where writing a temporary file would be unnecessary

It keeps the parsing flow simple and avoids disk I/O.

Named Columns Example

genfromtxt becomes especially handy when the text includes headers.

1from io import StringIO
2import numpy as np
3
4data = """name,score
5alice,10
6bob,20
7"""
8
9buffer = StringIO(data)
10array = np.genfromtxt(buffer, delimiter=",", names=True, dtype=None, encoding="utf-8")
11
12print(array["name"])
13print(array["score"])

With names=True, the first row is used as column names.

Handle Missing Values

One reason people choose genfromtxt over loadtxt is that it handles missing fields more gracefully.

1from io import StringIO
2import numpy as np
3
4data = """1,2,3
54,,6
67,8,9
7"""
8
9buffer = StringIO(data)
10array = np.genfromtxt(buffer, delimiter=",", filling_values=-1)
11
12print(array)

This is useful when the in-memory text comes from messy external data.

Reset the Buffer if You Read It Twice

Like a real file, a StringIO object has a cursor. Once genfromtxt reads it, the cursor is at the end.

1from io import StringIO
2import numpy as np
3
4buffer = StringIO("1,2\n3,4\n")
5print(np.genfromtxt(buffer, delimiter=","))
6
7buffer.seek(0)
8print(np.genfromtxt(buffer, delimiter=","))

If you forget seek(0), the second read may return nothing because the stream is already exhausted.

StringIO Versus BytesIO

Use StringIO for text strings. Use BytesIO only when the input is raw bytes and the consumer expects bytes.

For genfromtxt, text is usually the right fit, so StringIO is the normal answer.

from io import StringIO

buffer = StringIO("1,2,3\n4,5,6\n")

If you already have bytes, decode them first unless you have a specific reason to manage them as bytes.

Common Pitfalls

The biggest mistake is importing the wrong StringIO. In Python 3, use from io import StringIO.

Another issue is forgetting that the stream cursor moves as it is read. If you want to parse the same in-memory buffer twice, call seek(0) first.

Developers also sometimes use loadtxt when the data contains headers or missing fields. genfromtxt is usually the better tool in those messier cases.

Finally, make sure the delimiter and encoding match the input text. Parsing failures are often just mismatched assumptions about the source format.

Summary

• In Python 3, wrap the text with io.StringIO and pass that object to numpy.genfromtxt.
• 'StringIO lets genfromtxt read in-memory text as if it were a file.'
• Use names=True for header rows and filling_values for missing data.
• Reset the stream with seek(0) if you need to read it again.
• Use StringIO for text, not BytesIO, unless your data source is truly byte-oriented.