7.10-dars: Katta fayllar (chunks)

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

1. Kirish va motivatsiya

Ba'zan fayl xotiraga sig'maydi: 10 GB CSV, 50M qator. pd.read_csv("katta.csv") — MemoryError (RAM yetmaydi) yoki kompyuter qotadi. Bu katta ma'lumot (big data) muammosi. Yechim strategiyalari bor: qism-qism o'qish (chunksize — bo'lak-bo'lak), tur optimizatsiyasi (dtype, kategoriya — xotira kamaytir), faqat kerak ustun (usecols), va katta ma'lumot vositalari (Parquet, Dask, SQL). Bu darsda xotiraga sig'maydigan fayllar bilan ishlash usullari. Data Scientist katta ma'lumot bilan tez-tez uchraydi — buni samarali qayta ishlash muhim ko'nikma. Nega muhim? (1) Xotira — katta fayl RAM'ga sig'maydi; (2) Chunks — qism-qism (bo'lak); (3) Optimizatsiya — tur, ustun (xotira kamaytir). Bu dars katta fayllarni o'rgatadi — xotiraga sig'maydigan ma'lumot.

Katta fayllar (chunks) — xotiraga sig'maydigan: chunksize= (qism-qism o'qish — pd.read_csv(..., chunksize=100000); iterator), tur optimizatsiya (dtype — int8/float32; kategoriya — xotira kamaytir), usecols (faqat kerak ustun), agregatsiya (qism-qism — har chunk hisoblab yig'), strategiya (Parquet — 7.3; SQL — 7.5; Dask — parallel). Foydalanish: katta fayl (GB), xotira samaradorligi. Bu 7.2 (CSV), 6.4 (tur), 7.3 (Parquet) bilan bog'liq. Katta fayllar — qism-qism (chunks; optimizatsiya). Katta. Chunks.

Real vaziyat. Data Scientist 8 GB tranzaksiya CSV'sini tahlil qilmoqchi (50M qator). Muammo: pd.read_csv("tranzaksiya.csv") — MemoryError (RAM 16 GB — pandas 3-4× ko'p oladi). Hal — chunks: for chunk in pd.read_csv("...", chunksize=1_000_000): ... — 1M qatorlik bo'laklar (har bo'lak xotiraga sig'adi; hisoblab yig'); masalan har shahar jami savdosi (har chunk guruhlab, oxirida birlashtir). Yoki optimizatsiya: usecols=["shahar", "narx"] (faqat 2 ustun; 50 emas) + dtype={"narx": "float32"} (yarim xotira). Data Scientist chunks bilan qism-qism o'qidi (xotira sig'di), optimizatsiya qildi (ustun/tur). Katta fayllar — qism-qism.

Bu darsda katta fayllarni o'rganamiz.

Bu darsda:

• chunksize (qism-qism o'qish)
• Tur optimizatsiya (dtype, kategoriya)
• usecols (faqat kerak ustun)
• Qism-qism agregatsiya
• Katta ma'lumot strategiyasi
• Katta fayl amaliyoti
• Katta fayl tuzoqlari
• Amaliy: katta fayllar

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

2. Nazariya — chuqur tushuntirish

2.1. chunksize (qism-qism o'qish)

Bo'lak-bo'lak:

import pandas as pd

# chunksize — qism-qism o'qish (iterator)
for chunk in pd.read_csv("katta.csv", chunksize=1_000_000):
    # har chunk — 1M qatorlik DataFrame (xotiraga sig'adi)
    natija = chunk.groupby("shahar")["narx"].sum()
    # ... har chunkni qayta ishlab, yig'ish

# iterator (bir marta)
reader = pd.read_csv("katta.csv", chunksize=100000)
birinchi = next(reader)   # 1-chunk

chunksize (qism-qism o'qish) — bo'lak-bo'lak: pd.read_csv(..., chunksize=N) — faylni qism-qism o'qiydi (iterator qaytaradi; har chunk — N qatorlik DataFrame; xotiraga sig'adi); for chunk in reader: (har bo'lak — qayta ishlash). Sabab: butun fayl xotiraga sig'mas (50M qator — MemoryError); chunk (bo'lak — 1M; sig'adi; birma-bir); har chunk qayta ishlab (filtr/guruh/hisob) — natijani yig'ish; xotira doimiy (bir chunk). chunksize (bo'lak hajmi), iterator (birma-bir), for chunk (qayta ishlash), yig'ish (natija). chunksize — qism-qism (bo'lak; xotira). chunksize. Bo'lak.

2.2. Tur optimizatsiya (dtype, kategoriya)

Xotira kamaytirish:

import pandas as pd

# dtype — kichik tur (xotira kamaytir)
pd.read_csv("data.csv", dtype={
    "narx": "float32",     # float64 → float32 (yarim xotira)
    "soni": "int16",       # int64 → int16 (kichik oraliq)
    "shahar": "category",  # matn → kategoriya (takrorlanuvchi)
})

# int8 (-128..127), int16, int32; float32 (yarim)

Tur optimizatsiya (dtype, kategoriya) — xotira kamaytirish: dtype= (kichik tur — int8 (-128..127), int16, int32 (default int64 o'rniga); float32 (float64 yarim xotira); category (takrorlanuvchi matn — 6.4; shahar 3-4 xil)). Sabab: default tur ko'p xotira (int64 — 8 bayt; kichik son int8 — 1 bayt; float64 → float32 yarim); kategoriya (matn takrorlansa — kod + lug'at; 6.4); 50-70% xotira tejaladi (to'g'ri tur). int8/16/32 (son oraliq), float32 (yarim), category (matn — 6.4), 50-70% tejash. Tur optimizatsiya — dtype (kichik tur; xotira). dtype. category.

2.3. usecols (faqat kerak ustun)

usecols (faqat kerak ustun) — ustun kamaytir: pd.read_csv(..., usecols=["shahar", "narx"]) — faqat kerak ustun o'qiydi (50 ustun — 2 ta; xotira/tez); indeks yoki nom bilan. Sabab: ko'p ustun (fayl 50 ustun — tahlil 2 ta; qolgan 48 — keraksiz xotira); usecols — faqat kerak (o'qishda — o'qilmaydi ham; tez); "kerak emas ustun — o'qima". usecols (kerak ustun), xotira/tez (kam ustun), o'qilmaydi (keraksiz). usecols — kerak ustun (kamaytir). usecols. Ustun.

2.4. Qism-qism agregatsiya

Qism-qism agregatsiya — chunk yig'ish: katta fayl agregatsiya (jami, o'rtacha, guruh) — chunk bo'yicha qismiy hisoblab, birlashtir: jami/sanoq (har chunk sum/count → yig'), guruh (har chunk groupby → concat → yakuniy groupby), o'rtacha (jami/sanoq — o'rtacha to'g'ridan emas; sum/count alohida). Sabab: butun fayl agregatsiya xotiraga sig'mas; qismiy (har chunk — qism natija; yig'ish — yakuniy); "bo'lib-bo'lib hisobla" (map-reduce kabi). Har chunk (qismiy hisob), yig'ish (birlashtir — sum/concat), o'rtacha (sum/count alohida). Qism-qism agregatsiya — chunk yig'ish (qismiy → yakuniy). Agregatsiya. Yig'ish.

2.5. Katta ma'lumot strategiyasi

Katta ma'lumot strategiyasi — vositalar: Parquet (7.3 — ustunli, siqiq, tur; kerak ustun tez; CSV o'rniga), SQL (7.5 — bazada kamaytir; WHERE/GROUP BY; xotiraga emas), Dask (pandas kabi, lekin parallel/chunk avtomatik — katta ma'lumot; dask.dataframe), Polars (tez, xotira samarali; pandas alternativa), namuna (nrows=/sample — barcha emas, qism bilan sinov). Sabab: strategiya (fayl formati — Parquet; baza — SQL; parallel — Dask; tez — Polars); "katta ma'lumot — to'g'ri vosita" (chunks — pandas; Dask — avtomatik). Parquet (format), SQL (baza), Dask/Polars (vosita), namuna (sinov). Katta ma'lumot strategiyasi — Parquet/SQL/Dask (vositalar). Strategiya. Dask.

2.6. Katta fayl amaliyoti

Katta fayl amaliyoti: bahola (fayl hajmi — RAM'ga sig'adimi; nrows=5 — namuna ko'r); usecols (faqat kerak ustun — xotira); dtype (kichik tur — int8/float32/category; xotira); chunksize (sig'masa — qism-qism; iterator); qism-qism agregatsiya (har chunk hisoblab, yig'); Parquet (CSV → Parquet — 7.3; keyingi tez); SQL/Dask (juda katta — baza/parallel); namuna (sinov — sample/nrows). Tuzoqlar: butun o'qish (MemoryError — chunks), tur default (ko'p xotira — dtype), barcha ustun (usecols), chunk o'rtacha (sum/count), format (CSV katta — Parquet). Amaliyot — bahola, usecols, dtype, chunks. Katta. Xotira.

2.7. Katta fayl tuzoqlari

Katta fayl asosiy tuzoqlari: butun o'qish (pd.read_csv("katta.csv") — RAM sig'mas → MemoryError (yoki kompyuter qotadi); chunksize/usecols/dtype kamaytir); tur default (default int64/float64/object — ko'p xotira (kichik son int8; matn category — 6.4); dtype optimizatsiya — 50-70% tejash); barcha ustun (50 ustun o'qish — 2 kerak; usecols — faqat kerak); chunk o'rtacha (chunk bo'yicha mean — noto'g'ri (chunklar o'rtachasi ≠ umumiy o'rtacha; chunk turli o'lcham); sum/count alohida yig', keyin bo'l); format (CSV) (katta CSV — sekin/katta (matn, tur yo'q); Parquet (7.3 — siqiq, tez, tur; katta ma'lumot)); chunk holat (chunk mustaqil — chunklar orasi holat (masalan running total) — qo'lda saqla); RAM baholamas (fayl hajmi ko'r — RAM 3-4× (pandas overhead); 4 GB fayl — 16 GB RAM); kkategory ko'p noyob (category — takrorlanuvchi (shahar); noyob (id) — xotira ko'proq — 6.4); oldin o'qib keyin optimizatsiya (butun o'qib keyin astype — kech (xotira allaqachon); dtype o'qishda); Dask murakkablik (Dask — kuchli, lekin murakkab; kichik ma'lumot — pandas yetarli; katta — Dask). Sabab: katta fayl xotira/format nozik (butun o'qish, tur, o'rtacha — MemoryError yoki noto'g'ri). Yechim: chunks/usecols/dtype, Parquet, sum/count agregatsiya. Tuzoqlar — butun o'qish, tur, ustun, chunk o'rtacha.

2.8. Katta fayllar — xotiraga sig'maydigan ma'lumot

Katta fayl asosiy g'oyasi — xotiraga sig'maydigan ma'lumot: ba'zi fayl RAM'ga sig'mas (10 GB CSV, 50M qator — read_csv MemoryError); strategiyalar bilan hal (qism-qism, optimizatsiya, vositalar). chunksize=N (qism-qism o'qish — iterator; har chunk sig'adi; qismiy hisob → yig'), tur optimizatsiya (dtype — int8/float32/category; xotira 50-70% kamaytir — 6.4), usecols (faqat kerak ustun), qism-qism agregatsiya (har chunk hisoblab, birlashtir — sum/count alohida; chunk o'rtacha noto'g'ri), strategiya (Parquet 7.3 — siqiq/tez; SQL 7.5 — bazada; Dask — parallel; Polars — tez; namuna — sinov). Foydalanish: katta fayl (GB — xotiraga sig'mas), xotira samaradorligi (tur/ustun). Tuzoqlar: butun o'qish (MemoryError — chunks), tur default (xotira — dtype), barcha ustun (usecols), chunk o'rtacha (sum/count), format (CSV — Parquet), RAM baholamas (3-4× overhead). Bu 7.2 (CSV), 6.4 (tur — dtype/category), 7.3 (Parquet), 7.5 (SQL), 7.4 (formatlar) bilan. Katta fayllar — xotiraga sig'maydigan ma'lumot (chunks, optimizatsiya, strategiya). Katta. Chunks. Xotira.

3. Tez ma'lumotnoma

import pandas as pd

# CHUNKSIZE (qism-qism — xotiraga sig'maydigan fayl):
for chunk in pd.read_csv("katta.csv", chunksize=1_000_000):
    qism = chunk.groupby("shahar")["narx"].sum()
    # ... yig'ish

# TUR OPTIMIZATSIYA (o'qishda — 50-70% xotira):
pd.read_csv("data.csv", dtype={
    "narx": "float32",     # float64 → float32
    "soni": "int16",       # kichik oraliq
    "shahar": "category",  # takrorlanuvchi matn (6.4)
})

# USECOLS (faqat kerak ustun):
pd.read_csv("data.csv", usecols=["shahar", "narx"])

# QISM-QISM AGREGATSIYA (chunk yig'ish):
jami = 0; soni = 0
for chunk in pd.read_csv("katta.csv", chunksize=100000):
    jami += chunk["narx"].sum(); soni += len(chunk)
ortacha = jami / soni   # (chunk o'rtachasi EMAS — sum/count alohida)

# STRATEGIYA: Parquet 7.3-bob · SQL 7.5-bob · Dask (parallel) · namuna (nrows)
QOIDA: chunksize · dtype (kichik) · usecols · sum/count (o'rtacha emas)

Katta fayllar xulosasi

Katta fayllar — xotiraga sig'maydigan (MemoryError)
chunksize — qism-qism (iterator; har chunk sig'adi)
Tur optimizatsiya — dtype (int8/float32/category; 50-70% tejash)
usecols — faqat kerak ustun (xotira/tez)
Strategiya — Parquet, SQL, Dask (katta ma'lumot vositalari)

4. Batafsil misollar

Misollar real pandas/tempfile bilan (Python 3.14).

Misol 1 — chunksize (qism-qism)

"""chunksize (real pandas/tempfile)."""

import tempfile
from pathlib import Path
import numpy as np
import pandas as pd


def main() -> None:
    np.random.seed(0)
    yol = Path(tempfile.gettempdir()) / "test_ds710.csv"
    pd.DataFrame({
        "shahar": np.random.choice(["Toshkent", "Samarqand", "Buxoro"], 10000),
        "narx": np.random.randint(50, 200, 10000),
    }).to_csv(yol, index=False)

    print("=== 1. chunksize (bo'lak-bo'lak) ===")
    chunks = 0
    for chunk in pd.read_csv(yol, chunksize=2500):
        chunks += 1
    print(f"  chunklar soni: {chunks} (10000 / 2500)")

    print("\n=== 2. Har chunk — DataFrame ===")
    with pd.read_csv(yol, chunksize=2500) as reader:
        birinchi = next(reader)
    print(f"  1-chunk shakli: {birinchi.shape}")

    print("\n=== 3. Xotira doimiy ===")
    print("  bir chunk (2500) xotirada — butun emas")

    print("\n=== 4. Qism-qism yig'ish ===")
    jami = 0
    with pd.read_csv(yol, chunksize=2500) as reader:
        for chunk in reader:
            jami += int(chunk["narx"].sum())
    print(f"  jami narx: {jami}")
    yol.unlink()
    print("  ⭐ chunksize — qism-qism (xotira)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. chunksize (bo'lak-bo'lak) ===
  chunklar soni: 4 (10000 / 2500)

=== 2. Har chunk — DataFrame ===
  1-chunk shakli: (2500, 2)

=== 3. Xotira doimiy ===
  bir chunk (2500) xotirada — butun emas

=== 4. Qism-qism yig'ish ===
  jami narx: 1245478
  ⭐ chunksize — qism-qism (xotira)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Tur optimizatsiya (xotira)

"""Tur optimizatsiya (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    np.random.seed(0)
    df = pd.DataFrame({
        "narx": np.random.randint(50, 200, 100000).astype("float64"),
        "shahar": np.random.choice(["Toshkent", "Samarqand", "Buxoro"], 100000),
    })

    print("=== 1. Default tur xotira ===")
    default_xotira = df.memory_usage(deep=True).sum()
    print(f"  default: {default_xotira // 1024} KB")

    print("\n=== 2. Optimizatsiya (float32, category) ===")
    df_opt = df.copy()
    df_opt["narx"] = df_opt["narx"].astype("float32")
    df_opt["shahar"] = df_opt["shahar"].astype("category")
    opt_xotira = df_opt.memory_usage(deep=True).sum()
    print(f"  optimizatsiya: {opt_xotira // 1024} KB")

    print("\n=== 3. Tejash ===")
    tejash = round((1 - opt_xotira / default_xotira) * 100)
    print(f"  tejaldi: ~{tejash}%")

    print("\n=== 4. Turlar ===")
    print(f"  narx: {df_opt['narx'].dtype}, shahar: {df_opt['shahar'].dtype}")
    print("  ⭐ Tur optimizatsiya — xotira tejash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Default tur xotira ===
  default: 6315 KB

=== 2. Optimizatsiya (float32, category) ===
  optimizatsiya: 488 KB

=== 3. Tejash ===
  tejaldi: ~92%

=== 4. Turlar ===
  narx: float32, shahar: category
  ⭐ Tur optimizatsiya — xotira tejash

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Qism-qism agregatsiya

"""Qism-qism agregatsiya (real pandas/tempfile)."""

import tempfile
from pathlib import Path
import numpy as np
import pandas as pd


def main() -> None:
    np.random.seed(0)
    yol = Path(tempfile.gettempdir()) / "test_ds710b.csv"
    pd.DataFrame({
        "shahar": np.random.choice(["Toshkent", "Samarqand"], 10000),
        "narx": np.random.randint(50, 200, 10000),
    }).to_csv(yol, index=False)

    print("=== 1. O'rtacha (sum/count alohida) ===")
    jami = 0
    soni = 0
    for chunk in pd.read_csv(yol, chunksize=2500):
        jami += chunk["narx"].sum()
        soni += len(chunk)
    print(f"  o'rtacha: {jami / soni:.2f}")

    print("\n=== 2. To'g'ri (butun bilan solishtir) ===")
    butun = pd.read_csv(yol)["narx"].mean()
    print(f"  butun o'rtacha: {butun:.2f} (bir xil)")

    print("\n=== 3. Guruh (chunk → concat → groupby) ===")
    qismlar = []
    for chunk in pd.read_csv(yol, chunksize=2500):
        qismlar.append(chunk.groupby("shahar")["narx"].sum())
    guruh = pd.concat(qismlar).groupby(level=0).sum()
    print(f"  {guruh.to_dict()}")

    print("\n=== 4. Nega sum/count ===")
    print("  chunk o'rtachasi ≠ umumiy (sum/count alohida)")
    yol.unlink()
    print("  ⭐ Qism-qism agregatsiya (yig'ish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. O'rtacha (sum/count alohida) ===
  o'rtacha: 124.89

=== 2. To'g'ri (butun bilan solishtir) ===
  butun o'rtacha: 124.89 (bir xil)

=== 3. Guruh (chunk → concat → groupby) ===
  {'Samarqand': 635556, 'Toshkent': 613394}

=== 4. Nega sum/count ===
  chunk o'rtachasi ≠ umumiy (sum/count alohida)
  ⭐ Qism-qism agregatsiya (yig'ish)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — usecols va strategiya

"""usecols va strategiya (real pandas/tempfile)."""

import tempfile
from pathlib import Path
import pandas as pd


def main() -> None:
    yol = Path(tempfile.gettempdir()) / "test_ds710c.csv"
    pd.DataFrame({
        "shahar": ["Toshkent", "Samarqand"],
        "narx": [120, 80],
        "izoh": ["a" * 100, "b" * 100],   # katta ustun
        "id": [1, 2],
    }).to_csv(yol, index=False)

    print("=== 1. Barcha ustun ===")
    hammasi = pd.read_csv(yol)
    print(f"  ustunlar: {list(hammasi.columns)}")

    print("\n=== 2. usecols (faqat kerak) ===")
    kerak = pd.read_csv(yol, usecols=["shahar", "narx"])
    print(f"  ustunlar: {list(kerak.columns)}")

    print("\n=== 3. Xotira farqi ===")
    print(f"  barcha: {hammasi.memory_usage(deep=True).sum()} bayt")
    print(f"  usecols: {kerak.memory_usage(deep=True).sum()} bayt")

    print("\n=== 4. Strategiyalar ===")
    print("  Parquet 7.3-bob, SQL 7.5-bob, Dask (parallel)")
    yol.unlink()
    print("  ⭐ usecols — kerak ustun (xotira)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barcha ustun ===
  ustunlar: ['shahar', 'narx', 'izoh', 'id']

=== 2. usecols (faqat kerak) ===
  ustunlar: ['shahar', 'narx']

=== 3. Xotira farqi ===
  barcha: 577 bayt
  usecols: 263 bayt

=== 4. Strategiyalar ===
  Parquet 7.3-bob, SQL 7.5-bob, Dask (parallel)
  ⭐ usecols — kerak ustun (xotira)

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

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

6. Keng tarqalgan xatolar va yechimlari

1. Butun o'qish (MemoryError)

pd.read_csv("10gb.csv")   # MemoryError                           # ⚠️
for chunk in pd.read_csv("10gb.csv", chunksize=1_000_000): ...   # ✅

2. Tur default

pd.read_csv("data.csv")   # int64/float64 (ko'p xotira)           # ⚠️
pd.read_csv("data.csv", dtype={"soni": "int16"})   # kichik      # ✅

3. Barcha ustun

pd.read_csv("50ustun.csv")   # 50 ustun (2 kerak)                 # ⚠️
pd.read_csv("50ustun.csv", usecols=["a", "b"])   # kerak         # ✅

4. Chunk o'rtacha

np.mean([c["x"].mean() for c in chunks])   # noto'g'ri            # ⚠️
sum/count alohida yig', keyin bo'l                              # ✅

5. Format (CSV katta)

pd.read_csv("10gb.csv", ...)   # sekin (matn)                     # ⚠️
pd.read_parquet("data.parquet")   # tez 7.3-bob                    # ✅

6. Keyin astype

df = pd.read_csv("katta.csv"); df["x"] = df["x"].astype("int8")  # kech # ⚠️
pd.read_csv("katta.csv", dtype={"x": "int8"})   # o'qishda       # ✅

7. RAM baholamaslik

# 8 GB fayl, 16 GB RAM (pandas 3-4x → sig'maydi)                  # ⚠️
# hajmni bahol; chunks/dtype/Parquet                             # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 7.2-dars (o'tilgan): CSV (read_csv)
• 6.4-dars (o'tilgan): Tur (dtype/category)
• 7.3-dars (o'tilgan): Parquet (samarali)
• 7.5-dars (o'tilgan): SQL (bazada kamaytir)
• Ish: Big data (Dask, Spark)

8. Eng yaxshi amaliyotlar

1. Hajm bahola — RAM'ga sig'adimi.

2. chunksize — sig'masa (qism-qism).

3. dtype — kichik tur (o'qishda).

4. usecols — kerak ustun.

5. sum/count — o'rtacha (chunk emas).

6. Parquet — CSV o'rniga (katta).

7. SQL — bazada kamaytir 7.5-bob.

8. Dask/Polars — juda katta.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # katta fayl muammosi?
2.  # chunksize nima?
3.  # chunk nima?
4.  # dtype optimizatsiya?
5.  # category qachon?
6.  # usecols nima?
7.  # chunk agregatsiya?
8.  # o'rtacha qanday?
9.  # Parquet nega?
10. # Dask nima?
11. # RAM baholash?
12. # nega chunks?

Vazifa 2: Xatolarni tuzating

1.  pd.read_csv("10gb.csv")

2.  pd.read_csv("data.csv")   # int64

3.  pd.read_csv("50ustun.csv")

4.  np.mean([c["x"].mean() for c in chunks])

5.  df = pd.read_csv(...); df.astype("int8")

1.  chunksize=1_000_000

2.  dtype={"soni": "int16"}

3.  usecols=["a", "b"]

4.  sum/count alohida

5.  dtype={"x": "int8"} (o'qishda)

Vazifa 3: Chunks

Modellang:

1. chunksize
2. Iterator
3. Har chunk
4. Yig'ish

Vazifa 4: Optimizatsiya

Modellang:

1. dtype (int8)
2. float32
3. category
4. usecols

Vazifa 5: Strategiya

Modellang:

1. Parquet
2. SQL
3. Dask
4. Namuna

Vazifa 6: Integratsiya

Modellang:

1. CSV (7.2)
2. Tur (6.4)
3. Parquet (7.3)
4. SQL (7.5)

Vazifa 7: O'ylash

Katta fayllar bilan ishlash bir asosiy g'oyani ko'rsatadi: "hamma narsani bir vaqtda xotiraga yuklama". Chunks (qism-qism), tur optimizatsiyasi, faqat kerak ustun — barchasi xotirani tejaydi. Nima uchun "resurslarni oqilona ishlatish" (xotira, vaqt) Data Science'da faqat "katta ma'lumot" uchun emas, balki umumiy muhim ko'nikma, va nima uchun bu masshtablanuvchi (scalable) yechim tafakkurini talab qiladi?

Nimani mustahkamlaydi: 2.5, 2.6-bo'limlar.

Xulosa

Bu darsda katta fayllarni o'rgandik.

Eng muhim uch fikr:

1. chunksize va optimizatsiya. pd.read_csv(..., chunksize=N) — qism-qism o'qish (iterator; har chunk — N qator DataFrame; xotiraga sig'adi; for chunk in reader). Tur optimizatsiya — dtype (int8/int16/int32, float32 yarim, category takrorlanuvchi matn — 6.4; 50-70% xotira tejash; o'qishda — keyin astype kech).

2. usecols va agregatsiya. usecols=["a", "b"] (faqat kerak ustun — 50 dan 2; xotira/tez). Qism-qism agregatsiya — har chunk hisoblab yig' (sum/count alohida; guruh — concat → groupby); chunk o'rtacha noto'g'ri (chunklar o'rtachasi ≠ umumiy — sum/count alohida, keyin bo'l).

3. Xotiraga sig'maydigan. Katta fayl — xotiraga sig'mas (read_csv MemoryError; RAM 3-4× overhead). Strategiya: Parquet (7.3 — siqiq/tez), SQL (7.5 — bazada kamaytir), Dask/Polars (parallel/tez), namuna (sinov). Resurslarni oqilona (xotira/vaqt) — umumiy ko'nikma (katta emas ham — odat); masshtablanuvchi tafakkur (o'sishga tayyor — "10× o'ssa ishlaydimi?"). Tuzoqlar: butun o'qish (MemoryError — chunks), tur default (dtype), barcha ustun (usecols), chunk o'rtacha (sum/count), format (CSV — Parquet), keyin astype (o'qishda), RAM baholamas (3-4×).

Keyingi darsda etika va qonunni o'rganamiz: ma'lumot yig'ishning huquqiy/axloqiy tomonlari — maxfiylik (GDPR), robots.txt, foydalanish sharti, shaxsiy ma'lumot, litsenziya; mas'uliyatli ma'lumot yig'ish (7.9 scraping, 7.7 API bilan).