Data Science va sun'iy intellekt/Pandas10/14-dars16 daqiqa

Mundarija (22)

3.10-dars: Saralash va tartiblash

3-QISM — PANDAS · 10-dars

1. Kirish va motivatsiya

Ma'lumotni tartiblash — tahlil va taqdimotning muhim qismi. "Eng ko'p sotgan 10 mahsulot", "yosh bo'yicha kattadan kichikka", "avval shahar, keyin ism bo'yicha". Bu — saralash (sort_values) va reyting (nlargest/nsmallest). Tartiblangan ma'lumot ma'noni tez ko'rsatadi (eng katta/kichik darrov ko'rinadi), taqdimot chiroyli (reyting), va ba'zi amallar tartibga tayanadi (vaqt qatori). Nega muhim? (1) Reyting — eng yaxshi/yomon topish; (2) Taqdimot — tartibli natija (hisobot, grafik); (3) Tahlil — tartib bo'yicha naqsh (trend). Bu dars saralashni o'rgatadi — ma'lumotni tartibga solish.

Saralash — ma'lumotni tartiblash: sort_values (ustun bo'yicha — ascending= o'sish/kamayish), ko'p ustun (by=[...] — avval biri, keyin ikkinchi), sort_index (indeks bo'yicha), nlargest/nsmallest (eng katta/kichik N — reyting), rank (o'rin — reyting raqami), NaN (na_position — oxirga/boshga). Foydalanish: reyting, taqdimot, tahlil. Bu 3.8 (groupby natija), 2.8 (argmax) bilan bog'liq. sort_values — tartiblash. nlargest — top N. Reyting.

Real vaziyat. Data Scientist mahsulot savdosi bilan ishlar edi. Reyting kerak edi: eng ko'p sotgan 10 mahsulot — df.nlargest(10, "savdo") (top 10); saralash — df.sort_values("savdo", ascending=False) (kattadan kichikka); ko'p ustun — df.sort_values(["shahar", "savdo"], ascending=[True, False]) (avval shahar A-Z, keyin savdo kattadan); eng kichik — df.nsmallest(5, "narx") (arzon 5). Tartiblangan ma'lumot darrov ma'no berdi (eng ko'p sotilgan — birinchi qator; reyting — taqdimot). Saralash ma'lumotni tartibga soldi (reyting, taqdimot, tahlil). sort_values/nlargest — Data Science tartibga solish.

Bu darsda saralashni o'rganamiz.

Bu darsda:

sort_values (ustun bo'yicha)
nlargest/nsmallest (top N)
Ko'p ustun bo'yicha
sort_index va rank
NaN saralashda
Saralash amaliyoti
Saralash tuzoqlari
Amaliy: saralash modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. sort_values (ustun bo'yicha)

Ustun qiymati bo'yicha:

python

import pandas as pd

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

# sort_values — ustun bo'yicha
df.sort_values("yosh")                    # o'sish (kichikdan)
df.sort_values("yosh", ascending=False)   # kamayish (kattadan)

# natijani saqlash (yangi DataFrame)
df = df.sort_values("yosh")

sort_values (ustun bo'yicha) — ustun qiymati bo'yicha tartiblash: df.sort_values("yosh") (o'sish — kichikdan kattaga, standart), ascending=False (kamayish — kattadan kichikka). Sabab: ma'lumotni tartiblash (yosh bo'yicha, savdo bo'yicha — reyting, taqdimot); sort_values ustun qiymati bo'yicha qatorlarni qayta tartiblaydi. ascending=True (o'sish — standart), False (kamayish). Yangi DataFrame (natija saqla — df = df.sort_values(...)). Indeks saqlanadi (qayta tartiblangan — reset_index kerak bo'lsa). sort_values — ustun bo'yicha (o'sish/kamayish). Tartiblash. Reyting.

2.2. nlargest/nsmallest (top N)

Eng katta/kichik N:

python

df = pd.DataFrame({"mahsulot": ["A", "B", "C", "D"], "savdo": [100, 300, 50, 200]})

# nlargest — eng katta N (reyting)
df.nlargest(2, "savdo")       # eng ko'p 2 (B, D)

# nsmallest — eng kichik N
df.nsmallest(2, "savdo")      # eng kam 2 (C, A)

# teng: sort_values(ascending=False).head(2)

nlargest/nsmallest (top N) — eng katta/kichik N: df.nlargest(2, "savdo") (eng katta 2 — reyting), df.nsmallest(2, "savdo") (eng kichik 2). Sabab: ko'pincha top N kerak (eng ko'p sotgan 10, eng arzon 5 — reyting); nlargest(N, "ustun") to'g'ridan (saralab + N olish — bir amalda, tez). sort_values(ascending=False).head(N) bilan teng, lekin nlargest qisqa/tez (faqat N ni topadi). nlargest (eng katta), nsmallest (eng kichik). Reyting uchun eng qulay. nlargest/nsmallest — top N (reyting). Qisqa. Tez.

2.3. Ko'p ustun bo'yicha

Bir nechta ustun:

python

df = pd.DataFrame({
    "shahar": ["T", "S", "T", "S"],
    "savdo": [100, 200, 150, 120],
})

# ko'p ustun (by=[...])
df.sort_values(["shahar", "savdo"])
# avval shahar (A-Z), keyin savdo (o'sish)

# har ustunga alohida yo'nalish
df.sort_values(["shahar", "savdo"], ascending=[True, False])
# shahar o'sish, savdo kamayish

Ko'p ustun bo'yicha — bir nechta ustun: df.sort_values(["shahar", "savdo"]) (avval shahar, keyin savdo — birinchi ustun asosiy, ikkinchi ichida), ascending=[True, False] (har ustunga alohida yo'nalish — shahar o'sish, savdo kamayish). Sabab: ba'zan ko'p darajali tartib (avval shahar bo'yicha guruhla, har shaharda savdo bo'yicha — batafsil reyting); by=[...] (ro'yxat — tartib muhim: birinchi asosiy). ascending=[...] (har ustunga — o'sish/kamayish alohida). Ko'p ustun — sort_values([...]) (avval biri, keyin ikkinchi). Ko'p daraja. Yo'nalish.

2.4. sort_index va rank

Indeks va o'rin:

python

df = pd.DataFrame({"yosh": [30, 25, 35]}, index=["c", "a", "b"])

# sort_index — indeks bo'yicha
df.sort_index()               # a, b, c (indeks tartibi)

# rank — o'rin (reyting raqami)
df["orin"] = df["yosh"].rank()             # o'sish o'rni
df["orin"] = df["yosh"].rank(ascending=False)  # kamayish (1 — eng katta)

sort_index va rank — indeks va o'rin: sort_index (indeks bo'yicha — df.sort_index(), indeks tartibi; vaqt qatori — sana bo'yicha), rank (o'rin — reyting raqami; df["yosh"].rank() — har qiymat o'rni, o'sish; ascending=False — 1 eng katta). Sabab: sort_index — indeks bo'yicha (saralashdan keyin tiklash, sana tartibi); rank — o'rin raqami (kim nechanchi — reyting; teng qiymat — o'rtacha o'rin). sort_values (qiymat — qatorlarni tartiblaydi), rank (o'rin — raqam beradi, tartiblamaydi). sort_index/rank — indeks (sort_index), o'rin (rank). Indeks. Reyting raqami.

2.5. NaN saralashda

NaN saralashda — NaN qayerga: sort_values — NaN oxirga (standart — na_position="last"; qiymatlar oldin, NaN oxirda), na_position="first" (boshga). Sabab: NaN tartiblab bo'lmaydi (yo'q qiymat — katta/kichik emas); Pandas NaN'ni oxirga qo'yadi (standart — qiymatlar ko'rinadi, NaN pastda). nlargest/nsmallest — NaN o'tkazib yuboradi (top N — faqat qiymatlar). Bu NaN xatti-harakati (3.7 — maxsus). na_position (oxirga/boshga). NaN saralashda — oxirga (standart), na_position. Maxsus. O'tkaziladi.

2.6. Saralash amaliyoti

Saralash amaliyoti: sort_values (ustun — ascending); nlargest/nsmallest (top N — reyting); ko'p ustun (by=[...] — avval biri); sort_index (indeks — vaqt qatori); rank (o'rin — reyting raqami); natija saqlash (df = df.sort_values(...)); reset_index (saralashdan keyin indeks — 3.4); NaN (na_position — oxirga). Tuzoqlar: natija saqlamaslik (yangi — asl o'zgarmaydi), indeks tarqoq (saralashdan keyin — reset_index), ascending unutish (standart o'sish), ko'p ustun tartibi (birinchi asosiy). Amaliyot — sort_values, nlargest, ko'p ustun, rank. Tartiblash. Reyting.

2.7. Saralash tuzoqlari

Saralash asosiy tuzoqlari: natija saqlamaslik (df.sort_values("a") — yangi DataFrame, asl o'zgarmaydi; df = df.sort_values(...) yoki inplace=True); indeks tarqoq (saralashdan keyin indeks saqlanadi (qayta tartiblangan — 2, 0, 1); .iloc[0] (birinchi — pozitsiya), .loc[0] (nom); reset_index(drop=True) kerak bo'lsa — 3.4); ascending unutish (standart o'sish (kichikdan); kattadan kerak bo'lsa ascending=False); ko'p ustun tartibi (sort_values(["a", "b"]) — a asosiy (avval a, keyin b ichida); tartib muhim — ["b", "a"] boshqa); nlargest teng qiymat (teng bo'lsa — birinchi uchragani; barobar reyting keep=); matn saralash (matn — alifbo (A-Z; katta harf oldin — ASCII; key=str.lower bir xil)); rank teng (teng qiymat — o'rtacha o'rin (2.5, 2.5); method= o'zgartirish). Sabab: saralash natija/indeks/tartib nozik (saqlash, indeks, ascending — jim xato yoki chalkash). Yechim: natija saqla, reset_index, ascending, tartib. Tuzoqlar — natija, indeks, ascending, ko'p ustun.

2.8. Saralash — ma'lumotni tartibga solish

Saralash asosiy g'oyasi — ma'lumotni tartibga solish: ma'lumotni tartiblash (yosh, savdo bo'yicha — o'sish/kamayish); tartiblangan ma'lumot ma'noni tez ko'rsatadi (eng katta/kichik darrov; reyting; trend). sort_values (ustun bo'yicha — ascending; ko'p ustun [...]), nlargest/nsmallest (top N — reyting, eng qulay), sort_index (indeks — vaqt qatori), rank (o'rin — reyting raqami). Data Science'da doim (reyting — eng yaxshi/yomon; taqdimot — tartibli hisobot/grafik; tahlil — trend, naqsh; guruh natijasi — reyting 3.8). Bu 3.8 (groupby — natija saralash) va 2.8 (argmax — eng katta) davomi. Saralash — ma'lumotni tartibga solish (sort_values, nlargest). Reyting. Taqdimot. Ma'no.

3. Tez ma'lumotnoma

python

import pandas as pd

# sort_values (ustun bo'yicha):
df.sort_values("yosh")                    # o'sish (standart)
df.sort_values("yosh", ascending=False)   # kamayish

# KO'P USTUN (avval biri, keyin ikkinchi):
df.sort_values(["shahar", "savdo"])
df.sort_values(["shahar", "savdo"], ascending=[True, False])

# nlargest/nsmallest (top N — reyting):
df.nlargest(10, "savdo")      # eng ko'p 10
df.nsmallest(5, "narx")       # eng arzon 5

# sort_index / rank:
df.sort_index()               # indeks bo'yicha (vaqt qatori)
df["orin"] = df["yosh"].rank(ascending=False)  # o'rin (1 eng katta)

# NaN:
df.sort_values("a", na_position="first")   # NaN boshga

QOIDA: natijani saqla · reset_index (indeks) · nlargest reyting · ascending

Saralash xulosasi

Saralash — ma'lumotni tartibga solish (reyting, taqdimot, ma'no)
sort_values — ustun bo'yicha (ascending o'sish/kamayish)
nlargest/nsmallest — top N (reyting, eng qulay)
Ko'p ustun — sort_values([...]) (avval biri, keyin ikkinchi)
sort_index (indeks) · rank (o'rin raqami) · NaN oxirga

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — sort_values

python

"""sort_values (real pandas)."""

import pandas as pd


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

    print("=== 1. O'sish (standart) ===")
    print(f"  {list(df.sort_values('yosh')['ism'])}")

    print("\n=== 2. Kamayish ===")
    print(f"  {list(df.sort_values('yosh', ascending=False)['ism'])}")

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

    print("\n=== 4. Natijani saqlash ===")
    saralangan = df.sort_values("yosh")
    print(f"  yoshlar: {list(saralangan['yosh'])}")
    print("  ⭐ sort_values — ustun bo'yicha tartiblash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. O'sish (standart) ===
  ['Vali', 'Hasan', 'Ali', 'Guli']

=== 2. Kamayish ===
  ['Guli', 'Ali', 'Hasan', 'Vali']

=== 3. Eng yosh ===
  eng yosh: Vali

=== 4. Natijani saqlash ===
  yoshlar: [25, 28, 30, 35]
  ⭐ sort_values — ustun bo'yicha tartiblash

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — nlargest/nsmallest

python

"""nlargest/nsmallest: top N (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "mahsulot": ["A", "B", "C", "D", "E"],
        "savdo": [100, 300, 50, 200, 150],
    })

    print("=== 1. Eng ko'p 2 (nlargest) ===")
    top = df.nlargest(2, "savdo")
    print(f"  {list(top['mahsulot'])} ({list(top['savdo'])})")

    print("\n=== 2. Eng kam 2 (nsmallest) ===")
    past = df.nsmallest(2, "savdo")
    print(f"  {list(past['mahsulot'])} ({list(past['savdo'])})")

    print("\n=== 3. Teng: sort + head ===")
    teng = df.sort_values("savdo", ascending=False).head(2)
    print(f"  bir xil: {list(teng['mahsulot']) == list(top['mahsulot'])}")

    print("\n=== 4. Reyting ===")
    print(f"  eng ko'p sotgan: {df.nlargest(1, 'savdo').iloc[0]['mahsulot']}")
    print("  ⭐ nlargest — top N (reyting)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Eng ko'p 2 (nlargest) ===
  ['B', 'D'] ([300, 200])

=== 2. Eng kam 2 (nsmallest) ===
  ['C', 'A'] ([50, 100])

=== 3. Teng: sort + head ===
  bir xil: True

=== 4. Reyting ===
  eng ko'p sotgan: B
  ⭐ nlargest — top N (reyting)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Ko'p ustun bo'yicha

python

"""Ko'p ustun bo'yicha saralash (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "S", "T", "S"],
        "savdo": [100, 200, 150, 120],
    })

    print("=== 1. Shahar, keyin savdo ===")
    s1 = df.sort_values(["shahar", "savdo"])
    print(f"  shaharlar: {list(s1['shahar'])}")

    print("\n=== 2. Shahar o'sish, savdo kamayish ===")
    s2 = df.sort_values(["shahar", "savdo"], ascending=[True, False])
    print(f"  savdolar: {list(s2['savdo'])}")

    print("\n=== 3. Birinchi ustun asosiy ===")
    print(f"  S guruhi birinchi: {s1.iloc[0]['shahar']}")

    print("\n=== 4. Tushuntirish ===")
    print("  avval shahar (A-Z), keyin savdo (ichida)")
    print("  ⭐ Ko'p ustun — avval biri, keyin ikkinchi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Shahar, keyin savdo ===
  shaharlar: ['S', 'S', 'T', 'T']

=== 2. Shahar o'sish, savdo kamayish ===
  savdolar: [200, 120, 150, 100]

=== 3. Birinchi ustun asosiy ===
  S guruhi birinchi: S

=== 4. Tushuntirish ===
  avval shahar (A-Z), keyin savdo (ichida)
  ⭐ Ko'p ustun — avval biri, keyin ikkinchi

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — rank va sort_index

python

"""rank va sort_index (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "ball": [85, 92, 78],
    })

    print("=== 1. rank (o'rin) ===")
    df["orin"] = df["ball"].rank(ascending=False).astype(int)
    print(f"  o'rinlar: {list(df['orin'])} (1 — eng katta ball)")

    print("\n=== 2. Reyting bo'yicha ===")
    reyting = df.sort_values("orin")
    print(f"  1-o'rin: {reyting.iloc[0]['ism']}")

    print("\n=== 3. sort_index ===")
    d2 = pd.DataFrame({"x": [1, 2, 3]}, index=["c", "a", "b"])
    print(f"  indeks tartibi: {list(d2.sort_index().index)}")

    print("\n=== 4. Tushuntirish ===")
    print("  rank — o'rin raqami · sort_index — indeks bo'yicha")
    print("  ⭐ rank (o'rin), sort_index (indeks)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. rank (o'rin) ===
  o'rinlar: [2, 1, 3] (1 — eng katta ball)

=== 2. Reyting bo'yicha ===
  1-o'rin: Vali

=== 3. sort_index ===
  indeks tartibi: ['a', 'b', 'c']

=== 4. Tushuntirish ===
  rank — o'rin raqami · sort_index — indeks bo'yicha
  ⭐ rank (o'rin), sort_index (indeks)

Nima ko'rsatdi: 2.4-bo'lim.

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

Noto'g'ri fikr	To'g'risi
"sort_values asl o'zgartiradi"	Yangi (natijani saqla)
"ascending standart kamayish"	O'sish (False — kamayish)
"nlargest = sort"	Qisqa/tez (top N)
"ko'p ustun tartibsiz"	Birinchi asosiy
"saralash indeks tiklaydi"	Saqlanadi (reset_index)
"NaN saralanadi"	Oxirga (na_position)
"rank tartiblab beradi"	O'rin raqami (tartiblamaydi)
"sort_index = sort_values"	Indeks vs qiymat

6. Keng tarqalgan xatolar va yechimlari

1. Natijani saqlamaslik

python

df.sort_values("yosh")   # asl o'zgarmaydi                   # ⚠️
df = df.sort_values("yosh")   # saqla                         # ✅

2. ascending

python

df.sort_values("savdo")   # o'sish (eng kam birinchi)        # ⚠️
df.sort_values("savdo", ascending=False)   # eng ko'p         # ✅

3. Indeks tarqoq

python

s = df.sort_values("a"); s.loc[0]   # indeks tarqoq          # ⚠️
s = df.sort_values("a").reset_index(drop=True)   # tiklash    # ✅

4. Ko'p ustun tartibi

python

df.sort_values(["b", "a"])   # b asosiy (kutilmagan)         # ⚠️
df.sort_values(["a", "b"])   # a asosiy                       # ✅

5. nlargest o'rniga sort

python

df.sort_values("a", ascending=False).head(10)   # uzun       # ⚠️
df.nlargest(10, "a")   # qisqa/tez                            # ✅

6. NaN joyi

python

df.sort_values("a")   # NaN oxirga (kutilmasligi mumkin)     # ⚠️
df.sort_values("a", na_position="first")   # boshga           # ✅

7. Matn registri

python

df.sort_values("ism")   # katta harf oldin (ASCII)           # ⚠️
df.sort_values("ism", key=lambda s: s.str.lower())   # bir xil # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

2.8-dars (o'tilgan): argmax (eng katta)
3.8-dars (o'tilgan): groupby (natija saralash)
3.12-dars: Vaqt qatori (sort_index — sana)
5-qism: Vizualizatsiya (saralangan — grafik)
6-qism: Tozalash (tartibli ko'rish)

8. Eng yaxshi amaliyotlar

sort_values — ustun bo'yicha (natijani saqla).
ascending=False — kamayish (kattadan).
nlargest/nsmallest — top N (reyting).
Ko'p ustun — [...] (birinchi asosiy).
reset_index — saralashdan keyin.
rank — o'rin raqami (reyting).
na_position — NaN joyi.
Saralash — ma'lumotni tartibga solish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # sort_values nima?
2.  # ascending standart?
3.  # asl o'zgaradimi?
4.  # nlargest nima?
5.  # nlargest vs sort?
6.  # ko'p ustun tartibi?
7.  # sort_index nima?
8.  # rank nima?
9.  # NaN qayerga?
10. # saralash indeks?
11. # matn saralash?
12. # nega saralash muhim?

Javoblar

Ustun bo'yicha tartiblash
O'sish (kichikdan)
Yo'q (yangi)
Eng katta N (top)
nlargest qisqa/tez
Birinchi asosiy
Indeks bo'yicha
O'rin raqami
Oxirga (na_position)
Saqlanadi (reset_index)
Alifbo (registr — ASCII)
Reyting, taqdimot, ma'no

Vazifa 2: Xatolarni tuzating

python

1.  df.sort_values("yosh")   # asl saqlansin

2.  df.sort_values("savdo")   # eng ko'p birinchi

3.  s.loc[0]   # saralashdan keyin

4.  df.sort_values("a", ascending=False).head(10)

5.  df.sort_values(["b", "a"])   # a asosiy

Javoblar

python

1.  df = df.sort_values("yosh")

2.  ascending=False

3.  reset_index(drop=True)

4.  df.nlargest(10, "a")

5.  df.sort_values(["a", "b"])

Vazifa 3: sort_values

Modellang:

Ustun
O'sish
Kamayish
Natija

Vazifa 4: nlargest

Modellang:

Top N
nsmallest
Reyting
Tez

Vazifa 5: Ko'p ustun

Modellang:

Ro'yxat
Birinchi asosiy
Yo'nalish
Ichida

Vazifa 6: rank

Modellang:

O'rin
Reyting raqami
sort_index
Indeks

Vazifa 7: O'ylash

nlargest(10, "savdo") va sort_values("savdo", ascending=False).head(10) bir xil natija beradi, lekin nlargest tezroq. Nima uchun "faqat eng katta N ni topish" butun ma'lumotni saralashdan tezroq bo'lishi mumkin, va bu qanday qilib "kerakli ishni qilish, ortiqchasini qilmaslik" degan samaradorlik tamoyilini ko'rsatadi?

Javob

Qisqa javob: nlargest(10) butun saralashdan tezroq, chunki: (1) saralash — butun — sort_values barcha elementni tartiblaydi (million element — million tartiblash; keyin 10 olinadi — 999990 tartiblash behuda); (2) nlargest — faqat N — nlargest(10) faqat eng katta 10 ni topadi (butun tartiblamaydi — 10 tani kuzatadi, qolgani bilan taqqoslaydi); algoritm kam ish (N kichik — 10; million'dan 10 — tez); (3) murakkablik — saralash O(n log n) (butun); nlargest O(n log N) (N kichik — deyarli O(n); N=10 — million uchun ancha tez). "Kerakli ishni qilish, ortiqchani qilmaslik": (a) maqsad — faqat top 10 kerak (butun tartib kerak emas); nlargest maqsadga mos (10 ni topadi — ortiqcha yo'q); sort ortiqcha (butun tartiblab, 10 olinadi — 999990 behuda); (b) samaradorlik — kerakli ish (10 top) + ortiqcha yo'q (butun tartib) = tez; (c) umumiy naqsh — "faqat keraklini hisobla" (butun emas — kerakli qism); dasturlashda keng (kerakli — tez; ortiqcha — sekin). "Nega samaradorlik tamoyili": resurslar cheklangan (vaqt — 2.12); ortiqcha ish behuda (butun tartiblash — 10 uchun; isrof); kerakli ish yetadi (10 top — maqsad); "faqat kerakli" tamoyili (view — nusxa yo'q 2.4; broadcasting — jismonan yo'q 2.6; nlargest — butun tartib yo'q) — NumPy/Pandas umumiy naqsh (kerak bo'lmaganda ishlama). Saboqlar: saralash butun (ortiqcha — 10 uchun); nlargest faqat N (kerakli — tez); murakkablik (O(n log N) < O(n log n)); "kerakli ish, ortiqcha yo'q" (samaradorlik — 2.12). To'g'ri: top N — nlargest (kerakli); butun tartib kerak bo'lsa — sort_values. Muvozanat: aniqlik (natija bir xil) + tezlik (nlargest — kam ish) — nlargest afzal (top N uchun). Bu 2.12 (tezlik) davomi (kerakli ish — tez; ortiqcha — sekin); "kerak bo'lmaganda ishlama" (view, broadcasting, nlargest — NumPy/Pandas falsafa). To'g'ri vosita — maqsadga (top N — nlargest; butun — sort).

1. Nega nlargest tezroq

Saralash butun (million tartiblash — 10 uchun behuda)
nlargest faqat N (10 kuzatadi — kam ish)
Murakkablik (O(n log N) < O(n log n))

2. "Kerakli ish, ortiqcha yo'q"

Maqsad top 10 (butun tartib kerak emas)
nlargest maqsadga mos (ortiqcha yo'q)
sort ortiqcha (999990 behuda)

3. Samaradorlik tamoyili

Resurslar cheklangan (vaqt)
Ortiqcha behuda (butun tartib)
Kerakli yetadi (top N)

4. Umumiy naqsh

Mexanizm	Kerakli ish
View (2.4)	Nusxa yo'q
Broadcasting (2.6)	Jismonan yo'q
nlargest	Butun tartib yo'q

5. Saboqlar

Saralash butun (ortiqcha)
nlargest faqat N (kerakli — tez)
Murakkablik kam (O(n log N))
"Kerakli ish" (samaradorlik)

6. Xulosa

nlargest tezroq (faqat N — kam ish)
Saralash ortiqcha (butun — 10 uchun)
"Kerakli ish, ortiqcha yo'q" (tamoyil)
Maqsadga mos vosita (top N — nlargest)

Nimani mustahkamlaydi: 2.2, 2.6-bo'limlar.

Xulosa

Bu darsda saralashni o'rgandik.

Eng muhim uch fikr:

sort_values va top N. sort_values — ustun qiymati bo'yicha tartiblash: df.sort_values("yosh") (o'sish — standart), ascending=False (kamayish); yangi DataFrame (natija saqla). nlargest/nsmallest — top N (eng katta/kichik N — reyting; df.nlargest(10, "savdo") — eng ko'p 10); sort_values(...).head(N) bilan teng, lekin qisqa/tez (faqat N topadi).
Ko'p ustun va rank. Ko'p ustun — df.sort_values(["shahar", "savdo"]) (avval shahar asosiy, keyin savdo ichida), ascending=[True, False] (har ustunga alohida yo'nalish). sort_index (indeks bo'yicha — vaqt qatori, sana), rank (o'rin — reyting raqami; teng qiymat — o'rtacha o'rin).
Tartibga solish. NaN saralashda — oxirga (standart na_position="last"; qiymatlar oldin). Saralash — ma'lumotni tartibga solish (yosh/savdo bo'yicha — ma'noni tez ko'rsatadi: eng katta darrov, reyting, trend); Data Science'da doim (reyting — eng yaxshi/yomon; taqdimot — hisobot/grafik; guruh natija — 3.8). nlargest samarali (faqat N — butun tartib emas; "kerakli ish, ortiqcha yo'q" — 2.12). Tuzoqlar: natija saqlamaslik, indeks tarqoq (reset_index), ascending (standart o'sish), ko'p ustun tartibi (birinchi asosiy).

Keyingi darsda apply va transformatsiyani chuqurroq o'rganamiz: DataFrame'ga funksiya qo'llash, transform, applymap — ma'lumotni o'zgartirishning kuchli usullari.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!