NumPy for Data Science Beginners | Python Numerical Computing | Sinhala Guide

හැඳින්වීම: Data Science වලට පිවිසෙමු!

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ මේ දවස්වල Software Engineering ක්ෂේත්‍රයේ ගොඩක් ජනප්‍රිය මාතෘකාවක් ගැන – ඒ තමයි Data Science. අද ලෝකයේ හැම තැනම වගේ Data තියෙනවා, Facebook, Instagram වගේ Social Media platforms වල ඉඳලා, අපේ phone එකේ තියෙන apps, Banks, Hospitals වගේ හැම තැනම. ඉතින් මේ විශාල Data ප්‍රමාණයෙන් ප්‍රයෝජනවත් දේවල් හොයාගන්නේ කොහොමද? එතනට තමයි Data Science එන්නේ. Data Science කියන්නේ මේ Data එකතු කරලා, විශ්ලේෂණය කරලා, ඒකෙන් තේරුම් ගන්න පුළුවන් විදියට insights අරගෙන, අනාගතය ගැන පුරෝකථනය (predictions) කරන්න උදව් වෙන විද්‍යාවක්.

ඔබ Software Engineer කෙනෙක් විදියට මේ ගැන දැනගන්න එක හරිම වටිනවා. මොකද මේ ක්ෂේත්‍රයේ දියුණුවත් එක්ක අලුත් අවස්ථා ගොඩක් නිර්මාණය වෙනවා. Data Science වලට Programming Languages ගොඩක් තිබුණත්, Python කියන්නේ ඒ අතරින් කැපී පෙනෙන එකක්. Python වල තියෙන සරල බව, වගේම විශාල Libraries ප්‍රමාණයක් නිසා Data Science වලට Python නැතුවම බැරි Language එකක් වෙලා.

අද මේ Tutorial එකෙන් අපි Python Data Science ගමනේ මූලිකම පියවරක් ගැන කතා කරනවා: ඒ තමයි NumPy. NumPy කියන්නේ Python වල Numerical Computing (සංඛ්‍යාත්මක ගණනය කිරීම්) වලට තියෙන පදනම. අපි මේ Tutorial එකෙන් NumPy කියන්නේ මොකක්ද, ඒකේ තියෙන Arrays සහ Array Operations මොනවද, සහ ඒවා ප්‍රායෝගිකව භාවිතා කරන්නේ කොහොමද කියලා විස්තරාත්මකව බලමු. අපි ලොකු Data ප්‍රමාණයක් එක්ක වැඩ කරනකොට NumPy අපිට කොයි තරම් වැදගත්ද කියලා ඔබට මේ Tutorial එක අවසානයේදී තේරෙයි. එහෙනම්, අපි පටන් ගමු!

1. Data Science කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, Data Science කියන්නේ Data වලින් දැනුම සහ insights හොයාගන්න, විවිධ විද්‍යාත්මක ක්‍රම, algorithms, සහ පද්ධති භාවිතා කරන අන්තර් විනය ක්ෂේත්‍රයක් (interdisciplinary field). Data Science කරන කෙනෙක්ට (Data Scientist) Computer Science, Statistics, Mathematics, Domain Knowledge (ඒ කියන්නේ තමන් වැඩ කරන ක්ෂේත්‍රය පිළිබඳ දැනුම), මේ හැම එකක්ම එකට එකතු කරලා වැඩ කරන්න වෙනවා. ටිකක් සංකීර්ණයි වගේ පෙනුනත්, මූලික දේවල් තේරුම් ගැනීමෙන් ඕනෑම කෙනෙකුට මේ ක්ෂේත්‍රයට පිවිසෙන්න පුළුවන්.

Data Science ඇයි මේ තරම් වැදගත්?

• ව්‍යාපාරික තීරණ (Business Decisions): Data Science නිසා සමාගම් වලට ඔවුන්ගේ පාරිභෝගිකයන්ගේ හැසිරීම්, වෙළඳපල ප්‍රවණතා (market trends) තේරුම් අරගෙන වඩා හොඳ තීරණ ගන්න පුළුවන්. උදාහරණයක් විදියට, Netflix ඔබට ඊළඟට බලන්න recommend කරන්නේ Data Science algorithms භාවිතා කරලා.
• පුරෝකථනය (Predictions): කාලගුණ අනාවැකි (weather forecasts), කොටස් වෙළඳපල පුරෝකථනයන් (stock market predictions), රෝග පැතිරීම (disease outbreaks) වගේ දේවල් වලට Data Science වලින් ලොකු උදව්වක් ලැබෙනවා.
• කාර්යක්ෂමතාව වැඩි කිරීම (Improving Efficiency): කර්මාන්තශාලා වල නිෂ්පාදන ක්‍රියාවලීන්, සැපයුම් දාම කළමනාකරණය (supply chain management) වගේ දේවල් වල කාර්යක්ෂමතාව වැඩි කරන්න Data Analysis වලින් පුළුවන්.

මේ හැම දෙයකටම අවශ්‍ය වෙන Data Processing, Calculations, Analysis වගේ දේවල් ඉතා වේගයෙන් සහ කාර්යක්ෂමව කරන්න Python වලට තියෙන Libraries තමයි උදව් කරන්නේ. ඒ අතරින් Numerical Operations වලට පදනම දාන්නේ NumPy.

2. NumPy: Numerical Computing වලට පදනම

NumPy කියන්නේ Numerical Python කියන එකේ කෙටි යෙදුම. මේක Python වල තියෙන open-source library එකක්, විශේෂයෙන්ම විශාල, බහු-මාන Arrays (multi-dimensional arrays) සහ matrices එක්ක වැඩ කරන්න නිර්මාණය කරලා තියෙන්නේ. Data Science වලදී සංඛ්‍යාත්මක දත්ත (numerical data) කියන්නේ අනිවාර්ය දෙයක්. NumPy මේ සංඛ්‍යාත්මක දත්ත ගබඩා කරන්නත්, ඒවා මත වේගවත්ව Operations කරන්නත් අවශ්‍ය කරන ප්‍රධානම මෙවලම සපයනවා.

Python Lists වලට වඩා NumPy Arrays හොඳ ඇයි?

Python වල තියෙන සාමාන්‍ය Lists වලටත් Data ගබඩා කරන්න පුළුවන්නේ, එහෙනම් NumPy Array එකක් ඕන මොකටද කියලා ඔබට හිතෙන්න පුළුවන්. මෙන්න ඒකට හේතු කීපයක්:

• වේගය (Speed): NumPy Arrays C Language වලින් implement කරලා තියෙන නිසා Python Lists වලට වඩා වේගවත්ව ක්‍රියාත්මක වෙනවා, විශේෂයෙන් ලොකු Data ප්‍රමාණයක් එක්ක වැඩ කරනකොට.
• Memory Efficiency: NumPy Arrays Data ගබඩා කරන්නේ වඩාත් කාර්යක්ෂමව, Python Lists වලට වඩා අඩු මතකයක් (memory) භාවිතා කරමින්.
• ක්‍රියාකාරීත්වය (Functionality): NumPy වල Arrays මත කෙලින්ම කරන්න පුළුවන් Mathematical Operations (ගණිතමය ක්‍රියාවන්) සහ Functions ගොඩක් තියෙනවා (Vectorized Operations). Python Lists වල මේවා කෙලින්ම කරන්න අමාරුයි, Loops භාවිතා කරන්න වෙනවා.

NumPy Arrays හදමු! (Let's Create NumPy Arrays!)

මුලින්ම අපි NumPy library එක අපේ Python Code එකට import කරගන්න ඕනේ. සාමාන්‍යයෙන් මේකට භාවිතා කරන්නේ np කියන alias එක.

import numpy as np

දැන් අපි බලමු NumPy Array එකක් හදන්නේ කොහොමද කියලා. Python List එකක් NumPy Array එකක් බවට පත් කරන්න පුළුවන්.

1D Array එකක් (Vector) හදන හැටි:

# Python list එකක්
py_list = [1, 2, 3, 4, 5]
print(f"Python List: {py_list}")

# NumPy Array එකක්
numpy_array_1d = np.array(py_list)
print(f"NumPy 1D Array: {numpy_array_1d}")
print(f"Array වර්ගය: {type(numpy_array_1d)}")
print(f"Array වල හැඩය (Shape): {numpy_array_1d.shape}") # (5,) කියන්නේ element 5ක් තියෙන 1D Array එකක් කියලා

Output:

Python List: [1, 2, 3, 4, 5]
NumPy 1D Array: [1 2 3 4 5]
Array වර්ගය: <class 'numpy.ndarray'>
Array වල හැඩය (Shape): (5,)

2D Array එකක් (Matrix) හදන හැටි:

# Python lists වලින් හැදුනු list එකක්
py_list_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# NumPy 2D Array එකක්
numpy_array_2d = np.array(py_list_2d)
print(f"\nNumPy 2D Array:\n{numpy_array_2d}")
print(f"Array වල හැඩය (Shape): {numpy_array_2d.shape}") # (3, 3) කියන්නේ පේළි 3ක් සහ තීරු 3ක් තියෙන Matrix එකක් කියලා

Output:

NumPy 2D Array:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Array වල හැඩය (Shape): (3, 3)

NumPy වලින්ම Arrays හදන Methods:

හිස් Arrays, බිංදු වලින් පිරුණු Arrays, එකේ ඉලක්කම් වලින් පිරුණු Arrays වගේ දේවල් හදන්නත් NumPy වල පහසු Methods තියෙනවා.

# බිංදු වලින් පිරුණු Array එකක්
zeros_array = np.zeros((2, 4)) # පේළි 2ක්, තීරු 4ක්
print(f"\nZeros Array:\n{zeros_array}")

# එකේ ඉලක්කම් වලින් පිරුණු Array එකක්
ones_array = np.ones((3, 3))
print(f"\nOnes Array:\n{ones_array}")

# අනුපිළිවෙලින් අංක (Range) සහිත Array එකක්
range_array = np.arange(0, 10, 2) # 0 ඉඳන් 10ට (10 නැතුව) 2න් 2ට
print(f"\nRange Array: {range_array}")

# නිශ්චිත පරාසයක් තුල සමාන පරතරයකින් යුත් අගයන් සහිත Array එකක්
linspace_array = np.linspace(0, 1, 5) # 0 ඉඳන් 1ට (1ත් එක්ක) සමාන පරතරයකින් අගයන් 5ක්
print(f"\nLinspace Array: {linspace_array}")

Output:

Zeros Array:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]

Ones Array:
[[1. 1. 1.]
 [1. 1. 1.]]

Range Array: [0 2 4 6 8]

Linspace Array: [0.   0.25 0.5  0.75 1.  ]

3. Array Operations: බලය අත්විඳිමු!

NumPy වල ප්‍රධානම වාසියක් තමයි Vectorized Operations. මේකෙන් වෙන්නේ Loops භාවිතා කරන්නේ නැතුව Array එකක තියෙන හැම element එකක්ම එක පාර ගණනය කරන්න පුළුවන් වීම. මේකෙන් Code එක සරල වෙනවා වගේම, වේගයත් වැඩි වෙනවා.

Vectorized Operations (Vectorization)

අපි හිතමු අපිට Array එකක තියෙන හැම අගයකටම 10ක් එකතු කරන්න ඕනේ කියලා. සාමාන්‍ය Python List එකක නම් අපිට Loop එකක් භාවිතා කරන්න වෙනවා.

py_list = [1, 2, 3]
new_list = []
for x in py_list:
    new_list.append(x + 10)
print(f"Python List Operation: {new_list}")

Output:

Python List Operation: [11, 12, 13]

නමුත් NumPy Array එකක නම් අපිට මේක කෙලින්ම කරන්න පුළුවන්:

numpy_array = np.array([1, 2, 3])
result_array = numpy_array + 10
print(f"NumPy Array Operation: {result_array}")

Output:

NumPy Array Operation: [11 12 13]

දැක්ක නේද? කොයි තරම් සරලද කියලා. මේ වගේම අනෙක් ගණිතමය ක්‍රියා (-, *, /, **) වගේ දේවලුත් කෙලින්ම කරන්න පුළුවන්.

මූලික ගණිතමය ක්‍රියා (Basic Arithmetic Operations):

array1 = np.array([10, 20, 30, 40])
array2 = np.array([1, 2, 3, 4])

# එකතු කිරීම
print(f"Addition: {array1 + array2}")

# අඩු කිරීම
print(f"Subtraction: {array1 - array2}")

# ගුණ කිරීම (Element-wise multiplication)
print(f"Multiplication: {array1 * array2}")

# බෙදීම
print(f"Division: {array1 / array2}")

# වර්ග මූලය (Square root) - NumPy function එකක්
print(f"Square Root of array1: {np.sqrt(array1)}")

Output:

Addition: [11 22 33 44]
Subtraction: [ 9 18 27 36]
Multiplication: [ 10  40  90 160]
Division: [10. 10. 10. 10.]
Square Root of array1: [3.16227766 4.47213595 5.47722558 6.32455532]

ප්‍රමාණයන් සංසන්දනය කිරීම සහ Boolean Indexing (Comparison and Boolean Indexing):

data = np.array([10, 5, 20, 15, 30])

# 15ට වඩා වැඩි අගයන් හොයමු
over_15 = data > 15
print(f"Over 15 (Boolean Array): {over_15}")

# ඒ අගයන් විතරක් තෝරාගනිමු (Boolean Indexing)
filtered_data = data[over_15]
print(f"Filtered Data (over 15): {filtered_data}")

Output:

Over 15 (Boolean Array): [False False  True  True  True]
Filtered Data (over 15): [20 15 30]

දැන් ඔබ අහන්න පුළුවන් filtered_data වල 15 තියෙන්නේ කොහොමද කියලා. හොඳට බලන්න, data > 15 කියන එකේ ප්‍රතිඵලය තමයි [False False True False True]. ඉතින් data[over_15] කියන එකෙන් data array එකේ True තියෙන තැන් වල අගයන් විතරක් තෝරාගන්නවා. මම කලින් උදාහරණයෙන් පොඩි වැරැද්දක් කරලා තියෙනවා, ඒක නිවැරදි කරන්නම් data >= 15 කියලා.

data = np.array([10, 5, 20, 15, 30])

# 15 හෝ ඊට වැඩි අගයන් හොයමු
over_or_equal_15 = data >= 15
print(f"Over or Equal 15 (Boolean Array): {over_or_equal_15}")

# ඒ අගයන් විතරක් තෝරාගනිමු (Boolean Indexing)
filtered_data_corrected = data[over_or_equal_15]
print(f"Filtered Data (over or equal 15): {filtered_data_corrected}")

Output:

Over or Equal 15 (Boolean Array): [False False  True  True  True]
Filtered Data (over or equal 15): [20 15 30]

හරි, දැන් ඒක හරි! මෙතනදී 15 ඇතුළත් වෙන්නේ True වෙච්ච නිසා.

Array Slicing and Indexing

Python Lists වල වගේම NumPy Arrays වලත් අපිට අවශ්‍ය කොටස් තෝරාගන්න පුළුවන්. මේකට Indexing සහ Slicing භාවිතා කරනවා.

my_array = np.array([10, 20, 30, 40, 50, 60, 70])

# පළමු element එක (index 0)
print(f"First element: {my_array[0]}")

# තුන්වෙනි element එක (index 2)
print(f"Third element: {my_array[2]}")

# 2 ඉඳන් 5 වෙනකන් (5 ඇතුළත් නැහැ)
print(f"Elements from index 2 to 4: {my_array[2:5]}")

# මුල ඉඳන් 3 වෙනකන් (3 ඇතුළත් නැහැ)
print(f"Elements from start to index 2: {my_array[:3]}")

# 4 ඉඳන් අන්තිම වෙනකන්
print(f"Elements from index 4 to end: {my_array[4:]}")

# පියවරක් (step) එක්ක (මුල ඉඳන් අන්තිම වෙනකන්, 2න් 2ට)
print(f"Every other element: {my_array[::2]}")

Output:

First element: 10
Third element: 30
Elements from index 2 to 4: [30 40 50]
Elements from start to index 2: [10 20 30]
Elements from index 4 to end: [50 60 70]
Every other element: [10 30 50 70]

2D Arrays වල Slicing තව ටිකක් වෙනස්. ඒකේදී පේළි සහ තීරු දෙකම සඳහන් කරන්න වෙනවා.

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

# සම්පූර්ණ matrix එක
print(f"Matrix:\n{matrix}")

# දෙවෙනි පේළිය (index 1)
print(f"\nSecond row: {matrix[1]}")

# දෙවෙනි තීරුව (සියලුම පේළි, දෙවෙනි තීරුව)
print(f"\nSecond column: {matrix[:, 1]}")

# පළමු පේළියේ පළමු element එක
print(f"\nElement at (0, 0): {matrix[0, 0]}") # matrix[row_index, col_index]

# පළමු පේළියේ 2වෙනි සහ 3වෙනි element (index 1, 2)
print(f"\nFirst row, elements 1 to 2: {matrix[0, 1:]}")

# පළමු පේළි 2, පළමු තීරු 2
print(f"\nFirst two rows and columns (Sub-matrix):\n{matrix[:2, :2]}")

Output:

Matrix:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

Second row: [4 5 6]

Second column: [2 5 8]

Element at (0, 0): 1

First row, elements 1 to 2: [2 3]

First two rows and columns (Sub-matrix):
[[1 2]
 [4 5]]

හැඩය වෙනස් කරමු: Reshaping Arrays (Changing Shape: Reshaping Arrays)

සමහර වෙලාවට අපිට තියෙන Data Array එකක Shape එක වෙනස් කරන්න අවශ්‍ය වෙනවා. උදාහරණයක් විදියට, 1D Array එකක් 2D Matrix එකක් බවට පත් කරන්න හෝ ඒක අනෙක් පැත්තට කරන්න. මේකට reshape() කියන method එක භාවිතා කරනවා.

data_1d = np.arange(1, 13) # 1 සිට 12 දක්වා අංක (12 ඇතුළත් නැත)
print(f"Original 1D array: {data_1d}")
print(f"Original shape: {data_1d.shape}")

# 1D array එකක් 3x4 (පේළි 3ක්, තීරු 4ක්) matrix එකක් බවට පත් කිරීම
matrix_3x4 = data_1d.reshape(3, 4)
print(f"\nReshaped 3x4 matrix:\n{matrix_3x4}")
print(f"New shape: {matrix_3x4.shape}")

# 1D array එකක් 2x6 matrix එකක් බවට පත් කිරීම
matrix_2x6 = data_1d.reshape(2, 6)
print(f"\nReshaped 2x6 matrix:\n{matrix_2x6}")
print(f"New shape: {matrix_2x6.shape}")

# -1 භාවිතා කිරීම: NumPy ට ඉඩ දීමෙන් auto-calculate කිරීමට
# පේළි 4ක් තියෙන්න ඕනේ, තීරු ගණන NumPy ට හොයාගන්න දෙමු
matrix_4_auto = data_1d.reshape(4, -1)
print(f"\nReshaped 4x Auto matrix:\n{matrix_4_auto}")
print(f"New shape: {matrix_4_auto.shape}")

# Auto-calculate the rows
matrix_auto_3 = data_1d.reshape(-1, 3)
print(f"\nReshaped Auto x 3 matrix:\n{matrix_auto_3}")
print(f"New shape: {matrix_auto_3.shape}")

Output:

Original 1D array: [ 1  2  3  4  5  6  7  8  9 10 11 12]
Original shape: (12,)

Reshaped 3x4 matrix:
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
New shape: (3, 4)

Reshaped 2x6 matrix:
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]
New shape: (2, 6)

Reshaped 4x Auto matrix:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
New shape: (4, 3)

Reshaped Auto x 3 matrix:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
New shape: (4, 3)

reshape() භාවිතා කරනකොට මතක තියාගන්න ඕනේ, අලුත් Array එකේ Total elements ගණන මුල් Array එකේ Total elements ගණනට සමාන වෙන්න ඕනේ. (උදා: elements 12ක් තියෙන Array එකක් 3x4 matrix එකක් කරන්න පුළුවන්, මොකද 3 * 4 = 12.)

4. ප්‍රායෝගික උපදෙස් සහ හොඳ පුරුදු (Practical Tips and Best Practices)

NumPy එක්ක වැඩ කරනකොට අපි අවධානය යොමු කරන්න ඕනේ කරුණු කීපයක් තියෙනවා. මේවා ඔබට ගැටලු මඟහරවා ගන්නත්, ඔබේ Code එක වඩාත් කාර්යක්ෂම කර ගන්නත් උදව් වෙයි.

Shape Mismatches: පොදු ගැටලුවක් (A Common Problem)

NumPy Arrays එක්ක ගණිතමය ක්‍රියා කරනකොට Arrays වල Shape එක (හැඩය) ගැළපෙන්න ඕනේ. නැත්නම් ValueError: operands could not be broadcast together වගේ Error එකක් එන්න පුළුවන්. මේක හඳුන්වන්නේ Broadcasting කියලා. NumPy වලදී එකිනෙකට වෙනස් Shape තියෙන Arrays මත Operations කරන්න පුළුවන්, හැබැයි ඒකට යම් නීති රීති තියෙනවා.

array_a = np.array([1, 2, 3]) # shape (3,)
array_b = np.array([4, 5])   # shape (2,)

# මේක වැරදියි, Error එකක් එනවා:
# print(array_a + array_b)

# Error message එකක් මෙහෙම වෙන්න පුළුවන්:
# ValueError: operands could not be broadcast together with shapes (3,) (2,)

මේ Error එක මඟහරවා ගන්න, ඔබ Operations කරන Arrays වල Shape එක සමාන දැයි .shape attribute එකෙන් පරීක්ෂා කරගන්න.

array_c = np.array([1, 2, 3])
array_d = np.array([10, 20, 30])

print(f"Shape of array_c: {array_c.shape}") # Output: (3,)
print(f"Shape of array_d: {array_d.shape}") # Output: (3,)

# දැන් මේවා එකට එකතු කරන්න පුළුවන්
print(f"Result of addition: {array_c + array_d}")

Output:

Shape of array_c: (3,)
Shape of array_d: (3,)
Result of addition: [11 22 33]

විශාල Arrays වල Memory Efficiency

NumPy Arrays Python Lists වලට වඩා Memory කාර්යක්ෂමයි කියලා අපි කලින් කතා කළා. මේක විශේෂයෙන්ම වැදගත් වෙන්නේ විශාල Data sets එක්ක වැඩ කරනකොට. Data Science වලදී terabytes ගණන් Data එක්ක වැඩ කරන්න සිද්ධ වෙන්න පුළුවන්. ඒ වගේ වෙලාවට NumPy වගේ optimized library එකක් භාවිතා කරන එක අනිවාර්යයි.

තව දෙයක් තමයි, NumPy Operations කරනකොට සමහර වෙලාවට මුල් Array එකේ copy එකක් හදනවා. මේක මතක තබා ගන්න. විශාල Arrays එක්ක වැඩ කරනකොට අනවශ්‍ය ලෙස copies හැදෙන එක මඟහරවා ගැනීමෙන් memory සහ processor කාලය ඉතිරි කරගන්න පුළුවන්. .copy() method එක භාවිතා කරන්නේ ඔබට Array එකේ වෙනම copy එකක් අවශ්‍ය නම් විතරයි.

Vectorize Operations for Performance: රහස!

NumPy වල උපරිම ප්‍රයෝජන ගන්න නම්, හැම විටම Vectorized Operations භාවිතා කරන්න උත්සාහ කරන්න. Python Loops භාවිතා කරනවාට වඩා NumPy වලටම ආවේණික functions (np.sum(), np.mean(), np.max(), np.min(), np.std() වගේ) භාවිතා කිරීමෙන් ඔබේ Code එකේ වේගය සැලකිය යුතු ලෙස වැඩි කරගන්න පුළුවන්.

large_array = np.arange(1, 1000001) # ලොකු Array එකක් (මිලියනයක් elements)

# NumPy function එකක් භාවිතා කරලා එකතුව හොයමු
%timeit np.sum(large_array)

# Python loop එකක් භාවිතා කරලා එකතුව හොයමු (සැසඳීම සඳහා)
# %timeit sum(large_array) # මේක ගොඩක් වෙලා යන නිසා comment කරලා තියෙන්නේ. NumPy එකට වඩා ගොඩක් පස්සේ.

Output (ආසන්න වශයෙන්):

257 µs ± 7.91 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
# For sum(large_array) it would be in milliseconds, much slower

%timeit කියන්නේ Jupyter Notebooks වලදී Code එකක් ක්‍රියාත්මක වෙන්න කොච්චර වෙලාවක් යනවද කියලා බලන්න භාවිතා කරන Magic Command එකක්. උදාහරණයෙන් පේනවා නේද NumPy කොච්චර වේගවත්ද කියලා? ඒ නිසා, පුළුවන් හැම වෙලාවකම NumPy වල Built-in functions භාවිතා කරන්න පුරුදු වෙන්න.

අවසානයට: Data Science ගමනට සුබ පැතුම්!

ඉතින් යාළුවනේ, මේ Tutorial එකෙන් අපි Data Science කියන්නේ මොකක්ද කියන එකෙන් පටන් අරන්, ඒකට පදනම වන Python වල NumPy Library එක ගැන විස්තරාත්මකව කතා කළා. NumPy Arrays හදන හැටි, ඒවා මත ගණිතමය ක්‍රියා (Vectorized Operations) කරන හැටි, Slicing, Indexing, සහ Reshaping වගේ වැදගත් දේවල් අපි ඉගෙන ගත්තා. ඒ වගේම, Shape Mismatches වගේ පොදු ගැටලු මඟහරවා ගන්නත්, හොඳම කාර්යක්ෂමතාව ලබාගන්න Vectorized Operations භාවිතා කරන්නත් අපි උපදෙස් ලබාගත්තා.

මේක ඔබේ Data Science ගමනේ පළමු පියවර විතරයි. NumPy කියන්නේ මේ ගමනේදී ඔබට නැතුවම බැරි Tool එකක්. මේක හොඳින් තේරුම් ගත්තා නම්, Pandas, Matplotlib, Scikit-learn වගේ අනෙක් වැදගත් Libraries ඉගෙන ගන්න එක ඔබට ගොඩක් පහසු වෙයි.

මේ Tutorial එකේ තියෙන Code Snippets ඔබම ඔබේ Python Environment එකේ හෝ Google Colab, Jupyter Notebook වගේ තැනක Run කරලා බලන්න. අත්දැකීමෙන් ඉගෙන ගන්න එක තමයි හොඳම දේ. ඔබට මේ ගැන තියෙන ප්‍රශ්න, අදහස්, හෝ අත්දැකීම් පහළින් Comment Section එකේ Share කරන්න. අපි ඊළඟ Tutorial එකකින් නැවත හමුවෙමු!

ඔබේ Data Science ගමනට ජය!