15

De eenvoudigste manier om dit te doen is het deel van het dict te veranderen dat in datetime-formaat is in ISOFORMAT. Die waarde zal effectief een tekenreeks zijn in Isoformat waar JSON OK is.

v_dict = version.dict()
v_dict['created_at'] = v_dict['created_at'].isoformat()

16

Eigenlijk is het vrij eenvoudig.
Als u datums vaak serialiseert, werkt u dan met ze als snaren. Je kunt ze gemakkelijk terugzetten als DateDime-objecten indien nodig.

Als u meestal als dieetime-objecten moet werken, converteer ze dan als snaren voordat u het serialiseert.

import json, datetime
date = str(datetime.datetime.now())
print(json.dumps(date))
"2018-12-01 15:44:34.409085"
print(type(date))
<class 'str'>
datetime_obj = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S.%f')
print(datetime_obj)
2018-12-01 15:44:34.409085
print(type(datetime_obj))
<class 'datetime.datetime'>

Zoals u kunt zien, is de uitvoer in beide gevallen hetzelfde. Alleen het type is anders.

17

Probeer deze met een voorbeeld om het te ontleden:

#!/usr/bin/env python
import datetime
import json
import dateutil.parser  # pip install python-dateutil
class JSONEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return obj.isoformat()
        return super(JSONEncoder, self).default(obj)
def test():
    dts = [
        datetime.datetime.now(),
        datetime.datetime.now(datetime.timezone(-datetime.timedelta(hours=4))),
        datetime.datetime.utcnow(),
        datetime.datetime.now(datetime.timezone.utc),
    ]
    for dt in dts:
        dt_isoformat = json.loads(json.dumps(dt, cls=JSONEncoder))
        dt_parsed = dateutil.parser.parse(dt_isoformat)
        assert dt == dt_parsed
        print(f'{dt}, {dt_isoformat}, {dt_parsed}')
        # 2018-07-22 02:22:42.910637, 2018-07-22T02:22:42.910637, 2018-07-22 02:22:42.910637
        # 2018-07-22 02:22:42.910643-04:00, 2018-07-22T02:22:42.910643-04:00, 2018-07-22 02:22:42.910643-04:00
        # 2018-07-22 06:22:42.910645, 2018-07-22T06:22:42.910645, 2018-07-22 06:22:42.910645
        # 2018-07-22 06:22:42.910646+00:00, 2018-07-22T06:22:42.910646+00:00, 2018-07-22 06:22:42.910646+00:00
if __name__ == '__main__':
    test()

Antwoord 18

Als u het resultaat in een weergave gebruikt, moet u ervoor zorgen dat u een correct antwoord geeft. Volgens de API doet jsonify het volgende:

Creëert een reactie met de JSON-representatie van de gegeven argumenten
met een applicatie/json-mimetype.

Om dit gedrag met json.dumps na te bootsen, moet je een paar extra regels code toevoegen.

response = make_response(dumps(sample, cls=CustomEncoder))
response.headers['Content-Type'] = 'application/json'
response.headers['mimetype'] = 'application/json'
return response

Je moet ook een dictaat retourneren om het antwoord van jsonify volledig te repliceren. Het hele bestand ziet er dus zo uit

from flask import make_response
from json import JSONEncoder, dumps
class CustomEncoder(JSONEncoder):
    def default(self, obj):
        if set(['quantize', 'year']).intersection(dir(obj)):
            return str(obj)
        elif hasattr(obj, 'next'):
            return list(obj)
        return JSONEncoder.default(self, obj)
@app.route('/get_reps/', methods=['GET'])
def get_reps():
    sample = ['some text', <datetime object>, 123]
    response = make_response(dumps({'result': sample}, cls=CustomEncoder))
    response.headers['Content-Type'] = 'application/json'
    response.headers['mimetype'] = 'application/json'
    return response

Antwoord 19

Mijn oplossing …

from datetime import datetime
import json
from pytz import timezone
import pytz
def json_dt_serializer(obj):
    """JSON serializer, by macm.
    """
    rsp = dict()
    if isinstance(obj, datetime):
        rsp['day'] = obj.day
        rsp['hour'] = obj.hour
        rsp['microsecond'] = obj.microsecond
        rsp['minute'] = obj.minute
        rsp['month'] = obj.month
        rsp['second'] = obj.second
        rsp['year'] = obj.year
        rsp['tzinfo'] = str(obj.tzinfo)
        return rsp
    raise TypeError("Type not serializable")
def json_dt_deserialize(obj):
    """JSON deserialize from json_dt_serializer, by macm.
    """
    if isinstance(obj, str):
        obj = json.loads(obj)
    tzone = timezone(obj['tzinfo'])
    tmp_dt = datetime(obj['year'],
                      obj['month'],
                      obj['day'],
                      hour=obj['hour'],
                      minute=obj['minute'],
                      second=obj['second'],
                      microsecond=obj['microsecond'])
    loc_dt = tzone.localize(tmp_dt)
    deserialize = loc_dt.astimezone(tzone)
    return deserialize    

Ok, nu wat tests.

# Tests
now = datetime.now(pytz.utc)
# Using this solution
rsp = json_dt_serializer(now)
tmp = json_dt_deserialize(rsp)
assert tmp == now
assert isinstance(tmp, datetime) == True
assert isinstance(now, datetime) == True
# using default from json.dumps
tmp = json.dumps(datetime.now(pytz.utc), default=json_dt_serializer)
rsp = json_dt_deserialize(tmp)
assert isinstance(rsp, datetime) == True
# Lets try another timezone
eastern = timezone('US/Eastern')
now = datetime.now(eastern)
rsp = json_dt_serializer(now)
tmp = json_dt_deserialize(rsp)
print(tmp)
# 2015-10-22 09:18:33.169302-04:00
print(now)
# 2015-10-22 09:18:33.169302-04:00
# Wow, Works!
assert tmp == now

Antwoord 20

Hier is mijn volledige oplossing voor het converteren van datetime naar JSON en terug..

import calendar, datetime, json
def outputJSON(obj):
    """Default JSON serializer."""
    if isinstance(obj, datetime.datetime):
        if obj.utcoffset() is not None:
            obj = obj - obj.utcoffset()
        return obj.strftime('%Y-%m-%d %H:%M:%S.%f')
    return str(obj)
def inputJSON(obj):
    newDic = {}
    for key in obj:
        try:
            if float(key) == int(float(key)):
                newKey = int(key)
            else:
                newKey = float(key)
            newDic[newKey] = obj[key]
            continue
        except ValueError:
            pass
        try:
            newDic[str(key)] = datetime.datetime.strptime(obj[key], '%Y-%m-%d %H:%M:%S.%f')
            continue
        except TypeError:
            pass
        newDic[str(key)] = obj[key]
    return newDic
x = {'Date': datetime.datetime.utcnow(), 34: 89.9, 12.3: 90, 45: 67, 'Extra': 6}
print x
with open('my_dict.json', 'w') as fp:
    json.dump(x, fp, default=outputJSON)
with open('my_dict.json') as f:
    my_dict = json.load(f, object_hook=inputJSON)
print my_dict

Uitgang

{'Date': datetime.datetime(2013, 11, 8, 2, 30, 56, 479727), 34: 89.9, 45: 67, 12.3: 90, 'Extra': 6}
{'Date': datetime.datetime(2013, 11, 8, 2, 30, 56, 479727), 34: 89.9, 45: 67, 12.3: 90, 'Extra': 6}

JSON-bestand

{"Date": "2013-11-08 02:30:56.479727", "34": 89.9, "45": 67, "12.3": 90, "Extra": 6}

Hierdoor heeft mij in staat gesteld en exporteert u strings, inten, drijvers en datetime-objecten.
Het zou niet moeilijk moeten zijn om te strekken voor andere typen.

21

Converteer de datenaar string

date = str(datetime.datetime(somedatetimehere)) 

22

Over het algemeen zijn er verschillende manieren om datetimes te serialiseren, zoals:

1. ISO-string, kort en kan timezone-info bevatten, b.v. @ Jgbarah’s antwoord
2. Tijdstempel (tijdzone-gegevens zijn verloren), b.v. @ Jaytaylor’s Antwoord
3. Woordenboek van eigenschappen (inclusief timezone).

Als je akkoord gaat met de laatste manier, verwerkt het json_tricks-pakket datums, tijden en datetimes inclusief tijdzones.

from datetime import datetime
from json_tricks import dumps
foo = {'title': 'String', 'datetime': datetime(2012, 8, 8, 21, 46, 24, 862000)}
dumps(foo)

wat geeft:

{"title": "String", "datetime": {"__datetime__": null, "year": 2012, "month": 8, "day": 8, "hour": 21, "minute": 46, "second": 24, "microsecond": 862000}}

Dus alles wat je hoeft te doen is

`pip install json_tricks`

en importeer vervolgens uit json_tricksin plaats van json.

Het voordeel van het niet opslaan als een enkele string, int of float komt bij het decoderen: als je alleen een string of vooral int of float tegenkomt, moet je iets over de gegevens weten om te weten of het een datetime is. Als dictaat kun je metadata opslaan zodat deze automatisch kan worden gedecodeerd, wat json_tricksvoor je doet. Het is ook gemakkelijk te bewerken voor mensen.

Disclaimer: het is door mij gemaakt. Omdat ik hetzelfde probleem had.

Antwoord 23

Volgens het antwoord van @jjmontes heb ik de volgende aanpak gebruikt.
Voor kolf- en kolfrustgevende gebruikers

# get json string
jsonStr = json.dumps(my_dictionary, indent=1, sort_keys=True, default=str)
# then covert json string to json object
return json.loads(jsonStr)

Antwoord 24

Ik heb hetzelfde foutmelding tijdens het schrijven van de serialize decorator in een klas met Sqlalchemy. Dus in plaats van:

Class Puppy(Base):
    ...
    @property
    def serialize(self):
        return { 'id':self.id,
                 'date_birth':self.date_birth,
                  ...
                }

Ik heb gewoon het idee van Jgbarah geleend van het gebruik van isoformat () en de oorspronkelijke waarde bijgehouden met isoformat (), zodat het er nu uitziet:

                 ...
                 'date_birth':self.date_birth.isoformat(),
                  ...

25

Een snelle oplossing als u uw eigen formattering wilt

for key,val in sample.items():
    if isinstance(val, datetime):
        sample[key] = '{:%Y-%m-%d %H:%M:%S}'.format(val) #you can add different formating here
json.dumps(sample)

26

Als u aan beide zijden van de communicatie bevindt, kunt u REP () en EVAL () -functies samen met JSON gebruiken.

import datetime, json
dt = datetime.datetime.now()
print("This is now: {}".format(dt))
dt1 = json.dumps(repr(dt))
print("This is serialised: {}".format(dt1))
dt2 = json.loads(dt1)
print("This is loaded back from json: {}".format(dt2))
dt3 = eval(dt2)
print("This is the same object as we started: {}".format(dt3))
print("Check if they are equal: {}".format(dt == dt3))

U moet DATETIME niet importeren als

from datetime import datetime

Aangezien EVAL zal klagen. Of u kunt DATETIME doorgeven als een parameter voor EVAL. In ieder geval zou dit moeten werken.

27

Ik had hetzelfde probleem tegengekomen bij het externaliseren van Django-modelobject om te dumpen als JSON.
Hier is hoe je het kunt oplossen.

def externalize(model_obj):
  keys = model_obj._meta.get_all_field_names() 
  data = {}
  for key in keys:
    if key == 'date_time':
      date_time_obj = getattr(model_obj, key)
      data[key] = date_time_obj.strftime("%A %d. %B %Y")
    else:
      data[key] = getattr(model_obj, key)
  return data

28

def j_serial(o):     # self contained
    from datetime import datetime, date
    return str(o).split('.')[0] if isinstance(o, (datetime, date)) else None

Gebruik van bovenstaande hulpprogramma:

import datetime
serial_d = j_serial(datetime.datetime.now())
if serial_d:
    print(serial_d)  # output: 2018-02-28 02:23:15

29

deze bibliotheek superjson kan het doen. En je kunt eenvoudig JSON Serializer op maat maken voor je eigen Python-object door deze instructie te volgen https: // superjson. leeshedocs.io/index.html#extend .

Het algemene concept is:

Uw code moet de juiste serialisatie / deserialisatiemethode vinden op basis van het Python-object. Meestal is de volledige Classname een goede identifier.

En dan moet uw SER / Deser-methode uw object kunnen transformeren naar een gewone JSON-serialiseerbare object, een combinatie van generiek Python-type, DICT, lijst, string, int, float. En implementeer uw Deser-methode omkeerig.