آموزش پایتون - بسته‌بندی و باز کردن بسته

بسته‌بندی (Packing) و باز کردن (Unpacking) تکنیک‌هایی هستند که در پایتون برای مدیریت چندین مقدار در یک متغیر واحد استفاده می‌شوند. این فرایند شبیه به بسته‌بندی وسایل در یک کیف و بیرون آوردن آن‌ها در صورت نیاز است. توابع پایتون می‌توانند برای پذیرش یک مجموعه بسته‌بندی‌شده از آرگومان‌ها استفاده شوند، که سپس می‌توانند در داخل تابع برای پردازش بیشتر باز شوند. به این کار بسته‌بندی (Packing) و باز کردن (Unpacking) آرگومان‌ها گفته می‌شود.

در این فصل، به بررسی تمامی جزئیات بسته‌بندی و باز کردن در پایتون و نحوه انجام آن در داخل آرگومان‌های تابع خواهیم پرداخت. سرفصل‌هایی که در این فصل به آن‌ها می‌پردازیم عبارتند از −

• بسته‌بندی و باز کردن چیست؟
• بسته‌بندی و باز کردن تاپل‌ها در پایتون
• بسته‌بندی آرگومان‌ها در پایتون
• باز کردن آرگومان‌ها در پایتون
• کاربرد واقعی بسته‌بندی و باز کردن آرگومان‌ها
• مقایسه بسته‌بندی و باز کردن آرگومان‌ها

بسته‌بندی و باز کردن چیست؟

بسته‌بندی (Packing) تکنیکی است که برای گروه‌بندی چندین مقدار در یک متغیر واحد استفاده می‌شود. به عنوان مثال، هنگام فراخوانی یک تابع، می‌توانید چندین آرگومان را با بسته‌بندی آن‌ها در یک تاپل یا لیست ارسال کنید. باز کردن (Unpacking) دقیقاً عکس فرایند بسته‌بندی است. این تکنیک برای استخراج مقادیر منفرد از یک متغیر بسته‌بندی‌شده و انتساب آن‌ها به متغیرهای مجزا استفاده می‌شود. به طور کلی، باز کردن در داخل توابع انجام می‌شود تا به مقادیر منفردِ یک متغیر بسته‌بندی‌شده دسترسی پیدا کنیم.

در پایتون، بسته‌بندی و باز کردن با استفاده از نمادهای زیر انجام می‌شود −

• * − برای بسته‌بندی یا باز کردن تعداد متغیری از آرگومان‌های موقعیتی (positional arguments) استفاده می‌شود.
• ** − برای بسته‌بندی یا باز کردن تعداد متغیری از آرگومان‌های کلیدواژه‌ای (keyword arguments) استفاده می‌شود.

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

# Packing Example
def pack_example(*args):
    print("Packed arguments:", args)
pack_example(1, 2, 3, 'a', 'b')

# Unpacking Example
def unpack_example(a, b, c):
    print("Unpacked arguments:", a, b, c)
values = [1, 2, 3]
unpack_example(*values)

خروجی کد بالا به صورت زیر خواهد بود −

Packed arguments: (1, 2, 3, 'a', 'b')
Unpacked arguments: 1 2 3

بسته‌بندی و باز کردن تاپل‌ها در پایتون

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

می‌توانید از سینتکس زیر برای بسته‌بندی و باز کردن تاپل‌ها در پایتون استفاده کنید −

# Packing a tuple
my_tuple = (1, 2, 3)

# Unpacking a tuple
a, b, c = my_tuple

مثال ۱

در این مثال، تاپل شامل ۶ مقدار است و متغیرهایی که قرار است باز شوند ۳ عدد هستند. ما علامت "*" را قبل از متغیر دوم قرار می‌دهیم.

tup1 = (10,20,30, 40, 50, 60)
x, *y, z = tup1
print ("x: ",x, "y: ", y, "z: ", z)

این کد خروجی زیر را تولید خواهد کرد −

x: 10 y: [20, 30, 40, 50] z: 60

در اینجا، ابتدا مقادیر در "x" و "z" باز می‌شوند و سپس بقیه مقادیر به صورت یک لیست به "y" اختصاص داده می‌شوند.

مثال ۲

در این مثال، پیشوند "*" را به متغیر اول اضافه می‌کنیم و می‌بینیم که خروجی چه خواهد بود.

tup1 = (10,20,30, 40, 50, 60)
*x, y, z = tup1
print ("x: ",x, "y: ", y, "z: ", z) 

این کد خروجی زیر را تولید خواهد کرد −

x: [10, 20, 30, 40] y: 50 z: 60

در اینجا نیز تاپل به گونه‌ای باز می‌شود که متغیرهای منفرد ابتدا یک مقدار واحد را برمی‌دارند و مقادیر باقی‌مانده را برای لیست "x" باقی می‌گذارند.

بسته‌بندی آرگومان‌ها در پایتون

بسته‌بندی آرگومان‌ها به فرایند جمع‌آوری چندین آرگومان در یک پارامتر واحد تابع اشاره دارد. این کار زمانی مفید است که یک شیء قابل پیمایش (مانند لیست یا تاپل) یا یک دیکشنری را به تابع ارسال می‌کنید و می‌خواهید آن‌ها را در یک پارامتر واحد ترکیب کنید.

دو راه برای بسته‌بندی آرگومان‌ها در پایتون وجود دارد -

• *args: برای بسته‌بندی چندین آرگومان موقعیتی در یک تاپل استفاده می‌شود.
• **kwargs**: برای بسته‌بندی چندین آرگومان کلیدواژه‌ای در یک دیکشنری استفاده می‌شود.

بسته‌بندی آرگومان‌ها با *args

در مثال زیر، تابعی را تعریف کرده‌ایم که از *args برای ترکیب چندین آرگومان موقعیتی در یک تاپل واحد استفاده می‌کند. سپس کل تاپل را با استفاده از یک دستور print چاپ می‌کنیم.

def pack_args(*args):
    print("Packed arguments:", args)

# Calling the function with multiple arguments
pack_args(1, 2, 3, 'a', 'b')

خروجی کد بالا به صورت زیر خواهد بود −

Packed arguments: (1, 2, 3, 'a', 'b')

بسته‌بندی آرگومان‌ها با **kwargs

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

def pack_kwargs(**kwargs):
    print("Packed keyword arguments:", kwargs)

# Calling the function with multiple keyword arguments
pack_kwargs(name="Alice", age=30, city="New York")

خروجی کد بالا به صورت زیر خواهد بود −

Packed keyword arguments: {'name': 'Alice', 'age': 30, 'city': 'New York'}

باز کردن آرگومان‌ها در پایتون

باز کردن آرگومان‌ها (Unpacking arguments) دقیقاً نقطه مقابل بسته‌بندی آرگومان‌ها است. در این حالت، ما یک مجموعه کامل (مانند لیست، تاپل یا دیکشنری) را به یک تابع ارسال می‌کنیم و عناصر آن را به آرگومان‌های منفرد در داخل تابع باز می‌کنیم. دو راه برای باز کردن آرگومان‌ها در پایتون وجود دارد.

باز کردن آرگومان‌ها با *

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

def unpack_args(a, b, c):
    print("Unpacked arguments:", a, b, c)

# List of values to unpack
values = [1, 2, 3]
# Calling the function with unpacked values
unpack_args(*values)

خروجی کد بالا به صورت زیر خواهد بود −

Unpacked arguments: 1 2 3

باز کردن آرگومان‌ها با **

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

def unpack_kwargs(name, age, city):
    print("Unpacked keyword arguments:", name, age, city)

# Dictionary of values to unpack
info = {"name": "Farhan", "age": 25, "city": "Los Angeles"}

# Calling the function with unpacked values
unpack_kwargs(**info)

خروجی کد بالا به صورت زیر خواهد بود −

Unpacked keyword arguments: Farhan 25 Los Angeles

کاربرد واقعی بسته‌بندی و باز کردن آرگومان‌ها

بسته‌بندی و باز کردن آرگومان‌ها معمولاً در برنامه‌های کاربردی دنیای واقعی استفاده می‌شوند. در اینجا یک مثال از برنامه سبد خرید آورده شده است که در آن از بسته‌بندی و باز کردن آرگومان‌ها برای مدیریت تعداد متغیری از آیتم‌ها و جزئیات آن‌ها استفاده می‌کنیم.

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

# Function that accepts variable number of items (packing with *args)
def calculate_total(*items):
    print("Items in cart:", items)
    return sum(items)

# Function that accepts variable keyword arguments (packing with **kwargs)
def print_invoice(customer_name, **details):
    print(f"Invoice for {customer_name}")
    for key, value in details.items():
        print(f"{key}: {value}")

# _ Unpacking Example _

# Order items (list of prices)
order_items = [250, 100, 75]   # Prices of products
total_amount = calculate_total(*order_items)   # Unpacking list
print("Total Amount:", total_amount)

# Order details (dictionary)
order_details = {
    "Product": "Laptop",
    "Quantity": 1,
    "Price": total_amount,
    "Payment Method": "Credit Card"
}

# Passing dictionary as keyword args
print_invoice("Farhan", **order_details)

خروجی کد بالا به صورت زیر خواهد بود −

Items in cart: (250, 100, 75)
Total Amount: 425
Invoice for Farhan
Product: Laptop
Quantity: 1
Price: 425
Payment Method: Credit Card

مقایسه بسته‌بندی و باز کردن آرگومان‌ها

در اینجا مقایسه تفصیلی بسته‌بندی و باز کردن آرگومان‌ها در پایتون آورده شده است −

نتیجه‌گیری

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