توابع ناشناس یا lambda در پایتون

پایتون یک زبان برنامه‌نویسی قدرتمند و محبوب است که برای انجام پروژه‌های مختلف از توسعه وب تا تجزیه و تحلیل داده‌ها استفاده می‌شود. یکی از مفاهیم مهم در پایتون، توابع هستند. توابع به ما کمک می‌کنند تا کدهایمان را سازماندهی کرده و آنها را به بخش‌های کوچکتر و قابل‌استفاده مجدد تقسیم کنیم. در این درس، ما قصد داریم تا با توابع ناشناس یا lambda در پایتون آشنا شویم.

توابع به زبان ساده

قبل از اینکه به توابع ناشناس بپردازیم، بیایید ببینیم که توابع در پایتون چگونه کار می‌کنند. یک تابع در پایتون یک بلوک کد است که می‌تواند به عنوان یک واحد مستقل اجرا شود. توابع معمولاً یک یا چند ورودی می‌گیرند، عملیاتی را انجام می‌دهند و سپس یک خروجی تولید می‌کنند.

به عنوان مثال، فرض کنید می‌خواهیم یک تابع بنویسیم که نام یک دانش‌آموز را بگیرد و یک پیام خوش‌آمدگویی برای او نمایش دهد.

def welcome_student(name):
    print("سلام " + name + " به مکتب خوش آمدی!")

welcome_student("امین")

توابع ناشناس یا lambda

توابع ناشناس یا lambda توابع کوچکی هستند که می‌توانند بدون نام تعریف شوند. این توابع معمولاً برای انجام عملیات ساده و یک‌باره استفاده می‌شوند. ساختار یک تابع ناشناس در پایتون به این شکل است:

lambda arguments: expression

در این ساختار، `arguments` می‌تواند یک یا چند ورودی باشد و `expression` عملیاتی است که بر روی آن ورودی‌ها انجام می‌شود.

مثال‌هایی از توابع ناشناس

بیایید چند مثال از توابع ناشناس ببینیم تا کاربرد آنها را بهتر درک کنیم.

مثال 1: تابع ناشناس برای جمع دو عدد

فرض کنید می‌خواهیم یک تابع ناشناس بنویسیم که دو عدد را بگیرد و آنها را با هم جمع کند.

sum_numbers = lambda x, y: x + y
print(sum_numbers(5, 7))  # خروجی: 12

مثال 2: تابع ناشناس برای محاسبه مساحت یک مستطیل

حالا فرض کنید می‌خواهیم یک تابع ناشناس بنویسیم که طول و عرض یک مستطیل را بگیرد و مساحت آن را محاسبه کند.

rectangle_area = lambda length, width: length * width
print(rectangle_area(4, 5))  # خروجی: 20

استفاده از توابع ناشناس با map، filter و reduce

توابع ناشناس اغلب با توابع `map`، `filter` و `reduce` استفاده می‌شوند. این توابع به ما کمک می‌کنند تا عملیات را بر روی لیست‌ها و سایر iterable ها انجام دهیم.

استفاده از map با تابع ناشناس

تابع `map` به ما کمک می‌کند تا یک تابع را بر روی هر عنصر از یک لیست اعمال کنیم. به عنوان مثال، فرض کنید می‌خواهیم یک لیست از اعداد را بگیریم و هر عدد را به توان 2 برسانیم.

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # خروجی: [1, 4, 9, 16, 25]

استفاده از filter با تابع ناشناس

تابع `filter` به ما کمک می‌کند تا عناصری از یک لیست را که شرایط خاصی را دارند، جدا کنیم. به عنوان مثال، فرض کنید می‌خواهیم از یک لیست از اعداد، فقط اعداد زوج را جدا کنیم.

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # خروجی: [2, 4, 6]

استفاده از reduce با تابع ناشناس

تابع `reduce` که در ماژول `functools` قرار دارد، به ما کمک می‌کند تا یک لیست از عناصر را با استفاده از یک عملیات خاص کاهش دهیم. به عنوان مثال، فرض کنید می‌خواهیم یک لیست از اعداد را بگیریم و حاصل جمع آنها را محاسبه کنیم.

import functools

numbers = [1, 2, 3, 4, 5]
sum_of_numbers = functools.reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers)  # خروجی: 15

کاربردهای واقعی توابع ناشناس

توابع ناشناس می‌توانند در موقعیت‌های مختلفی از برنامه‌نویسی مورد استفاده قرار گیرند. به عنوان مثال، فرض کنید شما می‌خواهید یک برنامه بنویسید که به کاربران کمک کند تا نزدیک‌ترین ایستگاه مترو را به موقعیت فعلی‌شان پیدا کنند. شما می‌توانید از توابع ناشناس برای محاسبه فاصله بین دو نقطه استفاده کنید.

مثال: پیدا کردن نزدیک‌ترین ایستگاه مترو

فرض کنید ما لیستی از ایستگاه‌های مترو با مختصات جغرافیایی آنها داریم و می‌خواهیم نزدیک‌ترین ایستگاه به یک موقعیت خاص را پیدا کنیم.

stations = [
    {"name": "ایستگاه اول", "lat": 35.6895, "lon": 51.3890},
    {"name": "ایستگاه دوم", "lat": 35.6920, "lon": 51.3860},
    {"name": "ایستگاه سوم", "lat": 35.6880, "lon": 51.3875}
]

def distance(lat1, lon1, lat2, lon2):
    # فرمول ساده برای محاسبه فاصله
    return ((lat2 - lat1) ** 2 + (lon2 - lon1) ** 2) ** 0.5

my_lat, my_lon = 35.6900, 51.3880

distances = list(map(lambda station: (station["name"], distance(my_lat, my_lon, station["lat"], station["lon"])), stations))

closest_station = min(distances, key=lambda x: x[1])

print("نزدیک‌ترین ایستگاه:", closest_station[0])

مزایای استفاده از توابع ناشناس

استفاده از توابع ناشناس مزایای زیادی دارد:

• کد شما مختصر و قابل‌خواندن می‌شود.
• توابع ناشناس به خوبی با توابع دیگر مانند `map`، `filter` و `reduce` کار می‌کنند.
• شما می‌توانید به راحتی توابع کوچک و یک‌باره ایجاد کنید.

نکات مهم در استفاده از توابع ناشناس

با اینکه توابع ناشناس بسیار مفید هستند، اما باید به برخی نکات توجه کنید:

• توابع ناشناس باید ساده باشند. اگر عملیات شما پیچیده است، بهتر است از یک تابع معمولی استفاده کنید.
• خوانایی کد مهم است. اگر تابع ناشناس شما خیلی طولانی یا پیچیده است، بهتر است آن را به یک تابع معمولی تبدیل کنید.

“هر برنامه‌نویسی که یک بار توابع ناشناس را درک کند، دریچه‌های جدیدی از امکانات را در برنامه‌نویسی خود می‌بیند.”

تمرین

حالا نوبت شماست که دانش خود را در مورد توابع ناشناس تقویت کنید. فرض کنید شما لیستی از نمرات دانش‌آموزان را دارید و می‌خواهید نمرات را به صورت صعودی مرتب کنید.

scores = [
    {"name": "امین", "score": 85},
    {"name": "رضا", "score": 90},
    {"name": "علی", "score": 78}
]

# از تابع ناشناس برای مرتب‌سازی بر اساس نمرات استفاده کنید

شما می‌توانید از تابع `sorted` و یک تابع ناشناس برای این کار استفاده کنید.

scores = [
    {"name": "امین", "score": 85},
    {"name": "رضا", "score": 90},
    {"name": "علی", "score": 78}
]

sorted_scores = sorted(scores, key=lambda x: x["score"])

for student in sorted_scores:
    print(student["name"], student["score"])

نتیجه‌گیری نیست

توابع ناشناس یا lambda در پایتون ابزارهای قدرتمندی هستند که به شما کمک می‌کنند تا کدهایتان را کوتاه‌تر، خواناتر و کارآمدتر بنویسید. با تمرین و استفاده از این توابع در پروژه‌های مختلف، شما می‌توانید مهارت‌های برنامه‌نویسی خود را به سطح بالاتری برسانید. به یاد داشته باشید که همیشه خوانایی و سادگی کد را در نظر بگیرید و از توابع ناشناس در موارد مناسب استفاده کنید.