3.1-dars: Pandas nima va Series

3-QISM — PANDAS · 1-dars

1. Kirish va motivatsiya

NumPy'ni o'rgandik — u sonli massivlar uchun ajoyib. Lekin real ma'lumot ko'pincha jadval ko'rinishida: ustunlarning nomlari bor (yosh, ism, maosh), qatorlar turli tur (matn, son, sana), va yo'q qiymatlar (NaN) uchraydi. NumPy bu uchun noqulay (faqat son, nomsiz o'lchamlar). Shu yerda Pandas keladi — Data Science'ning eng ko'p ishlatiladigan kutubxonasi, jadval ma'lumot bilan ishlash uchun. Pandas ikkita asosiy tuzilma beradi: Series (nomlangan bir o'lchamli — bitta ustun) va DataFrame (jadval — ko'p ustun). Bu dars Seriesdan boshlaydi — Pandas'ning qurilish bloki. Nega muhim? (1) Real ma'lumot — CSV, Excel, ma'lumotlar bazasi — hammasi jadval; (2) Qulaylik — nomlangan ustun, aralash tur, NaN; (3) NumPy ustida — Pandas NumPy'ga tayanadi (tez), lekin yuqori daraja. Bu dars Pandas va Series'ni o'rgatadi — jadval ma'lumotning boshlanishi.

Pandas va Series — jadval ma'lumot kutubxonasi: Pandas (Data Science jadval vositasi — NumPy ustida, yuqori daraja), Series (nomlangan 1D — bitta ustun; qiymat + indeks), indeks (yorliq — raqam yoki nom, s['nom']), NumPy farqi (nomlangan indeks, aralash tur, NaN), yaratish (pd.Series — ro'yxat/dict), atributlar (.values, .index, .dtype). Foydalanish: bitta ustun, nomlangan ma'lumot, jadval bloki. Bu 2-qism (NumPy), 3.2 (DataFrame) bilan bog'liq. Pandas — jadval vositasi. Series — nomlangan 1D. NumPy ustida.

Real vaziyat. Data Scientist do'kon mahsulot narxlari bilan ishlar edi. NumPy massivda narxlar bor edi ([100, 200, 150]), lekin qaysi narx qaysi mahsulot — bilinmas edi (nomsiz — indeks 0,1,2). Pandas Series bilan tuzatdi: pd.Series([100, 200, 150], index=["olma", "non", "sut"]) — endi narx["non"] (nom bilan — 200); nomlangan (mazmunli). Series NumPy massivga o'xshash (vektorlashtirilgan — narx * 1.1), lekin nomlangan indeks (qulay), aralash tur (matn/son), NaN (yo'q qiymat). Pandas Series ma'lumotni nomlangan qildi (mazmun). Series — Pandas qurilish bloki (jadval boshi).

Bu darsda Pandas va Series'ni o'rganamiz.

Bu darsda:

• Pandas nima (jadval vositasi)
• Series (nomlangan 1D)
• Indeks (yorliq)
• Series amallari (vektorlashtirilgan)
• NumPy'dan farqi
• Series amaliyoti
• Series tuzoqlari
• Amaliy: Series modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Pandas nima (jadval vositasi)

Data Science jadval kutubxonasi:

import pandas as pd    # standart nom (pd)

# Pandas — jadval ma'lumot uchun:
#   Series — bitta ustun (nomlangan 1D)
#   DataFrame — jadval (ko'p ustun)

# NumPy ustida qurilgan (tez), lekin yuqori daraja:
#   nomlangan ustun, aralash tur, NaN, o'qish/yozish (CSV)

Pandas nima — Data Science jadval kutubxonasi: import pandas as pd (standart nom — pd); jadval ma'lumot bilan ishlash uchun (CSV, Excel, DB — hammasi jadval). Ikki asosiy tuzilma: Series (bitta ustun — nomlangan 1D), DataFrame (jadval — ko'p ustun). Sabab: real ma'lumot jadval (nomlangan ustun, aralash tur, NaN — NumPy noqulay); Pandas jadval uchun mo'ljallangan. NumPy ustida qurilgan (tez — vektorlashtirish), lekin yuqori daraja (nomlangan ustun, o'qish/yozish, guruhlash). Data Science'da eng ko'p ishlatiladi. Pandas — jadval vositasi (pd). Series/DataFrame. NumPy ustida.

2.2. Series (nomlangan 1D)

Nomlangan bir o'lchamli:

import pandas as pd

# ro'yxatdan
s = pd.Series([100, 200, 150])
# 0    100
# 1    200
# 2    150

# NOMLANGAN indeks bilan
narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])
narx["non"]     # 200 (nom bilan!)

# dict dan (kalit → indeks)
pd.Series({"olma": 100, "non": 200})

Series (nomlangan 1D) — bir o'lchamli nomlangan: pd.Series([100, 200, 150]) (qiymatlar + indeks — 0,1,2), index=[...] (nomlangan — narx["non"]), dict dan (kalit → indeks). Sabab: NumPy 1D nomsiz (indeks 0,1,2 — mazmunsiz); Series nomlangan (narx["non"] — mazmunli, qaysi qiymat nima). Series = qiymatlar (.values — NumPy massiv) + indeks (.index — yorliq). Ro'yxat (indeks avtomatik) yoki dict (kalit — indeks). Bu DataFrame ustuni (3.2 — DataFrame = Series lar to'plami). Series — nomlangan 1D (qiymat + indeks). Nomlangan. Ustun.

2.3. Indeks (yorliq)

Indeks — qatorlar yorligi:

narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])

# INDEKS bo'yicha kirish
narx["olma"]      # 100 (nom)
narx[0]           # 100 (pozitsiya ham)

# indeks atributlari
narx.index        # ['olma', 'non', 'sut']
narx.values       # [100 200 150] (NumPy massiv)

# indeks — mazmunli yorliq (raqam emas)

Indeks (yorliq) — qatorlar yorligi: narx["olma"] (nom bo'yicha — 100), narx.index (barcha yorliq), narx.values (qiymatlar — NumPy massiv). Sabab: indeks ma'lumotni mazmunli qiladi (raqam emas — narx["olma"] aniq, narx[0] mavhum); Series indeks bo'yicha ishlaydi (kirish, moslashtirish — 2.6). Indeks yorliq (nom yoki raqam — mazmunli), .values (NumPy massiv — asos), .index (yorliqlar). Indeks takrorlanuvchi amallarda saqlanadi (narx * 1.1 — indeks o'sha). Indeks — yorliq (nom, mazmunli). .values/.index. Mazmun.

2.4. Series amallari (vektorlashtirilgan)

NumPy kabi tez:

narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])

# VEKTORLASHTIRILGAN (NumPy kabi)
narx * 1.1          # har narxga 10% (indeks saqlanadi)
narx + 50           # har biriga +50
narx > 120          # bool Series (shart)
narx[narx > 120]    # filtr (boolean indeks)

# statistika
narx.mean()         # 150.0
narx.sum()          # 450
narx.max()          # 200

Series amallari (vektorlashtirilgan) — NumPy kabi tez: narx * 1.1 (har qiymat — vektorlashtirilgan, indeks saqlanadi), narx > 120 (bool Series — shart), narx[narx > 120] (filtr — boolean indeks 2.9), statistika (mean/sum/max — 2.8). Sabab: Series NumPy ustida (vektorlashtirilgan — tez, siklsiz 2.5); NumPy amallari Series'da ham (* 1.1, > 120, mean); lekin indeks saqlanadi (natija nomlangan). NumPy bilim Series'da ishlaydi (element-wise, filtr, agregatsiya). Series amallari — vektorlashtirilgan (NumPy kabi, indeks bilan). Tez. NumPy bilim.

2.5. NumPy'dan farqi

NumPy'dan farqi — Series nima qo'shadi: (1) nomlangan indeks — Series narx["non"] (nom), NumPy a[1] (pozitsiya — mazmunsiz); (2) aralash tur — Series object (matn/son aralash mumkin), NumPy bir tur (son); (3) NaN — Series yo'q qiymatni NaN (yo'q ma'lumot — real; NumPy noqulay); (4) indeks moslashtirish — ikki Series qo'shganda indeks bo'yicha moslashadi (nom mos — qo'shiladi; NumPy pozitsiya); (5) o'qish/yozish — Pandas CSV/Excel (NumPy — asosiy). Sabab: real ma'lumot jadval (nom, aralash, NaN — NumPy noqulay); Pandas bularni qo'shadi (yuqori daraja), lekin NumPy tezligini saqlaydi (ustida). NumPy'dan farq — nomlangan indeks, aralash tur, NaN, moslashtirish. Yuqori daraja. Real.

2.6. Series amaliyoti

Series amaliyoti: pd.Series (ro'yxat/dict — yaratish); index (nomlangan yorliq); narx["nom"] (indeks bo'yicha kirish); .values/.index/.dtype (atributlar); vektorlashtirilgan (* 1.1, > 120 — NumPy kabi); filtr (narx[narx > 120] — boolean); statistika (mean/sum/max — 2.8); indeks moslashtirish (ikki Series — nom bo'yicha). Tuzoqlar: indeks vs pozitsiya (narx[0] vs narx["nom"] — chalkash), indeks moslashtirish (turli indeks — NaN), aralash tur (object — sekinroq), NaN (yo'q qiymat — dropna/fillna). Amaliyot — Series yaratish, indeks, vektorlashtirish, filtr. Nomlangan. NumPy kabi.

2.7. Series tuzoqlari

Series asosiy tuzoqlari: indeks vs pozitsiya (narx["olma"] nom, narx[0] pozitsiya; nomlangan indeks bo'lsa ikkalasi ishlaydi, lekin chalkash — .loc nom, .iloc pozitsiya aniq — 3.4); indeks moslashtirish (ikki Series qo'shganda turli indeks — mos kelmagani NaN bo'ladi; s1 + s2 — faqat umumiy indeks); aralash tur (matn + son — object dtype, sekinroq va vektorlashtirish yo'q; bir tur afzal); NaN tarqalishi (NaN bilan amal — natija NaN; mean NaN'ni o'tkazib yuboradi lekin + tarqatadi; ehtiyot); indeks takrori (bir xil indeks ikki marta — narx["nom"] ikki qiymat qaytaradi, kutilmagan); copy vs view (Series ham — .copy() kerak bo'lsa, 2.13); indeks o'zgarmas deb (indeks o'zgartiriluvchan — reset_index, set_index). Sabab: Series indeks/tur nozik (indeks moslashtirish, aralash tur, NaN — jim xato yoki NaN). Yechim: .loc/.iloc (aniq), bir tur, NaN tekshir. Tuzoqlar — indeks, moslashtirish, aralash tur, NaN.

2.8. Series — Pandas qurilish bloki

Series asosiy g'oyasi — Pandas qurilish bloki: Series — nomlangan 1D (qiymatlar + indeks); bu Pandas'ning eng kichik birligi (DataFrame = Series lar to'plami — 3.2; har ustun bir Series). NumPy 1D nomsiz (pozitsiya — mazmunsiz); Series nomlangan (indeks — mazmunli, narx["non"]). Series NumPy ustida (vektorlashtirilgan — tez, * 1.1, > 120, mean), lekin qo'shadi: nomlangan indeks (qulay), aralash tur (object), NaN (yo'q qiymat — real), indeks moslashtirish (nom bo'yicha). Data Science'da Series bitta ustun (narx, yosh, ism — nomlangan ma'lumot). Bu 2-qism (NumPy — asos) davomi va 3.2 (DataFrame — jadval, Series to'plami) ga zamin. Series — Pandas qurilish bloki (nomlangan 1D). Nomlangan. Ustun. Asos.

3. Tez ma'lumotnoma

import pandas as pd

# SERIES YARATISH:
pd.Series([100, 200, 150])                      # indeks 0,1,2
pd.Series([100, 200], index=["olma", "non"])    # nomlangan
pd.Series({"olma": 100, "non": 200})            # dict dan

# INDEKS (yorliq):
narx["olma"]      # nom bo'yicha
narx.index        # yorliqlar
narx.values       # qiymatlar (NumPy massiv)
narx.dtype        # tur

# VEKTORLASHTIRILGAN (NumPy kabi, indeks saqlanadi):
narx * 1.1        # har qiymat
narx > 120        # bool Series
narx[narx > 120]  # filtr (boolean)
narx.mean()       # statistika (mean/sum/max)

# NumPy'DAN FARQI:
#   nomlangan indeks · aralash tur · NaN · indeks moslashtirish

QOIDA: Series = qiymat + indeks · NumPy ustida · .loc nom, .iloc pozitsiya

Series xulosasi

Series — Pandas qurilish bloki (nomlangan 1D)
Pandas — jadval vositasi (Series ustun, DataFrame jadval)
Series = qiymatlar (.values NumPy) + indeks (.index yorliq)
Vektorlashtirilgan (NumPy kabi — * 1.1, > 120, mean)
Qo'shadi — nomlangan indeks, aralash tur, NaN, moslashtirish

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — Series yaratish

"""Series yaratish (real pandas)."""

import pandas as pd


def main() -> None:
    print("=== 1. Ro'yxatdan ===")
    s = pd.Series([100, 200, 150])
    print(f"  qiymatlar: {list(s.values)}, indeks: {list(s.index)}")

    print("\n=== 2. Nomlangan indeks ===")
    narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])
    print(f"  narx['non']: {narx['non']}")

    print("\n=== 3. Dict dan ===")
    d = pd.Series({"olma": 100, "non": 200})
    print(f"  indeks: {list(d.index)}, qiymat: {list(d.values)}")

    print("\n=== 4. Atributlar ===")
    print(f"  dtype: {narx.dtype}, uzunlik: {len(narx)}")
    print("  ⭐ Series — nomlangan 1D (qiymat + indeks)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ro'yxatdan ===
  qiymatlar: [np.int64(100), np.int64(200), np.int64(150)], indeks: [0, 1, 2]

=== 2. Nomlangan indeks ===
  narx['non']: 200

=== 3. Dict dan ===
  indeks: ['olma', 'non'], qiymat: [np.int64(100), np.int64(200)]

=== 4. Atributlar ===
  dtype: int64, uzunlik: 3
  ⭐ Series — nomlangan 1D (qiymat + indeks)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Indeks bilan ishlash

"""Indeks bilan ishlash (real pandas)."""

import pandas as pd


def main() -> None:
    narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])

    print("=== 1. Nom bo'yicha ===")
    print(f"  narx['olma']: {narx['olma']}")

    print("\n=== 2. Bir nechta ===")
    print(f"  narx[['olma', 'sut']]:\n{narx[['olma', 'sut']].to_dict()}")

    print("\n=== 3. Values va index ===")
    print(f"  values: {list(narx.values)}")
    print(f"  index: {list(narx.index)}")

    print("\n=== 4. Indeks o'zgartirish ===")
    narx2 = narx.copy()
    narx2.index = ["A", "B", "C"]
    print(f"  yangi indeks: {list(narx2.index)}")
    print("  ⭐ Indeks — mazmunli yorliq")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Nom bo'yicha ===
  narx['olma']: 100

=== 2. Bir nechta ===
  narx[['olma', 'sut']]:
{'olma': 100, 'sut': 150}

=== 3. Values va index ===
  values: [np.int64(100), np.int64(200), np.int64(150)]
  index: ['olma', 'non', 'sut']

=== 4. Indeks o'zgartirish ===
  yangi indeks: ['A', 'B', 'C']
  ⭐ Indeks — mazmunli yorliq

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Series amallari

"""Series amallari: vektorlashtirilgan (real pandas)."""

import pandas as pd


def main() -> None:
    narx = pd.Series([100, 200, 150], index=["olma", "non", "sut"])

    print("=== 1. Vektorlashtirilgan ===")
    print(f"  narx * 1.1:\n{(narx * 1.1).round(1).to_dict()}")

    print("\n=== 2. Shart (bool Series) ===")
    print(f"  narx > 120:\n{(narx > 120).to_dict()}")

    print("\n=== 3. Filtr ===")
    print(f"  narx[narx > 120]:\n{narx[narx > 120].to_dict()}")

    print("\n=== 4. Statistika ===")
    print(f"  mean: {narx.mean()}, sum: {narx.sum()}, max: {narx.max()}")
    print("  ⭐ Series amallari — NumPy kabi (indeks saqlanadi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Vektorlashtirilgan ===
  narx * 1.1:
{'olma': 110.0, 'non': 220.0, 'sut': 165.0}

=== 2. Shart (bool Series) ===
  narx > 120:
{'olma': False, 'non': True, 'sut': True}

=== 3. Filtr ===
  narx[narx > 120]:
{'non': 200, 'sut': 150}

=== 4. Statistika ===
  mean: 150.0, sum: 450, max: 200
  ⭐ Series amallari — NumPy kabi (indeks saqlanadi)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Indeks moslashtirish

"""Indeks moslashtirish (real pandas)."""

import pandas as pd


def main() -> None:
    print("=== 1. Bir xil indeks ===")
    a = pd.Series([1, 2, 3], index=["x", "y", "z"])
    b = pd.Series([10, 20, 30], index=["x", "y", "z"])
    print(f"  a + b:\n{(a + b).to_dict()}")

    print("\n=== 2. Turli indeks (NaN) ===")
    c = pd.Series([1, 2], index=["x", "y"])
    d = pd.Series([10, 20], index=["y", "z"])
    natija = c + d
    print(f"  faqat umumiy 'y' son: {natija['y']}")
    print(f"  'x' va 'z' NaN: {natija.isna().sum()} ta")

    print("\n=== 3. Statistika NaN o'tkazadi ===")
    print(f"  natija.sum() (NaN o'tkazadi): {natija.sum()}")

    print("\n=== 4. Tushuntirish ===")
    print("  indeks bo'yicha moslashadi (nom mos)")
    print("  ⭐ Indeks moslashtirish — NumPy'dan farq")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Bir xil indeks ===
  a + b:
{'x': 11, 'y': 22, 'z': 33}

=== 2. Turli indeks (NaN) ===
  faqat umumiy 'y' son: 12.0
  'x' va 'z' NaN: 2 ta

=== 3. Statistika NaN o'tkazadi ===
  natija.sum() (NaN o'tkazadi): 12.0

=== 4. Tushuntirish ===
  indeks bo'yicha moslashadi (nom mos)
  ⭐ Indeks moslashtirish — NumPy'dan farq

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Indeks vs pozitsiya

narx[0]   # pozitsiya (nomlangan bo'lsa chalkash)             # ⚠️
narx.iloc[0]   # pozitsiya · narx.loc["olma"] — nom           # ✅

2. Indeks moslashtirish

a + b   # turli indeks → NaN                                 # ⚠️
a.add(b, fill_value=0)   # NaN o'rniga 0                      # ✅

3. Aralash tur

pd.Series([1, "matn", 3])   # object (sekin)                 # ⚠️
pd.Series([1, 2, 3])   # int64 (tez)                          # ✅

4. NaN tarqalishi

s + boshqa   # NaN tarqaladi                                 # ⚠️
s.fillna(0) + boshqa   # NaN to'ldirish                       # ✅

5. Values NumPy deb

narx.mean()   # Series metodi (to'g'ri)                      # ⚠️
narx.values.mean()   # NumPy (indeks yo'qoladi)               # ✅

6. Indeks takror

pd.Series([1, 2], index=["x", "x"])   # takror (chalkash)    # ⚠️
# noyob indeks (unique)                                        # ✅

7. Series print

print(s)   # to'liq (indeks + qiymat)                        # ⚠️
s.to_dict()   # ixcham (dict)                                 # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2-qism (o'tilgan): NumPy (Series asosi)
• 3.2-dars: DataFrame (Series lar to'plami)
• 3.4-dars: Tanlash (.loc/.iloc)
• 3.7-dars: Yo'q qiymatlar (NaN)
• 6-qism: Tozalash (Series bilan ustun tozalash)

8. Eng yaxshi amaliyotlar

1. import pandas as pd (standart nom).

2. Series = qiymat + indeks (nomlangan).

3. .loc nom, .iloc pozitsiya (aniq).

4. Bir tur (aralash — object sekin).

5. Indeks moslashtirish (turli — NaN).

6. Vektorlashtir (NumPy kabi — tez).

7. NaN tekshir (isna, fillna).

8. Series — Pandas qurilish bloki.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # Pandas nima uchun?
2.  # import qanday?
3.  # Series nima?
4.  # indeks nima?
5.  # narx['nom'] nima?
6.  # .values nima?
7.  # Series vektorlashtiriladimi?
8.  # NumPy'dan farqi?
9.  # turli indeks qo'shilsa?
10. # aralash tur?
11. # .loc vs .iloc?
12. # Series nima uchun blok?

Vazifa 2: Xatolarni tuzating

1.  narx[0]   # nomlangan (chalkash)

2.  a + b   # turli indeks

3.  pd.Series([1, "x", 3])   # tez kerak

4.  narx.values.mean()   # indeks kerak

5.  pd.Series([1,2], index=["x","x"])   # noyob

1.  narx.iloc[0] yoki narx.loc["olma"]

2.  a.add(b, fill_value=0)

3.  pd.Series([1, 2, 3])   # bir tur

4.  narx.mean()   # Series metodi

5.  noyob indeks (unique)

Vazifa 3: Pandas

Modellang:

1. Jadval
2. Series
3. DataFrame
4. NumPy ustida

Vazifa 4: Series

Modellang:

1. Qiymat
2. Indeks
3. Nomlangan
4. 1D

Vazifa 5: Indeks

Modellang:

1. Yorliq
2. Nom
3. .values
4. .index

Vazifa 6: Amallar

Modellang:

1. Vektorlashtirilgan
2. Filtr
3. Statistika
4. Moslashtirish

Vazifa 7: O'ylash

Pandas NumPy ustida qurilgan (uning tezligidan foydalanadi), lekin nomlangan indeks, aralash tur va NaN qo'shadi. Nima uchun bu "pastki qatlam ustida yuqori qatlam qurish" dasturlashning kuchli naqshi, va nega Pandas NumPy'ni almashtirmasdan uning ustiga qurilgani (ikkalasi ham kerak) mantiqan to'g'ri?

Nimani mustahkamlaydi: 2.1, 2.5-bo'limlar.

Xulosa

Bu darsda Pandas va Series'ni o'rgandik.

Eng muhim uch fikr:

1. Pandas va Series. Pandas (import pandas as pd) — Data Science jadval kutubxonasi (CSV, Excel — real ma'lumot); ikki tuzilma: Series (bitta ustun — nomlangan 1D), DataFrame (jadval — ko'p ustun); NumPy ustida (tez), lekin yuqori daraja. Series — nomlangan 1D: pd.Series([100, 200], index=["olma", "non"]) (qiymatlar + indeks); narx["non"] (nom bilan — mazmunli).

2. Indeks va amallar. Indeks (yorliq) — qatorlar yorligi (nom yoki raqam — mazmunli); narx.index (yorliqlar), narx.values (qiymatlar — NumPy massiv). Series amallari — vektorlashtirilgan (NumPy kabi — * 1.1, > 120, mean; indeks saqlanadi, tez — NumPy ustida); filtr (narx[narx > 120] — boolean 2.9), statistika (mean/sum/max — 2.8).

3. Qurilish bloki. NumPy'dan farqi — Series qo'shadi: nomlangan indeks (narx["non"]), aralash tur (object), NaN (yo'q qiymat — real), indeks moslashtirish (ikki Series — nom bo'yicha, turli indeks → NaN). Series — Pandas qurilish bloki (nomlangan 1D; DataFrame = Series to'plami — 3.2). Pandas NumPy ustida (qatlamli naqsh — qayta ishlatish, abstraksiya; ikkalasi kerak — NumPy son/tez, Pandas jadval/qulay). Tuzoqlar: indeks vs pozitsiya (.loc/.iloc), indeks moslashtirish (NaN), aralash tur (object sekin), NaN tarqalishi.

Keyingi darsda DataFrameni o'rganamiz: jadval (ko'p ustun) — Data Science'ning eng asosiy tuzilmasi; ustunlar, qatorlar, yaratish va ko'rish.