4: വേരിയബിളുകളും ഡാറ്റാ തരങ്ങളും

ഇതുവരെ നമ്മൾ മൂല്യങ്ങൾ നേരിട്ട് പ്രിന്റ് ചെയ്തു. യഥാർത്ഥ പ്രോഗ്രാമുകളിൽ, ഒരു മൂല്യം സൂക്ഷിച്ചു വെച്ച് പിന്നീട് പലയിടത്തും ഉപയോഗിക്കേണ്ടി വരും. ഇതിനാണ് വേരിയബിളുകൾ.

ഒരു വേരിയബിൾ കമ്പ്യൂട്ടറിന് എന്താണ്?

കമ്പ്യൂട്ടറിന്റെ മെമ്മറി ഒരുപാട് ചെറിയ ബോക്സുകൾ ചേർന്നതാണ് എന്ന് സങ്കൽപ്പിക്കുക. ഒരു മൂല്യം സൂക്ഷിക്കണമെങ്കിൽ, ആദ്യം അതിനുവേണ്ടി ഒരു ബോക്സ് ഉണ്ടാക്കണം (ഇതിനെ ഡിക്ലയർ ചെയ്യുക എന്ന് പറയുന്നു), എന്നിട്ട് അതിലേക്ക് മൂല്യം വെക്കണം (ഇതിനെ അസൈൻ ചെയ്യുക എന്ന് പറയുന്നു).

C പോലുള്ള ഭാഷകളിൽ ഇത് രണ്ട് വെവ്വേറെ ഘട്ടങ്ങളാണ്:

// C
int age;    // ഘട്ടം 1: 'age' എന്ന പേരിൽ ഒരു ബോക്സ് ഡിക്ലയർ ചെയ്യുന്നു
age = 25;   // ഘട്ടം 2: ആ ബോക്സിലേക്ക് 25 എന്ന മൂല്യം അസൈൻ ചെയ്യുന്നു

int എന്നത് ഈ ബോക്സിൽ എപ്പോഴും ഒരു പൂർണ്ണസംഖ്യ മാത്രമേ വെക്കാവൂ എന്ന് കമ്പ്യൂട്ടറിനോട് നേരത്തേ പറയുന്നു. അതനുസരിച്ച് കൃത്യമായ വലുപ്പമുള്ള മെമ്മറി അത് നീക്കിവെക്കുന്നു.

പൈത്തണിൽ ഇത് ഒറ്റ വരിയിൽ ചെയ്യാം:

age = 25   # ഡിക്ലയർ ചെയ്യലും അസൈൻ ചെയ്യലും ഒരുമിച്ച്
print(age)

പൈത്തൺ ഇവിടെ ഒരു പ്രത്യേക ബോക്സ് മുൻകൂട്ടി ഡിക്ലയർ ചെയ്യുന്നില്ല. പകരം, age എന്ന പേര് ഒരു ലേബൽ പോലെ, 25 എന്ന മൂല്യത്തിലേക്ക് ഒട്ടിക്കുന്നു. അതുകൊണ്ടാണ് പൈത്തണിൽ ഏത് തരം മൂല്യത്തിനും മുൻകൂട്ടി ഒരു type പറയേണ്ടി വരാത്തത് — ലേബൽ ഏത് മൂല്യത്തിലും ഒട്ടിക്കാം.

വേരിയബിൾ നാമകരണ നിയമങ്ങൾ

  • ഒരു അക്ഷരം അല്ലെങ്കിൽ _ ഉപയോഗിച്ച് തുടങ്ങണം
  • നമ്പർ വെച്ച് തുടങ്ങരുത്
  • അക്ഷരങ്ങൾ, നമ്പറുകൾ, _ എന്നിവ മാത്രമേ ഉപയോഗിക്കാവൂ
  • പൈത്തൺ കീവേഡുകൾ (if, for, print പോലുള്ളവ) പേരായി ഉപയോഗിക്കരുത്
  • പൈത്തൺ കേസ്-സെൻസിറ്റീവ് ആണ് — age, Age, AGE ഇവ മൂന്നും വ്യത്യസ്ത വേരിയബിളുകളാണ്
name = "Ravi"
age_1 = 20
_total = 100
print(name, age_1, _total)

പൊതുവായ ഡാറ്റാ തരങ്ങൾ

ഒരു വേരിയബിളിൽ എന്ത് തരം മൂല്യമാണ് ഉള്ളത് എന്ന് പറയുന്നതാണ് അതിന്റെ ഡാറ്റാ തരം.

തരംഎന്ത്ഉദാഹരണം
intപൂർണ്ണസംഖ്യage = 25
floatദശാംശ സംഖ്യprice = 49.99
strടെക്സ്റ്റ്name = "Anu"
boolTrue അല്ലെങ്കിൽ Falseis_active = True
age = 25
price = 49.99
name = "Anu"
is_active = True

print(age, price, name, is_active)

ഡാറ്റാ തരം പരിശോധിക്കുന്നു

type() ഉപയോഗിച്ച് ഒരു വേരിയബിളിന്റെ ഡാറ്റാ തരം കണ്ടെത്താം.

x = 10
print(type(x))

name = "Python"
print(type(name))

വേരിയബിൾ മൂല്യം മാറ്റുന്നു

ഒരു വേരിയബിളിന്റെ മൂല്യം എപ്പോൾ വേണമെങ്കിലും മാറ്റാം — ലേബൽ വേറൊരു മൂല്യത്തിലേക്ക് മാറ്റി ഒട്ടിക്കുന്നു എന്ന് ചിന്തിക്കാം.

score = 10
print(score)

score = 20
print(score)

C-യിൽ age എന്ന ബോക്സിന് int എന്ന് ഒരിക്കൽ പറഞ്ഞാൽ, എപ്പോഴും അതിൽ പൂർണ്ണസംഖ്യ മാത്രമേ വെക്കാനാവൂ. പൈത്തണിൽ ഇത് നിർബന്ധമില്ല — ഒരേ പേരിന് ആദ്യം ഒരു സംഖ്യയും പിന്നീട് ഒരു ടെക്സ്റ്റും അസൈൻ ചെയ്യാം.

value = 25
print(type(value))

value = "twenty-five"
print(type(value))

സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ

  • = ചിഹ്നം ഇടാൻ മറക്കുന്നു
  • സംഖ്യകൾക്ക് ചുറ്റും ഉദ്ധരണി ചിഹ്നം ഇടുന്നു (ഇത് അവയെ ടെക്സ്റ്റ് ആക്കി മാറ്റും)
  • കേസ് ശ്രദ്ധിക്കാതെ വേരിയബിൾ പേര് ഉപയോഗിക്കുന്നു (Age ഉം age ഉം വ്യത്യസ്തമാണ്)

ഈ അധ്യായത്തിന്റെ സംഗ്രഹം

  • വേരിയബിൾ എന്താണെന്നും, കമ്പ്യൂട്ടർ മെമ്മറിയിൽ എന്ത് സംഭവിക്കുന്നു എന്നും മനസ്സിലാക്കി
  • C-യിലെ ഡിക്ലയർ+അസൈൻ ഘട്ടങ്ങളും പൈത്തണിന്റെ ഒറ്റ-വരി രീതിയും താരതമ്യം ചെയ്തു
  • വേരിയബിൾ നാമകരണ നിയമങ്ങൾ പഠിച്ചു
  • int, float, str, bool എന്നീ ഡാറ്റാ തരങ്ങൾ പഠിച്ചു
  • type() ഉപയോഗിച്ച് ഡാറ്റാ തരം പരിശോധിച്ചു
  • വേരിയബിൾ മൂല്യം മാറ്റി

വ്യായാമങ്ങൾ

  • city എന്ന പേരിൽ ഒരു വേരിയബിളിൽ നിങ്ങളുടെ നാട്ടിന്റെ പേര് സൂക്ഷിച്ച് പ്രിന്റ് ചെയ്യുക
  • int, float, str, bool എന്നീ നാല് തരത്തിലുള്ള ഓരോ വേരിയബിളും സൃഷ്ടിച്ച്, ഓരോന്നിന്റെയും type() പ്രിന്റ് ചെയ്യുക
  • ഒരു വേരിയബിളിന് ആദ്യം ഒരു സംഖ്യയും, പിന്നീട് ഒരു ടെക്സ്റ്റ് മൂല്യവും അസൈൻ ചെയ്ത്, രണ്ട് തവണയും type() പ്രിന്റ് ചെയ്ത് വ്യത്യാസം കാണുക

Quiz & Self Assessment

ചോദ്യം 1 / 3
C-യിൽ ഒരു വേരിയബിൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ് എന്ത് ചെയ്യണം?

അടുത്ത അധ്യായത്തിൽ, ടെക്സ്റ്റ് ഡാറ്റാ തരമായ സ്ട്രിംഗുകളെ കുറിച്ച് കൂടുതൽ വിശദമായി പഠിക്കും.