Как получить из JSON строки int и float?

Question

[EvaSpence]

Код парсит csv строку из лога, затем, переводит её в json и далее идет выгрузка данных БД.. вот .

Вопрос в том как сделать так чтобы тип данных был правильным? а то тут все String а нужно ,чтобы значения соответствовали там int, float .

Пример JSONа

{
"FileName": "fio-example",
"terse_version_3": "3",
"fio_version": "fio-3.27-12-gd7a2",
"jobname": "oltp_read_uniform",
"read_runtime_ms": "120001",
"read_slat_min_us": "3",
"read_slat_max_us": "662",
"read_slat_mean_us": "7.105567",
"read_clat_pct03": "10.000000%=89",
"read_tlat_min_us": "50",
"read_lat_max_us": "23256",
"read_lat_mean_us": "114.506388",
"read_lat_dev_us": "60.999852",
"write_clat_min_us": "0",
"write_clat_max_us": "0",
"write_clat_mean_us": "0.000000",
"write_clat_dev_us": "0.000000",
"write_clat_pct01": "1.000000%=0",
"write_clat_pct18": "0%=0",
"write_clat_pct19": "0%=0",
"write_clat_pct20": "0%=0",
"write_tlat_min_us": "0",
"write_lat_max_us": "0",
"write_lat_mean_us": "0.000000",
"write_lat_dev_us": "0.000000",
"write_bw_min_kb": "0",
"cpu_user": "2.976875%",
"cpu_sys": "9.288333%",
"cpu_csw": "8295390",
"cpu_mjf": "0",
"cpu_minf": "381",
"iodepth_1": "100.0%",
"iodepth_2": "0.0%",
"lat_100us": "50.52%",
"lat_250us": "49.00%",
"lat_500us": "0.24%",
"lat_750us": "0.01%",
"lat_1000us": "0.19%",

}

кусок кода :

MY_COL .PY ###########################################################

from sqlalchemy import create_engine, Column, Integer, String, DateTime, MetaData, Table
from migrate.changeset import *

def CreateTable(tblName,engine,cols):
    metadata = MetaData()

    data = Table(tblName, metadata,
                Column('FileName', String))

    for coli in cols:
        col = Column(coli.replace("\n", ""), String)
        data.append_column(col)

    metadata.create_all(engine)
    return data

V1.PY ##########################################################################

def makeJSON(colnames,vals):
    i = 0
    r = vals.split(';')
    res='{'
    for col in colnames:
        try:
            res=res+'"'+col.name+'":"'+r[i]+'",'
        except:
            res=res+'"'+col.name+'":"",'
        i+=1
    res=res[:-1]+'}'
    return res.replace("\n", "")

MAIN.PY #########################################################################

for pars_el in parsed_lst:
        try:
            js = v1.makeJSON(data.columns, tarshortname + pars_el)
            conn.execute(data.insert(), [json.loads(js)])
        except Exception as err:
            print(err)
            print('Произошла ошибка')
            session.close()
            exit(-1)

    session.commit()
    session.close()
    print('Файлы успешно обработаны')

Answer 1

[Vindicar]

При парсинге CSV смотреть, что за колонка, и менять ей тип данных.
Например, используя словарь:

transforms = {
"write_bw_min_kb": int,
"cpu_user": lambda s: float(s[:-1]), #перевод из % в числа
# и так далее
}
noop = lambda s: s #а это для тех позиций, которые следует оставить строками
#а при парсинге CSV делаешь так
transform = transforms.get(col.name, noop) #определяем метод преобразования
value = transform(r[i])
#дальше используешь value

Но вообще ручное формирование JSON вызывает недоумение. Это имеет смысл если у тебя гигабайты данных, но ты же формируешь его через конкатенацию строк, что дьявольски неэффективно и медленно.
Чем тебе не по нраву json.dumps()? Сформировал структуру данных, как она нужна, и сдампил.

Comments

[EvaSpence]

Тут тогда как лучше это в коде исправить чтобы все не сломать? :(
(там три питона)
https://drive.google.com/drive/folders/1IcMbzGRFlh...

[Vindicar]

Вообще с такими задачами иди на фриланс. Но я сегодня добрый, дам небольшой стартер.

import csv
import json
# описываем преобразования типов
noop = lambda s: s #неизвестные поля оставляем строкой
transforms = {
    #"FileName": str, #что нужно оставить строкой, можно не указывать
    "terse_version_3": int,
    "fio_version": str,
    "jobname": str,
    "read_runtime_ms": int,
    # и так далее, для каждого поля
}

data = [] #список с данными из csv
with open('source.csv', 'rt', encoding='utf-8', newline='') as csvfile:
    reader = csv.DictReader(csvfile, delimiter=';')
    #грузим строки из csv файла как словари
    #первая строка файла определит имена колонок!
    #настройки формата csv (разделитель и всё такое) - см. справку питона
    for row in reader: 
        transformed_row = {}
        for key, value in row.items():
            transform = transforms.get(key, noop) #как преобразовывать?
            try:
                # преобразовываем строку в значение
                transformed_row[key] = transform(value)
            except: #что ты хочешь сделать с некорректными значениями?
                transformed_row[key] = "" 
        data.append(transformed_row)
#структура данных готова, осталось сдампить в JSON
#если нужно вывести в файл
with open('result.json', 'wt', encoding='utf-8') as dst:
    json.dump(data, dst, ensure_ascii=False)
#если нужна именно строка
data_str = json.dumps(data, ensure_ascii=False)

Дорабатывай и отлаживай сам.

[o5a]

EvaSpence, если конечная цель - записать в БД, то нет смысла назначать типы данных, все равно они будут определяться по типу поля самой таблицы.

[EvaSpence]

o5a, Тут возник вопрос ,что можно ли будет при таком коде , потом сравнивать значения из БД ,чтобы не получилось так что мы сравниваем строки , а не значения 662 и 630.
"read_slat_max_us": "662" и "read_slat_max_us": "630"

[o5a]

EvaSpence, зависит от того, где сравнение производится. Если это запрос в базе данных (т.е. 'SELECT ... WHERE a = b'), то там будет использоваться тип поля таблицы (если цифровой, то и сравниваться будут как цифры).
Если же это просто результат курсора запроса из базы данных в питон, то изначально все данные приходят как строка (по крайней мере в sqlite). Соответственно и при сравнении в питоне это будут строки.
Можно указать параметры соединения, чтобы пытался определять тип передаваемых данных

sqlite3.connect(database_name, detect_types = sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)

тогда скорее всего тип будет передаваться правильный (т.е. int для integer в базе и т.п.)