Python Variables සහ Data Types - මූලික සංකල්ප | SC Guide

කොහොමද යාලුවනේ?

Python කියන්නේ මේ දවස් වල ලෝකේ පුරාම ගොඩක් ජනප්‍රිය වෙලා තියෙන Programming Language එකක්. Data Science, Web Development, Automation වගේ ගොඩක් දේවල් වලට මේක පාවිච්චි කරනවා. Python වල තියෙන ලොකුම වාසියක් තමයි, මේක ඉගෙන ගන්න හරිම ලේසියි. ඒ වගේම Code කරනකොට ගොඩක් ෆන් එකක් වගේ දැනෙනවා. හැබැයි ඕනම Programming Language එකක් ඉගෙන ගන්න කලින් අපිට අත්‍යවශ්‍ය මූලික සංකල්ප ටිකක් තියෙනවා.

අද අපි කතා කරන්න යන්නේ Python වල තියෙන Variables සහ Data Types ගැනයි. මේ දෙක තේරුම් ගැනීම ඕනම Python Programer කෙනෙක්ට අනිවාර්යයි. මේක හරියට කඩේකට ගිහින් බඩු ගේනවා වගේ වැඩක්. අපි ගේන බඩු බෑග් එකක දාගෙන එනවනේ. ඒ වගේම තමයි අපේ Programs ඇතුලේ අපි පාවිච්චි කරන දත්ත (data) ගබඩා කරගන්නත් අපිට තැනක් ඕනේ. අන්න ඒකට තමයි Variables කියන දේ පාවිච්චි කරන්නේ. ඒ දත්ත මොන වගේ ඒවාද (සංඛ්‍යාද, අකුරුද, True/False ද) කියන එක තමයි Data Types වලින් කියන්නේ.

එහෙනම් අපි බලමු මේවා හරියටම වැඩ කරන්නේ කොහොමද කියලා.

Variables - දත්ත තැන්පත් කරන පෙට්ටි (Boxes for Data)

සරලවම කිව්වොත්, Variable එකක් කියන්නේ අපිට මොකක් හරි දත්තයක් (data) තැන්පත් කරලා තියාගන්න පුළුවන් නමක් තියෙන තැනක්. මේක හිතන්න පුළුවන් පොඩි පෙට්ටියක් වගේ. අපි ඒ පෙට්ටියට නමක් දාලා (උදාහරණයක් විදිහට "නම" කියලා) ඒ ඇතුලට අපිට ඕන දත්තයක් දානවා (උදාහරණයක් විදිහට "කමල්" කියලා).

Python වල Variable එකක් හදන්න හරිම සරලයි. ඔයාට කරන්න තියෙන්නේ නමක් දීලා = (assignment operator) එකෙන් ඒකට අගයක් (value) දෙන එක විතරයි. Python වල විශේෂ දෙයක් තමයි අපි Variable එකක් හදනකොට ඒකේ Data Type එක මොකක්ද කියලා කියන්න ඕන නෑ. Python බුද්ධිමත්වම ඒක හඳුනාගන්නවා. මේකට කියන්නේ Dynamic Typing කියලා.

Variable එකක් හදන හැටි:

උදාහරණයක් විදිහට බලමු:

# String (පාඨයක්) Variable එකක්
my_name = "සුනිල්"

# Integer (පූර්ණ සංඛ්‍යාවක්) Variable එකක්
my_age = 25

# Float (දශම සංඛ්‍යාවක්) Variable එකක්
my_height = 5.8

# Boolean (සත්‍ය/අසත්‍ය) Variable එකක්
is_student = True

print(my_name)      # Output: සුනිල්
print(my_age)       # Output: 25
print(my_height)    # Output: 5.8
print(is_student)   # Output: True

මේ Code එකේ අපි my_name, my_age, my_height, is_student කියන Variables හතර හැදුවා. ඒ වගේම ඒවාට අදාළ දත්ත දුන්නා. print() function එකෙන් අපිට ඒ Variables වල තියෙන අගයන් මොනවද කියලා බලාගන්න පුළුවන්.

Data Types - දත්ත වල ස්වභාවය (Nature of Data)

දැන් අපි කතා කරමු Data Types ගැන. Python වල දත්ත ගබඩා කරගන්න පුළුවන් විවිධ ආකාර තියෙනවා. අපි දන්නවානේ සංඛ්‍යා, අකුරු, සත්‍ය/අසත්‍ය වගේ දේවල් තියෙනවා කියලා. Python මේ දේවල් හඳුනාගන්නේ Data Types විදිහටයි.

Python වල බහුලවම පාවිච්චි වෙන මූලික Data Types ටිකක් මෙන්න:

• int (Integer): මේකෙන් පූර්ණ සංඛ්‍යා (whole numbers) ගබඩා කරනවා. දශම නැති සංඛ්‍යා - 10, -5, 1000 වගේ.
• float (Floating-point number): මේකෙන් දශම සංඛ්‍යා ගබඩා කරනවා. 3.14, 0.001, -2.5 වගේ.
• str (String): මේකෙන් අකුරු, වචන, වාක්‍ය වගේ පාඨමය දත්ත ගබඩා කරනවා. මේවා ' ' (single quotes) හෝ " " (double quotes) ඇතුලේ ලියන්න ඕනේ. උදාහරණ: "Hello World", 'Python is fun!', "ලංකාව".
• bool (Boolean): මේකෙන් ගබඩා කරන්නේ True (සත්‍ය) හෝ False (අසත්‍ය) කියන අගයන් දෙකෙන් එකක් විතරයි. මේවා තීරණ ගන්න (decision making) ගොඩක් වැදගත් වෙනවා.

Variable එකක Data Type එක මොකක්ද කියලා දැනගන්න අපිට type() කියන built-in function එක පාවිච්චි කරන්න පුළුවන්.

num1 = 10
num2 = 20.5
text = "Hello Python"
is_valid = False

print(f"num1 ගේ Type එක: {type(num1)}")    # Output: num1 ගේ Type එක: <class 'int'>
print(f"num2 ගේ Type එක: {type(num2)}")    # Output: num2 ගේ Type එක: <class 'float'>
print(f"text ගේ Type එක: {type(text)}")    # Output: text ගේ Type එක: <class 'str'>
print(f"is_valid ගේ Type එක: {type(is_valid)}") # Output: is_valid ගේ Type එක: <class 'bool'>

Operations and Type Conversion - දත්ත සමග සෙල්ලම් කරමු! (Let's Play with Data!)

දැන් අපි බලමු මේ Data Types එකිනෙකා එක්ක වැඩ කරන හැටි සහ එක Data Type එකක් තව Data Type එකකට වෙනස් කරන හැටි (Type Conversion) ගැන.

මූලික ගණිත කටයුතු (Basic Arithmetic Operations):

Numbers (int සහ float) එක්ක අපිට සාමාන්‍ය ගණිත කටයුතු කරන්න පුළුවන්:

• + (Addition / එකතු කිරීම)
• - (Subtraction / අඩු කිරීම)
• * (Multiplication / වැඩි කිරීම)
• / (Division / බෙදීම - මේකෙන් හැමවිටම float එකක් තමයි ලැබෙන්නේ)
• // (Integer Division / පූර්ණ සංඛ්‍යා බෙදීම - දශම නැතිව පූර්ණ සංඛ්‍යා කොටස විතරක් ලැබෙනවා)
• % (Modulo / ඉතිරි - බෙදූ විට ඉතිරි වන ප්‍රමාණය)
• ** (Exponentiation / බලය - ඝාතකය)

a = 15
b = 4

print(f"a + b = {a + b}")   # Output: a + b = 19
print(f"a - b = {a - b}")   # Output: a - b = 11
print(f"a * b = {a * b}")   # Output: a * b = 60
print(f"a / b = {a / b}")   # Output: a / b = 3.75 (float)
print(f"a // b = {a // b}") # Output: a // b = 3 (integer)
print(f"a % b = {a % b}")   # Output: a % b = 3 (15 = 4*3 + 3)
print(f"a ** 2 = {a ** 2}") # Output: a ** 2 = 225 (15*15)

Strings එකතු කිරීම (String Concatenation):

Strings වලටත් + operator එක පාවිච්චි කරන්න පුළුවන්. මේකට කියන්නේ String Concatenation කියලා. මේකෙන් වෙන්නේ Strings දෙකක් එකට එකතු වෙන එකයි.

first_name = "නලින්"
last_name = "පෙරේරා"
full_name = first_name + " " + last_name
print(full_name) # Output: නලින් පෙරේරා

greeting = "ආයුබෝවන්"
name = "නිමාෂා"
message = greeting + ", " + name + "!"
print(message)   # Output: ආයුබෝවන්, නිමාෂා!

Type Conversion (Casting):

සමහර වෙලාවට අපිට එක Data Type එකක් තව Data Type එකකට මාරු කරන්න වෙනවා. උදාහරණයක් විදිහට, අපි KeyBoard එකෙන් Input එකක් ගත්තොත්, ඒක හැමවිටම String එකක් විදිහට තමයි Python වලට ලැබෙන්නේ. ඒත් අපිට ඒක සංඛ්‍යාවක් විදිහට ගණනය කරන්න නම්, String එක Integer එකකට හෝ Float එකකට මාරු කරන්න වෙනවා.

මේකට Python වල Built-in Functions තියෙනවා:

• int(value): Value එක Integer එකකට මාරු කරයි.
• float(value): Value එක Float එකකට මාරු කරයි.
• str(value): Value එක String එකකට මාරු කරයි.
• bool(value): Value එක Boolean එකකට මාරු කරයි.

# String එකක් Integer එකකට
num_str = "123"
num_int = int(num_str)
print(f"String to int: {num_int}, Type: {type(num_int)}") # Output: String to int: 123, Type: <class 'int'>

# Float එකක් Integer එකකට (දශම කොටස කැපී යනවා)
float_val = 3.99
int_val = int(float_val)
print(f"Float to int: {int_val}, Type: {type(int_val)}") # Output: Float to int: 3, Type: <class 'int'>

# Integer එකක් String එකකට
int_to_str = str(500)
print(f"Int to string: {int_to_str}, Type: {type(int_to_str)}") # Output: Int to string: 500, Type: <class 'str'>

# String එකක් Float එකකට
price_str = "49.99"
price_float = float(price_str)
print(f"String to float: {price_float}, Type: {type(price_float)}") # Output: String to float: 49.99, Type: <class 'float'>

# 0, හිස් String, None වගේ දේවල් False වෙනවා. අනිත් ඔක්කොම True වෙනවා
print(f"bool(0): {bool(0)}")        # Output: bool(0): False
print(f"bool(10): {bool(10)}")      # Output: bool(10): True
print(f"bool(''): {bool('')}")      # Output: bool(''): False
print(f"bool('හලෝ'): {bool('හලෝ')}") # Output: bool('හලෝ'): True

සැලකිය යුතුයි: ඔයාට හැම String එකක්ම Number එකකට Convert කරන්න බෑ. Number එකක් විදිහට Convert කරන්න පුළුවන් String එකක අනිවාර්යයෙන්ම සංඛ්‍යාත්මක අගයක් විතරක් අඩංගු වෙන්න ඕනේ. උදාහරණයක් විදිහට int("හලෝ") කියලා දුන්නොත් Python එකට ඒක Integer එකක් විදිහට තේරුම් ගන්න බෑ. එතකොට ValueError එකක් එනවා.

Troubleshooting and Best Practices - ගැටලු සහ හොඳ පුරුදු (Problems and Good Habits)

Programming කරනකොට වැරදි (errors) එන එක සාමාන්‍ය දෙයක්. වැදගත් වෙන්නේ ඒ වැරදි මොනවද කියලා තේරුම් අරන් ඒවා හදාගන්න එක. ඒ වගේම හොඳට Code ලියන්න පුරුදු වීමත් වැදගත්.

TypeError - Data Types අතර ගැටුම්:

Python වල ගොඩක් වෙලාවට එන Error එකක් තමයි TypeError කියන්නේ. මේක එන්නේ අපි එකිනෙකට නොගැලපෙන Data Types දෙකක් එක්ක Operation එකක් කරන්න ගියොත්. උදාහරණයක් විදිහට, Number එකක් සහ String එකක් එකතු කරන්න හැදුවොත්.

my_number = 10
my_text = "අවුරුදු"

# මේකෙන් TypeError එකක් එනවා!
# result = my_number + my_text
# print(result)

මේක Run කළොත් මෙහෙම Error එකක් එනවා:

TypeError: unsupported operand type(s) for +: 'int' and 'str'

මේකෙන් කියන්නේ int (Integer) එකක් සහ str (String) එකක් + operator එකෙන් එකතු කරන්න බෑ කියලයි. මේක හදාගන්න නම්, අපි String එක Number එකකට Convert කරන්න ඕනේ, නැත්නම් Number එක String එකකට Convert කරන්න ඕනේ. අපේ උදාහරණයට නම්, Number එක String එකකට Convert කරන එක තමා හොඳම.

my_number = 10
my_text = "අවුරුදු"

# Number එක String එකකට Convert කරලා එකතු කරනවා
result = str(my_number) + " " + my_text
print(result) # Output: 10 අවුරුදු

Variable වල අගයන් Debug කරන හැටි:

ඔයාගේ Program එකේ Variable වල මොන අගයද තියෙන්නේ කියලා දැනගන්න ඕන නම්, print() function එක තමයි හොඳම යාළුවා. Code එකේ විවිධ තැන් වලට print() statements දාලා Variable එකක අගය ඒ මොහොතේ මොකක්ද කියලා බලාගන්න පුළුවන්. ටිකක් දියුණු Program කරනකොට IDE (Integrated Development Environment) වල තියෙන Debuggers පාවිච්චි කරන්න පුළුවන්. ඒත් මුලින් print() වලින් පටන් ගන්න එක හොඳයි.

Variable Names වල හොඳ පුරුදු (Best Practices for Variable Naming):

හොඳ Programmer කෙනෙක් වෙනවා නම්, Variable වලට නම් දානකොට හොඳ පුරුදු ටිකක් පාවිච්චි කරන්න ඕනේ. මේකෙන් ඔයාගේ Code එක අනිත් අයට තේරුම් ගන්න ලේසි වෙනවා, ඒ වගේම ඔයාටම පස්සේ බලනකොටත් ලේසියි.

• තේරුමක් තියෙන නම් දෙන්න: x = 10 කියන එකට වඩා student_age = 10 කියන එකෙන් ඒ Variable එක මොකටද කියලා පැහැදිලි වෙනවා.
• Lowercase සහ Underscores: Variable names සාමාන්‍යයෙන් පොඩි අකුරුවලින් ලියනවා (lowercase). වචන දෙකක් හෝ වැඩි ගණනක් තියෙනවා නම් ඒවා අතර _ (underscore) එකක් දාන්න (මේකට කියන්නේ snake_case කියලා). උදාහරණ: user_name, total_price.
• අකුරකින් හෝ Underscore එකකින් පටන් ගන්න: Variable names අංකයකින් පටන් ගන්න බෑ. 1_student_name වගේ.
• Keywords පාවිච්චි කරන්න එපා: Python වල තියෙන if, for, while, print වගේ Keywords Variable Names විදිහට පාවිච්චි කරන්න එපා.

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

Python Program කරනකොට Variables සහ Data Types කියන්නේ Programming ගොඩනැගිල්ලේ තියෙන අඩිතාලම වගේ. මේවා ගැන හොඳ අවබෝධයක් නැතුව අපිට සංකීර්ණ Programs ලියන්න බෑ. අද අපි කතා කළා Variables මොනවද, ඒවාට Data දාන්නේ කොහොමද, විවිධ Data Types මොනවද, ඒවා අතර Operations කරන්නේ කොහොමද, ඒ වගේම Type Conversion සහ Error Fix කරන හැටි වගේම හොඳ Programming පුරුදු ගැනත්.

දැන් ඔයාට පුළුවන් පොඩි පොඩි program ලියන්න, Variables හදලා, ඒවට Data දාලා, ඒවට Type Convert කරලා බලන්න. මතක තියාගන්න, Programming කියන්නේ ප්‍රායෝගිකව කරනකොට තමා හොඳටම ඉගෙන ගන්න පුළුවන්. ඒ නිසා මේවා ඔයාගේ Computer එකේ Try කරලා බලන්න.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න, යෝජනා තියෙනවා නම් පහලින් comment කරන්න. ඊළඟ ලිපියෙන් තවත් වැදගත් Python සංකල්පයක් ගැන කතා කරමු. එතකන් හැමෝටම ජය!