2.3-dars: Atributlar va turlar

2-QISM — NUMPY · 3-dars

1. Kirish va motivatsiya

Massivni yaratdik — endi uni to'liq tushunish kerak. Har ndarray o'zi haqida ma'lumot beradi: qanday shakl (shape), qancha o'lcham (ndim), qanday tur (dtype), qancha element (size). Bu atributlar — massivning "pasporti". Nega muhim? Chunki Data Science'da xatolarning ko'pi shakl mos kelmasligi (ikki massivni qo'shmoqchisiz, lekin shakllari farqli) yoki noto'g'ri tur (sonlar satr sifatida o'qildi) dan kelib chiqadi. Atributlarni tekshirish — xatoni oldindan topish. Bundan tashqari, dtype (element turi) muhim: int8 kam xotira lekin kichik diapazon, float64 aniq lekin ko'p xotira. To'g'ri turni tanlash — xotira va tezlikni boshqaradi. Bu dars atributlar va turlarni chuqur o'rgatadi — massivni to'liq nazorat qilish.

Massiv atributlari va turlari — ndarray haqida ma'lumot va element turi: shape (o'lcham — qatorlar × ustunlar tuple), ndim (o'lchamlar soni — 1D/2D/3D), dtype (element turi — int64, float64, bool), size (jami element), astype (tur o'zgartirish — int → float), tur oilalari (int8/16/32/64, float32/64, bool, str). Foydalanish: massivni tushunish, xato oldini, xotira boshqaruvi. Bu 2.1 (ndarray), 2.6 (broadcasting) bilan bog'liq. Atributlar — shape, ndim, dtype, size. Tur — int/float/bool. Nazorat.

Real vaziyat. Data Scientist ikki massivni qo'shmoqchi edi, lekin xato oldi: "shapes not aligned". a.shape — (3,), b.shape — (4,) — turli shakl (qo'shib bo'lmaydi). Atributni tekshirdi (shape), muammoni topdi (bir massiv 3, boshqasi 4 element). Boshqa holatda: sonlar satr sifatida o'qilgan edi (dtype — <U5 string, int emas) — matematik amal xato. astype(int) bilan tuzatdi. Atributlar (shape, dtype) muammoni oldindan ko'rsatdi. Atribut tekshirish — xato oldini.

Bu darsda massiv atributlari va turlarini o'rganamiz.

Bu darsda:

• shape, ndim, size
• dtype (element turi)
• Tur o'zgartirish (astype)
• Tur oilalari (int, float, bool)
• Atributlar nega muhim
• Atributlar amaliyoti
• Tur tuzoqlari
• Amaliy: atributlar modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. shape, ndim, size

Massivning o'lchamlari:

import numpy as np

b = np.array([[1, 2, 3], [4, 5, 6]])

b.shape      # (2, 3) — 2 qator, 3 ustun (tuple)
b.ndim       # 2 — o'lchamlar soni
b.size       # 6 — jami elementlar (2*3)
len(b)       # 2 — birinchi o'lcham (qatorlar)

shape, ndim, size — massivning o'lchamlari: shape (o'lcham — tuple, (2, 3) = 2 qator × 3 ustun; eng muhim atribut), ndim (o'lchamlar soni — 1D/2D/3D, shape uzunligi), size (jami element — 2*3=6). Sabab: massivni tushunish uchun o'lcham kerak (nechta qator, ustun — amal to'g'ri-mi); shape eng ko'p ishlatiladi (mos kelish — element-wise, broadcasting 2.6). shape tuple (o'zgarmas), ndim = shape uzunligi, size = shape ko'paytmasi. len(b) = birinchi o'lcham (qatorlar). shape/ndim/size — o'lcham, o'lcham soni, jami. Tuple. Muhim.

2.2. dtype (element turi)

Har element qanday tur:

np.array([1, 2, 3]).dtype        # int64 (butun)
np.array([1.5, 2.5]).dtype       # float64 (kasr)
np.array([True, False]).dtype    # bool
np.array(["a", "b"]).dtype       # <U1 (string)

# aralash → keng tur
np.array([1, 2.5]).dtype         # float64 (int → float)

dtype (data type — element turi) — har element qanday tur: int64 (butun — 8 bayt), float64 (kasr — 8 bayt), bool (True/False — 1 bayt), <U (string — matn). Sabab: ndarray bir tur (2.1 — hammasi bir xil); dtype bu turni ko'rsatadi (int? float? — amal, xotira). Aralash berilsa keng turga (int + float → float — ma'lumot yo'qotmaslik); satr bilan string (["1", "2"] — matn, matematik emas). dtype muhim (noto'g'ri tur — xato: sonlar satr → yig'indi yo'q). dtype — element turi (int/float/bool). Bir tur. Muhim.

2.3. Tur o'zgartirish (astype)

Bir turdan boshqasiga:

a = np.array([1, 2, 3])          # int64

# astype — tur o'zgartirish (yangi massiv)
a.astype(np.float64)             # [1. 2. 3.] (float)
a.astype(str)                    # ['1' '2' '3'] (string)

# satr → son (o'qilganda satr bo'lsa)
np.array(["1", "2", "3"]).astype(int)   # [1 2 3]

# float → int (kasr yo'qoladi!)
np.array([1.9, 2.1]).astype(int)        # [1 2] (kesiladi)

Tur o'zgartirish (astype) — bir turdan boshqasiga: a.astype(np.float64) (int → float), astype(str) (son → satr), astype(int) (satr → son). Sabab: ma'lumot noto'g'ri turda kelishi mumkin (CSV — hammasi satr, astype(int) bilan son; model — float kerak, astype(float)); astype yangi massiv (asl o'zgarmaydi). Muhim: float → int kasrni kesadi (1.9 → 1 — yaxlitlamaydi, kesadi — ma'lumot yo'qoladi); satr → son satr son bo'lishi kerak ("abc" → xato). Ehtiyot (yo'qotish). astype — tur o'zgartirish (yangi massiv). Float→int kesadi. Ehtiyot.

2.4. Tur oilalari (int, float, bool)

Xotira va diapazon:

TUR OILALARI:
   INT: int8, int16, int32, int64 (butun)
      int8 — kichik (-128 dan 127), kam xotira
      int64 — katta diapazon, ko'p xotira (standart)
   FLOAT: float32, float64 (kasr)
      float32 — kam xotira, kam aniqlik
      float64 — ko'p xotira, aniq (standart)
   BOOL: True/False (1 bayt)
   STRING: <U (matn)

   → kichik tur (int8) kam xotira, lekin cheklangan

Tur oilalari — xotira va diapazon: int (int8/16/32/64 — butun; int8 kichik diapazon (-128..127) kam xotira, int64 katta diapazon ko'p xotira, standart), float (float32/64 — kasr; float32 kam xotira/aniqlik, float64 aniq standart), bool (True/False — 1 bayt), string (<U — matn). Sabab: turlar xotira/aniqlik savdosi (int8 — kam xotira, lekin katta son buziladi; float64 — aniq, lekin ko'p xotira); katta ma'lumotda (million qator) kichik tur xotira tejaydi (int8 vs int64 — 8x kam), lekin diapazon cheklangan (to'lib ketish — 2.7). Standart int64/float64 (xavfsiz). Tur oilalari — int/float razmerlari. Xotira vs diapazon. Savdo.

2.5. Atributlar nega muhim

Atributlar nega muhim: (1) xato oldini — shape mos kelmaslik eng ko'p xato (ikki massiv qo'shish — turli shakl; tekshir); (2) tur to'g'ri — dtype noto'g'ri (sonlar satr — matematik yo'q; tekshir/astype); (3) xotira boshqaruvi — dtype xotirani belgilaydi (katta ma'lumot — kichik tur tejaydi); (4) debug — muammo (kutilmagan natija) — atribut tekshirish (shape, dtype) sababni topadi; (5) amal to'g'ri — broadcasting/element-wise shapega bog'liq 2.6-bob. Sabab: atributlar massiv holatini ko'rsatadi (o'lcham, tur — amal to'g'ri-mi); tekshirmasa — jim xato (shakl/tur mos emas). Yaxshi Data Scientist avval shape/dtype tekshiradi (amaldan oldin). Atributlar — xato oldini, tur, xotira, debug. Tekshir. Muhim.

2.6. Atributlar amaliyoti

Atributlar amaliyoti: shape tekshir (amaldan oldin — mos kelish); dtype tekshir (tur to'g'ri — son/satr); astype (tur o'zgartirish — satr → son, int → float); kichik tur (katta ma'lumot — xotira tejaydi, lekin diapazon ehtiyot); standart tur (int64/float64 — xavfsiz); ndim (o'lcham — 1D/2D, amal mos-mi); float → int ehtiyot (kesadi — yaxlitlash kerak bo'lsa round); debug (kutilmagan natija — shape/dtype tekshir). Tuzoqlar: shape tekshirmaslik (mos emas — xato), dtype e'tiborsiz (satr — matematik yo'q), float→int (kasr yo'qoladi), kichik tur to'lib ketish (int8 — katta son buziladi). Amaliyot — shape/dtype tekshir, astype, xotira. Nazorat.

2.7. Tur tuzoqlari

Tur asosiy tuzoqlari: dtype e'tiborsizligi (CSV — hammasi satr, ["1","2"] matematik amal xato; astype(int)); float → int kesish (np.array([1.9]).astype(int) = 1, yaxlitlamaydi — kesadi; round kerak bo'lsa); int to'lib ketish (int8 diapazon -128..127, int8(100)+100 — buziladi, o'raladi; katta tur); shape mos emas (element-wise turli shakl — xato/broadcasting; tekshir); satr → son xato ("abc".astype(int) — xato; son satr bo'lishi kerak); float aniqlik (float32 — kam aniq, katta hisobda xato; float64); bool arifmetika (True=1, False=0 — bool_massiv.sum() = True soni; foydali, lekin kutilmagan bo'lishi mumkin). Sabab: tur jim ta'sir qiladi (noto'g'ri tur — xato yoki noto'g'ri natija, sezilmaydi). Yechim: dtype tekshir, astype, mos tur. Tuzoqlar — dtype, float→int, to'lib ketish.

2.8. Atributlar — massivning pasporti

Atributlar asosiy g'oyasi — massivning pasporti: har ndarray o'zi haqida ma'lumot beradi (shape — o'lcham, dtype — tur, ndim — o'lcham soni, size — jami); bu "pasport" massivni tushunish va nazorat qilish uchun (amal to'g'ri-mi, xato bor-mi). Data Science'da xatolar ko'pincha shakl mos kelmaslik yoki noto'g'ri turdan (jim xato — sezilmaydi); atributlarni tekshirish (shape, dtype) oldindan topadi (debug, xato oldini). dtype xotira/aniqlikni ham boshqaradi (kichik tur — tejash, lekin diapazon). Yaxshi Data Scientist avval atributlarni tekshiradi (amaldan oldin — pasportni ko'radi). Bu 2.1 (ndarray) davomi va butun NumPy uchun (amal shapega bog'liq — 2.6). Atributlar — massiv pasporti (shape, dtype). Nazorat, xato oldini. Tekshir.

3. Tez ma'lumotnoma

import numpy as np
b = np.array([[1, 2, 3], [4, 5, 6]])

# ATRIBUTLAR (massiv pasporti):
b.shape      # (2, 3) — o'lcham (qatorlar, ustunlar) tuple
b.ndim       # 2 — o'lchamlar soni
b.size       # 6 — jami elementlar
b.dtype      # int64 — element turi

# DTYPE (element turi):
#   int8/16/32/64 · float32/64 · bool · <U (string)
#   aralash → keng tur (int+float → float)

# TUR O'ZGARTIRISH (astype — yangi massiv):
a.astype(np.float64)         # int → float
np.array(["1","2"]).astype(int)   # satr → son
np.array([1.9]).astype(int)  # float → int (KESADI: 1)

# TUR OILALARI:
#   int8 — kam xotira, kichik diapazon (-128..127)
#   int64 — standart · float64 — aniq (standart)

QOIDA: shape/dtype tekshir (amaldan oldin) · astype · mos tur

Atributlar xulosasi

Atributlar — massivning pasporti (shape, dtype, ndim, size)
shape — o'lcham (tuple, eng muhim — mos kelish)
dtype — element turi (int/float/bool, bir tur)
astype — tur o'zgartirish (satr→son, float→int kesadi)
Tur oilalari — int/float razmerlari (xotira vs diapazon savdosi)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — shape, ndim, size

"""Atributlar: shape, ndim, size (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. 1D massiv ===")
    a = np.array([1, 2, 3, 4, 5])
    print(f"  shape: {a.shape}, ndim: {a.ndim}, size: {a.size}")

    print("\n=== 2. 2D massiv ===")
    b = np.array([[1, 2, 3], [4, 5, 6]])
    print(f"  shape: {b.shape}, ndim: {b.ndim}, size: {b.size}")

    print("\n=== 3. 3D massiv ===")
    c = np.zeros((2, 3, 4))
    print(f"  shape: {c.shape}, ndim: {c.ndim}, size: {c.size}")

    print("\n=== 4. Tushuntirish ===")
    print("  shape — o'lcham (qatorlar, ustunlar)")
    print("  ndim — o'lchamlar soni (shape uzunligi)")
    print("  size — jami element (shape ko'paytmasi)")
    print("  ⭐ Atributlar — massiv pasporti")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. 1D massiv ===
  shape: (5,), ndim: 1, size: 5

=== 2. 2D massiv ===
  shape: (2, 3), ndim: 2, size: 6

=== 3. 3D massiv ===
  shape: (2, 3, 4), ndim: 3, size: 24

=== 4. Tushuntirish ===
  shape — o'lcham (qatorlar, ustunlar)
  ndim — o'lchamlar soni (shape uzunligi)
  size — jami element (shape ko'paytmasi)
  ⭐ Atributlar — massiv pasporti

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — dtype (element turi)

"""dtype: element turi (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Turli turlar ===")
    print(f"  [1,2,3] → {np.array([1, 2, 3]).dtype}")
    print(f"  [1.5,2.5] → {np.array([1.5, 2.5]).dtype}")
    print(f"  [True,False] → {np.array([True, False]).dtype}")

    print("\n=== 2. Aralash → keng tur ===")
    print(f"  [1, 2.5] → {np.array([1, 2.5]).dtype} (int → float)")

    print("\n=== 3. Satr (matn) ===")
    s = np.array(["1", "2", "3"])
    print(f"  ['1','2','3'] → {s.dtype} (string — matematik emas)")

    print("\n=== 4. dtype belgilash ===")
    print(f"  int32: {np.array([1, 2], dtype=np.int32).dtype}")
    print("  ⭐ dtype — element turi (bir tur)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Turli turlar ===
  [1,2,3] → int64
  [1.5,2.5] → float64
  [True,False] → bool

=== 2. Aralash → keng tur ===
  [1, 2.5] → float64 (int → float)

=== 3. Satr (matn) ===
  ['1','2','3'] → <U1 (string — matematik emas)

=== 4. dtype belgilash ===
  int32: int32
  ⭐ dtype — element turi (bir tur)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — astype (tur o'zgartirish)

"""astype: tur o'zgartirish (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. int → float ===")
    a = np.array([1, 2, 3])
    print(f"  {a} ({a.dtype}) → {a.astype(np.float64)}")

    print("\n=== 2. satr → son ===")
    s = np.array(["10", "20", "30"])
    print(f"  {s} ({s.dtype}) → {s.astype(int)}")

    print("\n=== 3. float → int (KESADI) ===")
    f = np.array([1.9, 2.1, 3.7])
    print(f"  {f} → {f.astype(int)} (kasr kesildi, yaxlitlanmadi)")

    print("\n=== 4. To'g'ri yaxlitlash ===")
    print(f"  round + astype: {np.round(f).astype(int)}")
    print("  ⭐ astype — tur o'zgartirish (float→int kesadi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. int → float ===
  [1 2 3] (int64) → [1. 2. 3.]

=== 2. satr → son ===
  ['10' '20' '30'] (<U2) → [10 20 30]

=== 3. float → int (KESADI) ===
  [1.9 2.1 3.7] → [1 2 3] (kasr kesildi, yaxlitlanmadi)

=== 4. To'g'ri yaxlitlash ===
  round + astype: [2 2 4]
  ⭐ astype — tur o'zgartirish (float→int kesadi)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Tur oilalari (xotira)

"""Tur oilalari: xotira va diapazon (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Int turlari (bayt) ===")
    for tur in [np.int8, np.int16, np.int32, np.int64]:
        a = np.array([1], dtype=tur)
        print(f"  {np.dtype(tur).name}: har element {a.itemsize} bayt")

    print("\n=== 2. Float turlari ===")
    for tur in [np.float32, np.float64]:
        a = np.array([1.0], dtype=tur)
        print(f"  {np.dtype(tur).name}: {a.itemsize} bayt")

    print("\n=== 3. Xotira farqi (1M element) ===")
    print("  int8: 1 MB · int64: 8 MB (8x farq)")

    print("\n=== 4. Savdo ===")
    print("  kichik tur — kam xotira, lekin cheklangan diapazon")
    print("  ⭐ Tur oilalari — xotira vs diapazon savdosi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Int turlari (bayt) ===
  int8: har element 1 bayt
  int16: har element 2 bayt
  int32: har element 4 bayt
  int64: har element 8 bayt

=== 2. Float turlari ===
  float32: 4 bayt
  float64: 8 bayt

=== 3. Xotira farqi (1M element) ===
  int8: 1 MB · int64: 8 MB (8x farq)

=== 4. Savdo ===
  kichik tur — kam xotira, lekin cheklangan diapazon
  ⭐ Tur oilalari — xotira vs diapazon savdosi

Nima ko'rsatdi: 2.4-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. dtype tekshirmaslik

s.sum()   # s satr bo'lsa (matematik xato)                     # ⚠️
s.astype(int).sum()   # avval son                              # ✅

2. float → int (kesish)

np.array([1.9]).astype(int)   # 1 (kasr kesildi)               # ⚠️
np.round(np.array([1.9])).astype(int)   # 2 (yaxlitlash)        # ✅

3. int to'lib ketish

np.array([100], dtype=np.int8) + 100   # -56 (o'raladi!)       # ⚠️
np.array([100], dtype=np.int64) + 100   # 200                  # ✅

4. shape mos emas

np.array([1,2,3]) + np.array([1,2])   # xato (turli shakl)     # ⚠️
# shape tekshir (bir xil yoki broadcasting)                     # ✅

5. astype asl deb

a.astype(float)   # a o'zgarmaydi (yangi qaytadi)              # ⚠️
a = a.astype(float)   # natijani saqla                          # ✅

6. float32 aniqlik

# katta hisob float32 (aniqlik yo'qoladi)                      # ⚠️
# float64 (aniq — standart)                                     # ✅

7. Aralash tur kutish

np.array([1, 2.5])   # float (int emas — keng tur)            # ⚠️
# dtype tekshir (aralash → keng)                                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.1-dars (o'tilgan): ndarray
• 2.6-dars: Broadcasting (shape muhim)
• 6-qism: Tozalash (astype — tur tuzatish)
• 3-qism: Pandas (dtype — ustun turlari)
• 22-qism: Deep Learning (float32 — GPU tezligi)

8. Eng yaxshi amaliyotlar

1. shape tekshir (amaldan oldin — mos kelish).

2. dtype tekshir (tur to'g'rimi — son/satr).

3. astype (tur o'zgartirish — natijani saqla).

4. float → int ehtiyot (round kerak bo'lsa).

5. Standart tur (int64/float64 — xavfsiz).

6. Kichik tur (katta ma'lumot — xotira, diapazon ehtiyot).

7. Debug — shape/dtype tekshir.

8. Atributlar — massiv pasporti (tekshir).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # shape nima?
2.  # shape turi (son yoki tuple)?
3.  # ndim nima?
4.  # size nima?
5.  # dtype nima?
6.  # aralash tur natijasi?
7.  # astype nima?
8.  # astype asl o'zgartiradimi?
9.  # float → int?
10. # int8 diapazoni?
11. # standart tur?
12. # nega atribut muhim?

Vazifa 2: Xatolarni tuzating

1.  s.sum()   # s satr

2.  np.array([1.9]).astype(int)   # yaxlitlash

3.  int8 + 100   # to'ladi

4.  a.astype(float)   # asl o'zgaradi deb

5.  # shape tekshirmasdan qo'shish

1.  s.astype(int).sum()

2.  np.round(...).astype(int)

3.  int64 (katta diapazon)

4.  a = a.astype(float)

5.  shape tekshir (mos kelish)

Vazifa 3: Atributlar

Modellang:

1. shape
2. ndim
3. size
4. Pasport

Vazifa 4: dtype

Modellang:

1. int
2. float
3. Aralash
4. String

Vazifa 5: astype

Modellang:

1. int→float
2. satr→son
3. float→int
4. Kesish

Vazifa 6: Tur oilalari

Modellang:

1. int8
2. int64
3. Xotira
4. Diapazon

Vazifa 7: O'ylash

NumPy'da int8 kam xotira ishlatadi (1 bayt), lekin diapazoni cheklangan (-128 dan 127); int64 ko'p xotira (8 bayt), lekin katta diapazon. Nima uchun bu "xotira vs diapazon" savdosi muhandislikning umumiy naqshi (bepul narsa yo'q), va nega "har doim eng katta turni ishlatish" (int64) ham noto'g'ri, "eng kichik" ham noto'g'ri?

Nimani mustahkamlaydi: 2.4, 2.7-bo'limlar.

Xulosa

Bu darsda massiv atributlari va turlarini o'rgandik.

Eng muhim uch fikr:

1. shape, ndim, size va dtype. shape, ndim, size — massiv o'lchamlari: shape (o'lcham — tuple (2,3), eng muhim), ndim (o'lchamlar soni — 1D/2D), size (jami element); massivni tushunish uchun. dtype (element turi) — har element qanday tur: int64/float64/bool/string; ndarray bir tur, aralash → keng turga (int+float → float), satr bilan → string; noto'g'ri tur — xato (sonlar satr → matematik yo'q).

2. astype va tur oilalari. Tur o'zgartirish (astype) — bir turdan boshqasiga: astype(float) (int→float), astype(int) (satr→son); yangi massiv (asl saqlanadi); float→int kesadi (1.9→1 — yaxlitlamaydi, round kerak). Tur oilalari: int (int8/16/32/64 — int8 kam xotira/kichik diapazon, int64 standart), float (float32/64 — float64 aniq standart), bool, string; xotira/aniqlik savdosi (kichik tur tejaydi, lekin diapazon cheklangan).

3. Atributlar — pasport. Atributlar nega muhim: xato oldini (shape mos kelmaslik eng ko'p xato), tur to'g'ri (dtype — son/satr), xotira boshqaruvi (kichik tur tejaydi), debug (kutilmagan natija — shape/dtype tekshir). Atributlar — massivning pasporti (shape, dtype, ndim, size): massivni tushunish/nazorat, Data Science xatolari ko'pincha shakl/tur mos kelmasligidan (jim xato); avval shape/dtype tekshirish (amaldan oldin). Xotira vs diapazon savdosi muhandislik naqshi (bepul narsa yo'q); "har doim int64" isrof, "har doim int8" xavf — ma'lumotga mos tur (muvozanat, kontekst).

Keyingi darsda indekslash va slicingni o'rganamiz: massiv elementlariga kirish, qism massiv olish, shart bo'yicha tanlash — ma'lumotni kesish va tanlash.