7.8-dars: JSON parse (chuqur)

7-QISM — MA'LUMOT YIG'ISH · 8-dars

1. Kirish va motivatsiya

API javoblari 7.7-bob va veb-ma'lumot ko'pincha murakkab, ichma-ich JSON bo'ladi: obyekt ichida obyekt, ro'yxat ichida obyekt, bir necha daraja chuqur. 7.3-darsda JSON asoslarini va json_normalize ni ko'rdik; endi chuqurroq: chuqur ichma-ich kirish, ro'yxat ichida obyekt bilan ishlash, xavfsiz olish (.get zanjir — kalit yo'q bo'lsa), yo'q maydonlar, va murakkab JSON'ni jadvalga aylantirish. Real API javoblari ko'pincha 3-4 daraja chuqur va nomuvofiq (ba'zi maydon yo'q) — buni ishonchli parse qilish muhim ko'nikma. Nega muhim? (1) Murakkab — API javob ichma-ich (chuqur); (2) Xavfsiz — yo'q maydon (.get); (3) Jadvalga — murakkab JSON → tahlil. Bu dars JSON parse'ni chuqur o'rgatadi — murakkab JSON bilan ishlash.

JSON parse (chuqur) — murakkab JSON: chuqur kirish (obj["a"]["b"][0]["c"] — zanjir; ichma-ich), xavfsiz olish (.get("a", {}).get("b") — kalit yo'q; KeyError oldini ol), ro'yxat ichida obyekt (sikl/list comprehension), yo'q maydon (nomuvofiq — default), json_normalize (chuqur — record_path, meta, sep, max_level), DataFrame (murakkab → jadval). Foydalanish: API/veb murakkab JSON, ishonchli parse. Bu 7.3 (JSON asoslari), 7.7 (API javob), 6.1 (yo'q qiymat) bilan bog'liq. JSON parse — murakkab JSON (chuqur, xavfsiz). JSON. Parse.

Real vaziyat. Data Scientist ijtimoiy media API'sidan javob oldi 7.7-bob — murakkab ichma-ich JSON: {"user": {"name": "Ali", "address": {"city": "Toshkent"}}, "posts": [{"text": "salom", "likes": 10}, {"text": "xayr", "likes": 5}]}. Muammo: obj["user"]["address"]["city"] (3 daraja); ba'zi foydalanuvchida address yo'q (KeyError — dastur to'xtaydi); posts — ro'yxat (har post — obyekt). Hal: xavfsiz (obj.get("user", {}).get("address", {}).get("city") — yo'q bo'lsa None), ro'yxat (sikl — har post; yoki json_normalize(record_path="posts")). Data Scientist chuqur kirdi (zanjir), xavfsiz oldi (.get — yo'q maydon), jadvalga (json_normalize). JSON parse — murakkab JSON.

Bu darsda JSON parse'ni chuqur o'rganamiz.

Bu darsda:

• Chuqur kirish (ichma-ich zanjir)
• Xavfsiz olish (.get zanjir)
• Ro'yxat ichida obyekt (sikl)
• Yo'q maydonlar (nomuvofiq)
• json_normalize (chuqur)
• Parse amaliyoti
• Parse tuzoqlari
• Amaliy: JSON parse

ℹ Misollar real json/pandas bilan (Python 3.14).

2. Nazariya — chuqur tushuntirish

2.1. Chuqur kirish (ichma-ich zanjir)

Daraja-daraja:

data = {
    "user": {
        "name": "Ali",
        "address": {"city": "Toshkent", "zip": "100000"}
    }
}

# chuqur kirish — zanjir (daraja-daraja)
data["user"]["name"]                  # "Ali"
data["user"]["address"]["city"]       # "Toshkent" (3 daraja)

# ro'yxat elementi
data["posts"][0]["text"]              # 1-post matni

Chuqur kirish (ichma-ich zanjir) — daraja-daraja: obj["a"]["b"]["c"] — ichma-ich obyektga zanjir (daraja-daraja; ["a"] → ["b"] → ["c"]); ro'yxat (obj["posts"][0] — indeks bilan element). Sabab: JSON ierarxik (7.3 — ichma-ich; API javob 3-4 daraja); kirish — har daraja kalit/indeks (zanjir); "chuqurga tushish" (daraja-daraja). ["kalit"] (obyekt), [indeks] (ro'yxat), zanjir (daraja-daraja). Chuqur kirish — zanjir (["a"]["b"]). Chuqur. Zanjir.

2.2. Xavfsiz olish (.get zanjir)

KeyError'siz:

# XATO: kalit yo'q → KeyError (dastur to'xtaydi)
data["user"]["address"]["city"]   # "address" yo'q bo'lsa → xato

# XAVFSIZ: .get (yo'q bo'lsa default)
data.get("user", {}).get("address", {}).get("city")   # None (xato yo'q)

# default qiymat
data.get("user", {}).get("phone", "yo`q")   # "yo`q"

Xavfsiz olish (.get zanjir) — KeyError'siz: obj.get("a", {}).get("b") — .get zanjir (kalit yo'q bo'lsa KeyError emas — default qaytaradi; {} — keyingi .get uchun); .get("kalit", default) (yo'q — default; None standart). Sabab: real JSON nomuvofiq (ba'zi maydon yo'q; obj["a"]["b"] — "a" yo'q → KeyError dastur to'xtaydi); .get — xavfsiz (yo'q — default; davom); zanjir ({} — keyingi .getka bo'sh dict). .get("a", {}) (yo'q — bo'sh dict), zanjir (keyingi .get), default (None/qiymat). Xavfsiz olish — .get zanjir (KeyError yo'q). Xavfsiz. .get.

2.3. Ro'yxat ichida obyekt (sikl)

Ro'yxat ichida obyekt (sikl) — har element: JSON ko'pincha ro'yxat ([{...}, {...}] — obyektlar ro'yxati; API — yozuvlar); sikl (for item in data["posts"]: item["text"]), list comprehension ([p["likes"] for p in posts]), json_normalize(record_path="posts") (ro'yxat → jadval — 7.3). Sabab: ro'yxat (ko'p yozuv — postlar, mahsulotlar; har biri obyekt); sikl/comprehension (har element — maydon olish); json_normalize (ro'yxat → DataFrame). Sikl (for — har element), comprehension ([... for ...]), record_path (ro'yxat → jadval). Ro'yxat ichida obyekt — sikl (har element). Ro'yxat. Sikl.

2.4. Yo'q maydonlar (nomuvofiq)

Yo'q maydonlar (nomuvofiq) — real JSON: real JSON nomuvofiq (ba'zi yozuvda maydon bor, ba'zida yo'q; API — ixtiyoriy maydon); xavfsiz (.get — default), tekshir (if "kalit" in obj), default (yo'q — None/0/""), json_normalize (yo'q maydon → NaN — avtomatik). Sabab: JSON sxemasiz (CSV — ustun qat'iy; JSON — moslashuvchan, maydon turli); nomuvofiq (yo'q maydon — KeyError yoki NaN); json_normalize (yo'q → NaN; keyin 6.1 hal). .get (default), in (tekshir), NaN (json_normalize — yo'q). Yo'q maydonlar — nomuvofiq (.get, NaN). Yo'q. Nomuvofiq.

2.5. json_normalize (chuqur)

json_normalize (chuqur) — murakkab parametrlar: pd.json_normalize(data, record_path="posts", meta=["user", "id"], sep="_", max_level=2): record_path (ro'yxat — har element qator; 7.3), meta (yuqori maydon — takror; ichma-ich — ["user", "name"]), sep (ustun ajratgich — _ yoki .), max_level (chuqurlik — necha daraja tekislash). Sabab: murakkab JSON (chuqur + ro'yxat + meta); json_normalize — kuchli (record_path ro'yxat, meta kontekst, max_level chuqurlik nazorat); "murakkab → jadval". record_path (ro'yxat), meta (yuqori), sep (ajratgich), max_level (chuqurlik). json_normalize (chuqur) — record_path/meta/max_level. Normalize. Chuqur.

2.6. Parse amaliyoti

Parse amaliyoti: struktura ko'r (JSON tuzilishini ko'r — chuqurlik, ro'yxat, maydon; print/hujjat); xavfsiz olish (.get zanjir — nomuvofiq JSON; KeyError yo'q); ro'yxat (sikl/comprehension yoki record_path); yo'q maydon (default/.get; NaN); json_normalize (murakkab → jadval; record_path/meta/max_level); DataFrame (tahlil — 6-qism tozalash); tekshir (ustunlar, NaN). Tuzoqlar: KeyError (.get xavfsiz), chuqur faraz (nomuvofiq — tekshir), ro'yxat/obyekt (turli — record_path), yo'q maydon (default), chuqur tekislash (max_level). Amaliyot — struktura, xavfsiz, ro'yxat, normalize. JSON. Parse.

2.7. Parse tuzoqlari

JSON parse asosiy tuzoqlari: KeyError (obj["a"]["b"] — kalit yo'q ("a" yoki "b") → KeyError (dastur to'xtaydi); .get zanjir (obj.get("a", {}).get("b") — xavfsiz)); chuqur faraz (JSON nomuvofiq (ba'zi yozuvda 3 daraja, ba'zida 2; taxmin — xato); struktura ko'r/tekshir); ro'yxat vs obyekt (obj["posts"] — ro'yxat ([]) yoki obyekt ({})? — turli kirish ([0] vs ["kalit"]); tekshir — isinstance); yo'q maydon (nomuvofiq — .get(default) yoki json_normalize NaN; KeyError emas); chuqur tekislash (json_normalize — chuqur JSON butun tekislaydi (ko'p ustun); max_level= — chegara); None zanjir (obj.get("a") None qaytarsa — .get("b") xato (None.get); obj.get("a") or {} yoki .get("a", {})); tur aralash (bir maydon — ba'zida son, ba'zida matn (nomuvofiq); tekshir/tur); katta JSON (chuqur/katta — xotira; ijson oqim yoki qism); indeks xato (obj["posts"][0] — ro'yxat bo'sh → IndexError; if posts: tekshir); unicode (JSON — \u... (7.3 ensure_ascii); loads avtomatik ochadi). Sabab: JSON parse nomuvofiq/chuqur nozik (KeyError, ro'yxat/obyekt, yo'q maydon — xato yoki to'xtash). Yechim: .get zanjir, struktura ko'r, isinstance, default, max_level. Tuzoqlar — KeyError, chuqur faraz, ro'yxat/obyekt, yo'q maydon.

2.8. JSON parse — murakkab JSON bilan ishlash

JSON parse asosiy g'oyasi — murakkab JSON bilan ishlash: API javob 7.7-bob/veb-ma'lumot ko'pincha murakkab, ichma-ich JSON (obyekt ichida obyekt, ro'yxat ichida obyekt; 3-4 daraja; nomuvofiq — ba'zi maydon yo'q); ishonchli parse muhim. Chuqur kirish (obj["a"]["b"]["c"] — zanjir; ro'yxat [0]), xavfsiz olish (.get("a", {}).get("b") — KeyError yo'q; default), ro'yxat ichida obyekt (sikl/comprehension; record_path), yo'q maydon (nomuvofiq — .get/NaN; 6.1), json_normalize (chuqur — record_path ro'yxat, meta yuqori, sep, max_level), DataFrame (murakkab → jadval → tahlil). Foydalanish: API/veb murakkab JSON (ichma-ich; 7.7), ishonchli parse (nomuvofiq — xavfsiz). Tuzoqlar: KeyError (.get xavfsiz), chuqur faraz (nomuvofiq — ko'r), ro'yxat/obyekt (isinstance), yo'q maydon (default), None zanjir (.get("a", {})), indeks xato (bo'sh ro'yxat). Bu 7.3 (JSON asoslari), 7.7 (API javob), 6.1 (yo'q qiymat — NaN), 7.12 (loyiha) bilan. JSON parse — murakkab JSON bilan ishlash (chuqur, xavfsiz, normalize). JSON. Parse. Xavfsiz.

3. Tez ma'lumotnoma

import json
import pandas as pd

# CHUQUR KIRISH (zanjir):
data["user"]["address"]["city"]        # 3 daraja (KeyError xavfi!)

# XAVFSIZ (.get zanjir — KeyError yo'q):
data.get("user", {}).get("address", {}).get("city")   # yo'q → None
data.get("user", {}).get("phone", "yo`q_default")

# RO'YXAT ICHIDA OBYEKT (sikl/comprehension):
for post in data["posts"]:
    print(post["text"])
likes = [p.get("likes", 0) for p in data.get("posts", [])]

# YO'Q MAYDON tekshirish:
if "address" in data["user"]:
    ...
val = data["user"].get("phone")        # None (yo'q)

# JSON_NORMALIZE (chuqur):
pd.json_normalize(data,
    record_path="posts",               # ro'yxat → qatorlar
    meta=[["user", "name"]],           # yuqori (ichma-ich)
    sep="_", max_level=2)              # ajratgich, chuqurlik

# RO'YXAT/OBYEKT tekshirish:
isinstance(data["x"], list)            # ro'yxatmi?

QOIDA: .get zanjir (KeyError) · struktura ko'r · isinstance · default (yo'q)

JSON parse xulosasi

JSON parse — murakkab JSON (ichma-ich, nomuvofiq)
Chuqur kirish — zanjir (obj["a"]["b"]; KeyError xavfi)
Xavfsiz olish — .get zanjir (yo'q → default; KeyError yo'q)
Ro'yxat ichida obyekt — sikl/comprehension (record_path)
json_normalize — record_path (ro'yxat), meta (yuqori), max_level

4. Batafsil misollar

Misollar real json/pandas bilan (Python 3.14).

Misol 1 — Chuqur kirish va xavfsiz

"""Chuqur kirish va xavfsiz (real Python)."""


def main() -> None:
    data = {
        "user": {"name": "Ali", "address": {"city": "Toshkent"}},
    }

    print("=== 1. Chuqur kirish (zanjir) ===")
    print(f"  name: {data['user']['name']}")
    print(f"  city: {data['user']['address']['city']} (3 daraja)")

    print("\n=== 2. KeyError xavfi ===")
    try:
        _ = data["user"]["phone"]["number"]
    except KeyError as e:
        print(f"  KeyError: {e} (dastur to'xtardi bo'lardi)")

    print("\n=== 3. Xavfsiz (.get zanjir) ===")
    phone = data.get("user", {}).get("phone", {})
    print(f"  phone (yo'q): {phone} (xato yo'q)")

    print("\n=== 4. Default qiymat ===")
    tel = data.get("user", {}).get("phone", "ko`rsatilmagan")
    print(f"  tel: {tel}")
    print("  ⭐ Chuqur + xavfsiz (.get)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Chuqur kirish (zanjir) ===
  name: Ali
  city: Toshkent (3 daraja)

=== 2. KeyError xavfi ===
  KeyError: 'phone' (dastur to'xtardi bo'lardi)

=== 3. Xavfsiz (.get zanjir) ===
  phone (yo'q): {} (xato yo'q)

=== 4. Default qiymat ===
  tel: ko`rsatilmagan
  ⭐ Chuqur + xavfsiz (.get)

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

Misol 2 — Ro'yxat ichida obyekt

"""Ro'yxat ichida obyekt (real Python)."""


def main() -> None:
    data = {
        "user": "Ali",
        "posts": [
            {"text": "salom", "likes": 10},
            {"text": "xayr", "likes": 5},
            {"text": "hello"},   # likes yo'q (nomuvofiq)
        ],
    }

    print("=== 1. Sikl (har post) ===")
    for post in data["posts"]:
        print(f"  {post['text']}")

    print("\n=== 2. Comprehension (likes) ===")
    likes = [p.get("likes", 0) for p in data["posts"]]
    print(f"  likes: {likes} (yo'q → 0)")

    print("\n=== 3. Jami likes ===")
    print(f"  jami: {sum(likes)}")

    print("\n=== 4. Nomuvofiq (3-post likes yo'q) ===")
    print("  .get('likes', 0) — default 0")
    print("  ⭐ Ro'yxat — sikl/comprehension")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Sikl (har post) ===
  salom
  xayr
  hello

=== 2. Comprehension (likes) ===
  likes: [10, 5, 0] (yo'q → 0)

=== 3. Jami likes ===
  jami: 15

=== 4. Nomuvofiq (3-post likes yo'q) ===
  .get('likes', 0) — default 0
  ⭐ Ro'yxat — sikl/comprehension

Nima ko'rsatdi: 2.3, 2.4-bo'limlar.

Misol 3 — json_normalize (chuqur)

"""json_normalize chuqur (real pandas)."""

import pandas as pd


def main() -> None:
    data = [
        {"user": {"name": "Ali", "city": "Toshkent"},
         "posts": [{"text": "a", "likes": 10}, {"text": "b", "likes": 5}]},
        {"user": {"name": "Vali", "city": "Samarqand"},
         "posts": [{"text": "c", "likes": 8}]},
    ]

    print("=== 1. record_path (posts → qatorlar) ===")
    df = pd.json_normalize(
        data, record_path="posts", meta=[["user", "name"], ["user", "city"]])
    print(f"  ustunlar: {list(df.columns)}")

    print("\n=== 2. Har post — qator ===")
    print(f"  qatorlar: {len(df)} (postlar yoyildi)")

    print("\n=== 3. meta (user takrorlandi) ===")
    print(f"  nomlar: {df['user.name'].tolist()}")

    print("\n=== 4. Natija ===")
    print(df[["user.name", "text", "likes"]].to_string(index=False))
    print("  ⭐ json_normalize — chuqur (record_path, meta)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. record_path (posts → qatorlar) ===
  ustunlar: ['text', 'likes', 'user.name', 'user.city']

=== 2. Har post — qator ===
  qatorlar: 3 (postlar yoyildi)

=== 3. meta (user takrorlandi) ===
  nomlar: ['Ali', 'Ali', 'Vali']

=== 4. Natija ===
user.name text  likes
      Ali    a     10
      Ali    b      5
     Vali    c      8
  ⭐ json_normalize — chuqur (record_path, meta)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Ro'yxat/obyekt va bo'sh

"""Ro'yxat/obyekt va bo'sh (real Python)."""


def main() -> None:
    data = {
        "a": [1, 2, 3],         # ro'yxat
        "b": {"x": 1},          # obyekt
        "c": [],                # bo'sh ro'yxat
    }

    print("=== 1. isinstance (ro'yxatmi?) ===")
    print(f"  a ro'yxat: {isinstance(data['a'], list)}")
    print(f"  b ro'yxat: {isinstance(data['b'], list)}")

    print("\n=== 2. Bo'sh ro'yxat (IndexError xavfi) ===")
    try:
        _ = data["c"][0]
    except IndexError:
        print("  data['c'][0] → IndexError (bo'sh)")

    print("\n=== 3. Xavfsiz (tekshir) ===")
    birinchi = data["c"][0] if data["c"] else None
    print(f"  birinchi (bo'sh): {birinchi}")

    print("\n=== 4. None zanjir xavfi ===")
    val = data.get("yoq")   # None
    natija = (val or {}).get("x", "default")
    print(f"  None zanjir: {natija}")
    print("  ⭐ isinstance + bo'sh tekshir")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. isinstance (ro'yxatmi?) ===
  a ro'yxat: True
  b ro'yxat: False

=== 2. Bo'sh ro'yxat (IndexError xavfi) ===
  data['c'][0] → IndexError (bo'sh)

=== 3. Xavfsiz (tekshir) ===
  birinchi (bo'sh): None

=== 4. None zanjir xavfi ===
  None zanjir: default
  ⭐ isinstance + bo'sh tekshir

Nima ko'rsatdi: 2.7-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. KeyError (chuqur)

data["user"]["address"]["city"]   # "address" yo'q → KeyError     # ⚠️
data.get("user", {}).get("address", {}).get("city")   # xavfsiz  # ✅

2. None zanjir

data.get("user").get("name")   # user None → None.get xato        # ⚠️
data.get("user", {}).get("name")   # bo'sh dict                   # ✅

3. Bo'sh ro'yxat

data["posts"][0]   # bo'sh → IndexError                           # ⚠️
data["posts"][0] if data["posts"] else None   # tekshir          # ✅

4. Ro'yxat/obyekt faraz

data["x"]["kalit"]   # x ro'yxat bo'lsa → xato                    # ⚠️
if isinstance(data["x"], dict): data["x"]["kalit"]   # tekshir   # ✅

5. Yo'q maydon

[p["likes"] for p in posts]   # likes yo'q → KeyError             # ⚠️
[p.get("likes", 0) for p in posts]   # default                   # ✅

6. Nomuvofiq faraz

# barcha yozuv 3 daraja deb (ba'zisi 2 — xato)                    # ⚠️
# strukturani ko'r/tekshir (nomuvofiq)                            # ✅

7. read_json chuqur

pd.read_json(murakkab)   # ichma-ich → chalkash                   # ⚠️
pd.json_normalize(data, record_path=..., meta=...)               # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 7.3-dars (o'tilgan): JSON asoslari
• 7.7-dars (o'tilgan): API (javob)
• 6.1-dars (o'tilgan): Yo'q qiymat (NaN)
• 7.9-dars: Web scraping (HTML → ma'lumot)
• 7.12-dars: Amaliyot (loyiha)

8. Eng yaxshi amaliyotlar

1. .get zanjir — KeyError yo'q.

2. Strukturani ko'r — nomuvofiq (tekshir).

3. isinstance — ro'yxat/obyekt.

4. Default — yo'q maydon (.get(d)).

5. .get("a", {}) — None zanjir.

6. Bo'sh ro'yxat — tekshir (IndexError).

7. json_normalize — murakkab (record_path).

8. NaN — yo'q maydon (6.1 hal).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # JSON parse nima?
2.  # chuqur kirish?
3.  # KeyError sababi?
4.  # .get zanjir?
5.  # ro'yxat ichida obyekt?
6.  # yo'q maydon?
7.  # json_normalize record_path?
8.  # meta nima?
9.  # isinstance nega?
10. # None zanjir?
11. # bo'sh ro'yxat?
12. # nega chuqur parse?

Vazifa 2: Xatolarni tuzating

1.  data["user"]["address"]["city"]

2.  data.get("user").get("name")

3.  data["posts"][0]

4.  [p["likes"] for p in posts]

5.  pd.read_json(murakkab)

1.  .get("user", {}).get(...)

2.  .get("user", {}).get("name")

3.  [0] if data["posts"] else None

4.  p.get("likes", 0)

5.  json_normalize(record_path=...)

Vazifa 3: Chuqur va xavfsiz

Modellang:

1. Zanjir
2. .get zanjir
3. Default
4. KeyError yo'q

Vazifa 4: Ro'yxat

Modellang:

1. Sikl
2. Comprehension
3. Yo'q maydon
4. record_path

Vazifa 5: Tuzoqlar

Modellang:

1. isinstance
2. Bo'sh ro'yxat
3. None zanjir
4. Nomuvofiq

Vazifa 6: Integratsiya

Modellang:

1. JSON (7.3)
2. API (7.7)
3. NaN (6.1)
4. Loyiha (7.12)

Vazifa 7: O'ylash

Real API javoblari nomuvofiq (ba'zi maydon bor, ba'zisi yo'q) va chuqur (ichma-ich). Ko'r-ko'rona obj["a"]["b"]["c"] yozish bir yozuvda ishlaydi, boshqasida (maydon yo'q) dasturni to'xtatadi. Nima uchun "mudofaaviy dasturlash" (.get, tekshirish) real ma'lumot bilan ishlashda zarur, va nima uchun "ma'lumot doim men kutgandek bo'ladi" farazi xavfli?

Nimani mustahkamlaydi: 2.2, 2.7-bo'limlar.

Xulosa

Bu darsda JSON parse'ni chuqur o'rgandik.

Eng muhim uch fikr:

1. Chuqur va xavfsiz. Chuqur kirish — obj["a"]["b"]["c"] (zanjir — daraja-daraja; ro'yxat [0]). Xavfsiz olish — obj.get("a", {}).get("b") (.get zanjir — kalit yo'q bo'lsa KeyError emas, default; {} keyingi .get uchun; None zanjir xato — .get("a", {})).

2. Ro'yxat va normalize. Ro'yxat ichida obyekt — sikl (for p in posts), comprehension ([p.get("likes", 0) for p in posts]), json_normalize(record_path="posts"). json_normalize (chuqur) — record_path (ro'yxat → qator), meta (yuqori maydon — ichma-ich [["user", "name"]]), sep, max_level (chuqurlik).

3. Murakkab JSON. Real JSON nomuvofiq (maydon bor/yo'q — .get/NaN) va chuqur (ichma-ich). Mudofaaviy dasturlash (.get, tekshir, default — real ma'lumot bilan zarur); "ma'lumot doim men kutgandek" farazi xavfli (bir yozuv ≠ hamma — KeyError to'xtatadi; ma'lumotga ishonma — tekshir). Tuzoqlar: KeyError (.get zanjir), chuqur faraz (struktura ko'r), ro'yxat/obyekt (isinstance), yo'q maydon (default), None zanjir (.get("a", {})), bo'sh ro'yxat (IndexError — tekshir).

Keyingi darsda web scraping (BeautifulSoup)ni o'rganamiz: veb-sahifadan ma'lumot olish (API yo'q bo'lganda) — HTML struktura, BeautifulSoup (teg, klass, find/find_all), va scraping etikasi (robots.txt, hurmat — 7.11 bilan).