3.2-dars: DataFrame

3-QISM — PANDAS · 2-dars

1. Kirish va motivatsiya

Series bitta ustun edi. Lekin real ma'lumot ko'p ustunli jadval: mijozlar ro'yxati (ism, yosh, shahar, maosh), savdo (sana, mahsulot, miqdor, narx). Bu — DataFrame — Pandas'ning eng asosiy va eng ko'p ishlatiladigan tuzilmasi. DataFrame — bu jadval: qatorlar (namunalar — har bir mijoz) va ustunlar (xususiyatlar — ism, yosh). Aslida DataFrame — bu Series lar to'plami (har ustun bir Series, umumiy indeks bilan). Excel jadvalini yoki SQL jadvalini tasavvur qiling — DataFrame aynan shu, lekin Python'da, dasturlash kuchi bilan. Nega muhim? (1) Real ma'lumot — deyarli hamma ma'lumot jadval; (2) Data Science markazi — tahlil, tozalash, ML tayyorgarlik — hammasi DataFrame ustida; (3) Kuch — filtrlash, guruhlash, birlashtirish (keyingi darslar). Bu dars DataFrame'ni o'rgatadi — Data Science'ning yuragi.

DataFrame — jadval (ko'p ustun): tuzilma (qatorlar × ustunlar — Series to'plami), yaratish (dict — {ustun: qiymatlar}, ro'yxatlar), ustun (df["yosh"] — Series), qator (df.loc[0] — 3.4), atributlar (.shape, .columns, .index, .dtypes), ko'rish (.head, .tail, .info, .describe). Foydalanish: jadval ma'lumot, tahlil, tozalash, ML. Bu 3.1 (Series), 3.3 (o'qish/yozish) bilan bog'liq. DataFrame — jadval. Series to'plami. Data Science markazi.

Real vaziyat. Data Scientist do'kon mijozlar ma'lumoti bilan ishlar edi: ism, yosh, shahar, xarid summasi (har mijoz — bir qator, har xususiyat — bir ustun). DataFrame yaratdi: pd.DataFrame({"ism": [...], "yosh": [...], "summa": [...]}) — jadval (Excel kabi, lekin dasturlash). df.head() (birinchi 5 qator — ko'rish), df.info() (ustunlar, turlar, NaN), df.describe() (statistika — o'rtacha, min, max). df["yosh"] (yosh ustuni — Series), df.shape (o'lcham — qator×ustun). DataFrame ma'lumotni jadval qildi (tahlil oson — ustun/qator, filtrlash, guruhlash). DataFrame — Data Science yuragi (deyarli hamma ish shu ustida).

Bu darsda DataFrame'ni o'rganamiz.

Bu darsda:

• DataFrame nima (jadval)
• DataFrame yaratish
• Ustun va qatorlar
• Atributlar (shape, columns, dtypes)
• Ko'rish (head, info, describe)
• DataFrame amaliyoti
• DataFrame tuzoqlari
• Amaliy: jadval modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. DataFrame nima (jadval)

Qatorlar va ustunlar:

import pandas as pd

df = pd.DataFrame({
    "ism": ["Ali", "Vali", "Guli"],
    "yosh": [25, 30, 28],
    "shahar": ["Toshkent", "Samarqand", "Buxoro"],
})
#     ism   yosh    shahar
# 0   Ali    25   Toshkent
# 1  Vali    30  Samarqand
# 2  Guli    28    Buxoro

# qatorlar — namunalar (har mijoz)
# ustunlar — xususiyatlar (ism, yosh, shahar)

DataFrame nima — jadval (qatorlar × ustunlar): qatorlar (namunalar — har mijoz/kuzatish), ustunlar (xususiyatlar — ism, yosh, shahar). Sabab: real ma'lumot jadval (ko'p xususiyat — bitta Series yetmaydi; ism VA yosh VA shahar); DataFrame ko'p ustun (jadval — Excel/SQL kabi). Aslida DataFrame — Series lar to'plami (har ustun bir Series, umumiy indeks — 3.1); "qator × ustun" (2D — lekin nomlangan, aralash tur). Data Science'ning asosiy tuzilmasi. DataFrame — jadval (qator × ustun, Series to'plami). Namuna/xususiyat. Markaz.

2.2. DataFrame yaratish

Turli usullar:

import pandas as pd

# 1. dict (ustun → qiymatlar) — eng ko'p
df = pd.DataFrame({
    "ism": ["Ali", "Vali"],
    "yosh": [25, 30],
})

# 2. ro'yxatlar ro'yxati (qatorlar)
df2 = pd.DataFrame(
    [["Ali", 25], ["Vali", 30]],
    columns=["ism", "yosh"],
)

# 3. bo'sh + ustun qo'shish
df3 = pd.DataFrame()
df3["ism"] = ["Ali", "Vali"]

DataFrame yaratish — turli usullar: (1) dict ({ustun: qiymatlar} — eng ko'p; kalit → ustun nomi, qiymat → ustun ma'lumoti); (2) ro'yxatlar ro'yxati (qatorlar — columns= bilan ustun nomi); (3) bo'sh + ustun (df["ism"] = [...] — qo'shib borish). Sabab: ma'lumot turli manbadan keladi (dict — kod ichida, ro'yxat — qator-qator, CSV — 3.3); dict eng qulay (ustun → qiymatlar, aniq). CSV/Excel'dan ham (3.3 — read_csv). dict — kalit ustun, qiymat ma'lumot. DataFrame yaratish — dict (eng ko'p), ro'yxat, CSV. dict qulay. Manba.

2.3. Ustun va qatorlar

Ustun (Series) va qator:

df = pd.DataFrame({"ism": ["Ali", "Vali"], "yosh": [25, 30]})

# USTUN — Series
df["yosh"]           # yosh ustuni (Series)
df[["ism", "yosh"]]  # bir nechta ustun (DataFrame)

# QATOR — .loc / .iloc (3.4)
df.loc[0]            # 0-qator (Series)
df.iloc[0]           # 0-qator (pozitsiya)

# YANGI ustun
df["katta"] = df["yosh"] > 27   # hisoblangan ustun

Ustun va qatorlar — kirish: ustun (df["yosh"] — Series; df[["ism", "yosh"]] — ko'p ustun, DataFrame), qator (df.loc[0] nom, df.iloc[0] pozitsiya — 3.4, Series), yangi ustun (df["katta"] = ... — hisoblangan/qo'shilgan). Sabab: ma'lumotga ustun/qator bo'yicha kirish (bitta xususiyat — ustun; bitta namuna — qator); ustun Series (3.1 — vektorlashtirilgan), ko'p ustun DataFrame. Yangi ustun oson (df["yangi"] = qiymat — hisoblangan, masalan yosh > 27). df["ustun"] (ustun), df.loc[qator] (qator). Ustun/qator — df["ustun"] Series, df.loc[] qator. Kirish. Yangi ustun.

2.4. Atributlar (shape, columns, dtypes)

DataFrame haqida ma'lumot:

df = pd.DataFrame({"ism": ["Ali", "Vali"], "yosh": [25, 30]})

df.shape        # (2, 2) — qatorlar × ustunlar
df.columns      # ['ism', 'yosh'] — ustun nomlari
df.index        # [0, 1] — qator indekslari
df.dtypes       # ism: object, yosh: int64 (ustun turlari)
len(df)         # 2 — qatorlar soni

Atributlar (shape, columns, dtypes) — DataFrame haqida: df.shape (o'lcham — qator × ustun, 2.3 kabi), df.columns (ustun nomlari), df.index (qator indekslari), df.dtypes (har ustun turi — ism object, yosh int64), len(df) (qatorlar soni). Sabab: DataFrameni tushunish (nechta qator/ustun, qaysi ustunlar, qanday tur — birinchi qadam); dtypes muhim (ustun turlari — son/matn; noto'g'ri tur — xato, 6-qism). shape (o'lcham), columns (ustunlar), dtypes (turlar). Atributlar — shape/columns/dtypes (DataFrame pasporti). Tushunish. Turlar.

2.5. Ko'rish (head, info, describe)

Ma'lumotni ko'rish:

df = pd.DataFrame({"yosh": [25, 30, 28, 35, 22]})

df.head()       # birinchi 5 qator (katta ma'lumot uchun)
df.head(3)      # birinchi 3
df.tail()       # oxirgi 5

df.info()       # ustunlar, turlar, NaN soni, xotira
df.describe()   # statistika (count, mean, std, min, max, kvartillar)

Ko'rish (head, info, describe) — ma'lumotni ko'rish: .head() (birinchi 5 qator — katta ma'lumot uchun ko'rish; .head(3) — 3), .tail() (oxirgi), .info() (ustunlar, turlar, NaN soni, xotira — umumiy holat), .describe() (statistika — count, mean, std, min, max, kvartillar; son ustunlar). Sabab: katta ma'lumotni butun ko'rib bo'lmaydi (million qator); head (namuna — qanday ko'rinadi), info (tuzilish — ustun, tur, NaN), describe (statistik xulosa — 1.6). Ma'lumotni tanish (birinchi qadam — CRISP-DM tushunish, 1.4). Ko'rish — head (namuna), info (tuzilish), describe (statistika). Tanish. Birinchi qadam.

2.6. DataFrame amaliyoti

DataFrame amaliyoti: pd.DataFrame (dict — eng ko'p); df["ustun"] (ustun — Series), df[["a", "b"]] (ko'p ustun); df["yangi"] = ... (yangi ustun — hisoblangan); atributlar (shape/columns/dtypes); ko'rish (head/info/describe); .loc/.iloc (qator — 3.4); vektorlashtirilgan (ustun amallari — Series 3.1). Tuzoqlar: ustun vs qator (df["ustun"] ustun, df.loc[] qator — chalkash), bir vs ko'p ustun (df["a"] Series, df[["a"]] DataFrame), dtype (noto'g'ri tur — 6-qism), copy vs view (.copy() — SettingWithCopyWarning). Amaliyot — yaratish, ustun/qator, atributlar, ko'rish. Jadval. Markaz.

2.7. DataFrame tuzoqlari

DataFrame asosiy tuzoqlari: ustun vs qator (df["yosh"] — ustun Series; qator uchun df.loc[0]/df.iloc[0]; chalkash — df[0] xato yoki noto'g'ri); bir vs ko'p ustun (df["a"] — Series (1D); df[["a"]] — DataFrame (2D, bir ustunli); qavs soni farqli); SettingWithCopyWarning (df[df.yosh > 25]["ism"] = ... — view/copy noaniq, o'zgartmaydi yoki ogohlantirish; .loc bilan df.loc[df.yosh > 25, "ism"] = ...); dtype noto'g'ri (CSV — hammasi object/matn; son astype — 6-qism); indeks chalkash (df.loc[0] indeks yorliq, df.iloc[0] pozitsiya; reset_index — 3.4); NaN (info NaN soni — tekshir, 3.7); ustun nomi bo'sh joy (df["yosh "] — bo'sh joy, xato; df.columns.str.strip()). Sabab: DataFrame ustun/qator/tur nozik (ustun vs qator, bir vs ko'p, view/copy — jim xato yoki ogohlantirish). Yechim: df["ustun"] ustun, .loc qator, .loc bilan o'zgartirish. Tuzoqlar — ustun/qator, bir/ko'p, SettingWithCopy, dtype.

2.8. DataFrame — Data Science yuragi

DataFrame asosiy g'oyasi — Data Science yuragi: real ma'lumot jadval (qatorlar — namunalar, ustunlar — xususiyatlar; mijozlar, savdo, o'lchovlar); DataFrame bu jadvalni Python'da beradi (Excel/SQL kabi, lekin dasturlash kuchi). Aslida DataFrame — Series lar to'plami (har ustun Series, umumiy indeks — 3.1); dict dan yaratiladi ({ustun: qiymatlar}), ustun Series (df["yosh"]), qator .loc/.iloc 3.4-bob. Atributlar (shape/columns/dtypes — tushunish), ko'rish (head/info/describe — tanish). Data Science'da deyarli hamma ish DataFrame ustida (tahlil, tozalash 6-qism, filtrlash 3.5, guruhlash 3.8, ML tayyorgarlik 20-qism). Bu 3.1 (Series — ustun) davomi va butun Pandas (3.3-3.14), Data Science uchun asos. DataFrame — Data Science yuragi (jadval, Series to'plami). Markaz. Deyarli hamma ish.

3. Tez ma'lumotnoma

import pandas as pd

# YARATISH (dict — eng ko'p):
df = pd.DataFrame({
    "ism": ["Ali", "Vali"],
    "yosh": [25, 30],
})

# USTUN (Series) va QATOR:
df["yosh"]           # ustun (Series)
df[["ism", "yosh"]]  # ko'p ustun (DataFrame)
df.loc[0]            # qator (nom) · df.iloc[0] — pozitsiya
df["yangi"] = df["yosh"] > 27   # yangi ustun (hisoblangan)

# ATRIBUTLAR:
df.shape        # (qator, ustun)
df.columns      # ustun nomlari
df.dtypes       # ustun turlari
len(df)         # qatorlar soni

# KO'RISH:
df.head()       # birinchi 5 · df.tail() — oxirgi
df.info()       # ustunlar, turlar, NaN, xotira
df.describe()   # statistika (mean, std, min, max)

QOIDA: df["ustun"] Series · df.loc[] qator · dict yaratish · head/info/describe

DataFrame xulosasi

DataFrame — Data Science yuragi (jadval, Series to'plami)
Yaratish — dict {ustun: qiymatlar} (eng ko'p)
Ustun — df["yosh"] (Series) · qator — df.loc[0]
Atributlar — shape, columns, dtypes (pasport)
Ko'rish — head (namuna), info (tuzilish), describe (statistika)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — DataFrame yaratish

"""DataFrame yaratish (real pandas)."""

import pandas as pd


def main() -> None:
    print("=== 1. dict dan ===")
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
    })
    print(f"  ustunlar: {list(df.columns)}")

    print("\n=== 2. Shakl ===")
    print(f"  shape: {df.shape} (qator × ustun)")

    print("\n=== 3. Ro'yxatlardan ===")
    df2 = pd.DataFrame([["Ali", 25], ["Vali", 30]], columns=["ism", "yosh"])
    print(f"  df2 shape: {df2.shape}")

    print("\n=== 4. Yangi ustun ===")
    df["katta"] = df["yosh"] > 27
    print(f"  katta ustun: {list(df['katta'])}")
    print("  ⭐ DataFrame — jadval (dict yaratish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. dict dan ===
  ustunlar: ['ism', 'yosh']

=== 2. Shakl ===
  shape: (3, 2) (qator × ustun)

=== 3. Ro'yxatlardan ===
  df2 shape: (2, 2)

=== 4. Yangi ustun ===
  katta ustun: [False, True, True]
  ⭐ DataFrame — jadval (dict yaratish)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Ustun va qatorlar

"""Ustun va qatorlar (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
    })

    print("=== 1. Ustun (Series) ===")
    print(f"  df['yosh']: {list(df['yosh'])}")

    print("\n=== 2. Ko'p ustun ===")
    kichik = df[["ism", "yosh"]]
    print(f"  df[['ism','yosh']] shape: {kichik.shape}")

    print("\n=== 3. Qator (iloc) ===")
    print(f"  df.iloc[0]: ism={df.iloc[0]['ism']}, yosh={df.iloc[0]['yosh']}")

    print("\n=== 4. Ustun statistikasi ===")
    print(f"  yosh o'rtacha: {df['yosh'].mean()}")
    print("  ⭐ Ustun — Series · qator — .loc/.iloc")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ustun (Series) ===
  df['yosh']: [25, 30, 28]

=== 2. Ko'p ustun ===
  df[['ism','yosh']] shape: (3, 2)

=== 3. Qator (iloc) ===
  df.iloc[0]: ism=Ali, yosh=25

=== 4. Ustun statistikasi ===
  yosh o'rtacha: 27.666666666666668
  ⭐ Ustun — Series · qator — .loc/.iloc

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Atributlar

"""Atributlar (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
        "maosh": [500.0, 700.0, 600.0],
    })

    print("=== 1. Shape ===")
    print(f"  shape: {df.shape}, len: {len(df)}")

    print("\n=== 2. Columns ===")
    print(f"  columns: {list(df.columns)}")

    print("\n=== 3. Dtypes ===")
    for ustun, tur in df.dtypes.items():
        print(f"  {ustun}: {tur}")

    print("\n=== 4. Index ===")
    print(f"  index: {list(df.index)}")
    print("  ⭐ Atributlar — shape, columns, dtypes (pasport)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Shape ===
  shape: (3, 3), len: 3

=== 2. Columns ===
  columns: ['ism', 'yosh', 'maosh']

=== 3. Dtypes ===
  ism: str
  yosh: int64
  maosh: float64

=== 4. Index ===
  index: [0, 1, 2]
  ⭐ Atributlar — shape, columns, dtypes (pasport)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Ko'rish (describe)

"""Ko'rish: head, describe (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, 30, 28, 35, 22, 40, 33],
        "maosh": [500, 700, 600, 900, 450, 1000, 750],
    })

    print("=== 1. head (birinchi 3) ===")
    print(f"  birinchi 3 yosh: {list(df.head(3)['yosh'])}")

    print("\n=== 2. Describe (yosh) ===")
    d = df["yosh"].describe()
    print(f"  count: {d['count']}, mean: {round(d['mean'], 1)}")
    print(f"  min: {d['min']}, max: {d['max']}")

    print("\n=== 3. Describe (maosh) ===")
    print(f"  maosh o'rtacha: {round(df['maosh'].mean(), 1)}")

    print("\n=== 4. Tail ===")
    print(f"  oxirgi 2 yosh: {list(df.tail(2)['yosh'])}")
    print("  ⭐ Ko'rish — head, describe (ma'lumotni tanish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. head (birinchi 3) ===
  birinchi 3 yosh: [25, 30, 28]

=== 2. Describe (yosh) ===
  count: 7.0, mean: 30.4
  min: 22.0, max: 40.0

=== 3. Describe (maosh) ===
  maosh o'rtacha: 700.0

=== 4. Tail ===
  oxirgi 2 yosh: [40, 33]
  ⭐ Ko'rish — head, describe (ma'lumotni tanish)

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Ustun vs qator

df[0]   # xato (ustun nomi kutadi)                           # ⚠️
df.iloc[0]   # qator · df["ustun"] — ustun                   # ✅

2. Bir vs ko'p ustun

df["ism"]   # Series (1D)                                    # ⚠️
df[["ism"]]   # DataFrame (2D — ko'p ustun uchun)             # ✅

3. SettingWithCopy

df[df.yosh > 25]["ism"] = "X"   # ogohlantirish (o'zgarmaydi) # ⚠️
df.loc[df.yosh > 25, "ism"] = "X"   # .loc bilan              # ✅

4. Dtype noto'g'ri

# CSV — hammasi object (matn)                                 # ⚠️
df["yosh"] = df["yosh"].astype(int)   # tur tuzatish          # ✅

5. Indeks chalkash

df.loc[0]   # indeks yorlig'i (0 bo'lmasligi mumkin)         # ⚠️
df.iloc[0]   # pozitsiya (doim birinchi)                       # ✅

6. Ustun nomi bo'sh joy

df["yosh "]   # bo'sh joy (xato)                             # ⚠️
df.columns = df.columns.str.strip()   # tozalash              # ✅

7. describe object

df.describe()   # faqat son ustunlar                         # ⚠️
df.describe(include="all")   # hamma ustun                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.1-dars (o'tilgan): Series (ustun)
• 3.3-dars: O'qish/yozish (CSV → DataFrame)
• 3.4-dars: Tanlash (.loc/.iloc)
• 3.5-dars: Filtrlash
• 6-qism: Tozalash (DataFrame tozalash)

8. Eng yaxshi amaliyotlar

1. pd.DataFrame(dict) — yaratish (eng ko'p).

2. df["ustun"] Series, df.loc[] qator.

3. df[["a", "b"]] — ko'p ustun (DataFrame).

4. shape/columns/dtypes — tushunish.

5. head/info/describe — ma'lumotni tanish.

6. .loc bilan o'zgartirish (SettingWithCopy).

7. dtypes tekshir (tur to'g'rimi).

8. DataFrame — Data Science yuragi.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # DataFrame nima?
2.  # qatorlar/ustunlar nima?
3.  # dict dan qanday?
4.  # df["yosh"] nima?
5.  # df[["a","b"]] nima?
6.  # yangi ustun qanday?
7.  # shape nima?
8.  # dtypes nima?
9.  # head nima?
10. # info nima?
11. # describe nima?
12. # DataFrame nima uchun yurak?

Vazifa 2: Xatolarni tuzating

1.  df[0]   # birinchi qator

2.  df["ism"]   # DataFrame kerak

3.  df[df.yosh > 25]["ism"] = "X"

4.  df.loc[0]   # doim birinchi

5.  df["yosh "]   # bo'sh joy

1.  df.iloc[0]   # qator

2.  df[["ism"]]   # DataFrame

3.  df.loc[df.yosh > 25, "ism"] = "X"

4.  df.iloc[0]   # pozitsiya

5.  df.columns.str.strip()

Vazifa 3: DataFrame

Modellang:

1. Jadval
2. Qator
3. Ustun
4. Series to'plami

Vazifa 4: Yaratish

Modellang:

1. dict
2. Ro'yxatlar
3. CSV
4. Yangi ustun

Vazifa 5: Kirish

Modellang:

1. Ustun
2. Qator
3. Ko'p ustun
4. .loc/.iloc

Vazifa 6: Ko'rish

Modellang:

1. head
2. info
3. describe
4. Tanish

Vazifa 7: O'ylash

DataFrame aslida "Series lar to'plami" (har ustun bir Series, umumiy indeks bilan). Nima uchun bu "ustunga yo'naltirilgan" tuzilma Data Science uchun mantiqan to'g'ri (nega ustunlar, qatorlar emas, asosiy birlik), va bu Excel jadvalidan qanday farq qiladi — nega DataFrame kuchliroq?

Nimani mustahkamlaydi: 2.1, 2.3-bo'limlar.

Xulosa

Bu darsda DataFrame'ni o'rgandik.

Eng muhim uch fikr:

1. DataFrame va yaratish. DataFrame — jadval (qatorlar × ustunlar): qatorlar (namunalar — mijoz), ustunlar (xususiyatlar — ism, yosh); aslida Series lar to'plami (har ustun Series, umumiy indeks). Yaratish — dict ({ustun: qiymatlar} — eng ko'p), ro'yxatlar (columns=), CSV 3.3-bob. Excel/SQL jadvali kabi, lekin dasturlash kuchi.

2. Ustun, qator va atributlar. Ustun — df["yosh"] (Series), df[["ism", "yosh"]] (ko'p ustun — DataFrame); qator — df.loc[0] (nom), df.iloc[0] (pozitsiya — 3.4); yangi ustun — df["katta"] = df["yosh"] > 27 (hisoblangan). Atributlar — shape (qator × ustun), columns (ustun nomlari), dtypes (ustun turlari — son/matn, muhim), index.

3. Ko'rish va yurak. Ko'rish — head (birinchi 5 — namuna), tail (oxirgi), info (ustunlar, turlar, NaN, xotira), describe (statistika — mean, std, min, max); katta ma'lumotni tanish (birinchi qadam). DataFrame — Data Science yuragi (jadval — Series to'plami; deyarli hamma ish shu ustida — tahlil, tozalash, filtrlash, guruhlash, ML); ustunga yo'naltirilgan (xususiyat — bir tur, vektorlashtirilgan, tez); Excel'dan kuchli (dasturlash, katta ma'lumot, ekotizim). Tuzoqlar: ustun vs qator (df["ustun"] vs df.loc[]), bir vs ko'p ustun (Series vs DataFrame), SettingWithCopy (.loc bilan), dtype (tur tekshir).

Keyingi darsda o'qish va yozish (CSV/Excel)ni o'rganamiz: real fayllardan ma'lumot o'qish (read_csv) va saqlash — real ma'lumot bilan ishlashning birinchi qadami.