# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025

# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-08-18 04:30+0000\n"

"PO-Revision-Date: 2026-08-14 10:15+0330\n"

"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"

"Language-Team: Persian (https://github.com/revisto/python-docs-fa/)\n"

"Language: fa\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

"X-Generator: Poedit 3.6\n"

msgid "More Control Flow Tools"

msgstr "ابزارهای بیشتر برای کنترل جریان"

msgid "As well as the :keyword:`while` statement just introduced, Python uses a few more that we will encounter in this chapter."

msgstr "علاوه بر دستور :keyword:`while` که به‌تازگی معرفی شد، پایتون چند مورد دیگر نیز دارد که در این فصل با آن‌ها آشنا خواهیم شد."

msgid ":keyword:`!if` Statements"

msgstr "دستورهای :keyword:`!if`"

msgid "Perhaps the most well-known statement type is the :keyword:`if` statement. For example::"

msgstr "شاید شناخته‌شده‌ترین نوع دستور، دستور :keyword:`if` باشد. برای مثال::"

msgid ""

">>> x = int(input(\"Please enter an integer: \"))\n"

"Please enter an integer: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negative changed to zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Single')\n"

"... else:\n"

"... print('More')\n"

"...\n"

"More"

msgstr ""

">>> x = int(input(\"Please enter an integer: \"))\n"

"Please enter an integer: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negative changed to zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Single')\n"

"... else:\n"

"... print('More')\n"

"...\n"

"More"

msgid "There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is optional. The keyword ':keyword:`!elif`' is short for 'else if', and is useful to avoid excessive indentation. An :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the ``switch`` or ``case`` statements found in other languages."

msgstr "می‌تواند صفر یا چند بخش :keyword:`elif` وجود داشته باشد و بخش :keyword:`else` اختیاری است. کلیدواژه‌ای ':keyword:`!elif`' کوتاه‌شدهٔ 'else if' است و برای جلوگیری از تورفتگی بیش از حد مفید است. یک دنبالهٔ :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... جایگزینی برای دستورهای ``switch`` یا ``case`` موجود در زبان‌های دیگر است."

msgid "If you're comparing the same value to several constants, or checking for specific types or attributes, you may also find the :keyword:`!match` statement useful. For more details see :ref:`tut-match`."

msgstr "اگر یک مقدار یکسان را با چندین مقدار ثابت مقایسه می‌کنید، یا نوع‌ها یا ویژگی‌های خاصی را بررسی می‌کنید، ممکن است دستور :keyword:`!match` نیز برایتان مفید باشد. برای جزئیات بیشتر به :ref:`tut-match` مراجعه کنید."

msgid ":keyword:`!for` Statements"

msgstr "دستورهای :keyword:`!for`"

msgid "The :keyword:`for` statement in Python differs a bit from what you may be used to in C or Pascal. Rather than always iterating over an arithmetic progression of numbers (like in Pascal), or giving the user the ability to define both the iteration step and halting condition (as C), Python's :keyword:`!for` statement iterates over the items of any sequence (a list or a string), in the order that they appear in the sequence. For example (no pun intended):"

msgstr "دستور :keyword:`for` در پایتون کمی با چیزی که ممکن است در C یا Pascal به آن عادت کرده باشید تفاوت دارد. به‌جای اینکه همیشه روی یک تصاعد حسابی از اعداد پیمایش کند (مانند Pascal)، یا به کاربر امکان تعریف هم گام پیمایش و هم شرط توقف را بدهد (مانند C)، دستور :keyword:`!for` پایتون روی آیتم‌های هر دنباله‌ای (یک فهرست یا یک رشته) به ترتیبی که در دنباله ظاهر شده‌اند پیمایش می‌کند. برای مثال (بدون قصد استعاره):"

msgid ""

">>> # Measure some strings:\n"

">>> words = ['cat', 'window', 'defenestrate']\n"

">>> for w in words:\n"

"... print(w, len(w))\n"

"...\n"

"cat 3\n"

"window 6\n"

"defenestrate 12"

msgstr ""

">>> # اندازه‌گیری طول چند رشته:\n"

">>> words = ['cat', 'window', 'defenestrate']\n"

">>> for w in words:\n"

"... print(w, len(w))\n"

"...\n"

"cat 3\n"

"window 6\n"

"defenestrate 12"

msgid "Code that modifies a collection while iterating over that same collection can be tricky to get right. Instead, it is usually more straight-forward to loop over a copy of the collection or to create a new collection::"

msgstr "کدی که هنگام پیمایش روی یک مجموعه، همان مجموعه را تغییر می‌دهد، ممکن است به‌درستی نوشتن دشوار باشد. در عوض، معمولاً ساده‌تر است که روی یک کپی از مجموعه پیمایش کنید یا یک مجموعهٔ جدید ایجاد کنید::"

msgid ""

"# Create a sample collection\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# Strategy: Iterate over a copy\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# Strategy: Create a new collection\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

msgstr ""

"# ایجاد یک مجموعه‌ی نمونه\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# راهبرد: پیمایش روی یک کپی\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# راهبرد: ایجاد یک مجموعه‌ی جدید\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

msgid "The :func:`range` Function"

msgstr "تابع :func:`range`"

msgid "If you do need to iterate over a sequence of numbers, the built-in function :func:`range` comes in handy. It generates arithmetic progressions::"

msgstr "اگر واقعاً نیاز دارید روی یک دنباله از اعداد پیمایش کنید، تابع داخلی :func:`range` بسیار کاربردی است. این تابع تصاعدهای حسابی تولید می‌کند::"

msgid ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

msgstr ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

msgid "The given end point is never part of the generated sequence; ``range(10)`` generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the 'step')::"

msgstr "نقطهٔ پایانی داده‌شده هرگز بخشی از دنبالهٔ تولیدشده نیست؛ ``range(10)`` مقدار تولید می‌کند که همان اندیس‌‌های مجاز برای آیتم‌های یک دنباله با طول ۱۰ هستند. امکان این وجود دارد که شروع بازه را از عدد دیگری تعیین کنید، یا افزایشی متفاوت (حتی منفی؛ که گاهی «گام» نامیده می‌شود) مشخص کنید::"

msgid ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

msgstr ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

msgid "To iterate over the indices of a sequence, you can combine :func:`range` and :func:`len` as follows::"

msgstr "برای پیمایش روی اندیس‌‌های یک دنباله، می‌توانید :func:`range` و :func:`len` را به شکل زیر ترکیب کنید::"

msgid ""

">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Mary\n"

"1 had\n"

"2 a\n"

"3 little\n"

"4 lamb"

msgstr ""

">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Mary\n"

"1 had\n"

"2 a\n"

"3 little\n"

"4 lamb"

msgid "In most such cases, however, it is convenient to use the :func:`enumerate` function, see :ref:`tut-loopidioms`."

msgstr "بااین‌حال، در بیشتر چنین مواردی استفاده از تابع :func:`enumerate` راحت‌تر است؛ به :ref:`tut-loopidioms` مراجعه کنید."

msgid "A strange thing happens if you just print a range::"

msgstr "اگر فقط یک range را چاپ کنید، اتفاق عجیبی رخ می‌دهد::"

msgid ""

">>> range(10)\n"

"range(0, 10)"

msgstr ""

">>> range(10)\n"

"range(0, 10)"

msgid "In many ways the object returned by :func:`range` behaves as if it is a list, but in fact it isn't. It is an object which returns the successive items of the desired sequence when you iterate over it, but it doesn't really make the list, thus saving space."

msgstr "از بسیاری جهات، شیئی که توسط :func:`range` برگردانده می‌شود طوری رفتار می‌کند که گویی یک فهرست است، اما در واقع چنین نیست. این یک شیء است که هنگام پیمایش، آیتم‌های متوالی دنبالهٔ موردنظر را برمی‌گرداند، اما واقعاً فهرست را ایجاد نمی‌کند و در نتیجه در فضا صرفه‌جویی می‌شود."

msgid "We say such an object is :term:`iterable`, that is, suitable as a target for functions and constructs that expect something from which they can obtain successive items until the supply is exhausted. We have seen that the :keyword:`for` statement is such a construct, while an example of a function that takes an iterable is :func:`sum`::"

msgstr "می‌گوییم چنین شیئی :term:`iterable` است؛ یعنی برای استفاده به‌عنوان هدف تابع‌ها و ساختارهایی مناسب است که انتظار دارند چیزی وجود داشته باشد که بتوانند از آن آیتم‌های متوالی را تا زمانی که چیزی باقی نمانده است دریافت کنند. دیدیم که دستور :keyword:`for` چنین ساختاری است، در حالی که نمونه‌ای از تابعی که یک شیء تکرارپذیر دریافت می‌کند :func:`sum` است::"

msgid ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

msgstr ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

msgid "Later we will see more functions that return iterables and take iterables as arguments. In chapter :ref:`tut-structures`, we will discuss :func:`list` in more detail."

msgstr "بعداً تابع‌های بیشتری را خواهیم دید که اشیای تکرارپذیر برمی‌گردانند و اشیای تکرارپذیر را به‌عنوان آرگومان دریافت می‌کنند. در فصل :ref:`tut-structures`، دربارهٔ :func:`list` با جزئیات بیشتری صحبت خواهیم کرد."

msgid ":keyword:`!break` and :keyword:`!continue` Statements"

msgstr "دستورهای :keyword:`!break` و :keyword:`!continue`"

msgid "The :keyword:`break` statement breaks out of the innermost enclosing :keyword:`for` or :keyword:`while` loop::"

msgstr "دستور :keyword:`break` از داخلی‌ترین حلقهٔ محصورکنندهٔ :keyword:`for` یا :keyword:`while` خارج می‌شود::"

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} equals {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 equals 2 * 2\n"

"6 equals 2 * 3\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} equals {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 equals 2 * 2\n"

"6 equals 2 * 3\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgid "The :keyword:`continue` statement continues with the next iteration of the loop::"

msgstr "دستور :keyword:`continue` به تکرار بعدی حلقه ادامه می‌دهد::"

msgid ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Found an even number {num}\")\n"

"... continue\n"

"... print(f\"Found an odd number {num}\")\n"

"...\n"

"Found an even number 2\n"

"Found an odd number 3\n"

"Found an even number 4\n"

"Found an odd number 5\n"

"Found an even number 6\n"

"Found an odd number 7\n"

"Found an even number 8\n"

"Found an odd number 9"

msgstr ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Found an even number {num}\")\n"

"... continue\n"

"... print(f\"Found an odd number {num}\")\n"

"...\n"

"Found an even number 2\n"

"Found an odd number 3\n"

"Found an even number 4\n"

"Found an odd number 5\n"

"Found an even number 6\n"

"Found an odd number 7\n"

"Found an even number 8\n"

"Found an odd number 9"

msgid ":keyword:`!else` Clauses on Loops"

msgstr "بخش‌های :keyword:`!else` در حلقه‌ها"

msgid "In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` statement may be paired with an :keyword:`!else` clause. If the loop finishes without executing the :keyword:`!break`, the :keyword:`!else` clause executes."

msgstr "در یک حلقهٔ :keyword:`!for` یا :keyword:`!while`، دستور :keyword:`!break` می‌تواند با یک بخش :keyword:`!else` همراه شود. اگر حلقه بدون اجرای :keyword:`!break` به پایان برسد، بخش :keyword:`!else` اجرا می‌شود."

msgid "In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the loop finishes its final iteration, that is, if no break occurred."

msgstr "در یک حلقهٔ :keyword:`for`، بخش :keyword:`!else` پس از پایان آخرین تکرار حلقه اجرا می‌شود؛ یعنی زمانی که هیچ breakای رخ نداده باشد."

msgid "In a :keyword:`while` loop, it's executed after the loop's condition becomes false."

msgstr "در یک حلقهٔ :keyword:`while`، این بخش پس از نادرست شدن شرط حلقه اجرا می‌شود."

msgid "In either kind of loop, the :keyword:`!else` clause is **not** executed if the loop was terminated by a :keyword:`break`. Of course, other ways of ending the loop early, such as a :keyword:`return` or a raised exception, will also skip execution of the :keyword:`else` clause."

msgstr "در هر دو نوع حلقه، بخش :keyword:`!else` در صورتی **اجرا نمی‌شود** که حلقه توسط یک :keyword:`break` خاتمه یافته باشد. البته روش‌های دیگر پایان زودهنگام حلقه، مانند یک :keyword:`return` یا ایجاد شدن یک استثنا، نیز اجرای بخش :keyword:`else` را رد می‌کنند."

msgid "This is exemplified in the following :keyword:`!for` loop, which searches for prime numbers::"

msgstr "این موضوع در حلقهٔ :keyword:`!for` زیر نشان داده شده است که به دنبال اعداد اول می‌گردد::"

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'equals', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # loop fell through without finding a factor\n"

"... print(n, 'is a prime number')\n"

"...\n"

"2 is a prime number\n"

"3 is a prime number\n"

"4 equals 2 * 2\n"

"5 is a prime number\n"

"6 equals 2 * 3\n"

"7 is a prime number\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'equals', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # حلقه بدون پیدا کردن هیچ مقسوم‌علیهی به پایان رسید\n"

"... print(n, 'is a prime number')\n"

"...\n"

"2 is a prime number\n"

"3 is a prime number\n"

"4 equals 2 * 2\n"

"5 is a prime number\n"

"6 equals 2 * 3\n"

"7 is a prime number\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgid "(Yes, this is the correct code. Look closely: the ``else`` clause belongs to the ``for`` loop, **not** the ``if`` statement.)"

msgstr "(بله، این کد درست است. با دقت نگاه کنید: بخش ``else`` به حلقهٔ ``for`` تعلق دارد، **نه** به دستور ``if``.)"

msgid "One way to think of the else clause is to imagine it paired with the ``if`` inside the loop. As the loop executes, it will run a sequence like if/if/if/else. The ``if`` is inside the loop, encountered a number of times. If the condition is ever true, a ``break`` will happen. If the condition is never true, the ``else`` clause outside the loop will execute."

msgstr "یک راه برای فکر کردن دربارهٔ بخش else این است که تصور کنید با دستور ``if`` داخل حلقه جفت شده است. هنگام اجرای حلقه، دنباله‌ای مانند if/if/if/else اجرا می‌شود. دستور ``if`` داخل حلقه قرار دارد و چندین بار بررسی می‌شود. اگر شرط هرگز درست شود، یک ``break`` رخ می‌دهد. اگر شرط هیچ‌گاه درست نشود، بخش ``else`` خارج از حلقه اجرا خواهد شد."

msgid "When used with a loop, the ``else`` clause has more in common with the ``else`` clause of a :keyword:`try` statement than it does with that of ``if`` statements: a ``try`` statement's ``else`` clause runs when no exception occurs, and a loop's ``else`` clause runs when no ``break`` occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-handling`."

msgstr "هنگام استفاده از یک حلقه، بخش ``else`` شباهت بیشتری به بخش ``else`` دستور :keyword:`try` دارد تا دستورهای ``if``: بخش ``else`` یک دستور ``try`` زمانی اجرا می‌شود که هیچ استثنایی رخ ندهد، و بخش ``else`` یک حلقه زمانی اجرا می‌شود که هیچ ``break`` ای رخ ندهد. برای اطلاعات بیشتر دربارهٔ دستور ``try`` و استثناها، به :ref:`tut-handling` مراجعه کنید."

msgid ":keyword:`!pass` Statements"

msgstr "دستورهای :keyword:`!pass`"

msgid "The :keyword:`pass` statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example::"

msgstr "دستور :keyword:`pass` هیچ کاری انجام نمی‌دهد. زمانی می‌توان از آن استفاده کرد که از نظر نحوی وجود یک دستور لازم باشد، اما برنامه به هیچ عملی نیاز نداشته باشد. برای مثال::"

msgid ""

">>> while True:\n"

"... pass # Busy-wait for keyboard interrupt (Ctrl+C)\n"

"..."

msgstr ""

">>> while True:\n"

"... pass # انتظار فعال برای وقفه‌ی صفحه‌کلید (Ctrl+C)\n"

"..."

msgid "This is commonly used for creating minimal classes::"

msgstr "این دستور معمولاً برای ایجاد کلاس‌های حداقلی استفاده می‌شود::"

msgid ""

">>> class MyEmptyClass:\n"

"... pass\n"

"..."

msgstr ""

">>> class MyEmptyClass:\n"

"... pass\n"

"..."

msgid "Another place :keyword:`pass` can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The :keyword:`!pass` is silently ignored::"

msgstr "جای دیگری که می‌توان از :keyword:`pass` استفاده کرد، به‌عنوان جای‌نگهدار برای بدنهٔ یک تابع یا شرط در زمانی است که روی کد جدید کار می‌کنید؛ این کار به شما اجازه می‌دهد در سطح انتزاعی‌تری به فکر کردن ادامه دهید. :keyword:`!pass` به‌صورت بی‌صدا نادیده گرفته می‌شود::"

msgid ""

">>> def initlog(*args):\n"

"... pass # Remember to implement this!\n"

"..."

msgstr ""

">>> def initlog(*args):\n"

"... pass # فراموش نکنید این تابع را پیاده‌سازی کنید!\n"

"..."

msgid "For this last case, many people use the ellipsis literal :code:`...` instead of :code:`pass`. This use has no special meaning to Python, and is not part of the language definition (you could use any constant expression here), but :code:`...` is used conventionally as a placeholder body as well. See :ref:`bltin-ellipsis-object`."

msgstr "برای حالت آخر، بسیاری از افراد به‌جای :code:`pass` از مقدار لفظی بیضی :code:`...` استفاده می‌کنند. این استفاده هیچ معنای ویژه‌ای برای پایتون ندارد و بخشی از تعریف زبان نیست (در اینجا می‌توانستید از هر عبارت ثابتی استفاده کنید)، اما :code:`...` به‌صورت قراردادی به‌عنوان بدنهٔ جای‌نگهدار نیز استفاده می‌شود. به :ref:`bltin-ellipsis-object` مراجعه کنید."

msgid ":keyword:`!match` Statements"

msgstr ":keyword:`!match` دستورات"

msgid "A :keyword:`match` statement takes an expression and compares its value to successive patterns given as one or more case blocks. This is superficially similar to a switch statement in C, Java or JavaScript (and many other languages), but it's more similar to pattern matching in languages like Rust or Haskell. Only the first pattern that matches gets executed and it can also extract components (sequence elements or object attributes) from the value into variables. If no case matches, none of the branches is executed."

msgstr "یک دستور :keyword:`match` یک عبارت را دریافت می‌کند و مقدار آن را با الگوهای متوالی که در یک یا چند بلوک case ارائه شده‌اند مقایسه می‌کند. این دستور در ظاهر شبیه دستور switch در C، Java یا JavaScript (و بسیاری از زبان‌های دیگر) است، اما شباهت بیشتری به تطبیق الگو (*pattern matching*) در زبان‌هایی مانند Rust یا Haskell دارد. تنها اولین الگویی که تطبیق پیدا کند اجرا می‌شود و این دستور همچنین می‌تواند اجزا (عناصر دنباله یا ویژگی‌های شیء) را از مقدار استخراج کرده و در متغیرها قرار دهد. اگر هیچ caseای تطبیق پیدا نکند، هیچ‌یک از شاخه‌ها اجرا نمی‌شوند."

msgid "The simplest form compares a subject value against one or more literals::"

msgstr "ساده‌ترین شکل، یک مقدار موضوع را با یک یا چند مقدار لفظی مقایسه می‌کند::"

msgid ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

msgstr ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

msgid "Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and never fails to match."

msgstr "به آخرین بلوک توجه کنید: «نام متغیر» ``_`` به‌عنوان یک *wildcard* عمل می‌کند و هرگز در تطبیق شکست نمی‌خورد."

msgid "You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr "می‌توانید چند مقدار لفظی را با استفاده از ``|`` («یا») در یک الگو ترکیب کنید::"

msgid ""

"case 401 | 403 | 404:\n"

" return \"Not allowed\""

msgstr ""

"case 401 | 403 | 404:\n"

" return \"Not allowed\""

msgid "Patterns can look like unpacking assignments, and can be used to bind variables::"

msgstr "الگوها می‌توانند شبیه انتساب‌های واگشایی (*unpacking assignments*) باشند و برای مقداردهی به متغیرها استفاده شوند::"

msgid ""

"# point is an (x, y) tuple\n"

"match point:\n"

" case (0, 0):\n"

" print(\"Origin\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Not a point\")"

msgstr ""

"# نقطه یک تاپل (x, y) است\n"

"match point:\n"

" case (0, 0):\n"

" print(\"Origin\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Not a point\")"

msgid "Study that one carefully! The first pattern has two literals, and can be thought of as an extension of the literal pattern shown above. But the next two patterns combine a literal and a variable, and the variable *binds* a value from the subject (``point``). The fourth pattern captures two values, which makes it conceptually similar to the unpacking assignment ``(x, y) = point``."

msgstr "این مورد را با دقت بررسی کنید! الگوی اول دو مقدار لفظی دارد و می‌توان آن را گسترشی از الگوی لفظی نشان‌داده‌شده در بالا در نظر گرفت. اما دو الگوی بعدی یک مقدار لفظی و یک متغیر را ترکیب می‌کنند، و متغیر یک مقدار را از موضوع (``point``) *دریافت* می‌کند. الگوی چهارم دو مقدار را دریافت می‌کند، که از نظر مفهومی شبیه به انتساب واگشاییٔ ``(x, y) = point`` است."

msgid "If you are using classes to structure your data you can use the class name followed by an argument list resembling a constructor, but with the ability to capture attributes into variables::"

msgstr "اگر برای ساختاربندی داده‌های خود از کلاس‌ها استفاده می‌کنید، می‌توانید نام کلاس را به‌همراه فهرستی از آرگومان‌ها که شبیه سازنده است استفاده کنید، اما با قابلیت دریافت ویژگی‌ها در متغیرها::"

msgid ""

"class Point:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def where_is(point):\n"

" match point:\n"

" case Point(x=0, y=0):\n"

" print(\"Origin\")\n"

" case Point(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Point(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Point():\n"

" print(\"Somewhere else\")\n"

" case _:\n"

" print(\"Not a point\")"

msgstr ""

"class Point:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def where_is(point):\n"

" match point:\n"

" case Point(x=0, y=0):\n"

" print(\"Origin\")\n"

" case Point(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Point(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Point():\n"

" print(\"Somewhere else\")\n"

" case _:\n"

" print(\"Not a point\")"

msgid "You can use positional parameters with some builtin classes that provide an ordering for their attributes (e.g. dataclasses). You can also define a specific position for attributes in patterns by setting the ``__match_args__`` special attribute in your classes. If it's set to (\"x\", \"y\"), the following patterns are all equivalent (and all bind the ``y`` attribute to the ``var`` variable)::"

msgstr "می‌توانید از پارامترهای موقعیتی با برخی کلاس‌های داخلی که برای ویژگی‌های خود ترتیب مشخصی ارائه می‌کنند (برای مثال dataclassها) استفاده کنید. همچنین می‌توانید با تنظیم ویژگی ویژهٔ ``__match_args__`` در کلاس‌های خود، موقعیت مشخصی برای ویژگی‌ها در الگوها تعریف کنید. اگر این ویژگی روی (\"x\", \"y\") تنظیم شده باشد، الگوهای زیر همگی معادل هستند (و همگی ویژگی ``y`` را در متغیر ``var`` قرار می‌دهند)::"

msgid ""

"Point(1, var)\n"

"Point(1, y=var)\n"

"Point(x=1, y=var)\n"

"Point(y=var, x=1)"

msgstr ""

"Point(1, var)\n"

"Point(1, y=var)\n"

"Point(x=1, y=var)\n"

"Point(y=var, x=1)"

msgid "A recommended way to read patterns is to look at them as an extended form of what you would put on the left of an assignment, to understand which variables would be set to what. Only the standalone names (like ``var`` above) are assigned to by a match statement. Dotted names (like ``foo.bar``), attribute names (the ``x=`` and ``y=`` above) or class names (recognized by the \"(...)\" next to them like ``Point`` above) are never assigned to."

msgstr "روش پیشنهادی برای خواندن الگوها این است که آن‌ها را شکل گسترش‌یافته‌ای از چیزی در نظر بگیرید که در سمت چپ یک انتساب قرار می‌دهید، تا متوجه شوید چه متغیرهایی با چه مقادیری تنظیم خواهند شد. تنها نام‌های مستقل (مانند ``var`` در بالا) توسط دستور match مقداردهی می‌شوند. نام‌های نقطه‌ای (مانند ``foo.bar``)، نام ویژگی‌ها (مانند ``x=`` و ``y=`` در بالا) یا نام کلاس‌ها (که با (...) کنار آن‌ها، مانند ``Point`` در بالا، شناخته می‌شوند) هرگز مقداردهی نمی‌شوند."

msgid "Patterns can be arbitrarily nested. For example, if we have a short list of Points, with ``__match_args__`` added, we could match it like this::"

msgstr "الگوها می‌توانند به‌صورت دلخواه تو‌در‌تو باشند. برای مثال، اگر یک فهرست کوتاه از Pointها داشته باشیم و ``__match_args__`` را به آن‌ها اضافه کرده باشیم، می‌توانیم آن را به این شکل تطبیق دهیم::"

msgid ""

"class Point:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match points:\n"

" case []:\n"

" print(\"No points\")\n"

" case [Point(0, 0)]:\n"

" print(\"The origin\")\n"

" case [Point(x, y)]:\n"

" print(f\"Single point {x}, {y}\")\n"

" case [Point(0, y1), Point(0, y2)]:\n"

" print(f\"Two on the Y axis at {y1}, {y2}\")\n"

" case _:\n"

" print(\"Something else\")"

msgstr ""

"class Point:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match points:\n"

" case []:\n"

" print(\"No points\")\n"

" case [Point(0, 0)]:\n"

" print(\"The origin\")\n"

" case [Point(x, y)]:\n"

" print(f\"Single point {x}, {y}\")\n"

" case [Point(0, y1), Point(0, y2)]:\n"

" print(f\"Two on the Y axis at {y1}, {y2}\")\n"

" case _:\n"

" print(\"Something else\")"

msgid "We can add an ``if`` clause to a pattern, known as a \"guard\". If the guard is false, ``match`` goes on to try the next case block. Note that value capture happens before the guard is evaluated::"

msgstr "می‌توانیم یک بخش ``if`` به یک الگو اضافه کنیم که به آن «نگهبان» (*guard*) گفته می‌شود. اگر نگهبان نادرست باشد، ``match`` به تلاش برای بلوک case بعدی ادامه می‌دهد. توجه کنید که دریافت مقدار پیش از ارزیابی نگهبان انجام می‌شود::"

msgid ""

"match point:\n"

" case Point(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Point(x, y):\n"

" print(f\"Not on the diagonal\")"

msgstr ""

"match point:\n"

" case Point(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Point(x, y):\n"

" print(f\"Not on the diagonal\")"

msgid "Several other key features of this statement:"

msgstr "چند ویژگی کلیدی دیگر این دستور:"

msgid "Like unpacking assignments, tuple and list patterns have exactly the same meaning and actually match arbitrary sequences. An important exception is that they don't match iterators or strings."

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

msgid "Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, *rest)`` work similar to unpacking assignments. The name after ``*`` may also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items without binding the remaining items."

msgstr "الگوهای دنباله‌ای از واگشاییٔ گسترده پشتیبانی می‌کنند: ``[x, y, *rest]`` و ``(x, y, *rest)`` مشابه انتساب‌های واگشایی عمل می‌کنند. نام پس از ``*`` نیز می‌تواند ``_`` باشد، بنابراین ``(x, y, *_)`` با دنباله‌ای دارای حداقل دو آیتم تطبیق پیدا می‌کند، بدون اینکه آیتم‌های باقی‌مانده را در متغیری قرار دهد."

msgid "Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the ``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr "الگوهای نگاشتی: ``{\"bandwidth\": b, \"latency\": l}`` مقادیر ``\"bandwidth\"`` و ``\"latency\"`` را از یک دیکشنری دریافت می‌کند. برخلاف الگوهای دنباله‌ای، کلیدهای اضافی نادیده گرفته می‌شوند. واگشایی‌ای مانند ``**rest`` نیز پشتیبانی می‌شود. (اما ``**_`` اضافی است، بنابراین مجاز نیست.)"

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "زیرالگوها را می‌توان با استفاده از کلیدواژهٔ ``as`` دریافت کرد::"

msgid "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgstr "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgid "will capture the second element of the input as ``p2`` (as long as the input is a sequence of two points)"

msgstr "عنصر دوم ورودی را به‌عنوان ``p2`` دریافت می‌کند (تا زمانی که ورودی یک دنبالهٔ دو عضوی از نقاط باشد)"

msgid "Most literals are compared by equality, however the singletons ``True``, ``False`` and ``None`` are compared by identity."

msgstr "بیشتر مقادیر لفظی با استفاده از برابری مقایسه می‌شوند، اما تک‌نمونه‌های ``True``، ``False`` و ``None`` با استفاده از هویت مقایسه می‌شوند."

msgid "Patterns may use named constants. These must be dotted names to prevent them from being interpreted as capture variables::"

msgstr "الگوها می‌توانند از ثابت‌های نام‌گذاری‌شده استفاده کنند. این‌ها باید نام‌های نقطه‌ای باشند تا از تفسیر شدن آن‌ها به‌عنوان متغیرهای دریافت‌کننده جلوگیری شود::"

msgid ""

"from enum import Enum\n"

"class Color(Enum):\n"

" RED = 'red'\n"

" GREEN = 'green'\n"

" BLUE = 'blue'\n"

"\n"

"color = Color(input(\"Enter your choice of 'red', 'blue' or 'green': \"))\n"

"\n"

"match color:\n"

" case Color.RED:\n"

" print(\"I see red!\")\n"

" case Color.GREEN:\n"

" print(\"Grass is green\")\n"

" case Color.BLUE:\n"

" print(\"I'm feeling the blues :(\")"

msgstr ""

"from enum import Enum\n"

"class Color(Enum):\n"

" RED = 'red'\n"

" GREEN = 'green'\n"

" BLUE = 'blue'\n"

"\n"

"color = Color(input(\"Enter your choice of 'red', 'blue' or 'green': \"))\n"

"\n"

"match color:\n"

" case Color.RED:\n"

" print(\"I see red!\")\n"

" case Color.GREEN:\n"

" print(\"Grass is green\")\n"

" case Color.BLUE:\n"

" print(\"I'm feeling the blues :(\")"

msgid "For a more detailed explanation and additional examples, you can look into :pep:`636` which is written in a tutorial format."

msgstr "برای توضیح دقیق‌تر و نمونه‌های بیشتر، می‌توانید به :pep:`636` مراجعه کنید که با قالب یک آموزش نوشته شده است."

msgid "Defining Functions"

msgstr "تعریف توابع"

msgid "We can create a function that writes the Fibonacci series to an arbitrary boundary::"

msgstr "می‌توانیم تابعی ایجاد کنیم که سری فیبوناچی را تا یک کران دلخواه بنویسد::"

msgid ""

">>> def fib(n): # write Fibonacci series less than n\n"

"... \"\"\"Print a Fibonacci series less than n.\"\"\"\n"

"... a, b = 0, 1\n"

"... while a < n:\n"

"... print(a, end=' ')\n"

"... a, b = b, a+b\n"

"... print()\n"

"...\n"

">>> # Now call the function we just defined:\n"

">>> fib(2000)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597"

msgstr ""

">>> def fib(n): # نوشتن دنباله‌ی فیبوناچی کوچک‌تر از n\n"

"... \"\"\"Print a Fibonacci series less than n.\"\"\"\n"

"... a, b = 0, 1\n"

"... while a < n:\n"

"... print(a, end=' ')\n"

"... a, b = b, a+b\n"

"... print()\n"

"...\n"

">>> # اکنون تابعی را که تعریف کردیم فراخوانی می‌کنیم:\n"

">>> fib(2000)\n"

"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597"

msgid "The keyword :keyword:`def` introduces a function *definition*. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented."

msgstr "کلیدواژهٔ :keyword:`def` یک *تعریف تابع* را معرفی می‌کند. این کلیدواژه باید پس از خود نام تابع و فهرست پارامترهای رسمی درون پرانتز بیاید. دستورهایی که بدنهٔ تابع را تشکیل می‌دهند از خط بعدی شروع می‌شوند و باید تورفتگی داشته باشند."

msgid "The first statement of the function body can optionally be a string literal; this string literal is the function's documentation string, or :dfn:`docstring`. (More about docstrings can be found in the section :ref:`tut-docstrings`.) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it's good practice to include docstrings in code that you write, so make a habit of it."

msgstr "اولین دستور بدنهٔ تابع می‌تواند به‌صورت اختیاری یک رشتهٔ لفظی باشد؛ این رشتهٔ لفظی، رشتهٔ مستندات تابع یا :dfn:`docstring` است. (اطلاعات بیشتر دربارهٔ رشته‌های مستندات را می‌توانید در بخش :ref:`tut-docstrings` پیدا کنید.) ابزارهایی وجود دارند که از docstringها برای تولید خودکار مستندات آنلاین یا چاپی، یا برای اجازه دادن به کاربر جهت مرور تعاملی کد استفاده می‌کنند؛ بهتر است در کدی که می‌نویسید docstringها را قرار دهید، بنابراین آن را به یک عادت تبدیل کنید."

msgid "The *execution* of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables and variables of enclosing functions cannot be directly assigned a value within a function (unless, for global variables, named in a :keyword:`global` statement, or, for variables of enclosing functions, named in a :keyword:`nonlocal` statement), although they may be referenced."

msgstr "*اجرای* یک تابع، یک جدول نماد جدید ایجاد می‌کند که برای متغیرهای محلی تابع استفاده می‌شود. به‌طور دقیق‌تر، تمام انتساب‌های متغیر در یک تابع، مقدار را در جدول نماد محلی ذخیره می‌کنند؛ در حالی که ارجاع‌های متغیر ابتدا در جدول نماد محلی، سپس در جدول‌های نماد محلی تابع‌های دربرگیرنده، سپس در جدول نماد سراسری، و در نهایت در جدول نام‌های داخلی جست‌وجو می‌شوند. بنابراین، متغیرهای سراسری و متغیرهای تابع‌های دربرگیرنده نمی‌توانند مستقیماً درون یک تابع مقداردهی شوند (مگر اینکه برای متغیرهای سراسری با یک دستور :keyword:`global`، یا برای متغیرهای تابع‌های دربرگیرنده با یک دستور :keyword:`nonlocal` نام‌گذاری شده باشند)، اگرچه می‌توان به آن‌ها ارجاع داد."

msgid "The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using *call by value* (where the *value* is always an object *reference*, not the value of the object). [#]_ When a function calls another function, or calls itself recursively, a new local symbol table is created for that call."

msgstr "پارامترهای واقعی (آرگومان‌ها) در یک فراخوانی تابع، هنگام فراخوانی تابع در جدول نماد محلی تابع فراخوانی‌شده قرار می‌گیرند؛ بنابراین، آرگومان‌ها با استفاده از *انتقال با مقدار* (*call by value*) ارسال می‌شوند (که در آن *مقدار* همیشه یک ارجاع به شیء است، نه مقدار خود شیء). [#]_ هنگامی که یک تابع، تابع دیگری را فراخوانی می‌کند یا به‌صورت بازگشتی خودش را فراخوانی می‌کند، یک جدول نماد محلی جدید برای آن فراخوانی ایجاد می‌شود."

msgid "A function definition associates the function name with the function object in the current symbol table. The interpreter recognizes the object pointed to by that name as a user-defined function. Other names can also point to that same function object and can also be used to access the function::"

msgstr "یک تعریف تابع، نام تابع را با شیء تابع در جدول نماد فعلی مرتبط می‌کند. مفسر شیئی را که آن نام به آن اشاره می‌کند به‌عنوان یک تابع تعریف‌شده توسط کاربر تشخیص می‌دهد. نام‌های دیگر نیز می‌توانند به همان شیء تابع اشاره کنند و برای دسترسی به تابع استفاده شوند::"

msgid ""

">>> fib\n"

"<function fib at 10042ed0>\n"

">>> f = fib\n"

">>> f(100)\n"

"0 1 1 2 3 5 8 13 21 34 55 89"

msgstr ""

">>> fib\n"

"<function fib at 10042ed0>\n"

">>> f = fib\n"

">>> f(100)\n"

"0 1 1 2 3 5 8 13 21 34 55 89"

msgid "Coming from other languages, you might object that ``fib`` is not a function but a procedure since it doesn't return a value. In fact, even functions without a :keyword:`return` statement do return a value, albeit a rather boring one. This value is called ``None`` (it's a built-in name). Writing the value ``None`` is normally suppressed by the interpreter if it would be the only value written. You can see it if you really want to using :func:`print`::"

msgstr "اگر از زبان‌های دیگر آمده باشید، ممکن است اعتراض کنید که ``fib`` یک تابع نیست، بلکه یک رویه (*procedure*) است، زیرا مقداری برنمی‌گرداند. در واقع، حتی تابع‌هایی که دستور :keyword:`return` ندارند نیز یک مقدار برمی‌گردانند، هرچند مقدار نسبتاً بی‌اهمیتی است. این مقدار ``None`` نام دارد (که یک نام داخلی است). نوشتن مقدار ``None`` معمولاً توسط مفسر حذف می‌شود اگر تنها مقداری باشد که قرار است نوشته شود. اگر واقعاً بخواهید می‌توانید آن را با استفاده از :func:`print` ببینید::"

msgid ""

">>> fib(0)\n"

">>> print(fib(0))\n"

"None"

msgstr ""

">>> fib(0)\n"

">>> print(fib(0))\n"

"None"

msgid "It is simple to write a function that returns a list of the numbers of the Fibonacci series, instead of printing it::"

msgstr "نوشتن تابعی که به‌جای چاپ کردن سری فیبوناچی، فهرستی از اعداد آن را برگرداند ساده است::"

msgid ""

">>> def fib2(n): # return Fibonacci series up to n\n"

"... \"\"\"Return a list containing the Fibonacci series up to n.\"\"\"\n"

"... result = []\n"

"... a, b = 0, 1\n"

"... while a < n:\n"

"... result.append(a) # see below\n"

"... a, b = b, a+b\n"

"... return result\n"

"...\n"

">>> f100 = fib2(100) # call it\n"

">>> f100 # write the result\n"

"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"

msgstr ""

">>> def fib2(n): # بازگرداندن دنباله‌ی فیبوناچی تا n\n"

"... \"\"\"Return a list containing the Fibonacci series up to n.\"\"\"\n"

"... result = []\n"

"... a, b = 0, 1\n"

"... while a < n:\n"

"... result.append(a) # توضیح زیر را ببینید\n"

"... a, b = b, a+b\n"

"... return result\n"

"...\n"

">>> f100 = fib2(100) # فراخوانی تابع\n"

">>> f100 # نمایش نتیجه\n"

"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"

msgid "This example, as usual, demonstrates some new Python features:"

msgstr "این مثال، مانند همیشه، چند ویژگی جدید پایتون را نشان می‌دهد:"

msgid "The :keyword:`return` statement returns with a value from a function. :keyword:`!return` without an expression argument returns ``None``. Falling off the end of a function also returns ``None``."

msgstr "دستور :keyword:`return` یک مقدار را از یک تابع برمی‌گرداند. :keyword:`!return` بدون یک آرگومان عبارت، ``None`` را برمی‌گرداند. رسیدن به انتهای یک تابع نیز ``None`` را برمی‌گرداند."

msgid "The statement ``result.append(a)`` calls a *method* of the list object ``result``. A method is a function that 'belongs' to an object and is named ``obj.methodname``, where ``obj`` is some object (this may be an expression), and ``methodname`` is the name of a method that is defined by the object's type. Different types define different methods. Methods of different types may have the same name without causing ambiguity. (It is possible to define your own object types and methods, using *classes*, see :ref:`tut-classes`) The method :meth:`~list.append` shown in the example is defined for list objects; it adds a new element at the end of the list. In this example it is equivalent to ``result = result + [a]``, but more efficient."

msgstr "دستور ``result.append(a)`` یک *متد* از شیء فهرست ``result`` را فراخوانی می‌کند. یک متد تابعی است که به یک شیء «تعلق دارد» و با قالب ``obj.methodname`` نام‌گذاری می‌شود؛ در اینجا ``obj`` یک شیء (که می‌تواند یک عبارت باشد) و ``methodname`` نام متدی است که توسط نوع شیء تعریف شده است. نوع‌های مختلف، متدهای متفاوتی تعریف می‌کنند. متدهای نوع‌های مختلف می‌توانند نام یکسانی داشته باشند، بدون اینکه ابهامی ایجاد شود. (می‌توان با استفاده از *کلاس‌ها* نوع‌ها و متدهای شیء سفارشی خود را تعریف کرد؛ به :ref:`tut-classes` مراجعه کنید.) متد :meth:`~list.append` که در مثال نشان داده شده است برای اشیای فهرست تعریف شده است؛ این متد یک عنصر جدید را به انتهای فهرست اضافه می‌کند. در این مثال، معادل ``result = result + [a]`` است، اما کارآمدتر است."

msgid "More on Defining Functions"

msgstr "اطلاعات بیشتر دربارهٔ تعریف تابع‌ها"

msgid "It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined."

msgstr "همچنین امکان تعریف تابع‌هایی با تعداد متغیری از آرگومان‌ها وجود دارد. سه شکل وجود دارد که می‌توان آن‌ها را با یکدیگر ترکیب کرد."

msgid "Default Argument Values"

msgstr "مقدارهای پیش‌فرض آرگومان‌ها"

msgid "The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow. For example::"

msgstr "کاربردی‌ترین شکل، مشخص کردن یک مقدار پیش‌فرض برای یک یا چند آرگومان است. این کار تابعی ایجاد می‌کند که می‌توان آن را با آرگومان‌های کمتری نسبت به تعداد تعریف‌شده فراخوانی کرد. برای مثال::"

msgid ""

"def ask_ok(prompt, retries=4, reminder='Please try again!'):\n"

" while True:\n"

" reply = input(prompt)\n"

" if reply in {'y', 'ye', 'yes'}:\n"

" return True\n"

" if reply in {'n', 'no', 'nop', 'nope'}:\n"

" return False\n"

" retries = retries - 1\n"

" if retries < 0:\n"

" raise ValueError('invalid user response')\n"

" print(reminder)"

msgstr ""

"def ask_ok(prompt, retries=4, reminder='Please try again!'):\n"

" while True:\n"

" reply = input(prompt)\n"

" if reply in {'y', 'ye', 'yes'}:\n"

" return True\n"

" if reply in {'n', 'no', 'nop', 'nope'}:\n"

" return False\n"

" retries = retries - 1\n"

" if retries < 0:\n"

" raise ValueError('invalid user response')\n"

" print(reminder)"

msgid "This function can be called in several ways:"

msgstr "این تابع را می‌توان به چند روش فراخوانی کرد:"

msgid "giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"

msgstr "فقط با دادن آرگومان اجباری: ``ask_ok('Do you really want to quit?')``"

msgid "giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', 2)``"

msgstr "با دادن یکی از آرگومان‌های اختیاری: ``ask_ok('OK to overwrite the file?', 2)``"

msgid "or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``"

msgstr "یا حتی با دادن همهٔ آرگومان‌ها: ``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``"

msgid "This example also introduces the :keyword:`in` keyword. This tests whether or not a sequence contains a certain value."

msgstr "این مثال همچنین کلیدواژهٔ :keyword:`in` را معرفی می‌کند. این کلیدواژه بررسی می‌کند که آیا یک دنباله مقدار مشخصی را در خود دارد یا خیر."

msgid "The default values are evaluated at the point of function definition in the *defining* scope, so that ::"

msgstr "مقدارهای پیش‌فرض در نقطهٔ تعریف تابع و در محدودهٔ *تعریف‌کننده* (*defining scope*) ارزیابی می‌شوند، بنابراین ::"

msgid ""

"i = 5\n"

"\n"

"def f(arg=i):\n"

" print(arg)\n"

"\n"

"i = 6\n"

"f()"

msgstr ""

"i = 5\n"

"\n"

"def f(arg=i):\n"

" print(arg)\n"

"\n"

"i = 6\n"

"f()"

msgid "will print ``5``."

msgstr "``5`` را چاپ خواهد کرد."

msgid "**Important warning:** The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls::"

msgstr "**هشدار مهم:** مقدار پیش‌فرض فقط یک‌بار ارزیابی می‌شود. این موضوع زمانی تفاوت ایجاد می‌کند که مقدار پیش‌فرض یک شیء قابل تغییر مانند یک فهرست، دیکشنری، یا نمونه‌ای از بیشتر کلاس‌ها باشد. برای مثال، تابع زیر آرگومان‌هایی را که در فراخوانی‌های بعدی به آن داده می‌شوند جمع‌آوری می‌کند::"

msgid ""

"def f(a, L=[]):\n"

" L.append(a)\n"

" return L\n"

"\n"

"print(f(1))\n"

"print(f(2))\n"

"print(f(3))"

msgstr ""

"def f(a, L=[]):\n"

" L.append(a)\n"

" return L\n"

"\n"

"print(f(1))\n"

"print(f(2))\n"

"print(f(3))"

msgid "This will print ::"

msgstr "این دستور چاپ خواهد کرد ::"

msgid ""

"[1]\n"

"[1, 2]\n"

"[1, 2, 3]"

msgstr ""

"[1]\n"

"[1, 2]\n"

"[1, 2, 3]"

msgid "If you don't want the default to be shared between subsequent calls, you can write the function like this instead::"

msgstr "اگر نمی‌خواهید مقدار پیش‌فرض بین فراخوانی‌های بعدی به اشتراک گذاشته شود، می‌توانید تابع را به این شکل بنویسید::"

msgid ""

"def f(a, L=None):\n"

" if L is None:\n"

" L = []\n"

" L.append(a)\n"

" return L"

msgstr ""

"def f(a, L=None):\n"

" if L is None:\n"

" L = []\n"

" L.append(a)\n"

" return L"

msgid "Keyword Arguments"

msgstr "آرگومان‌های کلیدواژه‌ای"

msgid "Functions can also be called using :term:`keyword arguments <keyword argument>` of the form ``kwarg=value``. For instance, the following function::"

msgstr "تابع‌ها همچنین می‌توانند با استفاده از :term:`keyword arguments <keyword argument>` به شکل ``kwarg=value`` فراخوانی شوند. برای نمونه، تابع زیر::"

msgid ""

"def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n"

" print(\"-- This parrot wouldn't\", action, end=' ')\n"

" print(\"if you put\", voltage, \"volts through it.\")\n"

" print(\"-- Lovely plumage, the\", type)\n"

" print(\"-- It's\", state, \"!\")"

msgstr ""

"def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n"

" print(\"-- This parrot wouldn't\", action, end=' ')\n"

" print(\"if you put\", voltage, \"volts through it.\")\n"

" print(\"-- Lovely plumage, the\", type)\n"

" print(\"-- It's\", state, \"!\")"

msgid "accepts one required argument (``voltage``) and three optional arguments (``state``, ``action``, and ``type``). This function can be called in any of the following ways::"

msgstr "یک آرگومان اجباری (``voltage``) و سه آرگومان اختیاری (``state``، ``action`` و ``type``) را می‌پذیرد. این تابع می‌تواند به هر یک از روش‌های زیر فراخوانی شود::"

msgid ""

"parrot(1000) # 1 positional argument\n"

"parrot(voltage=1000) # 1 keyword argument\n"

"parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments\n"

"parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments\n"

"parrot('a million', 'bereft of life', 'jump') # 3 positional arguments\n"

"parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword"

msgstr ""

"parrot(1000) # یک آرگومان موقعیتی\n"

"parrot(voltage=1000) # یک آرگومان کلیدواژه‌ای\n"

"parrot(voltage=1000000, action='VOOOOOM') # دو آرگومان کلیدواژه‌ای\n"

"parrot(action='VOOOOOM', voltage=1000000) # دو آرگومان کلیدواژه‌ای\n"

"parrot('a million', 'bereft of life', 'jump') # سه آرگومان موقعیتی\n"

"parrot('a thousand', state='pushing up the daisies') # یک آرگومان موقعیتی، یک آرگومان کلیدواژه‌ای"

msgid "but all the following calls would be invalid::"

msgstr "اما تمام فراخوانی‌های زیر نامعتبر خواهند بود::"

msgid ""

"parrot() # required argument missing\n"

"parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument\n"

"parrot(110, voltage=220) # duplicate value for the same argument\n"

"parrot(actor='John Cleese') # unknown keyword argument"

msgstr ""

"parrot() # آرگومان الزامی وارد نشده است\n"

"parrot(voltage=5.0, 'dead') # آرگومان غیرکلیدواژه‌ای پس از آرگومان کلیدواژه‌ای آمده است\n"

"parrot(110, voltage=220) # مقدار تکراری برای یک آرگومان یکسان\n"

"parrot(actor='John Cleese') # آرگومان کلیدواژه‌ای ناشناخته"

msgid "In a function call, keyword arguments must follow positional arguments. All the keyword arguments passed must match one of the arguments accepted by the function (e.g. ``actor`` is not a valid argument for the ``parrot`` function), and their order is not important. This also includes non-optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument may receive a value more than once. Here's an example that fails due to this restriction::"

msgstr "در یک فراخوانی تابع، آرگومان‌های کلیدواژه‌ای باید پس از آرگومان‌های موقعیتی بیایند. تمام آرگومان‌های کلیدواژه‌ای ارسال‌شده باید با یکی از آرگومان‌های پذیرفته‌شده توسط تابع مطابقت داشته باشند (برای مثال، ``actor`` یک آرگومان معتبر برای تابع ``parrot`` نیست)، و ترتیب آن‌ها اهمیتی ندارد. این موضوع شامل آرگومان‌های غیر‌اختیاری نیز می‌شود (برای مثال، ``parrot(voltage=1000)`` نیز معتبر است). هیچ آرگومانی نمی‌تواند بیش از یک‌بار مقدار دریافت کند. در اینجا مثالی وجود دارد که به دلیل این محدودیت شکست می‌خورد::"

msgid ""

">>> def function(a):\n"

"... pass\n"

"...\n"

">>> function(0, a=0)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: function() got multiple values for argument 'a'"

msgstr ""

">>> def function(a):\n"

"... pass\n"

"...\n"

">>> function(0, a=0)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: function() got multiple values for argument 'a'"

msgid "When a final formal parameter of the form ``**name`` is present, it receives a dictionary (see :ref:`typesmapping`) containing all keyword arguments except for those corresponding to a formal parameter. This may be combined with a formal parameter of the form ``*name`` (described in the next subsection) which receives a :ref:`tuple <tut-tuples>` containing the positional arguments beyond the formal parameter list. (``*name`` must occur before ``**name``.) For example, if we define a function like this::"

msgstr "هنگامی که یک پارامتر رسمی نهایی به شکل ``**name`` وجود داشته باشد، یک فرهنگ لغت (به :ref:`typesmapping` مراجعه کنید) دریافت می‌کند که شامل تمام آرگومان‌های کلیدواژه‌ای است، به‌جز آن‌هایی که متناظر با یک پارامتر رسمی هستند. این مورد می‌تواند با یک پارامتر رسمی به شکل ``*name`` ترکیب شود (که در زیربخش بعدی توضیح داده شده است)؛ این پارامتر یک :ref:`tuple <tut-tuples>` دریافت می‌کند که شامل آرگومان‌های موقعیتی فراتر از فهرست پارامترهای رسمی است. (``*name`` باید پیش از ``**name`` قرار گیرد.) برای مثال، اگر تابعی مانند زیر تعریف کنیم::"

msgid ""

"def cheeseshop(kind, *arguments, **keywords):\n"

" print(\"-- Do you have any\", kind, \"?\")\n"

" print(\"-- I'm sorry, we're all out of\", kind)\n"

" for arg in arguments:\n"

" print(arg)\n"

" print(\"-\" * 40)\n"

" for kw in keywords:\n"

" print(kw, \":\", keywords[kw])"

msgstr ""

"def cheeseshop(kind, *arguments, **keywords):\n"

" print(\"-- Do you have any\", kind, \"?\")\n"

" print(\"-- I'm sorry, we're all out of\", kind)\n"

" for arg in arguments:\n"

" print(arg)\n"

" print(\"-\" * 40)\n"

" for kw in keywords:\n"

" print(kw, \":\", keywords[kw])"

msgid "It could be called like this::"

msgstr "میتواند اینگونه فراخوانده شود::"

msgid ""

"cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n"

" \"It's really very, VERY runny, sir.\",\n"

" shopkeeper=\"Michael Palin\",\n"

" client=\"John Cleese\",\n"

" sketch=\"Cheese Shop Sketch\")"

msgstr ""

"cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n"

" \"It's really very, VERY runny, sir.\",\n"

" shopkeeper=\"Michael Palin\",\n"

" client=\"John Cleese\",\n"

" sketch=\"Cheese Shop Sketch\")"

msgid "and of course it would print:"

msgstr "و قطعا این دستور چاپ خواهد کرد:"

msgid ""

"-- Do you have any Limburger ?\n"

"-- I'm sorry, we're all out of Limburger\n"