کتابخانه Numpy در پایتون، ابزارهای قدرتمندی برای محاسبات عددی مبتنی بر ماتریس‌ها و آرایه‌های چندبعدی در اختیار قرار می‌دهد. اسم این کتابخانه، Numpy، از مخفف عبارت Numerical Python می‌آید. این کتابخانه ابزارهای زیادی شامل انواع توابع ریاضی، توابع توزیع آماری، ابزارهای موردنیاز برای محاسبات جبر خطی و تبدیل فوریه (Fourier Transformations) و … را داراست.
هسته این کتابخانه مبتنی بر زبان C نوشته شده که باعث می‌شود محاسبات در Numpy با سرعت بالا انجام شود. همچنین این کتابخانه امکان محاسبات روی سیستم‌های توزیع‌شده و GPU (Graphics Processing Unit) را هم فراهم می‌کند. بسیاری از کتابخانه‌های مهم دیگر که در پایتون برای تحلیل داده و یادگیری ماشین استفاده می‌شوند؛ مانند Pandas، Matplotlib، SciPy و Sklearn از Numpy بهره می‌برند.
به همین دلیل اگر بخواهید از پایتون برای محاسبات ریاضی، تحلیل‌های آماری و یادگیری ماشین استفاده کنید، حتماً نیاز پیدا خواهید کرد که از این کتابخانه استفاده کنید. بر اساس تجربیاتم، من در این مقاله سعی می‌کنم مهم‌ترین مواردی را که نیاز دارید برای شروع کار با این کتابخانه بدانید، اشاره کنم.
لازم است یادآوری کنم که وب‌سایت این کتابخانه به نشانی زیر حاوی مطالب و محتوای آموزشی متنوعی است و توصیه می‌کنم، حتماً به آن سر بزنید:
فراخوانی کتابخانه Numpy در پایتون
با فرض اینکه Numpy را روی سیستم خود نصب کرده باشید، با دستور import می‌توانید آن را فراخوانی کنید تا توابع آن برای استفاده در دسترس پایتون قرار گیرد. ازآنجاکه در پایتون هنگام استفاده از توابع یک کتابخانه لازم است همواره اسم آن کتابخانه را قبل از تابع بیاورید، می‌توانید یک اسم مخفف برای آن کتابخانه تعریف کنید. معمولاً در جامعه برنامه‌نویسان پایتون، Numpy را با np مخفف می‌کنند گرچه شما مختارید از هر اسم دیگری استفاده کنید.
در کد زیر من کتابخانه Numpy را با اسم مخفف np فراخوانی کردم و سپس نسخه آن را بررسی کردم. همان‌طور که مشخص است من از نسخه ۱٫۱۹٫۵ استفاده می‌کنم.
1 2 3 | import numpy as np np.__version__ '1.19.5' |
ساختار داده در کتابخانه Numpy
ساختاری که کتابخانه Numpy برای نگهداری داده‌ها از آن بهره می‌برد، آرایه است. فرض کنید من یک برداری از اعداد به نام a1 می‌خواهم ایجاد کنم که دارای پنج درایه شامل ۳٫۱، ۲٫۶، ۱٫۷، ۵٫۲، ۲٫۸ و ۱٫۹ است. برای این منظور لازم است از تابع array استفاده کنیم و درایه‌های بردار را در قالب لیست پایتون، به‌عنوان ورودی به آن بدهیم. به‌این‌ترتیب آرایه یک‌بعدی a1 ایجاد می‌شود:
1 2 3 4 | #Create arrays a1 = np.array([3.1, 2.6, 1.7, 5.2, 2.8, 1.9]) a1 array([3.1, 2.6, 1.7, 5.2, 2.8, 1.9]) |
اگر با استفاده از تابع type در پایتون، کلاس a1 را فراخوانی کنم، ndarray را برمی‌گرداند:
1 2 | print(type(a1)) <class 'numpy.ndarray'> |
وقتی یک شیء از کلاس آرایه تعریف می‌کنیم، این شیء یک سری ویژگی (attribute) دارد. برای فهم این موضوع، این‌طور تصور کنید که اشیاء در دنیای واقعی یک سری ویژگی دارند. برای مثال صندلی یک شیء است و پایه داشتن یک ویژگی صندلی محسوب می‌شود. یک صندلی ممکن است سه یا چهار یا بیشتر پایه داشته باشد. در آرایه یک‌بعدی هم ویژگی شکل (shape) بیانگر تعداد درایه‌های آرایه است:
1 2 3 | #Shape print(a1.shape) (6,) |
دسترسی به درایه‌های آرایه
یکی از مهارت‌های بسیار مهمی که در کار با آرایه‌ها لازم است بر روی آن مسلط باشید، برش زدن داده و جدا کردن زیرمجموعه‌ای از درایه‌های آرایه است. برای مثال اگر من بخواهم درایه ۳٫۱ را از آرایه a1 فراخوانی کنم، با استفاده از اندیس (Index) آن می‌توانم این کار را انجام دهم. اندیس‌ها در Numpy از صفر شروع می‌شود؛ یعنی اندیس درایه ۳٫۱ ، صفر است، اندیس درایه ۲٫۶، یک است و الی‌آخر. برای فراخوانی یک درایه لازم است اندیس آن درایه را به شکل زیر داخل کروشه قرار دهیم و فراخوانی کنیم:
1 2 3 | #Access array elements a1[0] 3.1 |
این امکان وجود دارد که چندین درایه را هم‌زمان باهم از a1 فراخوانی کنید. برای این منظور لازم است اندیس درایه‌ها را در قالب لیست داخل کروشه قرار دهیم:
1 2 | a1[[0, 2, 3]] array([3.1, 1.7, 5.2]) |
در Numpy اندیس منفی هم معنی می‌دهد. اندیس‌ها با شروع از صفر و از سمت چپ به راست افزایش می‌یابند. در مقابل اندیس منفی از انتهای آرایه شروع می‌شود و از راست به چپ کاهش می‌یابند. برای مثال اندیس درایه ۱٫۹، پنج است. بر اساس اندیس گذاری منفی، اندیس آن ۱- است. به‌طور مشابه، اندیس مثبت درایه ۲٫۸، چهار و اندیس منفی آن ۲- است. در کد زیر من عدد ۱٫۹ را با اندیس منفی فراخوانی کردم:
1 2 | a1[-1] 1.9 |
در Numpy می‌توان یک آرایه را به طریق زیر از اندیس شروع (start) تا اندیس پایان (end) با گام‌های مشخص (step) برش زد:
[start:end:step]
اگر اندیس شروع مشخص نشود به‌صورت پیش‌فرض صفر در نظر گرفته می‌شود، اگر اندیس پایان مشخص نشود طول بعد آرایه در نظر گرفته می‌شود، اگر تعداد گام‌ها مشخص نشود، یک در نظر گرفته می‌شود. درباره اندیس پایان توجه کنید که درایه متناظر با اندیس پایان، فراخوانی نمی‌شود. مثال‌های زیر نحوه به‌کارگیری برش زدن آرایه را با این روش نشان می‌دهد:
1 2 3 4 5 6 7 8 | a1[1 : 3] array([2.6, 1.7]) a1[: 3] array([3.1, 2.6, 1.7]) a1[3 : ] array([5.2, 2.8, 1.9]) |
ایجاد ماتریس در Numpy
از تابع array برای ساخت ماتریس هم می‌توان استفاده کرد. به‌این‌ترتیب که هر یک از ردیف‌ها را در داخل یک لیست به آن بدهیم. ماتریس سه در سه a2 را به شکل زیر ایجاد کردم:
1 2 3 4 5 6 | #Matrix a2 = np.array([[1, 3, 5], [0, 2, 6], [3, 7, 9]]) a2 array([[1, 3, 5], [0, 2, 6], [3, 7, 9]]) |
اگر ویژگی شکل این آرایه را استخراج کنیم، تعداد سطرها و ستون‌های ماتریس را برمی‌گرداند:
1 2 | a2.shape (3, 3) |
برای دسترسی به آرایه‌های ماتریس باید از دو اندیس استفاده کرد که اولی در تناظر با ردیف و دومی در تناظر با ستون آن درایه است. برای نمونه، عدد ۵ واقع در ردیف با اندیس صفر و ستون با اندیس دو است، پس آن را به ترتیب زیر فراخوانی کردم:
1 2 | a2[0, 2] 5 |
اگر بخواهم تمام درایه‌های واقع در ردیف با اندیس صفر را فراخوانی کنم، به یکی از دو شکل زیر می‌توان انجام داد:
1 2 3 | #Access first row a2[0, :] array([1, 3, 5]) |
اگر بخواهم تمام درایه‌های واقع در ستون با اندیس صفر را فراخوانی کنم، به طریق زیر می‌توان انجام داد:
1 2 3 | #Access first column a2[:, 0] array([1, 0, 3]) |
ایجاد آرایه‌های چندبعدی
گرچه بردارها و ماتریس‌ها بسیار کاربردی هستند، این امکان وجود دارد با استفاده از تابع array، آرایه‌ها با ابعاد بالاتر هم ایجاد کرد. برای مثال در کد زیر من یک آرایه سه‌بعدی ایجاد کردم. در این مثال من فرض کردم سه محصول a، b و c داریم و می‌خواهیم اطلاعات تقاضای این سه محصول را در فصول سال‌های ۱۳۹۹ و ۱۴۰۰ در آرایه a3 ذخیره کنم.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | #Products a,b,c - years: 1399, 1400 -Q1, Q2, Q3, Q4 a3 = np.array([[[1200, 1000, 1150, 800], [1350, 1100, 1450, 950]], [[800, 850, 420, 350], [750, 790, 400, 330]], [[200, 340, 320, 350], [150, 310, 280, 290]]]) a3 array([[[1200, 1000, 1150, 800], [1350, 1100, 1450, 950]], [[ 800, 850, 420, 350], [ 750, 790, 400, 330]], [[ 200, 340, 320, 350], [ 150, 310, 280, 290]]]) a3.shape (3, 2, 4) |
همان‌طور که مشخص است این آرایه سه بعد دارد. بعد اول مربوط به محصولات مختلف است. برای هر محصول یک ماتریس دوبعدی ایجاد شده که ردیف‌های آن در تناظر با اطلاعات سال‌های ۱۳۹۹ و ۱۴۰۰، و ستون‌های آن در تناظر با فصل‌ها است.
حال اگر بخواهم اطلاعات محصول a را که اندیس صفر دارد، فراخوانی کنم به شکل زیر عمل می‌کنم:
1 2 3 | a3[0] array([[1200, 1000, 1150, 800], [1350, 1100, 1450, 950]]) |
اگر بخواهم بدانم تقاضای محصول b، در فصل چهارم سال ۱۴۰۰ چه بوده، با فراخوانی اندیس‌ها می‌توان انجام داد:
1 2 3 | #b, 1400, Q4 a3[1, 1, 3] 330 |
نوع داده در آرایه‌ها
یکی دیگر از ویژگی‌های آرایه‌ها، نوع داده (dtype) است. همه درایه‌های یک آرایه باید از یک نوع داده باشند. برای مثال، درایه‌های a2 همگی float64 هستند که برای ذخیره‌سازی اعداد اعشاری استفاده می‌شود و ۶۴ بیت از حافظه RAM را اشغال می‌کند. داده‌های آرایه a2 از نوع int32 است که برای ذخیره‌سازی اعداد صحیح استفاده می‌شود و ۳۲ بیت از حافظه RAM را اشغال می‌کند.
1 2 3 4 5 6 | #Data type in Numpy a1.dtype dtype('float64') a2.dtype dtype('int32') |
با تابع astype می‌توان نوع داده را تغییر داد. در کد زیر من نوع داده را در آرایه a2 از اعداد صحیح به اعداد اعشاری تغییر دادم و داخل new_a2 ذخیره کردم:
1 2 3 4 5 6 7 8 9 | #Convert data type new_a2 = a2.astype('float') new_a2 array([[1., 3., 5.], [0., 2., 6.], [3., 7., 9.]]) new_a2.dtype dtype('float64') |
ایجاد تغییر در درایه‌های آرایه ایجادشده
اگر بخواهم درایه ۲٫۶ را در آرایه a1 به عدد دیگری مثلاً صفر تغییر دهم، لازم است با استفاده از اندیس آن را فراخوانی کنم سپس با عملگر تخصیص (در پایتون، مساوی عملگر تخصیص است) عدد جدید را به آن درایه تخصیص دهم:
1 2 3 4 5 6 7 | #Modify an array a1 array([3.1, 2.6, 1.7, 5.2, 2.8, 1.9]) a1[1] = 0 a1 array([3.1, 0. , 1.7, 5.2, 2.8, 1.9]) |
با همین روش می‌توانم یکی از درایه‌های ماتریس a2 را تغییر دهم. برای مثال در کد زیر عدد ۶ را که در ردیف با اندیس ۱ و ستون با اندیس ۲ است، به ۱۰- تغییر دادم:
1 2 3 4 5 6 7 8 9 10 | a2 array([[1, 3, 5], [0, 2, 6], [3, 7, 9]]) a2[1, 2] = -10 a2 array([[ 1, 3, 5], [ 0, 2, -10], [ 3, 7, 9]]) |
تغییر در ابعاد آرایه
تابع reshape این اجازه را می‌دهد که نحوه چینش درایه‌ها را در آرایه به شکلی که موردنظر تغییر است، دهیم. برای نمونه آرایه a1 یک آرایه یک‌بعدی است که ۶ درایه دارد. من این آرایه را با استفاده از تابع reshape به یک آرایه دوبعدی ۲ در ۳ تبدیل کردم و آن را در new_a1 ذخیره کردم:
1 2 3 4 5 6 7 8 9 | #Reshape new_a1 = a1.reshape(2, 3) new_a1 array([[3.1, 0. , 1.7], [5.2, 2.8, 1.9]]) new_a1.shape (2, 3) |
چسباندن آرایه‌ها
تابع concatenate، امکان به هم متصل کردن آرایه‌هایی را که ابعاد آنان با یکدیگر سازگار است فراهم می‌کند. آرگومان اول این تابع در قالب Tuple پایتون است که شامل آرایه‌هایی است که قرار است به یکدیگر چسبانده شوند. آرگومان axis تنظیم می‌کند که این اتصال در راستای کدام بعد باشد. برای نمونه ابعاد آرایه‌های a1 و new_a1 را در زیر محاسبه کردم:
1 2 3 4 5 6 | #Join NumPy Arrays print(a2.shape) (3, 3) print(new_a1.shape) (2, 3) |
هر دو آرایه سه ستون دارند درحالی‌که تعداد سطرهایشان متفاوت است. پس این دو آرایه را از بالا به پایین می‌توان به هم چسباند. چون تعداد ردیف‌های آنان باهم متفاوت است، نمی‌توان به‌صورت چپ به راست به هم چسباند. باید توجه کرد که در راهنمای تابع آمده که axis محوری است که “در راستای” آن اتصال صورت می‌گیرد. پس اگر با توجه به ابعاد آرایه‌های a1 و new_a1 من بخواهم آن‌ها را از بالا به پایین بچسبانم، درواقع در راستای ردیف باید این کار را انجام دهم. در Numpy محور ردیف معادل صفر و محور ستون معادل یک است.
1 2 3 4 5 6 | np.concatenate((a2, new_a1), axis = 0) array([[ 1. , 3. , 5. ], [ 0. , 2. , -10. ], [ 3. , 7. , 9. ], [ 3.1, 0. , 1.7], [ 5.2, 2.8, 1.9]]) |
لازم به ذکر است به‌جای تابع concatenate، دو تابع vstack و hstack وجود دارند که به ترتیب به برای چسباندن آرایه‌ها از بالا به پایین و چپ به راست می‌توانند استفاده شوند. من مثال بالا را با vstack دوباره ایجاد کردم:
1 2 3 4 5 6 | np.vstack((a2, new_a1)) array([[ 1. , 3. , 5. ], [ 0. , 2. , -10. ], [ 3. , 7. , 9. ], [ 3.1, 0. , 1.7], [ 5.2, 2.8, 1.9]]) |
جستجو در آرایه
آرایه a1 را در نظر بگیرید:
1 2 | a1 array([3.1, 0. , 1.7, 5.2, 2.8, 1.9]) |
اگر من بخواهم بفهمم اندیس درایه ۱٫۹ چیست، از تابع where می‌توان استفاده کرد:
1 2 3 | #Search Arrays np.where(a1 == 1.9) (array([5], dtype=int64),) |
همین‌طور می‌توان در تابع where شرط‌هایی را بررسی کرد. برای مثال در کد زیر من بررسی کردم که اندیس درایه‌هایی که بزرگ‌تر از ۲ هستند، کدام‌اند:
1 2 | np.where(a1 > 2) (array([0, 3, 4], dtype=int64),) |
همچنین دو تابع argmin و argmax برای یافتن اندیس درایه‌های کمینه و بیشینه آرایه استفاده می‌شوند:
1 2 3 4 5 | np.argmax(a1) 3 np.argmin(a1) 1 |
مرتب کردن آرایه
تابع sort برای مرتب کردن درایه‌های آرایه از کوچک به بزرگ استفاده می‌شود:
1 2 3 4 5 6 | a1 array([3.1, 0. , 1.7, 5.2, 2.8, 1.9]) #Sort Arrays np.sort(a1) array([0. , 1.7, 1.9, 2.8, 3.1, 5.2]) |
در همین رابطه، تابع argsort اندیس درایه‌های مرتب‌شده را برمی‌گرداند:
1 2 | np.argsort(a1) array([1, 2, 5, 4, 0, 3], dtype=int64) |
بنابراین به روش زیر از این تابع هم می‌توان استفاده کرد تا آرایه a1 را مرتب کرد:
1 2 | a1[np.argsort(a1)] array([0. , 1.7, 1.9, 2.8, 3.1, 5.2]) |
ایجاد آرایه‌های خاص
تا به اینجا نحوه ساخت آرایه را با استفاده از تابع array بحث کردم. در این روش نیاز است تا تک‌به‌تک درایه‌ها در قالب لیست به تابع داده شود. بسیار پیش می‌آید که درایه‌های آرایه موردنظر از یک الگوی مشخصی پیروی می‌کند. در این موارد بهتر است به‌جای واردکردن تک‌به‌تک درایه‌ها، از توابعی استفاده کنیم که در کتابخانه Numpy برای تعریف آرایه‌های خاص وجود دارند.
مثلاً برای ساخت آرایه‌ای که همه درایه‌های آن صفر است؛ از تابع zeros می‌توان استفاده کرد. در کد زیر، یک ماتریس ۲ در ۳ ایجاد کردم که همه درایه‌های آن صفر است:
1 2 3 4 | #Filling Arrays with Specific Values np.zeros((2, 3), dtype = int) array([[0, 0, 0], [0, 0, 0]]) |
تابع ones برای ساخت آرایه‌ای استفاده می‌شود که همه درایه‌های آن ۱ است. آرگومان اول تابع شکل آرایه و آرگومان dtype نوع داده را تعیین می‌کند که من آن را در کد زیر عدد صحیح (int) قرار دادم:
1 2 3 4 | np.ones((3, 3), dtype = int) array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) |
پر کردن آرایه با یک عدد خاص
به شکل کلی می‌توان از تابع full برای ساخت آرایه‌ای استفاده کرد که درایه آن عدد دلخواهی است. آرگومان اول تابع full، شکل آرایه و آرگومان دوم آن عدد دلخواهی است که درایه‌های آن را می‌سازد:
1 2 3 4 | np.full((3, 3), 2) array([[2, 2, 2], [2, 2, 2], [2, 2, 2]]) |
ساخت آرایه‌ای که درایه‌های آن در یک بازه است
یکی از پرکاربردترین توابع Numpy برای ساختن آرایه‌ای که درایه‌های آن در یک بازه است، تابع arange است. آرگومان اول این تابع، نقطه شروع بازه، آرگومان دوم، انتهای بازه و آرگومان سوم تعداد گام‌هاست. اگر عدد شروع بازه مشخص نشود به‌صورت پیش‌فرض صفر در نظر گرفته می‌شود. اگر تعداد گام‌ها مشخص نشود، یک در نظر گرفته می‌شود. همچنین عدد انتهای بازه در بازه در نظر گرفته نمی‌شود. به مثال‌های زیر توجه کنید:
1 2 3 4 5 6 | #Create Ranges with arange np.arange(5, 10, 0.5) array([5. , 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5]) np.arange(5) array([0, 1, 2, 3, 4]) |
یک روش پرکاربرد دیگر برای ساخت آرایه‌ای که درایه‌های آن در یک بازه است، استفاده از تابع linspace است. آرگومان اول، نقطه شروع بازه، آرگومان دوم، عدد انتهایی بازه و آرگومان سوم تابع، تعداد درایه‌های آرایه است. درایه‌هایی که ایجاد می‌شوند از یکدیگر فاصله برابر دارند. برای نمونه در کد زیر من یک آرایه با ۱۰ درایه ساختم که در بازه ۱ تا ۵ قرار دارند و از یکدیگر فاصله یکسانی دارند:
1 2 3 | np.linspace(1, 5, 10) array([1. , 1.44444444, 1.88888889, 2.33333333, 2.77777778, 3.22222222, 3.66666667, 4.11111111, 4.55555556, 5. ]) |
ساخت آرایه‌ای که درایه‌های آن از یک توزیع احتمالی آمده است
کتابخانه Numpy ماژولی به نام random دارد که توابع متنوعی برای توزیع احتمال است. برای نمونه اگر بخواهیم یک ماتریس ۳ در ۳ داشته باشیم که درایه‌های آن از توزیع نرمال با میانگین ۰ و انحراف معیار ۱ آمده باشد، کد زیر آن را به دست می‌دهد:
1 2 3 4 | np.random.normal(loc = 0, scale = 1, size = (3, 3)) array([[-1.0856306 , 0.99734545, 0.2829785 ], [-1.50629471, -0.57860025, 1.65143654], [-2.42667924, -0.42891263, 1.26593626]]) |
اگر کد بالا را اجرا کنید، خواهید دید که به اعداد متفاوتی ازآنچه من رسیدم، خواهید رسید. همین‌طور اگر هر بار کد بالا را اجرا کنید، نتیجه آن متفاوت خواهد بود. اگر بخواهیم نتیجه ثابت بماند قبل از اجرای کد بالا لازم است از تابع seed استفاده کنید و داخل آن یک عدد دلخواه بگذارید. من در مثال بعدی از این روش استفاده کردم.
تابع دیگری برای تولید عدد تصادفی، randint است که در بازه دلخواه عدد اعداد تصادفی صحیح تولید می‌کند. برای نمونه من در کد زیر یک ماتریس ۳ در ۳ ایجاد کردم که درایه‌های آن در بازه ۰ تا ۱۰ است:
1 2 3 4 5 | np.random.seed(123) np.random.randint(0, 10, (3, 3)) array([[2, 2, 6], [1, 3, 9], [6, 1, 0]]) |
تابع پرکاربرد دیگر، choice است که از یک جامعه آماری به‌صورت تصادفی به تعداد دلخواه انتخاب می‌کند. در کد زیر من پرتاب سه بار پرتاب سکه منصف را شبیه‌سازی کردم. آرگومان اول، همان جامعه آماری است که در قالب لیست به آن دادم و آرگومان size اندازه نمونه است:
1 2 3 | np.random.seed(123) np.random.choice(['H', 'T'], size = 3) array(['H', 'T', 'H'], dtype='<U1') |
محاسبات آماری پایه روی آرایه
کتابخانه Numpy توابع موردنیاز برای محاسبات آماری را در اختیار قرار می‌دهد. در جدول زیر توابع پایه‌ای را آورده‌ام:
بیشینه درایه‌های آرایه | max |
کمینه درایه‌های آرایه | min |
میانگین درایه‌ها | mean |
انحراف معیار درایه‌ها | sd |
جمع درایه‌ها | sum |
در مثال‌های زیر من توابع بالا را روی آرایه a2 که قبلاً ایجاد کرده بودم، پیاده‌سازی کردم:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | a2 array([[ 1, 3, 5], [ 0, 2, -10], [ 3, 7, 9]]) np.max(a2) 9 np.min(a2) -10 np.mean(a2) 2.2222222222222223 np.std(a2) 5.094174838376734 np.sum(a2) 20 |
یک آرگومان کاربردی در این توابع axis است که اجازه می‌دهد محاسبات را در راستای یک بعد آرایه انجام دهید. در Numpy محور ردیف معادل صفر و محور ستون معادل یک است. در کد زیر، ابتدا جمع در راستای ردیف آرایه (جمع روی ستون) و سپس جمع در راستای ستون آرایه (جمع روی ردیف) را محاسبه کردم:
1 2 3 4 5 6 7 | #Sum along with rows (sum over columns) np.sum(a2, axis = 0) array([ 4, 12, 4]) #Sum along with columns (sum over rows) np.sum(a2, axis = 1) array([ 9, -8, 19]) |
محاسبات پایه ماتریسی در Numpy
ماتریس a2 را در نظر بگیرید. می‌توان a2 را در یک عدد اسکالر مانند ۲ ضرب یا با آن جمع کرد:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | a2 array([[ 1, 3, 5], [ 0, 2, -10], [ 3, 7, 9]]) a2 * 2 array([[ 2, 6, 10], [ 0, 4, -20], [ 6, 14, 18]]) a2 + 2 array([[ 3, 5, 7], [ 2, 4, -8], [ 5, 9, 11]]) |
می‌توان عملگرهای مقایسه‌ای را روی درایه‌های ماتریس a2 پیاده کرد. در مثال زیر، من بررسی کردم که آیا تک‌تک درایه‌های a2 از ۲ بزرگ‌تر هستند یا خیر. می‌بینید خروجی این عملگر یک ماتریس هم‌بعد با ماتریس a2 است که درایه‌های آن True یا False است.
1 2 3 4 | a2 > 0 array([[ True, True, True], [False, True, False], [ True, True, True]]) |
اگر بخواهیم ترانهاده ماتریس a2 را محاسبه کنیم، از دستوری مانند زیر استفاده می‌کنیم:
1 2 3 4 5 | #Transpose of a matrix a2.T array([[ 1, 0, 3], [ 3, 2, 7], [ 5, -10, 9]]) |
کتابخانه Numpy دارای ماژولی به نام linalg است که توابع متنوعی برای محاسبات جبر خطی را شامل می‌شود. برای نمونه برای محاسبه دترمینان ماتریس از تابع det این ماژول به شکل زیر می‌توان استفاده کرد:
1 2 | np.linalg.det(a2) -32.000000000000014 |
تابع inv برای محاسبه معکوس ماتریس استفاده می‌شود:
1 2 3 4 5 | #Invert of a matrix np.linalg.inv(a2) array([[-2.75 , -0.25 , 1.25 ], [ 0.9375, 0.1875, -0.3125], [ 0.1875, -0.0625, -0.0625]]) |
به‌شرط سازگار بودن ابعاد دو ماتریس، تابع dot برای محاسبه ضرب ماتریس استفاده می‌گردد. در کد زیر، پس از بررسی ابعاد دو ماتریس a2 و new_a1 ضرب ماتریسی این دو را محاسبه کردم:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | a2 array([[ 1, 3, 5], [ 0, 2, -10], [ 3, 7, 9]]) new_a1 array([[3.1, 0. , 1.7], [5.2, 2.8, 1.9]]) print(new_a1.shape) (2, 3) print(a2.shape) (3, 3) np.dot(new_a1, a2) array([[ 8.2, 21.2, 30.8], [10.9, 34.5, 15.1]]) |
برای حل دستگاه معادلات خطی از تابع solve ماژول linalg می‌توان استفاده کرد. یک دستگاه معادلات خطی را می‌توان در قالب ماتریسی Ax = b در نظر گرفت که A ماتریس ضرایب و b ماتریس مقادیر سمت راست است. دستگاه معادلات خطی زیر را در نظر بگیرید:
در دستگاه معادلات خطی بالا، آرایه a2 که قبلاً ایجاد کرده بودم، همان ماتریس ضرایب و ماتریس b حاوی مقادیر سمت راست است. سپس آن را با تابع solve حل کردم:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | a2 array([[ 1, 3, 5], [ 0, 2, -10], [ 3, 7, 9]]) b = np.array([12, -1, -2]).reshape(3, 1) b array([[12], [-1], [-2]]) np.linalg.solve(a2, b) array([[-35.25 ], [ 11.6875], [ 2.4375]]) |
بررسی سرعت محاسبات در Numpy نسبت به پایتون پایه
همان‌طور که در ابتدا اشاره کردم، هسته کتابخانه Numpy مبتنی بر زبان C نوشته شده که باعث می‌شود سرعت محاسبات در Numpy بالا باشد. در کد زیر من مثالی ساختم و آن را با ابزارهای پایه پایتون و Numpy پیاده‌سازی کردم. در این کد یک لیست (ساختار داده پایه پایتون) ایجاد کردم که حاوی ۶۰ میلیون عدد است، مشابه همین کار را با آرایه Numpy کردم. سپس درایه‌های آن را باهم جمع زدم. با ماژول time زمان اجرای محاسبه را بر روی هر دو ساختار داده به دست‌آوردم. همان‌طور که در زیر مشخص است زمان اجرای محاسبه تفاوت محسوسی دارد.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | l = list(range(60000000)) a = np.arange(60000000) from time import time s_time = time() sum(l) e_time = time() print(f'The computation time is {e_time - s_time} sec') The computation time is 1.8032066822052002 sec s_time = time() np.sum(a) e_time = time() print(f'The computation time is {e_time - s_time} sec') The computation time is 0.05086493492126465 sec |