അടിസ്ഥാനപരമായ കാര്യങ്ങള്‍

ഹലോ വേള്‍ഡ് എന്ന് എഴുതിയതുകൊണ്ട് മാത്രം കാര്യമായില്ല അല്ലേ ? അതിനേക്കാൾ കൂടുതൽ ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. ഇന്‍പുട്ട് സ്വീകരിക്കുന്നതും അതില്‍ നിന്ന് ഒരു ഔട്പുട്ട് ഉണ്ടാക്കുവാന്‍ സാധിക്കുന്നവ. സ്ഥിരാങ്കങ്ങളും (constants) ചരങ്ങള്‍(വേരിയബിളുകളും) ഉപയോഗിച്ച് നമുക്ക് പൈത്തണിൽ ഇത് നേടാൻ കഴിയും, കൂടാതെ മറ്റ് ചില ആശയങ്ങളും ഈ അധ്യായത്തിൽ നിന്ന് പഠിക്കും.

കമെന്‍സ് (comments)

# ചിഹ്നത്തിന്റെ വലതുവശത്തുള്ള ഏത് വാചകവും പ്രധാനമായും നിങ്ങളുടെ പ്രോഗ്രാം റീഡറിനുള്ള (വായിക്കുന്ന) കുറിപ്പുകളാണ് .

ഉദാ:

print('hello world') # Note that print is a function

അല്ലെങ്കില്‍

# Note that print is a function
print('hello world')

നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിങ്ങൾക്ക് കഴിയുന്നത്ര ഉപയോഗപ്രദമായ കമെന്‍സ് (അഭിപ്രായങ്ങൾ/കുറിപ്പുകള്‍) ഉപയോഗിക്കുക:

ഒരു കോഡ് വായിച്ചാല്‍ (പ്രോഗ്രാമിലെ എക്സിക്യൂട്ടാകുന്ന വരികള്‍) നിങ്ങള്‍ എങ്ങനെ ഒരു ലോജിക്ക് എഴുതി എന്ന് മനസ്സിലാക്കാം , എന്നാല്‍ കമെന്‍സ് (അഭിപ്രായങ്ങൾ/കുറിപ്പുകള്‍) നിങ്ങള്‍ എന്തിന് ആ കോഡ് എഴുതി എന്ന് മറ്റൊരാള്‍ക്ക് മനസ്സിലാകുന്നതിനു വേണ്ടിയാണ്.

നിങ്ങളുടെ പ്രോഗ്രാം വായിക്കുന്നവർക്ക് ഇത് ഉപയോഗപ്രദമാകുന്നതിനാൽ പ്രോഗ്രാം എന്താണ് ചെയ്യുന്നതെന്ന് അവർക്ക് എളുപ്പത്തിൽ മനസ്സിലാക്കാൻ കഴിയും. ഓർക്കുക, ആ വ്യക്തിക്ക് ആറുമാസത്തിനുശേഷം നിങ്ങൾ സ്വയം ആകാം!

ലിറ്ററല്‍ കോന്‍സ്റ്റന്‍സ് ( പ്രോഗ്രാമിലെ സ്ഥിര വാക്കുകള്‍)

ഏറ്റവും നല്ല ലിറ്ററല്‍ കോന്‍സ്റ്റന്റ് (സ്ഥിര വാക്കുകള്‍/അക്ഷരം) ഉദാഹരണം നമ്പര്‍(അക്കങ്ങള്‍) ആണ് 5, 1.23 അല്ലെങ്കില്‍ ഒരു സ്ട്രിംഗ് (വാക്കുകള്‍) പോലെ 'This is a string'അല്ലെങ്കിൽ "It's a string!".

നിങ്ങൾ അതിന്റെ മൂല്യം അക്ഷരാർത്ഥത്തിൽ ഉപയോഗിക്കുന്നതിനാല്‍ അവയെ ലിറ്ററല്‍ കോന്‍സ്റ്റന്‍സ് എന്ന് വിളിക്കുന്നു. ഉദാ: 2 എന്നതുകൊണ്ടുന്തേശിക്കുന്നത് അതിന്റെ മൂല്യം തന്നെയാണ്. അത് സ്ഥിരമാണ്,_ കാരണം അതിന്റെ മൂല്യം മാറ്റാൻ കഴിയില്ല.

നമ്പേയ്സ് ( അക്കങ്ങള്‍)

സംഖ്യകൾ പ്രധാനമായും രണ്ട് തരത്തിലാണ് - പൂർണ്ണസംഖ്യകളും ഫ്ലോട്ടുകളും. ഒരു പൂർണ്ണ സംഖ്യയുടെ ഒരു ഉദാഹരണം ഒരു പൂർണ്ണ സംഖ്യ 2മാത്രമാണ്.

ഫ്ലോട്ടിംഗ് പോയിൻറ് നമ്പറുകളുടെ ഉദാഹരണങ്ങൾ (അല്ലെങ്കിൽ ഹ്രസ്വമായ ഫ്ലോട്ടുകൾ ഉദാഹരണങ്ങൾ) 3.23 , 52.3E-4 . E ചിഹ്നം സൂചിപ്പിക്കുന്നത് സംഖ്യ 10 ന്റെ ഘാതങ്ങള്‍(powers) ആണെന്നാണ്. 52.3E-4 എന്നെഴുതുന്നത് 52.3 * 10^-4^ സമമാണ്.

പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാർക്കുള്ള കുറിപ്പ് മറ്റു ഭാഷകളില്‍ ഉള്ളതുപോലെ long ടൈപ്പ് പൈത്തനില്‍ ഇല്ല.int ടൈപ്പ് എല്ലാ സംഖ്യകളേയും സൂചിപ്പിക്കുന്നതിനുപയോഗിക്കുന്നത്.

സ്ട്രിംഗുകൾ ( അക്ഷരശൃഖല)

വാക്കുകളുടെ ഒരു ശൃഖല ആണ് സ്ട്രിംഗ് . വാക്കുകളുടെ ഒരു കൂട്ടമാണ് പലപ്പോഴും ഇവ. നിങ്ങള്‍ എഴുതുവാന്‍ പോകുന്ന മുഴുവന്‍ പൈത്തണ്‍ പ്രോഗ്രമിലും ഇവയുണ്ടകുവാന്‍ സാധ്യതയുള്ലതുകൊണ്ട് കൂടുതല്‍ ശ്രദ്ധിക്കേണ്ട ഭാഗമാണ് താഴെ പറയുന്നവ.

ഒരു ഉദ്ധരണി ചിഹ്നത്തിനകത്ത് സ്ട്രിംഗുകൾ നിങ്ങള്‍ക്ക് സ്ട്രിംഗുകൾ ഒരു ഉദ്ധരണിക്കകത്ത് കൊടുക്കാവുന്നതാണ് , 'Quote me on this' ഇതുപോലെ. ഉദാഹരണത്തില്‍ കാണിച്ചിരിക്കുന്നതുപോലെ രണ്ട് വാക്കുകള്‍ക്കിടയിലുള്ള സ്ഥലം(space ) അതുപോലെ നിലനിര്‍ത്തിയിരിക്കുന്നു.

രണ്ട് ഉദ്ധരണിക്കുള്ളിലെ സ്ട്രിംഗുകൾ

സ്ട്രിംഗ് രണ്ട് ഉദ്ധരണികള്‍ക്കുള്ളില്‍ കൊടുക്കുന്നത് ഒരു ഉദ്ധരണികള്‍ക്കുള്ളില്‍ കൊടുക്കുന്നതും ഒരു പോലെ തന്നെയാണ്. ഉദാഹരണത്തിന് : "What's your name?"

മൂന്ന് ഉദ്ധരണിക്കുള്ളിലെ സ്ട്രിംഗുകൾ

നിങ്ങൾ ട്രിപ്പിൾ(മൂന്ന്) ഉദ്ധരണികൾ ഉപയോഗിച്ച് മൾട്ടി-ലൈൻ (ഒന്നില്ലതികം വരികളില്‍) സ്ട്രിങ്ങുകൾ വ്യക്തമാക്കാൻ കഴിയും. (""" അല്ലെങ്കില്‍ ''' ആണ് ഉപയോഗിക്കേണ്ടത്).

'''This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''

സ്ട്രിംഗുകൾ മാറ്റമില്ലാത്തവയാണ്

നിങ്ങൾ ഒരു സ്ട്രിംഗ് തയ്യാറാക്കിയശേഷം അത് മാറ്റാൻ കഴിയില്ല. ഇത് ഒരു മോശം കാര്യം പോലെ തോന്നിയാലും, അതു ശരിക്കും അല്ല. പുസ്തകത്തിന്റെ വരാനിരിക്കുന്ന ഭാഗങ്ങളില്‍ സ്ട്രിംഗുകളില്‍ മാറ്റം വരുത്താന്‍ കഴിയാത്തത് ഒരു പരിമിതിയല്ല എന്ന് നാം കാണും.

സി / സി ++ പ്രോഗ്രാമർമാർക്കുള്ള കുറിപ്പ്

പൈത്തണിൽ char പ്രത്യേക ഡാറ്റാ തരം ഇല്ല . ഇതിന്റെ യഥാർത്ഥ ആവശ്യമില്ല എന്നുള്ളതാണ് സത്യം, നിങ്ങൾക്ക് അത് നഷ്‌ടപ്പെടുന്നതില്‍ നിരാശപ്പെണ്ടേണ്ടി വരത്തില്ല.

പേൾ / പി‌എച്ച്പി പ്രോഗ്രാമർമാർക്കുള്ള കുറിപ്പ്

സിംഗിൾ ഉദ്ധരിച്ച സ്ട്രിങ്ങുകളും ഡബിൾ-ഉദ്ധരിച്ച സ്ട്രിങ്ങുകളും ഒരേ പോലെ ആണെന്ന് ഓർക്കുക.

സ്ട്രിംഗുകൾ ഫോർമാറ്റ് ( രൂപഘടന) ചെയ്യുന്ന രീതി

ചിലപ്പോൾ മറ്റ് വിവരങ്ങളിൽ നിന്ന് സ്ട്രിംഗുകൾ നിർമ്മിക്കാൻ നമ്മള്‍ ആഗ്രഹിച്ചേക്കാം. ഇവിടെയാണ് format()രീതി ഉപയോഗപ്രദമാകുന്നത്.

ഇനിപ്പറയുന്ന വരികൾ ഒരു ഫയലായി സംരക്ഷിക്കുക str_format.py:

age = 20
name = 'Swaroop'

print('{0} was {1} years old when he wrote this book'.format(name, age))
print('Why is {0} playing with that python?'.format(name))

ഔട്ട്പുട്ട്

$ python str_format.py
Swaroop was 20 years old when he wrote this book
Why is Swaroop playing with that python?

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഒരു സ്ട്രിംഗിന് ചില സവിശേഷതകൾ ഉപയോഗിക്കാൻ കഴിയും.format എന്ന ഫക്ഷന്‍ ആ സവിശേഷതകളെ പ്രത്യേകനിര്‍ദ്ദേശം (ആർഗ്യുമെൻറുകൾ ) ഉപയോഗിച്ച് മാറ്റിസ്ഥാപികുകയാണ് ചെയ്യുന്നത്.

ആദ്യ നമ്മള്‍ {0} ഉപയോഗിച്ചത് നിരീക്ഷിക്കുക. ഇത് name എന്ന വേരിയബിളിനോട് യോജിക്കുന്നു. അതുപോലെ, രണ്ടാമത്തെ സവിശേഷ ഫോര്‍മാറ്റായ {1} , age ആർഗ്യുമെന്റുമായി യോജിക്കുന്നു . പൈത്തണില്‍ ആർഗ്യുമെൻറുകൾ എണ്ണിതുടങ്ങുന്നത് ‘ 0 ‘ ല്‍ നിന്നാണ്. അതുകൊണ്ട് ആദ്യ ആർഗ്യുമെന്റിന്റെ സൂചിക 0 യില്‍ ആണ് ആരംഭിക്കുന്നത്.

സ്‌ട്രിംഗ് കോൺകറ്റനേഷൻ ( + ഉപയോഗിച്ച് പരസ്പരം ബന്ധിപ്പിക്കല്‍) ഉപയോഗിച്ച് നമുക്ക് ഇത് നേടാൻ കഴിയുമായിരുന്നു എന്നത് ശ്രദ്ധിക്കുക:

name + ' is ' + str(age) + ' years old'

പക്ഷേ അത് വളരെ പിശകുകള്‍ വരുത്തുവാന്‍ സാധ്യതയുള്ല ഒരു രീതിയാണ്. ഈ രീതിയില്‍ സ്‌ട്രിംഗ് അല്ലാത്ത വേരിയബിള്‍സിനെ നമ്മള്‍ തന്നെ സ്‌ട്രിംഗായി eg: str(age) പരിവര്‍ത്തനം ചെയ്യണം. format ഉപയോഗിക്കുകയാണെങ്കില്‍ നമ്മള്‍ കൂട്ടിചേര്‍ക്കേണ്ട വേരിയബിള്‍സ് എന്തെന്നറിയാതെ തന്നെ ഡീല്‍ ചെയ്യാവുന്നതാണ്.

അക്കങ്ങൾ‌ ഓപ്‌ഷണലാണെന്നതും ശ്രദ്ധിക്കുക, അതിനാൽ‌ നിങ്ങൾ‌ക്കും ഇങ്ങനെ എഴുതാം:

age = 20
name = 'Swaroop'

print('{} was {} years old when he wrote this book'.format(name, age))
print('Why is {} playing with that python?'.format(name))

ഇത് മുമ്പത്തെ പ്രോഗ്രാമിന്റെ അതേ ഔട്ട്പുട്ട് തരും.

നമുക്ക് പാരാമീറ്ററുകൾക്കും ( പാസ് ചെയ്യുന്ന ആര്‍ഗുമെന്റ്) പേര് നൽകാം:

age = 20
name = 'Swaroop'

print('{name} was {age} years old when he wrote this book'.format(name=name, age=age))
print('Why is {name} playing with that python?'.format(name=name))

ഇത് മുമ്പത്തെ പ്രോഗ്രാമിന്റെ അതേ ഔട്ട്പുട്ട് തരും.

പൈത്തൺ 3.6 ല്‍ പേര് കൊടുത്തുള്ല ആര്‍ഗുമെന്റ് പാസ് ചെയ്യാന്‍ ഒരു എളുപ്പമാര്‍ഗ്ഗം ഉണ്ട്.

age = 20
name = 'Swaroop'

print(f'{name} was {age} years old when he wrote this book')  # notice the 'f' before the string
print(f'Why is {name} playing with that python?')  # notice the 'f' before the string

ഇത് മുമ്പത്തെ പ്രോഗ്രാമിന്റെ അതേ ഔട്ട്പുട്ട് തരും. പൈത്തൺ ഈ formatരീതിയിൽ ചെയ്യുന്നത്, അത് ഓരോ ആർഗ്യുമെൻറ് മൂല്യത്തെയും സവിശേഷ സ്ഥാനത്തേയ്ക്ക് മാറ്റിസ്ഥാപിക്കുന്നു എന്നതാണ്. ഇനിപ്പറയുന്നതുപോലുള്ള കൂടുതൽ വിശദമായ കാര്യങ്ങള്‍ ഇതുവഴി ചെയ്യാം.

# decimal (.) precision of 3 for float '0.333'
print('{0:.3f}'.format(1.0/3))
# fill with underscores (_) with the text centered
# (^) to 11 width '___hello___'
print('{0:_^11}'.format('hello'))
# keyword-based 'Swaroop wrote A Byte of Python'
print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))

ഔട്ട്പുട്ട്

0.333
___hello___
Swaroop wrote A Byte of Python

ഫോർ‌മാറ്റിംഗിനെക്കുറിച്ച് ചർച്ച ചെയ്യുന്നതിനാൽ‌, ഇവിടെ ഒരു കാര്യം നിങ്ങളുടെ ശ്രദ്ധയില്‍ പെടുത്താന്‍ ആഗ്രഹിക്കുന്നു. printഎല്ലായ്‌പ്പോഴും അദൃശ്യമായ “പുതിയ ലൈൻ‌” പ്രതീകത്തിൽ‌ ( \n) അവസാനിക്കുന്നു. അതിനാൽ‌ ആവർത്തിച്ചുള്ള കോളുകൾ‌ printഓരോന്നും പ്രത്യേക ലൈനിൽ‌ അച്ചടിക്കും. ഈ പുതിയ ലൈൻ പ്രതീകം അച്ചടിക്കുന്നത് തടയാൻ, end സമം ശൂന്യസ്ഥലം ( ‘ ‘ ) എന്ന് ടൈപ്പ് ചെയ്യണം.

print('a', end='')
print('b', end='')

ഔട്ട്പുട്ട്

ab

അല്ലെങ്കിൽ നിങ്ങൾക്ക് endഒരു ഇടം (space) കീ ഉപയോഗിച്ചും കഴിയും :

a b c

എസ്കേപ്പ് സീക്വൻസുകൾ ( രക്ഷപ്പെടൽ ശ്രേണി കീ )

ഒരൊറ്റ ഉദ്ധരണി ( ') അടങ്ങിയിരിക്കുന്ന ഒരു സ്ട്രിംഗ് നിങ്ങൾക്ക് വേണമെന്ന് കരുതുക, ഈ സ്ട്രിംഗ് നിങ്ങൾ എങ്ങനെ വ്യക്തമാക്കും? ഉദാ: "What's your name?" നിങ്ങൾക്ക് ഇത് 'What's your name?' എന്ന് എഴുതാന്‍ കഴിയില്ല, കാരണം സ്ട്രിംഗ് ആരംഭിക്കുന്നതും അവസാനിക്കുന്നതും എവിടെയാണെന്ന് ഇടയിലുള്ള ' ചിഹ്നം പൈത്തനെ ആശയക്കുഴപ്പത്തിലാകും. അതിനാൽ, ഇടയിലുള്ള ഒരൊറ്റ ഉദ്ധരണി സ്‌ട്രിംഗിന്റെ അവസാനത്തെ സൂചിപ്പിക്കുന്നില്ലെന്ന് നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. എസ്‌കേപ്പ് സീക്വൻസ് എന്ന് വിളിക്കുന്നതിന്റെ സഹായത്തോടെ ഇത് ചെയ്യാൻ കഴിയും . ഒരൊറ്റ ഉദ്ധരണി നിങ്ങൾ ഇങ്ങനെ വ്യക്തമാക്കുന്നു \': ബാക്ക്‌സ്ലാഷ് ശ്രദ്ധിക്കുക. ഇപ്പോൾ, നിങ്ങൾക്ക് സ്ട്രിംഗ് ഇതുപോലെ വ്യക്തമാക്കാൻ കഴിയും 'What\'s your name?'.

ഈ നിർ‌ദ്ദിഷ്‌ട സ്‌ട്രിംഗ് വ്യക്തമാക്കുന്നതിനുള്ള മറ്റൊരു മാർ‌ഗ്ഗം, "What's your name?"അതായത് ഇരട്ട ഉദ്ധരണികൾ‌. അതുപോലെ, ഇരട്ട ഉദ്ധരികള്‍ സ്‌ട്രിംഗിന്റെ ഇടയിലുള്ളപ്പോള്‍ ഇരട്ട ഉദ്ധരണി ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ ഒരു രക്ഷപ്പെടൽ ( \ ) ശ്രേണി ഉപയോഗിക്കേണ്ടതുണ്ട്

രണ്ട്-വരി സ്ട്രിംഗ് വ്യക്തമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ എന്തുചെയ്യും? മുമ്പ് കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു ട്രിപ്പിൾ-ഉദ്ധരിച്ച സ്‌ട്രിംഗ് ഉപയോഗിക്കുക എന്നതാണ് ഒരു മാർഗ്ഗം അല്ലെങ്കിൽ \n എന്ന പുതിയ ലൈനിന്റെ പ്രതീകയ രക്ഷപ്പെടൽ ശ്രേണി ( എസ്‌കേപ്പ് സീക്വൻസ് ) ഉപയോഗിക്കാം.

'This is the first line\nThis is the second line'

ഇനി നമുക്ക് പഠിക്കാനും/അറിയാനുള്ള മറ്റൊരു ഉപയോഗപ്രദമായ രക്ഷപ്പെടൽ ശ്രേണി ടാബാണ് : \t. ഇനിയും നിരവധി എസ്‌കേപ്പ് സീക്വൻസുകളുണ്ടെങ്കിലും ഏറ്റവും ഉപയോഗപ്രദമായവ മാത്രമേ ഞാൻ ഇവിടെ പരാമർശിച്ചിട്ടുള്ളൂ.

ശ്രദ്ധിക്കേണ്ട ഒരു കാര്യം, ഒരു സ്ട്രിംഗിൽ, വരിയുടെ അവസാനത്തിലുള്ള ഒരൊറ്റ ബാക്ക്‌സ്ലാഷ് അടുത്ത വരിയിൽ സ്ട്രിംഗ് തുടരുന്നുവെന്ന് സൂചിപ്പിക്കുന്നു, ഉദാഹരണത്തിന്:

"This is the first sentence. \
This is the second sentence."

എന്നതിന് തുല്യമാണ്

"This is the first sentence. This is the second sentence."

അസംസ്കൃത സ്ട്രിംഗ് ( റോ സ്ട്രിംഗ് )

എസ്‌കേപ്പ് സീക്വൻസുകൾ പോലുള്ള പ്രത്യേക പ്രോസസ്സിംഗ് ആവശ്യമില്ലാതെ സ്ട്രിംഗുകൾ ചില അവസരങ്ങളില്‍ നമുക്ക് നിര്‍മ്മിക്കേണ്ടിവരും . അത്തരം അവസരങ്ങളി‍ല്‍ അസംസ്കൃത സ്ട്രിംഗ് ( റോ സ്ട്രിംഗ് ) r അല്ലെങ്കില്‍ R എന്ന പ്രിഫിക്സ് ചെര്‍ത്ത് നിര്‍മ്മിക്കുക.

r"Newlines are indicated by \n"

പതിവ് (റെഗുലര്‍) എക്‌സ്‌പ്രഷൻ ഉപയോക്താക്കൾക്കുള്ള കുറിപ്പ്

റെഗുലര്‍ എക്‌സ്‌പ്രഷനുകളുമായി നിരന്തരം ഉപയോഗിക്കുന്നവര്‍ എല്ലായ്പ്പോഴും അസംസ്കൃത സ്ട്രിംഗുകൾ ഉപയോഗിക്കുക. അല്ലെങ്കിൽ, ധാരാളം ബാക്ക്‌വാക്കിംഗ് ആവശ്യമായി വന്നേക്കാം. ഉദാഹരണത്തിന്, ബാക്ക് റഫറൻസുകൾ '\\1' എന്ന് പരാമർശിക്കന്നത് r'\1' എന്നാണ്.

വേരിയബിൾ (ചരങ്ങള്‍)

അക്ഷരീയ സ്ഥിരതകൾ(ലിറ്ററല്‍സ്) ഉപയോഗിക്കുന്നത് ഉടൻ തന്നെ ബോറടിപ്പിക്കുന്നതാണ് - ഏതെങ്കിലും വിവരങ്ങൾ സംഭരിക്കുന്നതിനും അവ കൈകാര്യം ചെയ്യുന്നതിനും നമ്മള്‍ക്ക് ചില വഴികൾ ആവശ്യമാണ്. ഇവിടെയാണ് വേരിയബിളുകൾ ചിത്രത്തിലേക്ക് വരുന്നത്. പേര് സൂചിപ്പിക്കുന്നത് തന്നെയാണ് വേരിയബിളുകൾ - അവയുടെ മൂല്യം വ്യത്യാസപ്പെടാം, അതായത്, നിങ്ങൾക്ക് ഒരു വേരിയബിൾ ഉപയോഗിച്ച് എന്തും സംഭരിക്കാനാകും. നിങ്ങളുടെ കമ്പ്യൂട്ടറിന്റെ മെമ്മറിയുടെ ചില ഭാഗങ്ങൾ മാത്രമാണ് വേരിയബിളുകൾ. അക്ഷര സ്ഥിരതകളിൽ(ലിറ്ററല്‍സ്) നിന്ന് വ്യത്യസ്തമായി, ഈ വേരിയബിളുകൾ ആക്സസ് (പരിശോധിക്കുന്നതിന്) ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ചില രീതി ആവശ്യമാണ്, അതിനാൽ നിങ്ങൾ അവയ്ക്ക് പേരുകൾ നൽകേണ്ടിവരുന്നു.

ഐഡന്റിഫയർ നാമകരണം ( തിരിച്ചറിയാന്‍ നാമകരണം )

ഐഡന്റിഫയറുകളുടെ ഉദാഹരണങ്ങളാണ് വേരിയബിളുകൾ. എന്തെങ്കിലും തിരിച്ചറിയാൻ_നൽകിയിരിക്കുന്ന പേരുകളാണ് _ഐഡന്റിഫയറുകൾ . ഐഡന്റിഫയറുകളുടെ പേരിടുന്നതിന് നിങ്ങൾ പാലിക്കേണ്ട ചില നിയമങ്ങളുണ്ട്:

ഡാറ്റ തരങ്ങൾ ( ഡാറ്റ ടൈപ്പ്സ് )

വേരിയബിളുകള്‍ക്ക് (ചരങ്ങള്‍) ഏതുതരം ഡാറ്റാ (മൂല്യം) ആണ് ഉള്‍കൊള്ളുവാന്‍ കഴിയുക എന്ന് വ്യക്തമാക്കുന്നതാണ് ഡാറ്റാ തരങ്ങൾ. അടിസ്ഥാന തരങ്ങൾ അക്കങ്ങളും സ്ട്രിംഗുകളുമാണ്, അവ നമ്മള്‍ ഇതിനകം ചർച്ചചെയ്തു. ക്ലാസുകൾ ഉപയോഗിച്ച് നമുക്ക് സ്വന്തം ഡാറ്റാ തരങ്ങൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് പിന്നീടുള്ള അധ്യായങ്ങളിൽ കാണാം.