NumPy massiv operatsiyalari: Matematik hisoblashlar bo'yicha to'liq qo'llanma

NumPy, ya'ni Numerical Python, Pythonda ilmiy hisoblashlar uchun asosiy paketdir. U raqamli ma'lumotlar, xususan, massivlar bilan ishlash uchun kuchli vositalarni taqdim etadi. Ushbu qo'llanma butun dunyodagi ma'lumotlar bo'yicha mutaxassislar, muhandislar va tadqiqotchilarga imkoniyat berish uchun global yondashuv va amaliy misollarni taklif qilib, matematik hisoblashlar uchun NumPy massiv operatsiyalarining asosiy jihatlarini o'rganadi.

NumPy massivlariga kirish

Asosida, NumPy raqamli operatsiyalar uchun Pythonning o'rnatilgan ro'yxatlariga qaraganda samaraliroq va ko'p qirrali bo'lgan ko'p o'lchovli massiv ob'ekti — ndarrayni taqdim etadi. Massivlar bir hil ma'lumotlar tuzilmalari bo'lib, bu elementlar odatda bir xil ma'lumotlar turiga (masalan, butun sonlar, o'nli kasrlar) ega ekanligini anglatadi. Bu bir xillik samaradorlikni optimallashtirish uchun juda muhimdir.

NumPy bilan ishlashni boshlash uchun avval uni o'rnatishingiz kerak (agar sizda hali o'rnatilmagan bo'lsa):

            pip install numpy
            

              
                Copy
              
            
          

Keyin, paketni Python muhitingizga import qiling:

            import numpy as np
            

              
                Copy
              
            
          

np taxallusi keng tarqalgan an'ana bo'lib, kodingizni o'qish uchun qulay qiladi.

NumPy massivlarini yaratish

Massivlar ro'yxatlar, kortejlar va boshqa massivga o'xshash ob'ektlardan yaratilishi mumkin. Mana bir nechta misollar:

• Ro'yxatdan massiv yaratish:

            import numpy as np
my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)
print(my_array) # Natija: [1 2 3 4 5]
            

              
                Copy
              
            
          

• Ko'p o'lchovli massiv (matritsa) yaratish:

            import numpy as np
my_matrix = [[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]]
my_array = np.array(my_matrix)
print(my_array)
# Natija:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
            

              
                Copy
              
            
          

• Maxsus qiymatlar bilan massivlar yaratish:

            import numpy as np
zeros_array = np.zeros(5) # 5 ta noldan iborat massiv yaratadi: [0. 0. 0. 0. 0.]
ones_array = np.ones((2, 3)) # 2x3 o'lchamdagi birlardan iborat massiv yaratadi: [[1. 1. 1.]
                           #                                   [1. 1. 1.]]
range_array = np.arange(0, 10, 2) # 0 dan 10 gacha (10 kirmaydi), 2 qadam bilan massiv yaratadi: [0 2 4 6 8]
linspace_array = np.linspace(0, 1, 5) # 0 dan 1 gacha 5 ta teng masofali qiymatdan iborat massiv yaratadi: [0.   0.25 0.5  0.75 1.  ]
            

              
                Copy
              
            
          

Massiv atributlari

NumPy massivlari massiv haqida qimmatli ma'lumotlarni taqdim etuvchi bir nechta atributlarga ega:

• shape: Massivning o'lchamlarini (qatorlar, ustunlar va hokazo) qaytaradi.
• dtype: Massiv elementlarining ma'lumotlar turini qaytaradi.
• ndim: Massivning o'lchamlar (o'qlar) sonini qaytaradi.
• size: Massivdagi elementlarning umumiy sonini qaytaradi.

            import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6]])
print(my_array.shape)  # Natija: (2, 3)
print(my_array.dtype)  # Natija: int64 (yoki tizimingizga qarab shunga o'xshash)
print(my_array.ndim)   # Natija: 2
print(my_array.size)   # Natija: 6
            

              
                Copy
              
            
          

Asosiy massiv operatsiyalari

NumPy massivlarda elementma-element operatsiyalarni bajarishga imkon beradi, bu esa matematik hisoblashlarni soddalashtiradi. Bu operatsiyalar ko'pincha Python sikllari yordamida bir xil operatsiyalarni bajarishdan ancha tezroq bo'ladi.

Arifmetik amallar

Asosiy arifmetik amallar (+, -, *, /, **) elementma-element bajariladi. Operatsiyalar vektorlashtirilgan, ya'ni ular massivning barcha elementlarida bir vaqtning o'zida ishlaydi.

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

# Qo'shish
c = a + b
print(c)  # Natija: [5 7 9]

# Ayirish
d = b - a
print(d)  # Natija: [3 3 3]

# Ko'paytirish
e = a * b
print(e)  # Natija: [ 4 10 18]

# Bo'lish
f = b / a
print(f)  # Natija: [4.  2.5 2. ]

# Darajaga ko'tarish
g = a ** 2
print(g)  # Natija: [1 4 9]
            

              
                Copy
              
            
          

Broadcasting (Kengaytirish)

Broadcasting (Kengaytirish) NumPy'dagi kuchli mexanizm bo'lib, u turli shakldagi massivlar ustida amallar bajarishga imkon beradi. Kichikroq massiv kattaroq massiv bo'ylab "kengaytiriladi", shunda ularning shakllari mos keladi. Bu ko'pincha yashirin tarzda sodir bo'lib, kodni soddalashtiradi.

Masalan, massivga skalyar qiymat qo'shishingiz mumkin:

            import numpy as np
a = np.array([1, 2, 3])
result = a + 5
print(result)  # Natija: [6 7 8]
            

              
                Copy
              
            
          

Bu yerda 5 skalyari a massivining shakliga kengaytirilib, samarali tarzda [5, 5, 5] massivini hosil qiladi va keyin a ga qo'shiladi.

Massivlarni indekslash va kesib olish

NumPy massiv elementlariga kirish va ularni o'zgartirish uchun moslashuvchan usullarni taqdim etadi.

• Indekslash: Alohida elementlarga ularning indekslari yordamida kirish.
• Kesib olish: Boshlang'ich, to'xtash va qadam qiymatlaridan foydalanib, elementlar diapazoniga kirish.

            import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Indekslash
element = a[0, 1] # Birinchi qator, ikkinchi ustundagi elementga kirish
print(element)  # Natija: 2

# Kesib olish
row_slice = a[1:3, :] # 1 va 2-qatorlarni va barcha ustunlarni olish
print(row_slice)
# Natija:
# [[4 5 6]
#  [7 8 9]]

col_slice = a[:, 1] # Barcha qatorlarni va ikkinchi ustunni olish
print(col_slice)  # Natija: [2 5 8]
            

              
                Copy
              
            
          

Mantiqiy indekslash va "fancy" indekslash (indekslar massividan foydalanish) kabi ilg'or indekslash usullari ham mavjud bo'lib, ular yanada ko'proq nazoratni ta'minlaydi.

Matematik funksiyalar

NumPy massivlar ustida ishlaydigan matematik funksiyalarning keng to'plamini, jumladan trigonometrik, ko'rsatkichli va logarifmik funksiyalar, statistik funksiyalar va boshqalarni taqdim etadi.

Trigonometrik funksiyalar

NumPy sin(), cos(), tan(), arcsin(), arccos(), arctan() va boshqalar kabi standart trigonometrik funksiyalarni taklif qiladi, ular elementma-element ishlaydi.

            import numpy as np
a = np.array([0, np.pi/2, np.pi])
sin_values = np.sin(a)
print(sin_values)  # Natija: [0.000e+00 1.000e+00 1.225e-16] (taxminan, o'nli kasrlar aniqligi tufayli)

            

              
                Copy
              
            
          

Ko'rsatkichli va logarifmik funksiyalar

exp(), log(), log10() va sqrt() kabi funksiyalar ham mavjud.

            import numpy as np
a = np.array([1, 2, 3])
exp_values = np.exp(a)
print(exp_values)
# Natija: [ 2.71828183  7.3890561  20.08553692]

log_values = np.log(a)
print(log_values)
# Natija: [0.         0.69314718 1.09861229]
            

              
                Copy
              
            
          

Statistik funksiyalar

NumPy statistik tahlil uchun funksiyalarni o'z ichiga oladi:

• mean(): Massiv elementlarining o'rtacha qiymatini hisoblaydi.
• median(): Medianani hisoblaydi.
• std(): Standart chetlanishni hisoblaydi.
• var(): Dispersiyani hisoblaydi.
• min(): Minimal qiymatni topadi.
• max(): Maksimal qiymatni topadi.
• sum(): Massiv elementlarining yig'indisini hisoblaydi.

            import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(np.mean(a))    # Natija: 3.0
print(np.std(a))     # Natija: 1.4142135623730951
print(np.sum(a))    # Natija: 15
            

              
                Copy
              
            
          

NumPy bilan chiziqli algebra

NumPy mashinaviy o'rganish, fizika va muhandislik kabi turli sohalar uchun muhim bo'lgan chiziqli algebra operatsiyalari uchun kuchli vositalarni taqdim etadi. numpy.linalg moduli ko'plab chiziqli algebra funksiyalarini o'z ichiga oladi.

Matritsa operatsiyalari

• Matritsalarni ko'paytirish: @ operatori (yoki np.dot()) matritsalarni ko'paytirishni amalga oshiradi.
• Matritsani transpozitsiyalash: .T atributi yoki np.transpose() dan foydalaning.
• Determinant: np.linalg.det() kvadrat matritsaning determinantini hisoblaydi.
• Teskari matritsa: np.linalg.inv() kvadrat, teskarilanuvchi matritsaning teskarisini hisoblaydi.

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

# Matritsalarni ko'paytirish
c = a @ b  # Yoki np.dot(a, b)
print(c)
# Natija:
# [[19 22]
#  [43 50]]

# Matritsani transpozitsiyalash
d = a.T
print(d)
# Natija:
# [[1 3]
#  [2 4]]

# Determinant
e = np.linalg.det(a)
print(e)  # Natija: -2.0
            

              
                Copy
              
            
          

Chiziqli tenglamalarni yechish

NumPy np.linalg.solve() yordamida chiziqli tenglamalar tizimini yecha oladi.

            import numpy as np
# Tenglamalar tizimini yechish:
# 2x + y = 5
# x + 3y = 8

a = np.array([[2, 1], [1, 3]])
b = np.array([5, 8])
x = np.linalg.solve(a, b)
print(x)  # Natija: [1. 3.] (taxminan)
            

              
                Copy
              
            
          

Xos qiymatlar va xos vektorlar

np.linalg.eig() funksiyasi kvadrat matritsaning xos qiymatlari va xos vektorlarini hisoblaydi.

            import numpy as np
a = np.array([[1, 2], [2, 1]])
eigenvalues, eigenvectors = np.linalg.eig(a)
print('Xos qiymatlar:', eigenvalues)
print('Xos vektorlar:', eigenvectors)
            

              
                Copy
              
            
          

Amaliy misollar: Global qo'llanilishlar

NumPy butun dunyo bo'ylab turli sohalarda keng qo'llaniladi. Mana bir nechta misollar:

1. Tasvirlarga ishlov berish

Tasvirlar ko'p o'lchovli massivlar sifatida ifodalanadi, bu esa NumPy yordamida samarali ishlov berish imkonini beradi. Rangni to'g'rilash kabi oddiy manipulyatsiyalardan tortib, qirralarni aniqlash va ob'ektlarni tanib olish (ko'pincha butun dunyoda, jumladan, Germaniya va Xitoyda ishlab chiqilayotgan avtonom transport vositalarida kompyuter ko'rish ilovalarida qo'llaniladi) kabi ilg'or texnikalargacha, NumPy asosiy o'rinni egallaydi.

            # Soddalashtirilgan misol:
import numpy as np
from PIL import Image  # Pillow kutubxonasini talab qiladi

# Tasvirni yuklash ('image.png' ni o'z tasvir faylingiz bilan almashtiring)
try:
    img = Image.open('image.png')
except FileNotFoundError:
    print('Xato: image.png topilmadi.  Iltimos, uni joriy katalogga joylashtiring yoki yo\'lni o\'zgartiring.')
    exit()

img_array = np.array(img)

# Kulrang tusga o'tkazish (RGB kanallarini o'rtachalashtirish)
grayscale_img = np.mean(img_array, axis=2, keepdims=False).astype(np.uint8)

# Kulrang tusdagi tasvirni ko'rsatish yoki saqlash (matplotlib kabi kutubxonani talab qiladi)
from PIL import Image
grayscale_image = Image.fromarray(grayscale_img)
grayscale_image.save('grayscale_image.png')
print('Kulrang tusdagi tasvir grayscale_image.png nomi bilan saqlandi')
            

              
                Copy
              
            
          

2. Data Science va Mashinaviy o'rganish

NumPy Python'dagi Pandas, scikit-learn va TensorFlow kabi ko'plab data science kutubxonalari uchun asos hisoblanadi. U ma'lumotlarni tozalash, manipulyatsiya qilish, xususiyatlarni muhandislik qilish, modelni o'qitish va baholash uchun ishlatiladi. Dunyo bo'ylab tadqiqotchilar va amaliyotchilar, Qo'shma Shtatlardagi moliyaviy modellashtirishdan Avstraliyadagi iqlim tadqiqotlarigacha, bashoratli modellarni yaratish, ma'lumotlar to'plamini tahlil qilish va ma'lumotlardan qimmatli xulosalar chiqarish uchun NumPy'ga tayanadilar.

            # Misol: Ma'lumotlar to'plamining o'rtacha qiymatini hisoblash
import numpy as np
data = np.array([10, 12, 15, 18, 20])
mean_value = np.mean(data)
print(f'Ma\'lumotlarning o\'rtacha qiymati: {mean_value}')
            

              
                Copy
              
            
          

3. Ilmiy hisoblashlar

Yevropa kosmik agentligidan Hindistondagi tadqiqot institutlarigacha bo'lgan butun dunyo olimlari va muhandislari simulyatsiyalar, modellashtirish va ma'lumotlar tahlili uchun NumPy'dan foydalanadilar. Masalan, ular suyuqlik dinamikasini simulyatsiya qilish, eksperimental ma'lumotlarni tahlil qilish va raqamli algoritmlarni ishlab chiqish uchun undan foydalanadilar.

            # Misol: Oddiy jismoniy tizimni simulyatsiya qilish
import numpy as np
# Vaqt parametrlarini aniqlash
time = np.linspace(0, 10, 100)  # Vaqt 0 dan 10 soniyagacha, 100 nuqta

# Parametrlarni aniqlash (misol: doimiy tezlanish)
acceleration = 9.8  # m/s^2 (gravitatsion tezlanish)
initial_velocity = 0  # m/s
initial_position = 0  # m

# Kinematik tenglama yordamida vaqt bo'yicha pozitsiyani hisoblash:  x = x0 + v0*t + 0.5*a*t^2
position = initial_position + initial_velocity * time + 0.5 * acceleration * time**2

# Natijalarni chiqarish (grafik chizish va hokazo uchun)
print(position)
            

              
                Copy
              
            
          

4. Moliyaviy modellashtirish

Moliyaviy tahlilchilar portfelni optimallashtirish, risklarni boshqarish va moliyaviy modellashtirish kabi vazifalar uchun NumPy'dan foydalanadilar. U Shveytsariya va Yaponiyadagi investitsiya firmalari kabi butun dunyodagi kompaniyalarda katta hajmdagi ma'lumotlar to'plamlarini qayta ishlash va murakkab hisob-kitoblarni samarali bajarish uchun ishlatiladi.

            # Misol: Yillik o'sishning murakkab sur'atini (CAGR) hisoblash
import numpy as np
initial_investment = 10000 # USD
final_value = 15000   # USD
number_of_years = 5  # Yillar

# CAGR ni hisoblash
cagr = ( (final_value / initial_investment)**(1 / number_of_years) - 1 ) * 100
print(f'CAGR: {cagr:.2f}%')
            

              
                Copy
              
            
          

NumPy kodini optimallashtirish

NumPy'ning samaradorligidan maksimal darajada foydalanish uchun quyidagi maslahatlarni inobatga oling:

• Vektorlashtirish: Iloji boricha Python sikllaridan foydalanishdan saqlaning; NumPy operatsiyalari vektorlashtirilgan va ancha tezroq.
• Ma'lumotlar turlari: Xotiradan foydalanishni minimallashtirish uchun mos ma'lumotlar turlarini tanlang.
• Massiv ko'rinishlari (Views): Keraksiz xotira ajratishdan qochish uchun massivlarni nusxalash o'rniga massiv ko'rinishlaridan (masalan, kesib olish) foydalaning.
• Keraksiz nusxalardan saqlaning: Nusxa yaratadigan operatsiyalarga e'tiborli bo'ling (masalan, array.copy() dan foydalanish).
• O'rnatilgan funksiyalardan foydalaning: Iloji boricha NumPy'ning optimallashtirilgan o'rnatilgan funksiyalaridan foydalaning (masalan, np.sum(), np.mean()).

Xulosa

NumPy ilmiy hisoblashlar va ma'lumotlar tahlilining tamal toshidir. NumPy massiv operatsiyalarini o'zlashtirish sizga raqamli ma'lumotlarni samarali boshqarish, murakkab hisob-kitoblarni bajarish va turli sohalarda innovatsion yechimlarni ishlab chiqish imkonini beradi. Uning global miqyosda qo'llanilishi uning ko'p qirraliligini va zamonaviy ma'lumotlarga asoslangan tashabbuslardagi muhim rolini aks ettiradi. Ushbu qo'llanma ma'lumotlar taraqqiyotning markazida bo'lgan dunyoda NumPy'ning boy imkoniyatlari va uning qo'llanilishini o'rganish uchun asos yaratadi.

Qo'shimcha o'rganish uchun

O'rganish sayohatingizni davom ettirish uchun quyidagi manbalarni ko'rib chiqing:

• NumPy hujjatlari: Rasmiy NumPy hujjatlari keng qamrovli va batafsil. https://numpy.org/doc/stable/
• Onlayn kurslar: Coursera, edX va Udemy kabi platformalar NumPy va data science bo'yicha ko'plab kurslarni taklif qiladi.
• Kitoblar: Data science va ilmiy hisoblashlar uchun Python bo'yicha kitoblarni o'rganing, ular ko'pincha NumPy haqidagi bo'limlarni o'z ichiga oladi.
• Amaliyot: Tushunchangizni mustahkamlash uchun misollar va loyihalar ustida ishlang. Kaggle va boshqa platformalar amaliyot uchun ma'lumotlar to'plamlari va musobaqalarni taklif qiladi.