Python kursi16.2-dars: json
Python kursi · Malumot formatlari

16.2-dars: json

25 daqiqa2/8-dars

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:

python
json.dumps({"summa": hisob.summa})       # summa — float

Oylik 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/load va tur jadvali
  • Nima o'zgarib qaytadi: kortej, son kalitlar, 1 va True kalitlari
  • Formatlash: indent, sort_keys, separators, ensure_ascii
  • Standartdan tashqari: NaN, Infinity va allow_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
python
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

python
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.

python
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):

bash
python -m json data.json                    # chiroyli chiqarish va tekshirish
python -m json --sort-keys --indent 2 < a.json
python -m json --json-lines log.jsonl

Yaroqsiz JSON da chiqish kodi 1 va xato joyi.


3. Tez ma'lumotnoma

python
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 yashirmang

4. Batafsil misollar

Misol 1 — Tur mosligi va formatlash

python
"""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:

text
=== 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: True

Nima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.

Misol 2 — Sonlar, standart va xatolar

python
"""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:

text
=== 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

python
"""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:

text
=== 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.

python
"""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:

text
=== 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 object

Nima 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

python
json.dump(d, f)                                    # "O\u02bbzbek"
json.dump(d, f, ensure_ascii=False)                # ✅ + open(..., encoding="utf-8")

2. Pul float da

python
json.dumps({"summa": 125000.50})                   # ⚠️
json.dumps({"summa_tiyin": 12500050})              # ✅

3. Katta ID son sifatida

python
json.dumps({"id": 12345678901234567890})           # ⚠️ JS da buziladi
json.dumps({"id": "12345678901234567890"})         # ✅

4. NaN tashqi tizimga

python
json.dumps(olchovlar)                              # ⚠️ 'NaN'
json.dumps(olchovlar, allow_nan=False)             # ✅ xato darhol

5. Beqaror chiqish

python
json.dumps(d, indent=2)                            # ⚠️ kalit tartibi ma'lumotga bog'liq
json.dumps(d, indent=2, sort_keys=True)            # ✅ git diff, xesh, test

6. Istisnoni juda keng ushlash

python
except Exception: ...                              # ❌
except json.JSONDecodeError as x: ... x.lineno     # ✅

7. Butun katta faylni json.load

python
json.load(open("10gb.json"))                       # ❌ xotira
# ✅ JSON Lines + satrma-satr yoki oqimli parser (ijson) — 16.8-dars

8. Tashqi JSON ni tekshirmasdan ishlatish

python
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

  1. Faylga — ensure_ascii=False, encoding="utf-8"; o'qishda utf-8-sig.

  2. Barqaror chiqish — sort_keys=True.

  3. Tashqi tizimga — allow_nan=False.

  4. Pul — butun son yoki Decimal satr; katta ID — satr.

  5. Tashqi JSON — takroriy kalitlarni rad eting va sxema bilan tekshiring.

  6. Maxsus turlar — aniq JSONEncoder, default=str emas.

  7. Katta yoki oqimli ma'lumot — JSON Lines.

  8. Xatolarda lineno/colno ni foydalanuvchiga ko'rsating.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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. [1, 2]
  2. {'1': 'a'}
  3. {"1": "b"}
  4. null true
  5. "\u02bb"
  6. "ʻ"
  7. {'a': 2}
  8. Infinity
  9. Decimal
  10. {"a": 2, "b": 1}
  11. [1,2]
  12. True

Vazifa 2: Xatolarni tuzating

python
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 mumkin
Javoblar
python
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:

  1. $.buyurtmalar[2].summa: 45000 → 47000
  2. Qo'shilgan va o'chirilgan kalitlar
  3. Tur o'zgarishi ("12" → 12) alohida belgilansin
  4. Ro'yxatlarda id maydoni bo'yicha solishtirish varianti
  5. argparse CLI va chiqish kodi (farq bor — 1)

Vazifa 4: JSON Schema (kichik)

Mini validator yozing: sxema — JSON (type, required, properties, items, minimum, enum):

  1. Barcha xatolarni yo'l bilan yig'sin (birinchisida to'xtamasin)
  2. Misol 4 dagi buyurtmalar sxemasini yozing
  3. 15 ta yaroqli va yaroqsiz namunada sinang
  4. jsonschema kutubxonasi natijasi bilan solishtiring (ixtiyoriy)

Vazifa 5: Sozlamalar fayli

  1. sozlama.json ni o'qib, sukut qiymatlar bilan birlashtiring (ichma-ich)
  2. Noma'lum kalitlar uchun ogohlantirish (logging)
  3. Tur xatolarini qator:ustun bilan ko'rsating (buning uchun o'qilgan matndan kalit joyini toping)
  4. O'zgartirishlarni atomar va barqaror formatda qayta yozing

Vazifa 6: API javoblarini keshlash

  1. Tashqi API javobini (sinov uchun lug'at) diskka JSON sifatida keshlang
  2. Kesh kaliti — so'rov parametrlaridan barqaror xesh (sort_keys=True + hashlib)
  3. Muddat (TTL) va datetime maydonlari to'g'ri tiklansin
  4. 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

  1. Oddiy format — keng qabul qilinadi; murakkablik ustiga qatlam sifatida qo'shiladi
  2. Barqarorlik ("o'zgarmaydi") — ekotizim ishonchi
  3. Talqin qilinmagan joylar (sonlar aniqligi, takroriy kalitlar) — tillar orasidagi nomuvofiqlik manbai; ularni o'z tizimingizda aniq qoidalar bilan yoping
  4. Sozlama fayllari uchun JSON noqulay — shuning uchun TOML/YAML (16.6)

5. Xulosa

  1. JSON soddalik va tillar ma'lumot modeliga moslik tufayli g'olib bo'ldi
  2. Cheklovlar — dizayn tanlovi, kamchilik emas
  3. Yetishmayotgan narsalar ustiga standartlar bilan qo'shiladi
  4. 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:

  1. JSON va Python turlari bir xil emas. Kortej ro'yxat bo'lib, son kalitlar satr bo'lib qaytadi; 1 va True kalitlari bitta kalitga aylanadi; set, datetime, Decimal umuman seriyalanmaydi. Faylga ensure_ascii=False va encoding="utf-8", barqaror chiqish uchun sort_keys=True. Maxsus turlar aniq JSONEncoder.default bilan yoziladi va sxema asosida tiklanadi — default=str esa xatolarni jim yashiradi.

  2. Sonlar va standart. Python NaN va Infinity ni yozadi, boshqa tillar esa rad etadi — tashqi tizimga allow_nan=False. Pul uchun float emas, butun tiyinlar yoki Decimal (parse_float=Decimal); 2^53 dan katta ID lar JavaScript'da buziladi — ularni satr sifatida yuboring.

  3. Tashqi JSON — ishonchsiz kiritish. Takroriy kalitlar jim oxirgisini beradi — object_pairs_hook bilan rad eting; JSONDecodeError qator 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 da python -m json --json-lines bilan tekshirish mumkin.

Keyingi darsda jadval ma'lumotlarining eng keng tarqalgan formati — csv: ajratgichlar, qo'shtirnoqlar, Excel va o'zbekcha matn, DictReader va turlarni tiklash.

Malumot formatlari · 2-dars yakunlandi

16.2-dars: json

25 daqvaqt
0belgi
Keyingi dars: 16.3-dars: csv
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0