آموزش numpy با مثال‌های کاربردی — آرایه و ماتریس

✨ نقشه راه سریع NumPy ✨

یه نگاه اجمالی به چیزایی که قراره یاد بگیریم:

• 🚀 چرا NumPy؟ سرعت، کارایی، قدرت برای محاسبات عددی.
• 🛠️ نصب و راه‌اندازی: `pip install numpy` و `import numpy as np`.
• 🔢 آرایه (ndarray): ساخت، ویژگی‌ها (shape, ndim, dtype).
• ✂️ ایندکس‌گذاری و برش‌زنی: دسترسی دقیق به داده‌ها.
• 🔄 بازشکل‌دهی: تغییر ابعاد آرایه‌ها (reshape).
• ➕ عملیات ریاضی: عنصری، ماتریسی و توابع تجمیعی.
• 🌐 بُردکستینگ: کار با آرایه‌هایی با ابعاد متفاوت.
• 💡 عیب‌یابی: حل مشکلات رایج و سوالات متداول.

آماده‌ایم؟ بزن بریم!

pip install numpy

import numpy as np

import numpy as np

# آرایه تک‌بعدی
list1 = [1, 2, 3, 4, 5]
arr1 = np.array(list1)
print(f"آرایه تک‌بعدی: {arr1}") # Output: آرایه تک‌بعدی: [1 2 3 4 5]

# آرایه دوبعدی (ماتریس)
list2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
arr2d = np.array(list2d)
print(f"آرایه دوبعدی:n{arr2d}")
# Output:
# آرایه دوبعدی:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

# تعیین نوع داده (dtype)
arr_float = np.array([1, 2, 3], dtype=float)
print(f"آرایه با نوع اعشاری: {arr_float}") # Output: آرایه با نوع اعشاری: [1. 2. 3.]
    

# آرایه 3x4 پر از صفر
zeros_arr = np.zeros((3, 4))
print(f"آرایه صفرها:n{zeros_arr}")

# آرایه 2x3 پر از یک
ones_arr = np.ones((2, 3))
print(f"آرایه یک‌ها:n{ones_arr}")

# آرایه 2x2 پر از عدد 7
full_arr = np.full((2, 2), 7)
print(f"آرایه پر از 7:n{full_arr}")
    

# np.arange(start, stop, step) - مشابه range در پایتون
range_arr = np.arange(0, 10, 2) # از 0 تا 10 با گام 2
print(f"آرایه arange: {range_arr}") # Output: [0 2 4 6 8]

# np.linspace(start, stop, num) - تولید 'num' عدد با فاصله یکسان بین start و stop
linspace_arr = np.linspace(0, 1, 5) # 5 عدد بین 0 و 1 (شامل 1)
print(f"آرایه linspace: {linspace_arr}") # Output: [0.   0.25 0.5  0.75 1.  ]
    

# آرایه 3x3 از اعداد اعشاری تصادفی بین 0 و 1
random_float_arr = np.random.rand(3, 3)
print(f"آرایه اعشاری تصادفی:n{random_float_arr}")

# آرایه 2x4 از اعداد صحیح تصادفی بین 1 تا 10 (10 شامل نمی‌شود)
random_int_arr = np.random.randint(1, 10, size=(2, 4))
print(f"آرایه صحیح تصادفی:n{random_int_arr}")
    

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

print(f"آرایه: n{arr}")
print(f"شکل (shape) آرایه: {arr.shape}")   # Output: (2, 3)
print(f"تعداد ابعاد (ndim): {arr.ndim}")     # Output: 2
print(f"تعداد کل عناصر (size): {arr.size}") # Output: 6
print(f"نوع داده عناصر (dtype): {arr.dtype}") # Output: int64 (ممکن است متفاوت باشد)
    

arr1d = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(f"آرایه تک‌بعدی: {arr1d}")

# دسترسی به یک عنصر
print(f"عنصر سوم (ایندکس 2): {arr1d[2]}") # Output: 2
print(f"آخرین عنصر: {arr1d[-1]}")       # Output: 9

# برش‌زنی (Slicing)
print(f"عناصر 2 تا 5: {arr1d[2:6]}")     # Output: [2 3 4 5]
print(f"از اول تا 4: {arr1d[:5]}")      # Output: [0 1 2 3 4]
print(f"از 5 تا آخر: {arr1d[5:]}")      # Output: [5 6 7 8 9]
print(f"هر دو عنصر: {arr1d[::2]}")      # Output: [0 2 4 6 8]

print("n--- آرایه دوبعدی ---")
arr2d = np.array([[10, 11, 12, 13],
                  [14, 15, 16, 17],
                  [18, 19, 20, 21]])
print(f"آرایه دوبعدی:n{arr2d}")

# دسترسی به یک عنصر (سطر 1، ستون 2)
print(f"عنصر در (1, 2): {arr2d[1, 2]}") # Output: 16

# دسترسی به یک سطر کامل (سطر 0)
print(f"سطر اول: {arr2d[0, :]}")        # Output: [10 11 12 13]
print(f"سطر دوم: {arr2d[1]}")           # Output: [14 15 16 17]

# دسترسی به یک ستون کامل (ستون 1)
print(f"ستون دوم: {arr2d[:, 1]}")       # Output: [11 15 19]

# برش‌زنی پیشرفته: زیرماتریس (سطرهای 0 و 1، ستون‌های 2 و 3)
sub_matrix = arr2d[0:2, 2:4]
print(f"زیرماتریس:n{sub_matrix}")
# Output:
# زیرماتریس:
# [[12 13]
#  [16 17]]

# ایندکس‌گذاری Boolean (فیلتر کردن)
# انتخاب عناصیر بزرگتر از 15
greater_than_15 = arr2d[arr2d > 15]
print(f"عناصر بزرگتر از 15: {greater_than_15}") # Output: [16 17 18 19 20 21]
    

arr = np.arange(12) # [ 0  1  2  3  4  5  6  7  8  9 10 11]
print(f"آرایه اصلی: {arr}")

# تغییر به آرایه 3x4
reshaped_arr = arr.reshape(3, 4)
print(f"آرایه 3x4:n{reshaped_arr}")
# Output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# تغییر به آرایه 4x3
reshaped_arr2 = arr.reshape(4, 3)
print(f"آرایه 4x3:n{reshaped_arr2}")

# اگه یه بُعد رو -1 بذاری، NumPy خودش محاسبه می‌کنه
arr_unknown_rows = arr.reshape(-1, 3) # 3 ستون، تعداد سطرها خودکار
print(f"آرایه با سطر نامعلوم:n{arr_unknown_rows}")

# تبدیل آرایه چندبعدی به تک‌بعدی
flat_arr = reshaped_arr.flatten() # یک کپی از آرایه رو برمیگردونه
print(f"آرایه تک‌بعدی (flatten): {flat_arr}")

ravel_arr = reshaped_arr.ravel()  # یک "نما" از آرایه رو برمیگردونه (ممکن است به حافظه اصلی اشاره کند)
print(f"آرایه تک‌بعدی (ravel): {ravel_arr}")
    

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

print(f"جمع: {arr1 + arr2}")      # Output: [5 7 9]
print(f"ضرب: {arr1 * arr2}")      # Output: [ 4 10 18]
print(f"تفریق: {arr1 - arr2}")     # Output: [-3 -3 -3]
print(f"تقسیم: {arr1 / arr2}")     # Output: [0.25 0.4  0.5 ]

print(f"توان: {arr1 ** 2}")      # Output: [1 4 9] (هر عنصر به توان 2)
print(f"مقایسه: {arr1 > 2}")     # Output: [False False  True] (Boolean array)
    

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

# ضرب ماتریسی
dot_product = np.dot(mat1, mat2)
print(f"ضرب ماتریسی (np.dot):n{dot_product}")
# Output:
# [[19 22]
#  [43 50]]

# ضرب ماتریسی با عملگر @ (در پایتون 3.5 به بعد)
at_product = mat1 @ mat2
print(f"ضرب ماتریسی (@):n{at_product}")
    

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

print(f"مجموع کل عناصر: {np.sum(arr)}")      # Output: 21
print(f"میانگین کل عناصر: {np.mean(arr)}")    # Output: 3.5
print(f"حداکثر کل عناصر: {np.max(arr)}")      # Output: 6
print(f"حداقل کل عناصر: {np.min(arr)}")      # Output: 1

# تجمیع روی محورها (axis)
# axis=0: روی ستون‌ها (جمع عناصر هر ستون)
print(f"جمع روی ستون‌ها: {np.sum(arr, axis=0)}") # Output: [5 7 9]

# axis=1: روی سطرها (جمع عناصر هر سطر)
print(f"جمع روی سطرها: {np.sum(arr, axis=1)}") # Output: [ 6 15]
    

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"آرایه اصلی:n{arr}")

scalar = 10
# اضافه کردن یک اسکالر به تمام عناصر آرایه
result_scalar = arr + scalar
print(f"اضافه کردن اسکالر:n{result_scalar}")
# Output:
# [[11 12 13]
#  [14 15 16]
#  [17 18 19]]

vector = np.array([100, 200, 300])
# اضافه کردن یک وکتور به هر سطر آرایه
result_vector = arr + vector
print(f"اضافه کردن وکتور به سطر:n{result_vector}")
# Output:
# [[101 202 303]
#  [104 205 306]
#  [107 208 309]]

# اضافه کردن یک وکتور ستونی به آرایه
vector_col = np.array([[10], [20], [30]]) # آرایه 3x1
result_vector_col = arr + vector_col
print(f"اضافه کردن وکتور ستونی:n{result_vector_col}")
# Output:
# [[11 12 13]
#  [24 25 26]
#  [37 38 39]]
    

چرا NumPy انقدر سریعه؟

سرعت بالای NumPy به چند دلیل اصلیه: اول اینکه، هسته اصلی NumPy با زبان‌های سطح پایین‌تر مثل C و Fortran نوشته شده که خیلی سریع‌تر از پایتون خام اجرا میشن. دوم، آرایه‌های NumPy به صورت فشرده و پیوسته تو حافظه ذخیره میشن، که دسترسی و پردازیش اطلاعات رو برای CPU آسون‌تر می‌کنه. سوم، NumPy از عملیات برداری استفاده می‌کنه، یعنی عملیات رو به جای تک‌تک عناصر، روی کل آرایه به صورت یکجا انجام میده که باعث میشه از بهینه‌سازی‌های سخت‌افزاری نهایت استفاده رو ببره.

آرایه و ماتریس چه فرقی دارن؟

از نظر برنامه‌نویسی و تو NumPy، ماتریس در واقع یه حالت خاص از آرایه‌های دوبعدیه. یعنی هر ماتریسی یه آرایه دوبعدی محسوب میشه. با این حال، از نظر ریاضیاتی، ماتریس‌ها معمولاً برای کاربردهای جبر خطی استفاده میشن و ممکنه قوانین و نمادگذاری‌های خاص خودشون رو داشته باشن (مثلاً ضرب ماتریسی). NumPy یک شیء به نام `np.matrix` هم داره، اما استفاده از `np.ndarray` (که همون آرایه معمولی NumPy هست) برای ماتریس‌ها تو اکثر موارد توصیه میشه، چون انعطاف‌پذیری و سازگاری بیشتری با بقیه توابع NumPy داره.

چطور آرایه‌هایی با مقادیر Boolean (درست/غلط) بسازم؟

خیلی راحته! میتونی یه آرایه از مقادیر Boolean مستقیم بسازی یا از عملیات مقایسه‌ای استفاده کنی. مثلاً:

# ساخت مستقیم
bool_arr = np.array([True, False, True, False])
print(f"آرایه Boolean مستقیم: {bool_arr}")

# با استفاده از مقایسه
data_arr = np.array([10, 20, 5, 30, 15])
is_greater_than_15 = data_arr > 15
print(f"آرایه Boolean از مقایسه: {is_greater_than_15}")
# Output: [False  True False  True False]
        

این آرایه‌های Boolean خیلی تو فیلتر کردن و انتخاب داده‌ها تو NumPy کاربرد دارن.

❌ `ValueError: cannot reshape array of size X into shape Y`

این خطا وقتی رخ میده که سعی میکنی یه آرایه رو به شکلی (shape) تغییر بدی که تعداد عناصرش با تعداد کل عناصر آرایه اصلیت هم‌خوانی نداره. مثلاً یه آرایه 12 عنصری رو نمیتونی به شکل (5, 3) (که 15 عنصر میشه) تغییر بدی.

✅ راه‌حل:

قبل از `reshape`، مطمئن شو که حاصل ضرب ابعاد جدید با `arr.size` برابر باشه. یا از `reshape(-1, N)` یا `reshape(N, -1)` استفاده کن تا NumPy خودش یکی از ابعاد رو محاسبه کنه.

arr = np.arange(10) # 10 عنصر
# arr.reshape(3, 4) # 3*4 = 12, خطا میده!
correct_reshape = arr.reshape(2, 5) # 2*5 = 10, درسته
print(correct_reshape)
        

❌ `TypeError: unsupported operand type(s) for *: ‘numpy.ndarray’ and ‘list’`

این خطا معمولاً وقتی پیش میاد که میخوای یه عملیات ریاضی (مثلاً ضرب) رو بین یه آرایه NumPy و یه لیست عادی پایتون انجام بدی. NumPy با لیست‌های پایتون به صورت مستقیم عملیات برداری انجام نمیده.

✅ راه‌حل:

قبل از انجام عملیات، لیست پایتون رو هم به یه آرایه NumPy تبدیل کن. کدهای آماده و اسنیپت میتونن بهت تو این موارد کمک کنن.

arr = np.array([1, 2, 3])
my_list = [4, 5, 6]
# result = arr * my_list # خطا میده

correct_result = arr * np.array(my_list)
print(correct_result) # Output: [ 4 10 18]
        

❌ `IndexError: index X is out of bounds for axis Y with size Z`

این خطا یعنی داری سعی میکنی به ایندکس یا موقعیتی تو آرایه دسترسی پیدا کنی که وجود نداره. مثلاً اگه یه آرایه 3 عنصری داشته باشی و بخوای به `arr[3]` دسترسی پیدا کنی، این خطا رو میگیری چون ایندکس‌ها از 0 شروع میشن و آخرین ایندکس 2 هست.

✅ راه‌حل:

همیشه قبل از دسترسی به عناصر، از `arr.shape` و `arr.ndim` استفاده کن تا مطمئن شی ایندکس‌ها یا برش‌هایی که استفاده میکنی، تو محدوده مجاز باشن.

arr = np.array([10, 20, 30])
# print(arr[3]) # خطا میده

print(arr[2]) # Output: 30