Array yaratish: shakl, tur va tasodifiy sonlar

2-bob 7 kod bloki 1605 so'z

Sahna: ma'lumot qayerdan keladi

1-bobda array ni tayyor ro'yxatdan yasadik. Amalda esa array uch yo'l bilan paydo bo'ladi:

1. Mavjud ma'lumotdan — ro'yxat, fayl, rasm, jadval.
2. Bo'sh "qolip" sifatida — natijani keyin to'ldirish uchun nollar yoki birlar.
3. Tasodifiy — test ma'lumoti, simulyatsiya, modelning boshlang'ich vaznlari.

Bu bobda uchalasini ko'ramiz, va har birida array ning "pasporti" — shape, ndim, size, dtype — nimani aytishini o'rganamiz.

Array ning pasporti

1D, 2D va 3D array: har o'q bo'ylab nechta element

import numpy as np

savdo = np.array([
    [12, 15, 9, 20],
    [8, 11, 14, 17],
    [10, 13, 12, 22],
])
print("shape:", savdo.shape)
print("ndim: ", savdo.ndim)
print("size: ", savdo.size)
print("dtype:", savdo.dtype)
print("bitta element:", savdo.itemsize, "bayt; jami:", savdo.nbytes, "bayt")

shape: (3, 4)
ndim:  2
size:  12
dtype: int64
bitta element: 8 bayt; jami: 96 bayt

Bu jadvalni "3 ta filial, 4 hafta savdosi" deb tasavvur qiling. Pasport shuni aytadi:

• shape = (3, 4) — 3 qator (filiallar), 4 ustun (haftalar). Eng ko'p ishlatiladigan atribut: NumPy dagi xatolarning katta qismi shakl mos kelmasligidan chiqadi, shuning uchun shubha bo'lsa birinchi shape ni chiqaring.
• ndim = 2 — nechta o'q bor. Ro'yxat — 1, jadval — 2, rangli rasm — 3 (balandlik, kenglik, rang kanali).
• size = 12 — jami elementlar: 3 × 4.
• dtype = int64 — har element 64 bitli butun son; nbytes — butun array qancha xotira olgani.

O'q (axis) so'zini hozirdan yodlang: axis 0 — qatorlar bo'ylab (yuqoridan pastga), axis 1 — ustunlar bo'ylab (chapdan o'ngga). 5-bobda yig'indi va o'rtachani aynan shu o'qlar bo'yicha hisoblaymiz.

Qolip yasash: zeros, ones, full, eye

Ko'pincha natija uchun avval joy kerak bo'ladi, keyin uni to'ldirasiz.

print(np.zeros(4))
print(np.ones((2, 3), dtype=int))
print(np.full((2, 2), 7.5))
print(np.eye(3, dtype=int))

[0. 0. 0. 0.]
[[1 1 1]
 [1 1 1]]
[[7.5 7.5]
 [7.5 7.5]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]

zeros va ones standart holda kasr son (float64) beradi — chunki hisob-kitob natijasi ko'pincha kasr. Butun son kerak bo'lsa, dtype=int ni o'zingiz yozasiz. eye — diagonalida 1 bo'lgan "birlik matritsa": chiziqli algebrada sonlar orasidagi 1 kabi rol o'ynaydi.

Ketma-ketlik: arange va linspace

print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))
print(len(np.arange(0, 1, 0.1)), len(np.arange(1, 1.3, 0.1)))

[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]
10 4

Ikkalasi o'xshash, lekin savol boshqa:

Oxirgi qatorga qarang: arange(1, 1.3, 0.1) — "1, 1.1, 1.2" kutasiz, ya'ni 3 ta. Lekin chiqdi 4 ta. Sabab: 0.1 kompyuterda aniq saqlanmaydi, va 1 + 3 × 0.1 ozgina 1.3 dan kichik chiqib, chegaradan "o'tib ketadi". Shuning uchun qoida: butun qadam — arange, kasr oraliq — linspace.

dtype tanlash: xotira va xavf

dtype faqat "son yoki matn" emas — u sonning diapazonini ham belgilaydi. Kichik tur kam xotira oladi, lekin chegaraga yetganda indamay "aylanib" ketadi.

kichik = np.array([100, 120], dtype=np.int8)
print(kichik.dtype, kichik + kichik)
print(np.iinfo(np.int8).min, np.iinfo(np.int8).max)

narx = np.array([12_500.75, 99_999.99])
print(narx.astype(int))
print(narx.astype(np.float32).nbytes, "va", narx.nbytes, "bayt")

int8 [-56 -16]
-128 127
[12500 99999]
8 va 16 bayt

int8 faqat −128 dan 127 gacha sig'diradi. 100 + 100 = 200 — sig'maydi, va NumPy xato bermasdan −56 qaytaradi (200 − 256). Bu "overflow". Real hayotda: kichik tur tanlab xotirani tejadingiz — summalar manfiy chiqib qoldi.

astype(int) kasrni yaxlitlamaydi, kesib tashlaydi: 12 500.75 → 12 500, 99 999.99 → 99 999. Yaxlitlash kerak bo'lsa avval np.round.

float32 xotirani ikki barobar kamaytiradi — katta rasmlar va neyron tarmoqlarda shuning uchun ishlatiladi. Lekin aniqlik kamroq: pul hisobida float64 qoldiring.

Tasodifiy sonlar: yangi yo'l — default_rng

Eski darsliklarda np.random.seed(42) va np.random.randint(...) ni ko'rasiz. NumPy endi boshqa yo'lni tavsiya qiladi — generator obyekti:

rng = np.random.default_rng(42)
print(rng.integers(1, 7, size=10))
print(rng.random(3).round(3))
print(rng.normal(loc=170, scale=8, size=4).round(1))

rng_a, rng_b = np.random.default_rng(7), np.random.default_rng(7)
print((rng_a.integers(0, 100, 5) == rng_b.integers(0, 100, 5)).all())

[1 5 4 3 3 6 1 5 2 1]
[0.976 0.761 0.786]
[169.9 163.2 177.  176.2]
True

• integers(1, 7) — 1 dan 6 gacha (7 kirmaydi): o'yin kubigi.
• random(3) — 0 bilan 1 orasidagi kasr sonlar.
• normal(170, 8) — o'rtachasi 170, tarqalishi 8 bo'lgan "qo'ng'iroq" shaklidagi sonlar: odamlar bo'yi kabi.

Seed (urug') — tasodifiylikning boshlang'ich nuqtasi. Bir xil seed — har safar bir xil "tasodifiy" sonlar. Bu kerak, chunki natijani hamkasbingiz takrorlay olishi va xatoni qayta ko'ra olishi shart.

Nega default_rng yaxshiroq? Eski np.random.seed butun dastur uchun bitta umumiy holatni o'zgartiradi: kutubxonaning ichida kimdir tasodifiy son olsa, sizning ketma-ketligingiz siljiydi. Generator esa o'zingizniki — boshqa kod unga tegmaydi.

Endi "qo'ng'iroq" ni ko'z bilan ko'ramiz:

rng = np.random.default_rng(0)
boy = rng.normal(170, 8, size=5_000)
kubik = rng.integers(1, 7, size=5_000)

fig, (chap, ong) = plt.subplots(1, 2, figsize=(10, 3.4))
chap.hist(boy, bins=40, color="#1a73e8")
chap.set_title("normal(170, 8): bo'y, sm")
ong.hist(kubik, bins=np.arange(0.5, 7.5, 1), color="#b06000", rwidth=0.85)
ong.set_title("integers(1, 7): kubik")
plt.show()
print(f"bo'y: o'rtacha {boy.mean():.1f}, eng past {boy.min():.1f}, eng baland {boy.max():.1f}")
print("kubik har tomoni necha marta:", np.bincount(kubik)[1:])

bo'y: o'rtacha 170.0, eng past 138.8, eng baland 196.1
kubik har tomoni necha marta: [865 827 816 836 848 808]

Chapdagi — normal taqsimot: ko'p qiymatlar o'rtachaga yaqin, chetlarga borgan sari kamayadi. O'ngdagi — tekis (uniform) taqsimot: har tomon taxminan teng chiqqan, lekin aynan teng emas — tasodif shunday ishlaydi.

Ro'yxatdan array: nimaga e'tibor berish kerak

print(np.array([[1, 2], [3, 4]]).shape)
try:
    np.array([[1, 2], [3]])
except ValueError as xato:
    print("ValueError:", str(xato)[:60], "...")

(2, 2)
ValueError: setting an array element with a sequence. The requested arra ...

Ichki ro'yxatlar uzunligi har xil bo'lsa, "tekis" jadval chiqmaydi va hozirgi NumPy xato beradi. Eski versiyalar bunday holda jimgina object turdagi array yasardi — tez hisoblash yo'qolardi. Hozirgi xato — yaxshi xato: muammoni darhol ko'rsatadi.

Xulosa

• Pasport: shape (har o'q bo'ylab nechta), ndim (nechta o'q), size (jami), dtype (tur), nbytes (xotira).
• Qolip: zeros, ones, full, eye; zeros/ones standartda float64.
• Butun qadam — arange, kasr oraliq — linspace (arange kasr qadamda kutilmagan uzunlik berishi mumkin).
• Kichik dtype xotirani tejaydi, lekin overflow indamay noto'g'ri son beradi; astype(int) kasrni kesadi.
• Tasodifiy sonlar uchun np.random.default_rng(seed) — o'z generatoringiz, takrorlanadigan natija.

Mashqlar

1. 4 qator, 6 ustunli, hammasi 0 bo'lgan butun sonli array yasang va shape, size, nbytes ni chiqaring.
2. np.array([250, 10], dtype=np.uint8) + 10 nima beradi va nega? (uint8 — 0 dan 255 gacha.)
3. 0 dan 2π gacha 9 ta teng nuqta kerak. arange yoki linspace — qaysi biri va nega?
4. default_rng(1) bilan 1 000 marta tanga tashlang (0 yoki 1). Nechta 1 chiqdi? Seed ni o'zgartirmasdan qayta ishga tushirsangiz-chi?