16.2-dars: json
16-QISM — MA'LUMOT FORMATLARI · 2-dars
1. Kirish va motivatsiya
JSON — zamonaviy dasturlashning "umumiy tili": veb API lar, sozlama fayllari, NoSQL bazalar, jurnallar 15.16-bob, brauzer va server orasidagi har bir so'rov. Python'da u bitta modul bilan: json.dumps va json.loads.
Oddiy ko'rinadi — lekin JSON va Python turlari bir xil emas. Tur mosligidagi har bir farq jim xatoga aylanishi mumkin.
Real vaziyat. To'lov xizmati summalarni JSON orqali boshqa xizmatga yuborardi:
json.dumps({"summa": hisob.summa}) # summa — floatOylik hisobotda bir necha tiyin farq chiqdi: 0.1 + 0.2 float'da 0.30000000000000004. Keyinroq ID lar JavaScript frontendga yuborildi — 12345678901234567890 kabi katta sonlar brauzerda oxirgi raqamlari o'zgarib ko'rindi. Uchinchi hodisa: NaN qiymatli o'lchov JSON ga yozildi, Python o'zi uni muammosiz qaytarib o'qidi, lekin Go'da yozilgan xizmat yiqildi — NaN JSON standartida yo'q. Va nihoyat, kimdir JSON ga bir xil kalitni ikki marta yozdi — Python jim oxirgisini oldi.
Bu darsda json ni to'liq o'rganamiz: tur mosligi, formatlash, maxsus turlar, xato xabarlari va xavfsiz qabul qilish.
Bu darsda:
-
dumps/loads,dump/loadva tur jadvali - Nima o'zgarib qaytadi: kortej, son kalitlar,
1vaTruekalitlari - Formatlash:
indent,sort_keys,separators,ensure_ascii - Standartdan tashqari:
NaN,Infinityvaallow_nan=False - Sonlar: float aniqligi,
parse_float=Decimal, JavaScript chegarasi - Takroriy kalitlar va
object_pairs_hook JSONDecodeError: qator, ustun, pozitsiya; BOM- Maxsus turlar:
JSONEncoder.default,object_hook - JSON Lines va
python -m json(3.14) - Amaliy: JSON Lines eksportini tekshiruvchi importyor
2. Nazariya — chuqur tushuntirish
2.1. Asosiy API
| Funksiya | Nima qiladi |
|---|---|
json.dumps(obyekt) |
Python → JSON satr |
json.loads(satr) |
JSON satr (yoki bytes) → Python |
json.dump(obyekt, fayl) |
Faylga yozish |
json.load(fayl) |
Fayldan o'qish |
with open("sozlama.json", "w", encoding="utf-8") as f:
json.dump(malumot, f, ensure_ascii=False, indent=2)
with open("sozlama.json", encoding="utf-8") as f:
malumot = json.load(f)2.2. Tur jadvali
| Python | JSON | Qaytib o'qilganda |
|---|---|---|
dict |
object | dict |
list |
array | list |
tuple |
array | list |
str |
string | str |
int |
number | int (istalgan kattalikda) |
float |
number | float |
True/False |
true/false |
bool |
None |
null |
None |
set, datetime, Decimal, bytes, obyektlar |
— | TypeError: Object of type ... is not JSON serializable |
Kalitlar:
| Python kaliti | JSON | Qaytganda |
|---|---|---|
"a" |
"a" |
"a" |
1 |
"1" |
"1" — satr |
2.5 |
"2.5" |
"2.5" |
True, None |
"true", "null" |
satr |
(1, 2) |
TypeError |
{1: "a", True: "b"} — Python'da 1 == True, demak bitta kalit; natija {"1": "b"}.
2.3. Formatlash
| Parametr | Ta'siri |
|---|---|
ensure_ascii=True (sukut) |
"Oʻ" → "O\u02bb" — xavfsiz, lekin o'qib bo'lmaydi |
ensure_ascii=False |
Belgilar o'zgarishsiz — faylga encoding="utf-8" bilan yozing |
indent=2 |
Odam o'qiydigan ko'rinish |
sort_keys=True |
Barqaror chiqish — git diff, xesh, testlar uchun |
separators=(",", ":") |
Eng ixcham (tarmoq uchun) |
default=f |
Seriyalanmaydigan obyektlar uchun funksiya |
2.4. Standartdan tashqari qiymatlar
JSON standarti (RFC 8259) NaN, Infinity, -Infinity ni qo'llamaydi. Python sukut bo'yicha ularni yozadi va o'qiydi — boshqa tillar esa rad etadi.
| Kod | Natija |
|---|---|
json.dumps(float("nan")) |
'NaN' — yaroqsiz JSON |
json.dumps(x, allow_nan=False) |
ValueError: Out of range float values are not JSON compliant |
json.loads("NaN") |
nan |
2.5. Sonlar
| Muammo | Tafsilot | Yechim |
|---|---|---|
| Float aniqligi | 0.1 + 0.2 = 0.30000000000000004 |
Pul — butun sonlarda (tiyin) yoki Decimal |
| O'qishda | json.loads("12650.50") → float |
parse_float=decimal.Decimal |
| Yozishda | Decimal — TypeError |
default da str(d) (satr sifatida) |
| JavaScript | Sonlar — IEEE 754 double: 2^53 - 1 = 9007199254740991 dan katta butun sonlar aniqligini yo'qotadi |
Katta ID lar — satr sifatida |
Python int |
Istalgan kattalikda — Python o'zi muammo sezmaydi |
2.6. Takroriy kalitlar va xatolar
json.loads('{"rol": "user", "rol": "admin"}') # {'rol': 'admin'} — jim oxirgisi Xavfsizlik muammosi: tekshiruvchi va ishlovchi turli parserlardan foydalansa, biri birinchi, boshqasi oxirgi qiymatni olishi mumkin. Yechim — object_pairs_hook bilan rad etish.
JSONDecodeError (ValueError vorisi):
| Atribut | Ma'nosi |
|---|---|
msg |
Sabab: Expecting property name enclosed in double quotes |
lineno, colno |
Qator va ustun (1 dan) |
pos |
Belgi pozitsiyasi (0 dan) |
| Kiritish | Xato |
|---|---|
{'a': 1} |
Qo'shtirnoq faqat " |
{"a": 1,} |
Illegal trailing comma |
[1] ortiqcha |
Extra data |
| BOM bilan satr | Unexpected UTF-8 BOM (decode using utf-8-sig) |
Izohlar // |
JSON da izoh yo'q |
2.7. Maxsus turlar
Yozish — JSONEncoder.default yoki default= funksiya: seriyalanmaydigan obyekt uchun chaqiriladi va JSON-mos qiymat qaytaradi.
class Kodlovchi(json.JSONEncoder):
def default(self, o):
if isinstance(o, datetime): return o.isoformat()
if isinstance(o, Decimal): return str(o)
return super().default(o) # ⭐ qolganlari — TypeError default=str — "hamma narsani satrga" — xatolarni yashiradi: noto'g'ri obyekt ham jim "<object at 0x...>" bo'lib yoziladi.
O'qish — object_hook(dict) -> obyekt har dict uchun chaqiriladi; object_pairs_hook(list[tuple]) — kalitlar tartibi va takrorlarini ham ko'radi.
JSON o'zi turlarni saqlamaydi: "2026-09-17" — satr. Qaytib o'qishda turlarni sxema (qaysi maydon qanday tur) asosida tiklash ishonchliroq — pydantic 13.8-bob yoki dataclass + tekshiruv.
2.8. JSON Lines va CLI
JSON Lines (.jsonl, NDJSON) — har qatorda bitta JSON obyekt:
| Afzallik | Nima beradi |
|---|---|
| Oqim bilan o'qish | Butun faylni xotiraga yuklamasdan |
| Oxiriga qo'shish | Faylni qayta yozmasdan |
| Xato izolyatsiyasi | Bitta buzilgan qator butun faylni yiqitmaydi |
| Jurnallar, eksport, ML datasetlar | Keng tarqalgan format |
CLI (3.14 dan python -m json, oldin python -m json.tool):
python -m json data.json # chiroyli chiqarish va tekshirish
python -m json --sort-keys --indent 2 < a.json
python -m json --json-lines log.jsonlYaroqsiz JSON da chiqish kodi 1 va xato joyi.
3. Tez ma'lumotnoma
import json
from decimal import Decimal
matn = json.dumps(malumot, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False)
malumot = json.loads(matn, parse_float=Decimal)
with open(yol, "w", encoding="utf-8") as f:
json.dump(malumot, f, ensure_ascii=False, indent=2)
with open(yol, encoding="utf-8-sig") as f:
malumot = json.load(f)
json.dumps(obyekt, cls=MeningKodlovchim)
json.loads(matn, object_pairs_hook=takrorsiz_dict)
for raqam, qator in enumerate(f, 1): # JSON Lines
yozuv = json.loads(qator)Qoidalar
faylga: ensure_ascii=False + encoding="utf-8"
barqaror chiqish: sort_keys=True
tashqi tizimga: allow_nan=False
pul: butun son yoki Decimal (satr sifatida)
katta ID — satr (JavaScript 2^53)
tashqi JSON: takroriy kalitlarni rad eting
default=str bilan hamma narsani yashirmang4. Batafsil misollar
Misol 1 — Tur mosligi va formatlash
"""dumps/loads; nima o'zgarib qaytadi; kalit turlari va 1/True to'qnashuvi; seriyalanmaydigan turlar; ensure_ascii, indent, sort_keys, separators; dump/load fayl bilan."""
import json
import tempfile
from pathlib import Path
def main() -> None:
print("=== 1. Aylanib qaytish ===")
asl = {"ism": "Oʻgʻiloy", "yosh": 25, "ballar": (87, 92), "faol": True, "telefon": None, "koeff": 1.5}
qaytgan = json.loads(json.dumps(asl))
for kalit in asl:
belgi = "✅" if asl[kalit] == qaytgan[kalit] and type(asl[kalit]) is type(qaytgan[kalit]) else "⚠️"
print(f" {belgi} {kalit:8} {asl[kalit]!r:12} → {qaytgan[kalit]!r:12} ({type(qaytgan[kalit]).__name__})")
print(f" butunlay teng: {asl == qaytgan}")
print("\n=== 2. ⚠️ Kalitlar ===")
print(f" {{1: 'a', 2.5: 'b', None: 'c'}} → {json.dumps({1: 'a', 2.5: 'b', None: 'c'})}")
qaytgan = json.loads(json.dumps({1: "bir"}))
print(f" qaytgan kalit turi: {type(next(iter(qaytgan))).__name__}, qaytgan[1] ishlaydimi: {1 in qaytgan}")
print(f" {{1: 'bir', True: 'rost'}} → {json.dumps({1: 'bir', True: 'rost'})} ← 1 == True, bitta kalit")
try:
json.dumps({(1, 2): "nuqta"})
except TypeError as xato:
print(f" kortej kalit → TypeError: {xato}")
print("\n=== 3. Seriyalanmaydigan turlar ===")
from datetime import date
from decimal import Decimal
for qiymat in ({1, 2}, date(2026, 9, 17), Decimal("12650.50"), b"baytlar"):
try:
json.dumps(qiymat)
except TypeError as xato:
print(f" {type(qiymat).__name__:8} → TypeError: {xato}")
print("\n=== 4. Formatlash ===")
malumot = {"shahar": "Toshkent", "aholi": 3_095_000, "tumanlar": ["Chilonzor", "Yunusobod"], "davlat": "Oʻzbekiston"}
print(f" sukut: {json.dumps(malumot)}")
print(f" ensure_ascii=False: {json.dumps(malumot, ensure_ascii=False)}")
print(f" ixcham: {json.dumps(malumot, ensure_ascii=False, separators=(',', ':'))}")
print(" indent=2, sort_keys=True:")
for qator in json.dumps(malumot, ensure_ascii=False, indent=2, sort_keys=True).splitlines():
print(f" {qator}")
print(f" sort_keys — kalit tartibidan qat'i nazar bir xil: "
f"{json.dumps({'b': 1, 'a': 2}, sort_keys=True) == json.dumps({'a': 2, 'b': 1}, sort_keys=True)}")
print("\n=== 5. Fayl bilan ===")
with tempfile.TemporaryDirectory() as katalog:
yol = Path(katalog) / "shahar.json"
with open(yol, "w", encoding="utf-8") as f:
json.dump(malumot, f, ensure_ascii=False, indent=2)
print(f" hajmi: {yol.stat().st_size} bayt, 'Oʻzbekiston' o'qiladigan holda: {'Oʻzbekiston' in yol.read_text(encoding='utf-8')}")
with open(yol, encoding="utf-8") as f:
print(f" load bilan teng: {json.load(f) == malumot}")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Aylanib qaytish ===
✅ ism 'Oʻgʻiloy' → 'Oʻgʻiloy' (str)
✅ yosh 25 → 25 (int)
⚠️ ballar (87, 92) → [87, 92] (list)
✅ faol True → True (bool)
✅ telefon None → None (NoneType)
✅ koeff 1.5 → 1.5 (float)
butunlay teng: False
=== 2. ⚠️ Kalitlar ===
{1: 'a', 2.5: 'b', None: 'c'} → {"1": "a", "2.5": "b", "null": "c"}
qaytgan kalit turi: str, qaytgan[1] ishlaydimi: False
{1: 'bir', True: 'rost'} → {"1": "rost"} ← 1 == True, bitta kalit
kortej kalit → TypeError: keys must be str, int, float, bool or None, not tuple
=== 3. Seriyalanmaydigan turlar ===
set → TypeError: Object of type set is not JSON serializable
date → TypeError: Object of type date is not JSON serializable
Decimal → TypeError: Object of type Decimal is not JSON serializable
bytes → TypeError: Object of type bytes is not JSON serializable
=== 4. Formatlash ===
sukut: {"shahar": "Toshkent", "aholi": 3095000, "tumanlar": ["Chilonzor", "Yunusobod"], "davlat": "O\u02bbzbekiston"}
ensure_ascii=False: {"shahar": "Toshkent", "aholi": 3095000, "tumanlar": ["Chilonzor", "Yunusobod"], "davlat": "Oʻzbekiston"}
ixcham: {"shahar":"Toshkent","aholi":3095000,"tumanlar":["Chilonzor","Yunusobod"],"davlat":"Oʻzbekiston"}
indent=2, sort_keys=True:
{
"aholi": 3095000,
"davlat": "Oʻzbekiston",
"shahar": "Toshkent",
"tumanlar": [
"Chilonzor",
"Yunusobod"
]
}
sort_keys — kalit tartibidan qat'i nazar bir xil: True
=== 5. Fayl bilan ===
hajmi: 136 bayt, 'Oʻzbekiston' o'qiladigan holda: True
load bilan teng: TrueNima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.
Misol 2 — Sonlar, standart va xatolar
"""NaN va Infinity; allow_nan=False; float va Decimal; JavaScript 2^53 chegarasi; takroriy kalitlar va object_pairs_hook; JSONDecodeError joylari; BOM."""
import json
from decimal import Decimal
JS_MAX = 2**53 - 1
def takrorsiz(juftlar: list[tuple[str, object]]) -> dict[str, object]:
kalitlar = [k for k, _ in juftlar]
takrorlar = sorted({k for k in kalitlar if kalitlar.count(k) > 1})
if takrorlar:
raise ValueError(f"takroriy kalitlar: {takrorlar}")
return dict(juftlar)
def main() -> None:
print("=== 1. ⚠️ NaN va Infinity ===")
olchovlar = {"harorat": 23.5, "namlik": float("nan"), "maks": float("inf")}
print(f" sukut: {json.dumps(olchovlar)} ← standart JSON emas")
try:
json.dumps(olchovlar, allow_nan=False)
except ValueError as xato:
print(f" allow_nan=False → ValueError: {xato}")
tozalangan = {k: (None if isinstance(v, float) and (v != v or v in (float('inf'), float('-inf'))) else v) for k, v in olchovlar.items()}
print(f" None ga almashtirilgan: {json.dumps(tozalangan, allow_nan=False)}")
print("\n=== 2. ⚠️ Float va Decimal ===")
matn = '{"narx": 0.1, "chegirma": 0.2}'
oddiy = json.loads(matn)
aniq = json.loads(matn, parse_float=Decimal)
print(f" float: {oddiy['narx'] + oddiy['chegirma']}")
print(f" Decimal: {aniq['narx'] + aniq['chegirma']}")
print(f" Decimal yozishda: {json.dumps({'summa': str(Decimal('12650.50'))})} ← satr sifatida")
print(f" ⭐ butun tiyinlarda: {json.dumps({'summa_tiyin': 1_265_050})}")
print("\n=== 3. ⚠️ JavaScript butun son chegarasi ===")
for id_ in (JS_MAX, JS_MAX + 2, 12345678901234567890):
js_korinish = int(float(id_)) # JavaScript double'da shunday bo'ladi
print(f" {id_:>22} → JS da {js_korinish:>22} aniq: {js_korinish == id_}")
print(f" Python o'zi muammo sezmaydi: {json.loads(json.dumps(12345678901234567890)) == 12345678901234567890}")
print(f" ⭐ yechim: {json.dumps({'id': str(12345678901234567890)})}")
print("\n=== 4. ⚠️ Takroriy kalitlar ===")
hujum = '{"foydalanuvchi": "aziz", "rol": "user", "rol": "admin"}'
print(f" json.loads: {json.loads(hujum)} ← jim oxirgisi")
try:
json.loads(hujum, object_pairs_hook=takrorsiz)
except ValueError as xato:
print(f" object_pairs_hook: ValueError: {xato}")
print("\n=== 5. JSONDecodeError ===")
for yomon in ("{'a': 1}", '{"a": 1,}', "[1, 2] ortiqcha", '{\n "ism": "Aziz",\n "yosh": 25\n "shahar": "Toshkent"\n}',
"", "// izoh\n{}"):
try:
json.loads(yomon)
except json.JSONDecodeError as xato:
print(f" {yomon.splitlines()[0][:18] if yomon else '(bo`sh)':20} → {xato.msg} (qator {xato.lineno}, ustun {xato.colno})".replace("`", "'"))
print(f" JSONDecodeError — ValueError vorisi: {issubclass(json.JSONDecodeError, ValueError)}")
print("\n=== 6. BOM ===")
bomli = "\ufeff" + '{"a": 1}'
try:
json.loads(bomli)
except json.JSONDecodeError as xato:
print(f" BOM li satr → {xato.msg}")
print(f" bytes sifatida (BOM tanib olinadi): {json.loads(bomli.encode('utf-8'))}")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. ⚠️ NaN va Infinity ===
sukut: {"harorat": 23.5, "namlik": NaN, "maks": Infinity} ← standart JSON emas
allow_nan=False → ValueError: Out of range float values are not JSON compliant: nan
None ga almashtirilgan: {"harorat": 23.5, "namlik": null, "maks": null}
=== 2. ⚠️ Float va Decimal ===
float: 0.30000000000000004
Decimal: 0.3
Decimal yozishda: {"summa": "12650.50"} ← satr sifatida
⭐ butun tiyinlarda: {"summa_tiyin": 1265050}
=== 3. ⚠️ JavaScript butun son chegarasi ===
9007199254740991 → JS da 9007199254740991 aniq: True
9007199254740993 → JS da 9007199254740992 aniq: False
12345678901234567890 → JS da 12345678901234567168 aniq: False
Python o'zi muammo sezmaydi: True
⭐ yechim: {"id": "12345678901234567890"}
=== 4. ⚠️ Takroriy kalitlar ===
json.loads: {'foydalanuvchi': 'aziz', 'rol': 'admin'} ← jim oxirgisi
object_pairs_hook: ValueError: takroriy kalitlar: ['rol']
=== 5. JSONDecodeError ===
{'a': 1} → Expecting property name enclosed in double quotes (qator 1, ustun 2)
{"a": 1,} → Illegal trailing comma before end of object (qator 1, ustun 8)
[1, 2] ortiqcha → Extra data (qator 1, ustun 8)
{ → Expecting ',' delimiter (qator 4, ustun 3)
(bo'sh) → Expecting value (qator 1, ustun 1)
// izoh → Expecting value (qator 1, ustun 1)
JSONDecodeError — ValueError vorisi: True
=== 6. BOM ===
BOM li satr → Unexpected UTF-8 BOM (decode using utf-8-sig)
bytes sifatida (BOM tanib olinadi): {'a': 1}Nima ko'rsatdi: 2.4, 2.5, 2.6-bo'limlar.
Misol 3 — Maxsus turlar: kodlash va tiklash
"""JSONEncoder.default: datetime, Decimal, UUID, set, Enum, dataclass; default=str xavfi; sxema asosida tiklash; object_hook; aylanib qaytish testi."""
import dataclasses
import json
import uuid
from datetime import UTC, date, datetime
from decimal import Decimal
from enum import Enum
class Holat(Enum):
YANGI = "yangi"
TOLANGAN = "tolangan"
@dataclasses.dataclass(frozen=True)
class Buyurtma:
id: uuid.UUID
mijoz: str
summa: Decimal
yaratilgan: datetime
yetkazish: date
teglar: frozenset[str]
holat: Holat
class Kodlovchi(json.JSONEncoder):
def default(self, o: object) -> object:
if isinstance(o, datetime | date):
return o.isoformat()
if isinstance(o, Decimal):
return str(o)
if isinstance(o, uuid.UUID):
return str(o)
if isinstance(o, set | frozenset):
return sorted(o)
if isinstance(o, Enum):
return o.value
if dataclasses.is_dataclass(o) and not isinstance(o, type):
return {f.name: getattr(o, f.name) for f in dataclasses.fields(o)}
return super().default(o)
def buyurtma_tikla(d: dict) -> Buyurtma:
"""Sxema asosida: har maydon qaysi turga aylanishi aniq."""
return Buyurtma(
id=uuid.UUID(d["id"]),
mijoz=d["mijoz"],
summa=Decimal(d["summa"]),
yaratilgan=datetime.fromisoformat(d["yaratilgan"]),
yetkazish=date.fromisoformat(d["yetkazish"]),
teglar=frozenset(d["teglar"]),
holat=Holat(d["holat"]),
)
class Maxfiy:
def __init__(self) -> None:
self.parol = "sir123"
def main() -> None:
b = Buyurtma(uuid.UUID("12345678-1234-5678-1234-567812345678"), "Oʻgʻiloy", Decimal("125000.50"),
datetime(2026, 9, 17, 9, 30, tzinfo=UTC), date(2026, 9, 20), frozenset({"tez", "sovg'a"}), Holat.YANGI)
print("=== 1. Kodlash ===")
matn = json.dumps(b, cls=Kodlovchi, ensure_ascii=False, sort_keys=True)
for qator in json.dumps(json.loads(matn), ensure_ascii=False, indent=2).splitlines():
print(f" {qator}")
print("\n=== 2. Tiklash va aylanib qaytish ===")
tiklangan = buyurtma_tikla(json.loads(matn))
print(f" asl bilan teng: {tiklangan == b}")
print(f" turlar: summa={type(tiklangan.summa).__name__}, yaratilgan={type(tiklangan.yaratilgan).__name__}, holat={tiklangan.holat}")
print(f" mintaqa saqlandi: {tiklangan.yaratilgan.tzinfo}")
print("\n=== 3. ⚠️ default=str ===")
shubhali = {"buyurtma_id": 42, "foydalanuvchi": Maxfiy()}
print(f" cls=Kodlovchi: ", end="")
try:
json.dumps(shubhali, cls=Kodlovchi)
except TypeError as xato:
print(f"TypeError: {xato}")
jim = json.dumps(shubhali, default=str)
print(f" default=str: jim yozildi, obyekt manzili bilan: {'<__main__.Maxfiy object at' in jim}")
print("\n=== 4. object_hook — belgilangan obyektlar ===")
def kengaytirilgan(o: object) -> object:
if isinstance(o, complex):
return {"__tur__": "complex", "re": o.real, "im": o.imag}
raise TypeError(f"{type(o).__name__} qo'llanmaydi")
def tikla(d: dict) -> object:
if d.get("__tur__") == "complex":
return complex(d["re"], d["im"])
return d
signal = {"chastota": 50, "impedans": complex(3, 4), "qatlamlar": [{"z": complex(1, -1)}]}
matn = json.dumps(signal, default=kengaytirilgan)
print(f" JSON: {matn}")
print(f" qaytgan: {json.loads(matn, object_hook=tikla)}")
print(" ⚠️ '__tur__' ga tayangan tiklash — faqat ishonchli manba uchun (16.4-dars: pickle bilan solishtiring)")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Kodlash ===
{
"holat": "yangi",
"id": "12345678-1234-5678-1234-567812345678",
"mijoz": "Oʻgʻiloy",
"summa": "125000.50",
"teglar": [
"sovg'a",
"tez"
],
"yaratilgan": "2026-09-17T09:30:00+00:00",
"yetkazish": "2026-09-20"
}
=== 2. Tiklash va aylanib qaytish ===
asl bilan teng: True
turlar: summa=Decimal, yaratilgan=datetime, holat=Holat.YANGI
mintaqa saqlandi: UTC
=== 3. ⚠️ default=str ===
cls=Kodlovchi: TypeError: Object of type Maxfiy is not JSON serializable
default=str: jim yozildi, obyekt manzili bilan: True
=== 4. object_hook — belgilangan obyektlar ===
JSON: {"chastota": 50, "impedans": {"__tur__": "complex", "re": 3.0, "im": 4.0}, "qatlamlar": [{"z": {"__tur__": "complex", "re": 1.0, "im": -1.0}}]}
qaytgan: {'chastota': 50, 'impedans': (3+4j), 'qatlamlar': [{'z': (1-1j)}]}
⚠️ '__tur__' ga tayangan tiklash — faqat ishonchli manba uchun (16.4-dars: pickle bilan solishtiring)Nima ko'rsatdi: 2.7-bo'lim.
Misol 4 — Amaliy: JSON Lines importyori
Boshqa tizimdan kunlik eksport keladi: buyurtmalar.jsonl — har qatorda bitta buyurtma. Importyor faylni oqim bilan o'qiydi, har qatorni alohida tekshiradi (JSON sintaksisi, takroriy kalitlar, majburiy maydonlar, turlar, NaN, katta ID lar), yaroqlilarini natija fayliga barqaror formatda yozadi, yaroqsizlarini qator raqami va sababi bilan xatolar fayliga yig'adi. Oxirida python -m json bilan natija tekshiriladi.
"""JSON Lines oqim bilan; har qator uchun alohida xato; object_pairs_hook, parse_float=Decimal, parse_constant; sxema tekshiruvi; barqaror yozish; hisobot; python -m json bilan tekshirish."""
import json
import math
import subprocess
import sys
import tempfile
from decimal import Decimal
from pathlib import Path
JS_MAX = 2**53 - 1
EKSPORT = [
'{"id": "9007199254740993", "mijoz": "Oʻgʻiloy", "summa": 125000.50, "mahsulotlar": ["daftar", "ruchka"]}',
'{"id": "1002", "mijoz": "Bek", "summa": 45000, "mahsulotlar": ["kitob"]}',
"{'id': '1003', 'mijoz': 'Malika'}",
'{"id": "1004", "mijoz": "Nodira", "summa": NaN, "mahsulotlar": []}',
'{"id": "1005", "mijoz": "Sardor", "summa": 12000, "mahsulotlar": ["sumka"], "summa": 1}',
'{"id": 9007199254740993, "mijoz": "Jasur", "summa": 7000, "mahsulotlar": ["qalam"]}',
"",
'{"id": "1007", "summa": 30000, "mahsulotlar": ["kalkulyator"]}',
'{"id": "1008", "mijoz": "Kamola", "summa": "o\'n ming", "mahsulotlar": ["daftar"]}',
'{"id": "1009", "mijoz": "Zarina", "summa": 99000.10, "mahsulotlar": ["kitob", "daftar"]}',
]
class YozuvXatosi(ValueError):
pass
def takrorsiz(juftlar: list[tuple[str, object]]) -> dict[str, object]:
natija: dict[str, object] = {}
for kalit, qiymat in juftlar:
if kalit in natija:
raise YozuvXatosi(f"takroriy kalit {kalit!r}")
natija[kalit] = qiymat
return natija
def konstanta(nom: str) -> object:
raise YozuvXatosi(f"standartdan tashqari qiymat {nom}")
def tekshir(yozuv: object) -> dict[str, object]:
if not isinstance(yozuv, dict):
raise YozuvXatosi("obyekt kutilgan")
for maydon in ("id", "mijoz", "summa", "mahsulotlar"):
if maydon not in yozuv:
raise YozuvXatosi(f"'{maydon}' maydoni yo'q")
if not isinstance(yozuv["id"], str):
katta = isinstance(yozuv["id"], int) and abs(yozuv["id"]) > JS_MAX
raise YozuvXatosi("id satr bo'lishi kerak" + (" (JavaScript da aniqlik yo'qoladi)" if katta else ""))
if isinstance(yozuv["summa"], bool) or not isinstance(yozuv["summa"], int | Decimal):
raise YozuvXatosi(f"summa son bo'lishi kerak, {type(yozuv['summa']).__name__} keldi")
if not isinstance(yozuv["mahsulotlar"], list) or not yozuv["mahsulotlar"]:
raise YozuvXatosi("mahsulotlar bo'sh bo'lmagan ro'yxat bo'lishi kerak")
return {"id": yozuv["id"], "mijoz": yozuv["mijoz"], "summa_tiyin": int(Decimal(yozuv["summa"]) * 100),
"mahsulotlar": sorted(yozuv["mahsulotlar"])}
def import_qil(kirish: Path, natija: Path, xatolar: Path) -> tuple[int, int]:
yaroqli = yaroqsiz = 0
with open(kirish, encoding="utf-8-sig") as manba, \
open(natija, "w", encoding="utf-8") as chiqish, \
open(xatolar, "w", encoding="utf-8") as xato_fayli:
for raqam, qator in enumerate(manba, start=1):
if not qator.strip():
continue
try:
yozuv = json.loads(qator, object_pairs_hook=takrorsiz, parse_float=Decimal, parse_constant=konstanta)
toza = tekshir(yozuv)
except json.JSONDecodeError as xato:
sabab = f"JSON xatosi: {xato.msg} (ustun {xato.colno})"
except YozuvXatosi as xato:
sabab = str(xato)
else:
chiqish.write(json.dumps(toza, ensure_ascii=False, sort_keys=True, allow_nan=False) + "\n")
yaroqli += 1
continue
xato_fayli.write(json.dumps({"qator": raqam, "sabab": sabab}, ensure_ascii=False) + "\n")
yaroqsiz += 1
return yaroqli, yaroqsiz
def main() -> None:
with tempfile.TemporaryDirectory() as katalog:
r = Path(katalog)
(r / "buyurtmalar.jsonl").write_text("\n".join(EKSPORT) + "\n", encoding="utf-8")
yaroqli, yaroqsiz = import_qil(r / "buyurtmalar.jsonl", r / "toza.jsonl", r / "xatolar.jsonl")
print(f"=== 1. Import: {yaroqli} yaroqli, {yaroqsiz} yaroqsiz ===")
for qator in (r / "toza.jsonl").read_text(encoding="utf-8").splitlines():
print(f" ✅ {qator}")
print("\n=== 2. Xatolar ===")
for qator in (r / "xatolar.jsonl").read_text(encoding="utf-8").splitlines():
xato = json.loads(qator)
print(f" ❌ {xato['qator']:>2}-qator: {xato['sabab']}")
print("\n=== 3. Tekshiruvlar ===")
toza = [json.loads(q) for q in (r / "toza.jsonl").read_text(encoding="utf-8").splitlines()]
print(f" jami summa: {sum(y['summa_tiyin'] for y in toza) / 100:,.2f} so'm".replace(",", " "))
print(f" katta ID satr sifatida saqlandi: {toza[0]['id'] == '9007199254740993'}")
print(f" hamma yozuvlar yaroqli JSON va NaN siz: {all(not isinstance(v, float) or math.isfinite(v) for y in toza for v in y.values())}")
buyruq = subprocess.run([sys.executable, "-m", "json", "--json-lines", str(r / "toza.jsonl")],
capture_output=True, text=True, encoding="utf-8")
print(f" python -m json --json-lines: kod {buyruq.returncode}")
buzuq = r / "buzuq.json"
buzuq.write_text('{"a": 1,}', encoding="utf-8")
buyruq = subprocess.run([sys.executable, "-m", "json", str(buzuq)], capture_output=True, text=True, encoding="utf-8")
print(f" buzuq faylda: kod {buyruq.returncode}, xabar: {buyruq.stderr.strip().split(':')[0]}")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Import: 3 yaroqli, 6 yaroqsiz ===
✅ {"id": "9007199254740993", "mahsulotlar": ["daftar", "ruchka"], "mijoz": "Oʻgʻiloy", "summa_tiyin": 12500050}
✅ {"id": "1002", "mahsulotlar": ["kitob"], "mijoz": "Bek", "summa_tiyin": 4500000}
✅ {"id": "1009", "mahsulotlar": ["daftar", "kitob"], "mijoz": "Zarina", "summa_tiyin": 9900010}
=== 2. Xatolar ===
❌ 3-qator: JSON xatosi: Expecting property name enclosed in double quotes (ustun 2)
❌ 4-qator: standartdan tashqari qiymat NaN
❌ 5-qator: takroriy kalit 'summa'
❌ 6-qator: id satr bo'lishi kerak (JavaScript da aniqlik yo'qoladi)
❌ 8-qator: 'mijoz' maydoni yo'q
❌ 9-qator: summa son bo'lishi kerak, str keldi
=== 3. Tekshiruvlar ===
jami summa: 269 000.60 so'm
katta ID satr sifatida saqlandi: True
hamma yozuvlar yaroqli JSON va NaN siz: True
python -m json --json-lines: kod 0
buzuq faylda: kod 1, xabar: Illegal trailing comma before end of objectNima ko'rsatdi: 2.4–2.8-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "JSON Python turlarini saqlaydi" | Kortej → ro'yxat, son kalit → satr |
"{1: .., True: ..} — ikki kalit" |
Bitta — 1 == True |
"json.dumps doim yaroqli JSON beradi" |
NaN/Infinity — allow_nan=False |
| "Float JSON da aniq" | parse_float=Decimal yoki butun tiyinlar |
| "Python o'qigan katta son hamma joyda aniq" | JavaScript 2^53 dan katta butunlarni buzadi |
| "Takroriy kalit xato beradi" | Jim oxirgisi olinadi |
"default=str — universal yechim" |
Xatolarni yashiradi |
"json.loads BOM ni tushunadi (satrda)" |
Xato; bytes yoki utf-8-sig |
6. Keng tarqalgan xatolar va yechimlari
1. Faylga ASCII escape lar bilan
json.dump(d, f) # "O\u02bbzbek"
json.dump(d, f, ensure_ascii=False) # ✅ + open(..., encoding="utf-8")2. Pul float da
json.dumps({"summa": 125000.50}) # ⚠️
json.dumps({"summa_tiyin": 12500050}) # ✅3. Katta ID son sifatida
json.dumps({"id": 12345678901234567890}) # ⚠️ JS da buziladi
json.dumps({"id": "12345678901234567890"}) # ✅4. NaN tashqi tizimga
json.dumps(olchovlar) # ⚠️ 'NaN'
json.dumps(olchovlar, allow_nan=False) # ✅ xato darhol5. Beqaror chiqish
json.dumps(d, indent=2) # ⚠️ kalit tartibi ma'lumotga bog'liq
json.dumps(d, indent=2, sort_keys=True) # ✅ git diff, xesh, test6. Istisnoni juda keng ushlash
except Exception: ... # ❌
except json.JSONDecodeError as x: ... x.lineno # ✅7. Butun katta faylni json.load
json.load(open("10gb.json")) # ❌ xotira
# ✅ JSON Lines + satrma-satr yoki oqimli parser (ijson) — 16.8-dars8. Tashqi JSON ni tekshirmasdan ishlatish
foydalanuvchi = json.loads(sorov.body)["rol"] # ❌ takroriy kalit, tur, yo'q maydon
# ✅ object_pairs_hook + sxema tekshiruvi (pydantic, 13.8 va 20.5)7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 13.8-dars (o'tilgan):
pydantic— JSON ni sxema bilan tekshirish - 15.4–15.5-darslar (o'tilgan): ISO 8601 sanalar va vaqt mintaqalari
- 15.16-dars (o'tilgan): JSON jurnallar
- 16.4-dars:
pickle— JSON bilan xavfsizlik farqi - 16.6-dars: YAML va TOML — sozlama formatlari
- 16.8-dars: katta JSON fayllarni oqim bilan o'qish
- 20-qism: FastAPI — JSON so'rov va javoblar
- 26.7-dars: API integratsiyasi
8. Eng yaxshi amaliyotlar
Faylga —
ensure_ascii=False,encoding="utf-8"; o'qishdautf-8-sig.Barqaror chiqish —
sort_keys=True.Tashqi tizimga —
allow_nan=False.Pul — butun son yoki
Decimalsatr; katta ID — satr.Tashqi JSON — takroriy kalitlarni rad eting va sxema bilan tekshiring.
Maxsus turlar — aniq
JSONEncoder,default=stremas.Katta yoki oqimli ma'lumot — JSON Lines.
Xatolarda
lineno/colnoni foydalanuvchiga ko'rsating.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
import json
from decimal import Decimal
1. print(json.dumps((1, 2)))
2. print(json.loads(json.dumps({1: "a"})))
3. print(json.dumps({1: "a", True: "b"}))
4. print(json.dumps(None), json.dumps(True))
5. print(json.dumps("ʻ"))
6. print(json.dumps("ʻ", ensure_ascii=False))
7. print(json.loads('{"a": 1, "a": 2}'))
8. print(json.dumps(float("inf")))
9. print(type(json.loads("1.5", parse_float=Decimal)).__name__)
10. print(json.dumps({"b": 1, "a": 2}, sort_keys=True))
11. print(json.dumps([1, 2], separators=(",", ":")))
12. print(issubclass(json.JSONDecodeError, ValueError))Javoblar
[1, 2]{'1': 'a'}{"1": "b"}null true"\u02bb""ʻ"{'a': 2}InfinityDecimal{"a": 2, "b": 1}[1,2]True
Vazifa 2: Xatolarni tuzating
1. def saqla(yol, malumot):
with open(yol, "w") as f:
json.dump(malumot, f)
2. def summa(matn):
return sum(t["narx"] for t in json.loads(matn)["tovarlar"]) # pul hisobi
3. def javob(foydalanuvchi):
return json.dumps({"id": foydalanuvchi.id, "yaratilgan": foydalanuvchi.yaratilgan}) # id — katta son, datetime
4. def sozlama(yol):
try:
return json.load(open(yol))
except Exception:
return {}
5. def hisobot(olchovlar):
return json.dumps({"ortacha": sum(olchovlar) / len(olchovlar)}) # olchovlar bo'sh yoki NaN bo'lishi mumkinJavoblar
1. def saqla(yol, malumot):
with open(yol, "w", encoding="utf-8") as f:
json.dump(malumot, f, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False)
2. def summa(matn):
return sum(t["narx"] for t in json.loads(matn, parse_float=Decimal)["tovarlar"])
3. def javob(foydalanuvchi):
return json.dumps({"id": str(foydalanuvchi.id),
"yaratilgan": foydalanuvchi.yaratilgan.isoformat()})
4. def sozlama(yol):
try:
with open(yol, encoding="utf-8-sig") as f:
return json.load(f)
except FileNotFoundError:
return {}
except json.JSONDecodeError as x:
raise ValueError(f"{yol}:{x.lineno}:{x.colno}: {x.msg}") from x
5. def hisobot(olchovlar):
toza = [x for x in olchovlar if math.isfinite(x)]
ortacha = sum(toza) / len(toza) if toza else None
return json.dumps({"ortacha": ortacha}, allow_nan=False)Vazifa 3: JSON farqlovchi
json_farq(a, b) — ikki JSON hujjat orasidagi farqlarni yo'l bilan chiqarsin:
$.buyurtmalar[2].summa: 45000 → 47000- Qo'shilgan va o'chirilgan kalitlar
- Tur o'zgarishi (
"12"→12) alohida belgilansin - Ro'yxatlarda
idmaydoni bo'yicha solishtirish varianti argparseCLI va chiqish kodi (farq bor — 1)
Vazifa 4: JSON Schema (kichik)
Mini validator yozing: sxema — JSON (type, required, properties, items, minimum, enum):
- Barcha xatolarni yo'l bilan yig'sin (birinchisida to'xtamasin)
- Misol 4 dagi buyurtmalar sxemasini yozing
- 15 ta yaroqli va yaroqsiz namunada sinang
jsonschemakutubxonasi natijasi bilan solishtiring (ixtiyoriy)
Vazifa 5: Sozlamalar fayli
sozlama.jsonni o'qib, sukut qiymatlar bilan birlashtiring (ichma-ich)- Noma'lum kalitlar uchun ogohlantirish (
logging) - Tur xatolarini
qator:ustunbilan ko'rsating (buning uchun o'qilgan matndan kalit joyini toping) - O'zgartirishlarni atomar va barqaror formatda qayta yozing
Vazifa 6: API javoblarini keshlash
- Tashqi API javobini (sinov uchun lug'at) diskka JSON sifatida keshlang
- Kesh kaliti — so'rov parametrlaridan barqaror xesh (
sort_keys=True+hashlib) - Muddat (TTL) va
datetimemaydonlari to'g'ri tiklansin - Buzilgan kesh fayli — o'chirilib, qayta yuklansin
Vazifa 7: O'ylash
JSON Duglas Krokford tomonidan "kashf qilingan" deb ataladi: u JavaScript obyekt sintaksisining kichik qismi. Unda izohlar, sanalar, NaN, butun va o'nli sonlar farqi yo'q. Shunga qaramay u XML ni siqib chiqardi. Nega bunday "kambag'al" format g'olib bo'ldi va uning cheklovlari qanday qo'shimcha standartlar (JSON Schema, JSON Lines, JSON5) paydo bo'lishiga olib keldi?
Javob
Qisqa javob: JSON oddiyligi tufayli g'olib bo'ldi: grammatikasi bir sahifaga sig'adi, har bir tilda ma'lumot tuzilmalariga (lug'at, ro'yxat, son, satr) to'g'ridan-to'g'ri mos keladi va brauzerda bepul ishlaydi. Cheklovlar ataylab qoldirilgan — format barqaror va hamma joyda bir xil talqin qilinishi uchun. Yetishmayotgan imkoniyatlar formatning o'ziga emas, ustiga qo'shildi: sxema, oqim, izohli variantlar.
1. Nega XML ni siqib chiqardi
| Xususiyat | XML | JSON |
|---|---|---|
| Ma'lumot modeli | Hujjat: element, atribut, matn, nomlar fazosi | Ma'lumot tuzilmasi: obyekt, massiv, qiymat |
| Dasturdagi turga moslik | Xaritalash kerak | To'g'ridan-to'g'ri |
| Hajm | Ochiluvchi va yopiluvchi teglar | Ixcham |
| Brauzer | Alohida parser | JSON.parse — tilning o'zida |
| Spetsifikatsiya | Yuzlab sahifa (XSD, XSLT, namespace) | Bir sahifa |
| Xavfsizlik tuzoqlari | XXE, entity portlashi (16.5) | Kam |
2. Ataylab qoldirilgan cheklovlar
| Yo'q narsa | Sabab |
|---|---|
| Izohlar | Krokford: izohlar parser direktivalariga aylanib, moslikni buzmasligi uchun |
| Sana turi | Tillar orasida sana tushunchasi har xil — ISO 8601 satr konventsiyasi |
NaN/Infinity |
Ko'p tillarda standart ifodasi yo'q |
| Butun/o'nli farq | "number" — aniqlik talqini parserga qoldirilgan |
| Versiya | "JSON hech qachon o'zgarmaydi" — barqarorlik kafolati |
3. Ustiga qurilgan standartlar
| Standart | Nima qo'shadi |
|---|---|
| JSON Schema | Turlar, majburiy maydonlar, cheklovlar — validatsiya va hujjat |
| OpenAPI | API ni JSON Schema bilan tasvirlash (20-qism) |
| JSON Lines / NDJSON | Oqim va katta hajm |
| JSON5, JSONC | Izohlar, oxirgi vergul — sozlama fayllari uchun (VS Code) |
| JSON Patch, Merge Patch | O'zgarishlarni tasvirlash |
| JSON-LD | Semantik bog'lanishlar |
| BSON, MessagePack, CBOR | Binar, tezroq, qo'shimcha turlar |
4. Muhandislik saboqlari
- Oddiy format — keng qabul qilinadi; murakkablik ustiga qatlam sifatida qo'shiladi
- Barqarorlik ("o'zgarmaydi") — ekotizim ishonchi
- Talqin qilinmagan joylar (sonlar aniqligi, takroriy kalitlar) — tillar orasidagi nomuvofiqlik manbai; ularni o'z tizimingizda aniq qoidalar bilan yoping
- Sozlama fayllari uchun JSON noqulay — shuning uchun TOML/YAML (16.6)
5. Xulosa
- JSON soddalik va tillar ma'lumot modeliga moslik tufayli g'olib bo'ldi
- Cheklovlar — dizayn tanlovi, kamchilik emas
- Yetishmayotgan narsalar ustiga standartlar bilan qo'shiladi
- Amaliyotda: JSON + sxema + aniq konventsiyalar (sana, pul, ID)
Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.
Xulosa
Bu darsda JSON bilan ishlashni va uning jim tuzoqlarini o'rgandik.
Eng muhim uch fikr:
JSON va Python turlari bir xil emas. Kortej ro'yxat bo'lib, son kalitlar satr bo'lib qaytadi;
1vaTruekalitlari bitta kalitga aylanadi;set,datetime,Decimalumuman seriyalanmaydi. Faylgaensure_ascii=Falsevaencoding="utf-8", barqaror chiqish uchunsort_keys=True. Maxsus turlar aniqJSONEncoder.defaultbilan yoziladi va sxema asosida tiklanadi —default=stresa xatolarni jim yashiradi.Sonlar va standart. Python
NaNvaInfinityni yozadi, boshqa tillar esa rad etadi — tashqi tizimgaallow_nan=False. Pul uchun float emas, butun tiyinlar yokiDecimal(parse_float=Decimal);2^53dan katta ID lar JavaScript'da buziladi — ularni satr sifatida yuboring.Tashqi JSON — ishonchsiz kiritish. Takroriy kalitlar jim oxirgisini beradi —
object_pairs_hookbilan rad eting;JSONDecodeErrorqator va ustunni ko'rsatadi; BOM li satr xato beradi. Katta va oqimli ma'lumot uchun JSON Lines: har qator alohida tekshiriladi va bitta buzilgan yozuv butun importni to'xtatmaydi; 3.14 dapython -m json --json-linesbilan tekshirish mumkin.
Keyingi darsda jadval ma'lumotlarining eng keng tarqalgan formati — csv: ajratgichlar, qo'shtirnoqlar, Excel va o'zbekcha matn, DictReader va turlarni tiklash.
Izohlar · 0
Izoh yozish uchun kiring.