Python kursi/Malumot tahlili12/18-dars15 daqiqa

Mundarija (22)

24.12-dars: pandas — unumdorlik

24-QISM — MA'LUMOT TAHLILI · 12-dars

1. Kirish va motivatsiya

24.5–24.11 da pandas'ning imkoniyatlarini ko'rdik. Endi katta ma'lumot (million qator) bilan samarali ishlash: pandas oson, lekin noto'g'ri ishlatilsa sekin va xotirani ko'p talab qiladi. apply bilan sikl (sekin), object turi (xotira ko'p), keraksiz nusxa — bularni tuzatish katta ma'lumotda soatlar farq qiladi.

pandas unumdorligi NumPy 24.4-bob tamoyillariga asoslanadi: vektorlashtirish (apply o'rniga ustun amali), to'g'ri dtype (object → category, int64 → int32), category turi (takrorlanuvchi matn uchun — xotirani keskin kamaytiradi), nusxani kamaytirish. Bu bilim katta ma'lumotni tez, kam xotira bilan ishlashga imkon beradi. ML (25) da katta ma'lumot tayyorlashda juda muhim.

Real vaziyat. Bir tahlil 5 million qatorli DataFrame'da apply bilan har qatorga funksiya qo'llardi — 3 daqiqa. Vektorlangan amalga o'tdi (df["a"] * 2 + df["b"]) — 2 soniya. Va object ustun (kategoriya) categoryga o'girildi — xotira 8GB'dan 1GB'ga. 90 barobar tez, 8 barobar kam xotira. Vektorlashtirish va category — katta ma'lumot bilan ishlashning kaliti.

Bu darsda pandas unumdorligini o'rganamiz.

Bu darsda:

Vektorlashtirish (applydan qochish)
category turi
dtype optimallashtirish
apply qachan kerak
Xotirani o'lchash
Nusxani kamaytirish
Katta ma'lumot usullari
Amaliy: samarali tahlil

ℹ Misollarda pandas (import pandas as pd) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. Vektorlashtirish (`apply`dan qochish)

Vektorlangan amal — applydan tez:

python

# ⚠️ sekin (apply — qator bo'yicha):
df["natija"] = df["narx"].apply(lambda x: x * 2 + 1)

# ✅ tez (vektorlangan):
df["natija"] = df["narx"] * 2 + 1

Vektorlashtirish — pandas ustun amali (df["a"] * 2) applydan tezroq (24.4 NumPy kabi): apply har qatorni Python funksiyasiga beradi (sikl — sekin); vektorlangan amal butun ustunni C darajasida (tez). Natija bir xil, lekin 10–100 barobar tez. Qoida: apply/sikl ko'rsangiz — vektorlashtirishga harakat qil. pandas unumdorligining eng katta omili.

2.2. `category` turi

Takrorlanuvchi matn uchun:

python

df["kategoriya"] = df["kategoriya"].astype("category")
# "kurs", "kitob", ... (kam noyob qiymat, ko'p takror)
# object: har qatorda to'liq matn (xotira ko'p)
# category: kodlar + noyob ro'yxat (xotira kam)

category turi — takrorlanuvchi matn (kam noyob qiymat, ko'p takror — kategoriya, til, status) uchun: object (har qatorda to'liq matn — xotira ko'p) o'rniga kodlar + noyob ro'yxat (xotira keskin kam). Million qator, 5 noyob kategoriya: object — MB'lar, category — KB'lar. Guruhlash ham tezroq. Takrorlanuvchi matn ustuni uchun doim category.

2.3. `dtype` optimallashtirish

To'g'ri turlar — kam xotira:

python

df["narx"] = df["narx"].astype("int32")     # int64 → int32 (yarmi)
df["baho"] = df["baho"].astype("int8")       # 0-100 → int8
df["kategoriya"] = df["kategoriya"].astype("category")
df.memory_usage(deep=True)                    # ustun xotirasi

dtype optimallashtirish (24.4 kabi): son ustunlarga kichik tur (int8/int32 — kerakincha), matnga category. df.memory_usage(deep=True) (har ustun xotirasi — deep matn uchun). Katta DataFrame'da to'g'ri turlar xotirani bir necha barobar kamaytiradi. O'qigach turlarni tekshir (dtypes) va optimallashtir.

2.4. `apply` qachan kerak

apply — ba'zan zaruriy:

python

# vektorlashtirib bo'lmaydigan murakkab mantiq:
df["natija"] = df.apply(lambda row: murakkab(row["a"], row["b"]), axis=1)
# lekin avval vektorlashtirishga harakat qil:
df["natija"] = np.where(df["a"] > 0, df["b"] * 2, df["b"])

apply qachan: vektorlashtirib bo'lmaydigan murakkab mantiq (bir necha ustun, shartli) uchun. Lekin avval vektorlangan yechim izla: np.where (shartli), .map (xarita), .str (matn), matematik amallar. apply — oxirgi chora (sekin). Ko'p "apply kerak" holatlari aslida vektorlashtiriladi. apply(axis=1) — eng sekin (qator bo'yicha).

2.5. Xotirani o'lchash

Xotira ishlatilishini ko'rish:

python

df.memory_usage(deep=True)         # har ustun bayt
df.memory_usage(deep=True).sum()   # jami
df.info(memory_usage="deep")       # umumiy
df.dtypes                          # turlar (tekshir)

Xotirani o'lchab optimallashtir (24.4 kabi — taxmin emas): .memory_usage(deep=True) (har ustun — deep matn to'liq), .info(memory_usage="deep") (umumiy). Qaysi ustun ko'p xotira oladi — ko'rib optimallashtir (object → category). O'lchash — optimallashtirishning birinchi qadami. Ko'pincha bir-ikki ustun xotiraning katta qismini oladi.

2.6. Nusxani kamaytirish

Keraksiz nusxa — xotira/vaqt:

python

df["a"] = df["a"] * 2              # joyida (ustun)
df.drop(columns=["b"], inplace=True)  # joyida (ehtiyot)
# zanjir o'rniga:
df = (df.assign(c=df.a * 2)
        .query("c > 10"))          # bir marta

Nusxani kamaytirish: keraksiz .copy()dan qochish, ustunni joyida o'zgartirish. Lekin inplace=True — ehtiyot (ba'zan nusxa baribir, va zanjir buziladi). Katta DataFrame'ni ko'p marta nusxalash — xotira/vaqt isrofi. Faqat kerakli ustunlarni o'qi (usecols, 24.6), kerakli qatorlarni filtrla. Ma'lumotni kichraytirib ishla.

2.7. Katta ma'lumot usullari

Juda katta ma'lumot uchun:

python

pd.read_csv("katta.csv", chunksize=10000)   # qismlarga bo'lib
pd.read_csv("katta.csv", usecols=["a", "b"]) # faqat kerak ustun
pd.read_csv("katta.csv", dtype={"kat": "category"})  # o'qishda tur
# yoki Polars, Dask (juda katta uchun)

Katta ma'lumot usullari: chunksize (faylni qismlarga bo'lib o'qi — xotiraga sig'masa), usecols (faqat kerak ustunlar), dtype (o'qishda to'g'ri tur — category). Juda katta (xotiraga sig'maydigan) uchun Polars (tez, zamonaviy) yoki Dask (parallel). pandas — o'rta ma'lumot (xotiraga sig'adigan); undan katta — boshqa vosita. Ma'lumot hajmiga qarab vosita.

2.8. Unumdorlik tamoyillari

pandas unumdorlik tamoyillari (24.4 NumPy kabi): 1) vektorlashtir (applydan qoch — eng katta ta'sir), 2) category (takrorlanuvchi matn), 3) to'g'ri dtype (son — kichik tur), 4) nusxani kamaytir, 5) o'lcha (taxmin emas). "Avval to'g'ri, keyin tez" 24.4-bob. Katta ma'lumotda bu farq soatlar vs soniyalar. pandas — NumPy ustida, shuning uchun NumPy unumdorlik bilimi bevosita qo'l keladi. Katta ma'lumot — vosita tanlovi (pandas/Polars/Dask).

3. Tez ma'lumotnoma

python

import pandas as pd
import numpy as np

# vektorlashtirish (apply o'rniga):
df["natija"] = df["narx"] * 2 + 1              # ✅
df["belgi"] = np.where(df["narx"] > 100, "qimmat", "arzon")  # shartli

# category (takrorlanuvchi matn):
df["kat"] = df["kat"].astype("category")

# dtype optimallashtirish:
df["narx"] = df["narx"].astype("int32")
df.memory_usage(deep=True)                     # o'lchash

# katta ma'lumot:
pd.read_csv("f.csv", usecols=["a", "b"], dtype={"kat": "category"})
pd.read_csv("f.csv", chunksize=10000)          # qismlarga

# apply (oxirgi chora):
df.apply(lambda row: f(row["a"], row["b"]), axis=1)

Unumdorlik xulosasi

Vektorlashtir: apply'dan qoch (10-100x) · category: takror matn (xotira)
dtype: son kichik tur · memory_usage(deep): o'lcha · nusxani kamaytir
Katta: chunksize/usecols · Polars/Dask (juda katta)

4. Batafsil misollar

Misollarda pandas (import pandas as pd) bilan sinaladi. Tezlik mashinaga bog'liq (o'lchanmaydi); xotira (memory_usage) va natija to'g'riligi ko'rsatiladi.

Misol 1 — Vektorlashtirish (apply vs ustun)

python

"""vektorlashtirish: ustun amali va apply bir xil natija (lekin ustun amali tez)."""

import warnings
warnings.filterwarnings("ignore")

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({"narx": [100, 120, 80, 150, 90]})

    print("=== 1. apply (sekin — qator bo'yicha) ===")
    apply_natija = df["narx"].apply(lambda x: x * 2 + 10)
    print(f"  {apply_natija.tolist()}")

    print("\n=== 2. Vektorlangan (tez) ===")
    vek_natija = df["narx"] * 2 + 10
    print(f"  {vek_natija.tolist()}")

    print("\n=== 3. Natija bir xil ===")
    print(f"  teng: {apply_natija.equals(vek_natija)}")

    print("\n=== 4. np.where (shartli — apply o'rniga) ===")
    df["belgi"] = np.where(df["narx"] > 100, "qimmat", "arzon")
    print(f"  {df['belgi'].tolist()}")
    print("  ⭐ vektorlangan/np.where — apply o'rniga (tez)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. apply (sekin — qator bo'yicha) ===
  [210, 250, 170, 310, 190]

=== 2. Vektorlangan (tez) ===
  [210, 250, 170, 310, 190]

=== 3. Natija bir xil ===
  teng: True

=== 4. np.where (shartli — apply o'rniga) ===
  ['arzon', 'qimmat', 'arzon', 'qimmat', 'arzon']
  ⭐ vektorlangan/np.where — apply o'rniga (tez)

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

Misol 2 — `category` turi (xotira)

python

"""category: takrorlanuvchi matn — object vs category xotira farqi (keskin kam)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    # 5000 qator, 2 noyob kategoriya (ko'p takror)
    df = pd.DataFrame({"kategoriya": ["kurs", "kitob"] * 2500})

    print("=== 1. object turi xotirasi ===")
    obj_mem = df["kategoriya"].memory_usage(deep=True)
    print(f"  object: {obj_mem} bayt")

    print("\n=== 2. category turiga o'girish ===")
    df["kat_cat"] = df["kategoriya"].astype("category")
    cat_mem = df["kat_cat"].memory_usage(deep=True)
    print(f"  category: {cat_mem} bayt")

    print("\n=== 3. Xotira tejash ===")
    print(f"  {obj_mem} → {cat_mem} bayt")
    print(f"  {round(obj_mem / cat_mem, 1)} barobar kam")

    print("\n=== 4. Qiymatlar bir xil ===")
    print(f"  noyob qiymatlar: {df['kat_cat'].cat.categories.tolist()}")
    print(f"  guruhlash ishlaydi: {df.groupby('kat_cat', observed=True).size().to_dict()}")
    print("  ⭐ category — takrorlanuvchi matn xotirasini keskin kamaytiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. object turi xotirasi ===
  object: 267632 bayt

=== 2. category turiga o'girish ===
  category: 5239 bayt

=== 3. Xotira tejash ===
  267632 → 5239 bayt
  51.1 barobar kam

=== 4. Qiymatlar bir xil ===
  noyob qiymatlar: ['kitob', 'kurs']
  guruhlash ishlaydi: {'kitob': 2500, 'kurs': 2500}
  ⭐ category — takrorlanuvchi matn xotirasini keskin kamaytiradi

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — `dtype` optimallashtirish

python

"""dtype: son ustunga kichik tur (int8/int32); memory_usage(deep) bilan o'lchash."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "id": range(1000),
        "baho": [i % 101 for i in range(1000)],       # 0-100
    })

    print("=== 1. Standart turlar (int64) ===")
    print(f"  dtypes: {df.dtypes.astype(str).to_dict()}")
    print(f"  baho int64 xotira: {df['baho'].memory_usage(deep=True)} bayt")

    print("\n=== 2. baho → int8 (0-100 yetadi) ===")
    df["baho8"] = df["baho"].astype("int8")
    print(f"  baho int8 xotira: {df['baho8'].memory_usage(deep=True)} bayt")

    print("\n=== 3. id → int32 ===")
    df["id32"] = df["id"].astype("int32")
    print(f"  id int64: {df['id'].memory_usage(deep=True)}, int32: {df['id32'].memory_usage(deep=True)}")

    print("\n=== 4. Natija bir xil (qiymat saqlanadi) ===")
    print(f"  baho == baho8: {(df['baho'] == df['baho8']).all()}")
    print("  ⭐ to'g'ri dtype — xotirani kamaytiradi (qiymat saqlanadi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Standart turlar (int64) ===
  dtypes: {'id': 'int64', 'baho': 'int64'}
  baho int64 xotira: 8132 bayt

=== 2. baho → int8 (0-100 yetadi) ===
  baho int8 xotira: 1132 bayt

=== 3. id → int32 ===
  id int64: 8132, int32: 4132

=== 4. Natija bir xil (qiymat saqlanadi) ===
  baho == baho8: True
  ⭐ to'g'ri dtype — xotirani kamaytiradi (qiymat saqlanadi)

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

Misol 4 — Amaliy: katta ma'lumot optimallashtirish

Real misol: katta DataFrame — turlar optimallashtirish, vektorlangan hisoblash, xotira taqqoslash. Bu — samarali pandas ishining namunasi.

python

"""to'liq optimallashtirish: category + kichik dtype, vektorlangan hisob, xotira taqqos."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    n = 5000
    df = pd.DataFrame({
        "kategoriya": (["kurs", "kitob", "video"] * n)[:n],
        "narx": [(i % 200) + 50 for i in range(n)],
        "sotildi": [(i % 50) + 1 for i in range(n)],
    })

    print("=== 1. Boshlang'ich xotira ===")
    boshi = df.memory_usage(deep=True).sum()
    print(f"  jami: {boshi} bayt")

    print("\n=== 2. Optimallashtirish (category + int16) ===")
    df["kategoriya"] = df["kategoriya"].astype("category")
    df["narx"] = df["narx"].astype("int16")
    df["sotildi"] = df["sotildi"].astype("int16")
    keyin = df.memory_usage(deep=True).sum()
    print(f"  optimallashtirilgan: {keyin} bayt")
    print(f"  tejash: {round(boshi / keyin, 1)} barobar")

    print("\n=== 3. Vektorlangan hisob (daromad) ===")
    df["daromad"] = df["narx"].astype("int32") * df["sotildi"]
    print(f"  jami daromad: {df['daromad'].sum()}")

    print("\n=== 4. Guruhlash (category — tez) ===")
    hisobot = df.groupby("kategoriya", observed=True)["daromad"].sum()
    print(f"  kategoriya bo'yicha: {hisobot.to_dict()}")
    print("  ⭐ category + dtype + vektorlangan — samarali tahlil")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Boshlang'ich xotira ===
  jami: 348465 bayt

=== 2. Optimallashtirish (category + int16) ===
  optimallashtirilgan: 25293 bayt
  tejash: 13.8 barobar

=== 3. Vektorlangan hisob (daromad) ===
  jami daromad: 20102500

=== 4. Guruhlash (category — tez) ===
  kategoriya bo'yicha: {'kitob': 6704222, 'kurs': 6699972, 'video': 6698306}
  ⭐ category + dtype + vektorlangan — samarali tahlil

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

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

Noto'g'ri fikr	To'g'risi
"`apply` — vektorlangan"	Sikl (sekin)
"`object` matn uchun yaxshi"	Takror matn — `category`
"`dtype` muhim emas"	Xotira (int8 vs int64)
"`apply` doim kerak"	Ko'pincha vektorlashtiriladi
"pandas har hajmga"	Juda katta — Polars/Dask
"`inplace` doim tez"	Ehtiyot (ba'zan nusxa)
"Xotirani taxmin qil"	O'lcha (`memory_usage`)
"`category` guruhda sekin"	Tezroq (kodlar)

6. Keng tarqalgan xatolar va yechimlari

1. apply vektorlangan o'rniga

python

df["a"].apply(lambda x: x * 2)   # ⚠️ sekin
df["a"] * 2                       # ✅ vektorlangan

2. Takror matn object

python

df["kat"]   # object (ko'p takror)             # ⚠️ xotira
df["kat"].astype("category")                   # ✅

3. apply(axis=1) (eng sekin)

python

df.apply(lambda r: r.a + r.b, axis=1)   # ⚠️ juda sekin
df["a"] + df["b"]                        # ✅

4. Xotirani o'lchamaslik

python

# "sekin bo'lsa kerak" — taxmin              # ⚠️
df.memory_usage(deep=True)                    # ✅ o'lcha

5. Katta faylni to'liq o'qish

python

pd.read_csv("katta.csv")   # xotira to'ladi   # ⚠️
pd.read_csv("katta.csv", usecols=[...], chunksize=10000)  # ✅

6. categoryda yangi qiymat

python

# category ustunga yangi kategoriya qo'shish — ehtiyot (add_categories)

7. Keraksiz nusxa (zanjir)

python

df2 = df.copy(); df2 = df2[...]; df2 = df2[...]   # ⚠️ ko'p nusxa
df2 = df[...].query(...)   # bir marta                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

24.4-dars (o'tilgan): NumPy unumdorlik — asos
24.5–24.11 (o'tilgan): pandas — optimallashtirish joyi
29.1-dars: Unumdorlikni o'lchash — profiling
29.2-dars: Profiling amaliyoti
25-qism: ML — katta ma'lumot tayyorlash

8. Eng yaxshi amaliyotlar

Vektorlashtir (applydan qoch).
Takror matn — category.
Son — kichik dtype (kerakincha).
Xotirani o'lcha (memory_usage(deep=True)).
Faqat kerak ustun/qatorni o'qi.
apply — oxirgi chora (avval vektorlangan).
Juda katta — chunksize yoki Polars/Dask.
Avval to'g'ri, keyin tez (o'lchab).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # vektorlashtirish nima?
2.  # apply nega sekin?
3.  # category nima?
4.  # category qachon?
5.  # dtype optimallashtirish?
6.  # memory_usage nima?
7.  # apply qachon kerak?
8.  # np.where nima?
9.  # chunksize nima?
10. # Polars/Dask qachon?
11. # apply(axis=1) qanday?
12. # avval to'g'ri yoki tez?

Javoblar

Ustun amali (sikl o'rniga)
Har qatorni Python funksiyasiga beradi (sikl)
Takrorlanuvchi matn turi (kod + noyob)
Kam noyob, ko'p takror matn
Kichik tur (int8/category — xotira)
Ustun/DataFrame xotirasi
Vektorlashtirib bo'lmaganda
Shartli tanlash (apply o'rniga)
Faylni qismlarga bo'lib o'qish
Juda katta (xotiraga sig'masa)
Qator bo'yicha (eng sekin)
Avval to'g'ri, keyin tez

Vazifa 2: Xatolarni tuzating

python

1.  df["a"].apply(lambda x: x*2)     # vektorlangan

2.  df["kat"]  # object, ko'p takror  # category

3.  df.apply(lambda r: r.a+r.b, axis=1)  # a+b

4.  # xotira taxmini                   # memory_usage

5.  pd.read_csv("katta.csv")           # usecols/chunksize

Javoblar

python

1.  df["a"] * 2

2.  df["kat"].astype("category")

3.  df["a"] + df["b"]

4.  df.memory_usage(deep=True)

5.  pd.read_csv("katta.csv", usecols=[...], chunksize=10000)

Vazifa 3: Vektorlashtirish

Solishtir:

apply
Vektorlangan
Natija teng
np.where

Vazifa 4: category

Xotira:

object xotira
categoryga o'gir
Farq
Guruhlash

Vazifa 5: dtype

Optimallashtirish:

int64 → int8
memory_usage
Qiymat saqlanadi
Taqqoslash

Vazifa 6: Katta ma'lumot

Samarali:

category + dtype
Vektorlangan
Xotira taqqos
Guruhlash

Vazifa 7: O'ylash

pandas unumdorligi NumPy 24.4-bob tamoyillariga asoslanadi: vektorlashtirish, to'g'ri dtype, category. Lekin pandas har hajmga mos emas — juda katta ma'lumot (xotiraga sig'maydigan) uchun Polars, Dask kerak. Nima uchun "to'g'ri vosita to'g'ri hajm uchun" (right tool for the scale), va bu 23.11 (SQL vs NoSQL) va umumiy muhandislik tanlovi bilan qanday bog'liq — nega bir vosita (pandas) barcha hajmga yaramaydi?

Javob

Qisqa javob: pandas o'rta hajm (xotiraga sig'adigan — MB'dan bir necha GB) uchun ideal: qulay, kuchli, NumPy tezligi. Lekin juda katta (xotiraga sig'maydigan — o'nlab GB, TB) uchun yaramaydi (xotira to'ladi) — Polars (tez, xotira-samarali) yoki Dask/Spark (parallel, ko'p mashina) kerak. "To'g'ri vosita to'g'ri hajm uchun" — har vosita ma'lum hajmga optimallashtirilgan: kichik (Python dict), o'rta (pandas), katta (Polars/Dask), juda katta (Spark). Bir vosita barcha hajmga yaramaydi, chunki dizayn tanlovlari (xotirada vs diskda, bir mashina vs parallel) hajmga bog'liq. Bu 23.11 (SQL o'rta, NoSQL katta) va umumiy muhandislik tanlovi bilan bir xil: muammo hajmi va shakliga qarab vosita. "Moda emas, mos" — hajmga qarab tanla.

1. Hajm va vosita

Hajm	Vosita
Kichik (dict, ro'yxat)	Python
O'rta (GB — xotirada)	pandas
Katta (o'nlab GB)	Polars, Dask
Juda katta (TB, klaster)	Spark

2. Nega pandas har hajmga emas

pandas — xotirada (hammasi RAM'da). Xotiraga sig'masa — ishlamaydi. Juda katta uchun disk/parallel kerak (Dask, Spark).

3. Dizayn tanlovi hajmga bog'liq

Kichik: soddalik (Python)
O'rta: xotirada tez (pandas)
Katta: xotira-samarali (Polars) yoki parallel (Dask)

Har biri o'z hajmiga optimallashtirilgan.

4. 23.11 bilan bog'liq

SQL (o'rta, bog'langan) vs NoSQL (katta, taqsimlangan) — hajm va shaklga qarab. pandas vs Spark — bir xil g'oya (hajm). "To'g'ri vosita" — universal muhandislik tamoyili.

5. Muhandislik saboqlari

Har vosita ma'lum hajmga optimali
pandas — o'rta (xotirada)
Juda katta — Polars/Dask/Spark
Hajm va shaklga qarab tanla (23.11 kabi)

6. Xulosa

pandas — o'rta hajm (xotirada)
Juda katta — boshqa vosita
To'g'ri vosita to'g'ri hajm uchun
Muammoga qarab tanla (moda emas)

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda pandas unumdorligini o'rgandik.

Eng muhim uch fikr:

Vektorlashtirish — applydan qochish. Vektorlashtirish — pandas ustun amali (df["a"] * 2 + 1) applydan tezroq (24.4 NumPy kabi): apply har qatorni Python funksiyasiga beradi (sikl — sekin), vektorlangan amal butun ustunni C darajasida (tez — 10–100 barobar). Shartli uchun np.where, xarita uchun .map, matn uchun .str — hammasi vektorlangan. apply — oxirgi chora (vektorlashtirib bo'lmaganda; apply(axis=1) eng sekin). Qoida: apply/sikl ko'rsangiz, avval vektorlangan yechim izla.
category va dtype. category turi — takrorlanuvchi matn (kam noyob, ko'p takror — kategoriya, til, status) uchun: object (har qatorda to'liq matn — xotira ko'p) o'rniga kodlar + noyob ro'yxat (xotira keskin kam — million qatorda MB→KB). Guruhlash ham tezroq. dtype optimallashtirish 24.4-bob: son ustunlarga kichik tur (int8/int32 — kerakincha). .memory_usage(deep=True) bilan o'lcha (taxmin emas) — qaysi ustun ko'p xotira oladi, optimallashtir.
Katta ma'lumot va vosita tanlovi. Katta ma'lumot usullari: chunksize (faylni qismlarga — xotiraga sig'masa), usecols (faqat kerak ustun), dtype (o'qishda tur). pandas — o'rta hajm (xotiraga sig'adigan); juda katta (o'nlab GB, TB) uchun Polars (tez, xotira-samarali) yoki Dask/Spark (parallel). "To'g'ri vosita to'g'ri hajm uchun" — har vosita ma'lum hajmga optimallashtirilgan (23.11 SQL/NoSQL kabi). Tamoyillar: vektorlashtir, category, to'g'ri dtype, nusxani kamaytir, o'lcha. pandas NumPy ustida — NumPy unumdorlik bilimi bevosita qo'l keladi ("avval to'g'ri, keyin tez").

Keyingi darsda Matplotlib ni o'rganamiz: ma'lumotni vizualizatsiya qilish — chiziq, ustun, diagramma grafiklari — ma'lumotni ko'z bilan ko'rish va tushunish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

24.12-dars: pandas — unumdorlik

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. Vektorlashtirish (applydan qochish)

2.2. category turi

2.3. dtype optimallashtirish

2.4. apply qachan kerak

2.5. Xotirani o'lchash

2.6. Nusxani kamaytirish

2.7. Katta ma'lumot usullari

2.8. Unumdorlik tamoyillari

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — Vektorlashtirish (apply vs ustun)

Misol 2 — category turi (xotira)

Misol 3 — dtype optimallashtirish

Misol 4 — Amaliy: katta ma'lumot optimallashtirish

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

6. Keng tarqalgan xatolar va yechimlari

7. Integratsiya — bu bilim qayerda kerak bo'ladi

8. Eng yaxshi amaliyotlar

9. Amaliy topshiriq

Xulosa

Izohlar (0)

2.1. Vektorlashtirish (`apply`dan qochish)

2.2. `category` turi

2.3. `dtype` optimallashtirish

2.4. `apply` qachan kerak

Misol 2 — `category` turi (xotira)

Misol 3 — `dtype` optimallashtirish