2.4-dars: Indekslash va slicing

2-QISM — NUMPY · 4-dars

1. Kirish va motivatsiya

Massivni yaratdik va tushundik — endi undan ma'lumot olishni o'rganamiz. Ko'pincha butun massiv emas, uning bir qismi kerak: bitta element, bir qator, bir ustun, yoki oraliq. Bu — indekslash (bitta elementga kirish) va slicing (qism massiv olish). Nega muhim? Data Science'da doim ma'lumotni kesib ishlaysiz: birinchi 100 qator, faqat 3-ustun, oxirgi element. NumPy indekslash Python ro'yxatidan kuchliroq: 2D'da a[1, 2] (qator 1, ustun 2 — bir vaqtda), butun ustun a[:, 0], oraliq a[1:3, :]. Bundan tashqari muhim tuzoq: slice view (ko'rinish) qaytaradi — nusxa emas; o'zgartirsangiz asl ham o'zgaradi. Bu dars indekslash va slicingni chuqur o'rgatadi — ma'lumotni aniq kesish.

Indekslash va slicing — massivdan ma'lumot olish: indekslash (bitta element — a[0], 2D a[1, 2] qator×ustun), slicing (qism massiv — a[1:3], oraliq start:stop:step), qator/ustun (2D — a[0] qator, a[:, 0] ustun), manfiy indeks (a[-1] oxirgi), : (butun o'lcham), view (slice — ko'rinish, nusxa emas). Foydalanish: ma'lumotni kesish, qism olish, qator/ustun. Bu 2.1 (ndarray), 2.9 (shart tanlash) bilan bog'liq. Indekslash — bitta element. Slicing — oraliq. Kesish.

Real vaziyat. Data Scientist 1000 qator × 5 ustun ma'lumotga ega edi. Faqat birinchi ustun (yosh) kerak edi — data[:, 0] (butun qator, 0-ustun) bilan oldi. Keyin birinchi 100 qator — data[:100] (slice). Bitta qiymat — data[5, 2] (5-qator, 2-ustun — bir vaqtda). Oxirgi qator — data[-1] (manfiy). So'ng tuzoqga duch keldi: qism = data[:10]; qism[0] = 999 — asl data ham o'zgardi (slice view!); .copy() bilan tuzatdi. Indekslash/slicing ma'lumotni aniq kesdi (kerakli qism). Kesish — Data Science asosi.

Bu darsda indekslash va slicingni o'rganamiz.

Bu darsda:

• Bitta element (indekslash)
• Slicing (oraliq)
• Qator va ustun (2D)
• Manfiy indeks va qadam
• View vs nusxa (tuzoq)
• Indekslash amaliyoti
• Slicing tuzoqlari
• Amaliy: kesish modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Bitta element (indekslash)

Elementga kirish:

import numpy as np

a = np.array([10, 20, 30, 40])
a[0]      # 10 (birinchi)
a[2]      # 30 (uchinchi)

# 2D — [qator, ustun] BIR vaqtda
b = np.array([[1, 2, 3], [4, 5, 6]])
b[0, 1]   # 2 (0-qator, 1-ustun)
b[1, 2]   # 6 (1-qator, 2-ustun)

Bitta element (indekslash) — elementga kirish: 1D a[0] (birinchi — 0 dan boshlanadi), a[2] (uchinchi); 2D b[qator, ustun] (bir vaqtda — b[0, 1] = 0-qator, 1-ustun). Sabab: ko'pincha bitta qiymat kerak (aniq element — yosh[5], narx[2]); NumPy 2D'da [qator, ustun] (bir kvadrat qavs — Python ro'yxatidan kuchliroq: list[0][1] emas, a[0, 1]). Indeks 0 dan (birinchi = 0). b[i, j] = i-qator, j-ustun. Bitta element — indekslash (a[0], b[i,j]). 0 dan. Aniq.

2.2. Slicing (oraliq)

Qism massiv:

a = np.array([10, 20, 30, 40, 50])

a[1:4]    # [20 30 40] (1 dan 4 gacha, 4 KIRMAYDI)
a[:3]     # [10 20 30] (boshdan 3 gacha)
a[2:]     # [30 40 50] (2 dan oxirgacha)
a[:]      # butun massiv
a[::2]    # [10 30 50] (har 2-element — qadam)

Slicing (oraliq) — qism massiv: a[start:stop] (start dan stop gacha, stop KIRMAYdI), a[:3] (boshdan 3 gacha), a[2:] (2 dan oxirgacha), a[:] (butun), a[::step] (qadam — ::2 har 2-element). Sabab: ko'pincha oraliq kerak (birinchi 100 — a[:100], o'rta qism — a[10:20]); slice start:stop:step (Python ro'yxat kabi). Muhim: stop kirmaydi (a[1:4] = indeks 1,2,3 — 4 emas). Slicing — oraliq (a[1:4]). Stop kirmaydi. Qism.

2.3. Qator va ustun (2D)

2D'da butun qator/ustun:

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

b[0]        # [1 2 3] (0-qator — butun)
b[0, :]     # [1 2 3] (aniq: 0-qator, butun ustun)
b[:, 0]     # [1 4 7] (butun qator, 0-ustun) ← USTUN
b[:, 1]     # [2 5 8] (1-ustun)
b[0:2, 1:3] # [[2 3] [5 6]] (0-1 qator, 1-2 ustun)

Qator va ustun (2D) — butun qator/ustun: b[0] yoki b[0, :] (0-qator — butun); b[:, 0] (butun qator, 0-ustun ← ustun olish); b[0:2, 1:3] (qator oraliq × ustun oraliq — kichik blok). Sabab: Data Science'da tez-tez butun ustun kerak (bir xususiyat — yosh ustuni; b[:, 0]) yoki qator (bir namuna — b[0]); : (butun o'lcham — "hammasi"). b[:, j] = j-ustun (butun qator), b[i, :] = i-qator. Blok: b[i1:i2, j1:j2]. Qator/ustun — b[0] qator, b[:, 0] ustun. : butun. Kesish.

2.4. Manfiy indeks va qadam

Oxirdan va sakrash:

a = np.array([10, 20, 30, 40, 50])

a[-1]     # 50 (oxirgi)
a[-2]     # 40 (oxiridan ikkinchi)
a[-3:]    # [30 40 50] (oxirgi 3)
a[::2]    # [10 30 50] (har 2-element)
a[::-1]   # [50 40 30 20 10] (TESKARI!)

Manfiy indeks va qadam — oxirdan va sakrash: manfiy (a[-1] oxirgi, a[-2] oxiridan 2-, a[-3:] oxirgi 3); qadam (a[::2] har 2-element, a[::-1] teskari). Sabab: oxirdan kirish qulay (oxirgi element — uzunlik bilmasdan, a[-1]); qadam — har n-element (namuna olish — a[::10]), ::-1 teskari (massivni ag'darish). Manfiy: -1 oxirgi, -2 oxiridan 2-. ::-1 teskari. Manfiy/qadam — oxirdan, sakrash. Qulay.

2.5. View vs nusxa (tuzoq)

View vs nusxa (muhim tuzoq): slice view (ko'rinish — asl massiv xotirasiga ishora, nusxa emas); sliceni o'zgartirsangiz asl ham o'zgaradi:

a = np.array([1, 2, 3, 4, 5])
qism = a[:3]          # view (ko'rinish)
qism[0] = 999         # qism o'zgardi
# a ham o'zgardi! → [999, 2, 3, 4, 5]

# YECHIM: .copy()
qism = a[:3].copy()   # mustaqil nusxa
qism[0] = 999         # a o'zgarmaydi

Sabab: NumPy tezlik/xotira uchun slice view qaytaradi (nusxa — sekin, ko'p xotira; view — tez, asl xotira); lekin kutilmagan (sliceni o'zgartirsangiz asl buziladi — jim xato). Yechim: .copy() (mustaqil nusxa — asl saqlanadi). Bu Python ro'yxat slicedan farq (ro'yxat slice — nusxa; NumPy slice — view). View — asl xotira (o'zgartirsa asl o'zgaradi), .copy() mustaqil. View vs nusxa — slice view, .copy() nusxa. Tuzoq. Ehtiyot.

2.6. Indekslash amaliyoti

Indekslash/slicing amaliyoti: [qator, ustun] (2D — bir qavs, a[i, j]); : (butun o'lcham — a[:, 0] ustun); slice (oraliq — a[start:stop], stop kirmaydi); manfiy (oxirdan — a[-1]); .copy() (mustaqil kerak bo'lsa — view tuzog'i); butun ustun (a[:, j] — xususiyat); butun qator (a[i] — namuna); ::step (qadam/teskari). Tuzoqlar: stop kiradi deb (kirmaydi), view (o'zgartirsa asl), Python a[0][1] (NumPy a[0, 1]), manfiy chalkash. Amaliyot — [i,j], :, slice, copy. Kesish.

2.7. Slicing tuzoqlari

Slicing asosiy tuzoqlari: stop kirmaydi (a[1:4] = 1,2,3 — 4 emas; eng ko'p xato); view (slice o'zgartirsa asl o'zgaradi — .copy() kerak bo'lsa); Python usuli (a[0][1] ishlaydi lekin sekin/noqulay — NumPy a[0, 1]); manfiy chalkash (a[-1] oxirgi, a[0] birinchi — aralashtirmang); bo'sh slice (a[5:3] = bo'sh — start > stop); chegaradan tashqari indeks (a[100] mavjud emas — xato, lekin slice a[:100] xato bermaydi — bor qismi); ustun chalkash (a[:, 0] ustun, a[0, :] qator — aralashtirmang). Sabab: slicing kuchli lekin nozik (stop, view, o'lcham tartibi — xato jim). Yechim: stop kirmaydi esla, .copy() kerak bo'lsa, [i, j] NumPy usuli. Tuzoqlar — stop, view, o'lcham tartibi.

2.8. Indekslash — ma'lumotni kesish

Indekslash/slicing asosiy g'oyasi — ma'lumotni kesish: butun massiv kam kerak, uning bir qismi (element, qator, ustun, oraliq) doim kerak; indekslash (bitta — a[i, j]) va slicing (oraliq — a[start:stop]) ma'lumotni aniq kesadi (kerakli qism). NumPy 2D'da [qator, ustun] (bir qavs — kuchli: ustun a[:, j], qator a[i], blok a[i1:i2, j1:j2]); : butun o'lcham. Muhim tuzoqlar: stop kirmaydi (a[1:4] = 1,2,3), slice view (o'zgartirsa asl — .copy()). Data Science'da doim kesish (birinchi 100 qator, faqat bir ustun — model uchun tayyorlash). Bu 2.1 (ndarray) davomi va 2.9 (shart tanlash — boolean indeks) ga zamin. Indekslash — ma'lumotni kesish (element, qator, ustun, oraliq). Aniq. Data Science asosi.

3. Tez ma'lumotnoma

import numpy as np
a = np.array([10, 20, 30, 40, 50])
b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# INDEKSLASH (bitta element, 0 dan):
a[0]         # 10 (birinchi)
b[1, 2]      # 6 (1-qator, 2-ustun — BIR qavs)

# SLICING (oraliq, stop KIRMAYDI):
a[1:4]       # [20 30 40] (1,2,3 — 4 emas)
a[:3]        # boshdan 3 gacha
a[2:]        # 2 dan oxirgacha

# QATOR / USTUN (2D):
b[0]         # [1 2 3] (qator)
b[:, 0]      # [1 4 7] (USTUN — : butun qator)
b[0:2, 1:3]  # blok (qator × ustun)

# MANFIY / QADAM:
a[-1]        # 50 (oxirgi)
a[::2]       # [10 30 50] (har 2-)
a[::-1]      # teskari

# VIEW TUZOG'I:
qism = a[:3]          # view (asl xotira!)
qism = a[:3].copy()   # mustaqil nusxa

QOIDA: stop kirmaydi · [i,j] bir qavs · slice view (.copy())

Indekslash xulosasi

Indekslash — ma'lumotni kesish (element, qator, ustun, oraliq)
Bitta element — a[i], b[i, j] (0 dan, bir qavs)
Slicing — oraliq a[start:stop] (stop KIRMAYDI)
Ustun — a[:, j] · qator — a[i] (: butun)
View tuzog'i — slice asl xotira (.copy() mustaqil)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Bitta element (indekslash)

"""Indekslash: bitta element (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. 1D indekslash ===")
    a = np.array([10, 20, 30, 40])
    print(f"  a[0]: {a[0]}, a[2]: {a[2]}")

    print("\n=== 2. 2D — [qator, ustun] ===")
    b = np.array([[1, 2, 3], [4, 5, 6]])
    print(f"  b[0, 1]: {b[0, 1]} (0-qator, 1-ustun)")
    print(f"  b[1, 2]: {b[1, 2]} (1-qator, 2-ustun)")

    print("\n=== 3. Bir qavs (NumPy usuli) ===")
    print(f"  b[1, 2]: {b[1, 2]} (to'g'ri)")
    print(f"  b[1][2]: {b[1][2]} (ishlaydi, lekin sekin)")

    print("\n=== 4. Tushuntirish ===")
    print("  indeks 0 dan boshlanadi")
    print("  ⭐ Bitta element — indekslash (a[i], b[i,j])")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. 1D indekslash ===
  a[0]: 10, a[2]: 30

=== 2. 2D — [qator, ustun] ===
  b[0, 1]: 2 (0-qator, 1-ustun)
  b[1, 2]: 6 (1-qator, 2-ustun)

=== 3. Bir qavs (NumPy usuli) ===
  b[1, 2]: 6 (to'g'ri)
  b[1][2]: 6 (ishlaydi, lekin sekin)

=== 4. Tushuntirish ===
  indeks 0 dan boshlanadi
  ⭐ Bitta element — indekslash (a[i], b[i,j])

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Slicing (oraliq)

"""Slicing: oraliq (real numpy)."""

import numpy as np


def main() -> None:
    a = np.array([10, 20, 30, 40, 50])

    print("=== 1. Oraliq ===")
    print(f"  a[1:4]: {a[1:4]} (1,2,3 — 4 KIRMAYDI)")

    print("\n=== 2. Boshdan / oxirgacha ===")
    print(f"  a[:3]: {a[:3]} (boshdan 3 gacha)")
    print(f"  a[2:]: {a[2:]} (2 dan oxirgacha)")

    print("\n=== 3. Qadam ===")
    print(f"  a[::2]: {a[::2]} (har 2-element)")

    print("\n=== 4. Butun ===")
    print(f"  a[:]: {a[:]} (butun massiv)")
    print("  ⭐ Slicing — oraliq (stop kirmaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Oraliq ===
  a[1:4]: [20 30 40] (1,2,3 — 4 KIRMAYDI)

=== 2. Boshdan / oxirgacha ===
  a[:3]: [10 20 30] (boshdan 3 gacha)
  a[2:]: [30 40 50] (2 dan oxirgacha)

=== 3. Qadam ===
  a[::2]: [10 30 50] (har 2-element)

=== 4. Butun ===
  a[:]: [10 20 30 40 50] (butun massiv)
  ⭐ Slicing — oraliq (stop kirmaydi)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Qator va ustun (2D)

"""Qator va ustun: 2D kesish (real numpy)."""

import numpy as np


def main() -> None:
    b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

    print("=== 1. Qator ===")
    print(f"  b[0]: {b[0]} (0-qator — butun)")

    print("\n=== 2. Ustun ===")
    print(f"  b[:, 0]: {b[:, 0]} (0-ustun — : butun qator)")
    print(f"  b[:, 1]: {b[:, 1]} (1-ustun)")

    print("\n=== 3. Blok ===")
    print(f"  b[0:2, 1:3]:\n{b[0:2, 1:3]} (0-1 qator, 1-2 ustun)")

    print("\n=== 4. Tushuntirish ===")
    print("  b[i] — qator · b[:, j] — ustun")
    print("  ⭐ Qator/ustun — : butun o'lcham")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Qator ===
  b[0]: [1 2 3] (0-qator — butun)

=== 2. Ustun ===
  b[:, 0]: [1 4 7] (0-ustun — : butun qator)
  b[:, 1]: [2 5 8] (1-ustun)

=== 3. Blok ===
  b[0:2, 1:3]:
[[2 3]
 [5 6]] (0-1 qator, 1-2 ustun)

=== 4. Tushuntirish ===
  b[i] — qator · b[:, j] — ustun
  ⭐ Qator/ustun — : butun o'lcham

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — View vs nusxa (tuzoq)

"""View vs nusxa: slice tuzog'i (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. View (tuzoq) ===")
    a = np.array([1, 2, 3, 4, 5])
    qism = a[:3]
    qism[0] = 999
    print(f"  qism o'zgardi → a ham: {a} (view!)")

    print("\n=== 2. .copy() (yechim) ===")
    a2 = np.array([1, 2, 3, 4, 5])
    qism2 = a2[:3].copy()
    qism2[0] = 999
    print(f"  qism2 o'zgardi → a2 saqlandi: {a2}")

    print("\n=== 3. Manfiy va teskari ===")
    c = np.array([10, 20, 30, 40, 50])
    print(f"  c[-1]: {c[-1]} (oxirgi)")
    print(f"  c[::-1]: {c[::-1]} (teskari)")

    print("\n=== 4. Xulosa ===")
    print("  slice — view (asl xotira) · .copy() — mustaqil")
    print("  ⭐ View tuzog'i — o'zgartirsa asl o'zgaradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. View (tuzoq) ===
  qism o'zgardi → a ham: [999   2   3   4   5] (view!)

=== 2. .copy() (yechim) ===
  qism2 o'zgardi → a2 saqlandi: [1 2 3 4 5]

=== 3. Manfiy va teskari ===
  c[-1]: 50 (oxirgi)
  c[::-1]: [50 40 30 20 10] (teskari)

=== 4. Xulosa ===
  slice — view (asl xotira) · .copy() — mustaqil
  ⭐ View tuzog'i — o'zgartirsa asl o'zgaradi

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. stop kiradi deb

a[1:4]   # [20 30 40] (4 KIRMAYDI, 1,2,3)                      # ⚠️
# stop chiqariladi (0-indeksli)                                 # ✅

2. View (asl o'zgaradi)

qism = a[:3]; qism[0] = 999   # a ham o'zgardi!                # ⚠️
qism = a[:3].copy()   # mustaqil                                # ✅

3. Python usuli 2D

b[0][1]   # ishlaydi, lekin sekin                              # ⚠️
b[0, 1]   # NumPy usuli (tez, bir qavs)                        # ✅

4. Ustun/qator chalkash

b[:, 0]   # USTUN (: butun qator)                             # ⚠️
b[0]      # qator (farqni bil)                                  # ✅

5. Manfiy chalkash

a[-1]   # oxirgi (birinchi emas!)                             # ⚠️
a[0]    # birinchi                                              # ✅

6. Chegaradan tashqari

a[100]   # xato (mavjud emas)                                 # ⚠️
a[:100]  # xato bermaydi (bor qismi)                           # ✅

7. Bo'sh slice

a[5:3]   # bo'sh (start > stop)                               # ⚠️
a[3:5]   # to'g'ri tartib                                       # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.1-dars (o'tilgan): ndarray
• 2.9-dars: Shart va tanlash (boolean indeks)
• 3-qism: Pandas (.iloc, .loc — indekslash)
• 6-qism: Tozalash (qism ma'lumot olish)
• 20-qism: ML (X, y ajratish — ustun tanlash)

8. Eng yaxshi amaliyotlar

1. [i, j] — bir qavs (NumPy usuli, tez).

2. stop kirmaydi (eslab qol).

3. : — butun o'lcham (a[:, j] ustun).

4. .copy() — mustaqil kerak bo'lsa (view tuzog'i).

5. Manfiy — oxirdan (a[-1]).

6. Ustun a[:, j], qator a[i] (farqni bil).

7. Slice — xato bermaydi (chegaradan tashqari).

8. Indekslash — ma'lumotni kesish (aniq).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # a[0] nima?
2.  # indeks nechadan?
3.  # b[1, 2] nima?
4.  # a[1:4] nechta element?
5.  # stop kiradimi?
6.  # b[:, 0] nima?
7.  # a[-1] nima?
8.  # a[::-1] nima?
9.  # slice view yoki nusxa?
10. # .copy() nima?
11. # a[0][1] va a[0,1]?
12. # a[100] va a[:100]?

Vazifa 2: Xatolarni tuzating

1.  a[1:4]   # 4 ta deb

2.  qism = a[:3]; qism[0] = 9   # asl o'zgarmaydi deb

3.  b[0][1]   # NumPy usuli

4.  b[:, 0]   # qator deb

5.  a[5:3]   # element kutish

1.  3 ta (1,2,3 — stop kirmaydi)

2.  qism = a[:3].copy()   # view tuzog'i

3.  b[0, 1]   # bir qavs

4.  b[:, 0] — ustun (b[0] — qator)

5.  a[3:5]   # start < stop

Vazifa 3: Indekslash

Modellang:

1. 1D
2. 2D
3. Bir qavs
4. 0 dan

Vazifa 4: Slicing

Modellang:

1. Oraliq
2. Stop
3. Qadam
4. Butun

Vazifa 5: Qator/ustun

Modellang:

1. Qator
2. Ustun
3. Blok
4. :

Vazifa 6: View

Modellang:

1. View
2. Asl o'zgaradi
3. .copy()
4. Mustaqil

Vazifa 7: O'ylash

NumPy slice view qaytaradi (asl xotiraga ishora), Python ro'yxat slice esa nusxa qaytaradi. Nima uchun NumPy bu farqli qarorni qildi (tezlik/xotira), va nega bu "jim tuzoq" — ya'ni yangi boshlovchi buni sezmasdan xato qilishi oson, va uni qanday oldini olish kerak?

Nimani mustahkamlaydi: 2.5, 2.7-bo'limlar.

Xulosa

Bu darsda indekslash va slicingni o'rgandik.

Eng muhim uch fikr:

1. Indekslash va slicing. Bitta element (indekslash) — 1D a[0] (0 dan), 2D b[i, j] (bir qavs — qator×ustun, b[0, 1] = 0-qator 1-ustun; NumPy usuli, Python a[0][1] dan tez). Slicing (oraliq) — a[start:stop] (stop KIRMAYdI — a[1:4] = 1,2,3), a[:3] (boshdan), a[2:] (oxirgacha), a[::step] (qadam).

2. Qator, ustun va manfiy. Qator/ustun (2D) — b[i] (qator — butun), b[:, j] (ustun — : butun qator), b[i1:i2, j1:j2] (blok); : = butun o'lcham. Manfiy/qadam — a[-1] (oxirgi), a[-3:] (oxirgi 3), a[::2] (har 2-), a[::-1] (teskari). Data Science'da butun ustun (xususiyat) yoki qator (namuna) tez-tez kerak.

3. View tuzog'i va kesish. View vs nusxa — NumPy slice view (asl xotira — nusxa emas, tezlik/xotira uchun); sliceni o'zgartirsangiz asl ham o'zgaradi (jim tuzoq — Python ro'yxat slicedan farq, kechikkan xato); yechim .copy() (mustaqil nusxa). Indekslash/slicing — ma'lumotni kesish (element, qator, ustun, oraliq — kerakli qism); Data Science'da doim kesish (birinchi 100 qator, bir ustun — model tayyorlash). Tuzoqlar: stop kirmaydi, slice view (.copy()), [i, j] NumPy usuli.

Keyingi darsda vektorlashtirilgan amallarni o'rganamiz: butun massivga bir vaqtda amal (a + b, a * 2), siklsiz — NumPy tezligi asosi.