Reja: NumPy nima?

NumPy tezkor ishga tushirish
Old shartlar
Python tilini biroz bilishingiz kerak. Yangilash uchun Python qoʻllanmasiga qarang.

Misollar bilan ishlash uchun sizga NumPy-ga qo'shimcha ravishda matplotlib o'rnatilgan bo'lishi kerak.

O'quvchi profili

Bu NumPy-dagi massivlarning qisqacha ko'rinishi. Bu n o'lchovliligini ko'rsatadi (

) massivlar ifodalanadi va ularni boshqarish mumkin. Xususan, agar siz n o‘lchamli massivlarga umumiy funksiyalarni qanday qo‘llashni bilmasangiz (for-looplardan foydalanmasdan) yoki n-o‘lchovli massivlar uchun o‘q va shakl xususiyatlarini tushunmoqchi bo‘lsangiz, ushbu maqola yordam berishi mumkin.

O'qishdan so'ng siz quyidagilarni bilishingiz kerak:

• 
  NumPy-da bir, ikki va n o'lchovli massivlar orasidagi farqni tushunish;
  

• 
  Ba'zi chiziqli algebra amallarini n o'lchovli massivlarga for-sikllardan foydalanmasdan qanday qo'llashni tushunish;
  

• 
  n o'lchovli massivlar uchun o'q va shakl xususiyatlarini tushunish.
  

Asoslar
NumPy ning asosiy ob'ekti bir hil ko'p o'lchovli massivdir. Bu bir xil turdagi elementlar jadvali (odatda raqamlar), manfiy bo'lmagan butun sonlar majmuasi bilan indekslanadi. NumPy-da o'lchamlar o'qlar deb ataladi.

Masalan, 3D fazodagi nuqta koordinatalari uchun massiv [1, 2, 1] bitta o'qga ega. Bu o'qda 3 ta element bor, shuning uchun biz uning uzunligi 3 ga teng deb aytamiz. Quyidagi rasmdagi misolda massiv 2 ta o'qga ega. Birinchi o'qning uzunligi 2 ga, ikkinchi o'qning uzunligi 3 ga teng.

[[1., 0., 0.],

[0., 1., 2.]]
NumPy massiv sinfi ndarray deb ataladi. U taxalluslar qatori bilan ham tanilgan. E'tibor bering, numpy.array standart Python kutubxonasi array.array sinfiga o'xshamaydi, u faqat bir o'lchovli massivlarni boshqaradi va kamroq funksionallikni taklif qiladi. Ndarray ob'ektining eng muhim atributlari quyidagilardir:

ndarray.ndim

massivning o'qlari (o'lchamlari) soni.

ndarray.shakl

massivning o'lchamlari. Bu har bir o'lchamdagi massivning o'lchamini ko'rsatadigan butun sonlar to'plami. n ta satr va m ustunli matritsa uchun shakl (n,m) bo'ladi. Shakl kortejining uzunligi shuning uchun o'qlar soni, ndim.

ndarray.size

massiv elementlarining umumiy soni. Bu shakl elementlarining mahsulotiga teng.

ndarray.dtype

massivdagi elementlarning turini tavsiflovchi ob'ekt. Standart Python turlaridan foydalanib, dtype-ni yaratish yoki belgilash mumkin. Bundan tashqari, NumPy o'z turlarini taqdim etadi. numpy.int32, numpy.int16 va numpy.float64 misollardir.

ndarray.itemsize

massivning har bir elementining baytdagi hajmi. Masalan, float64 tipidagi elementlar massivida element o'lchami 8 (=64/8) bo'lsa, kompleks32 tipidagi elementlarning o'lchami 4 (=32/8) ga ega. Bu ndarray.dtype.itemsize ga teng.

ndarray.data

massivning haqiqiy elementlarini o'z ichiga olgan bufer. Odatda, biz ushbu atributdan foydalanishimiz shart emas, chunki biz indekslash vositalaridan foydalangan holda massivdagi elementlarga kiramiz.
Misol
numpy ni np sifatida import qiling
a = np.arange(15).reshape(3, 5)
a
massiv([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
a.shakl
(3, 5)
a.ndim
2
a.dtype.name
"int64"
a.element hajmi
8
a.o'lcham
15
turi (a)

b = np.massiv([6, 7, 8])
b
massiv([6, 7, 8])
turi (b)

Massiv yaratish
Massivlarni yaratishning bir necha usullari mavjud.

Misol uchun, siz oddiy Python ro'yxatidan massiv yoki massiv funksiyasidan foydalanib qator yaratishingiz mumkin. Olingan massivning turi ketma-ketlikdagi elementlarning turidan chiqariladi.

numpy ni np sifatida import qiling

a = np.array([2, 3, 4])
a
massiv([2, 3, 4])
a.dtype
dtype('int64')
b = np.massiv([1.2, 3.5, 5.1])
b.d turi
dtype('float64')
Tez-tez uchraydigan xato argument sifatida bitta ketma-ketlikni taqdim etish o'rniga, bir nechta argumentlar bilan massivni chaqirishdan iborat.

a = np.array(1, 2, 3, 4) # NONO

Traceback (eng oxirgi qo'ng'iroq):
...
TypeError: array() 1 dan 2 tagacha pozitsion argumentni oladi, lekin 4 tasi berilgan
a = np.array([1, 2, 3, 4]) # O'NG
massiv ketma-ketliklar ketma-ketligini ikki o'lchovli massivlarga, ketma-ketliklar ketma-ketligini uch o'lchovli massivlarga va boshqalarga aylantiradi.

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

b
massiv([[1.5, 2. , 3. ],
[4. , 5. , 6. ]])
Massivning turini yaratish vaqtida ham aniq belgilash mumkin:

c = np.massiv([[1, 2], [3, 4]], dtype=kompleks)

c
massiv([[1.+0.j, 2.+0.j],
[3.+0.j, 4.+0.j]])
Ko'pincha massivning elementlari dastlab noma'lum, lekin uning hajmi ma'lum. Shunday qilib, NumPy boshlang'ich to'ldiruvchi tarkibiga ega massivlarni yaratish uchun bir nechta funktsiyalarni taklif qiladi. Bu massivlarni ko'paytirish zaruratini kamaytiradi, qimmat operatsiya.

Nollar funksiyasi nollarga to‘la massivni, birlar funksiyasi birlar bilan to‘la massivni, bo‘sh funksiya esa boshlang‘ich mazmuni tasodifiy bo‘lgan va xotira holatiga bog‘liq bo‘lgan massivni hosil qiladi. Odatiy bo'lib, yaratilgan massivning d turi float64 dir, lekin uni dtype argumenti kalit so'zi orqali ko'rsatish mumkin.

np.nollar((3, 4))
massiv([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
np.ones((2, 3, 4), dtype=np.int16)
massiv([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],

[[1, 1, 1, 1],

[1, 1, 1, 1],
[1, 1, 1, 1]]], dtype=int16)
np.empty((2, 3))
massiv([[3.73603959e-262, 6.02658058e-154, 6.55490914e-260], # farq qilishi mumkin
[5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
Raqamlar ketma-ketligini yaratish uchun NumPy Python o'rnatilgan diapazoniga o'xshash arange funksiyasini taqdim etadi, lekin massivni qaytaradi.

np.arange(10, 30, 5)

massiv([10, 15, 20, 25])
np.arange(0, 2, 0.3) # float argumentlarini qabul qiladi
massiv([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
Arange suzuvchi nuqta argumentlari bilan foydalanilganda, chekli suzuvchi nuqta aniqligi tufayli, odatda, olingan elementlar sonini taxmin qilish mumkin emas. Shu sababli, odatda qadam o'rniga, biz kerakli elementlar sonini argument sifatida qabul qiladigan linspace funktsiyasidan foydalanish yaxshiroqdir:

numpy import pi dan

np.linspace(0, 2, 9) # 9 0 dan 2 gacha raqamlar
massiv([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
x = np.linspace(0, 2 * pi, 100) # ko'p nuqtalarda funktsiyani baholash uchun foydalidir
f = np.sin(x)
Shuningdek qarang

massiv, nollar, nolga_o'xshash, birliklar, birlarga_o'xshash, bo'sh, bo'sh_kabi, arange, linspace, numpy.random.Generator.rand, numpy.random.Generator.randn, fromfunction, fromfile

Massivlarni chop etish

Massivni chop qilganingizda, NumPy uni ichki roʻyxatlarga oʻxshash tarzda, lekin quyidagi tartib bilan koʻrsatadi:

oxirgi o'q chapdan o'ngga chop etiladi,

ikkinchidan oxirgigacha yuqoridan pastgacha bosiladi,

qolganlari ham yuqoridan pastgacha chop etiladi, har bir tilim keyingisidan bo'sh chiziq bilan ajratiladi.

Keyin bir o'lchovli massivlar qatorlar, ikki o'lchovlilar matritsalar va uch o'lchovlilar matritsalar ro'yxati sifatida chop etiladi.

a = np.arange(6) # 1d massivi

chop etish(a)
[0 1 2 3 4 5]
>>>
b = np.arange(12).reshape(4, 3) # 2d massivi
chop etish (b)
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
>>>
c = np.arange(24).reshape(2, 3, 4) # 3D massivi
chop etish (c)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]
[20 21 22 23]]]
Qayta shakllantirish haqida batafsil ma'lumot olish uchun pastga qarang.

Agar massiv chop etish uchun juda katta bo'lsa, NumPy avtomatik ravishda massivning markaziy qismini o'tkazib yuboradi va faqat burchaklarni chop etadi:

chop etish (np.arange(10000))

[ 0 1 2 ... 9997 9998 9999]
>>>
print(np.arange(10000).reshape(100, 100))
[[ 0 1 2 ... 97 98 99]
[ 100 101 102 ... 197 198 199]
[ 200 201 202 ... 297 298 299]
...
[9700 9701 9702 ... 9797 9798 9799]
[9800 9801 9802 ... 9897 9898 9899]
[9900 9901 9902 ... 9997 9998 9999]]
Ushbu xatti-harakatni o'chirish va NumPy-ni butun massivni chop etishga majburlash uchun siz set_printoptions-dan foydalanib chop etish parametrlarini o'zgartirishingiz mumkin.

np.set_printoptions(threshold=sys.maxsize) # sys moduli import qilinishi kerak

Asosiy operatsiyalar
Massivlardagi arifmetik operatorlar elementlar bo'yicha qo'llaniladi. Yangi massiv yaratiladi va natija bilan to'ldiriladi.

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

b = np.arange(4)
b
massiv([0, 1, 2, 3])
c = a - b
c
massiv([20, 29, 38, 47])
b**2
massiv([0, 1, 4, 9])
10 * np.sin(a)
massiv([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
a < 35
massiv ([ rost, to'g'ri, noto'g'ri, noto'g'ri])
Ko'pgina matritsa tillaridan farqli o'laroq, mahsulot operatori * NumPy massivlarida elementlar bo'yicha ishlaydi. Matritsa mahsuloti @ operatori (pythonda >=3.5) yoki nuqta funksiyasi yoki usuli yordamida bajarilishi mumkin:

A = np.array([[1, 1],

[0, 1]])
B = np.array([[2, 0],
[3, 4]])
A * B # elementli mahsulot
massiv([[2, 0],
[0, 4]])
A @ B # matritsa mahsuloti
massiv([[5, 4],
[3, 4]])
A.dot(B) # boshqa matritsa mahsuloti
massiv([[5, 4],
[3, 4]])
Ba'zi operatsiyalar, masalan, += va *=, yangi massiv yaratish o'rniga, mavjud massivni o'zgartirish uchun ishlaydi.

rg = np.random.default_rng(1) # standart tasodifiy sonlar generatorining namunasini yaratish

a = np.ones((2, 3), dtype=int)
b = rg.tasodifiy((2, 3))
a *= 3
a
massiv([[3, 3, 3],
[3, 3, 3]])
b += a
b
massiv([[3.51182162, 3.9504637 , 3.14415961],
[3.94864945, 3.31183145, 3.42332645]])
a += b # b avtomatik ravishda butun son turiga aylantirilmaydi
Traceback (eng oxirgi qo'ng'iroq):
...
numpy.core._exceptions._UFuncOutputCastingError: ufunc 'add' chiqishini dtype('float64') dan dtype('int64') ga 'same_kind' quyish qoidasi bilan uzatib bo'lmaydi
Har xil turdagi massivlar bilan ishlaganda, hosil bo'lgan massivning turi umumiyroq yoki aniqroq (yuqoriga ko'tarilish deb nomlanuvchi xatti-harakat) mos keladi.