அறிமுகம்: Python-இன் எளிய தொடரியல் (syntax) அமைப்பானது, அதைக் கற்றுக்கொள்வதை எளிதாக்குகிறது; இதுவே தரவு அறிவியல் (Data Science), இயந்திரக் கற்றல் (Machine Learning) , செய்யறிவு (AI) ஆகிய துறைகளுக்கு முதன்மையான மொழியாக மாற்றுகிறது. இருப்பினும், ஒரு தொடக்க நிலையில் இருப்பவர், திறமையான, பராமரிக்க எளிதான அமைவுகளை உருவாக்கும் ஒரு தொழில்முறை வல்லுநராக மாறுவதற்கு, Python-இன் முக்கிய செயல்பாட்டு வழிமுறைகளை முழுமையாகக் கற்றுத் தேர்ந்திருப்பது மிகவும்அவசியமாகும்.

ஒவ்வொரு Python நிரலாளரும் (developer) தங்கள் திறன்களின் தொகுப்பில் கட்டாயம் வைத்திருக்க வேண்டிய ஐந்து அடிப்படை கோட்பாடுகள் பின்வருமாறு.

1. List Comprehensions , Generator Expressions

List comprehensions என்பவை, சிக்கலான  மடக்கிகளின்(‘loops’) அமைப்புகளை ஒரேயொரு வரி நிரலின் மூலம் மாற்றீடு செய்கின்றன; மேலும் இவை .append() எனும் வழிமுறையை விட வேகமாகச் செயல்படுகின்றன. இருப்பினும், மிகப்பிரம்மாண்டமான தரவுத் தொகுப்புகளை (datasets) கையாளும்போது, ​​Generator expression-ஐப் (அடைப்புக்குறிகளைப் பயன்படுத்தி உருவாக்கப்படுவது) பயன்படுத்துவதே ஒரு உண்மையான தொழில்முறை அணுகுமுறையாகும். Generators என்பவை  தேவைப்படும்போது மட்டும் கணக்கிடும் முறை  (“Lazy evaluation”) எனும் நுட்பத்தைப் பயன்படுத்துகின்றன; இவை தரவின் உறுப்புகளை (items) ஒவ்வொன்றாகவே உருவாக்குகின்றன, இதன் மூலம் கணினியின் நினைவகத்தை (memory) பெருமளவில் சேமிக்கின்றன.

numbers = range(1000000)

Python-இன் சிறப்பான List Comprehension எனும்வழிமுறை (அனைத்தையும் நினைவகத்தில் ஏற்றிக்கொள்ளும்)

squared_list = [n ** 2 for n in numbers if n % 2 == 0] # அளவு: ~4.1 MB

Generator Expression (தேவைப்படும்போது மட்டும் கணக்கிடும் முறை)

squared_gen = (n ** 2 for n in numbers if n % 2 == 0)

அளவு: 200 bytes

print(next(squared_gen))

வெளியீடு: 0

print(next(squared_gen))

வெளியீடு: 4

2. Decorators

Decorators என்பவை மேலுறைகள் (‘wrappers’) போலச் செயல்படுகின்றன; இவை ஒரு செயலி(function) அல்லது இனத்தின்(class)- மூல நிரலை (source code) நிரந்தரமாக மாற்றாமலேயே, அதன் செயல்பாட்டு முறையை மாற்றியமைக்கின்றன. இவை DRYஎனும் சுருக்குபெயரலால் அழைக்கப் பெறுகின்ற ஒரே செயலை மீண்டும் மீண்டும் செய்யாதே(‘Don’t Repeat Yourself’) எனும் கோட்பாட்டை நடைமுறைப்படுத்துகின்றன; இதனால் பதிவேற்றம் (‘logging’),  அடையாளச் சரிபார்ப்பு(‘authentication’) ,  தற்காலிகச் சேமிப்பு(‘caching’) போன்ற செயலிகளுக்கு இவை இன்றியமையாதவையாகத் திகழ்கின்றன.

Python

import time

from functools import wraps

def timer_decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

start = time.time()

result = func(*args, **kwargs)

print(f”{func.name} took {time.time() – start:.4f}s”)

return result

return wrapper

@timer_decorator

def heavy_computation():

return sum(range(10**7))

heavy_computation()

வெளியீடு: heavy_computation took 0.0941s

3. சூழல் மேலாளர்கள்( Context Managers)(with எனும்கூற்றுகள்)

கோப்புகள் அல்லது தரவுத்தள இணைப்புகள் போன்ற வளங்களை (resources) கைமுறையாக மூடுவதற்கு மறந்துவிடுவது, நினைவகக் கசிவுகள் (memory leaks) , கோப்புப் பூட்டுகளுக்கு (file locks) வழிவகுக்கும். withஎனும் கூற்றானது, பிழைகள் ஏற்பட்டாலும் கூட, வளங்களை அமைக்கும் , விடுவிக்கும் செயல்முறைகளை நம்பகத்தன்மையுடன் கையாளுவதன் மூலம், வள மேலாண்மையை தானியக்கமாக்குகிறது.

with open(“data.txt”, “w”) as f:

f.write(“Hello World”)

இந்தக் குறிமுமுறைவரிகளின் தொகுதியை விட்டு வெளியேறியதும் கோப்பு தானாகவே மூடப்பட்டுவிடும்.

4. *args , **kwargsஆகியவற்றினைக் கையாளுவதில் தேர்ச்சிபெறுதல்

தொகுப்பு(“Packing”) செயற்குறிகள், ஒரு செயலி(function) மாறுபடும் எண்ணிக்கையிலான அளபுருக்களை (arguments) ஏற்றுக்கொள்ள அனுமதிக்கின்றன. இந்த நெகிழ்வுத்தன்மையே Scikit-Learn ,Matplotlib போன்ற பிரபலமான நூலகங்களின் அடிப்படையாகத் திகழ்கிறது; இது, மாறிவரும் தேவைகளுக்கு ஏற்ப குறிமுறைவரிகளை மிகவும் எளிதாக மாற்றியமைக்க உதவுகிறது.

*args: கூடுதல் ‘நிலையின்சார்பு அளபுருக்களை’ (positional arguments) ஒரு ‘tuple’-ஆகத் தொகுக்கிறது.

**kwargs: கூடுதல் ‘பெயரிடப்பட்ட அளபுருக்களை’ (named parameters) ஒரு ‘dictionary’-ஆகத் தொகுக்கிறது.

def make_profile(name, *tags, **metadata):

print(f”User: {name} | Tags: {tags} | Details: {metadata}”)

make_profile(“Alice”, “DataScientist”, “Pythonist”, location=”NY”, seniority=”Senior”)

வெளியீடு: User: Alice | Tags: (‘DataScientist’, ‘Pythonist’) | Details: {‘location’: ‘NY’, ‘seniority’: ‘Senior’}

5. Dunder எனும்வழிமுறைகள் (Magic வழிமுறைகள்)

“Dunder”  எனும் இரட்டை அடிக்கோடு(Double Underscore) வழிமுறைகள், நாம் உருவாக்கும் தனிப்பயன் இனங்களை (custom classes), பைத்தானின் உள்ளிணைந்த செயலிகளைப் போன்றே செயல்பட அனுமதிக்கின்றன. இந்தச் சிறப்பு வழிமுறைகளை மறுவரையறை (overriding) செய்வதன் மூலம், நம்முடைய பொருள்கள் (objects) len() அல்லது print() போன்ற பைதான் சார்புகளுடன் இயல்பாகவே ஊடாட முடியும்.

class Dataset:

def init(self, data):

self.data = data

def len(self):

return len(self.data)

def str(self):

return f”Dataset with {len(self.data)} items”

my_data = Dataset([1, 2, 3])

print(len(my_data)) # Calls len -> Output: 3

print(my_data)      # Calls str -> Output: Dataset with 3 items

முடிவாக : இந்தக் கருவிகளில் தேர்ச்சி பெறுவது, எளிய உரைநிரல்களை எழுதுவதிலிருந்து விரிவாக்கக்கூடிய மென்பொருளை உருவாக்கும் நிலைக்கு மாறுவதைக் குறிக்கிறது. வேகத்திற்காக Comprehensioகளையும், தெளிவான தர்க்கத்திற்காக Decoratorsகளையும், பாதுகாப்பிற்காக Context  மேலாளர்களையும், தகவமைப்பிற்காக நெகிழ்வுடனான argumentsகளையும், பொருளின்ஆற்றலுக்காக dunder எனும் வழிமுறைகளையும் பயன்படுத்துவது, மேம்பட்ட பைதான் நிபுணத்துவத்திற்கு ஒரு வலுவான அடித்தளத்தை அமைக்கிறது.