آشنایی با args* و kwargs** در پایتون — همراه با مثال

args* و kwargs** در پایتون ابزارهایی بسیار مفید و پرکاربرد هستند که به ما این امکان را می‌دهند تا توابعی را تعریف کنیم که قادر به پذیرش تعداد متغیری از پارامترها باشند. این ویژگی‌ها به‌ویژه زمانی که نیاز داریم توابعی بسازیم که بتوانند ورودی‌های مختلف با تعداد مشخص یا متغیر را مدیریت کنند، بسیار کاربردی و ضروری هستند. به کمک این ابزارها، دیگر نیازی به تعریف تعداد دقیق آرگومان‌ها در هر تابع نخواهیم داشت و می‌توانیم ورودی‌هایی با تعداد متغیر را به راحتی پذیرش کنیم. در این مقاله از سری مقاله‌های آموزشی مجله پی استور، به آشنایی با args* و kwargs** در پایتون خواهیم پرداخت، همراه با مثال‌های کاربردی که به‌طور کامل مفهوم این دو ویژگی را شرح می‌دهند.

یکی از مهم‌ترین مزایای استفاده از args* و kwargs** در پایتون، انعطاف‌پذیری بالای آن‌هاست که به برنامه‌نویسان این امکان را می‌دهد که توابع خود را به گونه‌ای طراحی کنند که برای استفاده در شرایط مختلف و با ورودی‌های متفاوت مناسب باشند. این ویژگی‌ها به‌ویژه در برنامه‌هایی که نیاز به انجام عملیات بر روی ورودی‌های متغیر دارند، مانند پردازش داده‌های ورودی از منابع مختلف یا دریافت ورودی از کاربر، بسیار مفید هستند. علاوه بر این، استفاده از args و kwargs در توابع باعث ساده‌تر شدن کد می‌شود و از پیچیدگی‌های اضافی جلوگیری می‌کند.

مقدمه

args* و kwargs** در پایتون به ما این امکان را می‌دهند که تعداد متغیر «Variable» و نامشخصی از پارامترها را به یک تابع ارسال کنیم. برای این کار از دو نوع پارامتر استفاده می‌شود:

1. args: پارامتر args برای ارسال تعداد دلخواه از پارامترها به تابع استفاده می‌شود که به صورت یک لیست از مقادیر به تابع منتقل می‌شود.
2. kwargs: پارامتر kwargs برای ارسال پارامترهای کلید-مقدار به تابع کاربرد دارد و این پارامترها به صورت یک دیکشنری «Dictionary» به تابع منتقل می‌شوند. این ویژگی‌ها به برنامه‌نویس این امکان را می‌دهند که توابعی بنویسند که انعطاف‌پذیری بیشتری در دریافت ورودی‌ها داشته باشند و نیاز به تغییرات مداوم در کد نباشد.

مثال پارامترهای انعطاف پذیر args* و kwargs** در پایتون

# *args example
def fun(*args):
    return sum(args)

print(fun(1, 2, 3, 4)) 
print(fun(5, 10, 15))   

# **kwargs example
def fun(**kwargs):
    for k, val in kwargs.items():
        print(k, val)

fun(a=1, b=2, c=3)

خروجی:

۱۰
۳۰
a 1
b 2
c 3

در پایتون، دو نماد ویژه برای ارسال چندین پارامتر وجود دارد: args* و kwargs** در پایتون. این دو نماد به‌طور عمده در مواقعی به کار می‌روند که نیاز داریم تعداد متغیری از پارامترها را به یک تابع ارسال کنیم. به کمک این ویژگی‌ها، توابع به راحتی می‌توانند ورودی‌های مختلف با تعداد دلخواه را دریافت کنند، بدون اینکه نیازی به تعریف تعداد دقیقی از پارامترها در زمان نوشتن تابع باشد. در ادامه دقیق‌تر به بررسی این دو نماد ویژه می‌پردازیم:

نمادهای ویژه‌ای که برای ارسال پارامترها در پایتون استفاده می‌شوند:

• args (پارامترهای غیرکلمه‌ای)
• kwargs (پارامترهای کلمه‌ای)

توجه: ما از نماد «wildcard» یا «*» به این صورت استفاده می‌کنیم. args* و kwargs** در پایتون به عنوان پارامتر تابع زمانی که در مورد تعداد پارامترهایی که باید به تابع ارسال کنیم، شک داریم.

نحوه پارامتر args* در پایتون

نحو ویژه args* در تعریف توابع برای ارسال تعداد متغیری از پارامترها به یک تابع استفاده می‌شود. این ویژگی برای ارسال یک لیست پارامتر متغیر و غیرکلمه‌ای به کار می‌رود.

برای مثال، فرض کنیم می‌خواهیم یک تابع ضرب بسازیم که هر تعداد پارامتر را دریافت کند و همه آن‌ها را با هم ضرب کند. این کار با استفاده از args* قابل انجام است. با استفاده از *، متغیری که با * مرتبط می‌شود، قابلیت تکرار پیدا می‌کند، به این معنی که می‌توان از آن برای کارهایی مانند تکرار کردن، اجرای توابع سطح بالایی مانند map و filter و غیره استفاده کرد.

در پایتون، برای استفاده از args* و ارسال تعداد متغیر پارامترها به یک تابع، می‌توانیم تابعی بنویسیم که هر تعداد پارامتر را بپذیرد و بر اساس آن‌ها عملیاتی انجام دهد. این تابع به طور مثال می‌تواند مجموعه‌ای از پارامترها را با هم جمع کند یا ضرب کند.

def myFun(*argv):
    for arg in argv:
        print(arg)


myFun('Hello', 'Welcome', 'to', 'ProgramStore')

خروجی:

Hello
Welcome
to
ProgramStore

مثال زیر نشان دهنده ی استفاده از args* با یک پارامتر اضافی اول است:

def fun(arg1, *argv):
    print("First argument :", arg1)
    for arg in argv:
        print("Argument *argv :", arg)


fun('Hello', 'Welcome', 'to', 'ProgramStore')

خروجی:

First argument : Hello
Argument *argv : Welcome
Argument *argv : to
Argument *argv : ProgramStore

نحوه پارامتر kwargs** در پایتون

سینتکس خاص kwargs** در تعریف توابع برای ارسال یک لیست پارامتر با طول متغیر استفاده می‌شود. ما از نام kwargs با دو ستاره ** استفاده می‌کنیم.

پارامتر کلیدی «keyword argument» جایی است که شما یک نام برای متغیر تعیین می‌کنید و آن را هنگام فراخوانی تابع ارسال می‌کنید. این پارامترها تمام پارامترهای کلیدی اضافی که به تابع ارسال می‌شوند را جمع‌آوری کرده و در یک دیکشنری ذخیره می‌کند.

def fun(**kwargs):
    for k, val in kwargs.items():
        print("%s == %s" % (k, val))


# Driver code
fun(s1='Program', s2='Store', s3='Tabriz')

خروجی:

s1 == Program
s2 == Store
s3 == Tabriz

برای s1=Program، s1 کلید است و Program مقدار است. به عبارت ساده، آنچه که می‌فرستیم مقدار است و به چه چیزی می‌فرستیم کلید است.

def fun(arg1, **kwargs):
    for k, val in kwargs.items():
        print("%s == %s" % (k, val))


# Driver code
fun("Hi", s1='Program', s2='Store', s3='Tabriz')

خروجی:

s1 == Program
s2 == Store
s3 == Tabriz

استفاده همزمان از args* و kwargs** در پایتون

ما می‌توانیم از args* و kwargs** در یک تابع به طور همزمان استفاده کنیم تا ترکیبی از پارامترهای موقعیتی و کلیدی را قبول کنیم.

def fun(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

fun(1, 2, 3, a=4, b=5)

خروجی:

Positional arguments: (1, 2, 3)
Keyword arguments: {'a': 4, 'b': 5}

در این مثال، تابع می‌تواند هم آرگومان‌های موقعیتی و هم آرگومان‌های کلیدی را پردازش کند. پارامتر args* آرگومان‌های موقعیتی را در یک تاپل جمع‌آوری می‌کند، در حالی که پارامتر kwargs** آرگومان‌های کلیدی را در یک دیکشنری جمع‌آوری می‌کند.

نتیجه گیری

args* و kwargs** در پایتون از ویژگی‌های مهم و کاربردی برای مدیریت تعداد متغیری از آرگومان‌ها در توابع هستند. این دو قابلیت به شما اجازه می‌دهند کدی بنویسید که انعطاف‌پذیرتر باشد و بتواند با آرگومان‌های متنوع کار کند. args* برای گرفتن مجموعه‌ای از آرگومان‌های غیرکلیدی استفاده می‌شود و این آرگومان‌ها به صورت یک تاپل «tuple» به تابع ارسال می‌شوند. از طرف دیگر، kwargs** برای دریافت آرگومان‌های کلیدی به کار می‌رود و این آرگومان‌ها به صورت یک دیکشنری «dictionary» در اختیار تابع قرار می‌گیرند.

ترکیب args* و kwargs** در پایتون به شما امکان می‌دهد توابعی تعریف کنید که بتوانند نیازهای پیچیده را بدون تغییر مداوم در امضا «signature» آن‌ها برآورده کنند. علاوه بر این، این ویژگی در انتقال آرگومان‌ها بین توابع نیز بسیار مفید است. به طور خلاصه، استفاده از args* و kwargs** در پایتون کدنویسی را کارآمدتر، ساده‌تر و منعطف‌تر می‌کند.