7.4-dars: Saqlash formatlari

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

1. Kirish va motivatsiya

7.2-7.3 darslarda formatlar (CSV, Excel, JSON, Parquet) bilan tanishdik. Endi savol: yig'ilgan ma'lumotni qaysi formatda saqlash? Bu muhim qaror — noto'g'ri format sekinlik, katta hajm, tur yo'qolishi, yoki qayta o'qishda muammoga olib keladi. Bu darsda saqlash formatlarini tanlash mezonlari: hajm (siqiqlik), tezlik (o'qish/yozish), universallik (kim o'qiydi), tur saqlash (schema), va amaliy saqlash qoidalari (nomlash, versiyalash, papka tuzilishi). Bundan tashqari SQLite (mahalliy baza — bir fayl, so'rov). Data Scientist yig'ilgan/qayta ishlangan ma'lumotni oqilona saqlaydi — keyingi bosqich uchun. Nega muhim? (1) Qaror — noto'g'ri format muammo (sekinlik, hajm); (2) Mezonlar — hajm/tezlik/universallik/tur; (3) Amaliy — nomlash, versiyalash. Bu dars saqlash formatlarini o'rgatadi — qaysi format qachon.

Saqlash formatlari — qaysi format qachon: mezonlar (hajm/siqiqlik, tezlik, universallik, tur saqlash), CSV (universal, odam — kichik/almashinuv), Parquet (siqiq, tez, tur — katta/ML), JSON (ierarxik — API/veb), SQLite (mahalliy baza — bir fayl, so'rov), amaliy (nomlash, versiyalash, papka; data/xom/, data/toza/). Foydalanish: yig'ilgan ma'lumotni oqilona saqlash, keyingi bosqich uchun. Bu 7.2 (CSV), 7.3 (JSON/Parquet), 7.5 (SQL) bilan bog'liq. Saqlash formatlari — qaysi format qachon. Format. Mezon.

Real vaziyat. Data Scientist 5 GB tarixiy savdo ma'lumotini tozaladi (6-qism) — endi saqlash kerak. Noto'g'ri: CSV (to_csv) — 5 GB (matn; sekin o'qish; sana matn bo'lib qoladi — tur yo'q). To'g'ri: Parquet (to_parquet) — 500 MB (10× siqiq; o'qish tez; sana/tur saqlanadi — sxema). Va nomlash (savdo_toza_2024-06.parquet — mazmunli, sana), papka (data/xom/, data/toza/ — bosqich), versiyalash (asl xom saqlanadi — qayta ishlash mumkin). Data Scientist Parquetga saqladi (samarali), oqilona nomladi (mazmun, sana, papka). Saqlash formatlari — oqilona tanlash.

Bu darsda saqlash formatlarini o'rganamiz.

Bu darsda:

• Tanlash mezonlari (hajm/tezlik/universallik)
• Format taqqoslash (CSV/Parquet/JSON/SQLite)
• SQLite (mahalliy baza)
• Nomlash va versiyalash
• Papka tuzilishi (xom/toza)
• Saqlash amaliyoti
• Saqlash tuzoqlari
• Amaliy: format tanlash

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

2. Nazariya — chuqur tushuntirish

2.1. Tanlash mezonlari (hajm/tezlik/universallik)

To'rt mezon:

SAQLASH FORMATI — TANLASH MEZONLARI:
  HAJM (siqiqlik)     — Parquet siqiq (10x); CSV katta (matn)
  TEZLIK (o'qish)     — Parquet tez (ustunli); CSV sekin
  UNIVERSALLIK        — CSV universal (odam, Excel); Parquet maxsus
  TUR SAQLASH (schema)— Parquet/SQLite tur; CSV matn (tur yo'q)
  ODAM O'QIYDIMI      — CSV/JSON ha; Parquet/SQLite yo'q (binar)

Tanlash mezonlari (hajm/tezlik/universallik) — to'rt mezon: hajm (siqiqlik — Parquet siqiq (10× kichik); CSV katta (matn)), tezlik (o'qish/yozish — Parquet tez (ustunli — kerak ustun); CSV sekin (butun)), universallik (CSV universal — odam, Excel, har vosita; Parquet maxsus — kutubxona kerak), tur saqlash (schema — Parquet/SQLite tur saqlanadi (sana, son — sxema); CSV matn (tur yo'qoladi — qayta parse)). Sabab: maqsad har mezonni tortadi (almashinuv — universal CSV; katta/tez — Parquet; tur muhim — Parquet/SQLite); "nima muhim?" (hajm/tezlik/universallik/tur). Hajm (Parquet siqiq), tezlik (Parquet), universallik (CSV), tur (Parquet/SQLite). Tanlash mezonlari — hajm/tezlik/universallik/tur. Mezon. Maqsad.

2.2. Format taqqoslash (CSV/Parquet/JSON/SQLite)

Format taqqoslash (CSV/Parquet/JSON/SQLite) — qaysi qachon: CSV (universal, odam, Excel; kichik ma'lumot, almashinuv, ochiq; katta — sekin, tur yo'q), Parquet (siqiq, tez, tur; katta ma'lumot, ML, analitika; odam o'qiy olmaydi), JSON (ierarxik; API/veb, konfiguratsiya, moslashuvchan; katta — samarasiz), SQLite (mahalliy baza — bir fayl; so'rov (SQL), ko'p jadval, munosabat; ilova ma'lumoti). Sabab: maqsad/kontekst (almashinuv — CSV; katta — Parquet; ierarxik — JSON; so'rov/munosabat — SQLite); "ma'lumot qanday ishlatiladi?". CSV (universal), Parquet (katta/tez), JSON (ierarxik), SQLite (so'rov/baza). Format taqqoslash — CSV/Parquet/JSON/SQLite (maqsad). Format. Taqqoslash.

2.3. SQLite (mahalliy baza)

SQLite (mahalliy baza) — bir fayl baza: SQLite — serversiz ma'lumotlar bazasi (bir fayl .db; server o'rnatish yo'q; Python o'rnatilgan — sqlite3); df.to_sql("jadval", conn) (DataFrame → SQLite), pd.read_sql("SELECT * FROM jadval", conn) (SQL so'rov → DataFrame; 7.6). Sabab: baza afzalliklari (so'rov — SQL, qism olish; ko'p jadval, munosabat; tur saqlanadi) lekin oddiy (bir fayl — server yo'q; ulashish oson); CSV'dan kuchliroq (so'rov, munosabat), PostgreSQL'dan oddiyroq (server yo'q). .db fayl (serversiz), to_sql/read_sql (yozish/so'rov), SQL (qism, munosabat). SQLite — mahalliy baza (bir fayl, so'rov). SQLite. Bir fayl.

2.4. Nomlash va versiyalash

Nomlash va versiyalash — tartibli: nomlash (mazmunli nom — savdo_toza_2024-06.parquet; nima (savdo), holat (toza/xom), sana (2024-06); NOT data1.csv, final_v2_FINAL.csv), versiyalash (asl saqla — xom ma'lumot o'zgartirmasdan; qayta ishlash mumkin; git kod uchun, ma'lumot katta — DVC/papka), sana (yig'ilgan/qayta ishlangan sana — nomda yoki metadata). Sabab: topish/tartib (mazmunli nom — 6 oydan keyin tushunarli; data_final_2.csv — chalkash); takrorlanuvchanlik (asl saqla — 6.11; qayta ishlash; xom yo'qolmasin). Mazmunli nom (nima/holat/sana), asl saqla (xom — o'zgartirma), versiya (sana/git). Nomlash/versiyalash — mazmunli nom, asl saqla. Nom. Versiya.

2.5. Papka tuzilishi (xom/toza)

Papka tuzilishi (xom/toza) — bosqich bo'yicha: standart tuzilma (data/xom/ (raw — asl, o'zgartirmagan), data/toza/ (processed — tozalangan), data/oraliq/ (interim — vaqtincha), data/natija/ (final — chiqish)); kod alohida (src/ — skript; notebooks/ — tahlil). Sabab: tartib (bosqich — xom→toza→natija; qayerda nima); asl saqla (xom/ — hech qachon o'zgartirma; qayta ishlash manbai); "loyiha tuzilishi" (Cookiecutter Data Science — standart). xom/ (asl), toza/ (ishlangan), natija/ (chiqish), src/ (kod). Papka tuzilishi — xom/toza/natija (bosqich). Papka. Bosqich.

2.6. Saqlash amaliyoti

Saqlash amaliyoti: maqsad (ma'lumot qanday ishlatiladi — almashinuv/katta/so'rov/ierarxik); format (universal — CSV; katta — Parquet; so'rov — SQLite; ierarxik — JSON); asl saqla (data/xom/ — o'zgartirmagan); mazmunli nom (nima/holat/sana); tur saqla (Parquet/SQLite — sana/son; CSV — parse qayta); metadata (manba, sana, ustun ma'nosi — data dictionary); tekshir (qayta o'qib — to'g'rimi). Tuzoqlar: CSV katta (Parquet), tur yo'qoladi (CSV — Parquet/SQLite), nom noaniq (data1), asl o'zgartirish (xom yo'qoladi), metadata yo'q (ustun ma'nosi). Amaliyot — maqsad, format, nom, asl saqla. Saqlash. Oqilona.

2.7. Saqlash tuzoqlari

Saqlash asosiy tuzoqlari: katta CSV (katta ma'lumot (GB) CSV — sekin/katta (matn; o'qish sekin; disk); Parquet (siqiq, tez)); tur yo'qolishi (CSV — matn (sana, son — matn bo'lib qoladi; qayta o'qishda parse — 6.4); Parquet/SQLite — tur saqlanadi (sxema)); nom noaniq (data.csv, data1.csv, final_v2_FINAL.csv — chalkash (nima? qachon?); mazmunli — savdo_toza_2024-06.parquet); asl o'zgartirish (xom ma'lumotni ustidan yozish (tozalangan bilan) — asl yo'qoladi (qayta ishlash yo'q; xato tuzatib bo'lmas); xom/ o'zgartirma); metadata yo'q (ma'lumot — ustun ma'nosi/birlik/manba (data dictionary) yozilmagan; keyin tushunib bo'lmas); CSV vergul ichida (matn ustunda vergul ("Toshkent, O'zbekiston") — CSV buziladi; qo'shtirnoq (quoting) yoki boshqa ajratgich); kodlash (saqlashda encoding="utf-8" — o'zbekcha; unutsa — buziq); index yozish (to_csv — index=False; 7.2); siqish unut (CSV — to_csv("f.csv.gz", compression="gzip") — siqish mumkin; katta CSV siqmay — katta); Excel katta (Excel — 1M qator chegara; katta — CSV/Parquet; Excel oddiy hisobot). Sabab: saqlash format/tur/nom nozik (katta CSV, tur, nom, asl — sekin yoki yo'qotish). Yechim: Parquet katta, tur saqla, mazmunli nom, asl saqla, metadata. Tuzoqlar — katta CSV, tur, nom, asl.

2.8. Saqlash formatlari — oqilona tanlash

Saqlash formatlari asosiy g'oyasi — oqilona tanlash: yig'ilgan/qayta ishlangan ma'lumotni qaysi formatda saqlash — muhim qaror (noto'g'ri — sekinlik, hajm, tur yo'qolishi). Tanlash mezonlari: hajm (siqiqlik — Parquet 10×), tezlik (o'qish — Parquet ustunli), universallik (CSV — odam/Excel), tur saqlash (schema — Parquet/SQLite). Format: CSV (universal, odam — kichik/almashinuv), Parquet (siqiq, tez, tur — katta/ML), JSON (ierarxik — API/veb), SQLite (mahalliy baza — bir fayl, so'rov/munosabat). Amaliy: mazmunli nom (nima/holat/sana — savdo_toza_2024-06.parquet), asl saqla (data/xom/ — o'zgartirma), papka tuzilishi (xom/toza/natija — bosqich), metadata (data dictionary — ustun ma'nosi). Foydalanish: yig'ilgan ma'lumotni oqilona saqlash (keyingi bosqich), format tanlash (maqsadga). Tuzoqlar: katta CSV (Parquet), tur yo'qolishi (Parquet/SQLite), nom noaniq (mazmunli), asl o'zgartirish (xom saqla), metadata yo'q (data dictionary), CSV vergul (quoting), Excel katta (1M chegara). Bu 7.2 (CSV), 7.3 (JSON/Parquet), 7.5-7.6 (SQL/SQLite), 6.11 (takrorlanuvchanlik) bilan. Saqlash formatlari — oqilona tanlash (mezonlar; format; nomlash). Format. Oqilona. Mezon.

3. Tez ma'lumotnoma

import pandas as pd
import sqlite3

# FORMAT TANLASH (maqsadga qarab):
#   universal, odam, Excel   → CSV      (df.to_csv, index=False)
#   katta, tez, tur, ML      → Parquet  (df.to_parquet)
#   ierarxik, API/veb        → JSON     (df.to_json / json.dump)
#   so'rov, ko'p jadval      → SQLite   (df.to_sql)

# MEZONLAR:
#   hajm (Parquet 10x siqiq) · tezlik (Parquet) · universallik (CSV) · tur (Parquet/SQLite)

# SQLITE (mahalliy baza — bir fayl):
conn = sqlite3.connect("loyiha.db")
df.to_sql("savdo", conn, if_exists="replace", index=False)
natija = pd.read_sql("SELECT * FROM savdo WHERE narx > 100", conn)
conn.close()

# NOMLASH: savdo_toza_2024-06.parquet (nima_holat_sana)
# PAPKA: data/xom/ (asl) · data/toza/ (ishlangan) · data/natija/
# ASL SAQLA: xom/ ni o'zgartirma (qayta ishlash manbai)

QOIDA: maqsad → format · tur saqla · mazmunli nom · asl saqla · metadata

Saqlash formatlari xulosasi

Saqlash formatlari — oqilona tanlash (noto'g'ri: sekinlik, hajm)
Mezonlar — hajm (Parquet), tezlik (Parquet), universallik (CSV), tur
Format — CSV (universal), Parquet (katta), JSON (ierarxik), SQLite (so'rov)
SQLite — mahalliy baza (bir fayl, SQL so'rov)
Amaliy — mazmunli nom, asl saqla (xom/), papka tuzilishi, metadata

4. Batafsil misollar

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

Misol 1 — Format tanlash (mezonlar)

"""Format tanlash (real Python)."""


def format_tanla(maqsad):
    """Maqsadga qarab format."""
    xarita = {
        "almashinuv_odam": "CSV (universal, Excel)",
        "katta_tez_ml": "Parquet (siqiq, tez, tur)",
        "api_ierarxik": "JSON (ierarxik)",
        "sorov_kop_jadval": "SQLite (baza, SQL)",
    }
    return xarita.get(maqsad, "noma'lum")


def main() -> None:
    print("=== 1. Almashinuv/odam ===")
    print(f"  {format_tanla('almashinuv_odam')}")

    print("\n=== 2. Katta/tez/ML ===")
    print(f"  {format_tanla('katta_tez_ml')}")

    print("\n=== 3. API/ierarxik ===")
    print(f"  {format_tanla('api_ierarxik')}")

    print("\n=== 4. So'rov/ko'p jadval ===")
    print(f"  {format_tanla('sorov_kop_jadval')}")
    print("  ⭐ Format — maqsadga (mezonlar)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Almashinuv/odam ===
  CSV (universal, Excel)

=== 2. Katta/tez/ML ===
  Parquet (siqiq, tez, tur)

=== 3. API/ierarxik ===
  JSON (ierarxik)

=== 4. So'rov/ko'p jadval ===
  SQLite (baza, SQL)
  ⭐ Format — maqsadga (mezonlar)

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

Misol 2 — SQLite (mahalliy baza)

"""SQLite: mahalliy baza (real sqlite3/pandas)."""

import sqlite3
import pandas as pd


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

    print("=== 1. SQLite'ga yozish (to_sql) ===")
    conn = sqlite3.connect(":memory:")   # xotirada (test)
    df.to_sql("savdo", conn, index=False, if_exists="replace")
    print("  jadval: savdo (3 qator)")

    print("\n=== 2. SQL so'rov (read_sql) ===")
    natija = pd.read_sql("SELECT * FROM savdo WHERE narx > 75", conn)
    print(f"  narx > 75: {natija['shahar'].tolist()}")

    print("\n=== 3. Agregatsiya (SQL) ===")
    ort = pd.read_sql("SELECT AVG(narx) AS ortacha FROM savdo", conn)
    print(f"  o'rtacha narx: {ort['ortacha'][0]:.1f}")

    print("\n=== 4. Bir fayl baza ===")
    print("  SQLite — serversiz (bir .db fayl; SQL so'rov)")
    conn.close()
    print("  ⭐ SQLite — mahalliy baza (so'rov)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. SQLite'ga yozish (to_sql) ===
  jadval: savdo (3 qator)

=== 2. SQL so'rov (read_sql) ===
  narx > 75: ['Toshkent', 'Samarqand']

=== 3. Agregatsiya (SQL) ===
  o'rtacha narx: 90.0

=== 4. Bir fayl baza ===
  SQLite — serversiz (bir .db fayl; SQL so'rov)
  ⭐ SQLite — mahalliy baza (so'rov)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Nomlash va papka

"""Nomlash va papka (real Python)."""

from datetime import date


def fayl_nomi(nima, holat, sana=None):
    """Mazmunli fayl nomi."""
    sana = sana or date(2024, 6, 1)
    return f"{nima}_{holat}_{sana.strftime('%Y-%m')}.parquet"


def main() -> None:
    print("=== 1. Mazmunli nom ===")
    nom = fayl_nomi("savdo", "toza")
    print(f"  {nom}")

    print("\n=== 2. Noto'g'ri nomlar ===")
    yomon = ["data1.csv", "final.csv", "final_v2_FINAL.csv"]
    print(f"  yomon: {yomon} (chalkash)")

    print("\n=== 3. Papka tuzilishi ===")
    papkalar = ["data/xom/", "data/toza/", "data/natija/", "src/"]
    for p in papkalar:
        print(f"  {p}")

    print("\n=== 4. Asl saqlash ===")
    print("  data/xom/ — o'zgartirma (qayta ishlash manbai)")
    print("  ⭐ Nomlash (nima_holat_sana) + papka (bosqich)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Mazmunli nom ===
  savdo_toza_2024-06.parquet

=== 2. Noto'g'ri nomlar ===
  yomon: ['data1.csv', 'final.csv', 'final_v2_FINAL.csv'] (chalkash)

=== 3. Papka tuzilishi ===
  data/xom/
  data/toza/
  data/natija/
  src/

=== 4. Asl saqlash ===
  data/xom/ — o'zgartirma (qayta ishlash manbai)
  ⭐ Nomlash (nima_holat_sana) + papka (bosqich)

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

Misol 4 — Tur saqlash (CSV vs baza)

"""Tur saqlash: CSV vs baza (real pandas/sqlite3/tempfile)."""

import sqlite3
import tempfile
from pathlib import Path
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "sana": pd.to_datetime(["2024-01-15", "2024-03-20"]),
        "narx": [120, 80],
    })

    print("=== 1. Asl turlar ===")
    print(f"  sana turi: {df['sana'].dtype}")

    print("\n=== 2. CSV — tur yo'qoladi ===")
    yol = Path(tempfile.gettempdir()) / "test_ds74.csv"
    df.to_csv(yol, index=False)
    csv_qayta = pd.read_csv(yol)
    print(f"  CSV qayta sana turi: {csv_qayta['sana'].dtype} (matn!)")

    print("\n=== 3. SQLite — tur (deyarli) saqlanadi ===")
    conn = sqlite3.connect(":memory:")
    df.to_sql("t", conn, index=False)
    sql_qayta = pd.read_sql("SELECT * FROM t", conn, parse_dates=["sana"])
    print(f"  SQLite qayta sana turi: {sql_qayta['sana'].dtype}")
    conn.close()

    print("\n=== 4. Parquet — tur to'liq (konseptual) ===")
    print("  Parquet: sxema — sana/son tur saqlanadi")
    yol.unlink()
    print("  ⭐ Tur saqlash — CSV (yo'q) vs baza/Parquet")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Asl turlar ===
  sana turi: datetime64[us]

=== 2. CSV — tur yo'qoladi ===
  CSV qayta sana turi: str (matn!)

=== 3. SQLite — tur (deyarli) saqlanadi ===
  SQLite qayta sana turi: datetime64[us]

=== 4. Parquet — tur to'liq (konseptual) ===
  Parquet: sxema — sana/son tur saqlanadi
  ⭐ Tur saqlash — CSV (yo'q) vs baza/Parquet

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Katta CSV

katta_df.to_csv("data.csv")   # 5 GB (sekin)                      # ⚠️
katta_df.to_parquet("data.parquet")   # 500 MB (tez)             # ✅

2. Tur yo'qolishi

df.to_csv("data.csv")   # sana → matn (qayta parse)               # ⚠️
df.to_parquet("data.parquet")   # tur saqlanadi                  # ✅

3. Nom noaniq

df.to_csv("data1.csv")   # nima? qachon? (chalkash)               # ⚠️
df.to_csv("savdo_toza_2024-06.csv")   # mazmunli                 # ✅

4. Asl o'zgartirish

df_toza.to_csv("data/xom/savdo.csv")   # asl ustidan!             # ⚠️
df_toza.to_csv("data/toza/savdo.csv")   # toza papka             # ✅

5. Metadata yo'q

df.to_csv("data.csv")   # ustun ma'nosi? birlik? (noma'lum)       # ⚠️
# data dictionary (ustun, birlik, manba)                          # ✅

6. CSV vergul ichida

df.to_csv("data.csv")   # "Toshkent, UZ" → CSV buziladi           # ⚠️
df.to_csv("data.csv")   # pandas avtomatik qo'shtirnoq (odatda OK) # ✅

7. Excel katta ma'lumot

katta_df.to_excel("data.xlsx")   # 1M qator chegara               # ⚠️
katta_df.to_parquet("data.parquet")   # cheksiz                  # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 7.2-dars (o'tilgan): CSV/Excel
• 7.3-dars (o'tilgan): JSON/Parquet
• 7.5-7.6-dars: SQL/SQLite (so'rov)
• 6.11-dars (o'tilgan): Takrorlanuvchanlik (asl saqla)
• Ish: Loyiha tuzilishi

8. Eng yaxshi amaliyotlar

1. Maqsad → format (mezonlar).

2. Katta — Parquet (siqiq, tez).

3. Tur muhim — Parquet/SQLite.

4. Mazmunli nom (nima_holat_sana).

5. Asl saqla — data/xom/ (o'zgartirma).

6. Papka — xom/toza/natija.

7. Metadata — data dictionary.

8. SQLite — so'rov/ko'p jadval.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # saqlash formati nima?
2.  # mezonlar?
3.  # CSV qachon?
4.  # Parquet qachon?
5.  # SQLite nima?
6.  # tur saqlash?
7.  # nomlash?
8.  # asl saqlash?
9.  # papka tuzilishi?
10. # metadata?
11. # katta CSV?
12. # nega format muhim?

Vazifa 2: Xatolarni tuzating

1.  katta_df.to_csv("data.csv")

2.  df.to_csv("data.csv")   # sana

3.  df.to_csv("data1.csv")

4.  df_toza.to_csv("data/xom/s.csv")

5.  katta_df.to_excel("data.xlsx")

1.  to_parquet (katta)

2.  to_parquet (tur saqla)

3.  savdo_toza_2024-06.csv

4.  data/toza/s.csv

5.  to_parquet (1M chegara)

Vazifa 3: Mezonlar

Modellang:

1. Hajm
2. Tezlik
3. Universallik
4. Tur

Vazifa 4: Format

Modellang:

1. CSV
2. Parquet
3. JSON
4. SQLite

Vazifa 5: Amaliy

Modellang:

1. Nomlash
2. Asl saqla
3. Papka
4. Metadata

Vazifa 6: Integratsiya

Modellang:

1. CSV (7.2)
2. Parquet (7.3)
3. SQLite (7.5)
4. Takrorlanuvchanlik (6.11)

Vazifa 7: O'ylash

Saqlash formatini tanlash "kichik" texnik qaror kabi ko'rinadi, lekin u keyingi barcha ishga ta'sir qiladi: sekin o'qish, tur yo'qolishi, katta hajm, yoki hamkasb tushunmasligi. Ayniqsa "asl (xom) ma'lumotni saqlash" tamoyili muhim. Nima uchun xom ma'lumotni hech qachon o'zgartirmaslik kerak, va nima uchun saqlash qarorlari loyihaning uzoq muddatli sog'lig'iga ta'sir qiladi?

Nimani mustahkamlaydi: 2.4, 2.5-bo'limlar.

Xulosa

Bu darsda saqlash formatlarini o'rgandik.

Eng muhim uch fikr:

1. Mezonlar va format. Tanlash mezonlari: hajm (siqiqlik — Parquet 10×), tezlik (o'qish — Parquet ustunli), universallik (CSV — odam/Excel), tur saqlash (schema — Parquet/SQLite; CSV matn). Format: CSV (universal, odam — kichik/almashinuv), Parquet (siqiq, tez, tur — katta/ML), JSON (ierarxik — API/veb), SQLite (mahalliy baza — bir fayl, so'rov/munosabat).

2. SQLite va amaliy. SQLite — serversiz baza (bir fayl .db; df.to_sql, pd.read_sql — SQL so'rov; CSV'dan kuchliroq — so'rov/munosabat; PostgreSQL'dan oddiy). Amaliy: mazmunli nom (savdo_toza_2024-06.parquet — nima/holat/sana; NOT data1.csv), papka tuzilishi (data/xom/, data/toza/, data/natija/ — bosqich), metadata (data dictionary — ustun ma'nosi/birlik/manba).

3. Oqilona tanlash. Saqlash — muhim qaror (keyingi ishga ta'sir — texnik qarz). Xom ma'lumotni hech qachon o'zgartirma (data/xom/ — asl, manba haqiqati; qayta ishlash, audit, xato tuzatish — xomdan); saqlash uzoq muddatli sog'liqka ta'sir. Tuzoqlar: katta CSV (Parquet), tur yo'qolishi (CSV — Parquet/SQLite), nom noaniq (mazmunli), asl o'zgartirish (xom saqla), metadata yo'q (data dictionary), CSV vergul (quoting), Excel katta (1M chegara).

Keyingi darsda SQL asoslari (SQLite bilan)ni o'rganamiz: ma'lumotlar bazasidan ma'lumot olish — SQL tili (SELECT, WHERE, ORDER BY, GROUP BY, JOIN); Data Scientist uchun eng muhim ko'nikmalardan biri (ma'lumot ko'pincha bazada).