IlmHamroh
Python kursi/Malumot tahlili5/18-dars15 daqiqa
Mundarija (22)

24.5-dars: pandas — Series va DataFrame

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

1. Kirish va motivatsiya

NumPy (24.1–24.4) sonlar bilan ajoyib, lekin real ma'lumot ko'pincha jadval shaklida: ustunlar nomi bor (nom, narx, sana), turlar aralash (matn + son), qatorlar belgilangan (id, sana). NumPy massivi — faqat sonlar, nomsiz. Jadval ma'lumoti (CSV, Excel, baza) uchun boshqa vosita kerak.

pandas — Python'ning jadval ma'lumoti bilan ishlash kutubxonasi (NumPy ustida qurilgan). Ikki asosiy tuzilma: Series (bir o'lchamli — nomlangan indeksli massiv, jadvalning bir ustuni kabi) va DataFrame (ikki o'lchamli — nomlangan ustunli jadval, Excel varag'i kabi). Har ustun o'z turi (matn, son, sana), qatorlar indeks bilan. CSV o'qish, filtrlash, guruhlash, statistika — hammasi oson. Ma'lumot tahlilining eng ko'p ishlatiladigan vositasi.

Real vaziyat. Bir hisobot minglab sotuv yozuvini (sana, mahsulot, summa) qayta ishlardi — Python dict va sikl bilan yuzlab qator kod, xatolarga moyil. pandas'ga o'tdi: df = pd.read_csv("sotuv.csv"), df.groupby("mahsulot").summa.sum() — ikki qatorda jami. Filtrlash, guruhlash, statistika — bir necha qator. Kod 10 barobar qisqardi, o'qish oson bo'ldi. pandas — ma'lumot tahlilining ish oti.

Bu darsda pandas'ni — Series va DataFrame'ni o'rganamiz.

Bu darsda:

  • pandas nima
  • Series (bir o'lchamli)
  • DataFrame (jadval)
  • Ustun tanlash va qo'shish
  • Asosiy atributlar (shape, columns, dtypes)
  • Statistika (describe, mean)
  • head/tail (ko'rish)
  • Amaliy: jadval bilan ishlash

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

2. Nazariya — chuqur tushuntirish

2.1. pandas nima

pandas — jadval ma'lumoti bilan ishlash:

python
import pandas as pd
df = pd.DataFrame({
    "nom": ["Python", "Go", "Rust"],
    "narx": [100, 120, 150],
})

pandas — Python jadval ma'lumoti kutubxonasi (NumPy ustida). Ikki tuzilma: Series (bir ustun — nomlangan indeksli), DataFrame (jadval — nomlangan ustunli). NumPy'dan farq: ustunlar nomi bor, turlar aralash (matn + son), qatorlar indeks bilan. import pandas as pd — an'anaviy nom. CSV/Excel/baza o'qish, tahlil — asosiy vosita.

2.2. Series (bir o'lchamli)

Series — nomlangan indeksli massiv:

python
s = pd.Series([10, 20, 30], index=["a", "b", "c"])
s["b"]              # 20 (indeks bilan)
s[s > 15]           # b, c (bool indeks)
s.mean()            # 20.0
s.values            # NumPy massiv

Series — bir o'lchamli ma'lumot: qiymatlar + indeks (belgi — "a", "b" yoki 0, 1, 2). NumPy massivdan farq: har element nomlangan (indeks). s["b"] (indeks bilan o'qish), s[s > 15] (bool indeks, 24.3), s.mean() (statistika). DataFrame ustuni — Series. Lug'at (dict) va massiv o'rtasidagi narsa.

2.3. DataFrame (jadval)

DataFrame — nomlangan ustunli jadval:

python
df = pd.DataFrame({
    "nom": ["Python", "Go", "Rust"],
    "narx": [100, 120, 150],
    "til": ["uz", "en", "en"],
})
# har ustun — Series; har qator — indeksli

DataFrame — ikki o'lchamli jadval: nomlangan ustunlar (har biri Series), indeksli qatorlar. Excel varag'i yoki SQL jadvali kabi. Yaratish: dict (kalit → ustun), CSV 24.6-bob, baza. Har ustun o'z turi (matn, son, sana). Bu ma'lumot tahlilining asosiy tuzilmasi — real ma'lumot (jadval) uchun tabiiy.

2.4. Ustun tanlash va qo'shish

Ustun bilan ishlash:

python
df["nom"]                    # bir ustun (Series)
df[["nom", "narx"]]          # bir necha ustun (DataFrame)
df["chegirma"] = df["narx"] * 0.9   # yangi ustun
df["narx"].mean()            # ustun statistika

Ustun tanlash: df["nom"] (bir ustun — Series), df[["nom", "narx"]] (bir necha — DataFrame, ikki qavs). Yangi ustun: df["yangi"] = ... (vektorlangan — df["narx"] * 0.9). Ustun ustida amal (Series — NumPy kabi, vektorlangan). Bu jadval ma'lumoti bilan ishlashning asosi.

2.5. Asosiy atributlar

DataFrame haqida ma'lumot:

python
df.shape           # (3, 3) — qator, ustun
df.columns         # ustun nomlari
df.index           # qator indekslari
df.dtypes          # har ustun turi
df.info()          # umumiy ma'lumot
len(df)            # qatorlar soni

Atributlar: .shape (o'lcham — (qator, ustun)), .columns (ustun nomlari), .index (qator indekslari), .dtypes (har ustun turi — int64, float64, str), .info() (umumiy — ustunlar, turlar, bo'sh qiymatlar). Bular ma'lumotni tanish (birinchi qadam — qanday ma'lumot, qancha). Yangi ma'lumot bilan doim shularni ko'ring.

2.6. Statistika (describe, mean)

Tez statistika:

python
df["narx"].mean()      # o'rtacha
df["narx"].sum()       # yig'indi
df["narx"].max()       # eng katta
df.describe()          # barcha son ustun statistikasi
df["til"].value_counts()  # qiymatlar sanog'i

Statistika: .mean()/.sum()/.max()/.min()/.std() (Series yoki ustun), .describe() (barcha son ustun — count, mean, std, min, max, kvartil), .value_counts() (kategoriya sanog'i — har qiymat necha marta). describe() — ma'lumotni tez tushunishning eng foydali vositasi. 24.16 (statistika) da chuqurroq.

2.7. head/tail (ko'rish)

Ma'lumotning bir qismini ko'rish:

python
df.head()          # birinchi 5 qator
df.head(3)         # birinchi 3
df.tail()          # oxirgi 5
df.sample(3)       # tasodifiy 3 (tahlilda)

head(n) (birinchi n qator — default 5), tail(n) (oxirgi n), sample(n) (tasodifiy n). Katta ma'lumotda (million qator) hammasini ko'rib bo'lmaydi — head() bilan bir qismini ko'rib tuzilishini tushunish. Ma'lumot bilan tanishishning birinchi qadami: head(), shape, dtypes, describe().

2.8. pandas — NumPy ustida

pandas NumPy ustida qurilgan: har ustun (Series) ichida NumPy massiv (.values). Shuning uchun pandas ham vektorlangan (tez — df["narx"] * 0.9 siklsiz), NumPy amallari ishlaydi. Farq: pandas nomlangan (ustun, indeks — inson uchun), aralash tur (jadval), ma'lumot vositalari (CSV, guruhlash, birlashtirish). "NumPy — son yadrosi, pandas — jadval qatlami". Ikkalasi birga — ma'lumot tahlilining asosi.

3. Tez ma'lumotnoma

python
import pandas as pd

# Series (bir ustun):
s = pd.Series([10, 20, 30], index=["a", "b", "c"])
s["b"]; s[s > 15]; s.mean()

# DataFrame (jadval):
df = pd.DataFrame({"nom": [...], "narx": [...]})

# ustun:
df["nom"]                    # Series
df[["nom", "narx"]]          # DataFrame
df["yangi"] = df["narx"] * 2 # yangi ustun

# atributlar:
df.shape; df.columns; df.dtypes; df.index
len(df); df.info()

# statistika:
df["narx"].mean(); df.describe()
df["til"].value_counts()

# ko'rish:
df.head(); df.head(3); df.tail()

pandas xulosasi

Series: bir ustun (indeksli) · DataFrame: jadval (nomlangan ustun)
df["ustun"]: Series · df["yangi"]=...: qo'sh · describe/mean: statistika
head/shape/dtypes: tanish · NumPy ustida (vektorlangan)

4. Batafsil misollar

Misollarda pandas (import pandas as pd) bilan sinaladi.

Misol 1 — Series

python
"""Series: qiymat + indeks; indeks bilan o'qish; bool indeks; statistika (mean/max)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    print("=== 1. Series yaratish (indeks bilan) ===")
    s = pd.Series([100, 120, 150, 80], index=["Python", "Go", "Rust", "PHP"])
    print(s.to_string())

    print("\n=== 2. Indeks bilan o'qish ===")
    print(f"  s['Go'] = {s['Go']}")
    print(f"  s['Rust'] = {s['Rust']}")

    print("\n=== 3. Bool indeks (filtr) ===")
    qimmat = s[s > 100]
    print(f"  narx>100: {qimmat.to_dict()}")

    print("\n=== 4. Statistika ===")
    print(f"  o'rtacha: {round(s.mean(), 1)}, max: {s.max()}, min: {s.min()}")
    print(f"  eng qimmat: {s.idxmax()}")
    print("  ⭐ Series — nomlangan (indeksli) bir o'lchamli ma'lumot")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Series yaratish (indeks bilan) ===
Python    100
Go        120
Rust      150
PHP        80

=== 2. Indeks bilan o'qish ===
  s['Go'] = 120
  s['Rust'] = 150

=== 3. Bool indeks (filtr) ===
  narx>100: {'Go': 120, 'Rust': 150}

=== 4. Statistika ===
  o'rtacha: 112.5, max: 150, min: 80
  eng qimmat: Rust
  ⭐ Series — nomlangan (indeksli) bir o'lchamli ma'lumot

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — DataFrame yaratish va tanish

python
"""DataFrame: dict'dan jadval; shape/columns/dtypes (tanish); head (ko'rish)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", "Rust", "PHP", "Ruby"],
        "narx": [100, 120, 150, 80, 90],
        "til": ["uz", "en", "en", "uz", "en"],
    })

    print("=== 1. DataFrame (jadval) ===")
    print(df.to_string(index=False))

    print("\n=== 2. Atributlar (tanish) ===")
    print(f"  shape: {df.shape}")
    print(f"  columns: {list(df.columns)}")
    print(f"  dtypes: {df.dtypes.astype(str).to_dict()}")

    print("\n=== 3. head (birinchi qatorlar) ===")
    print(df.head(3).to_string(index=False))

    print("\n=== 4. Qatorlar soni va bir ustun ===")
    print(f"  qatorlar: {len(df)}")
    print(f"  nomlar: {df['nom'].tolist()}")
    print("  ⭐ DataFrame — nomlangan ustunli jadval")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. DataFrame (jadval) ===
   nom  narx til
Python   100  uz
    Go   120  en
  Rust   150  en
   PHP    80  uz
  Ruby    90  en

=== 2. Atributlar (tanish) ===
  shape: (5, 3)
  columns: ['nom', 'narx', 'til']
  dtypes: {'nom': 'str', 'narx': 'int64', 'til': 'str'}

=== 3. head (birinchi qatorlar) ===
   nom  narx til
Python   100  uz
    Go   120  en
  Rust   150  en

=== 4. Qatorlar soni va bir ustun ===
  qatorlar: 5
  nomlar: ['Python', 'Go', 'Rust', 'PHP', 'Ruby']
  ⭐ DataFrame — nomlangan ustunli jadval

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

Misol 3 — Ustun tanlash, qo'shish, statistika

python
"""ustun tanlash (Series, DataFrame); yangi ustun (vektorlangan); describe/value_counts."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", "Rust", "PHP", "Ruby"],
        "narx": [100, 120, 150, 80, 90],
        "til": ["uz", "en", "en", "uz", "en"],
    })

    print("=== 1. Ustun tanlash ===")
    print(f"  df['narx'] (Series): {df['narx'].tolist()}")
    print(f"  df[['nom','narx']] shape: {df[['nom', 'narx']].shape}")

    print("\n=== 2. Yangi ustun (vektorlangan) ===")
    df["chegirma"] = df["narx"] * 0.9
    print(f"  chegirma: {df['chegirma'].tolist()}")

    print("\n=== 3. Ustun statistika ===")
    print(f"  narx o'rtacha: {round(df['narx'].mean(), 1)}")
    print(f"  narx yig'indi: {df['narx'].sum()}")

    print("\n=== 4. value_counts (kategoriya sanog'i) ===")
    print(f"  til bo'yicha: {df['til'].value_counts().to_dict()}")
    print("  ⭐ ustun — Series (vektorlangan amal, statistika)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ustun tanlash ===
  df['narx'] (Series): [100, 120, 150, 80, 90]
  df[['nom','narx']] shape: (5, 2)

=== 2. Yangi ustun (vektorlangan) ===
  chegirma: [90.0, 108.0, 135.0, 72.0, 81.0]

=== 3. Ustun statistika ===
  narx o'rtacha: 108.0
  narx yig'indi: 540

=== 4. value_counts (kategoriya sanog'i) ===
  til bo'yicha: {'en': 3, 'uz': 2}
  ⭐ ustun — Series (vektorlangan amal, statistika)

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

Misol 4 — Amaliy: sotuv jadvali tahlili

Real misol: sotuv jadvali — yangi ustun (daromad), statistika, filtr, describe. Bu — pandas bilan jadval tahlilining namunasi.

python
"""to'liq tahlil: sotuv jadvali, yangi ustun (daromad), filtr, describe, value_counts."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "mahsulot": ["Python", "Go", "Rust", "PHP", "Ruby", "Java"],
        "narx": [100, 120, 150, 80, 90, 110],
        "sotildi": [50, 30, 20, 40, 25, 35],
        "kategoriya": ["kurs", "kurs", "kurs", "kitob", "kitob", "kurs"],
    })

    print("=== 1. Daromad ustuni (narx × sotildi) ===")
    df["daromad"] = df["narx"] * df["sotildi"]
    print(df[["mahsulot", "daromad"]].to_string(index=False))

    print("\n=== 2. Umumiy statistika ===")
    print(f"  jami daromad: {df['daromad'].sum()}")
    print(f"  o'rtacha narx: {round(df['narx'].mean(), 1)}")
    print(f"  eng ko'p sotilgan: {df.loc[df['sotildi'].idxmax(), 'mahsulot']}")

    print("\n=== 3. Filtr (qimmat mahsulotlar) ===")
    qimmat = df[df["narx"] > 100]
    print(f"  narx>100: {qimmat['mahsulot'].tolist()}")

    print("\n=== 4. Kategoriya bo'yicha ===")
    print(f"  kategoriya sanog'i: {df['kategoriya'].value_counts().to_dict()}")
    print(f"  narx describe: mean={round(df['narx'].describe()['mean'], 1)}, max={df['narx'].describe()['max']}")
    print("  ⭐ pandas — jadval tahlili (ustun, filtr, statistika)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Daromad ustuni (narx × sotildi) ===
mahsulot  daromad
  Python     5000
      Go     3600
    Rust     3000
     PHP     3200
    Ruby     2250
    Java     3850

=== 2. Umumiy statistika ===
  jami daromad: 20900
  o'rtacha narx: 108.3
  eng ko'p sotilgan: Python

=== 3. Filtr (qimmat mahsulotlar) ===
  narx>100: ['Go', 'Rust', 'Java']

=== 4. Kategoriya bo'yicha ===
  kategoriya sanog'i: {'kurs': 4, 'kitob': 2}
  narx describe: mean=108.3, max=150.0
  ⭐ pandas — jadval tahlili (ustun, filtr, statistika)

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
"pandas = NumPy" NumPy ustida (nomlangan, jadval)
"Series = ro'yxat" Indeksli (nomlangan)
"DataFrame faqat son" Aralash tur (matn + son)
"df['a'] — DataFrame" Series (bir ustun)
"Ustunda sikl kerak" Vektorlangan (Series amali)
"describe — bir ustun" Barcha son ustun
"Katta ma'lumot hammasini ko'r" head() (bir qism)
"Indeks 0 dan doim" Ixtiyoriy (sana, id)

6. Keng tarqalgan xatolar va yechimlari

1. Bir ustunni ikki qavssiz

python
df["nom", "narx"]                # ⚠️ xato
df[["nom", "narx"]]              # ✅ (ikki qavs)

2. Ustunda Python sikl

python
for i in range(len(df)): df["a"][i] *= 2   # ⚠️ sekin
df["a"] = df["a"] * 2                        # ✅ vektorlangan

3. df["yangi"] ni oldin e'lon

python
df["yangi"][0] = 5               # ⚠️ ustun yo'q
df["yangi"] = df["narx"] * 2     # ✅ (butun ustun)

4. head()siz katta ma'lumot chop etish

python
print(df)   # million qator                  # ⚠️
print(df.head())                             # ✅

5. value_counts son ustunda

python
df["narx"].value_counts()   # har narx sanog'i (kategoriya uchun)
df["narx"].describe()       # son uchun statistika  # ✅

6. SettingWithCopyWarning (view'ga yozish)

python
df[df.a > 0]["b"] = 5            # ⚠️ ogohlantirish
df.loc[df.a > 0, "b"] = 5        # ✅ (24.7 loc)

7. Indeks va pozitsiya chalkashtirish

python
s[0]   # indeks yoki pozitsiya? (24.7 loc/iloc)  # ehtiyot

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.1-dars (o'tilgan): NumPy — pandas asosi
  • 24.6-dars: O'qish/yozish — CSV, Excel
  • 24.7-dars: Tanlash/filtrlash — loc/iloc
  • 24.9-dars: Guruhlash — groupby
  • 25-qism: ML — DataFrame (model kirishi)

8. Eng yaxshi amaliyotlar

  1. Jadval ma'lumot — pandas (dict/sikl emas).

  2. Ustun ustida vektorlangan amal (sikl emas).

  3. Yangi ustun — butun ustun (df["a"] = ...).

  4. Ma'lumotni head/shape/dtypes bilan tani.

  5. describe() — tez statistika.

  6. Bir necha ustun — ikki qavs (df[[...]]).

  7. value_counts — kategoriya sanog'i.

  8. import pandas as pd (an'anaviy).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # pandas nima?
2.  # Series nima?
3.  # DataFrame nima?
4.  # df['nom'] — nima qaytaradi?
5.  # df[['a','b']] — nima?
6.  # yangi ustun qanday?
7.  # shape nima?
8.  # describe nima?
9.  # value_counts nima?
10. # head nima?
11. # dtypes nima?
12. # pandas vs NumPy?
Javoblar
  1. Jadval ma'lumot kutubxonasi (NumPy ustida)
  2. Bir o'lchamli (nomlangan indeksli)
  3. Jadval (nomlangan ustunli)
  4. Series (bir ustun)
  5. DataFrame (bir necha ustun)
  6. df["yangi"] = ...
  7. O'lcham (qator, ustun)
  8. Son ustunlar statistikasi
  9. Kategoriya sanog'i
  10. Birinchi qatorlar (default 5)
  11. Har ustun turi
  12. pandas nomlangan, jadval; NumPy son

Vazifa 2: Xatolarni tuzating

python
1.  df["nom", "narx"]             # ikki qavs

2.  for i in ...: df["a"][i] *= 2  # vektorlangan

3.  df["yangi"][0] = 5             # butun ustun

4.  print(df)  # million qator     # head

5.  df[df.a>0]["b"] = 5            # loc
Javoblar
python
1.  df[["nom", "narx"]]

2.  df["a"] = df["a"] * 2

3.  df["yangi"] = df["narx"] * 2

4.  print(df.head())

5.  df.loc[df.a > 0, "b"] = 5

Vazifa 3: Series

Bir o'lchamli:

  1. Indeks bilan yaratish
  2. Indeks bilan o'qish
  3. Bool indeks
  4. Statistika

Vazifa 4: DataFrame

Jadval:

  1. dict'dan yaratish
  2. shape, columns
  3. head
  4. Ustun tanlash

Vazifa 5: Ustun

Amal:

  1. Bir ustun (Series)
  2. Bir necha (DataFrame)
  3. Yangi ustun
  4. Statistika

Vazifa 6: Tahlil

Jadval:

  1. Yangi ustun (hisob)
  2. Filtr
  3. describe
  4. value_counts

Vazifa 7: O'ylash

pandas NumPy ustida qurilgan, lekin unga nom (ustun, indeks) qo'shadi — inson tushunadigan ma'lumot. NumPy massiv[0][2] (raqamli), pandas df.loc["2024-01", "narx"] (nomli). Nima uchun "nomlangan ma'lumot" (labeled data) tahlilni osonlashtiradi, va bu "kod o'qiluvchanligi" (readability) va xatoni kamaytirish bilan qanday bog'liq — nega df["narx"] arr[:, 2] dan yaxshiroq?

Javob

Qisqa javob: pandas ma'lumotga nom (ustun nomi, qator indeksi) qo'shadi — df["narx"] (nomli) vs arr[:, 2] (raqamli, "2-ustun nima?"). Nomlangan ma'lumot tahlilni osonlashtiradi, chunki: o'qiluvchan (df["narx"] — niyat aniq; arr[:, 2] — nima ekani noma'lum), xatoga kam moyil (ustun nomi — noto'g'ri raqam emas), o'zgarishga chidamli (ustun tartibi o'zgarsa, nom ishlaydi; raqam buziladi). Bu "kod o'zi hujjatlangan" (self-documenting) tamoyili — nom niyatni ko'rsatadi. NumPy tez son yadrosi (nomsiz — ichki), pandas nomlangan jadval qatlami (inson uchun). "Raqam o'rniga nom — o'qiluvchan va ishonchli".

1. Nomli vs raqamli

NumPy (raqamli) pandas (nomli)
arr[:, 2] df["narx"]
"2-ustun nima?" narx (aniq)
Tartib o'zgarsa buziladi Nom ishlaydi

2. Nega nom yaxshi

  • O'qiluvchan: df["narx"] — niyat ko'rinadi
  • Xatoga kam: nom (narx) — noto'g'ri raqam (2 vs 3) emas
  • Chidamli: ustun qo'shilsa/o'chirilsa, nom ishlaydi

3. Self-documenting kod

Nom — hujjat (izoh kerak emas). df["daromad"] = df["narx"] * df["soni"] — o'zi tushunarli. arr[:, 4] = arr[:, 2] * arr[:, 3] — izoh kerak.

4. Qachan NumPy, qachon pandas

NumPy pandas
Son yadrosi (ichki) Jadval (inson)
Bir tur, tez Nomlangan, aralash
Matritsa, ML Tahlil, hisobot

pandas ichida NumPy (tez), ustida nom (qulay).

5. Muhandislik saboqlari

  1. Nom — o'qiluvchan (niyat aniq)
  2. Nom — xatoga kam moyil (raqam emas)
  3. Self-documenting (nom — hujjat)
  4. pandas: NumPy tezligi + nom qulayligi

6. Xulosa

  1. pandas nomlangan (ustun, indeks)
  2. df["narx"] — o'qiluvchan, ishonchli
  3. Raqamli indeks — xatoga moyil
  4. Nom — self-documenting kod

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda pandas Series va DataFrame'ni o'rgandik.

Eng muhim uch fikr:

  1. pandas, Series, DataFrame. pandas — Python jadval ma'lumoti kutubxonasi (NumPy ustida). Series — bir o'lchamli ma'lumot: qiymatlar + indeks (belgi — "a", "b" yoki 0, 1, 2); har element nomlangan (s["b"] — indeks bilan). DataFrame — ikki o'lchamli jadval: nomlangan ustunlar (har biri Series), indeksli qatorlar (Excel varag'i / SQL jadvali kabi). Yaratish: dict (kalit → ustun), CSV 24.6-bob, baza. Har ustun o'z turi (matn, son, sana). Real ma'lumot (jadval) uchun tabiiy tuzilma.

  2. Ustun bilan ishlash va statistika. Ustun tanlash: df["nom"] (bir ustun — Series), df[["nom", "narx"]] (bir necha — DataFrame, ikki qavs). Yangi ustun: df["yangi"] = df["narx"] * 0.9 (vektorlangan — butun ustun). Atributlar: .shape, .columns, .index, .dtypes, .info() — ma'lumotni tanish (birinchi qadam). Statistika: .mean()/.sum()/.max(), .describe() (barcha son ustun — count, mean, std, min, max), .value_counts() (kategoriya sanog'i). Ko'rish: head(n), tail(n), sample(n).

  3. pandas — NumPy ustida (nomlangan qatlam). pandas NumPy ustida: har ustun (Series) ichida NumPy massiv (.values) — shuning uchun vektorlangan (tez, siklsiz). Farq: pandas nomlangan (ustun, indeks — inson uchun; df["narx"] vs arr[:, 2]), aralash tur (jadval), ma'lumot vositalari (CSV, guruhlash). Nomlangan ma'lumot — o'qiluvchan (niyat aniq), xatoga kam moyil (nom, raqam emas), self-documenting. "NumPy — son yadrosi, pandas — jadval qatlami". Ma'lumot tahlilining ish oti.

Keyingi darsda pandas: o'qish va yozish ni o'rganamiz: CSV, Excel, JSON fayllardan ma'lumot o'qish va saqlash — real ma'lumot bilan ishlashning birinchi qadami.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
24.5-dars: pandas — Series va DataFrame — IlmHamroh