راهبر لکوموتیو

باز کردن به عمل استخراج عناصر یک مجموعه، مانند list، tuple یا dict، با استفاده از پیمایش اشاره دارد. مقادیر بازشده را میتوان در همان دستور به متغیرها انتساب داد، که معمولاً به آن انتساب چندگانه میگویند.

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

انتساب چندگانه

در انتساب چندگانه، تعداد متغیرهای سمت چپ عملگر انتساب (=) باید با تعداد مقادیر سمت راست برابر باشد. برای جدا کردن مقادیر، از یک کاما (,) استفاده کنید:

>>> a, b = 1, 2
>>> a
1

اگر انتساب چندگانه تعداد متغیرهای نامتناسبی برای مقادیر دادهشده دریافت کند، یک ValueError صادر میشود:

>>> x, y, z = 1, 2

ValueError: too many values to unpack (expected 3, got 2)

انتساب چندگانه به یک نوع داده محدود نمیشود:

>>> x, y, z = 1, "Hello", True
>>> x
1

>>> y
'Hello'

>>> z
True

انتساب چندگانه را میتوان برای جابهجایی عناصر در lists به کار برد. این کار در الگوریتمهای مرتبسازی بسیار رایج است. برای مثال:

>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]

از آنجا که tuples تغییرناپذیرند، نمیتوانید عناصر یک tuple را جابهجا کنید.

باز کردن

در Python امکان باز کردن عناصر list/tuple/dictionary در متغیرهای مجزا وجود دارد. از آنجا که مقادیر درون lists/tuples به ترتیب مشخصی ظاهر میشوند، به همان ترتیب در متغیرها باز میشوند:

>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"

اگر مقادیری لازم نیستند، میتوانید با _ آنها را علامت بزنید:

>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"

باز کردن عمیق

باز کردن و انتساب مقادیر از یک list/tuple که درون یک list یا tuple جای گرفته است (که به آن list/tuple تودرتو هم میگویند) مانند باز کردن سطحی عمل میکند، اما اغلب به مشخصکنندههایی برای روشن کردن زمینه یا موقعیت نیاز دارد:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"

>>> d
"potato"

همچنین میتوانید فقط بخشی از یک list/tuple تودرتو را بهصورت عمیق باز کنید:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]

>>> c
"carrot"

اگر در باز کردن، متغیرها جایگیری نادرست و/یا تعداد نادرستی از مقادیر داشته باشند، یک ValueError دریافت میکنید:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables

ValueError: too many values to unpack (expected 1)

باز کردن یک list/tuple با *

هنگام باز کردن یک list/tuple میتوانید از عملگر * برای گرفتن مقادیر «باقیمانده» استفاده کنید. این روش از برش دادن list/tuple روشنتر است (که در برخی موقعیتها خوانایی کمتری دارد). برای مثال، میتوان اولین عنصر را استخراج کرد و سپس مقادیر باقیمانده را در یک list جدید بدون عنصر اول قرار داد:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"

>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]

همچنین میتوانیم مقادیر ابتدا و انتهای list را استخراج کنیم و در همین حال همهی مقادیر میانی را گروهبندی کنیم:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"

>>> middle
["banana", "cherry", "orange", "kiwi"]

همچنین میتوانیم از * در باز کردن عمیق استفاده کنیم:

>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"

>>> rest
["banana", "melon"]

باز کردن یک dictionary

باز کردن یک dictionary تا حدی با باز کردن یک list/tuple تفاوت دارد. پیمایش روی dictionaryها بهطور پیشفرض روی کلیدها انجام میشود. پس هنگام باز کردن یک dict، تنها میتوانید کلیدها را باز کنید و نه مقادیر را:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"

اگر میخواهید مقادیر را باز کنید، میتوانید از متد <dict>.values() استفاده کنید:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6

اگر هم کلیدها و هم مقادیر لازم باشند، از متد <dict>.items() استفاده کنید. متد <dict>.items() یک نمای تکرارپذیر تولید میکند که شامل جفتهای کلید-مقدار است. اینها را میتوان در یک tuple باز کرد:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)

بستهبندی

بستهبندی توانایی گروهبندی چندین مقدار در یک list است که به یک متغیر انتساب داده میشود. این کار زمانی مفید است که بخواهید مقادیر را باز کنید، تغییراتی بدهید و سپس نتایج را دوباره در یک متغیر بستهبندی کنید. همچنین امکان ادغام دو یا چند lists/tuples/dicts را فراهم میکند.

بستهبندی یک list/tuple با *

بستهبندی یک list/tuple را میتوان با عملگر * انجام داد. این کار همهی مقادیر را در یک list/tuple بستهبندی میکند.

>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]

# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits

# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']

برای اطلاعات بیشتر دربارهی استفاده از * در سمت چپ، PEP 3132 را ببینید.

بستهبندی یک dictionary با **

بستهبندی یک dictionary با استفاده از عملگر ** انجام میشود. این کار همهی جفتهای کلید-مقدار را از یک dictionary در dictionary دیگری بستهبندی میکند، یا دو dictionary را با هم ترکیب میکند.

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}

# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

کاربرد * و ** همراه با توابع

بستهبندی با پارامترهای تابع

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

کاربرد *args:

# This function is defined to take any number of positional arguments

>>> def my_function(*args):
...     print(args)

# Arguments given to the function are packed into a tuple

>>> my_function(1, 2, 3)
(1, 2, 3)

>>> my_function("Hello")
("Hello")

>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")

کاربرد **kwargs:

# This function is defined to take any number of keyword arguments

>>> def my_function(**kwargs):
...   print(kwargs)

# Arguments given to the function are packed into a dictionary

>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}

*args و **kwargs را میتوان بهصورت ترکیبی با یکدیگر هم به کار برد:

>>> def my_function(*args, **kwargs):
...   print(sum(args))
...   for key, value in kwargs.items():
...       print(str(key) + " = " + str(value))

>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3

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

>>> def my_function(a, b, *args):
...   print(a)
...   print(b)
...   print(args)

>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)

نوشتن آرگومانها با ترتیب نادرست به خطا منجر میشود:

>>>def my_function(*args, a, b):
... print(args)

>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
  File "c:\something.py", line 3, in <module>
    my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'

باز کردن در فراخوانی توابع

میتوانید از * برای باز کردن یک list/tuple از آرگومانها در یک فراخوانی تابع استفاده کنید. این کار برای توابعی که یک iterable را نمیپذیرند بسیار مفید است:

>>> def my_function(a, b, c):
...   print(c)
...   print(b)
...   print(a)

numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1

استفاده از باز کردن با * همراه با zip() توکار مورد کاربرد رایج دیگری است. تابع zip() چندین iterable میگیرد و یک list از tuples برمیگرداند که مقادیر هر iterable در آن گروهبندی شدهاند:

>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]