Python json loads error - Исправление ошибок и поиск оптимальных решений проблем

JSONDecodeError: Expecting value: line 1 column 1 (char 0) occurs while working with JSON (JavaScript Object Notation) format. You might be storing some data or trying to fetch JSON data from an API(Application Programming Interface). In this guide, we will discuss where it can creep in and how to resolve it.

How can JSONDecodeError: Expecting value: line 1 column 1 (char 0) occur?
- 1. Non-JSON conforming quoting
- 2. Empty JSON file
- 3. XML output (that is, a string starting with <)
Resolving JSONDecodeError: Expecting value: line 1 column 1 (char 0)
- 1. Solution for Non-JSON conforming quoting
- 2. Solution for empty JSON file
- 3. Solution for XML output(that is, a string starting with <)
JSONDecodeError: Expecting value: line 1 column 1 (char 0) Django
Are you facing this error in Flask?
FAQs
Conclusion JSONDecodeError: Expecting value: line 1 column 1 (char 0)
Trending Python Articles

JSONDecodeError means there is an incorrect JSON format being followed. For instance, the JSON data may be missing a curly bracket, have a key that does not have a value, and data not enclosed within double-quotes or some other syntactic error.

A JSON file example

Generally, the error expecting value: line 1 column 1 (char 0) error can occur due to the following reasons.

Non-JSON conforming quoting
Empty JSON file
XML output (that is, a string starting with <)

Let’s elaborate on the points stated above:

1. Non-JSON conforming quoting

JSON or JavaScript Object Notation has a similar format to that of the python dictionary datatype. A dictionary requires a key or value to be enclosed in quotes if it is a string. Similarly, the JSON standard defines that keys need not be a string. However, keys should always be enclosed within double quotes. Not following this standard can also raise an error.

Keys must be double-quoted in JSON

2. Empty JSON file

For this example, we have taken an empty JSON file named test.py and another file named test.py, which contains the code given below. Using context manager, we open the JSON file in reading mode and load it using the load method. However, an error is thrown because the JSON file is empty.

import json

with open("test.json", "r") as file:
    data = json.load(file)

print("Data retrieved")

Empty JSON file causes an error

3. XML output (that is, a string starting with <)

The Extensible Markup Language, or simply XML, is a simple text-based format for representing structured information: documents, data, configuration, books, transactions, invoices, and much more. Similar to JSON, it is an older way of storing data. Earlier APIs used to return data in XML format; however, JSON is nowadays the preferred choice. Let’s see how we can face the expecting value: line 1 column 1 (char 0) type error in this case.

<part number="1976">
  <name>Windscreen Wiper</name>
  <description>The Windscreen wiper
    automatically removes rain
    from your windscreen, if it
    should happen to splash there.
    It has a rubber <ref part="1977">blade</ref>
    which can be ordered separately
    if you need to replace it.
  </description>
</part>

import json
with open("test.xml", "r") as file:
    data = json.load(file)
print("Data retrieved")

Let’s break down what is happening here.

For ease of example, suppose API returns an XML format data, as shown above.
Now, when we try to load that response from API, we will get a type error.

XML response causes an error

Resolving JSONDecodeError: Expecting value: line 1 column 1 (char 0)

1. Solution for Non-JSON conforming quoting

To resolve the type error in this case, you need to ensure that the keys and values are enclosed within the double quotes. This is necessary because it is a part of JSON syntax. It is important to realize that JSON only uses double quotes, not single quotes.

Use double quotes for enclosing keys and values

2. Solution for empty JSON file

The solution for this is self-evident in the name. To resolve the type error, in this case, make sure that the JSON file or the response from an API is not empty. If the file is empty, add content to it, and for a response from an API, use try-except to handle the error, which can be empty JSON or a 404 error, for instance.

import json
import requests


def main():
    URL = "https://api.dictionaryapi.dev/api/v2/enties/en/"
    word = input("Enter a word:")
    data = requests.get(url + word)
    data = data.text
    try:
        data_json = json.loads(data)
        print(data_json)
    except json.JSONDecodeError:
        print("Empty response")


if __name__ == "__main__":
    main()

The above code takes in a word and returns all the information related to it in a JSON format. Now in order to show how we can handle the Expecting value: line 1 column 1 (char 0) type error, we have altered the URL. entries have been changed to enties. Therefore we will get an invalid response which will not be of the JSON format. However, this is merely done to imitate the error when you might get an invalid response from an API.

Now, if you try to run the code above, you will be prompted to enter a word. The response is saved into the data variable and later converted to a string.
However, in the try block json.loads method, which parses JSON string to python dictionary raises an error.
This is because the response sent by API is not of JSON format, hence can’t be parsed, resulting in JSONDecodeError.
JSONDecodeError gets handled by the try-except block, and a “Response content is not valid JSON” gets printed as an outcome.

The response content is not valid JSON

Response when everything runs correctly.

3. Solution for XML output(that is, a string starting with <)

To avoid type errors resulting from an XML format, we will convert it to a JSON format. However, firstly install this library.

pip install xmltodict

import json
import xmltodict

with open("test.xml", "r") as file:
    data = xmltodict.parse(file.read())
    file.close()

    json_data = json.dumps(data)
    with open("t.json", "w") as json_file:
        json_file.write(json_data)
        json_file.close()
print("Data retrieved")
print(data)

Let’s elaborate on the code above:

We have imported two libraries, namely JSON and xmltodict.
Using the context manager with, XML file test.xml is opened in read mode. Thereafter using the xmltodict parse method, it is converted to a dictionary type, and the file is closed.
json.dumps() takes in a JSON object and returns a string of that object.
Again using context manager with, a JSON file is created, XML data that was converted to a JSON string is written on it, and the file is closed.

XML data converted into JSON format

JSONDecodeError: Expecting value: line 1 column 1 (char 0) Django

This issue is caused by the failure of Pipenv 2018.10.9. To resolve this issue, use Pipenv 2018.5.18. For more, read here.

Are you facing this error in Flask?

Many times, when you receive the data from HTTP requests, they are fetched as bytes. So, if you face JSONDecodeError, you might be dealing with a JSON in bytes. First, you need to decode the JSON by using response.decode('utf-8'). This will create a string, and then you can parse it.

FAQs

How to parse JSON in python?

json.loads() method can be used to parse JSON in python. For instance:
import json json_string = '{"a":"1", "b":"2", "c":"3"}' json_to_dict = json.loads(json_string) print(json_to_dict) print(type(json_to_dict))

How to detect empty file/string before parsing JSON?

import os file_path = "/home/nikhilomkar/Desktop/test.json" print("File is empty!" if os.stat(file_path).st_size == 0 else "File isn't empty!")
The following code checks if the file is empty and prints the File is empty! If true, else, the File isn’t empty!.

Conclusion JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The following article discussed the JSONDecodeError: Expecting value: line 1 column 1 (char 0). This error is due to various decoding and formatting errors. We looked at likely situations where it can occur and how to resolve it.

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

In Python, JSONDecodeError occurs when there is an issue with the formatting of the JSON data. This specific error tells us the JSON decoder has encountered an empty JSON.

Example #1: Incorrect use of json.loads()

Let’s look at an example where we have a JSON file with the following contents:

[
        {"margherita":7.99},
        {"pepperoni":9.99},
        {"four cheeses":10.99}
]

We want to read the data into a program using the json library. Let’s look at the code:

import json

json_path = 'pizza.json'

data = json.loads(json_path)

In the above code, we try to read the data in using json.loads(). Let’s run the code to see the result:

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The error occurs because json.loads() expects a JSON encoded string, not a filename. The string pizza.json is not a valid JSON encoded string.

Solution

We need to use json.load() instead of json.loads() to read a file. Let’s look at the revised code:

import json

json_path = 'pizza.json'

with open(json_path, 'r') as f:

    data = json.loads(f.read())

print(data)

In the above code, we use the open() function to create a file object that json.load() can read and return the decoded data object. The with statement is a context manager that ensures that the file is closed once the code is complete. Let’s run the code to see the result:

[{'margherita': 7.99}, {'pepperoni': 9.99}, {'four cheeses': 10.99}]

Example #2: Empty JSON file

Let’s look at an example where we have an empty file, which we will try to read in using json.loads(). The file is called particles.json. Since the JSON file is empty, the JSON decoder will throw the JSONDecodeError when it tries to read the file’s contents. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:
    contents = json.loads(f.read())
    print(contents)

---------------------------------------------------------------------------
JSONDecodeError                           Traceback (most recent call last)
Input In [1], in <cell line: 5>()
      3 filename = 'particles.json'
      5 with open(filename, 'r') as f:
----> 6     contents = json.loads(f.read())
      7     print(contents)

File ~/opt/anaconda3/lib/python3.8/json/__init__.py:357, in loads(s, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)
    352     del kw['encoding']
    354 if (cls is None and object_hook is None and
    355         parse_int is None and parse_float is None and
    356         parse_constant is None and object_pairs_hook is None and not kw):
--> 357     return _default_decoder.decode(s)
    358 if cls is None:
    359     cls = JSONDecoder

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:337, in JSONDecoder.decode(self, s, _w)
    332 def decode(self, s, _w=WHITESPACE.match):
    333     """Return the Python representation of ``s`` (a ``str`` instance
    334     containing a JSON document).
    335 
    336     """
--> 337     obj, end = self.raw_decode(s, idx=_w(s, 0).end())
    338     end = _w(s, end).end()
    339     if end != len(s):

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:355, in JSONDecoder.raw_decode(self, s, idx)
    353     obj, end = self.scan_once(s, idx)
    354 except StopIteration as err:
--> 355     raise JSONDecodeError("Expecting value", s, err.value) from None
    356 return obj, end

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Solution

If the file is empty, it is good practice to add a try-except statement to catch the JSONDecodeError. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

File is empty

Now we have verified the file is empty, we can add some content to the file. We will add three particle names together with their masses.

[
        {"proton":938.3},
        {"neutron":939.6},
        {"electron":0.51}
]

Let’s try to read the JSON file into our program and print the contents to the console:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

[{'proton': 938.3}, {'neutron': 939.6}, {'electron': 0.51}]

We successfully read the contents of the file into a list object.

Example #3: Response Request

Let’s look at an example where we want to parse a JSON response using the requests library. We will send a RESTful GET call to a server, and in return, we get a response in JSON format. The requests library has a built-in JSON decoder, response.json(), which provides the payload data in the JSON serialized format.

We may encounter a response that has an error status code or is not content-type application/json. We must check that the response status code is 200 (OK) before performing the JSON parse. Let’s look at the code to check the response has the 200 status code and has the valid content type. application/json.

import requests

from requests.exceptions import HTTPError

url = 'https://httpbin.org/get'

try:

    response = requests.get(url)

    status = response.status_code

    if (status != 204 and response.headers["content-type"].strip().startswith("application/json")):

        try:

            json_response = response.json()

            print(json_response)

        except ValueError:
            
            print('Bad Data from Server. Response content is not valid JSON')

    elif (status != 204):

        try:

            print(response.text)

        except ValueError:

            print('Bad Data From Server. Reponse content is not valid text')

except HTTPError as http_err:

    print(f'HTTP error occurred: {http_err}')

except Exception as err:

    print(f'Other error occurred: {err}')

In the above example, we use httpbin.org to execute a GET call. Let’s run the code to get the result:

{'args': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.27.1', 'X-Amzn-Trace-Id': 'Root=1-6265a5c1-3b57327c02057a3a39ffe86d'}, 'origin': '90.206.95.191', 'url': 'https://httpbin.org/get'}

Summary

Congratulations on reading to the end of this tutorial! The JSONDecodeError: Expecting value: line 1 column 1 (char 0) occurs either when data is not present in a file, the JSON string is empty, or the payload from a RESTful call is empty.

You can resolve this error by checking the JSON file or string for valid content and using an if-statement when making a RESTful call to ensure the status code is 200 and the content type is application/json.

For further reading on errors involving JSON, go to the articles:

How to Solve Python ValueError: Trailing data
How to Solve Python JSONDecodeError: extra data
How to Solve Python TypeError: Object of type datetime is not JSON serializable
How to Solve Python JSONDecodeError: Expecting ‘,’ delimiter: line 1

Have fun and happy researching!

Источник

Почему при выполнении кода возникает ошибка?

File «/home/olga/.pyenv/versions/3.9.0/lib/python3.9/json/decoder.py», line 353, in raw_decode
obj, end = self.scan_once(s, idx)
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

import json 

old = str({"1": "red", "2": "black", "3": "green"})
new = json.loads(old)

Вопрос задан

более двух лет назад
901 просмотр

Потому что строковое представление словаря — это не JSON.

потому что JSON не соответствует стандарту — не те кавычки.
А так заработает:

import json 

old = json.dumps({"1": "red", "2": "black", "3": "green"})
new = json.loads(old)

В файле data.txt у нас такая строка:
{'1': 'red', '2': 'black', '3': 'green'}
Тогда можно прочитать словарь из файла так:

import json 

with open('data.txt') as file:
	data = file.read()

json_data = json.loads(data)
print(type(json_data))
print(json_data)

Вот что на выходе:

<class 'dict'>
{'1': 'red', '2': 'black', '3': 'green'}

import json 

old = json.dumps({"1": "red", "2": "black", "3": "green"}, indent = 4)
new = json.loads(old)

print(new['1'])

How To Convert Python Dictionary To JSON?

Пригласить эксперта

Показать ещё
Загружается…

10 февр. 2023, в 02:20

3000 руб./за проект

10 февр. 2023, в 01:33

1500 руб./за проект

10 февр. 2023, в 00:54

2000 руб./в час

Минуточку внимания

Источник

Source code: Lib/json/__init__.py

JSON (JavaScript Object Notation), specified by
RFC 7159 (which obsoletes RFC 4627) and by
ECMA-404,
is a lightweight data interchange format inspired by
JavaScript object literal syntax
(although it is not a strict subset of JavaScript [1] ).

json exposes an API familiar to users of the standard library
marshal and pickle modules.

Encoding basic Python object hierarchies:

>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print(json.dumps(""foobar"))
""foobar"
>>> print(json.dumps('u1234'))
"u1234"
>>> print(json.dumps('\'))
"\"
>>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
{"a": 0, "b": 0, "c": 0}
>>> from io import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'

Compact encoding:

>>> import json
>>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))
'[1,2,3,{"4":5,"6":7}]'

Pretty printing:

>>> import json
>>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
{
    "4": 5,
    "6": 7
}

Decoding JSON:

>>> import json
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
['foo', {'bar': ['baz', None, 1.0, 2]}]
>>> json.loads('"\"foo\bar"')
'"foox08ar'
>>> from io import StringIO
>>> io = StringIO('["streaming API"]')
>>> json.load(io)
['streaming API']

Specializing JSON object decoding:

>>> import json
>>> def as_complex(dct):
...     if '__complex__' in dct:
...         return complex(dct['real'], dct['imag'])
...     return dct
...
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
...     object_hook=as_complex)
(1+2j)
>>> import decimal
>>> json.loads('1.1', parse_float=decimal.Decimal)
Decimal('1.1')

Extending JSONEncoder:

>>> import json
>>> class ComplexEncoder(json.JSONEncoder):
...     def default(self, obj):
...         if isinstance(obj, complex):
...             return [obj.real, obj.imag]
...         # Let the base class default method raise the TypeError
...         return json.JSONEncoder.default(self, obj)
...
>>> json.dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
['[2.0', ', 1.0', ']']

Using json.tool from the shell to validate and pretty-print:

$ echo '{"json":"obj"}' | python -m json.tool
{
    "json": "obj"
}
$ echo '{1.2:3.4}' | python -m json.tool
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

See Command Line Interface for detailed documentation.

Note

JSON is a subset of YAML 1.2. The JSON produced by
this module’s default settings (in particular, the default separators
value) is also a subset of YAML 1.0 and 1.1. This module can thus also be
used as a YAML serializer.

19.2.1. Basic Usage¶

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)¶

Serialize obj as a JSON formatted stream to fp (a .write()-supporting
file-like object) using this conversion table.

If skipkeys is true (default: False), then dict keys that are not
of a basic type (str, int, float, bool,
None) will be skipped instead of raising a TypeError.

The json module always produces str objects, not
bytes objects. Therefore, fp.write() must support str
input.

If ensure_ascii is true (the default), the output is guaranteed to
have all incoming non-ASCII characters escaped. If ensure_ascii is
false, these characters will be output as-is.

If check_circular is false (default: True), then the circular
reference check for container types will be skipped and a circular reference
will result in an OverflowError (or worse).

If allow_nan is false (default: True), then it will be a
ValueError to serialize out of range float values (nan,
inf, -inf) in strict compliance of the JSON specification.
If allow_nan is true, their JavaScript equivalents (NaN,
Infinity, -Infinity) will be used.

If indent is a non-negative integer or string, then JSON array elements and
object members will be pretty-printed with that indent level. An indent level
of 0, negative, or "" will only insert newlines. None (the default)
selects the most compact representation. Using a positive integer indent
indents that many spaces per level. If indent is a string (such as "t"),
that string is used to indent each level.

Changed in version 3.2: Allow strings for indent in addition to integers.

If specified, separators should be an (item_separator, key_separator)
tuple. The default is (', ', ': ') if indent is None and
(',', ': ') otherwise. To get the most compact JSON representation,
you should specify (',', ':') to eliminate whitespace.

Changed in version 3.4: Use (',', ': ') as default if indent is not None.

If specified, default should be a function that gets called for objects that
can’t otherwise be serialized. It should return a JSON encodable version of
the object or raise a TypeError. If not specified, TypeError
is raised.

If sort_keys is true (default: False), then the output of
dictionaries will be sorted by key.

To use a custom JSONEncoder subclass (e.g. one that overrides the
default() method to serialize additional types), specify it with the
cls kwarg; otherwise JSONEncoder is used.

Changed in version 3.6: All optional parameters are now keyword-only.

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)¶: Serialize obj to a JSON formatted str using this conversion
table. The arguments have the same meaning as in
dump().

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.

Note

Keys in key/value pairs of JSON are always of the type str. When
a dictionary is converted into JSON, all the keys of the dictionary are
coerced to strings. As a result of this, if a dictionary is converted
into JSON and then back into a dictionary, the dictionary may not equal
the original one. That is, loads(dumps(x)) != x if x has non-string
keys.

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)¶

Deserialize fp (a .read()-supporting file-like object
containing a JSON document) to a Python object using this conversion
table.

object_hook is an optional function that will be called with the result of
any object literal decoded (a dict). The return value of
object_hook will be used instead of the dict. This feature can be used
to implement custom decoders (e.g. JSON-RPC
class hinting).

object_pairs_hook is an optional function that will be called with the
result of any object literal decoded with an ordered list of pairs. The
return value of object_pairs_hook will be used instead of the
dict. This feature can be used to implement custom decoders that
rely on the order that the key and value pairs are decoded (for example,
collections.OrderedDict() will remember the order of insertion). If
object_hook is also defined, the object_pairs_hook takes priority.

Changed in version 3.1: Added support for object_pairs_hook.

parse_float, if specified, will be called with the string of every JSON
float to be decoded. By default, this is equivalent to float(num_str).
This can be used to use another datatype or parser for JSON floats
(e.g. decimal.Decimal).

parse_int, if specified, will be called with the string of every JSON int
to be decoded. By default, this is equivalent to int(num_str). This can
be used to use another datatype or parser for JSON integers
(e.g. float).

parse_constant, if specified, will be called with one of the following
strings: '-Infinity', 'Infinity', 'NaN'.
This can be used to raise an exception if invalid JSON numbers
are encountered.

Changed in version 3.1: parse_constant doesn’t get called on ‘null’, ‘true’, ‘false’ anymore.

To use a custom JSONDecoder subclass, specify it with the cls
kwarg; otherwise JSONDecoder is used. Additional keyword arguments
will be passed to the constructor of the class.

If the data being deserialized is not a valid JSON document, a
JSONDecodeError will be raised.

Changed in version 3.6: All optional parameters are now keyword-only.

json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)¶

Deserialize s (a str, bytes or bytearray
instance containing a JSON document) to a Python object using this
conversion table.

The other arguments have the same meaning as in load(), except
encoding which is ignored and deprecated.

If the data being deserialized is not a valid JSON document, a
JSONDecodeError will be raised.

Changed in version 3.6: s can now be of type bytes or bytearray. The
input encoding should be UTF-8, UTF-16 or UTF-32.

19.2.2. Encoders and Decoders¶

class json.JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)¶

Simple JSON decoder.

Performs the following translations in decoding by default:

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

It also understands NaN, Infinity, and -Infinity as their
corresponding float values, which is outside the JSON spec.

object_hook, if specified, will be called with the result of every JSON
object decoded and its return value will be used in place of the given
dict. This can be used to provide custom deserializations (e.g. to
support JSON-RPC class hinting).

object_pairs_hook, if specified will be called with the result of every
JSON object decoded with an ordered list of pairs. The return value of
object_pairs_hook will be used instead of the dict. This
feature can be used to implement custom decoders that rely on the order
that the key and value pairs are decoded (for example,
collections.OrderedDict() will remember the order of insertion). If
object_hook is also defined, the object_pairs_hook takes priority.

Changed in version 3.1: Added support for object_pairs_hook.

parse_constant, if specified, will be called with one of the following
strings: '-Infinity', 'Infinity', 'NaN'.
This can be used to raise an exception if invalid JSON numbers
are encountered.

If strict is false (True is the default), then control characters
will be allowed inside strings. Control characters in this context are
those with character codes in the 0–31 range, including 't' (tab),
'n', 'r' and ''.

If the data being deserialized is not a valid JSON document, a
JSONDecodeError will be raised.

Changed in version 3.6: All parameters are now keyword-only.

decode(s)¶

Return the Python representation of s (a str instance
containing a JSON document).

JSONDecodeError will be raised if the given JSON document is not
valid.

raw_decode(s)¶

Decode a JSON document from s (a str beginning with a
JSON document) and return a 2-tuple of the Python representation
and the index in s where the document ended.

This can be used to decode a JSON document from a string that may have
extraneous data at the end.

class json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)¶

Extensible JSON encoder for Python data structures.

Supports the following objects and types by default:

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int- & float-derived Enums	number
True	true
False	false
None	null

Changed in version 3.4: Added support for int- and float-derived Enum classes.

To extend this to recognize other objects, subclass and implement a
default() method with another method that returns a serializable object
for o if possible, otherwise it should call the superclass implementation
(to raise TypeError).

If skipkeys is false (the default), then it is a TypeError to
attempt encoding of keys that are not str, int,
float or None. If skipkeys is true, such items are simply
skipped.

If ensure_ascii is true (the default), the output is guaranteed to
have all incoming non-ASCII characters escaped. If ensure_ascii is
false, these characters will be output as-is.

If check_circular is true (the default), then lists, dicts, and custom
encoded objects will be checked for circular references during encoding to
prevent an infinite recursion (which would cause an OverflowError).
Otherwise, no such check takes place.

If allow_nan is true (the default), then NaN, Infinity, and
-Infinity will be encoded as such. This behavior is not JSON
specification compliant, but is consistent with most JavaScript based
encoders and decoders. Otherwise, it will be a ValueError to encode
such floats.

If sort_keys is true (default: False), then the output of dictionaries
will be sorted by key; this is useful for regression tests to ensure that
JSON serializations can be compared on a day-to-day basis.

Changed in version 3.2: Allow strings for indent in addition to integers.

Changed in version 3.4: Use (',', ': ') as default if indent is not None.

Changed in version 3.6: All parameters are now keyword-only.

default(o)¶

Implement this method in a subclass such that it returns a serializable
object for o, or calls the base implementation (to raise a
TypeError).

For example, to support arbitrary iterators, you could implement default
like this:

def default(self, o):
   try:
       iterable = iter(o)
   except TypeError:
       pass
   else:
       return list(iterable)
   # Let the base class default method raise the TypeError
   return json.JSONEncoder.default(self, o)

encode(o)¶

Return a JSON string representation of a Python data structure, o. For
example:

>>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'

iterencode(o)¶

Encode the given object, o, and yield each string representation as
available. For example:

for chunk in json.JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

19.2.3. Exceptions¶

exception json.JSONDecodeError(msg, doc, pos)¶

Subclass of ValueError with the following additional attributes:

msg¶: The unformatted error message.

doc¶: The JSON document being parsed.

pos¶: The start index of doc where parsing failed.

lineno¶: The line corresponding to pos.

colno¶: The column corresponding to pos.

New in version 3.5.

19.2.4. Standard Compliance and Interoperability¶

The JSON format is specified by RFC 7159 and by
ECMA-404.
This section details this module’s level of compliance with the RFC.
For simplicity, JSONEncoder and JSONDecoder subclasses, and
parameters other than those explicitly mentioned, are not considered.

This module does not comply with the RFC in a strict fashion, implementing some
extensions that are valid JavaScript but not valid JSON. In particular:

Infinite and NaN number values are accepted and output;
Repeated names within an object are accepted, and only the value of the last
name-value pair is used.

Since the RFC permits RFC-compliant parsers to accept input texts that are not
RFC-compliant, this module’s deserializer is technically RFC-compliant under
default settings.

19.2.4.1. Character Encodings¶

The RFC requires that JSON be represented using either UTF-8, UTF-16, or
UTF-32, with UTF-8 being the recommended default for maximum interoperability.

As permitted, though not required, by the RFC, this module’s serializer sets
ensure_ascii=True by default, thus escaping the output so that the resulting
strings only contain ASCII characters.

Other than the ensure_ascii parameter, this module is defined strictly in
terms of conversion between Python objects and
Unicode strings, and thus does not otherwise directly address
the issue of character encodings.

The RFC prohibits adding a byte order mark (BOM) to the start of a JSON text,
and this module’s serializer does not add a BOM to its output.
The RFC permits, but does not require, JSON deserializers to ignore an initial
BOM in their input. This module’s deserializer raises a ValueError
when an initial BOM is present.

The RFC does not explicitly forbid JSON strings which contain byte sequences
that don’t correspond to valid Unicode characters (e.g. unpaired UTF-16
surrogates), but it does note that they may cause interoperability problems.
By default, this module accepts and outputs (when present in the original
str) code points for such sequences.

19.2.4.2. Infinite and NaN Number Values¶

The RFC does not permit the representation of infinite or NaN number values.
Despite that, by default, this module accepts and outputs Infinity,
-Infinity, and NaN as if they were valid JSON number literal values:

>>> # Neither of these calls raises an exception, but the results are not valid JSON
>>> json.dumps(float('-inf'))
'-Infinity'
>>> json.dumps(float('nan'))
'NaN'
>>> # Same when deserializing
>>> json.loads('-Infinity')
-inf
>>> json.loads('NaN')
nan

In the serializer, the allow_nan parameter can be used to alter this
behavior. In the deserializer, the parse_constant parameter can be used to
alter this behavior.

19.2.4.3. Repeated Names Within an Object¶

The RFC specifies that the names within a JSON object should be unique, but
does not mandate how repeated names in JSON objects should be handled. By
default, this module does not raise an exception; instead, it ignores all but
the last name-value pair for a given name:

>>> weird_json = '{"x": 1, "x": 2, "x": 3}'
>>> json.loads(weird_json)
{'x': 3}

The object_pairs_hook parameter can be used to alter this behavior.

19.2.4.4. Top-level Non-Object, Non-Array Values¶

The old version of JSON specified by the obsolete RFC 4627 required that
the top-level value of a JSON text must be either a JSON object or array
(Python dict or list), and could not be a JSON null,
boolean, number, or string value. RFC 7159 removed that restriction, and
this module does not and has never implemented that restriction in either its
serializer or its deserializer.

Regardless, for maximum interoperability, you may wish to voluntarily adhere
to the restriction yourself.

19.2.4.5. Implementation Limitations¶

Some JSON deserializer implementations may set limits on:

the size of accepted JSON texts
the maximum level of nesting of JSON objects and arrays
the range and precision of JSON numbers
the content and maximum length of JSON strings

This module does not impose any such limits beyond those of the relevant
Python datatypes themselves or the Python interpreter itself.

When serializing to JSON, beware any such limitations in applications that may
consume your JSON. In particular, it is common for JSON numbers to be
deserialized into IEEE 754 double precision numbers and thus subject to that
representation’s range and precision limitations. This is especially relevant
when serializing Python int values of extremely large magnitude, or
when serializing instances of “exotic” numerical types such as
decimal.Decimal.

Источник

In Python, You will get an error while retrieving the data from any 3rd party API request. In fact, when response content converts to JSON format using json.loads method, it throws an json.decoder.JSONDecodeError: Unexpected UTF-8 BOM error. In this article we are going to see how to fix json.loads() Unexpected UTF-8 BOM error in Python.

How to Fix json.loads Unexpected UTF-8 BOM error in Python. We have seen solutions to fix Unexpected UTF-8 BOM errors when using json.loads in Python.

The error was occur by the json.loads(r.text), so when text content convert to JSON format we have getting following error:

json.decoder.JSONDecodeError: Unexpected UTF-8 BOM (decode using utf-8-sig): line 1 column 1 (char 0)

The response content coming from the API, but ufeff Unicode character coming at the beginning. This Unicode character value ufeff (or xefxbbxbf in binary) is a byte order mark (BOM) character.

Python: Fix json.loads Unexpected json.decoder UTF-8 BOM Error

Following are 4 different solutions. Basically all following solutions we have to decode the data using utf-8-sign encoding. This way we can fix the error.

Solution 1 Decode content using utf-8-sig

In this solution, we can use decode() method on the return value of the string.encode() method. This is the most efficient solution to fix this error.

decoded_data = r.text.encode().decode('utf-8-sig')
data = json.loads(decoded_data)

Solution 2 Decode response content

This solution is a straightforward method to fix this issue. We have used the decode() method on r.content.

decoded_data = r.content.decode('utf-8-sig')
data = json.loads(decoded_data)

Solution 3 Encode requests.response object

In this solution, you can use the encoding property on the response object. This way we can skip the previous examples showing the calling of encode() and decode() methods.

r.encoding = 'utf-8-sig'
data = json.loads(r.text)

Solution 4 Use Python codecs module

You can use the Python codecs module. We can use the codecs.decode() method to decode the data using utf-8-sig encoding. The codecs.decode() method accepts a bytes object. Thus, you have to convert the string into a bytes object using encode() method.

decoded_data = codecs.decode(r.text.encode(), 'utf-8-sig')
data = json.loads(decoded_data)

Bottom Line

All in all, if the json.loads() method throws an unexpected UTF-8 BOM error. It means BOM values are existing in the response data. In this article we have seen 4 different solutions to rid out this json.loads Unexpected UTF-8 BOM error in Python.

Another most common error: object arrays cannot be loaded when allow_pickle=false. You can check fixexception to find an appropriate solution.

We hope you have found this article helpful. Let us know your questions or feedback if any through the comment section in below. You can subscribe our newsletter and get notified when we publish new articles. Moreover, you can explore here other interesting articles.

If you like our article, please consider buying a coffee for us.
Thanks for your support!

Buy me a coffee!

Источник

Table of Contents
Hide

JSONDecodeError: Expecting value: line 1 column 1 (char 0)
Example JSONDecodeError: Expecting value: line 1 column 1 (char 0)
Solution
Other Possible Solutions
1. Ensure HTTP 200 status code and valid content type as application/json
2. Invoke json.load() on the contents of the file

If you are working with APIs and trying to fetch and parse the JSON data while making the HTTP or curl requests and JSON response is not well-formed, Python will throw json.decoder.jsondecodeerror: expecting value: line 1 column 1 (char 0).

Let us take a look at the possible causes of JSONDecodeError and how we solve this issue in our code with some examples.

In most of cases, you get json.loads- JSONDecodeError: Expecting value: line 1 column 1 (char 0) error is due to :

The response might be in some other format such as XML, HTML, etc.
The JSON response is not structured properly.
The response type doesn’t come in the format of application/json. Rather it comes in string format, which in turn throws a JSONDecodeError while parsing the response.
Empty response
Invalid status code or httpx error

Also, read the Python JSONPath tutorial

Example JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Let me demonstrate with a simple example of replicating a JSONDecodeError, and we will look at solving the same.

In this example, we are trying to load a JSON file from the specified path and print the contents of the JSON file. However, since the JSON file is empty, the JSON module will throw a JSONDecodeError when we try to read the empty content. It always expects the proper JSON structure.

import json

file_path = "C:/Projects/Tryouts/books.json"

with open(file_path, 'r') as j:
     contents = json.loads(j.read())
     print(contents)

Output

Traceback (most recent call last):
  File "c:/Projects/Tryouts/main.py", line 6, in <module>
    contents = json.loads(j.read())
  File "C:UsersabcAppDataLocalProgramsPythonPython37libjson__init__.py", line 348, in loads    
    return _default_decoder.decode(s)
  File "C:UsersabcAppDataLocalProgramsPythonPython37libjsondecoder.py", line 337, in decode    
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "C:UsersabcAppDataLocalProgramsPythonPython37libjsondecoder.py", line 355, in raw_decode
    raise JSONDecodeError("Expecting value", s, err.value) from None
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The json.loads(j.read()) tries to load the JSON content and parse the JSON, and during that time, if it’s not well structured, you get a JSONDecodeError.

Note: In this case, if the JSON file is not found, you will get a FileNotFoundError: [Errno 2] No such file or directory

Solution

The solution is simple and straightforward. Validate if the file is not empty and has proper JSON content. Now that we have added the proper content to the books.json file when we run the same code again, we get the below output.

# Python program to solve JSONDecodeError: Expecting value: line 1 column 1 (char 0)
import json

file_path = "C:/Projects/Tryouts/books.json"

with open(file_path, 'r') as j:
     contents = json.loads(j.read())
     print(contents)

Output

{'category': 'reference', 'author': 'Nigel Rees', 'title': 'Sayings of the Century', 'isbn': '6-246-2356-8', 'price': 8.95}

1. Non-JSON conforming quoting

2. Empty JSON file

3. XML output (that is, a string starting with <)

Resolving JSONDecodeError: Expecting value: line 1 column 1 (char 0)

1. Solution for Non-JSON conforming quoting

2. Solution for empty JSON file

3. Solution for XML output(that is, a string starting with <)

JSONDecodeError: Expecting value: line 1 column 1 (char 0) Django

Are you facing this error in Flask?

FAQs

Conclusion JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Trending Python Articles

Table of contents

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Example #1: Incorrect use of json.loads()

Solution

Example #2: Empty JSON file

Solution

Example #3: Response Request

Summary

Минуточку внимания

19.2.1. Basic Usage¶

19.2.2. Encoders and Decoders¶

19.2.3. Exceptions¶

19.2.4. Standard Compliance and Interoperability¶

19.2.4.1. Character Encodings¶

19.2.4.2. Infinite and NaN Number Values¶

19.2.4.3. Repeated Names Within an Object¶

19.2.4.4. Top-level Non-Object, Non-Array Values¶

19.2.4.5. Implementation Limitations¶

Python: Fix json.loads Unexpected json.decoder UTF-8 BOM Error

Solution 1 Decode content using utf-8-sig

Solution 2 Decode response content

Solution 3 Encode requests.response object

Solution 4 Use Python codecs module

Bottom Line

Table of Contents Hide

Example JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Solution

Other Possible Solutions

Ensure HTTP 200 status code and valid content type as application/json

Invoke json.load() on the contents of the file

Sign Up for Our Newsletters

Table of Contents
Hide