functions.po

# Persian translations for Python package.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# Automatically generated, 2026.
#
# Translators:
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-24 04:15+0000\n"
"PO-Revision-Date: 2026-09-24 07:55+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: none\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.6\n"

msgid "Built-in functions"
msgstr "توابع توکار"

msgid "The Python interpreter has a number of functions and types built into it that are always available.  They are listed here in alphabetical order."
msgstr "مفسر پایتون دارای تعدادی تابع و نوع داده است که در آن بصورت توکار (built-in) همیشه در دسترس می‌باشند. آن‌ها در اینجا به ترتیب حروف الفبا فهرست شده‌اند."

msgid "Built-in Functions"
msgstr "توابع توکار"

msgid "**A**"
msgstr "**A**"

msgid ":func:`abs`"
msgstr ":func:`abs`"

msgid ":func:`aiter`"
msgstr ":func:`aiter`"

msgid ":func:`all`"
msgstr ":func:`all`"

msgid ":func:`anext`"
msgstr ":func:`anext`"

msgid ":func:`any`"
msgstr ":func:`any`"

msgid ":func:`ascii`"
msgstr ":func:`ascii`"

msgid "**B**"
msgstr "**B**"

msgid ":func:`bin`"
msgstr ":func:`bin`"

msgid ":func:`bool`"
msgstr ":func:`bool`"

msgid ":func:`breakpoint`"
msgstr ":func:`breakpoint`"

msgid "|func-bytearray|_"
msgstr "|func-bytearray|_"

msgid "|func-bytes|_"
msgstr "|func-bytes|_"

msgid "**C**"
msgstr "**C**"

msgid ":func:`callable`"
msgstr ":func:`callable`"

msgid ":func:`chr`"
msgstr ":func:`chr`"

msgid ":func:`classmethod`"
msgstr ":func:`classmethod`"

msgid ":func:`compile`"
msgstr ":func:`compile`"

msgid ":func:`complex`"
msgstr ":func:`complex`"

msgid "**D**"
msgstr "**D**"

msgid ":func:`delattr`"
msgstr ":func:`delattr`"

msgid "|func-dict|_"
msgstr "|func-dict|_"

msgid ":func:`dir`"
msgstr ":func:`dir`"

msgid ":func:`divmod`"
msgstr ":func:`divmod`"

msgid "**E**"
msgstr "**E**"

msgid ":func:`enumerate`"
msgstr ":func:`enumerate`"

msgid ":func:`eval`"
msgstr ":func:`eval`"

msgid ":func:`exec`"
msgstr ":func:`exec`"

msgid "**F**"
msgstr "**F**"

msgid ":func:`filter`"
msgstr ":func:`filter`"

msgid ":func:`float`"
msgstr ":func:`float`"

msgid ":func:`format`"
msgstr ":func:`format`"

msgid "|func-frozendict|_"
msgstr "|func-frozendict|_"

msgid "|func-frozenset|_"
msgstr "|func-frozenset|_"

msgid "**G**"
msgstr "**G**"

msgid ":func:`getattr`"
msgstr ":func:`getattr`"

msgid ":func:`globals`"
msgstr ":func:`globals`"

msgid "**H**"
msgstr "**H**"

msgid ":func:`hasattr`"
msgstr ":func:`hasattr`"

msgid ":func:`hash`"
msgstr ":func:`hash`"

msgid ":func:`help`"
msgstr ":func:`help`"

msgid ":func:`hex`"
msgstr ":func:`hex`"

msgid "**I**"
msgstr "**I**"

msgid ":func:`id`"
msgstr ":func:`id`"

msgid ":func:`input`"
msgstr ":func:`input`"

msgid ":func:`int`"
msgstr ":func:`int`"

msgid ":func:`isinstance`"
msgstr ":func:`isinstance`"

msgid ":func:`issubclass`"
msgstr ":func:`issubclass`"

msgid ":func:`iter`"
msgstr ":func:`iter`"

msgid "**L**"
msgstr "**L**"

msgid ":func:`len`"
msgstr ":func:`len`"

msgid "|func-list|_"
msgstr "|func-list|_"

msgid ":func:`locals`"
msgstr ":func:`locals`"

msgid "**M**"
msgstr "**M**"

msgid ":func:`map`"
msgstr ":func:`map`"

msgid ":func:`max`"
msgstr ":func:`max`"

msgid "|func-memoryview|_"
msgstr "|func-memoryview|_"

msgid ":func:`min`"
msgstr ":func:`min`"

msgid "**N**"
msgstr "**N**"

msgid ":func:`next`"
msgstr ":func:`next`"

msgid "**O**"
msgstr "**O**"

msgid ":func:`object`"
msgstr ":func:`object`"

msgid ":func:`oct`"
msgstr ":func:`oct`"

msgid ":func:`open`"
msgstr ":func:`open`"

msgid ":func:`ord`"
msgstr ":func:`ord`"

msgid "**P**"
msgstr "**P**"

msgid ":func:`pow`"
msgstr ":func:`pow`"

msgid ":func:`print`"
msgstr ":func:`print`"

msgid ":func:`property`"
msgstr ":func:`property`"

msgid "**R**"
msgstr "**R**"

msgid "|func-range|_"
msgstr "|func-range|_"

msgid ":func:`repr`"
msgstr ":func:`repr`"

msgid ":func:`reversed`"
msgstr ":func:`reversed`"

msgid ":func:`round`"
msgstr ":func:`round`"

msgid "**S**"
msgstr "**S**"

msgid "|func-set|_"
msgstr "|func-set|_"

msgid ":func:`setattr`"
msgstr ":func:`setattr`"

msgid ":func:`sentinel`"
msgstr ":func:`sentinel`"

msgid ":func:`slice`"
msgstr ":func:`slice`"

msgid ":func:`sorted`"
msgstr ":func:`sorted`"

msgid ":func:`staticmethod`"
msgstr ":func:`staticmethod`"

msgid "|func-str|_"
msgstr "|func-str|_"

msgid ":func:`sum`"
msgstr ":func:`sum`"

msgid ":func:`super`"
msgstr ":func:`super`"

msgid "**T**"
msgstr "**T**"

msgid "|func-tuple|_"
msgstr "|func-tuple|_"

msgid ":func:`type`"
msgstr ":func:`type`"

msgid "**V**"
msgstr "**V**"

msgid ":func:`vars`"
msgstr ":func:`vars`"

msgid "**Z**"
msgstr "**Z**"

msgid ":func:`zip`"
msgstr ":func:`zip`"

msgid "**_**"
msgstr "**_**"

msgid ":func:`__import__`"
msgstr ":func:`__import__`"

msgid "Return the absolute value of a number.  The argument may be an integer, a floating-point number, or an object implementing :meth:`~object.__abs__`. If the argument is a complex number, its magnitude is returned."
msgstr "مقدار قدر مطلق یک عدد را برمی‌گرداند. آرگومان می تواند یک عدد صحیح، یک عدد اعشاری، یا یک شیء که :meth:`~object.__abs__` را پیاده‌سازی می‌کند، باشد. اگر ارگومان یک عدد مختلط باشد، بزرگی آن بازگردانده می‌شود."

msgid "Return an :term:`asynchronous iterator` for an :term:`asynchronous iterable`. Equivalent to calling ``x.__aiter__()``."
msgstr "بازگرداندن یک :term:`asynchronous iterator` برای یک :term:`asynchronous iterable` معادل فراخوانی ``x.__aiter__()`` است."

msgid "Note: Unlike :func:`iter`, :func:`aiter` has no 2-argument variant."
msgstr "توجه: برخلاف :func:`iter`، :func:`aiter` نسخه دو آرگومانی ندارد."

msgid "Return ``True`` if all elements of the *iterable* are true (or if the iterable is empty).  Equivalent to::"
msgstr "در صورتی که تمام عناصر *iterable* درست باشند (یا اگر iterable خالی باشد)، ``True`` را برمی گرداند. معادل با::"

msgid ""
"def all(iterable):\n"
"    for element in iterable:\n"
"        if not element:\n"
"            return False\n"
"    return True"
msgstr ""
"def all(iterable):\n"
"    for element in iterable:\n"
"        if not element:\n"
"            return False\n"
"    return True"

msgid "When awaited, return the next item from the given :term:`asynchronous iterator`, or *default* if given and the iterator is :term:`exhausted`."
msgstr "هنگام انتظار، آیتم بعدی را از :term:`پیمایش‌گر ناهمگام <asynchronous iterator>` داده‌شده برگردانید، یا *default* اگر داده شده باشد و پیمایش‌گر :term:`به پایان رسیده <exhausted>` باشد."

msgid "This is the async variant of the :func:`next` builtin, and behaves similarly."
msgstr "این، نسخه ناهمگامِ تابع توکار :func:`next` است و به طور مشابه عمل می‌کند."

msgid "This calls the :meth:`~object.__anext__` method of *async_iterator*, returning an :term:`awaitable`. Awaiting this returns the next value of the iterator. If *default* is given, it is returned if the iterator is exhausted, otherwise :exc:`StopAsyncIteration` is raised."
msgstr "این متد :meth:`~object.__anext__` از *async_iterator* را فراخوانی می کند و یک :term:`awaitable` را برمی گرداند. در انتظار این مقدار بعدی پیمایش‌گر را برمی گرداند. اگر *default* داده شود، اگر پیمایش‌گر تمام شده باشد، برگردانده می شود، در غیر این صورت :exc:`StopAsyncIteration` پرتاب میشود."

msgid "Return ``True`` if any element of the *iterable* is true.  If the iterable is empty, return ``False``.  Equivalent to::"
msgstr "اگر هر عنصری از *iterable* درست باشد، ``True`` را برگردانید. اگر iterable خالی باشد، ``False`` را برگردانید. معادل با::"

msgid ""
"def any(iterable):\n"
"    for element in iterable:\n"
"        if element:\n"
"            return True\n"
"    return False"
msgstr ""
"def any(iterable):\n"
"    for element in iterable:\n"
"        if element:\n"
"            return True\n"
"    return False"

msgid "As :func:`repr`, return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by :func:`repr` using ``\\x``, ``\\u``, or ``\\U`` escapes.  This generates a string similar to that returned by :func:`repr` in Python 2."
msgstr "مانند تابع :func:`repr`، رشته‌ای حاوی نمایش قابل چاپ یک شیء را برمی‌گرداند، اما نویسه‌های غیر اَسکی (non-ASCII) را در رشته‌ی بازگردانده‌شده توسط تابع :func:`repr`، با استفاده از دنباله‌های خنثی‌سازی (escapes) ``\\x``، ``\\u`` یا ``\\U`` اِسکِیپ (escape) می‌کند. این عمل، رشته‌ای مشابه آنچه تابع :func:`repr` در پایتون ۲ بازمی‌گرداند، تولید می‌کند."

msgid "Convert an integer number to a binary string prefixed with \"0b\". The result is a valid Python expression. If *integer* is not a Python :class:`int` object, it has to define an :meth:`~object.__index__` method that returns an integer. Some examples:"
msgstr "تبدیل یک عدد صحیح به یک رشته دودویی که با \"0b\" پیشوند شده است. نتیجه یک عبارت معتبر پایتون خواهد بود. اگر *integer* یک شیء پایتون :class:`int` نباشد، لازم است یک متد :meth:`~object.__index__` تعریف کند که یک عدد صحیح برگرداند. برخی مثال ها:"

msgid "If the prefix \"0b\" is desired or not, you can use either of the following ways."
msgstr "چنانچه پیشوند \"0b\" مطلوب باشد یا نباشد، می‌توانید از یکی از روش‌های زیر استفاده کنید."

msgid "See also :func:`enum.bin` to represent negative values as twos-complement."
msgstr "همچنین برای نمایش مقادیر منفی به‌صورت مکمل دو، به :func:`enum.bin` مراجعه کنید."

msgid "See also :func:`format` for more information."
msgstr "همچنین برای اطلاعات بیشتر، به تابع :func:`format` مراجعه کنید."

msgid "Return a Boolean value, i.e. one of ``True`` or ``False``.  The argument is converted using the standard :ref:`truth testing procedure <truth>`. If the argument is false or omitted, this returns ``False``; otherwise, it returns ``True``.  The :class:`bool` class is a subclass of :class:`int` (see :ref:`typesnumeric`). It cannot be subclassed further.  Its only instances are ``False`` and ``True`` (see :ref:`typebool`)."
msgstr "یک مقدار بولی، یعنی یکی از ``True`` یا ``False`` را بر می‌گرداند.  آرگومان با استفاده از استاندارد :ref:`truth testing procedure <truth>` تبدیل می شود. اگر آرگومان نادرست یا حذف شده باشد، ``False`` را برمی گرداند. در غیر این صورت، ``True`` را برمی گرداند.  کلاس :class:`bool` یک زیر کلاس از :class:`int` است (به :ref:`typesnumeric` مراجعه کنید). این کلاس دیگر قابل زیرکلاس‌بندی نیست. تنها نمونه های آن ``False`` و ``True`` هستند (به :ref:`typebool` مراجعه کنید)."

msgid "The parameter is now positional-only."
msgstr "این پارامتر اکنون فقط‌جایگاهی (positional-only) است."

msgid "This function drops you into the debugger at the call site.  Specifically, it calls :func:`sys.breakpointhook`, passing ``args`` and ``kws`` straight through.  By default, ``sys.breakpointhook()`` calls :func:`pdb.set_trace` expecting no arguments.  In this case, it is purely a convenience function so you don't have to explicitly import :mod:`pdb` or type as much code to enter the debugger.  However, :func:`sys.breakpointhook` can be set to some other function and :func:`breakpoint` will automatically call that, allowing you to drop into the debugger of choice. If :func:`sys.breakpointhook` is not accessible, this function will raise :exc:`RuntimeError`."
msgstr "این تابع، اجرای برنامه را در محل فراخوانی متوقف کرده و شما را وارد محیط اشکال‌زدا می‌کند. به طور خاص، این تابع، :func:`sys.breakpointhook` را فراخوانی کرده و مقادیر ``args`` و ``kws`` مستقیماً به آن ارسال (pass) می‌کند. به طور پیش‌فرض، تابع ``sys.breakpointhook()`` بدون نیاز به هیچ آرگومانی :func:`pdb.set_trace` را فراخوانی می کند. در این حالت، این صرفاً یک تابع کمکی (convenience function) است تا مجبور نباشید ماژول :mod:`pdb` را به صراحت ایمپورت کنید یا برای ورود به اشکال‌زدا، کد زیادی بنویسید. با این حال، می‌توان :func:`sys.breakpointhook` را روی تابع دیگری تنظیم کرد و در این صورت، :func:`breakpoint` به طور خودکار آن را فراخوانی می کند و به شما این امکان را می دهد که به اشکال‌زدای مورد نظر خود وارد شوید. اگر :func:`sys.breakpointhook` قابل دسترسی نباشد، این تابع، استثنای :exc:`RuntimeError` را پرتاب خواهد کرد."

msgid "By default, the behavior of :func:`breakpoint` can be changed with the :envvar:`PYTHONBREAKPOINT` environment variable. See :func:`sys.breakpointhook` for usage details."
msgstr "به طور پیش‌فرض، رفتار تابع :func:`breakpoint` را می‌توان با متغیر محیطی :envvar:`PYTHONBREAKPOINT` تغییر داد. برای جزئیات استفاده، به تابع :func:`sys.breakpointhook` مراجعه کنید."

msgid "Note that this is not guaranteed if :func:`sys.breakpointhook` has been replaced."
msgstr "توجه داشته باشید که این امر تضمین نمی‌شود اگر تابع :func:`sys.breakpointhook` جایگزین شده باشد."

msgid "Raises an :ref:`auditing event <auditing>` ``builtins.breakpoint`` with argument ``breakpointhook``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` ``builtins.breakpoint`` با آرگومان ``breakpointhook`` پرتاب می‌کند."

msgid "Return a new array of bytes.  The :class:`bytearray` class is a mutable sequence of integers in the range 0 <= x < 256.  It has most of the usual methods of mutable sequences, described in :ref:`typesseq-mutable`, as well as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
msgstr "یک آرایه‌ی جدید از بایت‌ها را برمی‌گرداند. کلاس :class:`bytearray` دنباله‌ای قابل‌تغییر از اعداد صحیح در بازه‌ی 0 <= x < 256 است. این کلاس بیشتر متدهای معمول دنباله‌های قابل‌تغییر را دارد که در :ref:`typesseq-mutable` شرح داده شده‌اند، و همچنین بیشتر متدهایی را دارد که نوع :class:`bytes` دارد؛ به :ref:`bytes-methods` مراجعه کنید."

msgid "The optional *source* parameter can be used to initialize the array in a few different ways:"
msgstr "از پارامتر اختیاری *source* می‌توان برای مقداردهی اولیه آرایه به چند روش مختلف استفاده کرد:"

msgid "If it is a *string*, you must also give the *encoding* (and optionally, *errors*) parameters; :func:`bytearray` then converts the string to bytes using :meth:`str.encode`."
msgstr "اگر *source* یک *رشته* «*string*» باشد، باید پارامترهای *encoding* و (به‌صورت اختیاری) *errors* را نیز مشخص کنید؛ سپس تابع :func:`bytearray` آن رشته را با استفاده از متد :meth:`str.encode` به بایت‌ها تبدیل می‌کند."

msgid "If it is an *integer*, the array will have that size and will be initialized with null bytes."
msgstr "اگر «*source*» یک *عدد صحیح* «integer» باشد، آرایه به اندازه همان عدد ایجاد شده و با بایت‌های تهی «null byte» مقداردهی اولیه خواهد شد."

msgid "If it is an object conforming to the :ref:`buffer interface <bufferobjects>`, a read-only buffer of the object will be used to initialize the bytes array."
msgstr "اگر آرگومان، شیئی سازگار با :ref:`رابط بافر <bufferobjects>` باشد، از یک بافر فقط‌خواندنیِ آن شیء برای مقداردهی اولیه‌ی آرایه‌ی بایت‌ها استفاده خواهد شد."

msgid "If it is an *iterable*, it must be an iterable of integers in the range ``0 <= x < 256``, which are used as the initial contents of the array."
msgstr "اگر «*source*» یک *پیمایش‌پذیر* «iterable» باشد، باید یک پیمایش‌پذیر از اعداد صحیح در بازه ``0 <= x < 256`` باشد، که این اعداد به‌عنوان محتویات اولیه آرایه استفاده می‌شوند."

msgid "Without an argument, an array of size 0 is created."
msgstr "بدون آرگومان، یک آرایه با اندازه صفر «0» ایجاد می شود."

msgid "See also :ref:`binaryseq` and :ref:`typebytearray`."
msgstr "همچنین به :ref:`binaryseq` و :ref:`typebytearray` مراجعه کنید."

msgid "Return a new \"bytes\" object which is an immutable sequence of integers in the range ``0 <= x < 256``.  :class:`bytes` is an immutable version of :class:`bytearray` -- it has the same non-mutating methods and the same indexing and slicing behavior."
msgstr "یک شیء «bytes» جدید را برمی‌گرداند که دنباله‌ای تغییرناپذیر از اعداد صحیح در بازه‌ی ``0 <= x < 256`` است. :class:`bytes` نسخه‌ی تغییرناپذیر :class:`bytearray` است؛ همان متدهای غیرتغییردهنده و همان رفتار اندیس‌گذاری و اسلایس را دارد."

msgid "Accordingly, constructor arguments are interpreted as for :func:`bytearray`."
msgstr "بر این اساس، آرگومان‌های سازنده همانند :func:`bytearray` تفسیر می‌شوند."

msgid "Bytes objects can also be created with literals, see :ref:`strings`."
msgstr "اشیای bytes را می‌توان با استفاده از مقادیر لفظی نیز ایجاد کرد؛ برای اطلاعات بیشتر، :ref:`strings` را ببینید."

msgid "See also :ref:`binaryseq`, :ref:`typebytes`, and :ref:`bytes-methods`."
msgstr "همچنین به :ref:`binaryseq`، :ref:`typebytes` و :ref:`bytes-methods` مراجعه کنید."

msgid "Return :const:`True` if the *object* argument appears callable, :const:`False` if not.  If this returns ``True``, it is still possible that a call fails, but if it is ``False``, calling *object* will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a :meth:`~object.__call__` method."
msgstr "اگر آرگومان *object* فراخوانی‌پذیر باشد، مقدار :const:`True` و در غیر این صورت مقدار :const:`False` را برمی‌گرداند. اگر نتیجه ``True`` باشد، همچنان ممکن است فراخوانی با شکست مواجه شود؛ اما اگر ``False`` باشد، فراخوانی *object* هرگز موفق نخواهد شد. توجه داشته باشید که کلاس‌ها فراخوانی‌پذیر هستند (فراخوانی یک کلاس یک نمونه‌ی جدید برمی‌گرداند) و نمونه‌ها نیز در صورتی فراخوانی‌پذیر هستند که کلاس آن‌ها متد :meth:`~object.__call__` را داشته باشد."

msgid "This function was first removed in Python 3.0 and then brought back in Python 3.2."
msgstr "این تابع ابتدا در پایتون ۳٫۰ حذف شد و سپس در پایتون ۳٫۲ دوباره بازگردانده شد."

msgid "Return the string representing a character with the specified Unicode code point. For example, ``chr(97)`` returns the string ``'a'``, while ``chr(8364)`` returns the string ``'€'``. This is the inverse of :func:`ord`."
msgstr "رشته‌ای را که نویسه‌ی متناظر با نقطه‌ی کد یونیکد مشخص‌شده را نمایش می‌دهد، برمی‌گرداند. برای مثال، ``chr(97)`` رشته‌ی ``'a'`` و ``chr(8364)`` رشته‌ی ``'€'`` را برمی‌گرداند. این تابع معکوس :func:`ord` است."

msgid "The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16).  :exc:`ValueError` will be raised if it is outside that range."
msgstr "بازه‌ی معتبر برای این آرگومان از ۰ تا ۱٬۱۱۴٬۱۱۱ (برابر با 0x10FFFF در مبنای ۱۶) است. اگر مقدار خارج از این بازه باشد، استثنای :exc:`ValueError` پرتاب خواهد شد."

msgid "Transform a method into a class method."
msgstr "یک متد را به متد کلاسی تبدیل می‌کند."

msgid "A class method receives the class as an implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom::"
msgstr "یک متد کلاس، همان‌طور که متد نمونه، نمونه را به‌عنوان نخستین آرگومان ضمنی دریافت می‌کند، کلاس را به‌عنوان نخستین آرگومان ضمنی دریافت می‌کند. برای تعریف یک متد کلاس، از الگوی زیر استفاده کنید::"

msgid ""
"class C:\n"
"    @classmethod\n"
"    def f(cls, arg1, arg2): ..."
msgstr ""
"class C:\n"
"    @classmethod\n"
"    def f(cls, arg1, arg2): ..."

msgid "The ``@classmethod`` form is a function :term:`decorator` -- see :ref:`function` for details."
msgstr "شکل ``@classmethod`` یک :term:`دکوراتور <decorator>` تابع است؛ برای جزئیات به :ref:`تابع <function>` مراجعه کنید."

msgid "A class method can be called either on the class (such as ``C.f()``) or on an instance (such as ``C().f()``).  The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument."
msgstr "یک متد کلاس را می‌توان هم روی خود کلاس (مانند ``C.f()``) و هم روی یک نمونه (مانند ``C().f()``) فراخوانی کرد. در حالت دوم، نمونه نادیده گرفته می‌شود و فقط کلاس آن در نظر گرفته می‌شود. اگر متد کلاس برای یک کلاس مشتق‌شده فراخوانی شود، شیء کلاس مشتق‌شده به‌عنوان نخستین آرگومان ضمنی ارسال می‌شود."

msgid "Class methods are different than C++ or Java static methods. If you want those, see :func:`staticmethod` in this section. For more information on class methods, see :ref:`types`."
msgstr "متدهای کلاس با متدهای ایستای زبان‌های ++C یا Java تفاوت دارند. اگر به آن نوع متدها نیاز دارید، به :func:`staticmethod` در همین بخش مراجعه کنید. برای اطلاعات بیشتر درباره‌ی متدهای کلاس، :ref:`types` را ببینید."

msgid "Class methods can now wrap other :term:`descriptors <descriptor>` such as :func:`property`."
msgstr "اکنون متدهای کلاس می‌توانند سایر :term:`توصیف‌گرها <descriptor>`، مانند :func:`property`، را دربر بگیرند."

msgid "Class methods now inherit the method attributes (:attr:`~function.__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :attr:`~function.__doc__` and :attr:`~function.__annotations__`) and have a new ``__wrapped__`` attribute."
msgstr "اکنون متدهای کلاس ویژگی‌های متد (:attr:`~function.__module__`، :attr:`~function.__name__`، :attr:`~function.__qualname__`، :attr:`~function.__doc__` و :attr:`~function.__annotations__`) را به ارث می‌برند و همچنین دارای ویژگی جدید ``__wrapped__`` هستند."

msgid "Class methods can no longer wrap other :term:`descriptors <descriptor>` such as :func:`property`."
msgstr "دیگر متدهای کلاس نمی‌توانند سایر :term:`توصیف‌گرها <descriptor>`، مانند :func:`property`، را دربر بگیرند."

msgid "Compile the *source* into a code or AST object.  Code objects can be executed by :func:`exec` or :func:`eval`.  *source* can either be a normal string, a byte string, or an AST object.  Refer to the :mod:`ast` module documentation for information on how to work with AST objects."
msgstr "*source* را به یک شیء کد یا AST کامپایل می‌کند. اشیای کد را می‌توان با :func:`exec` یا :func:`eval` اجرا کرد. *source* می‌تواند یک رشته‌ی معمولی، یک رشته‌ی بایتی یا یک شیء AST باشد. برای اطلاعات بیشتر درباره‌ی کار با اشیای AST، به مستندات ماژول :mod:`ast` مراجعه کنید."

msgid "The *filename* argument should give the file from which the code was read; pass some recognizable value if it wasn't read from a file (``'<string>'`` is commonly used)."
msgstr "آرگومان *filename* باید نام پرونده‌ای را مشخص کند که کد از آن خوانده شده است؛ اگر کد از پرونده خوانده نشده، مقدار قابل تشخیصی را ارسال کنید (معمولاً از ``'<string>'`` استفاده می‌شود)."

#, fuzzy
#| msgid "The *mode* argument specifies what kind of code must be compiled; it can be ``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if it consists of a single expression, or ``'single'`` if it consists of a single interactive statement (in the latter case, expression statements that evaluate to something other than ``None`` will be printed)."
msgid "The *mode* argument specifies what kind of code must be compiled; it can be ``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if it consists of a single expression, or ``'single'`` if it consists of a single interactive statement (in the latter case, expression statements that evaluate to something other than ``None`` will be printed). It can also be ``'func_type'`` if *source* consists of a function type signature, for example ``(int) -> str``; see :func:`ast.parse` for more information. This mode requires passing :data:`ast.PyCF_ONLY_AST` in *flags*."
msgstr "آرگومان *mode* مشخص می‌کند که چه نوع کدی باید کامپایل شود؛ اگر *source* شامل دنباله‌ای از دستورها باشد، می‌تواند ``'exec'`` باشد؛ اگر شامل تنها یک عبارت باشد، ``'eval'``؛ و اگر شامل تنها یک دستور تعاملی باشد، ``'single'`` (در حالت آخر، اگر عبارت مقداری غیر از ``None`` تولید کند، آن مقدار چاپ خواهد شد)."

msgid "The optional arguments *flags* and *dont_inherit* control which :ref:`compiler options <ast-compiler-flags>` should be activated and which :ref:`future features <future>` should be allowed. If neither is present (or both are zero) the code is compiled with the same flags that affect the code that is calling :func:`compile`. If the *flags* argument is given and *dont_inherit* is not (or is zero) then the compiler options and the future statements specified by the *flags* argument are used in addition to those that would be used anyway. If *dont_inherit* is a non-zero integer then the *flags* argument is it -- the flags (future features and compiler options) in the surrounding code are ignored."
msgstr "آرگومان‌های اختیاری *flags* و *dont_inherit* تعیین می‌کنند که کدام :ref:`گزینه‌های کامپایلر <ast-compiler-flags>` فعال شوند و کدام :ref:`قابلیت‌های آینده <future>` مجاز باشند. اگر هیچ‌یک از آن‌ها ارائه نشوند (یا هر دو صفر باشند)، کد با همان پرچم‌هایی کامپایل می‌شود که بر کدی که :func:`compile` را فراخوانی کرده است اعمال می‌شوند. اگر آرگومان *flags* ارائه شود و *dont_inherit* ارائه نشود (یا صفر باشد)، گزینه‌های کامپایلر و دستورهای future مشخص‌شده توسط *flags* علاوه بر مواردی که به‌طور معمول اعمال می‌شوند، استفاده خواهند شد. اگر *dont_inherit* یک عدد صحیح ناصفر باشد، تنها از *flags* استفاده می‌شود و پرچم‌های (قابلیت‌های future و گزینه‌های کامپایلر) موجود در کد پیرامون نادیده گرفته می‌شوند."

msgid "Compiler options and future statements are specified by bits which can be bitwise ORed together to specify multiple options. The bitfield required to specify a given future feature can be found as the :attr:`~__future__._Feature.compiler_flag` attribute on the :class:`~__future__._Feature` instance in the :mod:`__future__` module. :ref:`Compiler flags <ast-compiler-flags>` can be found in :mod:`ast` module, with ``PyCF_`` prefix."
msgstr "گزینه‌های کامپایلر و دستورهای future با استفاده از بیت‌هایی مشخص می‌شوند که می‌توان آن‌ها را با عملگر OR بیتی با یکدیگر ترکیب کرد تا چندین گزینه به‌طور همزمان مشخص شوند. بیت‌فیلد لازم برای مشخص کردن هر قابلیت future را می‌توان در ویژگی :attr:`~__future__._Feature.compiler_flag` از نمونه‌ی :class:`~__future__._Feature` در ماژول :mod:`__future__` یافت. :ref:`پرچم‌های کامپایلر <ast-compiler-flags>` نیز با پیشوند ``PyCF_`` در ماژول :mod:`ast` موجود هستند."

msgid "The argument *optimize* specifies the optimization level of the compiler; the default value of ``-1`` selects the optimization level of the interpreter as given by :option:`-O` options.  Explicit levels are ``0`` (no optimization; ``__debug__`` is true), ``1`` (asserts are removed, ``__debug__`` is false) or ``2`` (docstrings are removed too)."
msgstr "آرگومان *optimize* سطح بهینه‌سازی کامپایلر را مشخص می‌کند؛ مقدار پیش‌فرض ``-1`` سطح بهینه‌سازی مفسر را مطابق گزینه‌های :option:`-O` انتخاب می‌کند. سطوح صریح عبارت‌اند از: ``0`` (بدون بهینه‌سازی؛ ``__debug__`` برابر با true است)، ``1`` (دستورهای assert حذف می‌شوند و ``__debug__`` برابر false است)، و ``2`` (علاوه بر آن، docstringها نیز حذف می‌شوند)."

msgid "The optional argument *module* specifies the module name. It is needed to unambiguous :ref:`filter <warning-filter>` syntax warnings by module name."
msgstr "آرگومان اختیاری *module* نام ماژول را مشخص می‌کند. این آرگومان برای رفع ابهام در هشدار‌های نحو (نحو :ref:`filter <warning-filter>`) بر اساس نام ماژول مورد نیاز است."

msgid "This function raises :exc:`SyntaxError` if the compiled source is invalid, including a *source* containing a null character or that cannot be decoded; :exc:`ValueError` if *mode* or *flags* is invalid, or if a string *source* contains surrogate characters; :exc:`MemoryError` or :exc:`RecursionError` if *source* is too complex to parse or compile, for example an expression with many thousands of nested operators; and :exc:`OverflowError` if *source* is too large."
msgstr "این تابع :exc:`SyntaxError` را پرتاب میکند اگر منبعِ کامپایل‌شده نامعتبر باشد، از جمله یک *source* که حاوی نویسه‌ی null است یا که قابل رمزگشایی نیست؛ :exc:`ValueError` اگر *حالت* یا *پرچم‌ها* نامعتبر باشند، یا اگر یک رشته *source* حاوی نویسه‌های جایگزین باشد؛ :exc:`MemoryError` یا :exc:`RecursionError` اگر *source* برای تجزیه یا کامپایل بیش از حد پیچیده باشد، برای مثال یک عبارت با هزاران عملگر تو در تو؛ و :exc:`OverflowError` اگر *source* بیش از حد بزرگ باشد."

msgid "If you want to parse Python code into its AST representation, see :func:`ast.parse`."
msgstr "اگر می‌خواهید کد پایتون را به نمایش AST آن تجزیه کنید، به :func:`ast.parse` مراجعه کنید."

msgid "Raises an :ref:`auditing event <auditing>` ``compile`` with arguments ``source`` and ``filename``. This event may also be raised by implicit compilation."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` با نام ``compile`` و آرگومان‌های ``source`` و ``filename`` پرتاب می‌کند. این رویداد ممکن است در نتیجه‌ی کامپایل ضمنی نیز پرتاب شود."

msgid "When compiling a string with multi-line code in ``'single'`` or ``'eval'`` mode, input must be terminated by at least one newline character.  This is to facilitate detection of incomplete and complete statements in the :mod:`code` module."
msgstr "هنگام کامپایل یک رشته شامل کد چندخطی در حالت ``'single'`` یا ``'eval'``، ورودی باید دست‌کم با یک نویسه‌ی پایان خط خاتمه یابد. این کار تشخیص دستورات ناقص و کامل را در ماژول :mod:`code` تسهیل می‌کند."

msgid "It is possible to crash the Python interpreter with a sufficiently large/complex string when compiling to an AST object due to stack depth limitations in Python's AST compiler."
msgstr "به دلیل محدودیت عمق پشته (stack depth) در کامپایلر AST پایتون، کامپایل یک رشته‌ی به‌اندازه‌ی کافی بزرگ یا پیچیده به یک شیء AST ممکن است باعث فروپاشی  مفسر پایتون شود."

msgid "Allowed use of Windows and Mac newlines.  Also, input in ``'exec'`` mode does not have to end in a newline anymore.  Added the *optimize* parameter."
msgstr "استفاده از نویسه‌های پایان خط ویندوز و مک مجاز شد. همچنین، ورودی در حالت ``'exec'`` دیگر لازم نیست با یک نویسه‌ی پایان خط خاتمه یابد. پارامتر *optimize* نیز اضافه شد."

msgid "Previously, :exc:`TypeError` was raised when null bytes were encountered in *source*."
msgstr "پیش از این، هنگام برخورد با بایت‌های تهی در *source*، استثنای :exc:`TypeError` پرتاب می‌شد."

msgid "``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` can now be passed in flags to enable support for top-level ``await``, ``async for``, and ``async with``."
msgstr "اکنون می‌توان ``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` را در پرچم‌ها ارسال کرد تا از ``await``، ``async for`` و ``async with`` در سطح بالای کد (top-level) پشتیبانی شود."

msgid "Added support for ``mode='func_type'``."
msgstr ""

msgid ":exc:`SyntaxError` is raised instead of :exc:`ValueError` when null bytes are encountered in *source*."
msgstr "هنگامی که بایت‌های تهی در *source* یافت شوند، :exc:`SyntaxError` به‌جای :exc:`ValueError` پرتاب می‌شود."

msgid "Added the *module* parameter."
msgstr "پارامتر *module* اضافه شد."

msgid "Convert a single string or number to a complex number, or create a complex number from real and imaginary parts."
msgstr "تبدیل یک رشته یا عدد به یک عدد مختلط، یا ایجاد یک عدد مختلط از بخش‌های حقیقی و موهومی یک عدد."

msgid "Examples:"
msgstr "مثال‌ها:"

msgid ""
">>> complex('+1.23')\n"
"(1.23+0j)\n"
">>> complex('-4.5j')\n"
"-4.5j\n"
">>> complex('-1.23+4.5j')\n"
"(-1.23+4.5j)\n"
">>> complex('\\t( -1.23+4.5J )\\n')\n"
"(-1.23+4.5j)\n"
">>> complex('-Infinity+NaNj')\n"
"(-inf+nanj)\n"
">>> complex(1.23)\n"
"(1.23+0j)\n"
">>> complex(imag=-4.5)\n"
"-4.5j\n"
">>> complex(-1.23, 4.5)\n"
"(-1.23+4.5j)"
msgstr ""
">>> complex('+1.23')\n"
"(1.23+0j)\n"
">>> complex('-4.5j')\n"
"-4.5j\n"
">>> complex('-1.23+4.5j')\n"
"(-1.23+4.5j)\n"
">>> complex('\\t( -1.23+4.5J )\\n')\n"
"(-1.23+4.5j)\n"
">>> complex('-Infinity+NaNj')\n"
"(-inf+nanj)\n"
">>> complex(1.23)\n"
"(1.23+0j)\n"
">>> complex(imag=-4.5)\n"
"-4.5j\n"
">>> complex(-1.23, 4.5)\n"
"(-1.23+4.5j)"

msgid "If the argument is a string, it must contain either a real part (in the same format as for :func:`float`) or an imaginary part (in the same format but with a ``'j'`` or ``'J'`` suffix), or both real and imaginary parts (the sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespaces and the round parentheses ``'('`` and ``')'``, which are ignored. The string must not contain whitespace between ``'+'``, ``'-'``, the ``'j'`` or ``'J'`` suffix, and the decimal number. For example, ``complex('1+2j')`` is fine, but ``complex('1 + 2j')`` raises :exc:`ValueError`. More precisely, the input must conform to the :token:`~float:complexvalue` production rule in the following grammar, after parentheses and leading and trailing whitespace characters are removed:"
msgstr "اگر آرگومان یک رشته باشد، باید شامل بخش حقیقی (با همان قالبی که برای :func:`float` استفاده می‌شود)، یا بخش موهومی (با همان قالب اما همراه با پسوند ``'j'`` یا ``'J'``)، یا هر دو بخش حقیقی و موهومی باشد (در این حالت، وجود علامت بخش موهومی الزامی است). رشته می‌تواند به‌صورت اختیاری با نویسه‌های فاصله‌ی سفید و پرانتزهای گرد ``'('`` و ``')'`` احاطه شده باشد که نادیده گرفته می‌شوند. همچنین، نباید بین ``'+'``، ``'-'``، پسوند ``'j'`` یا ``'J'`` و عدد ده‌دهی فاصله‌ی سفید وجود داشته باشد. برای مثال، ``complex('1+2j')`` معتبر است، اما ``complex('1 + 2j')`` باعث پرتاب استثنای :exc:`ValueError` می‌شود. به‌طور دقیق‌تر، پس از حذف پرانتزها و نویسه‌های فاصله‌ی سفید ابتدا و انتهای رشته، ورودی باید با قاعده‌ی تولید :token:`~float:complexvalue` در دستور زبان زیر مطابقت داشته باشد:"

msgid "If the argument is a number, the constructor serves as a numeric conversion like :class:`int` and :class:`float`. For a general Python object ``x``, ``complex(x)`` delegates to ``x.__complex__()``. If :meth:`~object.__complex__` is not defined then it falls back to :meth:`~object.__float__`. If :meth:`!__float__` is not defined then it falls back to :meth:`~object.__index__`."
msgstr "اگر آرگومان یک عدد باشد، سازنده مانند :class:`int` و :class:`float` به‌عنوان یک تبدیل عددی عمل می‌کند. برای یک شیء عمومی پایتون به نام ``x``، تابع ``complex(x)`` فراخوانی را به ``x.__complex__()`` واگذار می‌کند. اگر :meth:`~object.__complex__` تعریف نشده باشد، به :meth:`~object.__float__` بازمی‌گردد. اگر :meth:`!__float__` نیز تعریف نشده باشد، به :meth:`~object.__index__` بازمی‌گردد."

msgid "If two arguments are provided or keyword arguments are used, each argument may be any numeric type (including complex). If both arguments are real numbers, return a complex number with the real component *real* and the imaginary component *imag*. If both arguments are complex numbers, return a complex number with the real component ``real.real-imag.imag`` and the imaginary component ``real.imag+imag.real``. If one of arguments is a real number, only its real component is used in the above expressions."
msgstr "اگر دو آرگومان ارائه شوند یا از آرگومان‌های کلیدواژه‌ای استفاده شود، هر آرگومان می‌تواند از هر نوع عددی (از جمله اعداد مختلط) باشد. اگر هر دو آرگومان عدد حقیقی باشند، یک عدد مختلط با بخش حقیقی *real* و بخش موهومی *imag* برگردانده می‌شود. اگر هر دو آرگومان عدد مختلط باشند، عدد مختلطی با بخش حقیقی ``real.real-imag.imag`` و بخش موهومی ``real.imag+imag.real`` برگردانده می‌شود. اگر یکی از آرگومان‌ها عدد حقیقی باشد، فقط بخش حقیقی آن در عبارت‌های بالا استفاده می‌شود."

msgid "See also :meth:`complex.from_number` which only accepts a single numeric argument."
msgstr "همچنین به :meth:`complex.from_number` مراجعه کنید که فقط یک آرگومان عددی را می‌پذیرد."

msgid "If all arguments are omitted, returns ``0j``."
msgstr "اگر همه‌ی آرگومان‌ها حذف شوند، مقدار ``0j`` برگردانده می‌شود."

msgid "The complex type is described in :ref:`typesnumeric`."
msgstr "نوع مختلط در :ref:`typesnumeric` توضیح داده شده است."

msgid "Grouping digits with underscores as in code literals is allowed."
msgstr "گروه‌بندی رقم‌ها با استفاده از زیرخط، مانند مقادیر لفظی در کد، مجاز است."

msgid "Falls back to :meth:`~object.__index__` if :meth:`~object.__complex__` and :meth:`~object.__float__` are not defined."
msgstr "اگر :meth:`~object.__complex__` و :meth:`~object.__float__` تعریف نشده باشند، به :meth:`~object.__index__` بازمی‌گردد."

msgid "Passing a complex number as the *real* or *imag* argument is now deprecated; it should only be passed as a single positional argument."
msgstr "ارسال یک عدد مختلط به‌عنوان آرگومان *real* یا *imag* اکنون منسوخ شده است؛ عدد مختلط باید فقط به‌صورت یک آرگومان جایگاهی ارسال شود."

msgid "This is a relative of :func:`setattr`.  The arguments are an object and a string.  The string must be the name of one of the object's attributes.  The function deletes the named attribute, provided the object allows it.  For example, ``delattr(x, 'foobar')`` is equivalent to ``del x.foobar``. *name* need not be a Python identifier (see :func:`setattr`)."
msgstr "این تابع همتای :func:`setattr` است. آرگومان‌های آن یک شیء و یک رشته هستند. رشته باید نام یکی از ویژگی‌های شیء باشد. در صورت مجاز بودن، این تابع ویژگی نام‌برده را حذف می‌کند. برای مثال، ``delattr(x, 'foobar')`` معادل ``del x.foobar`` است. *name* الزامی ندارد که یک شناسه‌ی معتبر پایتون باشد (به :func:`setattr` مراجعه کنید)."

msgid "Create a new dictionary.  The :class:`dict` object is the dictionary class. See also :ref:`typesmapping` for documentation about this class."
msgstr "ایجاد یک دیکشنری جدید. شیء :class:`dict` کلاس دیکشنری است. برای مستندات این کلاس، به :ref:`typesmapping` مراجعه کنید."

msgid "For other containers see the built-in :class:`frozendict`, :class:`list`, :class:`set`, and :class:`tuple` classes, as well as the :mod:`collections` module."
msgstr "برای سایر ظروف، به کلاس‌های توکار :class:`frozendict`، :class:`list`، :class:`set` و :class:`tuple` و همچنین ماژول :mod:`collections` مراجعه کنید."

msgid "Without arguments, return the list of names in the current local scope.  With an argument, attempt to return a list of valid attributes for that object."
msgstr "بدون آرگومان، فهرست نام‌های موجود در دامنه‌ی محلیِ فعلی را بازمی‌گرداند. با ارسال یک آرگومان، تلاش می‌کند فهرستی از ویژگی‌های معتبر آن شیء را بازگرداند."

msgid "If the object has a method named :meth:`~object.__dir__`, this method will be called and must return the list of attributes. This allows objects that implement a custom :func:`~object.__getattr__` or :func:`~object.__getattribute__` function to customize the way :func:`dir` reports their attributes."
msgstr "اگر شیء متدی با نام :meth:`~object.__dir__` داشته باشد، این متد فراخوانی می‌شود و باید فهرستی از ویژگی‌ها را برگرداند. این امکان را فراهم می‌کند که اشیایی که :func:`~object.__getattr__` یا :func:`~object.__getattribute__` سفارشی را پیاده‌سازی کرده‌اند، نحوه‌ی گزارش ویژگی‌های خود توسط :func:`dir` را سفارشی‌سازی کنند."

msgid "If the object does not provide :meth:`~object.__dir__`, the function tries its best to gather information from the object's :attr:`~object.__dict__` attribute, if defined, and from its type object.  The resulting list is not necessarily complete and may be inaccurate when the object has a custom :func:`~object.__getattr__`."
msgstr "اگر شیء متد :meth:`~object.__dir__` را ارائه نکند، این تابع در صورت تعریف شدن، تلاش می‌کند تا حد امکان اطلاعات را از ویژگی :attr:`~object.__dict__` شیء و همچنین از شیء نوع (type object) آن جمع‌آوری کند. فهرست حاصل لزوماً کامل نیست و اگر شیء دارای :func:`~object.__getattr__` سفارشی باشد، ممکن است دقیق هم نباشد."

msgid "The default :func:`dir` mechanism behaves differently with different types of objects, as it attempts to produce the most relevant, rather than complete, information:"
msgstr "سازوکار پیش‌فرض :func:`dir` بسته به نوع شیء رفتار متفاوتی دارد، زیرا تلاش می‌کند به‌جای ارائه‌ی اطلاعات کامل، مرتبط‌ترین اطلاعات را ارائه دهد:"

msgid "If the object is a module object, the list contains the names of the module's attributes."
msgstr "اگر شیء یک ماژول باشد، فهرست شامل نام ویژگی‌های آن ماژول خواهد بود."

msgid "If the object is a type or class object, the list contains the names of its attributes, and recursively of the attributes of its bases."
msgstr "اگر شیء یک نوع یا کلاس باشد، فهرست شامل نام ویژگی‌های آن و همچنین، به‌صورت بازگشتی، نام ویژگی‌های کلاس‌های پایه‌ی آن خواهد بود."

msgid "Otherwise, the list contains the object's attributes' names, the names of its class's attributes, and recursively of the attributes of its class's base classes."
msgstr "در غیر این صورت، فهرست شامل نام ویژگی‌های شیء، نام ویژگی‌های کلاس آن، و همچنین به‌صورت بازگشتی، نام ویژگی‌های کلاس‌های پایه‌ی آن خواهد بود."

msgid "The resulting list is sorted alphabetically.  For example:"
msgstr "فهرست حاصل به‌ترتیب الفبایی مرتب می‌شود. برای مثال:"

msgid "Because :func:`dir` is supplied primarily as a convenience for use at an interactive prompt, it tries to supply an interesting set of names more than it tries to supply a rigorously or consistently defined set of names, and its detailed behavior may change across releases.  For example, metaclass attributes are not in the result list when the argument is a class."
msgstr "از آنجا که :func:`dir` در درجه‌ی اول برای سهولت استفاده در اعلان تعاملی طراحی شده است، بیشتر تلاش می‌کند مجموعه‌ای مفید از نام‌ها را ارائه دهد تا مجموعه‌ای با تعریف دقیق و سازگار. بنابراین، رفتار دقیق آن ممکن است بین نسخه‌های مختلف تغییر کند. برای مثال، اگر آرگومان یک کلاس باشد، ویژگی‌های فراکلاس در فهرست نتایج قرار نمی‌گیرند."

msgid "Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division.  With mixed operand types, the rules for binary arithmetic operators apply.  For integers, the result is the same as ``(a // b, a % b)``. For floating-point numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a / b)`` but may be 1 less than that.  In any case ``q * b + a % b`` is very close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0 <= abs(a % b) < abs(b)``."
msgstr "دو عدد (غیرمختلط) را به‌عنوان آرگومان می‌گیرد و جفتی از اعداد شامل خارج‌قسمت و باقیمانده‌ی تقسیم کف آن‌ها را برمی‌گرداند. در صورت متفاوت بودن نوع عملوندها، قواعد عملگرهای حسابی دودویی اعمال می‌شود. برای اعداد صحیح، نتیجه برابر با ``(a // b, a % b)`` است. برای اعداد ممیز شناور، نتیجه ``(q, a % b)`` است که در آن *q* معمولاً برابر ``math.floor(a / b)`` است، اما ممکن است یک واحد کمتر از آن باشد. در هر صورت، مقدار ``q * b + a % b`` بسیار به *a* نزدیک است، و اگر ``a % b`` صفر نباشد، هم‌علامت با *b* خواهد بود و همچنین ``0 <= abs(a % b) < abs(b)`` برقرار است."

msgid "Return an enumerate object. *iterable* must be a sequence, an :term:`iterator`, or some other object which supports iteration. The :meth:`~iterator.__next__` method of the iterator returned by :func:`enumerate` returns a tuple containing a count (from *start* which defaults to 0) and the values obtained from iterating over *iterable*."
msgstr "یک شیء enumerate را برمی‌گرداند. *iterable* باید یک دنباله، یک :term:`پیمایش‌گر <iterator>` یا هر شیء دیگری باشد که از پیمایش پشتیبانی می‌کند. متد :meth:`~iterator.__next__` پیمایش‌گر بازگردانده‌شده توسط :func:`enumerate`، تاپلی شامل یک شمارنده (که از *start* آغاز می‌شود و مقدار پیش‌فرض آن 0 است) و مقادیر به‌دست‌آمده از پیمایش *iterable* را برمی‌گرداند."

msgid "Equivalent to::"
msgstr "مساوی است با::"

msgid ""
"def enumerate(iterable, start=0):\n"
"    n = start\n"
"    for elem in iterable:\n"
"        yield n, elem\n"
"        n += 1"
msgstr ""
"def enumerate(iterable, start=0):\n"
"    n = start\n"
"    for elem in iterable:\n"
"        yield n, elem\n"
"        n += 1"

msgid "Parameters"
msgstr "پارامترها"

msgid "A Python expression."
msgstr "یک عبارت پایتون."

msgid "The global namespace (default: ``None``)."
msgstr "فضای نام سراسری (پیش‌فرض: ``None``)."

msgid "The local namespace (default: ``None``)."
msgstr "فضای نام محلی (پیش‌فرض: ``None``)."

msgid "Returns"
msgstr "بازمیگرداند"

msgid "The result of the evaluated expression."
msgstr "نتیجه‌ی عبارت ارزیابی‌شده."

msgid "raises"
msgstr "پرتاب می‌کند"

msgid "Syntax errors are reported as exceptions."
msgstr "خطاهای نحوی به‌صورت استثنا گزارش می‌شوند."

msgid "This function executes arbitrary code. Calling it with untrusted user-supplied input will lead to security vulnerabilities."
msgstr "این تابع کد دلخواه را اجرا می‌کند. فراخوانی آن با ورودیِ تأمین‌شده از سوی کاربر که قابل اعتماد نیست، منجر به آسیب‌پذیری‌های امنیتی خواهد شد."

msgid "The *source* argument is parsed and evaluated as a Python expression (technically speaking, an :ref:`expression list <exprlists>`) using the *globals* and *locals* mappings as global and local namespace. If the *globals* dictionary is present and does not contain a value for the key ``__builtins__``, a reference to the dictionary of the built-in module :mod:`builtins` is inserted under that key before *source* is parsed. Overriding ``__builtins__`` can be used to restrict or change the available names, but this is **not** a security mechanism: the executed code can still access all builtins. If the *locals* mapping is omitted it defaults to the *globals* dictionary.  If both mappings are omitted, the source is executed with the *globals* and *locals* in the environment where :func:`eval` is called.  Note, *eval()* will only have access to the :term:`nested scopes <nested scope>` (non-locals) in the enclosing environment if they are already referenced in the scope that is calling :func:`eval` (e.g. via a :keyword:`nonlocal` statement)."
msgstr "آرگومان *source* به‌عنوان یک عبارت پایتون (از نظر فنی، یک :ref:`فهرست عبارات <exprlists>`) با استفاده از نگاشت‌های *globals* و *locals* به‌ترتیب به‌عنوان فضای نام سراسری و محلی، تجزیه و ارزیابی می‌شود. اگر دیکشنری *globals* وجود داشته باشد اما کلید ``__builtins__`` را نداشته باشد، پیش از تجزیه‌ی *source*، ارجاعی به دیکشنری ماژول توکار :mod:`builtins` تحت این کلید درج می‌شود. بازنویسی ``__builtins__`` می‌تواند برای محدود کردن یا تغییر نام‌های در دسترس استفاده شود، اما این **یک سازوکار امنیتی نیست**؛ زیرا کد اجراشده همچنان می‌تواند به تمام توابع و اشیای توکار دسترسی داشته باشد. اگر نگاشت *locals* ارائه نشود، به‌طور پیش‌فرض از دیکشنری *globals* استفاده می‌شود. اگر هر دو نگاشت حذف شوند، *source* با استفاده از *globals* و *locals* محیطی که :func:`eval` در آن فراخوانی شده اجرا می‌شود. توجه داشته باشید که *eval()* تنها در صورتی به :term:`دامنه‌های تودرتو <nested scope>` (متغیرهای nonlocal) محیط پیرامون دسترسی خواهد داشت که آن‌ها از قبل در دامنه‌ای که :func:`eval` را فراخوانی می‌کند ارجاع داده شده باشند (برای مثال، از طریق دستور :keyword:`nonlocal`)."

msgid "Example:"
msgstr "مثال:"

msgid "This function can also be used to execute arbitrary code objects (such as those created by :func:`compile`).  In this case, pass a code object instead of a string.  If the code object has been compiled with ``'exec'`` as the *mode* argument, :func:`eval`\\'s return value will be ``None``."
msgstr "از این تابع همچنین می‌توان برای اجرای اشیای کد دلخواه (مانند اشیایی که توسط :func:`compile` ایجاد شده‌اند) استفاده کرد. در این حالت، به‌جای رشته، یک شیء کد ارسال کنید. اگر شیء کد با آرگومان *mode* برابر ``'exec'`` کامپایل شده باشد، مقدار بازگشتی :func:`eval` برابر ``None`` خواهد بود."

msgid "Hints: dynamic execution of statements is supported by the :func:`exec` function.  The :func:`globals` and :func:`locals` functions return the current global and local dictionary, respectively, which may be useful to pass around for use by :func:`eval` or :func:`exec`."
msgstr "راهنمایی: اجرای پویای دستورها توسط تابع :func:`exec` پشتیبانی می‌شود. توابع :func:`globals` و :func:`locals` به‌ترتیب دیکشنری سراسری و محلی فعلی را برمی‌گردانند که می‌توان آن‌ها را برای استفاده در :func:`eval` یا :func:`exec` به توابع دیگر ارسال کرد."

msgid "If the given source is a string, then leading and trailing spaces and tabs are stripped."
msgstr "اگر کد منبع داده‌شده یک رشته باشد، فاصله‌ها و نویسه‌های تب ابتدا و انتهای آن حذف می‌شوند."

msgid "See :func:`ast.literal_eval` for a function to evaluate strings with expressions containing only literals."
msgstr "برای تابعی که رشته‌های دارای عبارت‌هایی شامل فقط مقادیر لفظی را ارزیابی می‌کند، به :func:`ast.literal_eval` مراجعه کنید."

msgid "Raises an :ref:`auditing event <auditing>` ``exec`` with the code object as the argument. Code compilation events may also be raised."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` با نام ``exec`` و شیء کد به‌عنوان آرگومان پرتاب می‌کند. رویدادهای مربوط به کامپایل کد نیز ممکن است پرتاب شوند."

msgid "The *globals* and *locals* arguments can now be passed as keywords."
msgstr "آرگومان‌های *globals* و *locals* اکنون می‌توانند به‌صورت آرگومان کلیدواژه‌ای نیز ارسال شوند."

msgid "The semantics of the default *locals* namespace have been adjusted as described for the :func:`locals` builtin."
msgstr "معنای فضای نام پیش‌فرض *locals* مطابق توضیحات ارائه‌شده برای تابع توکار :func:`locals` تنظیم شده است."

msgid "*globals* can now be a :class:`frozendict`."
msgstr "اکنون *globals* می‌تواند یک :class:`frozendict` باشد."

msgid "This function supports dynamic execution of Python code. *source* must be either a string or a code object.  If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). [#]_ If it is a code object, it is simply executed.  In all cases, the code that's executed is expected to be valid as file input (see the section :ref:`file-input` in the Reference Manual). Be aware that the :keyword:`nonlocal`, :keyword:`yield`,  and :keyword:`return` statements may not be used outside of function definitions even within the context of code passed to the :func:`exec` function. The return value is ``None``."
msgstr "این تابع از اجرای پویای کد پایتون پشتیبانی می‌کند. *source* باید یا یک رشته باشد یا یک شیء کد. اگر رشته باشد، به‌عنوان مجموعه‌ای از دستورهای پایتون تجزیه و سپس اجرا می‌شود (مگر اینکه خطای نحوی رخ دهد). [#]_ اگر یک شیء کد باشد، مستقیماً اجرا می‌شود. در همه‌ی موارد، انتظار می‌رود کد اجراشده به‌عنوان ورودی پرونده معتبر باشد (به بخش :ref:`file-input` در راهنمای مرجع مراجعه کنید). توجه داشته باشید که دستورهای :keyword:`nonlocal`، :keyword:`yield` و :keyword:`return` حتی در کدی که از طریق :func:`exec` اجرا می‌شود نیز خارج از تعریف تابع قابل استفاده نیستند. مقدار بازگشتی ``None`` است."

msgid "In all cases, if the optional parts are omitted, the code is executed in the current scope.  If only *globals* is provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global and the local variables.  If *globals* and *locals* are given, they are used for the global and local variables, respectively.  If provided, *locals* can be any mapping object.  Remember that at the module level, globals and locals are the same dictionary."
msgstr "در همه‌ی حالت‌ها، اگر بخش‌های اختیاری حذف شوند، کد در محدوده فعلی اجرا می‌شود. اگر فقط *globals* ارائه شود، باید یک دیکشنری باشد (و نه یک زیرکلاس از دیکشنری) که هم برای متغیرهای سراسری و هم برای متغیرهای محلی استفاده خواهد شد. اگر هر دو *globals* و *locals* ارائه شوند، به‌ترتیب برای متغیرهای سراسری و محلی استفاده می‌شوند. در صورت ارائه، *locals* می‌تواند هر شیء نگاشتی باشد. به خاطر داشته باشید که در سطح ماژول، globals و locals همان دیکشنری یکسان هستند."

msgid "When ``exec`` gets two separate objects as *globals* and *locals*, the code will be executed as if it were embedded in a class definition. This means functions and classes defined in the executed code will not be able to access variables assigned at the top level (as the \"top level\" variables are treated as class variables in a class definition)."
msgstr "وقتی ``exec`` دو شیء جداگانه را به‌عنوان *globals* و *locals* دریافت می‌کند، کد به‌گونه‌ای اجرا می‌شود که گویی درون یک تعریف کلاس قرار دارد. این بدان معناست که توابع و کلاس‌های تعریف‌شده در کد اجراشده نمی‌توانند به متغیرهای اختصاص‌یافته در سطح بالا دسترسی داشته باشند (زیرا متغیرهای «سطح بالا» در تعریف کلاس به‌عنوان متغیرهای کلاس در نظر گرفته می‌شوند)."

msgid "If the *globals* dictionary does not contain a value for the key ``__builtins__``, a reference to the dictionary of the built-in module :mod:`builtins` is inserted under that key. Overriding ``__builtins__`` can be used to restrict or change the available names, but this is **not** a security mechanism: the executed code can still access all builtins."
msgstr "اگر دیکشنری *globals* مقداری برای کلید ``__builtins__`` نداشته باشد، ارجاعی به دیکشنری ماژول توکار :mod:`builtins` با همان کلید در آن درج می‌شود. بازنویسی ``__builtins__`` می‌تواند برای محدود کردن یا تغییر نام‌های در دسترس استفاده شود، اما این **یک سازوکار امنیتی نیست**؛ زیرا کدی که اجرا می‌شود همچنان می‌تواند به تمام اشیای توکار دسترسی داشته باشد."

msgid "The *closure* argument specifies a closure--a tuple of cellvars. It's only valid when the *object* is a code object containing :term:`free (closure) variables <closure variable>`. The length of the tuple must exactly match the length of the code object's :attr:`~codeobject.co_freevars` attribute."
msgstr "آرگومان *بستار* یک بستار را مشخص می‌کند؛ یعنی یک تاپل از cellvarها. این آرگومان تنها زمانی معتبر است که *object* یک شیء کد باشد که شامل :term:`متغیرهای آزاد (بستار) <closure variable>` باشد. طول این تاپل باید دقیقاً با طول ویژگی :attr:`~codeobject.co_freevars` شیء کد برابر باشد."

msgid "The built-in functions :func:`globals` and :func:`locals` return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument to :func:`exec`."
msgstr "توابع توکار :func:`globals` و :func:`locals` به‌ترتیب فضای نام سراسری و محلی فعلی را برمی‌گردانند که می‌توانند برای ارسال به‌عنوان آرگومان دوم و سوم تابع :func:`exec` مفید باشند."

msgid "The default *locals* act as described for function :func:`locals` below. Pass an explicit *locals* dictionary if you need to see effects of the code on *locals* after function :func:`exec` returns."
msgstr "*locals* پیش‌فرض همان‌گونه عمل می‌کند که در ادامه برای تابع :func:`locals` توضیح داده شده است. اگر لازم است پس از بازگشت تابع :func:`exec` تغییرات اعمال‌شده روی *locals* را مشاهده کنید، یک دیکشنری *locals* صریح ارسال کنید."

msgid "Added the *closure* parameter."
msgstr "پارامتر *closure* اضافه شد."

msgid "Construct an iterator from those elements of *iterable* for which *function* is true.  *iterable* may be either a sequence, a container which supports iteration, or an iterator.  If *function* is ``None``, the identity function is assumed, that is, all elements of *iterable* that are false are removed."
msgstr "از میان عناصر *iterable*، آن‌هایی را که *function* برایشان مقدار True برمی‌گرداند، انتخاب کرده و یک پیمایش‌گر می‌سازد. *iterable* می‌تواند یک دنباله، یک ظرف پیمایش‌پذیر، یا یک پیمایش‌گر باشد. اگر *function* برابر ``None`` باشد، تابع همانی در نظر گرفته می‌شود؛ یعنی تمام عناصری از *iterable* که نادرست (False) هستند، حذف می‌شوند."

msgid "Note that ``filter(function, iterable)`` is equivalent to the generator expression ``(item for item in iterable if function(item))`` if function is not ``None`` and ``(item for item in iterable if item)`` if function is ``None``."
msgstr "توجه داشته باشید که اگر *function* برابر ``None`` نباشد، ``filter(function, iterable)`` معادل عبارت تولیدگر ``(item for item in iterable if function(item))`` است، و اگر *function* برابر ``None`` باشد، معادل ``(item for item in iterable if item)`` خواهد بود."

msgid "See :func:`itertools.filterfalse` for the complementary function that returns elements of *iterable* for which *function* is false."
msgstr "برای تابع مکملی که عناصر *iterable* را که *function* برای آن‌ها مقدار نادرست (false) برمی‌گرداند، بازمی‌گرداند، به :func:`itertools.filterfalse` مراجعه کنید."

msgid "Return a floating-point number constructed from a number or a string."
msgstr "یک عدد ممیز شناور که از یک عدد یا یک رشته ساخته شده است را برمی‌گرداند."

msgid ""
">>> float('+1.23')\n"
"1.23\n"
">>> float('   -12345\\n')\n"
"-12345.0\n"
">>> float('1e-003')\n"
"0.001\n"
">>> float('+1E6')\n"
"1000000.0\n"
">>> float('-Infinity')\n"
"-inf"
msgstr ""
">>> float('+1.23')\n"
"1.23\n"
">>> float('   -12345\\n')\n"
"-12345.0\n"
">>> float('1e-003')\n"
"0.001\n"
">>> float('+1E6')\n"
"1000000.0\n"
">>> float('-Infinity')\n"
"-inf"

msgid "If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace.  The optional sign may be ``'+'`` or ``'-'``; a ``'+'`` sign has no effect on the value produced.  The argument may also be a string representing a NaN (not-a-number), or positive or negative infinity. More precisely, the input must conform to the :token:`~float:floatvalue` production rule in the following grammar, after leading and trailing whitespace characters are removed:"
msgstr "اگر آرگومان یک رشته باشد، باید شامل یک عدد ده‌دهی باشد که به‌صورت اختیاری با یک علامت و همچنین با فاصله‌ی سفید احاطه شده باشد. علامت اختیاری می‌تواند ``'+'`` یا ``'-'`` باشد؛ علامت ``'+'`` تأثیری بر مقدار تولیدشده ندارد. آرگومان همچنین می‌تواند رشته‌ای باشد که یک NaN (عدد نیست) یا بی‌نهایت مثبت یا منفی را نمایش می‌دهد. به‌طور دقیق‌تر، پس از حذف نویسه‌های فاصله‌ی سفید ابتدا و انتهای رشته، ورودی باید با قاعده‌ی تولید :token:`~float:floatvalue` در دستور زبان زیر مطابقت داشته باشد:"

msgid "Case is not significant, so, for example, \"inf\", \"Inf\", \"INFINITY\", and \"iNfINity\" are all acceptable spellings for positive infinity."
msgstr "بزرگی و کوچکی حروف (case) اهمیتی ندارد؛ بنابراین، برای مثال، «inf»، «Inf»، «INFINITY» و «iNfINity» همگی برای نمایش بی‌نهایت مثبت معتبر هستند."

msgid "Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python's floating-point precision) is returned.  If the argument is outside the range of a Python float, an :exc:`OverflowError` will be raised."
msgstr "در غیر این صورت، اگر آرگومان یک عدد صحیح یا یک عدد ممیز شناور باشد، یک عدد ممیز شناور با همان مقدار (در محدوده‌ی دقت اعداد ممیز شناور پایتون) برگردانده می‌شود. اگر آرگومان خارج از محدوده‌ی یک عدد ممیز شناور در پایتون باشد، استثنای :exc:`OverflowError` پرتاب خواهد شد."

msgid "For a general Python object ``x``, ``float(x)`` delegates to ``x.__float__()``.  If :meth:`~object.__float__` is not defined then it falls back to :meth:`~object.__index__`."
msgstr "برای یک شیء عمومی پایتون به نام ``x``، تابع ``float(x)`` فراخوانی را به ``x.__float__()`` واگذار می‌کند. اگر :meth:`~object.__float__` تعریف نشده باشد، به :meth:`~object.__index__` بازمی‌گردد."

msgid "See also :meth:`float.from_number` which only accepts a numeric argument."
msgstr "همچنین به :meth:`float.from_number` مراجعه کنید که فقط یک آرگومان عددی را می‌پذیرد."

msgid "If no argument is given, ``0.0`` is returned."
msgstr "اگر هیچ آرگومانی ارائه نشود، مقدار ``0.0`` برگردانده می‌شود."

msgid "The float type is described in :ref:`typesnumeric`."
msgstr "نوع ممیز شناور در :ref:`typesnumeric` توضیح داده شده است."

msgid "Falls back to :meth:`~object.__index__` if :meth:`~object.__float__` is not defined."
msgstr "اگر :meth:`~object.__float__` تعریف نشده باشد، به :meth:`~object.__index__` بازمی‌گردد."

msgid "Convert a *value* to a \"formatted\" representation, as controlled by *format_spec*.  The interpretation of *format_spec* will depend on the type of the *value* argument; however, there is a standard formatting syntax that is used by most built-in types: :ref:`formatspec`."
msgstr "*value* را مطابق با *format_spec* به یک نمایش قالب‌بندی‌شده تبدیل می‌کند. نحوه‌ی تفسیر *format_spec* به نوع آرگومان *value* بستگی دارد؛ با این حال، یک سینتکس استاندارد برای قالب‌بندی وجود دارد که بیشتر انواع توکار از آن استفاده می‌کنند: :ref:`formatspec`."

msgid "The default *format_spec* is an empty string which usually gives the same effect as calling :func:`str(value) <str>`."
msgstr "مقدار پیش‌فرض *format_spec* یک رشته‌ی خالی است که معمولاً همان اثری را دارد که فراخوانی :func:`str(value) <str>` ایجاد می‌کند."

msgid "A call to ``format(value, format_spec)`` is translated to ``type(value).__format__(value, format_spec)`` which bypasses the instance dictionary when searching for the value's :meth:`~object.__format__` method. A :exc:`TypeError` exception is raised if the method search reaches :mod:`object` and the *format_spec* is non-empty, or if either the *format_spec* or the return value are not strings."
msgstr "فراخوانی ``format(value, format_spec)`` به ``type(value).__format__(value, format_spec)`` تبدیل می‌شود که هنگام جست‌وجوی متد :meth:`~object.__format__` مربوط به *value*، دیکشنری نمونه را نادیده می‌گیرد. اگر جست‌وجوی متد به :mod:`object` برسد و *format_spec* خالی نباشد، یا اگر *format_spec* یا مقدار بازگشتی رشته نباشند، استثنای :exc:`TypeError` پرتاب می‌شود."

msgid "``object().__format__(format_spec)`` raises :exc:`TypeError` if *format_spec* is not an empty string."
msgstr "اگر *format_spec* یک رشته‌ی خالی نباشد، ``object().__format__(format_spec)`` استثنای :exc:`TypeError` پرتاب می‌کند."

msgid "Create a new frozen dictionary.  The :class:`frozendict` object is a built-in class. See also :ref:`typesmapping` for documentation about this class."
msgstr "یک دیکشنری فریزشده‌ی جدید ایجاد کنید. شیء :class:`frozendict` یک کلاس توکار است. برای مستندات مربوط به این کلاس، به :ref:`typesmapping` نیز مراجعه کنید."

msgid "For other containers see the built-in :class:`dict`, :class:`list`, :class:`set`, and :class:`tuple` classes, as well as the :mod:`collections` module."
msgstr "برای سایر ظروف، به کلاس‌های توکار :class:`dict`، :class:`list`، :class:`set` و :class:`tuple` و همچنین ماژول :mod:`collections` مراجعه کنید."

msgid "Return a new :class:`frozenset` object, optionally with elements taken from *iterable*.  :class:`frozenset` is a built-in class.  See also :ref:`types-set` for documentation about this class."
msgstr "یک شیء جدید از نوع :class:`frozenset` را برمی‌گرداند که در صورت ارائه، عناصر آن از *iterable* گرفته می‌شوند. :class:`frozenset` یک کلاس توکار است. برای مستندات این کلاس، به :ref:`types-set` مراجعه کنید."

msgid "For other containers see the built-in :class:`set`, :class:`list`, :class:`tuple`, and :class:`dict` classes, as well as the :mod:`collections` module."
msgstr "برای سایر انواع ظرف‌ها، به کلاس‌های توکار :class:`set`، :class:`list`، :class:`tuple` و :class:`dict`، و همچنین ماژول :mod:`collections` مراجعه کنید."

msgid "Return the value of the named attribute of *object*.  *name* must be a string. If the string is the name of one of the object's attributes, the result is the value of that attribute.  For example, ``getattr(x, 'foobar')`` is equivalent to ``x.foobar``.  If the named attribute does not exist, *default* is returned if provided, otherwise :exc:`AttributeError` is raised. *name* need not be a Python identifier (see :func:`setattr`)."
msgstr "مقدار ویژگیِ نام‌گذاری‌شده‌ی *object* را برمی‌گرداند. *name* باید یک رشته باشد. اگر رشته، نام یکی از ویژگی‌های شیء باشد، نتیجه مقدار آن ویژگی خواهد بود. برای مثال، ``getattr(x, 'foobar')`` معادل ``x.foobar`` است. اگر ویژگیِ نام‌گذاری‌شده وجود نداشته باشد، در صورت ارائه، *default* برگردانده می‌شود؛ در غیر این صورت، استثنای :exc:`AttributeError` پرتاب می‌شود. لازم نیست *name* یک شناسه‌ی معتبر پایتون باشد (به :func:`setattr` مراجعه کنید)."

msgid "Since :ref:`private name mangling <private-name-mangling>` happens at compilation time, one must manually mangle a private attribute's (attributes with two leading underscores) name in order to retrieve it with :func:`getattr`."
msgstr "از آنجا که :ref:`تغییر نام خصوصی <private-name-mangling>` در زمان کامپایل انجام می‌شود، برای بازیابی یک ویژگی خصوصی (ویژگی‌هایی که با دو زیرخط آغاز می‌شوند) با استفاده از :func:`getattr`، باید نام آن را به‌صورت دستی تغییر دهید."

msgid "Return the dictionary implementing the current module namespace. For code within functions, this is set when the function is defined and remains the same regardless of where the function is called."
msgstr "دیکشنریی را که فضای نام ماژول فعلی را پیاده‌سازی می‌کند، برمی‌گرداند. برای کدهای داخل توابع، این مقدار هنگام تعریف تابع تنظیم می‌شود و بدون توجه به این‌که تابع از کجا فراخوانی شود، ثابت باقی می‌ماند."

msgid "The arguments are an object and a string.  The result is ``True`` if the string is the name of one of the object's attributes, ``False`` if not. (This is implemented by calling ``getattr(object, name)`` and seeing whether it raises an :exc:`AttributeError` or not.)"
msgstr "آرگومان‌ها شامل یک شیء و یک رشته هستند. اگر رشته نام یکی از ویژگی‌های آن شیء باشد، نتیجه ``True`` و در غیر این صورت ``False`` خواهد بود. (این کار با فراخوانی ``getattr(object, name)`` و بررسی اینکه آیا استثنای :exc:`AttributeError` پرتاب می‌شود یا نه، پیاده‌سازی شده است.)"

msgid "Return the hash value of the object (if it has one).  Hash values are integers.  They are used to quickly compare dictionary keys during a dictionary lookup.  Numeric values that compare equal have the same hash value (even if they are of different types, as is the case for 1 and 1.0)."
msgstr "مقدار هش شیء را (در صورتی که داشته باشد) برمی‌گرداند. مقادیر هش اعداد صحیح هستند. از آن‌ها برای مقایسه‌ی سریع کلیدهای دیکشنری هنگام جست‌وجو در دیکشنری استفاده می‌شود. مقادیر عددی که با یکدیگر برابر مقایسه می‌شوند، مقدار هش یکسانی دارند (حتی اگر از نوع‌های متفاوتی باشند، مانند 1 و 1.0)."

msgid "For objects with custom :meth:`~object.__hash__` methods, note that :func:`hash` truncates the return value based on the bit width of the host machine."
msgstr "برای اشیایی که متد :meth:`~object.__hash__` سفارشی دارند، توجه داشته باشید که :func:`hash` مقدار بازگشتی را بر اساس پهنای بیت ماشین میزبان کوتاه می‌کند."

msgid "Invoke the built-in help system.  (This function is intended for interactive use.)  If no argument is given, the interactive help system starts on the interpreter console.  If the argument is a string, then the string is looked up as the name of a module, function, class, method, keyword, or documentation topic, and a help page is printed on the console.  If the argument is any other kind of object, a help page on the object is generated."
msgstr "سامانه‌ی راهنمای توکار را فراخوانی می‌کند. (این تابع برای استفاده‌ی تعاملی طراحی شده است.) اگر هیچ آرگومانی ارائه نشود، سامانه‌ی راهنمای تعاملی در کنسول مفسر آغاز می‌شود. اگر آرگومان یک رشته باشد، آن رشته به‌عنوان نام یک ماژول، تابع، کلاس، متد، کلیدواژه یا موضوع مستندات جست‌وجو می‌شود و صفحه‌ی راهنمای آن در کنسول نمایش داده می‌شود. اگر آرگومان هر نوع شیء دیگری باشد، صفحه‌ی راهنمای مربوط به آن شیء تولید می‌شود."

msgid "Note that if a slash(/) appears in the parameter list of a function when invoking :func:`help`, it means that the parameters prior to the slash are positional-only. For more info, see :ref:`the FAQ entry on positional-only parameters <faq-positional-only-arguments>`."
msgstr "توجه داشته باشید که اگر هنگام فراخوانی :func:`help` یک اسلش (/) در فهرست پارامترهای یک تابع ظاهر شود، به این معناست که پارامترهای قبل از اسلش فقط به‌صورت جایگاهی قابل ارسال هستند. برای اطلاعات بیشتر، به :ref:`پرسش متداول مربوط به پارامترهای فقط جایگاهی <faq-positional-only-arguments>` مراجعه کنید."

msgid "This function is added to the built-in namespace by the :mod:`site` module."
msgstr "این تابع توسط ماژول :mod:`site` به فضای نام توکار (built-in namespace) اضافه می‌شود."

msgid "Changes to :mod:`pydoc` and :mod:`inspect` mean that the reported signatures for callables are now more comprehensive and consistent."
msgstr "تغییرات اعمال‌شده در :mod:`pydoc` و :mod:`inspect` باعث شده‌اند امضاهای گزارش‌شده برای اشیای فراخوانی‌پذیر اکنون کامل‌تر و سازگارتر باشند."

msgid "Convert an integer number to a lowercase hexadecimal string prefixed with \"0x\". If *integer* is not a Python :class:`int` object, it has to define an :meth:`~object.__index__` method that returns an integer. Some examples:"
msgstr "یک عدد صحیح را به یک رشته‌ی مبنای شانزده کوچک‌حرف با پیشوند «0x» تبدیل می‌کند. اگر *integer* یک شیء از نوع :class:`int` پایتون نباشد، باید متدی به نام :meth:`~object.__index__` تعریف کند که یک عدد صحیح برمی‌گرداند. چند نمونه:"

msgid "If you want to convert an integer number to an uppercase or lower hexadecimal string with prefix or not, you can use either of the following ways:"
msgstr "اگر می‌خواهید یک عدد صحیح را به یک رشته‌ی مبنای شانزده با حروف بزرگ یا کوچک، با پیشوند یا بدون آن، تبدیل کنید، می‌توانید از هر یک از روش‌های زیر استفاده کنید:"

msgid "See also :func:`int` for converting a hexadecimal string to an integer using a base of 16."
msgstr "همچنین برای تبدیل یک رشته‌ی مبنای شانزده به یک عدد صحیح با استفاده از مبنای 16، به :func:`int` مراجعه کنید."

msgid "To obtain a hexadecimal string representation for a float, use the :meth:`float.hex` method."
msgstr "برای به‌دست‌آوردن نمایش شانزدهی یک عدد ممیز شناور، از متد :meth:`float.hex` استفاده کنید."

msgid "Return the \"identity\" of an object.  This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same :func:`id` value."
msgstr "«شناسه» یک شیء را برمی‌گرداند. این مقدار یک عدد صحیح است که در طول عمر آن شیء، یکتا و ثابت بودنش تضمین شده است. دو شیء که طول عمر آن‌ها با یکدیگر هم‌پوشانی ندارد، ممکن است مقدار یکسانی از :func:`id` داشته باشند."

msgid "This is the address of the object in memory."
msgstr "این، آدرس شیء در حافظه است."

msgid "Raises an :ref:`auditing event <auditing>` ``builtins.id`` with argument ``id``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` با نام ``builtins.id`` و آرگومان ``id`` پرتاب می‌کند."

msgid "If the *prompt* argument is present, it is written to standard output without a trailing newline.  The function then reads a line from input, converts it to a string (stripping a trailing newline), and returns that.  When EOF is read, :exc:`EOFError` is raised.  Example::"
msgstr "اگر آرگومان *prompt* ارائه شود، بدون افزودن نویسه‌ی پایان خط در خروجی استاندارد نوشته می‌شود. سپس تابع یک خط از ورودی می‌خواند، آن را به یک رشته تبدیل می‌کند (با حذف نویسه‌ی پایان خط انتهایی) و همان را برمی‌گرداند. اگر به پایان پرونده  برسد، استثنای :exc:`EOFError` پرتاب می‌شود. مثال::"

msgid ""
">>> s = input('--> ')\n"
"--> Monty Python's Flying Circus\n"
">>> s\n"
"\"Monty Python's Flying Circus\""
msgstr ""
">>> s = input('--> ')\n"
"--> Monty Python's Flying Circus\n"
">>> s\n"
"\"Monty Python's Flying Circus\""

msgid "If the :mod:`readline` module was loaded, then :func:`input` will use it to provide elaborate line editing and history features."
msgstr "اگر ماژول :mod:`readline` بارگذاری شده باشد، :func:`input` از آن برای فراهم کردن امکانات پیشرفته‌ی ویرایش خط و تاریخچه‌ی ورودی استفاده می‌کند."

msgid "Raises an :ref:`auditing event <auditing>` ``builtins.input`` with argument ``prompt`` before reading input"
msgstr "پیش از خواندن ورودی، یک :ref:`رویداد حسابرسی <auditing>` با نام ``builtins.input`` و آرگومان ``prompt`` پرتاب می‌کند"

msgid "Raises an :ref:`auditing event <auditing>` ``builtins.input/result`` with the result after successfully reading input."
msgstr "پس از خواندن موفقیت‌آمیز ورودی، یک :ref:`رویداد حسابرسی <auditing>` با نام ``builtins.input/result`` و نتیجه‌ی خوانده‌شده پرتاب می‌کند."

msgid "Return an integer object constructed from a number or a string, or return ``0`` if no arguments are given."
msgstr "یک شیء عدد صحیح را که از یک عدد یا یک رشته ساخته شده است برمی‌گرداند، یا اگر هیچ آرگومانی داده نشده باشد، مقدار ``0`` را برمی‌گرداند."

msgid ""
">>> int(123.45)\n"
"123\n"
">>> int('123')\n"
"123\n"
">>> int('   -12_345\\n')\n"
"-12345\n"
">>> int('FACE', 16)\n"
"64206\n"
">>> int('0xface', 0)\n"
"64206\n"
">>> int('01110011', base=2)\n"
"115"
msgstr ""
">>> int(123.45)\n"
"123\n"
">>> int('123')\n"
"123\n"
">>> int('   -12_345\\n')\n"
"-12345\n"
">>> int('FACE', 16)\n"
"64206\n"
">>> int('0xface', 0)\n"
"64206\n"
">>> int('01110011', base=2)\n"
"115"

msgid "If the argument defines :meth:`~object.__int__`, ``int(x)`` returns ``x.__int__()``.  If the argument defines :meth:`~object.__index__`, it returns ``x.__index__()``. For floating-point numbers, this truncates towards zero."
msgstr "اگر آرگومان متد :meth:`~object.__int__` را تعریف کرده باشد، ``int(x)`` مقدار ``x.__int__()`` را برمی‌گرداند. اگر آرگومان متد :meth:`~object.__index__` را تعریف کرده باشد، مقدار ``x.__index__()`` برگردانده می‌شود. برای اعداد ممیز شناور، این تبدیل بخش اعشاری را در جهت صفر حذف می‌کند."

msgid "If the argument is not a number or if *base* is given, then it must be a string, :class:`bytes`, or :class:`bytearray` instance representing an integer in radix *base*.  Optionally, the string can be preceded by ``+`` or ``-`` (with no space in between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed between digits."
msgstr "اگر آرگومان یک عدد نباشد یا *base* داده شده باشد، باید یک نمونه از رشته، :class:`bytes` یا :class:`bytearray` باشد که یک عدد صحیح را در مبنای *base* نشان می‌دهد. رشته می‌تواند به‌طور اختیاری با ``+`` یا ``-`` (بدون فاصله بین آن‌ها و عدد)، با صفرهای ابتدایی، دربرگرفته‌شده با فاصله‌های سفید، و با زیرخط‌های منفرد در میان رقم‌ها باشد."

msgid "A base-n integer string contains digits, each representing a value from 0 to n-1. The values 0--9 can be represented by any Unicode decimal digit. The values 10--35 can be represented by ``a`` to ``z`` (or ``A`` to ``Z``). The default *base* is 10. The allowed bases are 0 and 2--36. Base-2, -8, and -16 strings can be optionally prefixed with ``0b``/``0B``, ``0o``/``0O``, or ``0x``/``0X``, as with integer literals in code.  For base 0, the string is interpreted in a similar way to an :ref:`integer literal in code <integers>`, in that the actual base is 2, 8, 10, or 16 as determined by the prefix. Base 0 also disallows leading zeros: ``int('010', 0)`` is not legal, while ``int('010')`` and ``int('010', 8)`` are."
msgstr "یک رشته‌ی عدد صحیح در مبنای n شامل رقم‌هایی است که هر یک مقداری بین 0 تا n-1 را نمایش می‌دهند. مقادیر 0 تا 9 را می‌توان با هر رقم ده‌دهی یونیکد نمایش داد. مقادیر 10 تا 35 را می‌توان با نویسه‌های ``a`` تا ``z`` (یا ``A`` تا ``Z``) نمایش داد. مقدار پیش‌فرض *base* برابر 10 است. مبناهای مجاز عبارت‌اند از 0 و 2 تا 36. رشته‌های مبنای 2، 8 و 16 می‌توانند، همانند ثابت‌های عدد صحیح در کد، به‌ترتیب با پیشوندهای ``0b``/``0B``، ``0o``/``0O`` یا ``0x``/``0X`` آغاز شوند. برای مبنای 0، رشته مشابه یک :ref:`ثابت عدد صحیح در کد <integers>` تفسیر می‌شود؛ یعنی مبنای واقعی بر اساس پیشوند، یکی از 2، 8، 10 یا 16 خواهد بود. همچنین در مبنای 0 استفاده از صفرهای ابتدایی مجاز نیست؛ بنابراین ``int('010', 0)`` معتبر نیست، در حالی که ``int('010')`` و ``int('010', 8)`` معتبر هستند."

msgid "The integer type is described in :ref:`typesnumeric`."
msgstr "نوع عدد صحیح (integer) در :ref:`typesnumeric` توضیح داده شده است."

msgid "If *base* is not an instance of :class:`int` and the *base* object has a :meth:`base.__index__ <object.__index__>` method, that method is called to obtain an integer for the base.  Previous versions used :meth:`base.__int__ <object.__int__>` instead of :meth:`base.__index__ <object.__index__>`."
msgstr "اگر *base* نمونه‌ای از :class:`int` نباشد و شیء *base* متد :meth:`base.__index__ <object.__index__>` را تعریف کرده باشد، آن متد برای به‌دست آوردن یک عدد صحیح به‌عنوان مبنا فراخوانی می‌شود. در نسخه‌های پیشین، به‌جای :meth:`base.__index__ <object.__index__>` از :meth:`base.__int__ <object.__int__>` استفاده می‌شد."

msgid "The first parameter is now positional-only."
msgstr "پارامتر اول اکنون فقط به‌صورت فقط‌جایگاهی قابل ارسال است."

msgid "Falls back to :meth:`~object.__index__` if :meth:`~object.__int__` is not defined."
msgstr "اگر :meth:`~object.__int__` تعریف نشده باشد، به :meth:`~object.__index__` بازمی‌گردد."

msgid ":class:`int` string inputs and string representations can be limited to help avoid denial of service attacks. A :exc:`ValueError` is raised when the limit is exceeded while converting a string to an :class:`int` or when converting an :class:`int` into a string would exceed the limit. See the :ref:`integer string conversion length limitation <int_max_str_digits>` documentation."
msgstr "ورودی‌های رشته‌ای :class:`int` و نمایش‌های رشته‌ای آن را می‌توان برای کمک به جلوگیری از حملات منع سرویس (Denial of Service) محدود کرد. اگر هنگام تبدیل یک رشته به :class:`int` از این محدودیت فراتر رود، یا تبدیل یک :class:`int` به رشته باعث عبور از این محدودیت شود، استثنای :exc:`ValueError` پرتاب می‌شود. برای اطلاعات بیشتر، مستندات :ref:`محدودیت طول تبدیل رشته‌ای اعداد صحیح <int_max_str_digits>` را ببینید."

msgid ":func:`int` no longer delegates to the :meth:`~object.__trunc__` method."
msgstr ":func:`int` دیگر فراخوانی را به متد :meth:`~object.__trunc__` واگذار نمی‌کند."

msgid "Return ``True`` if the *object* argument is an instance of the *classinfo* argument, or of a (direct, indirect, or :term:`virtual <abstract base class>`) subclass thereof.  If *object* is not an object of the given type, the function always returns ``False``. If *classinfo* is a tuple of type objects (or recursively, other such tuples) or a :ref:`types-union` of multiple types, return ``True`` if *object* is an instance of any of the types. If *classinfo* is not a type or tuple of types and such tuples, a :exc:`TypeError` exception is raised. :exc:`TypeError` may not be raised for an invalid type if an earlier check succeeds."
msgstr "اگر آرگومان *object* نمونه‌ای از *classinfo* یا از یکی از زیرکلاس‌های آن (مستقیم، غیرمستقیم یا :term:`مجازی <abstract base class>`) باشد، مقدار ``True`` را برمی‌گرداند. اگر *object* از نوع داده‌شده نباشد، این تابع همیشه ``False`` برمی‌گرداند. اگر *classinfo* یک تاپل از نوع‌ها (یا به‌صورت بازگشتی، تاپل‌هایی از این نوع) یا یک :ref:`types-union` از چندین نوع باشد، در صورتی که *object* نمونه‌ای از هر یک از آن نوع‌ها باشد، مقدار ``True`` برگردانده می‌شود. اگر *classinfo* یک نوع، یا تاپلی از نوع‌ها و تاپل‌های مشابه نباشد، استثنای :exc:`TypeError` پرتاب می‌شود. با این حال، اگر یک بررسیِ زودتر با موفقیت انجام شود، ممکن است برای یک نوع نامعتبر استثنای :exc:`TypeError` پرتاب نشود."

msgid "*classinfo* can be a :ref:`types-union`."
msgstr "*classinfo* می‌تواند یک :ref:`types-union` باشد."

msgid "Return ``True`` if *cls* is a subclass (direct, indirect, or :term:`virtual <abstract base class>`) of *classinfo*.  A class is considered a subclass of itself. *classinfo* may be a tuple of class objects (or recursively, other such tuples) or a :ref:`types-union`, in which case return ``True`` if *cls* is a subclass of any entry in *classinfo*.  In any other case, a :exc:`TypeError` exception is raised."
msgstr "اگر *cls* زیرکلاس (مستقیم، غیرمستقیم، یا :term:`مجازی <abstract base class>`) از *classinfo* باشد، ``True`` را برمی‌گرداند. یک کلاس زیرکلاس خودش در نظر گرفته می‌شود. *classinfo* ممکن است تاتویی از شیء‌های کلاس (یا به طور بازگشتی، سایر تاپل‌های این‌چنینی) یا یک :ref:`types-union` باشد؛ در این صورت، اگر *cls* زیرکلاس هر یک از ورودی‌های *classinfo* باشد، ``True`` بازگردانده می‌شود. در هر صورت دیگر، یک استثنای :exc:`TypeError` بالا برده می‌شود."

msgid "Return an :term:`iterator` object.  The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, the single argument must be a collection object which supports the :term:`iterable` protocol (the :meth:`~object.__iter__` method), or it must support the sequence protocol (the :meth:`~object.__getitem__` method with integer arguments starting at ``0``).  If it does not support either of those protocols, :exc:`TypeError` is raised. If the second argument, *sentinel*, is given, then the first argument must be a callable object.  The iterator created in this case will call *callable* with no arguments for each call to its :meth:`~iterator.__next__` method; if the value returned is equal to *sentinel*, :exc:`StopIteration` will be raised, otherwise the value will be returned."
msgstr "یک شیء :term:`پیمایش‌گر <iterator>` را برمی‌گرداند. تفسیر آرگومان اول به وجود یا عدم وجود آرگومان دوم بستگی دارد. اگر آرگومان دومی وجود نداشته باشد، آرگومان اول باید یک شیء مجموعه باشد که از پروتکل :term:`پیمایش‌پذیر <iterable>` (متد :meth:`~object.__iter__`) پشتیبانی کند، یا از پروتکل دنباله (متد :meth:`~object.__getitem__` با آرگومان‌های صحیح که از ``0`` شروع می‌شوند) پشتیبانی کند. اگر از هیچ‌یک از این پروتکل‌ها پشتیبانی نکند، استثنای :exc:`TypeError` پرتاب می‌شود. اگر آرگومان دوم، یعنی *sentinel*، ارائه شود، آرگومان اول باید یک شیء فراخوانی‌پذیر باشد. پیمایش‌گر ایجادشده در این حالت، در هر فراخوانی متد :meth:`~iterator.__next__`، *callable* را بدون آرگومان فراخوانی می‌کند؛ اگر مقدار بازگردانده‌شده برابر *sentinel* باشد، استثنای :exc:`StopIteration` پرتاب می‌شود؛ در غیر این صورت، همان مقدار برگردانده می‌شود."

msgid "See also :ref:`typeiter`."
msgstr "همچنین به :ref:`typeiter` مراجعه کنید."

msgid "One useful application of the second form of :func:`iter` is to build a block-reader. For example, reading fixed-width blocks from a binary database file until the end of file is reached::"
msgstr "یکی از کاربردهای مفید شکل دوم :func:`iter`، ساختن یک خواننده‌ی بلوکی (block reader) است. برای مثال، خواندن بلوک‌هایی با اندازه‌ی ثابت از یک پرونده‌ی پایگاه داده‌ی دودویی تا رسیدن به انتهای پرونده::"

msgid ""
"from functools import partial\n"
"with open('mydata.db', 'rb') as f:\n"
"    for block in iter(partial(f.read, 64), b''):\n"
"        process_block(block)"
msgstr ""
"from functools import partial\n"
"with open('mydata.db', 'rb') as f:\n"
"    for block in iter(partial(f.read, 64), b''):\n"
"        process_block(block)"

msgid "Return the length (the number of items) of an object.  The argument may be a sequence (such as a string, bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set)."
msgstr "طول یک شیء (تعداد عناصر آن) را برمی‌گرداند. آرگومان می‌تواند یک دنباله (مانند رشته، bytes، تاپل، فهرست یا range) یا یک مجموعه (مانند دیکشنری، set یا frozenset) باشد."

msgid "``len`` raises :exc:`OverflowError` on lengths larger than :data:`sys.maxsize`, such as :class:`range(2 ** 100) <range>`."
msgstr "``len`` برای طول‌هایی بزرگ‌تر از :data:`sys.maxsize`، مانند :class:`range(2 ** 100) <range>`، استثنای :exc:`OverflowError` پرتاب می‌کند."

msgid "Rather than being a function, :class:`list` is actually a mutable sequence type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
msgstr ":class:`list` در واقع یک نوع دنباله‌ی تغییرپذیر است، نه یک تابع؛ همان‌گونه که در :ref:`typesseq-list` و :ref:`typesseq` مستند شده است."

msgid "Return a mapping object representing the current local symbol table, with variable names as the keys, and their currently bound references as the values."
msgstr "یک شیء نگاشتی را برمی‌گرداند که جدول نمادهای محلی فعلی را نمایش می‌دهد؛ در آن، نام متغیرها کلیدها و ارجاع‌های فعلی آن‌ها مقادیر هستند."

msgid "At module scope, as well as when using :func:`exec` or :func:`eval` with a single namespace, this function returns the same namespace as :func:`globals`."
msgstr "در محدوده‌ی ماژول، و همچنین هنگام استفاده از :func:`exec` یا :func:`eval` با یک فضای نام واحد، این تابع همان فضای نامی را برمی‌گرداند که :func:`globals` برمی‌گرداند."

msgid "At class scope, it returns the namespace that will be passed to the metaclass constructor."
msgstr "در محدوده‌ی کلاس، این تابع فضای نامی را برمی‌گرداند که به سازنده‌ی فراکلاس ارسال خواهد شد."

msgid "When using ``exec()`` or ``eval()`` with separate local and global arguments, it returns the local namespace passed in to the function call."
msgstr "هنگام استفاده از ``exec()`` یا ``eval()`` با آرگومان‌های محلی و سراسریِ جداگانه، این تابع فضای نام محلیِ ارسال‌شده به فراخوانی تابع را بازمی‌گرداند."

msgid "In all of the above cases, each call to ``locals()`` in a given frame of execution will return the *same* mapping object. Changes made through the mapping object returned from ``locals()`` will be visible as assigned, reassigned, or deleted local variables, and assigning, reassigning, or deleting local variables will immediately affect the contents of the returned mapping object."
msgstr "در همه‌ی حالت‌های بالا، هر فراخوانی ``locals()`` در یک فریممشخص از اجرا، *همان* شیء نگاشتی را برمی‌گرداند. تغییراتی که از طریق شیء نگاشتیِ بازگردانده‌شده توسط ``locals()`` اعمال شوند، به‌صورت انتساب، انتساب مجدد یا حذف متغیرهای محلی قابل مشاهده خواهند بود، و انتساب، انتساب مجدد یا حذف متغیرهای محلی نیز بلافاصله محتوای شیء نگاشتیِ بازگردانده‌شده را تغییر می‌دهد."

msgid "In an :term:`optimized scope` (including functions, generators, and coroutines), each call to ``locals()`` instead returns a fresh dictionary containing the current bindings of the function's local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are *not* written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does *not* affect the contents of previously returned dictionaries."
msgstr "در یک :term:`محدوده‌ی بهینه‌شده <optimized scope>` (از جمله توابع، تولیدگرها و هم‌روال‌ها)، هر فراخوانی ``locals()`` یک دیکشنری جدید برمی‌گرداند که شامل انتساب‌های فعلی متغیرهای محلی تابع و هرگونه ارجاع به سلول‌های غیرمحلی است. در این حالت، تغییرات انتساب نام که از طریق دیکشنری بازگردانده‌شده انجام شوند، به متغیرهای محلی یا ارجاع‌های سلول‌های غیرمحلی متناظر بازنویسی *نمی‌شوند*، و انتساب، انتساب مجدد یا حذف متغیرهای محلی و ارجاع‌های سلول‌های غیرمحلی نیز بر محتوای دیکشنری‌های بازگردانده‌شده‌ی قبلی تأثیری *ندارد*."

msgid "Calling ``locals()`` as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension's initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function."
msgstr "فراخوانی ``locals()`` درون یک comprehension در یک تابع، تولیدگر یا هم‌روال، معادل فراخوانی آن در محدوده‌ی دربرگیرنده است، با این تفاوت که متغیرهای پیمایشِ مقداردهی‌شده‌ی comprehension نیز در آن گنجانده می‌شوند. در سایر محدوده‌ها رفتار آن به‌گونه‌ای است که گویی comprehension به‌صورت یک تابع تودرتو اجرا می‌شود."

msgid "Calling ``locals()`` as part of a generator expression is equivalent to calling it in a nested generator function."
msgstr "فراخوانی ``locals()`` درون یک عبارت تولیدگر معادل فراخوانی آن در یک تابع تولیدگر تودرتو است."

msgid "The behaviour of ``locals()`` in a comprehension has been updated as described in :pep:`709`."
msgstr "رفتار ``locals()`` در comprehensionها مطابق :pep:`709` به‌روزرسانی شده است."

msgid "As part of :pep:`667`, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in :term:`optimized scopes <optimized scope>` is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions."
msgstr "به‌عنوان بخشی از :pep:`667`، اکنون معناشناسی تغییر دادن اشیای نگاشتی که این تابع برمی‌گرداند، تعریف شده است. رفتار این تابع در :term:`محدوده‌های بهینه‌شده <optimized scope>` اکنون همان‌گونه است که در بالا توضیح داده شد. به‌جز تعریف رسمی این رفتار، عملکرد آن در سایر محدوده‌ها نسبت به نسخه‌های پیشین تغییری نکرده است."

msgid "Return an iterator that applies *function* to every item of *iterable*, yielding the results.  If additional *iterables* arguments are passed, *function* must take that many arguments and is applied to the items from all iterables in parallel.  With multiple iterables, the iterator stops when the shortest iterable is :term:`exhausted`.  If *strict* is ``True`` and one of the iterables is exhausted before the others, a :exc:`ValueError` is raised. For cases where the function inputs are already arranged into argument tuples, see :func:`itertools.starmap`."
msgstr "یک پیمایش‌گر برگردانید که *function* را به هر *item* از *iterable* اعمال می‌کند و نتایج را تولید می‌کند.  اگر آرگومان‌های *iterables* اضافه‌ای داده شوند، *function* باید آن تعداد آرگومان بپذیرد و به آیتم‌های تمام پیمایش‌پذیرها به صورت موازی اعمال شود.  با چند پیمایش‌پذیر، پیمایش‌گر زمانی متوقف می‌شود که کوتاه‌ترین پیمایش‌پذیر :term:`به پایان رسیده <exhausted>` شود.  اگر *strict* برابر ``True`` باشد و یکی از پیمایش‌پذیرها قبل از بقیه به پایان برسد، یک :exc:`ValueError` تولید می‌شود. برای مواردی که ورودی‌های تابع قبلاً در تاپل‌های آرگومان دستبند شده‌اند، به :func:`itertools.starmap` مراجعه کنید."

msgid "Added the *strict* parameter."
msgstr "پارامتر *strict* اضافه شد."

msgid "Return the largest item in an iterable or the largest of two or more arguments."
msgstr "بزرگ‌ترین عنصر یک پیمایش‌پذیر، یا بزرگ‌ترین مقدار از میان دو یا چند آرگومان را برمی‌گرداند."

msgid "If one positional argument is provided, it should be an :term:`iterable`. The largest item in the iterable is returned.  If two or more positional arguments are provided, the largest of the positional arguments is returned."
msgstr "اگر یک آرگومان جایگاهی ارائه شود، باید یک :term:`پیمایش‌پذیر <iterable>` باشد. در این صورت، بزرگ‌ترین عنصر آن پیمایش‌پذیر برگردانده می‌شود. اگر دو یا چند آرگومان جایگاهی ارائه شوند، بزرگ‌ترین آرگومان جایگاهی برگردانده می‌شود."

msgid "There are two optional keyword-only arguments. The *key* argument specifies a one-argument ordering function like that used for :meth:`list.sort`. The *default* argument specifies an object to return if the provided iterable is empty. If the iterable is empty and *default* is not provided, a :exc:`ValueError` is raised."
msgstr "دو آرگومان اختیاریِ فقط-کلیدواژه‌ای (keyword-only) وجود دارد. آرگومان *key* یک تابع مرتب‌سازی تک‌آرگومانی، مشابه آنچه در :meth:`list.sort` استفاده می‌شود، مشخص می‌کند. آرگومان *default* شی‌ءای را مشخص می‌کند که در صورت خالی بودن پیمایش‌پذیر بازگردانده شود. اگر پیمایش‌پذیر خالی باشد و *default* ارائه نشده باشد، استثنای :exc:`ValueError` پرتاب می‌شود."

msgid "If multiple items are maximal, the function returns the first one encountered.  This is consistent with other sort-stability preserving tools such as ``sorted(iterable, key=keyfunc, reverse=True)[0]`` and ``heapq.nlargest(1, iterable, key=keyfunc)``."
msgstr "اگر چندین عنصر دارای بیشترین مقدار باشند، تابع نخستین موردی را که با آن برخورد کند برمی‌گرداند. این رفتار با سایر ابزارهایی که پایداری مرتب‌سازی را حفظ می‌کنند، مانند ``sorted(iterable, key=keyfunc, reverse=True)[0]`` و ``heapq.nlargest(1, iterable, key=keyfunc)``، سازگار است."

msgid "Added the *default* keyword-only parameter."
msgstr "پارامتر فقط-کلیدواژه‌ی *default* اضافه شد."

msgid "The *key* can be ``None``."
msgstr "*key* می‌تواند ``None`` باشد."

msgid "Return a \"memory view\" object created from the given argument.  See :ref:`typememoryview` for more information."
msgstr "یک شیء «memory view» ایجادشده از آرگومان داده‌شده را برمی‌گرداند. برای اطلاعات بیشتر، به :ref:`typememoryview` مراجعه کنید."

msgid "Return the smallest item in an iterable or the smallest of two or more arguments."
msgstr "کوچک‌ترین عنصر یک پیمایش‌پذیر، یا کوچک‌ترین مقدار از میان دو یا چند آرگومان را برمی‌گرداند."

msgid "If one positional argument is provided, it should be an :term:`iterable`. The smallest item in the iterable is returned.  If two or more positional arguments are provided, the smallest of the positional arguments is returned."
msgstr "اگر یک آرگومان جایگاهی ارائه شود، باید یک :term:`پیمایش‌پذیر <iterable>` باشد. در این صورت، کوچک‌ترین عنصر آن پیمایش‌پذیر برگردانده می‌شود. اگر دو یا چند آرگومان جایگاهی ارائه شوند، کوچک‌ترین آرگومان جایگاهی برگردانده می‌شود."

msgid "If multiple items are minimal, the function returns the first one encountered.  This is consistent with other sort-stability preserving tools such as ``sorted(iterable, key=keyfunc)[0]`` and ``heapq.nsmallest(1, iterable, key=keyfunc)``."
msgstr "اگر چندین عنصر دارای کمترین مقدار باشند، تابع نخستین موردی را که با آن برخورد کند برمی‌گرداند. این رفتار با سایر ابزارهایی که پایداری مرتب‌سازی را حفظ می‌کنند، مانند ``sorted(iterable, key=keyfunc)[0]`` و ``heapq.nsmallest(1, iterable, key=keyfunc)``، سازگار است."

msgid "Retrieve the next item from the :term:`iterator` by calling its :meth:`~iterator.__next__` method.  If *default* is given, it is returned if the iterator is :term:`exhausted`, otherwise :exc:`StopIteration` is raised."
msgstr "آیتم بعدی را از :term:`پیمایش‌گر <iterator>` با فراخوانی متد :meth:`~iterator.__next__` آن دریافت کنید.  اگر *default* داده شده باشد، در صورتی که پیمایش‌گر :term:`به پایان رسیده <exhausted>` باشد، آن برگردانده می‌شود، در غیر این صورت :exc:`StopIteration` تولید می‌شود."

msgid "This is the ultimate base class of all other classes. It has methods that are common to all instances of Python classes. When the constructor is called, it returns a new featureless object. The constructor does not accept any arguments."
msgstr "این، کلاس پایه‌ی نهایی همه‌ی کلاس‌های دیگر است. این کلاس متدهایی را در اختیار دارد که میان تمام نمونه‌های کلاس‌های پایتون مشترک هستند. هنگام فراخوانی سازنده‌ی آن، یک شیء جدید و بدون ویژگی ایجاد می‌شود. این سازنده هیچ آرگومانی را نمی‌پذیرد."

msgid ":class:`object` instances do *not* have :attr:`~object.__dict__` attributes, so you can't assign arbitrary attributes to an instance of :class:`object`."
msgstr "نمونه‌های :class:`object` دارای ویژگی :attr:`~object.__dict__` *نیستند*؛ بنابراین نمی‌توانید ویژگی‌های دلخواهی را به یک نمونه از :class:`object` اختصاص دهید."

msgid "Convert an integer number to an octal string prefixed with \"0o\".  The result is a valid Python expression. If *integer* is not a Python :class:`int` object, it has to define an :meth:`~object.__index__` method that returns an integer. For example:"
msgstr "یک عدد صحیح را به یک رشته‌ی هشت‌هشتی با پیشوند «0o» تبدیل کنید. نتیجه یک عبارت معتبر پایتون است. اگر *integer* یک شیء :class:`int` پایتون نباشد، باید متد :meth:`~object.__index__` را تعریف کند که یک عدد صحیح بازمی‌گرداند. برای مثال:"

msgid "If you want to convert an integer number to an octal string either with the prefix \"0o\" or not, you can use either of the following ways."
msgstr "اگر می‌خواهید یک عدد صحیح را به یک رشته‌ی هشت‌هشتی، با پیشوند «0o» یا بدون آن، تبدیل کنید، می‌توانید از هر یک از روش‌های زیر استفاده کنید."

msgid "Open *file* and return a corresponding :term:`file object`.  If the file cannot be opened, an :exc:`OSError` is raised. See :ref:`tut-files` for more examples of how to use this function."
msgstr "*file* را باز کرده و :term:`شیء پرونده <file object>` متناظر با آن را برمی‌گرداند. اگر پرونده قابل باز شدن نباشد، استثنای :exc:`OSError` پرتاب می‌شود. برای مثال‌های بیشتر درباره‌ی نحوه‌ی استفاده از این تابع، به :ref:`tut-files` مراجعه کنید."

msgid "*file* is a :term:`path-like object` giving the pathname (absolute or relative to the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped.  (If a file descriptor is given, it is closed when the returned I/O object is closed unless *closefd* is set to ``False``.)"
msgstr "*file* یک :term:`شیء شبه‌مسیر <path-like object>` است که مسیر پرونده (مطلق یا نسبی نسبت به پوشه‌ی کاری فعلی) را برای باز شدن مشخص می‌کند، یا یک توصیف‌گر عددی پرونده مربوط به پرونده‌ای است که باید در یک شیء ورودی/خروجی بسته‌بندی شود. (اگر یک توصیف‌گر پرونده ارائه شود، هنگام بسته شدن شیء ورودی/خروجیِ بازگشتی نیز بسته خواهد شد، مگر اینکه *closefd* برابر ``False`` تنظیم شده باشد.)"

msgid "*mode* is an optional string that specifies the mode in which the file is opened.  It defaults to ``'r'`` which means open for reading in text mode. Other common values are ``'w'`` for writing (truncating the file if it already exists), ``'x'`` for exclusive creation, and ``'a'`` for appending (which on *some* Unix systems, means that *all* writes append to the end of the file regardless of the current seek position).  In text mode, if *encoding* is not specified, UTF-8 is used by default; if :ref:`Python UTF-8 Mode <utf8-mode>` is disabled, :func:`locale.getencoding` is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave *encoding* unspecified.)  The available modes are:"
msgstr "*mode* یک رشته‌ی اختیاری است که حالتی که در آن پرونده گشوده می‌شود را مشخص می‌کند. حالت پیش‌فرض آن ``'r'`` است که به معنای گشودن برای خواندن در حالت متنی است. سایر مقادیر رایج عبارتند از ``'w'`` برای نوشتن (که اگر پرونده از قبل وجود داشته باشد، محتوای آن را پاک می‌کند)، ``'x'`` برای ایجاد انحصاری، و ``'a'`` برای الحاق (که در *برخی* سیستم‌های یونیکس، به این معناست که *تمام* عمل نوشتن بدون توجه به موقعیت فعلی مکان‌یاب، به انتهای پرونده الحاق می‌شود). در حالت متنی، اگر *encoding* مشخص نشده باشد، به طور پیش‌فرض از UTF-8 استفاده می‌شود؛ اگر :ref:`حالت UTF-8 پایتون <utf8-mode>` غیرفعال باشد، تابع :func:`locale.getencoding` برای دریافت کدگذاری محلی فعلی فراخوانی می‌شود. (برای خواندن و نوشتن بایت‌های خام، از حالت دودویی استفاده کنید و *encoding* را مشخص نکنید.) حالت‌های موجود عبارتند از:"

msgid "Character"
msgstr "نویسه"

msgid "Meaning"
msgstr "معنی"

msgid "``'r'``"
msgstr "``'r'``"

msgid "open for reading (default)"
msgstr "باز کردن برای خواندن (پیش‌فرض)"

msgid "``'w'``"
msgstr "``'w'``"

msgid "open for writing, truncating the file first"
msgstr "باز کردن برای نوشتن؛ ابتدا محتوای پرونده حذف می‌شود."

msgid "``'x'``"
msgstr "``'x'``"

msgid "open for exclusive creation, failing if the file already exists"
msgstr "باز کردن برای ایجاد انحصاری؛ در صورتی که پرونده از قبل وجود داشته باشد، عملیات شکست می‌خورد"

msgid "``'a'``"
msgstr "``'a'``"

msgid "open for writing, appending to the end of file if it exists"
msgstr "باز کردن برای نوشتن؛ اگر پرونده وجود داشته باشد، داده‌ها به انتهای آن افزوده می‌شوند"

msgid "``'b'``"
msgstr "``'b'``"

msgid "binary mode"
msgstr "حالت دودویی"

msgid "``'t'``"
msgstr "``'t'``"

msgid "text mode (default)"
msgstr "حالت متن (پیشفرض)"

msgid "``'+'``"
msgstr "``'+'``"

msgid "open for updating (reading and writing)"
msgstr "باز کردن برای به‌روزرسانی (خواندن و نوشتن)"

msgid "The default mode is ``'r'`` (open for reading text, a synonym of ``'rt'``). Modes ``'w+'`` and ``'w+b'`` open and truncate the file.  Modes ``'r+'`` and ``'r+b'`` open the file with no truncation."
msgstr "حالت پیش‌فرض ``'r'`` است (باز کردن پرونده برای خواندن متن، که معادل ``'rt'`` است). حالت‌های ``'w+'`` و ``'w+b'`` پرونده را باز کرده و محتوای آن را حذف می‌کنند. حالت‌های ``'r+'`` و ``'r+b'`` پرونده را بدون حذف محتوا باز می‌کنند."

msgid "As mentioned in the :ref:`io-overview`, Python distinguishes between binary and text I/O.  Files opened in binary mode (including ``'b'`` in the *mode* argument) return contents as :class:`bytes` objects without any decoding.  In text mode (the default, or when ``'t'`` is included in the *mode* argument), the contents of the file are returned as :class:`str`, the bytes having been first decoded using the default encoding or using the specified *encoding* if given."
msgstr "همان‌طور که در :ref:`io-overview` ذکر شد، پایتون بین ورودی/خروجی دودویی و متنی تمایز قائل می‌شود. پرونده‌هایی که در حالت دودویی گشوده می‌شوند (شامل ``'b'`` در آرگومان *mode*) محتویات را به شکل شیءهای :class:`bytes` و بدون هیچ‌گونه کدگشایی برمی‌گردانند. در حالت متنی (حالت پیش‌فرض، یا زمانی که ``'t'`` در آرگومان *mode* گنجانده شده باشد)، محتویات پرونده به شکل :class:`str` برگردانده می‌شوند، در حالی که بایت‌ها ابتدا با استفاده از کدگذاری پیش‌فرض یا در صورت ارائه‌ شدن، با استفاده از *encoding* مشخص‌شده کدگشایی شده‌اند."

msgid "Python doesn't depend on the underlying operating system's notion of text files; all the processing is done by Python itself, and is therefore platform-independent."
msgstr "پایتون به مفهوم پرونده‌ی متنی در سیستم‌عامل زیربنایی وابسته نیست؛ تمام پردازش‌ها توسط خود پایتون انجام می‌شوند و بنابراین مستقل از سکو هستند."

msgid "*buffering* is an optional integer used to set the buffering policy.  Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable when writing in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but ``TextIOWrapper`` (i.e., files opened with ``mode='r+'``) would have another buffering. To disable buffering in ``TextIOWrapper``, consider using the ``write_through`` flag for :func:`io.TextIOWrapper.reconfigure`. When no *buffering* argument is given, the default buffering policy works as follows:"
msgstr "آرگومان *buffering* یک عدد صحیح اختیاری است که برای تعیین سیاست بافرگذاری استفاده می‌شود. برای غیرفعال کردن بافرگذاری مقدار 0 را وارد کنید (که فقط در حالت دودویی مجاز است)، برای انتخاب بافرگذاری سطری مقدار 1 را وارد کنید (که فقط هنگام نوشتن در حالت متنی قابل استفاده است)، و یک عدد صحیح بزرگ‌تر از 1 را برای تعیین اندازه‌ی یک بافر با اندازه‌ی ثابت (بر حسب بایت) مشخص کنید. توجه داشته باشید که تعیین اندازه‌ی بافر به این روش فقط برای ورودی/خروجی دودوییِ بافرشده اعمال می‌شود، اما ``TextIOWrapper`` (یعنی پرونده‌هایی که با ``mode='r+'`` باز می‌شوند) از بافرگذاری دیگری استفاده می‌کند. برای غیرفعال کردن بافرگذاری در ``TextIOWrapper``، استفاده از پرچم ``write_through`` برای :func:`io.TextIOWrapper.reconfigure` را در نظر بگیرید. اگر آرگومان *buffering* مشخص نشود، سیاست پیش‌فرض بافرگذاری به صورت زیر عمل می‌کند:"

msgid "Binary files are buffered in fixed-size chunks; the size of the buffer is ``max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)`` when the device block size is available. On most systems, the buffer will typically be 128 kilobytes long."
msgstr "پرونده‌های دودویی در قطعه‌هایی با اندازه‌ی ثابت بافر می‌شوند؛ اگر اندازه‌ی بلوک دستگاه در دسترس باشد، اندازه‌ی بافر برابر با ``max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)`` خواهد بود. در بیشتر سیستم‌ها، اندازه‌ی بافر معمولاً ۱۲۸ کیلوبایت است."

msgid "\"Interactive\" text files (files for which :meth:`~io.IOBase.isatty` returns ``True``) use line buffering.  Other text files use the policy described above for binary files."
msgstr "پرونده‌های متنی «تعاملی» (پرونده‌هایی که :meth:`~io.IOBase.isatty` برای آن‌ها مقدار ``True`` برمی‌گرداند) از بافرگذاری سطری استفاده می‌کنند. سایر پرونده‌های متنی از سیاستی که در بالا برای پرونده‌های دودویی توضیح داده شده است، پیروی می‌کنند."

msgid "*encoding* is the name of the encoding used to decode or encode the file. This should only be used in text mode.  The default encoding is UTF-8; if :ref:`Python UTF-8 Mode <utf8-mode>` is disabled, the default is platform-dependent (whatever :func:`locale.getencoding` returns). Any :term:`text encoding` supported by Python can be used, and ``encoding=\"locale\"`` specifies the current locale encoding explicitly. See the :mod:`codecs` module for the list of supported encodings."
msgstr "*encoding* نام کدگذاری‌ای است که برای کدگشایی یا کدگذاری پرونده استفاده می‌شود. این پارامتر فقط باید در حالت متنی استفاده شود. کدگذاری پیش‌فرض UTF-8 است؛ اگر :ref:`حالت UTF-8 پایتون <utf8-mode>` غیرفعال باشد، مقدار پیش‌فرض به پلتفرم بستگی دارد (هر چیزی که :func:`locale.getencoding` برگرداند). هر :term:`کدگذاری متن <text encoding>` که توسط پایتون پشتیبانی شود قابل استفاده است و مقدار ``encoding=\"locale\"`` کدگذاری محلی فعلی را به طور صریح مشخص می‌کند. برای فهرست کدگذاری‌های پشتیبانی‌شده، به ماژول :mod:`codecs` مراجعه کنید."

msgid "*errors* is an optional string that specifies how encoding and decoding errors are to be handled—this cannot be used in binary mode. A variety of standard error handlers are available, though any error handling name that has been registered with :func:`codecs.register_error` is also valid.  The standard names can be found in :ref:`error-handlers`."
msgstr "*errors* یک رشته‌ی اختیاری است که مشخص می‌کند خطاهای کدگذاری و کدگشایی چگونه باید مدیریت شوند — این پارامتر را نمی‌توان در حالت دودویی استفاده کرد. مجموعه‌ای متنوع از هندلرهای خطای استاندارد در دسترس هستند، البته هر نام مدیریت خطایی که در :func:`codecs.register_error` ثبت شده باشد نیز معتبر است. نام‌های استاندارد را می‌توانید در :ref:`error-handlers` بیابید."

msgid "*newline* determines how to parse newline characters from the stream. It can be ``None``, ``''``, ``'\\n'``, ``'\\r'``, and ``'\\r\\n'``.  It works as follows:"
msgstr "*newline* مشخص می‌کند که نویسه‌های پایان خط در جریان داده چگونه تجزیه شوند. این مقدار می‌تواند ``None``، ``''``، ``'\\n'``، ``'\\r'`` یا ``'\\r\\n'`` باشد. عملکرد آن به صورت زیر است:"

msgid "When reading input from the stream, if *newline* is ``None``, universal newlines mode is enabled.  Lines in the input can end in ``'\\n'``, ``'\\r'``, or ``'\\r\\n'``, and these are translated into ``'\\n'`` before being returned to the caller.  If it is ``''``, universal newlines mode is enabled, but line endings are returned to the caller untranslated.  If it has any of the other legal values, input lines are only terminated by the given string, and the line ending is returned to the caller untranslated."
msgstr "هنگام خواندن ورودی از جریان، اگر *newline* برابر ``None`` باشد، حالت پایان‌سطرهای همگانی فعال می‌شود. در این حالت، سطرهای ورودی می‌توانند با ``'\\n'``، ``'\\r'`` یا ``'\\r\\n'`` پایان یابند و پیش از بازگردانده شدن به فراخواننده، همگی به ``'\\n'`` تبدیل می‌شوند. اگر مقدار آن ``''`` باشد، حالت پایان‌سطرهای همگانی همچنان فعال است، اما نویسه‌های پایان خط بدون تبدیل به فراخواننده بازگردانده می‌شوند. اگر *newline* یکی از مقادیر مجاز دیگر را داشته باشد، سطرهای ورودی فقط با همان رشته خاتمه می‌یابند و نویسه‌ی پایان خط بدون تبدیل بازگردانده می‌شود."

msgid "When writing output to the stream, if *newline* is ``None``, any ``'\\n'`` characters written are translated to the system default line separator, :data:`os.linesep`.  If *newline* is ``''`` or ``'\\n'``, no translation takes place.  If *newline* is any of the other legal values, any ``'\\n'`` characters written are translated to the given string."
msgstr "هنگام نوشتن خروجی در جریان، اگر *newline* برابر ``None`` باشد، هر نویسه‌ی ``'\\n'`` نوشته‌شده به جداکننده‌ی پیش‌فرض پایان خط سیستم، یعنی :data:`os.linesep`، تبدیل می‌شود. اگر *newline* برابر ``''`` یا ``'\\n'`` باشد، هیچ تبدیلی انجام نمی‌شود. اگر *newline* یکی از مقادیر مجاز دیگر را داشته باشد، هر ``'\\n'`` نوشته‌شده به همان رشته‌ی مشخص‌شده تبدیل خواهد شد."

msgid "If *closefd* is ``False`` and a file descriptor rather than a filename was given, the underlying file descriptor will be kept open when the file is closed.  If a filename is given *closefd* must be ``True`` (the default); otherwise, an error will be raised."
msgstr "اگر *closefd* برابر ``False`` باشد و به‌جای نام پرونده یک توصیف‌گر پرونده ارائه شده باشد، هنگام بسته شدن پرونده، توصیف‌گر پرونده‌ی زیربنایی باز خواهد ماند. اگر نام پرونده ارائه شود، *closefd* باید برابر ``True`` (مقدار پیش‌فرض) باشد؛ در غیر این صورت، خطا پرتاب خواهد شد."

msgid "A custom opener can be used by passing a callable as *opener*. The underlying file descriptor for the file object is then obtained by calling *opener* with (*file*, *flags*). *opener* must return an open file descriptor (passing :mod:`os.open` as *opener* results in functionality similar to passing ``None``)."
msgstr "با ارسال یک شیء فراخوانی‌پذیر به‌عنوان *opener* می‌توان از یک بازکننده‌ی سفارشی استفاده کرد. در این صورت، توصیف‌گر پرونده‌ی زیربناییِ شیء پرونده با فراخوانی *opener* و ارسال (*file*, *flags*) به آن به‌دست می‌آید. *opener* باید یک توصیف‌گر پرونده‌ی باز برگرداند (ارسال :mod:`os.open` به‌عنوان *opener* رفتاری مشابه ارسال ``None`` خواهد داشت)."

msgid "The newly created file is :ref:`non-inheritable <fd_inheritance>`."
msgstr "پرونده‌ی تازه ایجادشده :ref:`غیرقابل‌وراثت <fd_inheritance>` است."

msgid "The following example uses the :ref:`dir_fd <dir_fd>` parameter of the :func:`os.open` function to open a file relative to a given directory::"
msgstr "مثال زیر از پارامتر :ref:`dir_fd <dir_fd>` تابع :func:`os.open` برای باز کردن پرونده‌ای نسبت به یک پوشه مشخص استفاده می‌کند::"

msgid ""
">>> import os\n"
">>> dir_fd = os.open('somedir', os.O_RDONLY)\n"
">>> def opener(path, flags):\n"
"...     return os.open(path, flags, dir_fd=dir_fd)\n"
"...\n"
">>> with open('spamspam.txt', 'w', opener=opener) as f:\n"
"...     print('This will be written to somedir/spamspam.txt', file=f)\n"
"...\n"
">>> os.close(dir_fd)  # don't leak a file descriptor"
msgstr ""
">>> import os\n"
">>> dir_fd = os.open('somedir', os.O_RDONLY)\n"
">>> def opener(path, flags):\n"
"...     return os.open(path, flags, dir_fd=dir_fd)\n"
"...\n"
">>> with open('spamspam.txt', 'w', opener=opener) as f:\n"
"...     print('This will be written to somedir/spamspam.txt', file=f)\n"
"...\n"
">>> os.close(dir_fd)  # don't leak a file descriptor"

msgid "The type of :term:`file object` returned by the :func:`open` function depends on the mode.  When :func:`open` is used to open a file in a text mode (``'w'``, ``'r'``, ``'wt'``, ``'rt'``, etc.), it returns a subclass of :class:`io.TextIOBase` (specifically :class:`io.TextIOWrapper`).  When used to open a file in a binary mode with buffering, the returned class is a subclass of :class:`io.BufferedIOBase`.  The exact class varies: in read binary mode, it returns an :class:`io.BufferedReader`; in write binary and append binary modes, it returns an :class:`io.BufferedWriter`, and in read/write mode, it returns an :class:`io.BufferedRandom`.  When buffering is disabled, the raw stream, a subclass of :class:`io.RawIOBase`, :class:`io.FileIO`, is returned."
msgstr "نوع :term:`شیء پرونده <file object>` بازگردانده‌شده توسط تابع :func:`open` به حالت بستگی دارد. هنگامی که :func:`open` برای باز کردن پرونده در حالت متنی (مانند ``'w'``، ``'r'``، ``'wt'``، ``'rt'`` و غیره) استفاده شود، زیرکلاسی از :class:`io.TextIOBase` (به‌طور مشخص :class:`io.TextIOWrapper`) را بازمی‌گرداند. هنگام باز کردن پرونده در حالت دودویی همراه با بافر، کلاس بازگردانده‌شده زیرکلاسی از :class:`io.BufferedIOBase` خواهد بود. کلاس دقیق بسته به حالت متفاوت است: در حالت خواندن دودویی، :class:`io.BufferedReader`؛ در حالت‌های نوشتن دودویی و افزودن به انتهای پرونده، :class:`io.BufferedWriter`؛ و در حالت خواندن/نوشتن، :class:`io.BufferedRandom` بازگردانده می‌شود. اگر بافر غیرفعال باشد، جریان خام (raw stream)، یعنی :class:`io.FileIO` که زیرکلاسی از :class:`io.RawIOBase` است، بازگردانده می‌شود."

msgid "See also the file handling modules, such as :mod:`fileinput`, :mod:`io` (where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:`tempfile`, and :mod:`shutil`."
msgstr "همچنین به ماژول‌های مربوط به کار با پرونده‌ها، مانند :mod:`fileinput`، :mod:`io` (که :func:`open` در آن تعریف شده است)، :mod:`os`، :mod:`os.path`، :mod:`tempfile` و :mod:`shutil` مراجعه کنید."

msgid "Raises an :ref:`auditing event <auditing>` ``open`` with arguments ``path``, ``mode``, ``flags``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` با نام ``open`` و آرگومان‌های ``path``، ``mode`` و ``flags`` پرتاب می‌کند."

msgid "The ``mode`` and ``flags`` arguments may have been modified or inferred from the original call."
msgstr "آرگومان‌های ``mode`` و ``flags`` ممکن است بر اساس فراخوانی اولیه تغییر داده شده یا مقدار آن‌ها استنباط شده باشند."

msgid "The *opener* parameter was added."
msgstr "پارامتر *opener* اضافه شده است."

msgid "The ``'x'`` mode was added."
msgstr "حالت ``'x'`` اضافه شده است."

msgid ":exc:`IOError` used to be raised, it is now an alias of :exc:`OSError`."
msgstr "در گذشته استثنای :exc:`IOError` پرتاب می‌شد؛ اکنون این استثنا نام مستعاری برای :exc:`OSError` است."

msgid ":exc:`FileExistsError` is now raised if the file opened in exclusive creation mode (``'x'``) already exists."
msgstr "اگر پرونده‌ای که در حالت ایجاد انحصاری (``'x'``) باز می‌شود از قبل وجود داشته باشد، اکنون استثنای :exc:`FileExistsError` پرتاب می‌شود."

msgid "The file is now non-inheritable."
msgstr "اکنون این پرونده غیرقابل‌وراثت است."

msgid "If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an :exc:`InterruptedError` exception (see :pep:`475` for the rationale)."
msgstr "اگر فراخوانی سیستمی متوقف شود و هندلر سیگنال استثنایی پرتاب نکند، اکنون این تابع به‌جای پرتاب استثنای :exc:`InterruptedError`، فراخوانی سیستمی را دوباره امتحان می‌کند (برای دلیل این تغییر، :pep:`475` را ببینید)."

msgid "The ``'namereplace'`` error handler was added."
msgstr "هندلر خطای ``'namereplace'`` اضافه شده است."

msgid "Support added to accept objects implementing :class:`os.PathLike`."
msgstr "پشتیبانی از پذیرش اشیایی که :class:`os.PathLike` را پیاده‌سازی می‌کنند، اضافه شده است."

msgid "On Windows, opening a console buffer may return a subclass of :class:`io.RawIOBase` other than :class:`io.FileIO`."
msgstr "در ویندوز، باز کردن یک بافر کنسول ممکن است زیرکلاسی از :class:`io.RawIOBase` غیر از :class:`io.FileIO` را برگرداند."

msgid "The ``'U'`` mode has been removed."
msgstr "حالت ``'U'`` حذف شده است."

msgid "UTF-8 is now the default encoding, instead of the platform-dependent locale encoding (:pep:`686`)."
msgstr "اکنون UTF-8 کدگذاری پیش‌فرض است و جایگزین کدگذاری locale وابسته به پلتفرم شده است (:pep:`686`)."

msgid "Return the ordinal value of a character."
msgstr "مقدار ترتیبی یک نویسه را برمی‌گرداند."

msgid "If the argument is a one-character string, return the Unicode code point of that character.  For example, ``ord('a')`` returns the integer ``97`` and ``ord('€')`` (Euro sign) returns ``8364``.  This is the inverse of :func:`chr`."
msgstr "اگر آرگومان یک رشته‌ی تک‌نویسه‌ای باشد، نقطه‌ی کد یونیکد آن نویسه برگردانده می‌شود. برای مثال، ``ord('a')`` عدد صحیح ``97`` و ``ord('€')`` (نماد یورو) عدد ``8364`` را برمی‌گرداند. این تابع معکوس :func:`chr` است."

msgid "If the argument is a :class:`bytes` or :class:`bytearray` object of length 1, return its single byte value. For example, ``ord(b'a')`` returns the integer ``97``."
msgstr "اگر آرگومان یک شیء :class:`bytes` یا :class:`bytearray` با طول ۱ باشد، مقدار تنها بایت آن برگردانده می‌شود. برای مثال، ``ord(b'a')`` عدد صحیح ``97`` را برمی‌گرداند."

msgid "Return *base* to the power *exp*; if *mod* is present, return *base* to the power *exp*, modulo *mod* (computed more efficiently than ``pow(base, exp) % mod``). The two-argument form ``pow(base, exp)`` is equivalent to using the power operator: ``base**exp``."
msgstr "*base* را به توان *exp* می‌رساند؛ اگر *mod* مشخص شده باشد، مقدار *base* به توان *exp* را به پیمانه‌ی *mod* برمی‌گرداند (که کارآمدتر از ``pow(base, exp) % mod`` محاسبه می‌شود). شکل دوآرگومانی ``pow(base, exp)`` معادل استفاده از عملگر توان، یعنی ``base**exp``، است."

msgid "When arguments are builtin numeric types with mixed operand types, the coercion rules for binary arithmetic operators apply.  For :class:`int` operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered.  For example, ``pow(10, 2)`` returns ``100``, but ``pow(10, -2)`` returns ``0.01``.  For a negative base of type :class:`int` or :class:`float` and a non-integral exponent, a complex result is delivered.  For example, ``pow(-9, 0.5)`` returns a value close to ``3j``. Whereas, for a negative base of type :class:`int` or :class:`float` with an integral exponent, a float result is delivered. For example, ``pow(-9, 2.0)`` returns ``81.0``."
msgstr "وقتی آرگومان‌ها از انواع عددی توکار با انواع عملوند متفاوت باشند، قواعد تبدیل (coercion) عملگرهای حسابی دودویی اعمال می‌شود. برای عملوندهای :class:`int`، نتیجه پس از اعمال تبدیل، همان نوع عملوندها را خواهد داشت؛ مگر اینکه آرگومان دوم منفی باشد که در این صورت همه‌ی آرگومان‌ها به float تبدیل شده و نتیجه نیز از نوع float خواهد بود. برای مثال، ``pow(10, 2)`` مقدار ``100`` را برمی‌گرداند، اما ``pow(10, -2)`` مقدار ``0.01`` را بازمی‌گرداند. اگر پایه‌ی منفی از نوع :class:`int` یا :class:`float` باشد و توان عددی غیرصحیح باشد، نتیجه از نوع مختلط خواهد بود. برای مثال، ``pow(-9, 0.5)`` مقداری نزدیک به ``3j`` را برمی‌گرداند. در مقابل، اگر پایه‌ی منفی از نوع :class:`int` یا :class:`float` باشد و توان عددی صحیح باشد، نتیجه از نوع float خواهد بود. برای مثال، ``pow(-9, 2.0)`` مقدار ``81.0`` را برمی‌گرداند."

msgid "For :class:`int` operands *base* and *exp*, if *mod* is present, *mod* must also be of integer type and *mod* must be nonzero. If *mod* is present and *exp* is negative, *base* must be relatively prime to *mod*. In that case, ``pow(inv_base, -exp, mod)`` is returned, where *inv_base* is an inverse to *base* modulo *mod*."
msgstr "برای عملوندهای :class:`int` یعنی *base* و *exp*، اگر *mod* ارائه شود، باید از نوع عدد صحیح باشد و مقدار آن نیز نباید صفر باشد. اگر *mod* ارائه شده باشد و *exp* منفی باشد، *base* و *mod* باید نسبت به هم اول باشند. در این حالت، ``pow(inv_base, -exp, mod)`` برگردانده می‌شود که در آن *inv_base* وارونِ *base* به پیمانه‌ی *mod* است."

msgid "Here's an example of computing an inverse for ``38`` modulo ``97``::"
msgstr "در اینجا مثالی از محاسبه‌ی وارون پیمانه‌ایِ ``38`` به پیمانه‌ی ``97`` آورده شده است::"

msgid ""
">>> pow(38, -1, mod=97)\n"
"23\n"
">>> 23 * 38 % 97 == 1\n"
"True"
msgstr ""
">>> pow(38, -1, mod=97)\n"
"23\n"
">>> 23 * 38 % 97 == 1\n"
"True"

msgid "For :class:`int` operands, the three-argument form of ``pow`` now allows the second argument to be negative, permitting computation of modular inverses."
msgstr "برای عملوندهای :class:`int`، شکل سه‌آرگومانی ``pow`` اکنون اجازه می‌دهد آرگومان دوم منفی باشد و در نتیجه امکان محاسبه‌ی وارون پیمانه‌ای را فراهم می‌کند."

msgid "Allow keyword arguments.  Formerly, only positional arguments were supported."
msgstr "امکان استفاده از آرگومان‌های کلیدواژه‌ای اضافه شد. پیش از این، فقط آرگومان‌های جایگاهی پشتیبانی می‌شدند."

msgid "Print *objects* to the text stream *file*, separated by *sep* and followed by *end*.  *sep*, *end*, *file*, and *flush*, if present, must be given as keyword arguments."
msgstr "*objects* را با جداکننده‌ی *sep* و در انتها با *end* در جریان متنی *file* چاپ می‌کند. اگر *sep*، *end*، *file* یا *flush* مشخص شوند، باید به‌صورت آرگومان‌های کلیدواژه‌ای ارائه شوند."

msgid "All non-keyword arguments are converted to strings like :func:`str` does and written to the stream, separated by *sep* and followed by *end*.  Both *sep* and *end* must be strings; they can also be ``None``, which means to use the default values.  If no *objects* are given, :func:`print` will just write *end*."
msgstr "همه‌ی آرگومان‌های غیرکلیدواژه‌ای، همانند :func:`str`، به رشته تبدیل شده و با جداکننده‌ی *sep* از یکدیگر جدا شده و سپس همراه با *end* در جریان  نوشته می‌شوند. هر دو مقدار *sep* و *end* باید رشته باشند؛ همچنین می‌توانند ``None`` باشند که در این صورت از مقادیر پیش‌فرض استفاده می‌شود. اگر هیچ *objects*\\ ی ارائه نشود، :func:`print` فقط مقدار *end* را خواهد نوشت."

msgid "The *file* argument must be an object with a ``write(string)`` method; if it is not present or ``None``, :data:`sys.stdout` will be used.  Since printed arguments are converted to text strings, :func:`print` cannot be used with binary mode file objects.  For these, use ``file.write(...)`` instead."
msgstr "آرگومان *file* باید شی‌ءای باشد که متد ``write(string)`` را داشته باشد؛ اگر این آرگومان ارائه نشود یا ``None`` باشد، از :data:`sys.stdout` استفاده خواهد شد. از آنجا که آرگومان‌های چاپ‌شده به رشته‌ی متنی تبدیل می‌شوند، :func:`print` را نمی‌توان با اشیای پرونده در حالت دودویی استفاده کرد. برای چنین مواردی، به‌جای آن از ``file.write(...)`` استفاده کنید."

msgid "Output buffering is usually determined by *file*. However, if *flush* is true, the stream is forcibly flushed."
msgstr "بافرگذاری خروجی معمولاً توسط *file* تعیین می‌شود. با این حال، اگر *flush* برابر True باشد، جریان داده به‌اجبار تخلیه می‌شود."

msgid "Added the *flush* keyword argument."
msgstr "آرگومان کلیدواژه‌ای *flush* اضافه شد."

msgid "Return a property attribute."
msgstr "یک ویژگی از نوع property را برمی‌گرداند."

msgid "*fget* is a function for getting an attribute value.  *fset* is a function for setting an attribute value. *fdel* is a function for deleting an attribute value.  And *doc* creates a docstring for the attribute."
msgstr "*fget* تابعی برای دریافت مقدار یک ویژگی است. *fset* تابعی برای تنظیم مقدار یک ویژگی است. *fdel* تابعی برای حذف مقدار یک ویژگی است. همچنین *doc* یک رشته‌ی مستندات برای آن ویژگی ایجاد می‌کند."

msgid "A typical use is to define a managed attribute ``x``::"
msgstr "یک کاربرد رایج، تعریف ویژگی مدیریت‌شده‌ی ``x`` به‌صورت زیر است::"

msgid ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    def getx(self):\n"
"        return self._x\n"
"\n"
"    def setx(self, value):\n"
"        self._x = value\n"
"\n"
"    def delx(self):\n"
"        del self._x\n"
"\n"
"    x = property(getx, setx, delx, \"I'm the 'x' property.\")"
msgstr ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    def getx(self):\n"
"        return self._x\n"
"\n"
"    def setx(self, value):\n"
"        self._x = value\n"
"\n"
"    def delx(self):\n"
"        del self._x\n"
"\n"
"    x = property(getx, setx, delx, \"I'm the 'x' property.\")"

msgid "If *c* is an instance of *C*, ``c.x`` will invoke the getter, ``c.x = value`` will invoke the setter, and ``del c.x`` the deleter."
msgstr "اگر *c* نمونه‌ای از *C* باشد، عبارت ``c.x`` فراخوانی‌کننده‌ی getter، عبارت ``c.x = value`` فراخوانی‌کننده‌ی setter، و عبارت ``del c.x`` فراخوانی‌کننده‌ی deleter خواهد بود."

msgid "If given, *doc* will be the docstring of the property attribute. Otherwise, the property will copy *fget*'s docstring (if it exists).  This makes it possible to create read-only properties easily using :deco:`property` as a :term:`decorator`::"
msgstr "اگر *doc* مشخص شده باشد، به‌عنوان docstring ویژگی property استفاده خواهد شد. در غیر این صورت، property، docstring مربوط به *fget* را (در صورت وجود) کپی می‌کند. این امکان را فراهم می‌کند که با استفاده از :deco:`property` به‌عنوان یک :term:`دکوراتور <decorator>`، به‌سادگی ویژگی‌های فقط‌خواندنی ایجاد شوند::"

msgid ""
"class Parrot:\n"
"    def __init__(self):\n"
"        self._voltage = 100000\n"
"\n"
"    @property\n"
"    def voltage(self):\n"
"        \"\"\"Get the current voltage.\"\"\"\n"
"        return self._voltage"
msgstr ""
"class Parrot:\n"
"    def __init__(self):\n"
"        self._voltage = 100000\n"
"\n"
"    @property\n"
"    def voltage(self):\n"
"        \"\"\"Get the current voltage.\"\"\"\n"
"        return self._voltage"

msgid "The ``@property`` decorator turns the :meth:`!voltage` method into a \"getter\" for a read-only attribute with the same name, and it sets the docstring for *voltage* to \"Get the current voltage.\""
msgstr "دکوراتور‌ی ``@property`` متد :meth:`!voltage` را به یک «getter» برای ویژگی فقط‌خواندنی‌ای با همان نام تبدیل می‌کند و docstring ویژگی *voltage* را روی «Get the current voltage.» تنظیم می‌کند."

msgid "A property object has ``getter``, ``setter``, and ``deleter`` methods usable as decorators that create a copy of the property with the corresponding accessor function set to the decorated function.  This is best explained with an example:"
msgstr "یک شیء property دارای متدهای ``getter``، ``setter`` و ``deleter`` است که می‌توان از آن‌ها به‌عنوان دکوراتور استفاده کرد. این متدها نسخه‌ای از property را ایجاد می‌کنند که تابع دسترسی متناظر آن با تابع دکوراتورشده جایگزین شده است. این موضوع با یک مثال بهتر توضیح داده می‌شود:"

msgid ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    @property\n"
"    def x(self):\n"
"        \"\"\"I'm the 'x' property.\"\"\"\n"
"        return self._x\n"
"\n"
"    @x.setter\n"
"    def x(self, value):\n"
"        self._x = value\n"
"\n"
"    @x.deleter\n"
"    def x(self):\n"
"        del self._x"
msgstr ""
"class C:\n"
"    def __init__(self):\n"
"        self._x = None\n"
"\n"
"    @property\n"
"    def x(self):\n"
"        \"\"\"I'm the 'x' property.\"\"\"\n"
"        return self._x\n"
"\n"
"    @x.setter\n"
"    def x(self, value):\n"
"        self._x = value\n"
"\n"
"    @x.deleter\n"
"    def x(self):\n"
"        del self._x"

msgid "This code is exactly equivalent to the first example.  Be sure to give the additional functions the same name as the original property (``x`` in this case.)"
msgstr "این کد دقیقاً معادل مثال اول است. دقت کنید که توابع اضافی نیز همان نام property اصلی (در این مثال ``x``) را داشته باشند."

msgid "The returned property object also has the attributes ``fget``, ``fset``, and ``fdel`` corresponding to the constructor arguments."
msgstr "شیء property بازگردانده‌شده همچنین دارای ویژگی‌های ``fget``، ``fset`` و ``fdel`` متناظر با آرگومان‌های سازنده است."

msgid "The docstrings of property objects are now writeable."
msgstr "اکنون docstring اشیای property قابل‌ویرایش است."

msgid "Attribute holding the name of the property. The name of the property can be changed at runtime."
msgstr "ویژگی‌ای که نام property را نگه می‌دارد. نام property را می‌توان در زمان اجرا تغییر داد."

msgid "Rather than being a function, :class:`range` is actually an immutable sequence type, as documented in :ref:`typesseq-range` and :ref:`typesseq`."
msgstr ":class:`range` در واقع یک نوع دنباله‌ی تغییرناپذیر است، نه یک تابع؛ همان‌گونه که در :ref:`typesseq-range` و :ref:`typesseq` مستند شده است."

msgid "Return a string containing a printable representation of an object.  For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to :func:`eval`; otherwise, the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object.  A class can control what this function returns for its instances by defining a :meth:`~object.__repr__` method. If :func:`sys.displayhook` is not accessible, this function will raise :exc:`RuntimeError`."
msgstr "رشته‌ای را برمی‌گرداند که نمایش قابل چاپی از یک شیء را در بر دارد. برای بسیاری از نوع‌ها، این تابع تلاش می‌کند رشته‌ای برگرداند که اگر به :func:`eval` داده شود، شی‌ءای با همان مقدار تولید کند؛ در غیر این صورت، نمایش به‌صورت رشته‌ای درون کروشه‌های زاویه‌دار خواهد بود که نام نوع شیء و اطلاعات اضافی، که معمولاً شامل نام و نشانی شیء است، در آن قرار دارد. یک کلاس می‌تواند با تعریف متد :meth:`~object.__repr__` مشخص کند که این تابع برای نمونه‌های آن چه مقداری برگرداند. اگر :func:`sys.displayhook` در دسترس نباشد، این تابع استثنای :exc:`RuntimeError` پرتاب می‌کند."

msgid "This class has a custom representation that can be evaluated::"
msgstr "این کلاس یک نمایش (representation) سفارشی دارد که قابل ارزیابی است::"

msgid ""
"class Person:\n"
"   def __init__(self, name, age):\n"
"      self.name = name\n"
"      self.age = age\n"
"\n"
"   def __repr__(self):\n"
"      return f\"Person({self.name!r}, {self.age!r})\""
msgstr ""
"class Person:\n"
"   def __init__(self, name, age):\n"
"      self.name = name\n"
"      self.age = age\n"
"\n"
"   def __repr__(self):\n"
"      return f\"Person({self.name!r}, {self.age!r})\""

msgid "Return a reverse :term:`iterator`.  The argument must be an object which has a :meth:`~object.__reversed__` method or supports the sequence protocol (the :meth:`~object.__len__` method and the :meth:`~object.__getitem__` method with integer arguments starting at ``0``)."
msgstr "یک :term:`پیمایش‌گر <iterator>` معکوس را برمی‌گرداند. آرگومان باید شی‌ءای باشد که متد :meth:`~object.__reversed__` را داشته باشد یا از پروتکل دنباله (متد :meth:`~object.__len__` و متد :meth:`~object.__getitem__` با آرگومان‌های صحیح که از ``0`` شروع می‌شوند) پشتیبانی کند."

msgid "Return *number* rounded to *ndigits* precision after the decimal point.  If *ndigits* is omitted or is ``None``, it returns the nearest integer to its input."
msgstr "*number* را با دقت *ndigits* رقم پس از ممیز گرد می‌کند. اگر *ndigits* حذف شده باشد یا برابر ``None`` باشد، نزدیک‌ترین عدد صحیح به ورودی را برمی‌گرداند."

msgid "For the built-in types supporting :func:`round`, values are rounded to the closest multiple of 10 to the power minus *ndigits*; if two multiples are equally close, rounding is done toward the even choice (so, for example, both ``round(0.5)`` and ``round(-0.5)`` are ``0``, and ``round(1.5)`` is ``2``).  Any integer value is valid for *ndigits* (positive, zero, or negative).  The return value is an integer if *ndigits* is omitted or ``None``. Otherwise, the return value has the same type as *number*."
msgstr "برای انواع توکاری که از :func:`round` پشتیبانی می‌کنند، مقادیر به نزدیک‌ترین مضرب 10 به توان منفی *ndigits* گرد می‌شوند. اگر دو مضرب به یک اندازه نزدیک باشند، گرد کردن به سمت مقدار زوج انجام می‌شود (برای مثال، هر دو عبارت ``round(0.5)`` و ``round(-0.5)`` برابر ``0`` هستند و ``round(1.5)`` برابر ``2`` است). هر مقدار صحیحی (مثبت، صفر یا منفی) برای *ndigits* معتبر است. اگر *ndigits* حذف شود یا ``None`` باشد، مقدار بازگشتی یک عدد صحیح خواهد بود. در غیر این صورت، مقدار بازگشتی همان نوع *number* را خواهد داشت."

msgid "For a general Python object ``number``, ``round`` delegates to ``number.__round__``."
msgstr "برای یک شیء عمومی پایتون به نام ``number``، تابع ``round`` فراخوانی را به ``number.__round__`` واگذار می‌کند."

msgid "The behavior of :func:`round` for floats can be surprising: for example, ``round(2.675, 2)`` gives ``2.67`` instead of the expected ``2.68``. This is not a bug: it's a result of the fact that most decimal fractions can't be represented exactly as a float.  See :ref:`tut-fp-issues` for more information."
msgstr "رفتار :func:`round` برای اعداد ممیز شناور ممکن است غافلگیرکننده باشد؛ برای مثال، ``round(2.675, 2)`` به‌جای ``2.68`` مقدار ``2.67`` را برمی‌گرداند. این یک باگ نیست؛ بلکه نتیجه‌ی این واقعیت است که بیشتر کسرهای ده‌دهی را نمی‌توان به‌طور دقیق به‌صورت عدد ممیز شناور نمایش داد. برای اطلاعات بیشتر به :ref:`tut-fp-issues` مراجعه کنید."

msgid "Return a new :class:`set` object, optionally with elements taken from *iterable*.  :class:`set` is a built-in class.  See also :ref:`types-set` for documentation about this class."
msgstr "یک شیء جدید از نوع :class:`set` را برمی‌گرداند و به صورت اختیاری، عناصر آن از *iterable* گرفته می‌شوند. :class:`set` یک کلاس توکار است. برای مستندات این کلاس، به :ref:`types-set` مراجعه کنید."

msgid "For other containers see the built-in :class:`frozenset`, :class:`list`, :class:`tuple`, and :class:`dict` classes, as well as the :mod:`collections` module."
msgstr "برای سایر انواع ظرف‌ها، به کلاس‌های توکار :class:`frozenset`، :class:`list`، :class:`tuple` و :class:`dict`، و همچنین ماژول :mod:`collections` مراجعه کنید."

msgid "This is the counterpart of :func:`getattr`.  The arguments are an object, a string, and an arbitrary value.  The string may name an existing attribute or a new attribute.  The function assigns the value to the attribute, provided the object allows it.  For example, ``setattr(x, 'foobar', 123)`` is equivalent to ``x.foobar = 123``."
msgstr "این تابع همتای :func:`getattr` است. آرگومان‌های آن یک شیء، یک رشته و یک مقدار دلخواه هستند. رشته می‌تواند نام یک ویژگی موجود یا یک ویژگی جدید باشد. در صورت مجاز بودن، تابع مقدار را به آن ویژگی اختصاص می‌دهد. برای مثال، ``setattr(x, 'foobar', 123)`` معادل ``x.foobar = 123`` است."

msgid "*name* need not be a Python identifier as defined in :ref:`identifiers` unless the object chooses to enforce that, for example in a custom :meth:`~object.__getattribute__` or via :attr:`~object.__slots__`. An attribute whose name is not an identifier will not be accessible using the dot notation, but is accessible through :func:`getattr` etc.."
msgstr "*name* لازم نیست یک شناسه‌ی پایتون، مطابق تعریف :ref:`identifiers`، باشد؛ مگر اینکه خود شیء این موضوع را اعمال کند، برای مثال در یک :meth:`~object.__getattribute__` سفارشی یا از طریق :attr:`~object.__slots__`. ویژگی‌ای که نام آن یک شناسه نباشد، با استفاده از نماد نقطه قابل دسترسی نیست، اما از طریق :func:`getattr` و توابع مشابه قابل دسترسی خواهد بود."

msgid "Since :ref:`private name mangling <private-name-mangling>` happens at compilation time, one must manually mangle a private attribute's (attributes with two leading underscores) name in order to set it with :func:`setattr`."
msgstr "از آنجا که :ref:`تغییر نام خصوصی <private-name-mangling>` در زمان کامپایل انجام می‌شود، برای تنظیم مقدار یک ویژگی خصوصی (ویژگی‌هایی که با دو زیرخط آغاز می‌شوند) با استفاده از :func:`setattr`، باید نام آن را به‌صورت دستی تغییر دهید."

msgid "Return a new unique sentinel object.  *name* must be a :class:`str`, and is used by default as the returned object's representation::"
msgstr "یک شیء نشانگر یکتا و جدید برمی‌گرداند. آرگومان *name* باید یک :class:`str` باشد و به‌طور پیش‌فرض به عنوان نمایش شیء بازگردانده‌شده استفاده می‌شود::"

msgid ""
">>> MISSING = sentinel(\"MISSING\")\n"
">>> MISSING\n"
"MISSING"
msgstr ""
">>> MISSING = sentinel(\"MISSING\")\n"
">>> MISSING\n"
"MISSING"

msgid "The optional *repr* argument can be used to specify a different representation::"
msgstr "آرگومان اختیاری *repr* را می‌توان برای مشخص کردن یک بازنمایی متفاوت به کار برد::"

msgid ""
">>> MISSING = sentinel(\"MISSING\", repr=\"<MISSING>\")\n"
">>> MISSING\n"
"<MISSING>"
msgstr ""
">>> MISSING = sentinel(\"MISSING\", repr=\"<MISSING>\")\n"
">>> MISSING\n"
"<MISSING>"

msgid "Sentinel objects are truthy and compare equal only to themselves.  They are intended to be compared with the :keyword:`is` operator."
msgstr "اشیاء نشانگر دارای ارزش راستین (truthy) هستند و فقط با خودشان برابر مقایسه می‌شوند. آن‌ها برای مقایسه با عملگر :keyword:`is` در نظر گرفته شده‌اند."

msgid "``sentinel`` does not support subclassing."
msgstr "``sentinel`` از ایجاد زیرکلاس پشتیبانی نمی‌کند."

msgid "Shallow and deep copies of a sentinel object return the object itself."
msgstr "نسخه‌های کم‌عمق و عمیق از یک شیء نشانگر، خودِ شیء را برمی‌گردانند."

msgid "Sentinels are conventionally assigned to a variable with a matching name. Sentinels defined in this way can be used in :term:`type hints <type hint>`::"
msgstr "نشانگرها به‌طور قراردادی به یک متغیر با نام مشابه اختصاص داده می‌شوند. نشانگرهایی که به این روش تعریف می‌شوند را می‌توان در :term:`راهنماهای نوع <type hint>` استفاده کرد::"

msgid ""
"MISSING = sentinel(\"MISSING\")\n"
"\n"
"def next_value(default: int | MISSING = MISSING):\n"
"    ..."
msgstr ""
"MISSING = sentinel(\"MISSING\")\n"
"\n"
"def next_value(default: int | MISSING = MISSING):\n"
"    ..."

msgid "Sentinel objects support the :ref:`| <bitwise>` operator for use in type expressions."
msgstr "اشیاء نشانگر از عملگر :ref:`| <bitwise>` برای استفاده در عبارات نوع پشتیبانی می‌کنند."

msgid ":mod:`Pickling <pickle>` is supported for sentinel objects that are placed in the global scope of a module under a name matching the sentinel's name, and for sentinels placed in class scopes with a name matching the :term:`qualified name` of the sentinel. Other sentinels, such as those defined in a function scope, are not picklable. The identity of the sentinel is preserved after pickling::"
msgstr ":mod:`Pickling <pickle>` برای اشیاء نشانگری پشتیبانی می‌شود که در محدوده سراسری یک ماژول با نامی منطبق با نام نشانگر قرار دارند و همچنین برای نشانگرهایی که در محدوده‌های کلاس با نامی منطبق با :term:`نام کامل <qualified name>` نشانگر قرار گرفته‌اند. سایر نشانگرها، مانند آن‌هایی که در محدوده یک تابع تعریف شده‌اند، پیکل‌پذیر نیستند. هویت نشانگر پس از پیکل شدن حفظ می‌شود::"

msgid ""
"import pickle\n"
"\n"
"PICKLABLE = sentinel(\"PICKLABLE\")\n"
"\n"
"assert pickle.loads(pickle.dumps(PICKLABLE)) is PICKLABLE\n"
"\n"
"class Cls:\n"
"    PICKLABLE = sentinel(\"Cls.PICKLABLE\")\n"
"\n"
"assert pickle.loads(pickle.dumps(Cls.PICKLABLE)) is Cls.PICKLABLE"
msgstr ""
"import pickle\n"
"\n"
"PICKLABLE = sentinel(\"PICKLABLE\")\n"
"\n"
"assert pickle.loads(pickle.dumps(PICKLABLE)) is PICKLABLE\n"
"\n"
"class Cls:\n"
"    PICKLABLE = sentinel(\"Cls.PICKLABLE\")\n"
"\n"
"assert pickle.loads(pickle.dumps(Cls.PICKLABLE)) is Cls.PICKLABLE"

msgid "Sentinel objects have the following attributes:"
msgstr "اشیاء نشانگر دارای ویژگی‌های زیر هستند:"

msgid "The sentinel's name."
msgstr "نام نشانگر."

msgid "The name of the module where the sentinel was created. This attribute is writable."
msgstr "نام ماژولی که نشانگر در آن ایجاد شده است. این ویژگی قابل نوشتن است."

msgid "Return a :term:`slice` object representing the set of indices specified by ``range(start, stop, step)``.  The *start* and *step* arguments default to ``None``."
msgstr "یک شیء :term:`slice` را برمی‌گرداند که مجموعه‌ی اندیس‌های مشخص‌شده توسط ``range(start, stop, step)`` را نمایش می‌دهد. آرگومان‌های *start* و *step* به‌طور پیش‌فرض برابر ``None`` هستند."

msgid "Slice objects are also generated when :ref:`slicing syntax <slicings>` is used.  For example: ``a[start:stop:step]`` or ``a[start:stop, i]``."
msgstr "اشیای slice هنگام استفاده از :ref:`سینتکس اسلایس <slicings>` نیز ایجاد می‌شوند. برای مثال: ``a[start:stop:step]`` یا ``a[start:stop, i]``."

msgid "See :func:`itertools.islice` for an alternate version that returns an :term:`iterator`."
msgstr "برای نسخه‌ی جایگزینی که یک :term:`پیمایش‌گر <iterator>` برمی‌گرداند، به :func:`itertools.islice` مراجعه کنید."

msgid "These read-only attributes are set to the argument values (or their default).  They have no other explicit functionality; however, they are used by NumPy and other third-party packages."
msgstr "این ویژگی‌های فقط‌خواندنی بر اساس مقادیر آرگومان‌ها (یا مقادیر پیش‌فرض آن‌ها) تنظیم می‌شوند. خود آن‌ها قابلیت صریح دیگری ندارند؛ بااین‌حال، توسط NumPy و سایر بسته‌های شخص ثالث استفاده می‌شوند."

msgid "Slice objects are now :term:`hashable` (provided :attr:`~slice.start`, :attr:`~slice.stop`, and :attr:`~slice.step` are hashable)."
msgstr "اشیای slice اکنون :term:`هش‌پذیر <hashable>` هستند (به شرطی که :attr:`~slice.start`، :attr:`~slice.stop` و :attr:`~slice.step` نیز هش‌پذیر باشند)."

msgid "Return a new sorted list from the items in *iterable*."
msgstr "یک فهرست مرتب‌شده‌ی جدید از عناصر *iterable* را برمی‌گرداند."

msgid "Has two optional arguments which must be specified as keyword arguments."
msgstr "دارای دو آرگومان اختیاری است که باید به‌صورت آرگومان‌های کلیدواژه‌ای مشخص شوند."

msgid "*key* specifies a function of one argument that is used to extract a comparison key from each element in *iterable* (for example, ``key=str.lower``).  The default value is ``None`` (compare the elements directly)."
msgstr "*key* تابعی با یک آرگومان را مشخص می‌کند که برای استخراج یک کلید مقایسه از هر عنصر در *iterable* استفاده می‌شود (برای مثال، ``key=str.lower``). مقدار پیش‌فرض آن ``None`` است (در این حالت، عناصر مستقیماً با یکدیگر مقایسه می‌شوند)."

msgid "*reverse* is a boolean value.  If set to ``True``, then the list elements are sorted as if each comparison were reversed."
msgstr "*reverse* یک مقدار بولی است. اگر برابر ``True`` باشد، عناصر فهرست به گونه‌ای مرتب می‌شوند که گویی نتیجه‌ی هر مقایسه معکوس شده است."

msgid "Use :func:`functools.cmp_to_key` to convert an old-style *cmp* function to a *key* function."
msgstr "برای تبدیل یک تابع *cmp* به سبک قدیمی به یک تابع *key*، از :func:`functools.cmp_to_key` استفاده کنید."

msgid "The built-in :func:`sorted` function is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal --- this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade)."
msgstr "تابع توکار :func:`sorted` تضمین می‌کند که مرتب‌سازی پایدار باشد. مرتب‌سازی پایدار به این معناست که ترتیب نسبی عناصری که با هم برابر مقایسه می‌شوند تغییر نمی‌کند؛ این ویژگی برای مرتب‌سازی چندمرحله‌ای (برای مثال، ابتدا بر اساس دپارتمان و سپس بر اساس رده‌ی حقوق) مفید است."

msgid "The sort algorithm uses only ``<`` comparisons between items.  While defining an :meth:`~object.__lt__` method will suffice for sorting, :PEP:`8` recommends that all six :ref:`rich comparisons <comparisons>` be implemented.  This will help avoid bugs when using the same data with other ordering tools such as :func:`max` that rely on a different underlying method.  Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call the reflected :meth:`~object.__gt__` method."
msgstr "الگوریتم مرتب‌سازی تنها از مقایسه‌های ``<`` بین عناصر استفاده می‌کند. هرچند تعریف متد :meth:`~object.__lt__` برای مرتب‌سازی کافی است، :PEP:`8` توصیه می‌کند که هر شش عملگر :ref:`مقایسه‌ی غنی <comparisons>` پیاده‌سازی شوند. این کار به جلوگیری از بروز خطا هنگام استفاده از همان داده‌ها با ابزارهای مرتب‌سازی دیگری مانند :func:`max` که به متد زیربنایی متفاوتی متکی هستند کمک می‌کند. همچنین، پیاده‌سازی هر شش مقایسه از سردرگمی در مقایسه‌ی انواع مختلف که ممکن است متد بازتابی :meth:`~object.__gt__` را فراخوانی کنند جلوگیری می‌کند."

msgid "For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`."
msgstr "برای مثال‌هایی از مرتب‌سازی و یک آموزش کوتاه درباره‌ی آن، به :ref:`sortinghowto` مراجعه کنید."

msgid "Transform a method into a static method."
msgstr "یک متد را به متد ایستا تبدیل می‌کند."

msgid "A static method does not receive an implicit first argument. To declare a static method, use this idiom::"
msgstr "یک متد ایستا نخستین آرگومان ضمنی دریافت نمی‌کند. برای تعریف یک متد ایستا، از الگوی زیر استفاده کنید::"

msgid ""
"class C:\n"
"    @staticmethod\n"
"    def f(arg1, arg2, argN): ..."
msgstr ""
"class C:\n"
"    @staticmethod\n"
"    def f(arg1, arg2, argN): ..."

msgid "The ``@staticmethod`` form is a function :term:`decorator` -- see :ref:`function` for details."
msgstr "شکل ``@staticmethod`` یک :term:`دکوراتور <decorator>` تابع است؛ برای جزئیات به :ref:`تابع <function>` مراجعه کنید."

msgid "A static method can be called either on the class (such as ``C.f()``) or on an instance (such as ``C().f()``). Moreover, the static method :term:`descriptor` is also callable, so it can be used in the class definition (such as ``f()``)."
msgstr "یک متد ایستا را می‌توان هم روی خود کلاس (مانند ``C.f()``) و هم روی یک نمونه (مانند ``C().f()``) فراخوانی کرد. علاوه بر این، :term:`توصیف‌گر <descriptor>` متد ایستا نیز فراخوانی‌پذیر است؛ بنابراین می‌توان از آن در تعریف کلاس (مانند ``f()``) استفاده کرد."

msgid "Static methods in Python are similar to those found in Java or C++. Also, see :deco:`classmethod` for a variant that is useful for creating alternate class constructors."
msgstr "متدهای ایستا در پایتون مشابه متدهای ایستای موجود در جاوا یا ++C هستند. همچنین، برای گونه‌ای که در ایجاد سازنده‌های جایگزین برای کلاس مفید است، به :deco:`classmethod` مراجعه کنید."

msgid "Like all decorators, it is also possible to call ``staticmethod`` as a regular function and do something with its result.  This is needed in some cases where you need a reference to a function from a class body and you want to avoid the automatic transformation to instance method.  For these cases, use this idiom::"
msgstr "مانند همه‌ی دکوراتورها، می‌توان ``staticmethod`` را نیز به‌صورت یک تابع معمولی فراخوانی کرد و از نتیجه‌ی آن استفاده نمود. این کار در برخی موارد که به ارجاعی به یک تابع از درون بدنه‌ی کلاس نیاز دارید و می‌خواهید از تبدیل خودکار آن به متد نمونه جلوگیری کنید، ضروری است. در چنین مواردی، از الگوی زیر استفاده کنید::"

msgid ""
"def regular_function():\n"
"    ...\n"
"\n"
"class C:\n"
"    method = staticmethod(regular_function)"
msgstr ""
"def regular_function():\n"
"    ...\n"
"\n"
"class C:\n"
"    method = staticmethod(regular_function)"

msgid "For more information on static methods, see :ref:`types`."
msgstr "برای اطلاعات بیشتر درباره‌ی متدهای ایستا، به :ref:`types` مراجعه کنید."

msgid "Static methods now inherit the method attributes (:attr:`~function.__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :attr:`~function.__doc__` and :attr:`~function.__annotations__`), have a new ``__wrapped__`` attribute, and are now callable as regular functions."
msgstr "متدهای ایستا اکنون ویژگی‌های متد (:attr:`~function.__module__`، :attr:`~function.__name__`، :attr:`~function.__qualname__`، :attr:`~function.__doc__` و :attr:`~function.__annotations__`) را به ارث می‌برند، دارای ویژگی جدید ``__wrapped__`` هستند و همچنین اکنون مانند توابع معمولی فراخوانی‌پذیر‌اند."

msgid "Return a :class:`str` version of *object*.  See :func:`str` for details."
msgstr "نسخه‌ای از *object* از نوع :class:`str` را برمی‌گرداند. برای جزئیات بیشتر، به :func:`str` مراجعه کنید."

msgid "``str`` is the built-in string :term:`class`.  For general information about strings, see :ref:`textseq`."
msgstr "``str`` :term:`کلاس <class>` رشته‌ی توکار پایتون است. برای اطلاعات کلی درباره‌ی رشته‌ها، :ref:`textseq` را ببینید."

msgid "Sums *start* and the items of an *iterable* from left to right and returns the total.  The *iterable*'s items are normally numbers, and the start value is not allowed to be a string."
msgstr "*start* و عناصر *iterable* را از چپ به راست با هم جمع می‌کند و مجموع را برمی‌گرداند. عناصر *iterable* معمولاً عدد هستند و مقدار *start* مجاز نیست رشته باشد."

msgid "For some use cases, there are good alternatives to :func:`sum`. The preferred, fast way to concatenate a sequence of strings is by calling ``''.join(sequence)``.  To add floating-point values with extended precision, see :func:`math.fsum`\\.  To concatenate a series of iterables, consider using :func:`itertools.chain`."
msgstr "برای برخی کاربردها، جایگزین‌های مناسبی برای :func:`sum` وجود دارد. روش ترجیحی و سریع برای به‌هم‌چسباندن یک دنباله از رشته‌ها، فراخوانی ``''.join(sequence)`` است. برای جمع کردن اعداد ممیز شناور با دقت بیشتر، به :func:`math.fsum` مراجعه کنید. همچنین برای به‌هم‌پیوستن مجموعه‌ای از پیمایش‌پذیرها، استفاده از :func:`itertools.chain` را در نظر بگیرید."

msgid "The *start* parameter can be specified as a keyword argument."
msgstr "پارامتر *start* را می‌توان به‌صورت آرگومان کلیدواژه‌ای مشخص کرد."

msgid "Summation of floats switched to an algorithm that gives higher accuracy and better commutativity on most builds."
msgstr "الگوریتم جمع اعداد ممیز شناور به الگوریتمی تغییر یافته است که در بیشتر نسخه‌های ساخت (buildها)، دقت بیشتر و جابجاپذیری بهتری فراهم می‌کند."

msgid "Added specialization for summation of complexes, using same algorithm as for summation of floats."
msgstr "بهینه‌سازی ویژه‌ای برای جمع اعداد مختلط، با استفاده از همان الگوریتم جمع اعداد اعشاری، اضافه شد."

msgid "Return a proxy object that delegates method calls to a parent or sibling class of *type*.  This is useful for accessing inherited methods that have been overridden in a class."
msgstr "یک شیء پراکسی را برمی‌گرداند که فراخوانی متدها را به یک کلاس والد یا هم‌رده‌ی *type* واگذار می‌کند. این قابلیت برای دسترسی به متدهای به‌ارث‌رسیده‌ای که در یک کلاس بازنویسی شده‌اند، مفید است."

msgid "The *object_or_type* determines the :term:`method resolution order` to be searched.  The search starts from the class right after the *type*."
msgstr "*object_or_type* ترتیب :term:`حل متد <method resolution order>` را که باید جست‌وجو شود تعیین می‌کند. جست‌وجو از کلاسی که بلافاصله پس از *type* قرار دارد آغاز می‌شود."

msgid "For example, if :attr:`~type.__mro__` of *object_or_type* is ``D -> B -> C -> A -> object`` and the value of *type* is ``B``, then :func:`super` searches ``C -> A -> object``."
msgstr "برای مثال، اگر :attr:`~type.__mro__` مربوط به *object_or_type* برابر با ``D -> B -> C -> A -> object`` باشد و مقدار *type* برابر ``B`` باشد، در این صورت :func:`super` در مسیر ``C -> A -> object`` جست‌وجو می‌کند."

msgid "The :attr:`~type.__mro__` attribute of the class corresponding to *object_or_type* lists the method resolution search order used by both :func:`getattr` and :func:`super`.  The attribute is dynamic and can change whenever the inheritance hierarchy is updated."
msgstr "ویژگی :attr:`~type.__mro__` کلاس متناظر با *object_or_type* ترتیب جست‌وجوی حل متد را که هم توسط :func:`getattr` و هم توسط :func:`super` استفاده می‌شود، فهرست می‌کند. این ویژگی پویا است و هر زمان که سلسله‌مراتب وراثت تغییر کند، ممکن است تغییر یابد."

msgid "If the second argument is omitted, the super object returned is unbound.  If the second argument is an object, ``isinstance(obj, type)`` must be true.  If the second argument is a type, ``issubclass(type2, type)`` must be true (this is useful for classmethods)."
msgstr "اگر آرگومان دوم حذف شود، شیء super بازگردانده‌شده بدون اتصال (unbound) خواهد بود. اگر آرگومان دوم یک شیء باشد، باید ``isinstance(obj, type)`` برقرار باشد. اگر آرگومان دوم یک نوع باشد، باید ``issubclass(type2, type)`` برقرار باشد (این مورد برای متدهای کلاس مفید است)."

msgid "When called directly within an ordinary method of a class, both arguments may be omitted (\"zero-argument :func:`!super`\"). In this case, *type* will be the enclosing class, and *obj* will be the first argument of the immediately enclosing function (typically ``self``). (This means that zero-argument :func:`!super` will not work as expected within nested functions, including generator expressions, which implicitly create nested functions.)"
msgstr "هنگامی که این تابع مستقیماً درون یک متد معمولیِ یک کلاس فراخوانی شود، هر دو آرگومان را می‌توان حذف کرد («:func:`!super` بدون آرگومان»). در این حالت، *type* همان کلاسِ محصورکننده خواهد بود و *obj* اولین آرگومانِ تابعِ بلافاصله محصورکننده (معمولاً ``self``) خواهد بود. (این بدان معناست که :func:`!super` بدون آرگومان در توابع تودرتو، از جمله عبارت‌های تولیدگر که به‌طور ضمنی توابع تودرتو ایجاد می‌کنند، مطابق انتظار عمل نخواهد کرد.)"

msgid "There are two typical use cases for *super*.  In a class hierarchy with single inheritance, *super* can be used to refer to parent classes without naming them explicitly, thus making the code more maintainable.  This use closely parallels the use of *super* in other programming languages."
msgstr "دو کاربرد متداول برای *super* وجود دارد. در سلسله‌مراتب کلاسی با وراثت تکی، می‌توان از *super* برای ارجاع به کلاس‌های والد بدون نام بردن صریح از آن‌ها استفاده کرد و در نتیجه نگهداری کد را آسان‌تر ساخت. این کاربرد بسیار مشابه استفاده از *super* در سایر زبان‌های برنامه‌نویسی است."

msgid "The second use case is to support cooperative multiple inheritance in a dynamic execution environment.  This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance.  This makes it possible to implement \"diamond diagrams\" where multiple base classes implement the same method.  Good design dictates that such implementations have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime)."
msgstr "کاربرد متداول دوم، پشتیبانی از وراثت چندگانه‌ی مشارکتی در یک محیط اجرای پویا است. این کاربرد مختص پایتون است و در زبان‌های کامپایل‌شونده‌ی ایستا یا زبان‌هایی که فقط از وراثت تکی پشتیبانی می‌کنند وجود ندارد. این قابلیت امکان پیاده‌سازی «الگوهای الماسی» را فراهم می‌کند؛ جایی که چندین کلاس پایه یک متد یکسان را پیاده‌سازی می‌کنند. طراحی مناسب ایجاب می‌کند که چنین پیاده‌سازی‌هایی در همه‌ی موارد امضای فراخوانی یکسانی داشته باشند (زیرا ترتیب فراخوانی‌ها در ران‌تایم تعیین می‌شود، با تغییرات سلسله‌مراتب کلاس تطبیق می‌یابد و ممکن است شامل کلاس‌های هم‌سطحی باشد که پیش از ران‌تایم ناشناخته هستند)."

msgid "For both use cases, a typical superclass call looks like this::"
msgstr "در هر دو مورد استفاده، یک فراخوانی معمول به ابرکلاس به صورت زیر است::"

msgid ""
"class C(B):\n"
"    def method(self, arg):\n"
"        super().method(arg)    # This does the same thing as:\n"
"                               # super(C, self).method(arg)"
msgstr ""
"class C(B):\n"
"    def method(self, arg):\n"
"        super().method(arg)    # This does the same thing as:\n"
"                               # super(C, self).method(arg)"

msgid "In addition to method lookups, :func:`super` also works for attribute lookups.  One possible use case for this is calling :term:`descriptors <descriptor>` in a parent or sibling class."
msgstr "علاوه بر جست‌وجوی متدها، :func:`super` برای جست‌وجوی ویژگی‌ها نیز عمل می‌کند. یکی از کاربردهای ممکن آن، فراخوانی :term:`توصیف‌گرها <descriptor>` در یک کلاس والد یا هم‌رده است."

msgid "Note that :func:`super` is implemented as part of the binding process for explicit dotted attribute lookups such as ``super().__getitem__(name)``. It does so by implementing its own :meth:`~object.__getattribute__` method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, :func:`super` is undefined for implicit lookups using statements or operators such as ``super()[name]``."
msgstr "توجه داشته باشید که :func:`super` به‌عنوان بخشی از فرایند اتصال برای جست‌وجوی صریح ویژگی‌ها با نماد نقطه، مانند ``super().__getitem__(name)``, پیاده‌سازی شده است. این کار از طریق پیاده‌سازی متد :meth:`~object.__getattribute__` خودش انجام می‌شود تا کلاس‌ها را با ترتیبی قابل پیش‌بینی جست‌وجو کند؛ ترتیبی که از وراثت چندگانه‌ی مشارکتی (cooperative multiple inheritance) پشتیبانی می‌کند. بر این اساس، رفتار :func:`super` برای جست‌وجوهای ضمنی که با دستورها یا عملگرهایی مانند ``super()[name]`` انجام می‌شوند، تعریف نشده است."

msgid "Also note that, aside from the zero argument form, :func:`super` is not limited to use inside methods.  The two argument form specifies the arguments exactly and makes the appropriate references.  The zero argument form only works inside a class definition, as the compiler fills in the necessary details to correctly retrieve the class being defined, as well as accessing the current instance for ordinary methods."
msgstr "همچنین توجه داشته باشید که، به‌جز حالت بدون آرگومان، :func:`super` محدود به استفاده درون متدها نیست. شکل دوآرگومانی، آرگومان‌ها را دقیقاً همان‌گونه که داده شده‌اند استفاده کرده و ارجاعات مناسب را ایجاد می‌کند. شکل بدون آرگومان فقط درون تعریف یک کلاس کار می‌کند، زیرا کامپایلر جزئیات لازم را برای بازیابی صحیح کلاس در حال تعریف و همچنین دسترسی به نمونه‌ی فعلی در متدهای معمولی به‌طور خودکار فراهم می‌کند."

msgid "For practical suggestions on how to design cooperative classes using :func:`super`, see `guide to using super() <https://rhettinger.wordpress.com/2011/05/26/super-considered-super/>`_."
msgstr "برای پیشنهادهای کاربردی درباره‌ی طراحی کلاس‌های مشارکتی با استفاده از :func:`super`، به `راهنمای استفاده از super() <https://rhettinger.wordpress.com/2011/05/26/super-considered-super/>`_ مراجعه کنید."

msgid ":class:`super` objects are now :mod:`pickleable <pickle>` and  :mod:`copyable <copy>`."
msgstr "اکنون اشیای :class:`super` از :mod:`سریال‌سازی با pickle <pickle>` و :mod:`کپی شدن <copy>` پشتیبانی می‌کنند."

msgid "Rather than being a function, :class:`tuple` is actually an immutable sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`."
msgstr ":class:`tuple` در واقع یک نوع دنباله‌ی تغییرناپذیر است، نه یک تابع؛ همان‌گونه که در :ref:`typesseq-tuple` و :ref:`typesseq` مستند شده است."

msgid "With one argument, return the type of an *object*.  The return value is a type object and generally the same object as returned by :attr:`object.__class__`."
msgstr "در صورت ارسال یک آرگومان، نوعِ یک *object* را بازمی‌گرداند. مقدار بازگشتی یک شیء از نوع type است و معمولاً همان شی‌ءای است که توسط :attr:`object.__class__` بازگردانده می‌شود."

msgid "The :func:`isinstance` built-in function is recommended for testing the type of an object, because it takes subclasses into account."
msgstr "برای بررسی نوع یک شیء، استفاده از تابع توکار :func:`isinstance` توصیه می‌شود، زیرا زیرکلاس‌ها را نیز در نظر می‌گیرد."

msgid "With three arguments, return a new type object.  This is essentially a dynamic form of the :keyword:`class` statement. The *name* string is the class name and becomes the :attr:`~type.__name__` attribute. The *bases* tuple contains the base classes and becomes the :attr:`~type.__bases__` attribute; if empty, :class:`object`, the ultimate base of all classes, is added.  The *dict* dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the :attr:`~type.__dict__` attribute. The following two statements create identical :class:`!type` objects:"
msgstr "در صورت ارسال سه آرگومان، یک شیء type جدید بازمی‌گرداند. این در واقع شکل پویای دستور :keyword:`class` است. رشته‌ی *name* نام کلاس را مشخص می‌کند و به ویژگی :attr:`~type.__name__` تبدیل می‌شود. تاپل *bases* کلاس‌های پایه را در خود نگه می‌دارد و به ویژگی :attr:`~type.__bases__` تبدیل می‌شود؛ اگر خالی باشد، :class:`object`، که کلاس پایه‌ی نهایی همه‌ی کلاس‌ها است، به آن افزوده می‌شود. دیکشنری *dict* شامل تعریف ویژگی‌ها و متدهای بدنه‌ی کلاس است؛ این دیکشنری ممکن است پیش از تبدیل شدن به ویژگی :attr:`~type.__dict__` کپی یا در یک wrapper قرار داده شود. دو دستور زیر اشیای :class:`!type` یکسانی ایجاد می‌کنند:"

msgid "See also:"
msgstr "همچنین ببینید:"

msgid ":ref:`Documentation on attributes and methods on classes <class-attrs-and-methods>`."
msgstr ":ref:`مستندات ویژگی‌ها و متدهای کلاس‌ها <class-attrs-and-methods>`."

msgid ":ref:`bltin-type-objects`"
msgstr ":ref:`bltin-type-objects`"

msgid "Keyword arguments provided to the three argument form are passed to the appropriate metaclass machinery (usually :meth:`~object.__init_subclass__`) in the same way that keywords in a class definition (besides *metaclass*) would."
msgstr "آرگومان‌های کلیدواژه‌ای که به شکل سه‌آرگومانی ارسال می‌شوند، همانند کلیدواژه‌های موجود در تعریف یک کلاس (به‌جز *فراکلاس*) به سازوکار مناسب فراکلاس (معمولاً :meth:`~object.__init_subclass__`) ارسال می‌شوند."

msgid "Unlike a :keyword:`class` statement, the three argument form does not call the metaclass ``__prepare__`` method (see :ref:`prepare`).  Use :func:`types.new_class` to dynamically create a class using the appropriate metaclass."
msgstr "برخلاف دستور :keyword:`class`، فرم سه‌آرگومانی متد ``__prepare__`` فراکلاس را فراخوانی نمی‌کند (به :ref:`prepare` مراجعه کنید). برای ایجاد پویای یک کلاس با استفاده از فراکلاس مناسب، از :func:`types.new_class` استفاده کنید."

msgid "See also :ref:`class-customization`."
msgstr "همچنین به :ref:`class-customization` مراجعه کنید."

msgid "Subclasses of :class:`!type` which don't override ``type.__new__`` may no longer use the one-argument form to get the type of an object."
msgstr "زیرکلاس‌های :class:`!type` که ``type.__new__`` را بازنویسی نمی‌کنند، دیگر نمی‌توانند از شکل تک‌آرگومانی برای دریافت نوع یک شیء استفاده کنند."

msgid "*dict* can now be a :class:`frozendict`."
msgstr "اکنون *dict* می‌تواند یک :class:`frozendict` باشد."

msgid "Return the :attr:`~object.__dict__` attribute for a module, class, instance, or any other object with a :attr:`!__dict__` attribute."
msgstr "ویژگی :attr:`~object.__dict__` یک ماژول، کلاس، نمونه یا هر شیء دیگری که دارای ویژگی :attr:`!__dict__` باشد را برمی‌گرداند."

msgid "Objects such as modules and instances have an updateable :attr:`~object.__dict__` attribute; however, other objects may have write restrictions on their :attr:`!__dict__` attributes (for example, classes use a :class:`types.MappingProxyType` to prevent direct dictionary updates)."
msgstr "اشیایی مانند ماژول‌ها و نمونه‌ها دارای ویژگی :attr:`~object.__dict__` قابل‌به‌روزرسانی هستند؛ با این حال، برخی اشیای دیگر ممکن است محدودیت‌هایی برای نوشتن در ویژگی :attr:`!__dict__` خود داشته باشند (برای مثال، کلاس‌ها از :class:`types.MappingProxyType` برای جلوگیری از به‌روزرسانی مستقیم دیکشنری استفاده می‌کنند)."

msgid "Without an argument, :func:`vars` acts like :func:`locals`."
msgstr "در صورت نداشتن آرگومان، :func:`vars` همانند :func:`locals` عمل می‌کند."

msgid "A :exc:`TypeError` exception is raised if an object is specified but it doesn't have a :attr:`~object.__dict__` attribute (for example, if its class defines the :attr:`~object.__slots__` attribute)."
msgstr "اگر شی‌ءای مشخص شود اما دارای ویژگی :attr:`~object.__dict__` نباشد (برای مثال، اگر کلاس آن ویژگی :attr:`~object.__slots__` را تعریف کرده باشد)، استثنای :exc:`TypeError` پرتاب می‌شود."

msgid "The result of calling this function without an argument has been updated as described for the :func:`locals` builtin."
msgstr "نتیجه‌ی فراخوانی این تابع بدون آرگومان، مطابق توضیحات ارائه‌شده برای تابع توکار :func:`locals` به‌روزرسانی شده است."

msgid "Iterate over several iterables in parallel, producing tuples with an item from each one."
msgstr "روی چندین پیمایش‌پذیر به‌طور همزمان پیمایش می‌کند و تاپل‌هایی تولید می‌کند که هر یک شامل یک عنصر از هر پیمایش‌پذیر هستند."

msgid "Example::"
msgstr "مثال::"

msgid ""
">>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):\n"
"...     print(item)\n"
"...\n"
"(1, 'sugar')\n"
"(2, 'spice')\n"
"(3, 'everything nice')"
msgstr ""
">>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):\n"
"...     print(item)\n"
"...\n"
"(1, 'sugar')\n"
"(2, 'spice')\n"
"(3, 'everything nice')"

msgid "More formally: :func:`zip` returns an iterator of tuples, where the *i*-th tuple contains the *i*-th element from each of the argument iterables."
msgstr "به‌طور دقیق‌تر، :func:`zip` یک پیمایش‌گر از تاپل‌ها برمی‌گرداند که در آن، تاپل *i*\\ ام شامل عنصر *i*\\ ام از هر یک از پیمایش‌پذیرهای آرگومان‌ها است."

msgid "Another way to think of :func:`zip` is that it turns rows into columns, and columns into rows.  This is similar to `transposing a matrix <https://en.wikipedia.org/wiki/Transpose>`_."
msgstr "راه دیگری برای درک :func:`zip` این است که ردیفها را به ستون‌ها و ستون‌ها را به ردیفها تبدیل می‌کند. این کار مشابه `ترانهاده‌ی یک ماتریس <https://fa.wikipedia.org/wiki/ترانهاده>`_ است."

msgid ":func:`zip` is lazy: The elements won't be processed until the iterable is iterated on, e.g. by a :keyword:`!for` loop or by wrapping in a :class:`list`."
msgstr ":func:`zip` تنبل است؛ عناصر تا زمانی که روی پیمایش‌پذیر پیمایش انجام نشود، پردازش نمی‌شوند؛ برای مثال، با یک حلقه‌ی :keyword:`!for` یا با قرار دادن آن در :class:`list`."

msgid "One thing to consider is that the iterables passed to :func:`zip` could have different lengths; sometimes by design, and sometimes because of a bug in the code that prepared these iterables.  Python offers three different approaches to dealing with this issue:"
msgstr "یکی از نکاتی که باید در نظر داشت این است که پیمایش‌پذیرهای ارسال‌شده به :func:`zip` ممکن است طول‌های متفاوتی داشته باشند؛ گاهی این موضوع عمدی است و گاهی به دلیل وجود یک باگ در کدی است که این پیمایش‌پذیرها را آماده کرده است. پایتون سه روش مختلف برای برخورد با این مسئله ارائه می‌دهد:"

msgid "By default, :func:`zip` stops when the shortest iterable is :term:`exhausted`. It will ignore the remaining items in the longer iterables, cutting off the result to the length of the shortest iterable::"
msgstr "به طور پیش‌فرض، :func:`zip` زمانی متوقف می‌شود که کوتاه‌ترین پیمایش‌پذیر :term:`به پایان رسیده <exhausted>` شود. این تابع آیتم‌های باقی‌مانده در پیمایش‌پذیرهای طولانی‌تر را نادیده می‌گیرد و نتیجه را به طول کوتاه‌ترین پیمایش‌پذیر برمی‌دارد::"

msgid ""
">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n"
"[(0, 'fee'), (1, 'fi'), (2, 'fo')]"
msgstr ""
">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n"
"[(0, 'fee'), (1, 'fi'), (2, 'fo')]"

msgid ":func:`zip` is often used in cases where the iterables are assumed to be of equal length.  In such cases, it's recommended to use the ``strict=True`` option. Its output is the same as regular :func:`zip`::"
msgstr "از :func:`zip` اغلب در مواردی استفاده می‌شود که فرض بر این است پیمایش‌پذیرها طول یکسانی دارند. در چنین مواردی، توصیه می‌شود از گزینه‌ی ``strict=True`` استفاده کنید. خروجی آن با :func:`zip` معمولی یکسان است::"

msgid ""
">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n"
"[('a', 1), ('b', 2), ('c', 3)]"
msgstr ""
">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n"
"[('a', 1), ('b', 2), ('c', 3)]"

msgid "Unlike the default behavior, it raises a :exc:`ValueError` if one iterable is :term:`exhausted` before the others:"
msgstr "برخلاف رفتار پیش‌فرض، اگر یک پیمایش‌پذیر قبل از بقیه :term:`به پایان رسیده <exhausted>` شود، یک :exc:`ValueError` تولید می‌کند:"

msgid "Without the ``strict=True`` argument, any bug that results in iterables of different lengths will be silenced, possibly manifesting as a hard-to-find bug in another part of the program."
msgstr "بدون آرگومان ``strict=True``، هر اشکالی که باعث شود پیمایش‌پذیرها طول‌های متفاوتی داشته باشند، بی‌صدا نادیده گرفته می‌شود و ممکن است در بخش دیگری از برنامه به‌صورت یک باگ دشوار برای یافتن ظاهر شود."

msgid "Shorter iterables can be padded with a constant value to make all the iterables have the same length.  This is done by :func:`itertools.zip_longest`."
msgstr "می‌توان پیمایش‌پذیرهای کوتاه‌تر را با یک مقدار ثابت پُر کرد تا همه‌ی پیمایش‌پذیرها طول یکسانی داشته باشند. این کار توسط :func:`itertools.zip_longest` انجام می‌شود."

msgid "Edge cases: With a single iterable argument, :func:`zip` returns an iterator of 1-tuples.  With no arguments, it returns an empty iterator."
msgstr "حالت‌های خاص: اگر فقط یک آرگومان پیمایش‌پذیر به :func:`zip` داده شود، یک پیمایش‌گر از تاپل‌های تک‌عضوی برمی‌گرداند. اگر هیچ آرگومانی داده نشود، یک پیمایش‌گر خالی برمی‌گرداند."

msgid "Tips and tricks:"
msgstr "نکته‌ها و ترفندها:"

msgid "The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data series into n-length groups using ``zip(*[iter(s)]*n, strict=True)``.  This repeats the *same* iterator ``n`` times so that each output tuple has the result of ``n`` calls to the iterator. This has the effect of dividing the input into n-length chunks."
msgstr "ترتیب ارزیابی پیمایش‌پذیرها از چپ به راست تضمین شده است. این موضوع امکان استفاده از الگوی ``zip(*[iter(s)]*n, strict=True)`` را برای گروه‌بندی یک دنباله‌ی داده به گروه‌هایی با طول n فراهم می‌کند. در این روش، *همان* پیمایش‌گر ``n`` بار تکرار می‌شود تا هر تاپل خروجی حاصل ``n`` فراخوانی از همان پیمایش‌گر باشد. نتیجه‌ی این کار تقسیم ورودی به قطعاتی با طول n است."

msgid ":func:`zip` in conjunction with the ``*`` operator can be used to unzip a list::"
msgstr "می‌توان از :func:`zip` همراه با عملگر ``*`` برای بازکردن یک فهرست استفاده کرد::"

msgid ""
">>> x = [1, 2, 3]\n"
">>> y = [4, 5, 6]\n"
">>> list(zip(x, y))\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> x2, y2 = zip(*zip(x, y))\n"
">>> x == list(x2) and y == list(y2)\n"
"True"
msgstr ""
">>> x = [1, 2, 3]\n"
">>> y = [4, 5, 6]\n"
">>> list(zip(x, y))\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> x2, y2 = zip(*zip(x, y))\n"
">>> x == list(x2) and y == list(y2)\n"
"True"

msgid "Added the ``strict`` argument."
msgstr "آرگومان ``strict`` اضافه شد."

msgid "This is an advanced function that is not needed in everyday Python programming, unlike :func:`importlib.import_module`."
msgstr "این تابع پیشرفته‌ای است که برخلاف :func:`importlib.import_module` در برنامه‌نویسی روزمره‌ی پایتون معمولاً به آن نیازی نخواهید داشت."

msgid "This function is invoked by the :keyword:`import` statement.  It can be replaced (by importing the :mod:`builtins` module and assigning to ``builtins.__import__``) in order to change semantics of the :keyword:`!import` statement, but doing so is **strongly** discouraged as it is usually simpler to use import hooks (see :pep:`302`) to attain the same goals and does not cause issues with code which assumes the default import implementation is in use.  Direct use of :func:`__import__` is also discouraged in favor of :func:`importlib.import_module`."
msgstr "این تابع توسط دستور :keyword:`import` فراخوانی می‌شود. برای تغییر معنای دستور :keyword:`!import` می‌توان آن را (با وارد کردن ماژول :mod:`builtins` و انتساب به ``builtins.__import__``) جایگزین کرد، اما انجام این کار **اکیداً توصیه نمی‌شود**، زیرا معمولاً استفاده از import hookها (به :pep:`302` مراجعه کنید) برای دستیابی به همان هدف ساده‌تر است و با کدی که فرض می‌کند پیاده‌سازی پیش‌فرض import در حال استفاده است نیز مشکلی ایجاد نمی‌کند. همچنین استفاده‌ی مستقیم از :func:`__import__` به نفع :func:`importlib.import_module` توصیه نمی‌شود."

msgid "The function imports the module *name*, potentially using the given *globals* and *locals* to determine how to interpret the name in a package context. The *fromlist* gives the names of objects or submodules that should be imported from the module given by *name*.  The standard implementation does not use its *locals* argument at all and uses its *globals* only to determine the package context of the :keyword:`import` statement."
msgstr "این تابع ماژول *name* را ایمپورت می‌کند و در صورت نیاز از *globals* و *locals* داده‌شده برای تعیین نحوه‌ی تفسیر نام در زمینه‌ی یک بسته استفاده می‌کند. آرگومان *fromlist* نام اشیا یا زیرماژول‌هایی را مشخص می‌کند که باید از ماژول مشخص‌شده توسط *name* وارد شوند. پیاده‌سازی استاندارد اصلاً از آرگومان *locals* استفاده نمی‌کند و از *globals* تنها برای تعیین زمینه‌ی بسته در دستور :keyword:`import` بهره می‌برد."

msgid "*level* specifies whether to use absolute or relative imports. ``0`` (the default) means only perform absolute imports.  Positive values for *level* indicate the number of parent directories to search relative to the directory of the module calling :func:`__import__` (see :pep:`328` for the details)."
msgstr "*level* مشخص می‌کند که از ایمپورت مطلق استفاده شود یا نسبی. مقدار ``0`` (که مقدار پیش‌فرض است) به این معناست که فقط ایمپورت مطلق انجام شود. مقادیر مثبت برای *level* تعداد پوشه‌های والد را مشخص می‌کنند که باید نسبت به پوشه‌ی ماژولی که :func:`__import__` را فراخوانی کرده است جست‌وجو شوند (برای جزئیات، :pep:`328` را ببینید)."

msgid "When the *name* variable is of the form ``package.module``, normally, the top-level package (the name up till the first dot) is returned, *not* the module named by *name*.  However, when a non-empty *fromlist* argument is given, the module named by *name* is returned."
msgstr "وقتی متغیر *name* به شکل ``package.module`` باشد، به‌طور معمول بسته‌ی سطح بالا (بخشی از نام تا اولین نقطه) بازگردانده می‌شود، نه ماژولی که *name* به آن اشاره می‌کند. با این حال، اگر آرگومان *fromlist* ناتهی باشد، ماژول مشخص‌شده توسط *name* بازگردانده می‌شود."

msgid "For example, the statement ``import spam`` results in bytecode resembling the following code::"
msgstr "برای مثال، دستور ``import spam`` به بایت‌کدی مشابه کد زیر تبدیل می‌شود::"

msgid "spam = __import__('spam', globals(), locals(), [], 0)"
msgstr "spam = __import__('spam', globals(), locals(), [], 0)"

msgid "The statement ``import spam.ham`` results in this call::"
msgstr "دستور ``import spam.ham`` منجر به این فراخوانی می‌شود::"

msgid "spam = __import__('spam.ham', globals(), locals(), [], 0)"
msgstr "spam = __import__('spam.ham', globals(), locals(), [], 0)"

msgid "Note how :func:`__import__` returns the toplevel module here because this is the object that is bound to a name by the :keyword:`import` statement."
msgstr "توجه داشته باشید که :func:`__import__` در اینجا ماژول سطح بالا را برمی‌گرداند، زیرا این همان شی‌ءای است که توسط دستور :keyword:`import` به یک نام منتسب می‌شود."

msgid "On the other hand, the statement ``from spam.ham import eggs, sausage as saus`` results in ::"
msgstr "از سوی دیگر، دستور ``from spam.ham import eggs, sausage as saus`` به نتیجه‌ی زیر منجر می‌شود::"

msgid ""
"_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n"
"eggs = _temp.eggs\n"
"saus = _temp.sausage"
msgstr ""
"_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n"
"eggs = _temp.eggs\n"
"saus = _temp.sausage"

msgid "Here, the ``spam.ham`` module is returned from :func:`__import__`.  From this object, the names to import are retrieved and assigned to their respective names."
msgstr "در اینجا، ماژول ``spam.ham`` از :func:`__import__` بازگردانده می‌شود. سپس، نام‌هایی که باید ایمپورت شوند از این شیء استخراج شده و به نام‌های متناظر خود اختصاص داده می‌شوند."

msgid "If you simply want to import a module (potentially within a package) by name, use :func:`importlib.import_module`."
msgstr "اگر فقط می‌خواهید یک ماژول (احتمالاً درون یک بسته) را بر اساس نام آن ایمپورت کنید، از :func:`importlib.import_module` استفاده کنید."

msgid "Negative values for *level* are no longer supported (which also changes the default value to 0)."
msgstr "مقادیر منفی برای *level* دیگر پشتیبانی نمی‌شوند (در نتیجه، مقدار پیش‌فرض آن نیز به 0 تغییر کرده است)."

msgid "When the command line options :option:`-E` or :option:`-I` are being used, the environment variable :envvar:`PYTHONCASEOK` is now ignored."
msgstr "هنگامی که گزینه‌های خط فرمان :option:`-E` یا :option:`-I` استفاده شوند، متغیر محیطی :envvar:`PYTHONCASEOK` نادیده گرفته می‌شود."

msgid "Footnotes"
msgstr "پانویس‌ها"

msgid "Note that the parser only accepts the Unix-style end of line convention. If you are reading the code from a file, make sure to use newline conversion mode to convert Windows or Mac-style newlines."
msgstr "توجه داشته باشید که پارسر فقط قرارداد پایان خط به سبک یونیکس را می‌پذیرد. اگر کد را از یک پرونده می‌خوانید، مطمئن شوید که از حالت تبدیل نویسه‌ی پایان خط برای تبدیل پایان سطرهای ویندوز یا مک استفاده می‌کنید."

msgid "Boolean"
msgstr "بولی"

msgid "type"
msgstr "نوع"

msgid "built-in function"
msgstr "تابع توکار"

msgid "exec"
msgstr "exec"

msgid "NaN"
msgstr "NaN"

msgid "Infinity"
msgstr "بی‌نهایت"

msgid "__format__"
msgstr "__format__"

msgid "string"
msgstr "رشته"

msgid "format() (built-in function)"
msgstr "format() (تابع توکار)"

msgid "file object"
msgstr "شیء پرونده"

msgid "open() built-in function"
msgstr "تابع توکار open()"

msgid "file"
msgstr "پرونده"

msgid "modes"
msgstr "حالات"

msgid "universal newlines"
msgstr "پایان‌سطرهای همگانی"

msgid "line-buffered I/O"
msgstr "ورودی/خروجی با بافرگذاری سطری"

msgid "unbuffered I/O"
msgstr "ورودی/خروجی بافرگذاری‌نشده"

msgid "buffer size, I/O"
msgstr "اندازه‌ی بافر، ورودی/خروجی"

msgid "I/O control"
msgstr "کنترل ورودی/خروجی"

msgid "buffering"
msgstr "بافرگذاری"

msgid "text mode"
msgstr "حالت متن"

msgid "module"
msgstr "ماژول"

msgid "sys"
msgstr "sys"

msgid "str() (built-in function)"
msgstr "str() (تابع توکار)"

msgid "object"
msgstr "شیء"

msgid "statement"
msgstr "دستور"

msgid "import"
msgstr "ایمپورت"

msgid "builtins"
msgstr "توکارها"

#~ msgid "This function raises :exc:`SyntaxError` or :exc:`ValueError` if the compiled source is invalid."
#~ msgstr "اگر کد منبع کامپایل‌شده نامعتبر باشد، این تابع استثنای :exc:`SyntaxError` یا :exc:`ValueError` پرتاب می‌کند."

#~ msgid "``'strict'`` to raise a :exc:`ValueError` exception if there is an encoding error.  The default value of ``None`` has the same effect."
#~ msgstr "``'strict'`` در صورت بروز خطای کدگذاری، استثنای :exc:`ValueError` پرتاب می‌کند. مقدار پیش‌فرض ``None`` نیز همین رفتار را دارد."

#~ msgid "``'ignore'`` ignores errors.  Note that ignoring encoding errors can lead to data loss."
#~ msgstr "``'ignore'`` خطاها را نادیده می‌گیرد. توجه داشته باشید که نادیده گرفتن خطاهای کدگذاری ممکن است به از دست رفتن داده‌ها منجر شود."

#~ msgid "``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted where there is malformed data."
#~ msgstr "``'replace'`` باعث می‌شود در محل داده‌های نادرست، یک نویسه‌ی جایگزین (مانند ``'?'``) درج شود."

#~ msgid "``'surrogateescape'`` will represent any incorrect bytes as low surrogate code units ranging from U+DC80 to U+DCFF. These surrogate code units will then be turned back into the same bytes when the ``surrogateescape`` error handler is used when writing data.  This is useful for processing files in an unknown encoding."
#~ msgstr "``'surrogateescape'`` هر بایت نادرست را به‌صورت واحدهای کد جانشین پایینی در بازه‌ی U+DC80 تا U+DCFF نمایش می‌دهد. سپس، هنگام نوشتن داده‌ها و استفاده از هندلر خطای ``surrogateescape``، این واحدهای کد جانشین دوباره به همان بایت‌ها تبدیل می‌شوند. این قابلیت برای پردازش پرونده‌هایی با کدگذاری نامشخص مفید است."

#~ msgid "``'xmlcharrefreplace'`` is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference :samp:`&#{nnn};`."
#~ msgstr "``'xmlcharrefreplace'`` فقط هنگام نوشتن در یک پرونده پشتیبانی می‌شود. نویسه‌هایی که توسط کدگذاری پشتیبانی نمی‌شوند، با ارجاع نویسه‌ی XML متناظر آن‌ها به صورت :samp:`&#{nnn};` جایگزین می‌شوند."

#~ msgid "``'backslashreplace'`` replaces malformed data by Python's backslashed escape sequences."
#~ msgstr "``'backslashreplace'`` داده‌های نادرست را با دنباله‌های خنثی‌سازی دارای بک‌اسلش در پایتون جایگزین می‌کند."

#~ msgid "``'namereplace'`` (also only supported when writing) replaces unsupported characters with ``\\N{...}`` escape sequences."
#~ msgstr "``'namereplace'`` (که آن هم فقط هنگام نوشتن پشتیبانی می‌شود) نویسه‌های پشتیبانی‌نشده را با دنباله‌های خنثی‌سازی ``\\N{...}`` جایگزین می‌کند."