آموزش کتابخانه numpy در پایتون

این پست به آموزش کتابخانه NumPy در پایتون اختصاص دارد. کتابخانه NumPy ، یک کتابخانه بسیار پرکاربرد در حوزه کامپیوتر ساینس است. این کتابخانه امکانات زیادی برای کار با آرایه‌ها دارد. از این رو یادگیری آن برای همه محققانی که می‌خواهند در حوزه کامپیوترساینس فعالیت داشته باشند ضروری است. اگر می‌خواهید با نامپای و دستورهای مهم آن آشنا شوید، آموزش نامپای ( NumPy ) هوسم را از دست ندهید…

کتابخانه NumPy چیست ؟

عبارت NumPy مخفف Numerical Python است و نامپای یک کتابخانه پایتونی برای کار با آرایه‌ای عددی است.  شاید این سوال برای شما ایجاد شود که با وجود لیست‌ها در پایتون، دلیل نیاز به کتابخانه NumPy چیست ؟ جواب این است که، اگرچه امکان ساختن یک آرایه با لیست‌ ها وجود دارد، اما کار کردن با آرایه‌هایی که با لیست ساخته می‌شوند به هیچ وجه ساده نیست!

کتابخانه NumPy مخصوص کار با آرایه‌های عددی ساخته شده است. با استفاده از کتابخانه نامپای و متدهای متعددی که دارد، به راحتی می‌توان با آرایه‌ها کار کرد. ضرب کردن دو آرایه که با لیست‌ها ساخته شده‌اند شاید ساده نباشد. اما ضرب دو آرایه نامپای در یک چشم به هم زدن انجام می‌شود. همچنین آرایه‌ها و توابع NumPy مخصوص کار با داده‌های بزرگ طراحی شده‌اند و حتی در ذخیره‌سازی آرایه‌ها نسبت به لیست‌ها بسیار بهینه‌تر هستند.

بسیارخب، در این بخش به این سوال پرداختیم که کتابخانه NumPy چیست؟ در بخش بعدی مختصری در مورد تاریخچه نامپای صحبت خواهیم کرد.

تاریخچه کتابخانه NumPy

همیشه آقای Travis Oliphant به عنوان خالق Numpy معرفی می‌شود. اما اینطور نیست که ایشان یک روزی تصمیم گرفته باشند کتابخانه‌ای به نام «نامپای» در پایتون خلق کنند! ساخته شدن کتابخانه نامپای هم ماجرا دارد که من خلاصه برایتان تعریف می‌کنم.

پایتون به صورت خاص برای کار با اعداد طراحی نشده بود. اما به مرور زمان به دلیل سادگی و خوانایی این زبان برنامه‌نویسی، توانست توجه جامعه علمی و مهندسان را به خودش جلب کند. اما پایتون در مقایسه با سایر زبان‌های برنامه‌نویسی مثل C، ابزاری برای کار با آرایه‌ها نداشت. همین باعث ساخته شدن کتابخانه Numeric و پس از آن کتابخانه Numarray شد.

تمایل بسیار زیادی وجود داشت که کتابخانه Numeric تبدیل به کتابخانه استاندارد پایتون شود، اما Guido van Rossum، خالق پایتون، ایراداتی به کدهای Numeric داشت و از این کار جلوگیری کرد. سرانجام در سال 2005 آقای Travis Oliphant با هدف متحد کردن جامعه علمی، دو کتابخانه Numarray و Numeric را در هم ادغام کرده و NumPy را ارائه کرد! جالب است بدانید که NumPy ابتدا بخشی از کتابخانه SciPy بود. اما چون SciPy کتابخانه بزرگی است، تصمیم گرفته شد که نامپای را به صورت جداگانه ارائه دهند.

تفاوت تعریف آرایه در نامپای و لیست در پایتون

در بخش قبل از آموزش، گفتیم که نامپای برای کار با آرایه‌ها در پایتون ساخته شده است. اگر با پایتون آشنایی داشته باشید، احتمالا می‌دانید که با استفاده از لیست هم می‌توان در پایتون یک آرایه تعریف کرد. خب اگر اینطور هست، چه نیازی به کتابخانه Numpy داریم؟ در جواب این سوال، می‌توان ویژگی‌های زیر را معرفی کرد:

• سرعت بالاتر

مهم‌ترین تفاوت آرایه تعریف شده در نامپای با آرایه‌ای که به صورت لیست ساخته شده است، سرعت آن‌هاست! شاید در ابعاد پایین این مساله زیاد هم قابل لمس نباشد، اما در کار با آرایه‌های بزرگ و چندبعدی اهمیت سرعت بیشتر مشخص می‌شود.

دلیل سریع‌تر بودن Numpy، نحوه ذخیره شدن داده‌ها در حافظه است. در یک لیست، برای هر آیتم، یک پوینتر در حافظه وجود دارد. هرکدام از پوینترها به نقطه‌ای از حافظه اشاره می‌کنند که اطلاعات مربوط به عنصر متناظرشان در آنجا ذخیره شده است. این پوینترها پشت سر هم نیستند و ممکن است دو آیتم که در لیست کنار هم قرار گرفته‌اند، در دو نقطه متفاوت از حافظه ذخیره شوند.

اما در نامپای تمامی آیتم‌های یک آرایه در کنار هم ذخیره می‌شوند. همین امر باعث می‌شود دسترسی به آیتم‌های یک آرایه در نامپای با سرعت بیشتری انجام شود!

• حلقه‌های کمتر

نامپای این امکان را می‌دهد که حلقه‌های کمتری استفاده کنید! چطور؟ کتابخانه Numpy در پایتون، شامل توابع ریاضی زیادی است که کمک می‌کنند یکسری عملیات ریاضی به صورت ماتریسی انجام شوند. اگر با کدنویسی متلب آشنایی داشته باشید احتمالا آنجا نیز چنین رفتاری را دیده‌اید! طبیعتا انجام برخی محاسبات مثلا ضرب دو آرایه اگر به صورت ماتریسی انجام شوند، زمان کمتری طول می‌کشند.

• کدهای تمیزتر

وقتی حلقه‌های کمتری استفاده می‌شوند، قطعا تعداد خطوط کد شما کمتر شده و تمیزتر و خواناتر خواهد شد.

نصب و فراخوانی کتابخانه Numpy در پایتون

روش‌های مختلفی برای نصب کتابخانه نامپای در پایتون وجود دارد که در این آموزش ما در مورد نحوه نصب Numpy با pip صحبت خواهیم کرد. برای نصب نامپای کافی است که CMD را در ویندوز باز کرده و بنویسید:

pip install numpy

با اجرای دستور بالا نامپای نصب خواهد شد و شما می‌توانید آن را فراخوانی کنید. برای فراخوانی کتابخانه Numpy در پایتون، کافی است بنویسید:

import numpy

حالا کتابخانه نامپای فراخوانی شده و آماده استفاده است.

np مخفف چیست ؟!

در بخش قبل کتابخانه نامپای را در پایتون فراخوانی کردیم. اما بسیار رایج است که برنامه‌نویسان یک نام اختصاری به numpy اختصاص می‌دهند و به این شکل کتابخانه نامپای را فراخوانی می‌کنند:

import numpy as np

np در واقع همان مخفف کلمه Numpy است. حالا هرجایی در کدمان بخواهیم از Numpy، اتریبیوت‌ها و متدهایش استفاده کنیم، باید بنویسیم np. یعنی np نماینده Numpy خواهد بود. برویم سراغ بخش بعدی از پست « آموزش کتابخانه numpy در پایتون »…

تعریف آرایه در پایتون

در این بخش از آموزش کتابخانه numpy در پایتون، نحوه تعریف یک آرایه Numpy در پایتون را به صورت کامل آموزش خواهیم داد. برای کار با آرایه‌ها در پایتون، قدم اول طبیعتا تعریف یک آرایه است.

تعریف یک آرایه در نامپای بسیار ساده و با استفاده از متد ()np.array انجام می‌شود. برای این کار کافیست که داخل پرانتز، آرایه خود را به شکل یک لیست وارد کنید! اگر با لیست‌ها آشنایی ندارید، به پست « لیست در پایتون » مراجعه کنید.

دست به کیبورد شوید تا با چند مثال، نحوه تعریف آرایه در پایتون را با هم تمرین کنیم. بیایید با تعریف یک بردار سطری ساده شروع کنیم. در اولین مثال، می‌خواهیم برداری با سه عنصر 1، 2 و 3 تعریف کنیم.

به این منظور کافی است بنویسید:

arr_1 = np.array([1, 2, 3])

به همین سادگی که می‌بینید، برداری سطری با عناصر 1، 2 و 3 تعریف کردیم. حالا همین بردار را به صورت ستونی می‌خواهیم تعریف کنیم.

برای این کار کد بالا را به شکل زیر تغییر می‌دهیم:

arr_2 = np.array([[1], [2], [3]])

مشاهده می‌کنید که دقیقا به شکل یک لیست تو در تو نوشته شده است. خب از کجا معلوم که واقعا یک بردار ستونی باشد؟ پرینتش کنید و ببینید:

print(arr_2)

array([[1],
       [2],
       [3]])

حالا مثلا برای نوشتن یک ماتریس 3 در 2 به شکل زیر، چه باید بنویسیم؟

برای تعریف چنین آرایه‌ای کافی است آن را به صورت یک لیست تو در تو بنویسیم، یعنی به شکل زیر:

سمت چپ ماتریس موردنظر و سمت راست نحوه تعریف این آرایه در Numpy آورده شده است. برای تعریف این آرایه کافی است بنویسید:

arr_3 = np.array([[1, 1], [2, 2], [3, 3]])

مشاهده می‌کنید که یک ماتریس 3 در 2 با درایه‌های خواسته شده ساختیم. به همین ترتیب می‌توانیم هر آرایه‌ای را با نامپای بسازیم.

محاسبه ابعاد یک آرایه Numpy

برای محاسبه ابعاد یک آرایه در نامپای می‌توان از دستور shape استفاده کرد. دستور shape یکی از attribute-های آرایه در نامپای است. از قضا این اتریبیوت بسیار بسیار بسیااار پر استفاده است! برای محاسبه ابعاد یک آرایه در پایتون مثلا arr_3، کافی است بنویسید:

arr_3.shape

 (3, 2)

مشاهده می‌کنید که نتیجه (2 ,3) است. عدد اول تعداد سطرها و عدد دوم تعداد ستون‌ها را نشان می‌دهد.

نکته بعد از shape نباید از پرانتز استفاده کنید! اگر پرانتز بگذارید با خطا مواجه می‌شوید.

اندیس دهی به آرایه در نامپای

همان‌طور که می‌دانید، اندیس دهی برای دسترسی به یک المان (یا درایه) از یک آرایه استفاده می‌شود. به این منظور، کافی است آدرس درایه موردنظر را داشته باشیم. آدرس یک درایه، شماره سطر و ستون آن است.

دقت کنید که در پایتون، اندیس‌ها از صفر شروع می‌شوند. یعنی اگر درایه‌ای در ستون اول باشد، شماره آن در پایتون صفر است! برای سطرها هم همینطور، اگر در سطر دوم باشد، شماره آن در پایتون، یک خواهد بود! به شکل زیر می‌توانید درایه‌ای که در سطر دوم و ستون اول از arr_3 وجود دارد را استخراج کنید:

arr_3[1, 0]

2

دقت کنید که اول شماره سطر را وارد کردیم و بعد شماره ستون را. به همین ترتیب می‌توانید هر درایه‌ای که دلتان بخواهد را استخراج کنید.

تکه‌برداری (Slicing) آرایه در نامپای

تکه‌برداری یا اسلایسینگ به این معناست که یک بخش از آرایه را برداریم. مثلا ستون اول و سطر اول و دوم. برای انجام چنین عملیاتی در پایتون از علامت کولن (:) کمک می‌گیریم. علامت : در پایتون معادل با «تا» است. یعنی یک بازه را انتخاب می‌کند. اما دقت کنید که این بازه، بازه باز است!🥴 مثلا سطر اول و دوم را می‌توان نوشت، 0:2، این یعنی بازه باز 0 تا 2، یعنی همان اندیس 0 و 1. برای انتخاب ستون اول و سطر اول و دوم از arr_3 کافی است بنویسید:

arr_3[0:2, 0]

 array([1, 2])

درست است دیگر نه؟ ستون اول و سطر اول و دوم را برداشتیم. حالا اگر بخواهیم ستون اول و دوم و سطر دوم و سوم را برداریم چه باید بنویسیم؟ باید بنویسیم:

arr_3[1:3, 0:2]

array([[2, 2],
       [3, 3]])

اما علامت : را دست کم نگیرید. اگر این علامت را به تنهایی برای اسلایسینگ استفاده کنید، به معنی تمامی عناصر آن بعد است. یعنی از اول تا آخر! مثلا اگر بخواهیم، تمامی عناصر موجود در ستون دوم را برداریم، کافی است بنویسیم:

arr_3[:, 1]

 array([1, 2, 3])

در واقع ما اندیس شروع و پایان را مشخص نکردیم و مشاهده می‌کنید که تمامی عناصر موجود در ستون دوم، استخراج شده است.

یک نکته جالب دیگر اینکه، اگر سمت چپ علامت : را خالی بگذاریم، یعنی از اندیس صفر شروع کن و اگر سمت راست آن را خالی بگذاریم یعنی تا اندیس آخر ادامه بده! یعنی برای انتخاب عناصر موجود در ستون اول و سطر اول و دوم، کافی است بنویسید:

arr_3[:2, 0]

 array([1, 2])

یا برای انتخاب عناصر موجود در ستون اول و سطر دوم و سوم باید بنویسید:

arr_3[1:, 0]

 array([2, 3])

به همین راحتی!

متدهای تعریف ماتریس های خاص در نامپای

در زبان‌های برنامه‌نویسی مثل متلب، دستورهایی وجود دارند که یکسری ماتریس های خاص و رایج را به کمک آن‌ها می‌توان تعریف کرد. مثلا ماتریس صفر، یا یک! در نامپای هم متدهایی وجود دارند که ماتریس های خاص را می‌توان با آن‌ها تعریف کرد. در ادامه پست «آموزش کتابخانه numpy در پایتون» نحوه تعریف چند ماتریس خاص را معرفی خواهیم کرد.

تعریف ماتریس صفر در Numpy

ماتریس صفر، یعنی ماتریسی که تمام عناصر آن صفر باشد. برای تعریف یک ماتریس صفر در نامپای کافی است از متد zeros استفاده کنید. شما باید تعداد سطر و ستون ماتریس را مشخص کنید. مثلا برای یک ماتریس صفر به ابعاد 2 در 4، کافی است بنویسید:

np.zeros((2, 4)) 

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]])

مشاهده می‌کنید که یک ماتریس 2 در 4 تعریف کردیم که تمام درایه‌های آن صفر است! به پرانتزها دقت کنید! همیشه باید ابعاد را در پرانتز بنویسید!

اگر بخواهیم یک بردار صفر به طول 5 تعریف کنیم چه؟ کافی است بنویسیم:

np.zeros(5)

یا

np.zeros((1, 5))

خروجی هردو کد برابر است با:

array([[0., 0., 0., 0., 0.]])

با کد زیر هم می‌توانید یک بردار ستونی به طول 5 تعریف کنید:

np.zeros((5, 1))

array([[0.],
       [0.],
       [0.],
       [0.],
       [0.]])

مشاهده می‌کنید که این بار یک ماتریس ستونی تعریف کردیم که تمامی عناصر آن صفر است.

تعریف ماتریس یک در نامپای

ماتریس یک، ماتریسی است که تمامی درایه‌های آن یک هستند. برای تعریف چنین ماتریسی در نامپای از دستور ones استفاده می‌کنیم. نحوه استفاده از این دستور نیز مشابه با دستور zeros است. برای تعریف یک ماتریس 2 در 4 با درایه‌های یک، کافی است بنویسید:

np.ones((2, 4))

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])

در اینجا هم باید ابعاد را در پرانتز بنویسیم! تعریف بردار یک به طول 5 نیز به شکل زیر انجام می‌شود:

np.ones(5)

array([1., 1., 1., 1., 1.])

np.ones((5, 1))

تعریف ماتریس همانی در نامپای

ماتریس همانی، ماتریسی است که در آن عناصر روی قطر اصلی یک و بقیه درایه‌ها صفر هستند. تصویر زیر را ببینید:

این تصویر یک ماتریس همانی با ابعاد 4 در 4 را نشان می‌دهد. چنین ماتریسی در نامپای با کمک متد eye ساخته می‌شود. مثلا برای ماتریس همانی که در شکل بالا مشخص شده، کافی است بنویسید:

np.eye(4)

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

یک ماتریس همانی در ریاضیات همیشه مربعی است. بنابراین وقتی یک عدد به eye بدهیم با آن یک ماتریس مربعی می‌سازد! اگرچه در ریاضیات یک ماتریس همانی، همیشه مربعی است، اما در نامپای ماتریس همانی می‌تواند ماتریس مربعی نباشد! مثلا می‌توانیم در نامپای یک ماتریس همانی به ابعاد 4 در 6 بسازیم:

np.eye(4, 6)

array([[1., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0.]])

مشاهده می‌کنید که عناصر روی قطر اصلی (تا جایی که وجود دارد)، یک و بقیه صفر هستند. دقت کنید که در استفاده از متد eye نیاز نیست که ابعاد را داخل پرانتز بنویسید، بلکه می‌توانید آن را مستقیما به این دستور بدهید.

ساخت آرایه با مقدار دلخواه در نامپای

در نامپای این امکان وجود دارد که یک آرایه با ابعاد دلخواه بسازید که تمامی عناصر آن یک عدد ثابتِ دلخواه باشند. از متد full برای این کار می‌توانید استفاده کنید. مثلا فرض کنید بخواهید یک آرایه 5 در 3 با مقدار 2 تعریف کنید. برای این کار باید بنویسید:

np.full((5, 3), 2)

array([[2, 2, 2],
       [2, 2, 2],
       [2, 2, 2],
       [2, 2, 2],
       [2, 2, 2]])

مشاهده می‌کنید که بدون هیچ دردسری یک ماتریس ساختیم و آن را با عدد 2 پر کردیم. دقت کنید که اینجا هم ابعاد را در یک پرانتز جداگانه وارد کردیم. برای معرفی یک بردار ستونی به طول 7 و با مقادیر 4 چه باید بنویسیم؟ کافی است بنویسیم:

np.full((7, 1), 4)

array([[4],
       [4],
       [4],
       [4],
       [4],
       [4],
       [4]])

full(15, 7)

آرایه‌های تصادفی در NumPy

برای ساختن یک آرایه تصادفی در نامپای، باید از ماژول random استفاده کنید. این ماژول، دستورهای متنوع و زیادی برای ساختن آرایه تصادفی دارد که در این بخش چند مورد از پرکاربردترین‌ها را با هم مرور می‌کنیم.

آرایه تصادفی با توزیع یکنواخت در نامپای (دستور rand)

برای ساختن یک آرایه تصادفی با توزیع یکنواخت می‌توانید از دستور rand استفاده کنید. اعداد تولید شده توسط دستور rand در NumPy در بازه صفر و یک قرار دارند. استفاده از دستور rand بسیار ساده است و فقط کافی است ابعاد آرایه را به آن بدهیم؛ به این شکل:

np.random.rand(3, 2)

array([[0.89445501, 0.98196831],

[0.70063108, 0.72274348],

[0.58738385, 0.25436146]])

نتیجه این دستور، یک آرایه تصادفی با 3 سطر و 2 ستون است. مشاهده می‌کنید که تمامی مقادیر تولید شده بین صفر و یک هستند. به همین ترتیب می‌توانید آرایه‌هایی با ابعاد دلخواه تولید کنید.

ساختن یک عدد تصادفی با استفاده از دستور rand

برای ساختن یک عدد تصادفی کافی است عدد 1 را در ورودی وارد کنید:

np.random.rand(1)

array([0.31829185])

اگر هر عدد دیگری به جز 1 در ورودی بدهید، یک بردار سطری به همان طول ساخته خواهد شد. در بخش بعد این مساله را بررسی می‌کنیم.

ساختن یک بردار سطری تصادفی با استفاده از دستور rand

در بخش قبل گفتیم که اگر در ورودی دستور rand یک عدد غیر از 1 بدهید، یک بردار سطری به همان طول ساخته خواهد شد. مثلا برای ساختن یک بردار سطری به طول 4 کافی است بنویسید:

np.random.rand(4)

array([0.00710531, 0.87450822, 0.20581312, 0.21422563])

بردار سطری با چنین ابعادی را به این شکل هم می‌توان ساخت:

np.random.rand(1, 4)

ساختن آرایه‌های تصادفی با ابعاد بالاتر نکته خاصی ندارد و کافی است فقط ابعاد را در ورودی وارد کنید. دقت کنید که چون بردارهای ساخته شده تصادفی هستند، با هر بار اجرای کد، پاسخ متفاوت خواهد بود. پس طبیعتا نتایج شما با این اعدادی که اینجا می‌بینید یکی نخواهد بود!

ساختن آرایه تصادفی با توزیع یکنواخت در بازه دلخواه

گفتیم که بازه اعداد تولید شده در بازه صفر و یک است. با استفاده از عملیات ریاضی می‌توانیم اعداد تصادفی در بازه دلخواه خودمان تولید کنیم. مثلا فرض کنید بخواهیم یک بردار سطری به طول 10 و با اعداد تصادفی در بازه 0 و 5 تولید کنیم. برای این کار کافی است بردار مورد نظر را ابتدا با دستور rand تولید کرده، سپس آن را در عدد 5 ضرب کنیم:

5 * np.random.rand(10)

array([2.67132251, 0.57867137, 4.25305154, 0.05131422, 2.90625722,
       0.63779192, 4.11317394, 4.4145065 , 4.34336764, 3.73278008])

مشاهده می‌کنید که اعداد تولید شده در بازه دلخواه ما هستند. حالا اگر بخواهیم اعداد تولید شده در بازه 3 و 7 باشند چه؟ طول بازه مورد نظر ما 4 است. پس ابتدا اعداد تولید شده با rand را در 4 ضرب می‌کنیم. سپس این اعداد را با عدد 3 جمع می‌کنیم که 3 واحد به سمت بالا شیفت پیدا کند.

4 * np.random.rand(10) + 3

array([6.3080561 , 6.12760568, 4.886181  , 4.12806806, 4.47591615,
       5.72097954, 3.90174287, 5.94609974, 6.78054413, 3.37002944])

مشاهده می‌کنید که همه اعداد در بازه 3 تا 7 هستند.

آرایه تصادفی با توزیع گوسین یا نرمال در نامپای (دستور randn)

در این بخش از آموزش NumPy می‌خواهیم دستور randn را معرفی کنیم که اعداد تصادفی با توزیع نرمال استاندارد (میانگین صفر و انحراف معیار یک) تولید می‌کند. عدد تصادفی با میانگین نرمال استاندارد یعنی اینکه هرچه عدد به میانگین (یعنی صفر) نزدیک‌تر باشد، احتمال تولید شدنش بیشتر است. بنابراین بیشتر اعدادی که با این دستور تولید می‌شوند، حول میانگین هستند.

استفاده از این دستور هم دقیقا مشابه با rand است. در ورودی، ابعاد آرایه تصادفی که می‌خواهید را وارد کنید و خروجی موردنظرتان را دریافت کنید:

np.random.randn(3, 2)

array([[ 1.67715994, 0.52635689],
[-0.80579418, 0.79492547],
[ 2.39877104, 1.32360532]])

مشابه با دستور rand، اگر در ورودی عدد 1 را وارد کنید، یک عدد تصادفی خواهید گرفت. اگر هم یک عدد غیر یک وارد کنید، یک بردار سطری با مقادیر تصادفی (با توزیع نرمال) دریافت خواهید کرد.

np.random.randn(1)

array([-0.89228867])

np.random.randn(4)

array([ 0.37803379, -0.17040093,  0.93933929,  0.70282122])

در بخش بعدی از آموزش نامپای در پایتون خواهم گفت که چگونه اعدادی تصادفی با انحراف معیار و میانگین دلخواه خود را تولید کنید.

ساختن آرایه تصادفی با توزیع گوسین در بازه دلخواه

گفتیم که دستور randn یک توزیع گوسین (یا نرمال) با میانگین صفر و انحراف معیار یک می‌سازد. اما این امکان وجود دارد که با استفاده از عملیات ریاضی، اعدادی تصادفی با میانگین و انحراف معیار دلخواه تولید کرد.

این کار تقریبا مشابه با rand است. برای این کار کافی است اعداد تولید شده را در انحراف معیار دلخواه ضرب کرده و با میانگین موردنظر جمع کنید:

sigma = 2
mu = 3
sigma * np.random.randn(10) + mu

array([4.29374289, 2.56617573, 1.84363607, 2.92451867, 3.42672418,

       2.41740056, 2.27683039, 2.2359051 , 2.06124983, 1.81936546])

مشاهده می‌کنید که بیشتر اعداد تولید شده حول میانگین (یعنی حول عدد 3) هستند.

آرایه تصادفی با مقادیر صحیح در numpy (دستور randint)

با استفاده از دستور randint، شما می‌توانید یک آرایه تصادفی بسازید که مقادیر آن اعداد صحیح باشند. برای این کار کافی است که ابتدا و انتهای بازه و ابعاد آرایه موردنظرمان را مشخص کنیم. دقت کنید که انتهای بازه، باز است. یعنی عدد انتهای بازه هیچگاه انتخاب نخواهد شد.

به عنوان مثال، برای ساختن یک آرایه تصادفی با ابعاد 5 در 2 که شامل اعداد تصادفی در بازه 1 تا 9 باشند، کافی است بنویسید:

np.random.randint(1, 10, size=(5, 2))

array([[7, 8],
       [1, 7],
       [8, 4],
       [5, 9],
       [4, 1]])

انتهای بازه را عدد 10 گذاشتیم. چرا؟ چون گفتیم بازه باز است و اگر بگذاریم 9، خود عدد 9 انتخاب نخواهد شد. ابعاد را هم به شکل توپل به عنوان سومین ورودی با کلیدواژه size به تابع می‌دهیم.

دو نکته در مورد randint

نکته اول اینکه شما می‌توانید ابتدای بازه را اصلا وارد نکرده و فقط انتهای بازه را وارد کنید. اگر می‌خواهید اعداد تولید شده از صفر باشند، دیگر نیازی به وارد کردن ابتدای بازه نیست:

np.random.randint(5, size=(2, 3))

با اجرای این کد اعداد تصادفی از صفر تولید خواهند شد.

array([[0, 1, 4],
       [3, 0, 2]])

نکته دوم این است که اگر size را وارد نکنید، خروجی randint تنها یک عدد تصادفی صحیح خواهد بود.

آموزش کتابخانه numpy در پایتون ادامه دارد…