7.3-dars: JSON va Parquet

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

1. Kirish va motivatsiya

CSV va Excel — tekis (flat) jadval formatlari. Lekin ma'lumot har doim tekis emas: API javoblari, veb-ilovalar, konfiguratsiya — JSON (JavaScript Object Notation) formatida keladi, ierarxik (ichma-ich) tuzilma bilan. Va katta ma'lumot uchun CSV samarasiz (matn, katta, sekin) — Parquet (ustunli binar format) ancha tez, siqiq va samarali. Bu darsda: JSON o'qish/yozish (json, pd.read_json), ierarxik JSON'ni jadvalga (json_normalize), va Parquet asoslari (nega, qachon). 7.1-darsda semi-structured (JSON) va formatlarni ko'rdik; endi amaliy. Nega muhim? (1) JSON — API/veb standart (ierarxik); (2) Parquet — katta ma'lumot (tez, siqiq); (3) Ierarxik — ichma-ich (jadvalga aylantirish). Bu dars JSON va Parquet formatlarini o'rgatadi — tekis emas ma'lumot.

JSON va Parquet — tekis emas / samarali formatlar: JSON (json.loads/json.dumps — matn↔obyekt; pd.read_json — jadval; ierarxik — API/veb), json_normalize (ierarxik JSON → tekis jadval), Parquet (ustunli binar format — katta ma'lumot, tez, siqiq; to_parquet/read_parquet; pyarrow), ierarxik (ichma-ich — obyekt/massiv), CSV bilan farq (JSON ierarxik, Parquet samarali). Foydalanish: API/veb ma'lumot (JSON), katta ma'lumot (Parquet). Bu 7.1 (semi-structured), 7.2 (CSV), 7.5 (JSON parse), 7.7 (API — JSON) bilan bog'liq. JSON va Parquet — tekis emas / samarali. JSON. Parquet.

Real vaziyat. Data Scientist ob-havo API'sidan javob oldi 7.7-bob. JSON javob: {"shahar": "Toshkent", "harorat": {"hozir": 25, "min": 18, "max": 30}, "kunlar": [22, 24, 26]} — ierarxik (harorat — ichma-ich obyekt; kunlar — massiv). Muammo: pd.read_json to'g'ridan — chalkash (ichma-ich ustun). Hal: json.loads (matn → Python obyekt), keyin pd.json_normalize (ierarxik → tekis: harorat.hozir, harorat.min ustunlar). Va katta tarixiy ma'lumot (10M qator) — CSV sekin/katta (2 GB); Parquet (to_parquet) — 200 MB (10× siqiq), o'qish 5× tez. Data Scientist JSON parse qildi (ierarxik → jadval), katta ma'lumotni Parquetga (samarali). JSON va Parquet — tekis emas / samarali.

Bu darsda JSON va Parquet formatlarini o'rganamiz.

Bu darsda:

• JSON o'qish/yozish (json, read_json)
• json_normalize (ierarxik → tekis)
• Parquet (nega, qachon)
• JSON vs CSV vs Parquet
• Ierarxik tuzilma
• Format amaliyoti
• Format tuzoqlari
• Amaliy: JSON va Parquet

ℹ Misollar real pandas/json bilan (Python 3.14). Parquet — konseptual (pyarrow bu muhitda yo'q).

2. Nazariya — chuqur tushuntirish

2.1. JSON o'qish/yozish (json, read_json)

Matn va obyekt:

import json
import pandas as pd

# json.loads — JSON matn → Python obyekt (dict/list)
obyekt = json.loads('{"shahar": "Toshkent", "narx": 120}')

# json.dumps — Python obyekt → JSON matn
matn = json.dumps({"shahar": "Toshkent"}, ensure_ascii=False)

# pd.read_json — JSON → DataFrame (tekis bo'lsa)
df = pd.read_json("data.json")

# fayldan
with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

JSON o'qish/yozish (json, read_json) — matn↔obyekt: json.loads(matn) (JSON matn → Python obyekt — dict/list), json.dumps(obyekt, ensure_ascii=False) (obyekt → matn; ensure_ascii=False — o'zbekcha harflar saqlanadi, \u... emas), json.load(f)/json.dump(obj, f) (fayldan/faylga), pd.read_json (JSON → DataFrame — tekis bo'lsa). Sabab: JSON — matn format (API/veb — matn uzatiladi); Python'da dict/list (obyekt); loads/dumps (matn↔obyekt); read_json (tekis JSON — to'g'ridan jadval). loads (matn→obyekt), dumps (obyekt→matn), ensure_ascii=False (o'zbekcha), read_json (tekis → jadval). JSON o'qish — json.loads/dumps (matn↔obyekt). JSON. loads.

2.2. json_normalize (ierarxik → tekis)

Ichma-ichni tekislash:

import pandas as pd

# ierarxik JSON (ichma-ich obyekt)
data = [
    {"shahar": "Toshkent", "harorat": {"hozir": 25, "max": 30}},
    {"shahar": "Samarqand", "harorat": {"hozir": 22, "max": 28}},
]

# json_normalize — ierarxik → tekis (harorat.hozir, harorat.max)
df = pd.json_normalize(data)
# ustunlar: shahar, harorat.hozir, harorat.max

# ichma-ich massiv (record_path)
pd.json_normalize(data, record_path="kunlar", meta="shahar")

json_normalize (ierarxik → tekis) — tekislash: pd.json_normalize(data) — ierarxik JSON (ichma-ich obyekt) → tekis jadval (harorat.hozir, harorat.max — nuqta bilan ustun); record_path= (ichma-ich massiv — har element qator), meta= (yuqori daraja maydon — takrorlanadi). Sabab: JSON ierarxik (ichma-ich — obyekt/massiv; pd.DataFrame to'g'ridan — ustun ichida dict, chalkash); json_normalize — tekislaydi (ichma-ich → nuqta ustun; tahlil uchun); API javob (ko'pincha ierarxik). json_normalize (ierarxik → tekis), nuqta ustun (harorat.hozir), record_path (massiv), meta (yuqori). json_normalize — ierarxik → tekis (tekislash). Normalize. Tekis.

2.3. Parquet (nega, qachon)

Parquet (nega, qachon) — samarali format: Parquet — ustunli binar format (df.to_parquet("f.parquet"), pd.read_parquet; pyarrow/fastparquet kutubxona); afzalliklar: siqiq (binar + siqish — CSV'dan 5-10× kichik), tez (ustunli — faqat kerak ustun o'qiladi; CSV — butun qator), tur saqlanadi (sxema — dtype yo'qolmaydi; CSV — matn), katta ma'lumot (samarali). Sabab: CSV samarasiz (matn — katta, sekin, tur yo'q); Parquet — katta ma'lumot/analitika (ustunli — tahlil tez; big data — Spark, ombor). Ustunli (kerak ustun — tez), siqiq (kichik), tur saqlanadi (sxema). Parquet — samarali (katta ma'lumot; ustunli). Parquet. Ustunli.

2.4. JSON vs CSV vs Parquet

JSON vs CSV vs Parquet — qaysi qachon: CSV (tekis jadval — oddiy, universal, odam o'qiy oladi; katta — sekin/katta; tur yo'q), JSON (ierarxik — API/veb, moslashuvchan; tekis emas ma'lumot; katta — samarasiz), Parquet (ustunli binar — katta ma'lumot, tez, siqiq; odam o'qiy olmaydi (binar); ML/analitika). Sabab: maqsad — almashinuv/o'qish (CSV — universal), API/ierarxik (JSON), katta/tez (Parquet); "kichik+universal — CSV; ierarxik — JSON; katta+tez — Parquet". CSV (universal, odam), JSON (ierarxik, API), Parquet (katta, tez). JSON vs CSV vs Parquet — maqsad (universal/ierarxik/katta). Format. Maqsad.

2.5. Ierarxik tuzilma

Ierarxik tuzilma (ichma-ich) — JSON shakli: JSON — ichma-ich (obyekt ichida obyekt/massiv): obyekt ({} — kalit-qiymat; dict), massiv ([] — ro'yxat; list), ichma-ich ({"a": {"b": [1, 2]}} — obyekt→obyekt→massiv); kirish (obj["a"]["b"][0] — zanjir). Sabab: real ma'lumot ierarxik (foydalanuvchi → buyurtmalar → mahsulotlar; ichma-ich; tekis jadval emas); JSON — moslashuvchan (turli chuqurlik); tahlil uchun tekislash (json_normalize — 2.2). Obyekt ({} dict), massiv ([] list), ichma-ich (zanjir), tekislash (normalize). Ierarxik tuzilma — ichma-ich (obyekt/massiv). Ierarxik. Ichma-ich.

2.6. Format amaliyoti

Format amaliyoti: JSON o'qish (json.load fayldan; json.loads matndan; ensure_ascii=False yozishda); tekislash (ierarxik — pd.json_normalize; record_path/meta); kirish (ichma-ich — obj["a"]["b"]; .get() xavfsiz); Parquet (katta ma'lumot — to_parquet/read_parquet; ML/analitika); format tanlash (universal — CSV; API — JSON; katta — Parquet); tekshir (df.head(), df.columns — tekislandimi). Tuzoqlar: read_json ierarxik (chalkash — normalize), ensure_ascii (o'zbekcha \u), ichma-ich kirish (KeyError — .get), Parquet kutubxona (pyarrow kerak), CSV katta (Parquet). Amaliyot — JSON, normalize, Parquet, format. Format. Tekis.

2.7. Format tuzoqlari

Format asosiy tuzoqlari: read_json ierarxik (pd.read_json — tekis JSON uchun; ierarxik (ichma-ich obyekt) — ustun ichida dict (chalkash); json.loads + json_normalize); ensure_ascii (json.dumps — standart ensure_ascii=True (o'zbekcha → t...; o'qib bo'lmas); ensure_ascii=False — harflar saqlanadi); ichma-ich kirish (obj["a"]["b"] — kalit yo'q bo'lsa KeyError; .get("a", {}).get("b") xavfsiz); Parquet kutubxona (to_parquet/read_parquet — pyarrow yoki fastparquet o'rnatilgan bo'lishi kerak; yo'q — xato); CSV katta ma'lumot (10M+ qator CSV — sekin/katta; Parquet samarali); JSON tur (JSON — cheklangan tur (matn, son, bool, null, obyekt, massiv); sana — matn (parse kerak); tuple/set yo'q); read_json orientation (orient= — JSON tuzilishi (records, columns, split); noto'g'ri — xato); katta JSON xotira (butun JSON — xotirada; katta — ijson (oqim) yoki qism); sana JSON (JSON sana yo'q — matn; pd.to_datetime keyin 6.8); NaN JSON (JSON — null (NaN emas); null → NaN o'qiladi). Sabab: format ierarxik/tur/kutubxona nozik (read_json, ensure_ascii, kirish — chalkash yoki xato). Yechim: json_normalize, ensure_ascii=False, .get, pyarrow, Parquet katta. Tuzoqlar — read_json, ensure_ascii, kirish, kutubxona.

2.8. JSON va Parquet — tekis emas va samarali ma'lumot

JSON va Parquet asosiy g'oyasi — tekis emas va samarali ma'lumot: CSV/Excel tekis (flat) jadval, lekin ma'lumot har doim tekis emas (API/veb — JSON ierarxik) va katta ma'lumot CSV samarasiz (Parquet — tez, siqiq). JSON (json.loads/dumps matn↔obyekt; ensure_ascii=False o'zbekcha; pd.read_json tekis; json_normalize ierarxik→tekis — harorat.hozir nuqta ustun; record_path/meta), Parquet (ustunli binar — siqiq (5-10× CSV), tez (kerak ustun), tur saqlanadi (sxema); to_parquet/read_parquet; pyarrow; katta ma'lumot/ML). JSON vs CSV vs Parquet (universal — CSV; ierarxik — JSON; katta+tez — Parquet), ierarxik (ichma-ich obyekt/massiv — tekislash). Foydalanish: API/veb ma'lumot (JSON — ierarxik; 7.7), katta ma'lumot (Parquet — samarali; ML/analitika). Tuzoqlar: read_json ierarxik (chalkash — normalize), ensure_ascii (o'zbekcha \u), ichma-ich kirish (KeyError — .get), Parquet kutubxona (pyarrow), CSV katta (Parquet). Bu 7.1 (semi-structured), 7.2 (CSV), 7.5 (JSON parse chuqurroq), 7.7 (API — JSON), 7.4 (formatlar) bilan. JSON va Parquet — tekis emas (JSON ierarxik) va samarali (Parquet). JSON. Parquet. Ierarxik.

3. Tez ma'lumotnoma

import json
import pandas as pd

# JSON (matn ↔ obyekt):
obyekt = json.loads('{"shahar": "Toshkent"}')          # matn → obyekt
matn = json.dumps(obyekt, ensure_ascii=False)          # obyekt → matn (o'zbekcha)
with open("f.json", encoding="utf-8") as f: data = json.load(f)   # fayldan

# JSON → DataFrame:
pd.read_json("data.json")                              # tekis JSON
pd.json_normalize(data)                                # ierarxik → tekis
pd.json_normalize(data, record_path="kunlar", meta="shahar")  # massiv

# XAVFSIZ KIRISH (ichma-ich):
obj.get("a", {}).get("b")                              # KeyError yo'q

# PARQUET (katta ma'lumot — tez, siqiq; pyarrow):
df.to_parquet("data.parquet")                          # yozish
pd.read_parquet("data.parquet", columns=["a", "b"])    # faqat kerak ustun

# FORMAT TANLASH:
#   universal, odam o'qiydi  → CSV
#   ierarxik (API/veb)       → JSON
#   katta, tez, ML           → Parquet
QOIDA: ierarxik → normalize · ensure_ascii=False · .get · Parquet katta

JSON va Parquet xulosasi

JSON va Parquet — tekis emas (JSON) va samarali (Parquet)
JSON — loads/dumps (matn↔obyekt); ensure_ascii=False (o'zbekcha)
json_normalize — ierarxik → tekis (harorat.hozir nuqta ustun)
Parquet — ustunli binar (siqiq, tez, tur saqlanadi; katta ma'lumot)
Format — CSV (universal), JSON (ierarxik), Parquet (katta)

4. Batafsil misollar

Misollar real pandas/json bilan (Python 3.14). Parquet — konseptual.

Misol 1 — JSON o'qish/yozish

"""JSON o'qish/yozish (real json)."""

import json


def main() -> None:
    print("=== 1. loads (matn → obyekt) ===")
    matn = '{"shahar": "Toshkent", "narx": {"min": 80, "max": 120}}'
    obyekt = json.loads(matn)
    print(f"  obyekt turi: {type(obyekt).__name__}")
    print(f"  narx.min: {obyekt['narx']['min']}")

    print("\n=== 2. dumps (obyekt → matn) ===")
    yangi = {"shahar": "Buxoro", "narx": 90}
    chiqish = json.dumps(yangi, ensure_ascii=False)
    print(f"  matn: {chiqish}")

    print("\n=== 3. ensure_ascii=False (o'zbekcha) ===")
    ozbek = {"izoh": "arzon uy"}
    print(f"  False: {json.dumps(ozbek, ensure_ascii=False)}")
    print(f"  True: {json.dumps(ozbek, ensure_ascii=True)}")

    print("\n=== 4. Xavfsiz kirish (.get) ===")
    print(f"  bor: {obyekt.get('shahar')}")
    print(f"  yo'q (.get): {obyekt.get('yosh', 'yo`q')}")
    print("  ⭐ JSON — loads/dumps (matn↔obyekt)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. loads (matn → obyekt) ===
  obyekt turi: dict
  narx.min: 80

=== 2. dumps (obyekt → matn) ===
  matn: {"shahar": "Buxoro", "narx": 90}

=== 3. ensure_ascii=False (o'zbekcha) ===
  False: {"izoh": "arzon uy"}
  True: {"izoh": "arzon uy"}

=== 4. Xavfsiz kirish (.get) ===
  bor: Toshkent
  yo'q (.get): yo`q
  ⭐ JSON — loads/dumps (matn↔obyekt)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — json_normalize (ierarxik → tekis)

"""json_normalize: ierarxik → tekis (real pandas)."""

import pandas as pd


def main() -> None:
    data = [
        {"shahar": "Toshkent", "harorat": {"hozir": 25, "max": 30}},
        {"shahar": "Samarqand", "harorat": {"hozir": 22, "max": 28}},
    ]

    print("=== 1. To'g'ridan DataFrame (chalkash) ===")
    xato = pd.DataFrame(data)
    print(f"  harorat ustuni: {xato['harorat'].tolist()}")
    print("  (ustun ichida dict — chalkash)")

    print("\n=== 2. json_normalize (tekis) ===")
    df = pd.json_normalize(data)
    print(f"  ustunlar: {list(df.columns)}")

    print("\n=== 3. Nuqta ustun (harorat.hozir) ===")
    print(f"  hozir: {df['harorat.hozir'].tolist()}")

    print("\n=== 4. Endi tahlil ===")
    print(f"  o'rtacha hozir: {df['harorat.hozir'].mean().round(1)}")
    print("  ⭐ json_normalize — ierarxik → tekis")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. To'g'ridan DataFrame (chalkash) ===
  harorat ustuni: [{'hozir': 25, 'max': 30}, {'hozir': 22, 'max': 28}]
  (ustun ichida dict — chalkash)

=== 2. json_normalize (tekis) ===
  ustunlar: ['shahar', 'harorat.hozir', 'harorat.max']

=== 3. Nuqta ustun (harorat.hozir) ===
  hozir: [25, 22]

=== 4. Endi tahlil ===
  o'rtacha hozir: 23.5
  ⭐ json_normalize — ierarxik → tekis

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Ichma-ich massiv (record_path)

"""Ichma-ich massiv: record_path (real pandas)."""

import pandas as pd


def main() -> None:
    data = [
        {"shahar": "Toshkent", "kunlar": [{"kun": 1, "narx": 100}, {"kun": 2, "narx": 110}]},
        {"shahar": "Samarqand", "kunlar": [{"kun": 1, "narx": 80}]},
    ]

    print("=== 1. record_path (massivni yoyish) ===")
    df = pd.json_normalize(data, record_path="kunlar", meta="shahar")
    print(f"  ustunlar: {list(df.columns)}")

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

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

    print("\n=== 4. Natija ===")
    print(df[["shahar", "kun", "narx"]].to_string(index=False))
    print("  ⭐ record_path — ichma-ich massiv")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. record_path (massivni yoyish) ===
  ustunlar: ['kun', 'narx', 'shahar']

=== 2. Har element — qator ===
  qatorlar: 3 (massivlar yoyildi)

=== 3. meta (shahar takrorlandi) ===
  shaharlar: ['Toshkent', 'Toshkent', 'Samarqand']

=== 4. Natija ===
   shahar  kun  narx
 Toshkent    1   100
 Toshkent    2   110
Samarqand    1    80
  ⭐ record_path — ichma-ich massiv

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Format taqqoslash

"""Format taqqoslash (real pandas/json)."""

import json
import pandas as pd


def main() -> None:
    df = pd.DataFrame({"shahar": ["Toshkent", "Samarqand"], "narx": [120, 80]})

    print("=== 1. CSV (universal, odam o'qiydi) ===")
    csv = df.to_csv(index=False)
    print(f"  CSV:\n{csv.strip()}")

    print("\n=== 2. JSON (ierarxik, API) ===")
    json_matn = df.to_json(orient="records", force_ascii=False)
    print(f"  JSON: {json_matn}")

    print("\n=== 3. Parquet (katta, tez — konseptual) ===")
    print("  Parquet: ustunli binar (5-10x siqiq, tez)")
    print("  df.to_parquet('f.parquet') — pyarrow kerak")

    print("\n=== 4. Format tanlash ===")
    print("  universal — CSV; API — JSON; katta — Parquet")
    print("  ⭐ Format — maqsadga qarab")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. CSV (universal, odam o'qiydi) ===
  CSV:
shahar,narx

Toshkent,120

Samarqand,80

=== 2. JSON (ierarxik, API) ===
  JSON: [{"shahar":"Toshkent","narx":120},{"shahar":"Samarqand","narx":80}]

=== 3. Parquet (katta, tez — konseptual) ===
  Parquet: ustunli binar (5-10x siqiq, tez)
  df.to_parquet('f.parquet') — pyarrow kerak

=== 4. Format tanlash ===
  universal — CSV; API — JSON; katta — Parquet
  ⭐ Format — maqsadga qarab

Nima ko'rsatdi: 2.4-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. read_json ierarxik

pd.read_json("data.json")   # ichma-ich → chalkash                # ⚠️
pd.json_normalize(json.load(f))   # tekislash                    # ✅

2. ensure_ascii (o'zbekcha)

json.dumps({"a": "arzon"})   # a... (o'qib bo'lmas)          # ⚠️
json.dumps({"a": "arzon"}, ensure_ascii=False)   # arzon         # ✅

3. Ichma-ich kirish (KeyError)

obj["a"]["b"]   # "a" yo'q → KeyError                              # ⚠️
obj.get("a", {}).get("b")   # xavfsiz                             # ✅

4. Parquet kutubxona

df.to_parquet("f.parquet")   # pyarrow yo'q → xato                # ⚠️
# pip install pyarrow (yoki fastparquet)                          # ✅

5. Katta CSV

pd.read_csv("katta_10gb.csv")   # sekin, xotira                   # ⚠️
pd.read_parquet("data.parquet")   # tez, siqiq                   # ✅

6. JSON sana

df["sana"]   # JSON sana — matn (datetime emas)                   # ⚠️
pd.to_datetime(df["sana"])   # parse 6.8-bob                       # ✅

7. orient noto'g'ri

pd.read_json(matn)   # orient noto'g'ri → xato                    # ⚠️
pd.read_json(matn, orient="records")   # tuzilma mos             # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 7.1-dars (o'tilgan): Semi-structured (JSON)
• 7.2-dars (o'tilgan): CSV/Excel
• 7.5-dars: JSON parse (chuqurroq)
• 7.7-dars: API (JSON javob)
• 7.10-dars: Katta fayllar (Parquet)

8. Eng yaxshi amaliyotlar

1. JSON — json.loads/dumps.

2. ensure_ascii=False — o'zbekcha.

3. Ierarxik — json_normalize.

4. Xavfsiz kirish — .get.

5. Katta ma'lumot — Parquet.

6. Format — maqsadga (CSV/JSON/Parquet).

7. JSON sana — to_datetime (parse).

8. Parquet — columns= (kerak ustun).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # JSON nima?
2.  # loads vs dumps?
3.  # ensure_ascii?
4.  # read_json qachon?
5.  # json_normalize?
6.  # record_path?
7.  # Parquet nima?
8.  # nega Parquet?
9.  # CSV vs JSON vs Parquet?
10. # ichma-ich kirish?
11. # JSON'da sana?
12. # nega tekis emas?

Vazifa 2: Xatolarni tuzating

1.  pd.read_json("data.json")   # ichma-ich

2.  json.dumps({"a": "arzon"})

3.  obj["a"]["b"]   # "a" yo'q

4.  df.to_parquet("f.parquet")   # pyarrow

5.  df["sana"]   # JSON matn

1.  json_normalize (tekislash)

2.  ensure_ascii=False

3.  obj.get("a", {}).get("b")

4.  pip install pyarrow

5.  pd.to_datetime(df["sana"])

Vazifa 3: JSON

Modellang:

1. loads
2. dumps
3. ensure_ascii
4. read_json

Vazifa 4: Normalize

Modellang:

1. json_normalize
2. Nuqta ustun
3. record_path
4. meta

Vazifa 5: Parquet va format

Modellang:

1. Ustunli binar
2. Siqiq, tez
3. CSV/JSON/Parquet
4. Maqsad

Vazifa 6: Integratsiya

Modellang:

1. Semi-structured (7.1)
2. JSON parse (7.5)
3. API (7.7)
4. Katta fayl (7.10)

Vazifa 7: O'ylash

JSON ierarxik (ichma-ich), CSV tekis, Parquet ustunli binar — uch format, uch maqsad. Bu shuni ko'rsatadiki, "eng yaxshi format" yo'q — kontekstga (universallik, ierarxiya, hajm) bog'liq. Nima uchun format tanlash muhim qaror, va nima uchun bir format boshqasidan avtomatik "yaxshiroq" emas?

Nimani mustahkamlaydi: 2.4, 2.7-bo'limlar.

Xulosa

Bu darsda JSON va Parquet formatlarini o'rgandik.

Eng muhim uch fikr:

1. JSON o'qish va normalize. JSON — json.loads(matn) (matn → obyekt dict/list), json.dumps(obj, ensure_ascii=False) (obyekt → matn; ensure_ascii=False o'zbekcha harflar saqlanadi), json.load/dump (fayl), pd.read_json (tekis JSON). pd.json_normalize(data) — ierarxik JSON → tekis jadval (harorat.hozir nuqta ustun; record_path ichma-ich massiv, meta yuqori maydon).

2. Parquet va format. Parquet — ustunli binar format (to_parquet/read_parquet; pyarrow): siqiq (5-10× CSV), tez (kerak ustun — columns=), tur saqlanadi (sxema); katta ma'lumot/ML/analitika (odam o'qiy olmaydi — binar). Format tanlash: CSV (universal, odam), JSON (ierarxik, API), Parquet (katta, tez).

3. Tekis emas va samarali. JSON — ierarxik (ichma-ich obyekt/massiv — API/veb; tekislash json_normalize); Parquet — samarali (katta ma'lumot). Eng yaxshi format yo'q — kontekstga (maqsad/hajm/tuzilma; almashuv). Tuzoqlar: read_json ierarxik (chalkash — normalize), ensure_ascii (o'zbekcha \u — False), ichma-ich kirish (KeyError — .get), Parquet kutubxona (pyarrow), CSV katta (Parquet), JSON sana (matn — parse), orient (tuzilma mos).

Keyingi darsda saqlash formatlarini o'rganamiz: qaysi format qachon (CSV/JSON/Parquet/SQLite — tanlash mezonlari — hajm, tezlik, universallik, tur), va yig'ilgan ma'lumotni to'g'ri saqlash (7.2-7.3 sintezi).