تابع tuple

تابع tuple در پایتون یک تابع پیش‌ساخته (built-in) است که یک شیء قابل تکرار را به یک تاپل تبدیل می‌کند. تاپل‌ها دنباله‌هایی تغییرناپذیر (immutable) هستند که می‌توانند انواع مختلف داده را در خود نگه دارند. tuple یکی از ساختارهای داده بنیادی پایتون است و در موقعیت‌هایی که نیاز به نگهداری مجموعه‌ای ثابت از مقادیر دارید، به ویژه به عنوان کلید دیکشنری یا خروجی توابعی که چند مقدار برمی‌گردانند، کاربرد گسترده‌ای دارد.

سینتکس تابع tuple

سینتکس کلی تابع tuple به صورت زیر است:

tuple(iterable=())

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

• آرگومان اختیاری iterable می‌تواند هر شیء قابل تکراری باشد که می‌خواهیم به تاپل تبدیل شود؛ مانند لیست، استرینگ، مجموعه، دیکشنری، range یا هر ایتریبل دیگری. اگر آرگومانی وارد نشود، یک تاپل خالی () برگردانده می‌شود.

مقدار بازگشتی تابع tuple همیشه یک شیء تغییرناپذیر از نوع tuple است.

کاربردهای تابع tuple

ساده‌ترین مثال از کاربرد این تابع می‌تواند حالت زیر باشد:

>>> tuple()
()
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple("hello")
('h', 'e', 'l', 'l', 'o')
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple({1, 2, 3})
(1, 2, 3)
>>> tuple({"a": 1, "b": 2})
('a', 'b')

تاپل‌ها می‌توانند انواع مختلف داده را در خود داشته باشند:

>>> mixed = tuple([1, "hello", 3.14, True, None])
>>> mixed
(1, 'hello', 3.14, True, None)

رایج‌ترین کاربردهای تابع tuple عبارتند از:

• تبدیل لیست یا سایر ایتریبل‌ها به تاپل برای جلوگیری از تغییر ناخواسته داده‌ها،
• استفاده از تاپل به عنوان کلید دیکشنری (چون تاپل‌ها hashable هستند)،
• بازگشت چند مقدار از یک تابع به صورت یکجا،
• ذخیره‌سازی داده‌های ثابت مثل مختصات، رنگ‌های RGB، یا تنظیمات پیکربندی.

تغییرناپذیری؛ تفاوت تاپل با لیست: مهم‌ترین تفاوت تاپل و لیست، تغییرناپذیر بودن تاپل است. بعد از ساخته شدن، نمی‌توانید عناصر آن را تغییر دهید:

>>> my_list = [1, 2, 3]
>>> my_list[0] = 99           # allowed operation
>>> my_list
[99, 2, 3]

>>> my_tuple = tuple([1, 2, 3])
>>> my_tuple[0] = 99          # TypeError!
TypeError: 'tuple' object does not support item assignment

یادآوری: داده‌های تغییرناپذیر (immutable) در پایتون، پس از ساخته شدن قابل تغییر نیستند و هر تغییری باعث ایجاد یک شیء جدید در حافظه می‌شود. برای مثال انواعی مثل str و tuple و int در Python تغییرناپذیر هستند.

همین تغییرناپذیری باعث می‌شود تاپل‌ها بتوانند کلید دیکشنری باشند، در حالی که لیست‌ها نمی‌توانند:

>>> coords = {(35.6892, 51.3890): "Rasht", (41.0082, 28.9784): "Tehran"}
>>> coords[(35.6892, 51.3890)]
'Rasht'

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

def min_max(numbers):
    return min(numbers), max(numbers)   # return as a tuple

result = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(result)          # (1, 9)
print(type(result))    # <class 'tuple'>

همین قابلیت باعث می‌شود مفهومی به نام باز کردن تاپل‌ها یا tuple unpacking وجود داشته باشد. در این روش، می‌توانیم چندین متغیر را در یک خط تعریف کنیم:

# tuple unpacking
low, high = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(low, high)       # output: 1 9

تاپل تک‌عنصری: برای ساخت تاپلی با یک عنصر، باید دقت داشته باشید:

>>> not_tuple = (42)                # wrong way!
>>> not_tuple       
42
>>> type(not_tuple) 
<class 'int'>

>>> single_element = tuple([42])    # using tuple() function
>>> single_element              
(42,)
>>> type(single_element)
<class 'tuple'>

>>> best_way = (42,)                # best way
>>> best_way        
(42,)
>>> type(best_way)
<class 'tuple'>

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

مثال واقعی از تابع tuple

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

raw_records = [
    ["A001", "Laptop", 45000000, 10],
    ["A002", "Mouse", 850000, 50],
    ["A003", "Keyboard", 2200000, 30],
    ["A004", "Headphone", 3200000, 15],
]

# converting each record to a tuple
inventory = [tuple(record) for record in raw_records]

# using tuple as dictionary key
price_lookup = {(r[0], r[1]): r[2] for r in inventory}

for record in inventory:
    code, name, price, qty = record    # tuple unpacking
    total = price * qty
    print(f"{name} ({code}): {price:,} Rials × {qty} = {total:,} Rials")

print("\nPrice Search:")
key = ("A002", "Mouse")
print(f"{key[1]} Price: {price_lookup[key]:,} Rials")

نمونه خروجی این کد به صورت زیر خواهد بود:

Laptop (A001): 45,000,000 Rials × 10 = 450,000,000 Rials
Mouse (A002): 850,000 Rials × 50 = 42,500,000 Rials
Keyboard (A003): 2,200,000 Rials × 30 = 66,000,000 Rials
Headphone (A004): 3,200,000 Rials × 15 = 48,000,000 Rials

Price Search:
Mouse Price: 850,000 Rials

در این مثال، تبدیل رکوردها به تاپل، هم داده‌ها را در برابر تغییر محافظت می‌کند و هم امکان استفاده از آنها به عنوان کلید دیکشنری را فراهم می‌کند.

تفاوت تابع tuple با list و set

هر سه می‌توانند مجموعه‌ای از عناصر را نگه دارند، اما رفتار متفاوتی دارند:

>>> data = [3, 1, 4, 1, 5, 9, 2, 6]

>>> tuple(data)
(3, 1, 4, 1, 5, 9, 2, 6)

>>> list(data)
[3, 1, 4, 1, 5, 9, 2, 6]

>>> set(data)
{1, 2, 3, 4, 5, 6, 9}

به صورت کلی، حین تبدیل یک ایتریبل:

• تبدیل به تاپل: تغییرناپذیر، ترتیب حفظ می‌شود، تکرار مجاز
• تبدیل به لیست: تغییرپذیر، ترتیب حفظ می‌شود، تکرار مجاز
• تبدیل به مجموعه: تغییرپذیر، ترتیب حفظ نمی‌شود، بدون تکرار

علاوه بر این، تاپل‌ها چون قابل هش (hashable) هستند، می‌توانند به عنوان کلید دیکشنری استفاده شوند اما لیست‌ها چنین قابلیتی ندارند:

>>> d = {tuple(data): "hashable"}
>>> d
{(3, 1, 4, 1, 5, 9, 2, 6): 'hashable'}

>>> d = {list(data): "not hashable"}
>>> d
TypeError: unhashable type: 'list'

یادآوری: یک شیء زمانی hashable است که مقدار هَش ثابتی داشته باشد و بتوان از آن به عنوان کلید دیکشنری یا عضو مجموعه استفاده کرد. در پایتون، معمولاً اشیای immutable مانند استرینگ و تاپل قابل هش هستند، اما انواع mutable مثل لیست قابل هش نیستند.

سوالات متداول

جهت کسب اطلاعات بیشتر می‌توانید به مستندات رسمی پایتون برای تابع tuple مراجعه کنید.