பைதான் லாம்ப்டா செயல்பாடுகளை புரிந்துகொள்வதற்கான தொடக்க வழிகாட்டி

பைத்தானில் உள்ள லாம்ப்டாஸ் மிகவும் பயனுள்ள, முக்கியமான மற்றும் சுவாரஸ்யமான அம்சங்களில் ஒன்று. துரதிர்ஷ்டவசமாக, அவர்கள் தவறாகப் புரிந்துகொள்வது மற்றும் தவறாகப் புரிந்துகொள்வது எளிது.

இந்த கட்டுரையில், இந்த மர்மமான செயல்பாடுகள், அவற்றை எவ்வாறு பயன்படுத்துவது, அவை ஏன் பயனுள்ளதாக இருக்கும் என்பது பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தையும் நாங்கள் விளக்கப் போகிறோம்.

---

---

இந்த நடைமுறை உதாரணங்களுக்குள் நுழைவதற்கு முன், நீங்கள் ஒரு பைதான் மெய்நிகர் சூழலை அமைக்க விரும்பலாம். நீங்கள் அதை செய்ய விரும்பவில்லை என்றால், நீங்கள் குறைந்தபட்சம் இந்த உதாரணங்களை முயற்சிக்க வேண்டும் ஒரு ஊடாடும் ஆன்லைன் பைதான் ஷெல்லுடன் .

பைத்தானில் ஒரு லம்ப்டா என்றால் என்ன?

பைத்தானில் ஒரு செயல்பாட்டை வரையறுக்க லாம்ப்டா ஒரு வழி. அவர்கள் சில நேரங்களில் 'லாம்ப்டா ஆபரேட்டர்கள்' அல்லது 'லாம்ப்டா செயல்பாடுகள்' என்று அழைக்கப்படுகிறார்கள்.

நீங்கள் முன்பு பைத்தானைப் பயன்படுத்தியிருந்தால், உங்கள் செயல்பாடுகளை நீங்கள் பயன்படுத்தி வரையறுத்து இருக்கலாம் டெஃப் முக்கிய சொல், அது இதுவரை உங்களுக்கு நன்றாக வேலை செய்தது. அதே காரியத்தைச் செய்ய ஏன் வேறு வழி இருக்கிறது?

வித்தியாசம் என்னவென்றால், லாம்ப்டா செயல்பாடுகள் அநாமதேயமானது. பொருள், அவை பெயரிடத் தேவையில்லாத செயல்பாடுகள். ஒரு 'உண்மையான' செயல்பாடு மிகப் பெரியதாகவும், பருமனாகவும் இருக்கும் சந்தர்ப்பங்களில் சிறிய, ஒரு முறை செயல்பாடுகளை உருவாக்க அவை பயன்படுத்தப்படுகின்றன.

லம்ப்டாஸ் ஒரு செயல்பாட்டு பொருளைத் தருகிறது, இது ஒரு மாறிக்கு ஒதுக்கப்படலாம். லம்ப்தாஸ் எத்தனை வாதங்களை வேண்டுமானாலும் கொண்டிருக்கலாம், ஆனால் அவை ஒரே ஒரு வெளிப்பாட்டை மட்டுமே கொண்டிருக்க முடியும். நீங்கள் லம்ப்டாஸ் உள்ளே மற்ற செயல்பாடுகளை அழைக்க முடியாது.

---

---

லாம்ப்டா செயல்பாடுகளுக்கு மிகவும் பொதுவான பயன்பாடானது ஒரு எளிய ஒரு-வரிசை செயல்பாடு தேவைப்படும் குறியீடாகும், அங்கு ஒரு முழுமையான இயல்பான செயல்பாட்டை எழுத அதிகப்படியானதாக இருக்கும். 'வரைபடம், வடிகட்டி மற்றும் குறைத்தல் பற்றி என்ன?' என்பதன் கீழ் இது கீழே விரிவாக விவரிக்கப்பட்டுள்ளது.

பைத்தானில் லம்ப்டாஸை எவ்வாறு பயன்படுத்துவது

ஒரு லாம்ப்டா செயல்பாட்டைப் பார்ப்பதற்கு முன், 'பாரம்பரிய' வழியில் வரையறுக்கப்பட்ட ஒரு சூப்பர் அடிப்படை செயல்பாட்டைப் பார்ப்போம்:

---

---

def add_five(number):
return number + 5

print(add_five(number=4))

இந்த செயல்பாடு மிகவும் அடிப்படையானது, ஆனால் இது லாம்ப்டாக்களை விளக்குகிறது. உங்களுடையது இதை விட சிக்கலானதாக இருக்கலாம். இந்த செயல்பாடு மூலம் அனுப்பப்படும் எந்த எண்ணிற்கும் ஐந்து சேர்க்கிறது எண் அளவுரு.

இது ஒரு லாம்ப்டா செயல்பாடாக எப்படி இருக்கிறது என்பது இங்கே:

add_five = lambda number: number + 5

print(add_five(number=4))

பயன்படுத்துவதை விட டெஃப் , அந்த வார்த்தை லாம்ப்டா பயன்படுத்தப்பட்டுள்ளது. அடைப்புக்குறிகள் தேவையில்லை, ஆனால் பின்வரும் எந்த வார்த்தைகளும் லாம்ப்டா முக்கிய சொல் அளவுருக்களாக உருவாக்கப்பட்டது. பெருங்குடல் அளவுருக்கள் மற்றும் வெளிப்பாட்டை பிரிக்க பயன்படுகிறது. இந்த வழக்கில், வெளிப்பாடு உள்ளது எண் + 5 .

பயன்படுத்த வேண்டிய அவசியமில்லை திரும்ப முக்கிய சொல் --- லாம்ப்டா இதை உங்களுக்காக தானாகவே செய்கிறது.

இரண்டு வாதங்களுடன் ஒரு லாம்ப்டா செயல்பாட்டை எவ்வாறு உருவாக்குவது என்பது இங்கே:

விஜியோ டிவியில் பயன்பாடுகளை எவ்வாறு சேர்ப்பது

add_numbers_and_five = lambda number1, number2: number1 + number2 + 5

print(add_numbers_and_five(number1=4, number2=3))

லாம்ப்டாஸின் புள்ளி குறித்து உங்களுக்கு இன்னும் உறுதியாக தெரியவில்லை என்றால், அடுத்த பகுதி உள்ளே நுழைந்து ஒளியைப் பார்க்க உதவும்.

வரைபடம், வடிகட்டி மற்றும் குறைப்புடன் பைதான் லாம்ப்தாஸ்

பைதான் கோர் நூலகம் என்று அழைக்கப்படும் மூன்று முறைகள் உள்ளன வரைபடம் , குறைக்க , மற்றும் வடிகட்டி . இந்த முறைகள் லாம்ப்டா செயல்பாடுகளைப் பயன்படுத்த சிறந்த காரணங்கள்.

தி வரைபடம் செயல்பாடு இரண்டு வாதங்களை எதிர்பார்க்கிறது: ஒரு செயல்பாடு மற்றும் ஒரு பட்டியல். இது அந்த செயல்பாட்டை எடுத்து, பட்டியலில் உள்ள ஒவ்வொரு உறுப்புகளுக்கும் பொருந்தும், மாற்றியமைக்கப்பட்ட உறுப்புகளின் பட்டியலை வரைபடப் பொருளாகத் தருகிறது. தி பட்டியல் இதன் விளைவாக வரும் வரைபட பொருளை மீண்டும் ஒரு பட்டியலாக மாற்ற செயல்பாடு பயன்படுத்தப்படுகிறது.

லாம்ப்டா இல்லாமல் வரைபடத்தை எவ்வாறு பயன்படுத்துவது என்பது இங்கே:

list1 = [2, 4, 6, 8]
print(list1)
def add_five(number):
return number + 5

new_list = list(map(add_five, list1))
print(new_list)

இந்த வரைபட செயல்பாடு மிகவும் எளிது, ஆனால் அது சிறப்பாக இருக்கலாம். தி add_five செயல்பாடு ஒரு வாதமாக அனுப்பப்பட்டது, ஆனால் நீங்கள் வரைபடத்தைப் பயன்படுத்தும் ஒவ்வொரு முறையும் ஒரு செயல்பாட்டை உருவாக்க விரும்பவில்லை என்றால் என்ன செய்வது? அதற்கு பதிலாக நீங்கள் ஒரு லாம்ப்டாவைப் பயன்படுத்தலாம்!

லாம்ப்டாவால் மாற்றப்பட்ட செயல்பாட்டால் மட்டுமே அதே குறியீடு எப்படி இருக்கும் என்பது இங்கே:

உயர்தர வீடியோவை பேஸ்புக்கில் பதிவேற்றுவது எப்படி

list1 = [2, 4, 6, 8]
print(list1)

new_list = list(map(lambda x: x + 5, list1))
print(new_list)

நீங்கள் பார்க்க முடியும் என, முழு add_five செயல்பாடு இனி தேவையில்லை. அதற்கு பதிலாக, லாம்ப்டா செயல்பாடு விஷயங்களை நேர்த்தியாக வைத்திருக்க பயன்படுகிறது.

உடன் வடிகட்டி செயல்பாடு, செயல்முறை மிகவும் ஒன்றே. வடிகட்டி ஒரு செயல்பாட்டை எடுத்து ஒரு பட்டியலில் உள்ள ஒவ்வொரு எலெமனுக்கும் அதைப் பயன்படுத்துகிறது மற்றும் செயல்பாட்டை உண்மைக்குத் திரும்பச் செய்த உறுப்புகளை மட்டுமே கொண்ட ஒரு புதிய பட்டியலை உருவாக்கியது.

முதலில், லம்ப்டாஸ் இல்லாமல்:

numbers = [1, 4, 5, 10, 20, 30]
print(numbers)
def greater_than_ten_func(number):
if number > 10:
return True
else:
return False
new_numbers = list(filter(greater_than_ten_func, numbers))

print(new_numbers)

இந்த குறியீட்டில் தவறில்லை, ஆனால் அது சற்று நீளமாகிறது. ஒரு லாம்ப்டா எத்தனை வரிகளை அகற்ற முடியும் என்று பார்ப்போம்:

numbers = [1, 4, 5, 10, 20, 30]
print(numbers)
new_numbers = list(filter(lambda x: x > 10, numbers))
print(new_numbers)

லாம்ப்டா செயல்பாடு முழு தேவையையும் மாற்றியுள்ளது பெரிய_தை விட_பெரியது ! மேலும் இது ஐந்து எளிய வார்த்தைகளில் முடிந்தது. இதனால்தான் லாம்ப்டாக்கள் சக்தி வாய்ந்தவை: அவை எளிய பணிகளுக்கான குழப்பத்தை குறைக்கின்றன.

இறுதியாக, பார்க்கலாம் குறைக்க . குறைத்தல் மற்றொரு சிறந்த பைதான் செயல்பாடு. இது ஒரு பட்டியலில் உள்ள அனைத்து உருப்படிகளுக்கும் ஒரு உருட்டல் கணக்கீட்டைப் பயன்படுத்துகிறது. நீங்கள் ஒரு கூட்டுத்தொகையை கணக்கிட இதைப் பயன்படுத்தலாம் அல்லது அனைத்து எண்களையும் பெருக்கலாம்:

from functools import reduce
numbers = [10, 20, 30, 40]
print(numbers)
def summer(a, b):
return a + b

result = reduce(summer, numbers)
print(result)

இந்த உதாரணத்தை இறக்குமதி செய்ய வேண்டும் குறைக்க இருந்து ஃபங்க்டூல்கள் தொகுதி, ஆனால் கவலைப்பட வேண்டாம், ஃபங்க்டூல்ஸ் தொகுதி பைதான் கோர் நூலகத்தின் ஒரு பகுதியாகும்.

ஒரு லாம்ப்டாவுடன் கதை மிகவும் ஒத்திருக்கிறது, ஒரு செயல்பாடு தேவையில்லை:

from functools import reduce
numbers = [10, 20, 30, 40]
print(numbers)

result = reduce(lambda a, b: a + b, numbers)
print(result)

பைதான் லம்ப்தாஸ் கவனிக்க வேண்டிய விஷயங்கள்

பைதான் கோர் நூலகத்திலிருந்து வரைபடம், வடிகட்டி மற்றும் குறைப்புடன் லாம்ப்டா செயல்பாடுகள் எவ்வளவு எளிது என்பதை இந்த உதாரணங்கள் காட்டுகின்றன. இன்னும், லாம்ப்டா செயல்பாடுகள் உதவாத சில பயன்பாடுகள் உள்ளன.

நீங்கள் ஒரு அடிப்படை பணியைத் தவிர வேறு ஏதாவது செய்கிறீர்கள் அல்லது மற்ற முறைகளை அழைக்க விரும்பினால், ஒரு சாதாரண செயல்பாட்டைப் பயன்படுத்தவும். லாம்ப்டாஸ் ஒரு அநாமதேய செயல்பாடுகளுக்கு சிறந்தது, ஆனால் அவை ஒரே ஒரு வெளிப்பாட்டை மட்டுமே கொண்டிருக்க வேண்டும். உங்கள் லாம்ப்டா ஒரு வழக்கமான வெளிப்பாடாகத் தோன்ற ஆரம்பித்தால், அது ஒரு பிரத்யேக முறைக்கு மறுசீரமைக்கும் நேரம்.

மேலும் உதவிக்குறிப்புகளுக்கு, எங்களைச் சரிபார்க்கவும் பைத்தானில் பொருள் சார்ந்த நிரலாக்கத்திற்கான வழிகாட்டி பைதான் தொடக்கக்காரர்களுக்கான எங்கள் FAQ வழிகாட்டியைப் பாருங்கள்.

பகிர் பகிர் ட்வீட் மின்னஞ்சல் மின்னஞ்சல் உண்மையானதா அல்லது போலியானதா என்பதை சரிபார்க்க 3 வழிகள்

சற்று சந்தேகத்திற்குரிய ஒரு மின்னஞ்சலை நீங்கள் பெற்றிருந்தால், அதன் நம்பகத்தன்மையை சரிபார்க்க எப்போதும் சிறந்தது. மின்னஞ்சல் உண்மையானதா என்பதை அறிய மூன்று வழிகள் உள்ளன.

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• பைதான்
• குறியீட்டு பயிற்சிகள்

எழுத்தாளர் பற்றி ஜோ கோபர்ன்(136 கட்டுரைகள் வெளியிடப்பட்டன)

ஜோ இங்கிலாந்தின் லிங்கன் பல்கலைக்கழகத்தில் கணினி அறிவியலில் பட்டதாரி. அவர் ஒரு தொழில்முறை மென்பொருள் டெவலப்பர், அவர் ட்ரோன்களை பறக்காதபோது அல்லது இசை எழுதாதபோது, ​​அவர் அடிக்கடி புகைப்படம் எடுப்பதை அல்லது வீடியோக்களை தயாரிப்பதை காணலாம்.

ஜோ கோபர்னிடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்