By Thisara Priyamal — 23 Aug 2025

AI සහ LLM සඳහා Python මූලික කරුණු | සිංහල මාර්ගෝපදේශය

ආයුබෝවන් යාළුවනේ!

අද කාලේ, Artificial Intelligence (AI) සහ Large Language Models (LLMs) කියන වචන නිතරම ඇහෙනවා නේද? මේවා අනාගතය වෙනස් කරනවා කියලා අපි හැමෝම දන්නවා. ඒත් මේ වගේ දේවල් වලට අඩිතාලම දාගන්නෙ කොහොමද කියලා ඔයාලා කල්පනා කරනවා ඇති. ඉතින්, මේ AI ලෝකයට පිවිසෙන්න හොඳම ආරම්භය තමයි Python Programming Language එක ඉගෙන ගන්න එක!

Python කියන්නේ සරල, කියවීමට පහසු, ඒ වගේම ගොඩක් බලවත් Programming Language එකක්. විශේෂයෙන්ම Data Science, Machine Learning සහ AI ක්ෂේත්‍රවල Python තමයි රජු. ඇයි ඒ? මොකද, මේ ක්ෂේත්‍ර වලට අවශ්‍ය කරන Libraries සහ Frameworks ගොඩක් Python වලට තියෙනවා. ඒ වගේම, ආරම්භකයින්ටත් පහසුවෙන් ඉගෙන ගන්න පුළුවන් විදියට Python නිර්මාණය වෙලා තියෙනවා.

මේ Guide එකෙන් අපි Python Programming වල මූලික කරුණු සිංහලෙන් සරලව කතා කරනවා. ඔයාලට Python ගැන කිසිම දැනුමක් නැති වුණත්, මේක අවසාන වෙනකොට AI සහ LLMs වලට අවශ්‍ය වෙන මූලික Python දැනුම ඔයාලට ලැබෙයි. අපි මෙහිදී Python Syntax, Data Structures, Functions, Object-Oriented Programming (OOP) වගේම AI වලට Python වැදගත් වෙන්නේ ඇයි කියලත් කතා කරනවා.

එහෙනම්, අපි පටන් ගමුද?

1. Python මූලික කරුණු (Python Fundamentals)

Python ඉගෙන ගන්න කලින්, ඔයාලගේ පරිගණකයට Python Install කරගන්න ඕනේ. ඒකට Python.org නිල වෙබ් අඩවියට ගිහින් අලුත්ම Version එක Download කරගන්න පුළුවන්. Install කරනකොට, "Add Python to PATH" කියන Option එකට ටික් එකක් දාන්න අමතක කරන්න එපා. ඒකෙන් ඔයාලට Command Line එකෙන් Python Run කරන්න පුළුවන් වෙනවා.

Variables සහ Data Types

Programming වලදී අපි දත්ත ගබඩා කරන්න Variables පාවිච්චි කරනවා. Variable එකක් කියන්නේ දත්ත ටිකක් තියාගන්න පුළුවන් නමක් තියෙන Container එකක් වගේ දෙයක්. Python වලදී Variable එකක් හදන්න ගොඩක් සරලයි, Data Type එක specify කරන්න ඕනෙත් නැහැ.

Python වල පොදුවේ පාවිච්චි කරන Data Types කිහිපයක් මෙන්න:

Integers (int): සම්පූර්ණ සංඛ්‍යා (උදා: 10, -5, 0)
Floating-point Numbers (float): දශම සංඛ්‍යා (උදා: 3.14, 0.5, -2.7)
Strings (str): අකුරු, වචන, වාක්‍ය (උදා: "Hello", 'Python is fun')
Booleans (bool): True හෝ False කියන Logical අගයන් (උදා: True, False)

උදාහරණය: Variables සහ Data Types

# Variable එකක් හදලා Integer අගයක් දානවා
age = 30
print(age) # Output: 30

# Floating-point number එකක්
price = 19.99
print(price) # Output: 19.99

# String එකක්
name = "Kasun"
print(name) # Output: Kasun

# Boolean අගයක්
is_student = True
print(is_student) # Output: True

# Variable වල Data Type එක බලන්න පුළුවන් `type()` function එකෙන්
print(type(age)) # Output: <class 'int'>
print(type(name)) # Output: <class 'str'>

Operators (ගණිත කර්ම සහ සංසන්දන)

Operators කියන්නේ Variables හෝ Values මත Operations කරන්න පාවිච්චි කරන Symbols. Python වල ප්‍රධාන Operator වර්ග කිහිපයක් තියෙනවා:

Arithmetic Operators: +, -, *, /, %, //, ** (கூட்டல், கழித்தல், பெருக்கல், බෙදීම, ඉතිරිය, පූර්ණ බෙදීම, බලය)
Comparison Operators: ==, !=, >, <, >=, <= (සමානද, අසමානද, වඩා විශාලද, වඩා කුඩාද, ආදිය)
Logical Operators: and, or, not (තර්කානුකූල කර්ම)

උදාහරණය: Operators

# Arithmetic Operators
a = 10
b = 3
print(a + b)  # Output: 13
print(a / b)  # Output: 3.3333333333333335
print(a % b)  # Output: 1 (ඉතිරිය)

# Comparison Operators
x = 5
y = 10
print(x == y) # Output: False
print(x < y)  # Output: True

# Logical Operators
is_sunny = True
is_weekend = False
print(is_sunny and is_weekend) # Output: False (දෙකම True නම් විතරයි True)
print(is_sunny or is_weekend)  # Output: True (එකක් True වුණත් True)
print(not is_sunny)          # Output: False (අගය පෙරලනවා)

Control Flow (වැඩසටහන් ගලායාම පාලනය කිරීම)

Programs සාමාන්‍යයෙන් ඉහල සිට පහලට Line by Line Execute වෙනවා. නමුත් සමහර වෙලාවට අපිට තීරණ ගන්න, නැත්නම් යම්කිසි Code Block එකක් නැවත නැවත Run කරන්න ඕනේ වෙනවා. ඒකට අපි Control Flow Statements පාවිච්චි කරනවා.

if-elif-else Statements: මේවා Condition එකක් මත පදනම් වෙලා Code Execute කරන්න පාවිච්චි කරනවා.
for Loops: එකතුවක (List, String, Range) තියෙන සෑම Element එකක්ම Iteration කරන්න පාවිච්චි කරනවා.
while Loops: යම්කිසි Condition එකක් True වෙනකම් Code Block එකක් නැවත නැවත Run කරන්න පාවිච්චි කරනවා.

උදාහරණය: Control Flow

# if-elif-else Statement
score = 85

if score >= 90:
    print("ඔයාට A එකක්! නියමයි!")
elif score >= 75:
    print("ඔයාට B එකක්! හොඳට කරා!")
elif score >= 50:
    print("ඔයාට C එකක්! තවත් මහන්සි වෙන්න!")
else:
    print("සමාවෙන්න, ඔයා අසමත්. ඊළඟ වතාවේ බලමු!")

# for Loop
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"මම කන්න ආසයි {fruit}!")
# Output:
# මම කන්න ආසයි apple!
# මම කන්න ආසයි banana!
# මම කන්න ආසයි cherry!

# while Loop
count = 0
while count < 5:
    print(f"Count එක {count}යි.")
    count += 1 # count = count + 1 වගේමයි
# Output:
# Count එක 0යි.
# Count එක 1යි.
# Count එක 2යි.
# Count එක 3යි.
# Count එක 4යි.

2. Python Data Structures (දත්ත ව්‍යුහයන්)

Python වල දත්ත effectively ගබඩා කරන්න සහ Organize කරන්න විවිධ Data Structures තියෙනවා. මේවා Python Programming වලට අත්‍යවශ්‍යයි. AI සහ LLMs වලදී විශාල දත්ත ප්‍රමාණයක් එක්ක වැඩ කරනකොට මේවා හරියට පාවිච්චි කරන එක ගොඩක් වැදගත්.

Lists (ලැයිස්තු)

Lists කියන්නේ Python වල වැඩියෙන්ම පාවිච්චි කරන Data Structure එකක්. මේවා Ordered Collection එකක්, ඒ කියන්නේ Elements එකතු කරන පිලිවෙලටමයි තියෙන්නේ. Lists වල තියෙන විශේෂත්වය තමයි Mutable වීම, ඒ කියන්නේ හදපු පස්සේ වුණත් Elements වෙනස් කරන්න, අලුතින් එකතු කරන්න, අයින් කරන්න පුළුවන්. ඒ වගේම එක List එකක විවිධ Data Types වල Elements තියාගන්නත් පුළුවන්.

උදාහරණය: Lists

# List එකක් හදනවා
my_list = [1, 2, 3, "apple", True]
print(my_list) # Output: [1, 2, 3, 'apple', True]

# Element එකකට Access කරනවා (Index 0 ඉඳන් පටන් ගන්නවා)
print(my_list[0]) # Output: 1
print(my_list[3]) # Output: apple

# List එකකට Element එකක් Add කරනවා
my_list.append("banana")
print(my_list) # Output: [1, 2, 3, 'apple', True, 'banana']

# List එකකින් Element එකක් අයින් කරනවා
my_list.remove(2)
print(my_list) # Output: [1, 3, 'apple', True, 'banana']

# Element එකක් වෙනස් කරනවා
my_list[1] = 100
print(my_list) # Output: [1, 100, 'apple', True, 'banana']

Tuples (ටියුපල්)

Tuples Lists වලට ගොඩක් සමානයි, ඒ වුණත් ප්‍රධාන වෙනසක් තියෙනවා: Tuples Immutable. ඒ කියන්නේ Tuple එකක් හැදුවට පස්සේ ඒක ඇතුලේ තියෙන Elements වෙනස් කරන්න, Add කරන්න, Remove කරන්න බැහැ. Tuples සාමාන්‍යයෙන් පාවිච්චි කරන්නේ Data Collection එකක් වෙනස් වෙන්නේ නැහැ කියලා sure නම් (උදා: Point coordinates (x, y)).

උදාහරණය: Tuples

# Tuple එකක් හදනවා
my_tuple = (10, 20, "hello")
print(my_tuple) # Output: (10, 20, 'hello')

# Element එකකට Access කරනවා
print(my_tuple[0]) # Output: 10

# Tuple එකක Element එකක් වෙනස් කරන්න හැදුවොත් Error එකක් එනවා
# my_tuple[0] = 5  # This would raise a TypeError

Dictionaries (ශබ්දකෝෂ)

Dictionaries කියන්නේ Key-Value Pairs විදියට Data ගබඩා කරන Data Structure එකක්. මේවා Unordered Collection එකක්, ඒ කියන්නේ Elements වලට පිලිවෙලක් නැහැ (Python 3.7න් පස්සේ Insertion Order එක මතක තියාගන්නවා). සෑම Key එකක්ම Unique වෙන්න ඕනේ, ඒ වගේම ඒ Key එකට අදාළ Value එකක් තියෙනවා. මේවා Real-world Objects නිරූපණය කරන්න ගොඩක් හොඳයි.

උදාහරණය: Dictionaries

# Dictionary එකක් හදනවා
person = {
    "name": "Nimal",
    "age": 25,
    "city": "Colombo"
}
print(person) # Output: {'name': 'Nimal', 'age': 25, 'city': 'Colombo'}

# Key එකක් පාවිච්චි කරලා Value එකකට Access කරනවා
print(person["name"]) # Output: Nimal

# අලුත් Key-Value Pair එකක් Add කරනවා
person["occupation"] = "Engineer"
print(person) # Output: {'name': 'Nimal', 'age': 25, 'city': 'Colombo', 'occupation': 'Engineer'}

# පවතින Value එකක් වෙනස් කරනවා
person["age"] = 26
print(person) # Output: {'name': 'Nimal', 'age': 26, 'city': 'Colombo', 'occupation': 'Engineer'}

Sets (කට්ටල)

Sets කියන්නේ Unique Elements Collection එකක්. ඒ කියන්නේ Set එකක් ඇතුලේ එකම Element එක දෙපාරක් තියාගන්න බැහැ. Sets වලට පිලිවෙලක් නැහැ (Unordered). මේවා සාමාන්‍යයෙන් පාවිච්චි කරන්නේ Collection එකකින් Duplicate Elements අයින් කරන්න, නැත්නම් දෙකක් අතර Common Elements හොයන්න වගේ දේවල් වලට.

උදාහරණය: Sets

# Set එකක් හදනවා
my_set = {1, 2, 3, 2, 1, 4}
print(my_set) # Output: {1, 2, 3, 4} (Duplicate values අයින් වෙලා)

# Set එකකට Element එකක් Add කරනවා
my_set.add(5)
print(my_set) # Output: {1, 2, 3, 4, 5}

# Sets අතර Operations
set_a = {1, 2, 3}
set_b = {3, 4, 5}

# Union (දෙකේම තියෙනවා)
print(set_a.union(set_b))        # Output: {1, 2, 3, 4, 5}

# Intersection (දෙකටම පොදු)
print(set_a.intersection(set_b)) # Output: {3}

3. Functions (කාර්යයන්) සහ Code Reusability

අපි Programs ලියනකොට එකම Code Block එක නැවත නැවත ලියන්න වෙන අවස්ථා එනවා. මේ වගේ අවස්ථා වලදී අපි Functions පාවිච්චි කරනවා. Function එකක් කියන්නේ යම්කිසි කාර්යයක් (Task) ඉටු කරන්න ලියපු Code Block එකක්. Functions වලින් අපේ Code එක Modular, Readability වැඩි, සහ Maintain කරන්න පහසු වෙනවා.

Functions නිර්මාණය කිරීම (Defining Functions)

Python වල Function එකක් හදන්නේ def Keyword එක පාවිච්චි කරලා. Function එකකට Parameters (Inputs) දෙන්න පුළුවන්, ඒ වගේම Return Value එකක් (Output) දෙන්නත් පුළුවන්.

උදාහරණය: Functions

# Parameters නැති සරල Function එකක්
def greet():
    print("ආයුබෝවන්, Python ලෝකයට සාදරයෙන් පිළිගනිමු!")

# Function එක Call කරනවා (Run කරනවා)
greet()
# Output: ආයුබෝවන්, Python ලෝකයට සාදරයෙන් පිළිගනිමු!

# Parameters තියෙන Function එකක්
def greet_person(name):
    print(f"ආයුබෝවන්, {name}! අද වැඩ කොහොමද?")

greet_person("අනුර")
# Output: ආයුබෝවන්, අනුර! අද වැඩ කොහොමද?

# Return Value එකක් තියෙන Function එකක්
def add_numbers(num1, num2):
    total = num1 + num2
    return total # Function එකේ Output එක විදියට total එක දෙනවා

result = add_numbers(10, 5)
print(result) # Output: 15

def calculate_grade(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    else:
        return "C"

student_grade = calculate_grade(88)
print(f"ශිෂ්‍යයාගේ ශ්‍රේණිය: {student_grade}")
# Output: ශිෂ්‍යයාගේ ශ්‍රේණිය: B

Parameters සහ Arguments

Parameters: Function එක Define කරනකොට අපි දෙන Names (name, num1, num2 වගේ).
Arguments: Function එක Call කරනකොට අපි දෙන Actual Values ("අනුර", 10, 5 වගේ).

අපිට Default Parameters පාවිච්චි කරන්නත් පුළුවන්. ඒ කියන්නේ Argument එකක් නොදුන්නොත් Function එකේ Parameter එකට Default Value එකක් පාවිච්චි කරනවා.

def display_message(message, sender="Unknown"):
    print(f"{sender} වෙතින්: {message}")

display_message("අපි AI ඉගෙන ගමු!", "සුනිල්")
# Output: සුනිල් වෙතින්: අපි AI ඉගෙන ගමු!
display_message("සුභ දවසක්!")
# Output: Unknown වෙතින්: සුභ දවසක්! (sender එකට default value එක ආවා)

4. Object-Oriented Programming (OOP) මූලික කරුණු

Object-Oriented Programming (OOP) කියන්නේ Programming Paradigm එකක්. ඒ කියන්නේ Program එකක් Design කරන විදියක්. Python OOP Concept වලට හොඳට Support කරනවා. OOP වලදී අපි Real-world Objects වගේ Entities විදියට Programs හදන්න බලනවා.

OOP වල ප්‍රධානම Concepts දෙක තමයි Classes සහ Objects.

Classes සහ Objects

Class: Class එකක් කියන්නේ Object එකක් හදන්න පාවිච්චි කරන Blueprint එකක් නැත්නම් Template එකක්. ඒකේ Object එකක තියෙන්න ඕනේ Attributes (Data) මොනවද, Methods (Functions) මොනවද කියලා Define කරනවා.
Object: Object එකක් කියන්නේ Class එකකින් හදපු Actual Instance එකක්. Class එක Blueprint එක නම්, Object එක තමයි ඒ Blueprint එකෙන් හදපු Actual Building එක.

උදාහරණය: Classes සහ Objects

# Class එකක් Define කරනවා - අපි "Car" කියන Class එකක් හදමු
class Car:
    # __init__ කියන්නේ Constructor එක. Object එකක් හදනකොට මේක Run වෙනවා.
    # self කියන්නේ Object එකම refer කරනවා.
    def __init__(self, brand, model, year):
        self.brand = brand   # Attributes
        self.model = model
        self.year = year
        self.speed = 0 # Default speed එක 0

    # Method එකක් - Car එකට කරන්න පුළුවන් දේවල්
    def accelerate(self, increment):
        self.speed += increment
        print(f"{self.brand} {self.model} දැන් වේගය {self.speed} km/h.")

    def brake(self, decrement):
        self.speed -= decrement
        if self.speed < 0:
            self.speed = 0
        print(f"{self.brand} {self.model} දැන් වේගය {self.speed} km/h.")

    def display_info(self):
        print(f"Brand: {self.brand}, Model: {self.model}, Year: {self.year}, Current Speed: {self.speed} km/h")

# Class එකෙන් Objects හදනවා (Instances)
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Honda", "Civic", 2022)

# Objects වල Attributes වලට Access කරනවා
print(car1.brand) # Output: Toyota
print(car2.model) # Output: Civic

# Objects වල Methods Call කරනවා
car1.accelerate(50)
# Output: Toyota Corolla දැන් වේගය 50 km/h.
car1.display_info()
# Output: Brand: Toyota, Model: Corolla, Year: 2020, Current Speed: 50 km/h

car2.accelerate(70)
car2.brake(20)
# Output: Honda Civic දැන් වේගය 70 km/h.
# Output: Honda Civic දැන් වේගය 50 km/h.
car2.display_info()
# Output: Brand: Honda, Model: Civic, Year: 2022, Current Speed: 50 km/h

මේ උදාහරණයෙන් ඔයාලට පේනවා ඇති Class එකක් (Car) කියන්නේ Blueprints එකක් වගේ, ඒකෙන් අපි Objects දෙකක් (car1, car2) හැදුවා. මේ සෑම Object එකකටම තමන්ගේම Attributes (brand, model, year, speed) සහ කරන්න පුළුවන් Methods (accelerate, brake, display_info) තියෙනවා.

5. AI සහ LLM සඳහා Python පරිසර පද්ධතිය (Python Ecosystem for AI)

AI සහ LLMs වලට Python ඇයි මෙච්චර ජනප්‍රිය කියලා දැන් අපි පොඩ්ඩක් බලමු. Python වල තියෙන සරල බව, කියවීමට පහසු වීම, ඒ වගේම විශාල Libraries සහ Frameworks ප්‍රමාණයක් AI ක්ෂේත්‍රයේ දියුණුවට ගොඩක් දායක වෙලා තියෙනවා.

Python ඇයි AI වලට මෙච්චර හොඳ?

සරල බව සහ කියවීමේ හැකියාව (Simplicity and Readability): Python Code කියවන්න සහ තේරුම් ගන්න ගොඩක් පහසුයි. ඒකෙන් Developer ලාට ඉක්මනින් Models හදන්න සහ Test කරන්න පුළුවන්.
විශාල Library ප්‍රමාණයක් (Rich Ecosystem of Libraries): AI, Machine Learning, Data Science වලට අවශ්‍ය කරන Libraries දහස් ගණනක් Python වලට තියෙනවා. මේවා නිසා අපිට රෝදය නැවත හදන්න (Reinvent the wheel) ඕනේ නැහැ.
විශාල Community Support එකක් (Strong Community Support): Python වලට ලොකු Developer Community එකක් තියෙනවා. ඒ නිසා ඔයාලට ප්‍රශ්නයක් ආවොත් උදව් හොයාගන්න ලේසියි.
Frameworks සහ Tools (Frameworks and Tools): Deep Learning Frameworks වන TensorFlow, PyTorch වගේම NLP (Natural Language Processing) වලට Hugging Face Transformers වගේ දේවල් Python එක්ක හොඳට වැඩ කරනවා.

ප්‍රධාන Libraries (Key Libraries)

AI සහ LLM ක්ෂේත්‍රයේදී ඔයාලට හම්බවෙන ප්‍රධාන Python Libraries කිහිපයක් මෙන්න:

NumPy: සංඛ්‍යාත්මක ගණනය කිරීම් (Numerical computations) සඳහා. විශාල, බහු-මාන Arrays සහ Matrices සමඟ කාර්යක්ෂමව වැඩ කරන්න මේක අත්‍යවශ්‍යයි.
Pandas: දත්ත විශ්ලේෂණය සහ හැසිරවීම (Data manipulation and analysis) සඳහා. DataFrames කියන Data Structure එක හරහා අපිට Spreadsheet වගේ දත්ත එක්ක වැඩ කරන්න පුළුවන්.
Matplotlib / Seaborn: දත්ත දෘශ්‍යකරණය (Data visualization) සඳහා. Graphs, Charts වගේ දේවල් හදලා දත්ත තේරුම් ගන්න මේවා පාවිච්චි කරනවා.
Scikit-learn: Machine Learning Algorithms (classification, regression, clustering) ක්‍රියාත්මක කරන්න. මේක Beginner-friendly Library එකක්.
TensorFlow / PyTorch: Deep Learning සහ Neural Networks හදන්න පාවිච්චි කරන බලවත් Frameworks.
Hugging Face Transformers: විශේෂයෙන්ම LLMs සහ NLP Applications හදන්න පාවිච්චි කරන Library එකක්. ChatGPT වගේ Models වලට පදනම දාන්නේ මේ වගේ Frameworks.

උදාහරණය: AI Libraries (සරල දළ විශ්ලේෂණයක්)

import numpy as np
import pandas as pd

# NumPy: Array එකක් හදනවා
np_array = np.array([1, 2, 3, 4, 5])
print("NumPy Array:", np_array)
# Output: NumPy Array: [1 2 3 4 5]

# Pandas: Data Series එකක් හදනවා
pd_series = pd.Series(["apple", "banana", "cherry"])
print("\nPandas Series:", pd_series)
# Output:
# Pandas Series:
# 0     apple
# 1    banana
# 2    cherry
# dtype: object

# මේවා තමයි AI වලට අවශ්‍ය Data Handling වලට මූලිකම දේවල්.
# TensorFlow/PyTorch වගේ ඒවා ගොඩක් Complex, ඒ නිසා මේකෙන් පස්සේ ඒවා ඉගෙන ගන්න.

අවසන් වශයෙන් (Conclusion)

ඉතින් යාළුවනේ, මේ Guide එකෙන් අපි Python Programming වල මූලික කරුණු බොහොමයක් ආවරණය කළා. අපි Python Syntax වල ඉඳලා Data Structures, Functions, Object-Oriented Programming දක්වාම කතා කළා. ඒ වගේම, AI සහ LLMs වලට Python මෙච්චර වැදගත් වෙන්නේ ඇයි කියලත්, ඒකට පාවිච්චි කරන ප්‍රධාන Libraries මොනවද කියලත් ඔයාලට අදහසක් ලැබෙන්න ඇති.

AI ලෝකය කියන්නේ විශාල ක්ෂේත්‍රයක්, ඒත් Python කියන්නේ ඒකට පිවිසෙන්න තියෙන හොඳම දොරටුව. මේ මූලික දැනුමෙන් ඔයාලට ඕනෑම AI Project එකක් පටන් ගන්න හොඳ හැකියාවක් ලැබෙනවා.

මතක තියාගන්න, Programming කියන්නේ නිතරම Practice කරන්න ඕනේ දෙයක්. මේ Guide එකේ තියෙන Code Examples ඔයාලගේම පරිගණකයේ Run කරලා බලන්න. පොඩි පොඩි Programs හදන්න උත්සාහ කරන්න. අලුත් Libraries ගැන හොයලා බලන්න. ඊළඟට NumPy, Pandas වගේ Libraries ටිකක් ගැඹුරින් ඉගෙන ගන්න, ඊට පස්සේ Scikit-learn, TensorFlow, PyTorch වගේ දේවල් ගැන බලන්න.

ඔයාලගේ Python ගමනට සුභ පතනවා! මේ ගැන තව මොනවා හරි දැනගන්න ඕන නම්, නැත්නම් ඔයාලගේ අත්දැකීම් කොහොමද කියලා පහලින් Comment කරන්න. අපි කතා කරමු!

ජය වේවා!