آموزش جامع map و filter در پایتون با کدهای آماده

نقشه راه سریع: Map و Filter در یک نگاه

┌──────────────────────────────────────────────────────────┐
│              🛠️  Map & Filter: ابزارهای حیاتی پایتون 🛠️              │
├──────────────────────────────────────────────────────────┤
│                       💡 Map چیست؟                       │
│  ✨ برای اعمال یک تابع روی تک تک آیتم‌های یک دنباله.      │
│  🔄 هر آیتم را "تقییر" می‌دهد و نتیجه جدیدی برمی‌گرداند.   │
│  🔗 خروجی: یک شیء Map (باید به List/Tuple تبدیل شود).     │
│  مثال: [1, 2, 3] --(map x*2)--> [2, 4, 6]                 │
├──────────────────────────────────────────────────────────┤
│                      🎯 Filter چیست؟                     │
│  🕵️‍♀️ برای انتخاب آیتم‌هایی از یک دنباله که شرط خاصی را دارند.│
│  ✅ فقط آیتم‌هایی که تابع روی آن‌ها True برگرداند، حفظ می‌شوند.│
│  🔗 خروجی: یک شیء Filter (باید به List/Tuple تبدیل شود).   │
│  مثال: [1, 2, 3] --(filter x>1)--> [2, 3]                 │
├──────────────────────────────────────────────────────────┤
│                  📈 مزایای کلیدی:                         │
│  •  کد کوتاه‌تر و خواناتر (Pythonic).                     │
│  •  عملکرد بهتر در داده‌های بزرگ (نسبت به حلقه‌های ساده). │
│  •  قابلیت موازی‌سازی (در برخی موارد).                    │
├──────────────────────────────────────────────────────────┤
│                  🔍 چه زمانی استفاده کنیم؟                 │
│  •  Map: وقتی می‌خواهید Transformation روی داده‌ها انجام دهید. │
│  •  Filter: وقتی می‌خواهید Selection یا فیلترینگ انجام دهید.   │
├──────────────────────────────────────────────────────────┤
│                 ⚠️ نکات مهم:                             │
│  •  خروجی Lazy است: تا زمانی که لازم نباشد، محاسبه نمی‌شود.│
│  •  می‌توان از List Comprehension به عنوان جایگزین استفاده کرد. │
└──────────────────────────────────────────────────────────┘
        

مقدمه: چرا `map` و `filter` در پایتون مهم هستند؟

در دنیای برنامه‌نویسی، خصوصاً با پایتون، اغلب با مجموعه‌ای از داده‌ها سروکار داریم که نیاز به پردازش دارند. مثلاً، یک لیست از اعداد که می‌خواهیم همه آن‌ها را دو برابر کنیم، یا لیستی از کاربران که می‌خواهیم فقط کاربران فعال را جدا کنیم. رویکرد سنتی برای این کارها معمولاً استفاده از حلقه‌های `for` است. اما پایتون برای این مسائل راه‌حل‌های پایتونیک‌تر، خواناتر و گاهی اوقات کارآمدتر ارائه می‌دهد: توابع `map` و `filter`.

این دو تابع جزو توابع توکار (built-in functions) پایتون هستند و بخش مهمی از برنامه‌نویسی تابعی (Functional Programming) محسوب می‌شوند. با یادگیری و استفاده درست از آن‌ها، می‌توانید کدی بنویسید که نه تنها کوتاه‌تر و تمیزتر باشد، بلکه درک آن برای خودتان و دیگران آسان‌تر و مدیریت‌پذیرتر باشد. این مقاله یک راهنمای کامل و گام‌به‌گام برای تسلط بر `map` و `filter` است.

تابع `map` در پایتون: دگرگون‌کننده داده‌ها

تابع `map` (نقشه) یک ابزار قدرتمند در پایتون است که به شما اجازه می‌دهد یک تابع مشخص را روی هر آیتم از یک دنباله (مانند لیست، تاپل یا رشته) اعمال کنید و نتایج جدید را در یک دنباله جدید جمع‌آوری کنید. به عبارت ساده‌تر، `map` یک لیست از آیتم‌ها را می‌گیرد و با اعمال یک “نقشه” (تابع) روی هر آیتم، لیستی جدید از آیتم‌های تغییر یافته به شما می‌دهد.

ساختار و سینتکس `map`

map(function, iterable, ...)

نکته مهم اینجاست که `map` یک شیء `map` برمی‌گرداند که یک ایتراتور (iterator) است. برای دیدن نتایج نهایی، باید آن را به یک نوع داده قابل مشاهده مانند لیست یا تاپل تبدیل کنید.

مثال‌های عملی با `map`

Copy Code
# تعریف لیست اصلی
numbers = [1, 2, 3, 4, 5]

# تعریف تابعی برای دو برابر کردن
def double(num):
    return num * 2

# استفاده از map برای اعمال تابع double روی هر آیتم
doubled_numbers_map = map(double, numbers)

# تبدیل شیء map به لیست برای مشاهده نتایج
result_list = list(doubled_numbers_map)
print(f"اعداد اصلی: {numbers}")
print(f"اعداد دو برابر شده با map: {result_list}")

# خروجی:
# اعداد اصلی: [1, 2, 3, 4, 5]
# اعداد دو برابر شده با map: [2, 4, 6, 8, 10]
        

Copy Code
words = ["hello", "python", "world"]

# استفاده از lambda برای تبدیل هر رشته به حروف بزرگ
uppercased_words_map = map(lambda word: word.upper(), words)

result_list = list(uppercased_words_map)
print(f"کلمات اصلی: {words}")
print(f"کلمات با حروف بزرگ: {result_list}")

# خروجی:
# کلمات اصلی: ['hello', 'python', 'world']
# کلمات با حروف بزرگ: ['HELLO', 'PYTHON', 'WORLD']
        

Copy Code
list1 = [1, 2, 3]
list2 = [10, 20, 30]

# تابعی برای جمع کردن دو عدد
def add(x, y):
    return x + y

# اعمال تابع add روی آیتم‌های متناظر از list1 و list2
sum_lists = map(add, list1, list2)

result_list = list(sum_lists)
print(f"لیست اول: {list1}")
print(f"لیست دوم: {list2}")
print(f"مجموع آیتم‌های متناظر: {result_list}")

# خروجی:
# لیست اول: [1, 2, 3]
# لیست دوم: [10, 20, 30]
# مجموع آیتم‌های متناظر: [11, 22, 33]
        

تابع `filter` در پایتون: انتخابگر هوشمند داده‌ها

تابع `filter` (فیلتر) همانطور که از اسمش پیداست، برای “فیلتر کردن” یا انتخاب آیتم‌هایی از یک دنباله استفاده می‌شود که یک شرط خاص را برآورده می‌کنند. این تابع یک دنباله و یک تابع را می‌گیرد. تابع مورد نظر روی هر آیتم اعمال می‌شود و فقط آیتم‌هایی که تابع روی آن‌ها `True` برگرداند (یعنی شرط را برآورده کنند) به عنوان خروجی حفظ می‌شوند.

ساختار و سینتکس `filter`

filter(function, iterable)

مثل `map`، تابع `filter` هم یک شیء `filter` برمی‌گرداند که یک ایتراتور است و برای دیدن نتایج باید آن را به لیست یا تاپل تبدیل کنید.

مثال‌های عملی با `filter`

Copy Code
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# تابعی برای بررسی زوج بودن عدد
def is_even(num):
    return num % 2 == 0

# استفاده از filter برای انتخاب اعداد زوج
even_numbers_filter = filter(is_even, numbers)

result_list = list(even_numbers_filter)
print(f"اعداد اصلی: {numbers}")
print(f"اعداد زوج با filter: {result_list}")

# خروجی:
# اعداد اصلی: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# اعداد زوج با filter: [2, 4, 6, 8, 10]
        

Copy Code
words = ["apple", "banana", "cat", "dog", "elephant", "zoo"]

# استفاده از lambda برای فیلتر کردن کلمات با طول بیشتر از 5
long_words_filter = filter(lambda word: len(word) > 5, words)

result_list = list(long_words_filter)
print(f"کلمات اصلی: {words}")
print(f"کلمات بلندتر از 5 حرف: {result_list}")

# خروجی:
# کلمات اصلی: ['apple', 'banana', 'cat', 'dog', 'elephant', 'zoo']
# کلمات بلندتر از 5 حرف: ['banana', 'elephant']
        

Copy Code
data = [1, 0, True, False, "hello", "", None, [1, 2], []]

# filter با None، آیتم‌های falsy (0, False, "", None, []) را حذف می‌کند
filtered_data = filter(None, data)

result_list = list(filtered_data)
print(f"داده‌های اصلی: {data}")
print(f"داده‌های فیلتر شده (non-falsy): {result_list}")

# خروجی:
# داده‌های اصلی: [1, 0, True, False, 'hello', '', None, [1, 2], []]
# داده‌های فیلتر شده (non-falsy): [1, True, 'hello', [1, 2]]
        

`map` و `filter` در مقابل List Comprehension

یکی از سوالات رایج در پایتون این است که آیا باید از `map` و `filter` استفاده کرد یا از List Comprehension؟ هر دو روش برای انجام کارهای مشابه قابل استفاده هستند و انتخاب بین آن‌ها اغلب به سلیقه برنامه‌نویس، خوانایی کد و گاهی اوقات پرفورمنس بستگی دارد. اما عموماً در جامعه پایتون، List Comprehension برای موارد ساده‌تر ارجحیت دارد.

Copy Code
numbers = [1, 2, 3, 4, 5]

# با map
doubled_map = list(map(lambda x: x * 2, numbers))
print(f"با map: {doubled_map}")

# با List Comprehension
doubled_comprehension = [x * 2 for x in numbers]
print(f"با List Comprehension: {doubled_comprehension}")

# خروجی:
# با map: [2, 4, 6, 8, 10]
# با List Comprehension: [2, 4, 6, 8, 10]
        

Copy Code
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# با filter
even_filter = list(filter(lambda x: x % 2 == 0, numbers))
print(f"با filter: {even_filter}")

# با List Comprehension
even_comprehension = [x for x in numbers if x % 2 == 0]
print(f"با List Comprehension: {even_comprehension}")

# خروجی:
# با filter: [2, 4, 6, 8, 10]
# با List Comprehension: [2, 4, 6, 8, 10]
        

جدول مقایسه `map`، `filter` و List Comprehension

برای اینکه انتخاب راحت‌تر باشد، در این جدول تفاوت‌های اصلی و موارد استفاده هر کدام را مرور می‌کنیم. برای دسترسی به اسنیپت‌های بیشتر، اینجا کلیک کن.

چه زمانی از کدام استفاده کنیم؟

انتخاب بین `map`/`filter` و List Comprehension به چند عامل بستگی دارد:

• خوانایی: برای عملیات ساده تغییر (مانند `x*2`) یا فیلترینگ ساده (`x % 2 == 0`)، List Comprehension معمولاً خواناتر است. وقتی تابع شما پیچیده‌تر می‌شود یا قبلاً تعریف شده است (مثل `str.upper` یا یک تابع اختصاصی)، `map`/`filter` می‌تواند کد را تمیزتر کند.
• اندازه داده: اگر با داده‌های بسیار بزرگ سروکار دارید و نیازی به پردازش همه آیتم‌ها به صورت همزمان ندارید، `map` و `filter` که خروجی ایتراتور (lazy evaluation) می‌دهند، حافظه کمتری مصرف می‌کنند و می‌توانند کارآمدتر باشند. List Comprehension تمام لیست را در حافظه می‌سازد.
• بازگشت یک شیء ایتراتور: اگر قصد دارید نتیجه را بلافاصله مصرف کنید و نیازی به لیست کامل ندارید (مثلاً در یک حلقه `for` دیگر)، `map` و `filter` بهترین گزینه هستند.
• هم‌زمانی (Concurrency): در برخی فریم‌ورک‌های پردازش موازی، توابعی مشابه `map` و `filter` برای توزیع وظایف بین پردازنده‌ها یا هسته‌ها استفاده می‌شوند. مثلاً در JavaScript هم توابع مشابهی وجود دارد که به کمک آن می‌توانید کدنویسی بهتری داشته باشید.

به طور کلی، برای اکثر موارد رایج در پایتون، List Comprehension ترجیح داده می‌شود، مگر اینکه دلایل خاصی برای استفاده از `map` و `filter` داشته باشید (مثل پیچیدگی تابع، حافظه یا laziness).

نکات پیشرفته و بهترین شیوه‌ها

زنجیره‌ای کردن `map` و `filter`

یکی از مزایای `map` و `filter` این است که می‌توانید آن‌ها را به راحتی با هم زنجیره‌ای کنید. از آنجا که هر دو یک ایتراتور برمی‌گردانند، می‌توانید خروجی یکی را به ورودی دیگری بدهید.

Copy Code
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# ابتدا اعداد زوج را فیلتر می‌کنیم، سپس آنها را دو برابر می‌کنیم
# (1) filter: [2, 4, 6, 8, 10]
# (2) map: [4, 8, 12, 16, 20]
result = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numbers)))
print(f"نتیجه ترکیب map و filter: {result}")

# خروجی:
# نتیجه ترکیب map و filter: [4, 8, 12, 16, 20]
        

این رویکرد نه تنها کد را جمع‌وجورتر می‌کند بلکه به دلیل ارزیابی تنبل (lazy evaluation) حافظه کمتری نیز مصرف می‌کند؛ چون در هر مرحله فقط آیتم‌های مورد نیاز پردازش می‌شوند.

کارایی و حافظه (Lazy Evaluation)

یکی از مزیت‌های بزرگ `map` و `filter` نسبت به List Comprehension در سناریوهای خاص، رفتار تنبل یا “lazy” آن‌هاست. یعنی این توابع، عناصر را در لحظه تولید می‌کنند (just-in-time)، نه اینکه از ابتدا یک لیست کامل در حافظه بسازند. این ویژگی باعث می‌شود که برای کار با دنباله‌های بسیار بزرگ یا حتی بی‌نهایت، `map` و `filter` (به دلیل خروجی ایتراتور) بسیار کارآمدتر از List Comprehension باشند که همیشه یک لیست کامل در حافظه می‌سازد. برای مثال، اگر با یک فایل حجیم کار می‌کنید، استفاده از ایتراتورها از بار حافظه می‌کاهد.

عیب‌یابی سریع (Troubleshooting)

استفاده از `map` و `filter` در ابتدا ممکن است با چند چالش همراه باشد. اینجا به برخی مشکلات رایج و راه‌حل‌های آن‌ها اشاره می‌کنیم:

• مشکل: `map` یا `filter` چیزی نشان نمی‌دهند!

  راه‌حل: یادت باشه، `map` و `filter` ایتراتور (iterator) برمی‌گردونن. برای دیدن نتیجه باید اون‌ها رو به لیست، تاپل یا هر دنباله دیگه‌ای تبدیل کنی.

  Copy Code
  # غلط
  result_map = map(lambda x: x * 2, [1, 2, 3])
  print(result_map) # 

• مشکل: تابع ارسالی به `map` یا `filter` آرگومان‌های اشتباه می‌گیره.

  راه‌حل: مطمئن شو تابعی که به `map` یا `filter` میدی، دقیقاً تعداد آرگومان‌های مناسب رو می‌پذیره. برای `map` با چند ایتراتور، تابع باید به تعداد ایتراتورها آرگومان داشته باشه. برای `filter`، تابع همیشه فقط یک آرگومان (آیتم فعلی) می‌گیره.

  Copy Code
  # غلط (تابع add دو آرگومان می‌گیرد، اما map یک iterable دارد)
  # list(map(lambda x, y: x + y, [1, 2, 3])) # TypeError
  
  # صحیح (تابع lambda یک آرگومان می‌گیرد و map هم یک iterable دارد)
  list(map(lambda x: x * 2, [1, 2, 3])) # [2, 4, 6]
  
  # صحیح (تابع add دو آرگومان می‌گیرد و map هم دو iterable دارد)
  list(map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])) # [5, 7, 9]
              

• مشکل: چرا `map`/`filter` کندتر از `for` یا List Comprehension عمل می‌کنه؟

  راه‌حل: در موارد ساده و لیست‌های کوچک، `map`/`filter` ممکن است به دلیل سربار (overhead) فراخوانی تابع، کمی کندتر از List Comprehension یا حلقه `for` به نظر برسد. مزیت اصلی `map`/`filter` در خوانایی برای توابع پیچیده یا از پیش تعریف شده و همچنین مدیریت حافظه بهتر برای داده‌های بزرگ و بی‌نهایت (به دلیل laziness) است. همیشه قبل از بهینه‌سازی، پروفایل‌گیری (profiling) انجام بده تا گلوگاه واقعی رو پیدا کنی. همچنین، بهینه سازی زودرس (premature optimization) غالبا باعث ایجاد مشکلات جدید می‌شود.

• مشکل: نمی‌دانم چه زمانی `map` و چه زمانی `filter` را استفاده کنم؟

  راه‌حل: قانون طلایی این است:

  • اگر می‌خواهی هر آیتم را به آیتم دیگری “تبدیل” (transform) کنی، از `map` استفاده کن (مثلاً تبدیل عدد به رشته، ضرب در یک عدد، اعمال یک تابع محاسباتی).
  • اگر می‌خواهی آیتم‌هایی را بر اساس یک “شرط” (condition) “انتخاب” یا “حذف” کنی، از `filter` استفاده کن (مثلاً انتخاب اعداد زوج، حذف کلمات کوتاه، فقط فعال بودن کاربران).

  اگر نیاز به هر دو داری، می‌تونی آن‌ها رو ترکیب کنی (زنجیره‌ای کنی).

نتیجه‌گیری

همانطور که دیدیم، توابع `map` و `filter` ابزارهای قدرتمندی در جعبه ابزار هر برنامه‌نویس پایتون هستند. این توابع به شما کمک می‌کنند تا کدی تمیزتر، خواناتر و در برخی سناریوها، کارآمدتر بنویسید. در حالی که List Comprehension برای بسیاری از موارد کاربرد دارد و اغلب ترجیح داده می‌شود، درک و تسلط بر `map` و `filter` برای مواجهه با چالش‌های خاص، بهبود پرفورمنس در داده‌های بزرگ و نوشتن کدهای واقعاً پایتونیک ضروری است.

با تمرین و استفاده مداوم از این توابع در پروژه‌هایت، به زودی به طور غریزی می‌دانی که چه زمانی از کدام ابزار استفاده کنی. دنیای برنامه‌نویسی پایتون پر از راه‌حل‌های ظریف و کارآمد است، و `map` و `filter` تنها دو نمونه از آن‌ها هستند. برای کسب اطلاعات بیشتر و دیدن اسنیپت‌های کد مفید در زمینه‌های مختلف (از جمله HTML، CSS، وردپرس و سایر کدهای آماده)، حتماً به سایت ما سر بزن.

پرسش‌های متداول (FAQ Schema)