I suggest several possible solutions.

One solution is to write custom code to slurp in the input file. I would suggest putting a special line before each JSON object in the file, such as: ###

Then you could write code like this:

import json

def json_get_objects(f):
    temp = ''
    line = next(f)  # pull first line
    assert line == SPECIAL_LINE

    for line in f:
        if line != SPECIAL_LINE:
            temp += line
        else:
            # found special marker, temp now contains a complete JSON object
            j = json.loads(temp)
            yield j
            temp = ''
    # after loop done, yield up last JSON object
    if temp:
        j = json.loads(temp)
        yield j

with open("specs_data.txt", "r") as f:
    for j in json_get_objects(f):
        pass # do something with JSON object j

Two notes on this. First, I am simply appending to a string over and over; this used to be a very slow way to do this in Python, so if you are using a very old version of Python, don't do it this way unless your JSON objects are very small. Second, I wrote code to split the input and yield up JSON objects one at a time, but you could also use a guaranteed-unique string, slurp in all the data with a single call to f.read() and then split on your guaranteed-unique string using the str.split() method function.

Another solution would be to write the whole file as a valid JSON list of valid JSON objects. Write the file like this:

{"mylist":[
# first JSON object, followed by a comma
# second JSON object, followed by a comma
# third JSON object
]}

This would require your file appending code to open the file with writing permission, and seek to the last ] in the file before writing a comma plus newline, then the new JSON object on the end, and then finally writing ]} to close out the file. If you do it this way, you can use json.loads() to slurp the whole thing in and have a list of JSON objects.

Finally, I suggest that maybe you should just use a database. Use SQLite or something and just throw the JSON strings in to a table. If you choose this, I suggest using an ORM to make your life simple, rather than writing SQL commands by hand.

Personally, I favor the first suggestion: write in a special line like ###, then have custom code to split the input on those marks and then get the JSON objects.

EDIT: Okay, the first suggestion was sort of assuming that the JSON was formatted for human readability, with a bunch of short lines:

{
    "foo": 0,
    "bar": 1,
    "baz": 2
}

But it's all run together as one big long line:

{"foo":0,"bar":1,"baz":2}

Here are three ways to fix this.

0) write a newline before the ### and after it, like so:

###
{"foo":0,"bar":1,"baz":2}
###
{"foo":0,"bar":1,"baz":2}

Then each input line will alternately be ### or a complete JSON object.

1) As long as SPECIAL_LINE is completely unique (never appears inside a string in the JSON) you can do this:

with open("specs_data.txt", "r") as f:
    temp = f.read()  # read entire file contents
    lst = temp.split(SPECIAL_LINE)
    json_objects = [json.loads(x) for x in lst]
    for j in json_objects:
        pass # do something with JSON object j

The .split() method function can split up the temp string into JSON objects for you.

2) If you are certain that each JSON object will never have a newline character inside it, you could simply write JSON objects to the file, one after another, putting a newline after each; then assume that each line is a JSON object:

import json

def json_get_objects(f):
    for line in f:
        if line.strip():
            yield json.loads(line)

with open("specs_data.txt", "r") as f:
    for j in json_get_objects(f):
        pass # do something with JSON object j

I like the simplicity of option (2), but I like the reliability of option (0). If a newline ever got written in as part of a JSON object, option (0) would still work, but option (2) would error.

Again, you can also simply use an actual database (SQLite) with an ORM and let the database worry about the details.

Good luck.

I've got a file with hundreds of JSON lines in it.

No you don't, and that's the problem.

Hundreds of JSON texts is not a valid JSON file. A valid JSON file is just one text. Which is why json.load is returning an error.

Hundreds of JSON texts that each fit on exactly one line with newlines in between them is a valid file in other formats like JSONlines or NDJ. It's still not a valid JSON file, so you can't use json.load, but you could use a JSONlines or NDJ library, or just parse it like this:

with open('fixed.json') as f:
    for line in f:
        data = json.loads(line)
        # do stuff

For writing a JSONlines file, again, you can use a JSONlines library, or you can just make sure that each JSON text has no embedded newlines—which actually happens by default, if you don't specify non-default ensure_ascii or indent parameters—and just write out json.dumps(data) + "\n" for each value.

But hundreds of JSON texts that each take up multiple lines isn't a valid anything file.

This is actually explained in the json module docs:

Note Unlike pickle and marshal, JSON is not a framed protocol, so trying to serialize multiple objects with repeated calls to dump() using the same fp will result in an invalid JSON file.

What "not a framed protocol" means is basically that the format would be ambiguous. For example, if you did a json.dump(2, f), and then a json.dump(3, f), what you'd get in your file is 23. Which is the same thing you get from json.dump(23, f).

If you can fix your file to be something valid, like JSONlines, that's the easy solution.

If you can't…

Well, pre-standardization, there was a concept of "JSON document", which meant basically a JSON text that's either an Array or Object. And a stream of JSON documents is not ambiguous.

Since this isn't a standard format, you're probably not going to find a parser for it, so you'll have to write one yourself.

One way you can do that is by using the raw_decode method in the json module. This will try to decode a JSON text, possibly with extra stuff after it, and also return the index to that extra stuff. Which, in your case, is the next JSON document.

Since hundreds of objects of that size isn't too big, it's probably simpler to just read the whole file into memory and then parse it, so we don't have to worry about buffering:

with open('fixed.json') as f:
    contents = f.read()
decoder = json.JSONDecoder()
while contents:
    data, idx = decoder.raw_decode(contents)
    do_stuff(data)
    contents = contents[idx:].lstrip()

Remember that this will only work if your file is a stream of JSON documents—that is, the top-level values are always Array or Object. Also, if you're editing these files by hand, unlike JSONlines, which can skip one bad text and continue to parse the rest, there's now way to recover from an error here, because you have no idea where the next document starts.

You should add second loop and iterate matches:

for rounds in js['rounds']:
    for matches in rounds['matches']:
        print(matches['team1']['name'])

json_formatted_str is a string, and iterating through a string will yield the individual characters. You probably want something like for line in json_formatted_str.split("\n")

Iterate through .values():

import json

with open('data.json') as data_file:    
    data = json.load(data_file)
    for v in data.values():
        print(v['x'], v['y'], v['yr'])

The solution of diek is the one that worked for me, edited my post because of this. The better code is:

import requests
import json
response = requests.get("")
data =response.text
parsed=json.loads(data)

for product in parsed['products']:
    print(product['id'])

The output will look as follow:

66057248
66057245
66057242
66057239
66057236
66057233
66057230
66057227
66057224

If you want to produce valid JSON file you need to write all values at once, not one value at a time (which will produce ndjson or JSON lines)

So, for a valid JSON

values = [{"first_name": "John", "last_name": "Smith", "food": "corn"},
          {"first_name": "Jane", "last_name": "Doe", "food": "soup"}]

import json
with open('some_file.json', 'w') as f:
    json.dump(values, f, indent=4)

some_file.json

[
    {
        "first_name": "John",
        "last_name": "Smith",
        "food": "corn"
    },
    {
        "first_name": "Jane",
        "last_name": "Doe",
        "food": "soup"
    }
]

if you really need ndjson - you can use ndjson package (need install via pip from PyPi).

import ndjson

with open('some_file2.ndjson', 'w') as f:
    ndjson.dump(values, f)

some_file2.ndjson

{"first_name": "John", "last_name": "Smith", "food": "corn"}
{"first_name": "Jane", "last_name": "Doe", "food": "soup"}

Alternative to ndjson package is jsonlines package

You have a JSON Lines format text file. You need to parse your file line by line:

import json

data = []
with open('file') as f:
    for line in f:
        data.append(json.loads(line))

Each line contains valid JSON, but as a whole, it is not a valid JSON value as there is no top-level list or object definition.

Note that because the file contains JSON per line, you are saved the headaches of trying to parse it all in one go or to figure out a streaming JSON parser. You can now opt to process each line separately before moving on to the next, saving memory in the process. You probably don't want to append each result to one list and then process everything if your file is really big.

If you have a file containing individual JSON objects with delimiters in-between, use How do I use the 'json' module to read in one JSON object at a time? to parse out individual objects using a buffered method.

Your question is a little unclear. If you're generating hostDict in a loop:

with open('data.txt', 'a') as outfile:
    for hostDict in ....:
        json.dump(hostDict, outfile)
        outfile.write('\n')

If you mean you want each variable within hostDict to be on a new line:

with open('data.txt', 'a') as outfile:
    json.dump(hostDict, outfile, indent=2)

When the indent keyword argument is set it automatically adds newlines.

The problem is that you are appending to data multiple times in the loop: first {"id":feature.pk}, then {attribute.attribute.name : attribute.value} in the inner loop.

Instead, you need to define a dictionary inside the loop, fill it with id item and attributes and only then append:

data=[]
for feature in features_selected:
    item = {"id": feature.pk}
    for attribute in attributes_selected:
        if attribute.feature == feature:
            item[attribute.attribute.name] = attribute.value
    data.append(item)

jsonData=json.dumps(data)

That's because you used string. How about that:

for i in range(10):
    json_Daten2[i] = {"ID": i}