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

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

"POT-Creation-Date: 2026-09-21 11:59+0000\n"

"PO-Revision-Date: 2026-09-21 13:27+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 Types"

msgstr "انواع توکار"

msgid "The following sections describe the standard types that are built into the interpreter."

msgstr "بخش‌های زیر انواع استانداردی را که به‌صورت توکار در مفسر وجود دارند، توصیف می‌کنند."

msgid "The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions."

msgstr "انواع توکار اصلی عبارت‌اند از: اعداد، دنباله‌ها، نگاشت‌ها، کلاس‌ها، نمونه‌ها و استثناها."

msgid "Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don't return a specific item, never return the collection instance itself but ``None``."

msgstr "برخی از کلاس‌های مجموعه تغییرپذیر هستند. متدهایی که اعضای آن‌ها را درجا اضافه، حذف یا بازآرایی می‌کنند و آیتم مشخصی را برنمی‌گردانند، هرگز خودِ نمونه‌ی مجموعه را برنمی‌گردانند، بلکه ``None`` را برمی‌گردانند."

msgid "Some operations are supported by several object types; in particular, practically all objects can be compared for equality, tested for truth value, and converted to a string (with the :func:`repr` function or the slightly different :func:`str` function). The latter function is implicitly used when an object is written by the :func:`print` function."

msgstr "برخی عملیات توسط چندین نوع شیء پشتیبانی می‌شوند؛ به‌طور خاص، تقریباً همه‌ی اشیاء را می‌توان از نظر برابری مقایسه کرد، مقدار درستی آن‌ها را بررسی کرد و به یک رشته تبدیل کرد (با تابع :func:`repr` یا تابع :func:`str` که اندکی متفاوت است). تابع دوم به‌طور ضمنی زمانی استفاده می‌شود که شیءای توسط تابع :func:`print` نوشته می‌شود."

msgid "Truth Value Testing"

msgstr "آزمودن ارزش درستی"

msgid "Any object can be tested for truth value, for use in an :keyword:`if` or :keyword:`while` condition or as operand of the Boolean operations below."

msgstr "هر شیء را می‌توان از نظر مقدار درستی آزمود، برای استفاده در شرط :keyword:`if` یا :keyword:`while` یا به‌عنوان عملوند عملیات‌های بولی زیر."

msgid "By default, an object is considered true unless its class defines either a :meth:`~object.__bool__` method that returns ``False`` or a :meth:`~object.__len__` method that returns zero, when called with the object. [1]_ If one of the methods raises an exception when called, the exception is propagated and the object does not have a truth value (for example, :data:`NotImplemented`). Here are most of the built-in objects considered false:"

msgstr "به‌طور پیش‌فرض، یک شیء درست در نظر گرفته می‌شود مگر اینکه کلاس آن متدی از نوع :meth:`~object.__bool__` تعریف کرده باشد که هنگام فراخوانی با آن شیء ``False`` برگرداند، یا متدی از نوع :meth:`~object.__len__` که صفر برگرداند. [1]_ اگر یکی از این متدها هنگام فراخوانی استثنایی را پرتاب کند، آن استثنا منتشر می‌شود و شیء مقدار صحتی نخواهد داشت (برای مثال، :data:`NotImplemented`). در ادامه بیشتر اشیای توکاری که نادرست در نظر گرفته می‌شوند آمده‌اند:"

msgid "constants defined to be false: ``None`` and ``False``"

msgstr "ثابت‌هایی که نادرست تعریف شده‌اند: ``None`` و ``False``"

msgid "zero of any numeric type: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, ``Fraction(0, 1)``"

msgstr "صفر از هر نوع عددی: ``0``، ``0.0``، ``0j``، ``Decimal(0)``، ``Fraction(0, 1)``"

msgid "empty sequences and collections: ``''``, ``()``, ``[]``, ``{}``, ``set()``, ``range(0)``"

msgstr "دنباله‌ها و مجموعه‌های خالی: ``''``, ``()``, ``[]``, ``{}``, ``set()``, ``range(0)``"

msgid "Operations and built-in functions that have a Boolean result always return ``0`` or ``False`` for false and ``1`` or ``True`` for true, unless otherwise stated. (Important exception: the Boolean operations ``or`` and ``and`` always return one of their operands.)"

msgstr "عملیات‌ها و توابع توکاری که نتیجه بولی دارند، همیشه برای نادرست ``0`` یا ``False`` و برای درست ``1`` یا ``True`` برمی‌گردانند، مگر اینکه خلاف آن ذکر شده باشد. (استثنای مهم: عملیات بولی ``or`` و ``and`` همیشه یکی از عملوندهای خود را برمی‌گردانند.)"

msgid "Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`"

msgstr "عملیات بولی --- :keyword:`!and`، :keyword:`!or`، :keyword:`!not`"

msgid "These are the Boolean operations, ordered by ascending priority:"

msgstr "این‌ها عملیات‌های بولی هستند که به ترتیب اولویت صعودی مرتب شده‌اند:"

msgid "Operation"

msgstr "عملیات"

msgid "Result"

msgstr "نتیجه"

msgid "Notes"

msgstr "یادداشت‌ها"

msgid "``x or y``"

msgstr "``x or y``"

msgid "if *x* is true, then *x*, else *y*"

msgstr "اگر *x* درست باشد، آنگاه *x*، وگرنه *y*"

msgid "\\(1)"

msgstr "\\(1)"

msgid "``x and y``"

msgstr "``x and y``"

msgid "if *x* is false, then *x*, else *y*"

msgstr "اگر *x* نادرست باشد، آنگاه *x*، وگرنه *y*"

msgid "\\(2)"

msgstr "\\(2)"

msgid "``not x``"

msgstr "``not x``"

msgid "if *x* is false, then ``True``, else ``False``"

msgstr "اگر *x* نادرست باشد، آنگاه ``True``، در غیر این صورت ``False``"

msgid "\\(3)"

msgstr "\\(3)"

msgid "Notes:"

msgstr "یادداشت‌ها:"

msgid "This is a short-circuit operator, so it only evaluates the second argument if the first one is false."

msgstr "این یک عملگر اتصال کوتاه است؛ بنابراین تنها در صورتی آرگومان دوم را ارزیابی می‌کند که آرگومان اول نادرست باشد."

msgid "This is a short-circuit operator, so it only evaluates the second argument if the first one is true."

msgstr "این یک عملگر اتصال کوتاه است، بنابراین تنها در صورتی آرگومان دوم را ارزیابی می‌کند که آرگومان اول درست باشد."

msgid "``not`` has a lower priority than non-Boolean operators, so ``not a == b`` is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error."

msgstr "``not`` اولویت کمتری نسبت به عملگرهای غیربولی دارد، بنابراین ``not a == b`` به صورت ``not (a == b)`` تفسیر می‌شود و ``a == not b`` یک خطای سینتکس است."

msgid "Comparisons"

msgstr "مقایسه‌ها"

msgid "There are eight comparison operations in Python. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, ``x < y <= z`` is equivalent to ``x < y and y <= z``, except that *y* is evaluated only once (but in both cases *z* is not evaluated at all when ``x < y`` is found to be false)."

msgstr "در پایتون هشت عملیات مقایسه وجود دارد. همگی آن‌ها اولویت یکسانی دارند (که بالاتر از اولویت عملیات بولی است). مقایسه‌ها را می‌توان به‌طور دلخواه زنجیره‌ای کرد؛ برای مثال، ``x < y <= z`` معادل ``x < y and y <= z`` است، با این تفاوت که *y* فقط یک بار ارزیابی می‌شود (اما در هر دو حالت، وقتی مشخص شود که ``x < y`` نادرست است، *z* اصلاً ارزیابی نمی‌شود)."

msgid "This table summarizes the comparison operations:"

msgstr "این جدول عملیات مقایسه را خلاصه می‌کند:"

msgid "Meaning"

msgstr "معنی"

msgid "``<``"

msgstr "``<``"

msgid "strictly less than"

msgstr "کاملاً کمتر از"

msgid "``<=``"

msgstr "``<=``"

msgid "less than or equal"

msgstr "کوچک‌تر یا مساوی"

msgid "``>``"

msgstr "``>``"

msgid "strictly greater than"

msgstr "اکیداً بزرگ‌تر از"

msgid "``>=``"

msgstr "``>=``"

msgid "greater than or equal"

msgstr "بزرگ‌تر یا مساوی"

msgid "``==``"

msgstr "``==``"

msgid "equal"

msgstr "برابر"

msgid "``!=``"

msgstr "``!=``"

msgid "not equal"

msgstr "نامساوی"

msgid "``is``"

msgstr "``is``"

msgid "object identity"

msgstr "هویت شیء"

msgid "``is not``"

msgstr "``is not``"

msgid "negated object identity"

msgstr "نقیض هویت شیء"

msgid "Unless stated otherwise, objects of different types never compare equal. The ``==`` operator is always defined but for some object types (for example, class objects) is equivalent to :keyword:`is`. The ``<``, ``<=``, ``>`` and ``>=`` operators are only defined where they make sense; for example, they raise a :exc:`TypeError` exception when one of the arguments is a complex number."

msgstr "مگر اینکه خلاف آن ذکر شده باشد، اشیاء از انواع مختلف هرگز برابر مقایسه نمی‌شوند. عملگر ``==`` همیشه تعریف شده است اما برای برخی انواع شیء (برای مثال، اشیاء کلاس) معادل :keyword:`is` است. عملگرهای ``<``، ``<=``، ``>`` و ``>=`` فقط در مواردی تعریف شده‌اند که معنا داشته باشند؛ برای مثال، وقتی یکی از آرگومان‌ها یک عدد مختلط باشد، استثنای :exc:`TypeError` را پرتاب می‌کنند."

msgid "Non-identical instances of a class normally compare as non-equal unless the class defines the :meth:`~object.__eq__` method."

msgstr "نمونه‌های غیریکسان یک کلاس معمولاً به‌صورت نابرابر مقایسه می‌شوند، مگر اینکه کلاس متد :meth:`~object.__eq__` را تعریف کرده باشد."

msgid "Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods :meth:`~object.__lt__`, :meth:`~object.__le__`, :meth:`~object.__gt__`, and :meth:`~object.__ge__` (in general, :meth:`~object.__lt__` and :meth:`~object.__eq__` are sufficient, if you want the conventional meanings of the comparison operators)."

msgstr "نمونه‌های یک کلاس را نمی‌توان نسبت به سایر نمونه‌های همان کلاس یا انواع دیگری از اشیاء مرتب کرد، مگر اینکه کلاس تعداد کافی از متدهای :meth:`~object.__lt__`، :meth:`~object.__le__`، :meth:`~object.__gt__` و :meth:`~object.__ge__` را تعریف کند (به طور کلی، اگر معانی مرسوم عملگرهای مقایسه را می‌خواهید، :meth:`~object.__lt__` و :meth:`~object.__eq__` کافی هستند)."

msgid "The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be customized; also they can be applied to any two objects and never raise an exception."

msgstr "رفتار عملگرهای :keyword:`is` و :keyword:`is not` قابل سفارشی‌سازی نیست؛ همچنین می‌توان این عملگرها را روی هر دو شیء دلخواه اعمال کرد و هرگز استثنایی پرتاب نمی‌کنند."

msgid "Two more operations with the same syntactic priority, :keyword:`in` and :keyword:`not in`, are supported by types that are :term:`iterable` or implement the :meth:`~object.__contains__` method."

msgstr "دو عملیات دیگر با اولویت نحوی یکسان، :keyword:`in` و :keyword:`not in`، توسط نوع‌هایی پشتیبانی می‌شوند که :term:`پیمایش‌پذیر <iterable>` هستند یا متد :meth:`~object.__contains__` را پیاده‌سازی می‌کنند."

msgid "Numeric Types --- :class:`int`, :class:`float`, :class:`complex`"

msgstr "انواع عددی --- :class:`int`، :class:`float`، :class:`complex`"

msgid "There are three distinct numeric types: :dfn:`integers`, :dfn:`floating-point numbers`, and :dfn:`complex numbers`. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating-point numbers are usually implemented using :c:expr:`double` in C; information about the precision and internal representation of floating-point numbers for the machine on which your program is running is available in :data:`sys.float_info`. Complex numbers have a real and imaginary part, which are each a floating-point number. To extract these parts from a complex number *z*, use ``z.real`` and ``z.imag``. (The standard library includes the additional numeric types :mod:`fractions.Fraction`, for rationals, and :mod:`decimal.Decimal`, for floating-point numbers with user-definable precision.)"

msgstr "سه نوع عددی متمایز وجود دارد: :dfn:`عددهای صحیح (integers)`، :dfn:`عددهای ممیز شناور (floating-point numbers)` و :dfn:`عددهای مختلط (complex numbers)`. علاوه بر این، بولی‌ها زیرنوعی از عددهای صحیح هستند. عددهای صحیح دقتی نامحدود دارند. عددهای ممیز شناور معمولاً با استفاده از :c:expr:`double` در C پیاده‌سازی می‌شوند؛ اطلاعات مربوط به دقت و نمایش درونی عددهای ممیز شناور برای ماشینی که برنامه شما روی آن اجرا می‌شود، در :data:`sys.float_info` موجود است. عددهای مختلط دارای بخش حقیقی و بخش موهومی هستند که هر یک از آن‌ها یک عدد ممیز شناور است. برای استخراج این بخش‌ها از یک عدد مختلط *z*، از ``z.real`` و ``z.imag`` استفاده کنید. (کتابخانه استاندارد همچنین شامل نوع‌های عددی دیگری است: :mod:`fractions.Fraction` برای اعداد گویا و :mod:`decimal.Decimal` برای عددهای ممیز شناور با دقت قابل تعریف توسط کاربر.)"

msgid "Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating-point numbers. Appending ``'j'`` or ``'J'`` to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts."

msgstr "اعداد با مقادیر لفظی عددی یا به‌عنوان نتیجه‌ی توابع توکار و عملگرها ساخته می‌شوند. مقادیر لفظی عدد صحیح ساده (از جمله اعداد مبنای شانزده، مبنای هشت و مبنای دو) اعداد صحیح تولید می‌کنند. مقادیر لفظی عددی حاوی ممیز اعشار یا علامت توان، اعداد ممیز شناور تولید می‌کنند. افزودن ``'j'`` یا ``'J'`` به انتهای یک لفظی عددی، یک عدد موهومی (یک عدد مختلط با بخش حقیقی صفر) ایجاد می‌کند که می‌توانید آن را به یک عدد صحیح یا ممیز شناور اضافه کنید تا عدد مختلطی با بخش‌های حقیقی و موهومی به دست آورید."

msgid "The constructors :func:`int`, :func:`float`, and :func:`complex` can be used to produce numbers of a specific type."

msgstr "سازنده‌های :func:`int`، :func:`float` و :func:`complex` می‌توانند برای تولید اعدادی از یک نوع مشخص به کار روند."

msgid "Python fully supports mixed arithmetic: when a binary arithmetic operator has operands of different built-in numeric types, the operand with the \"narrower\" type is widened to that of the other:"

msgstr "پایتون به‌طور کامل از حساب ترکیبی پشتیبانی می‌کند: هنگامی که یک عملگر حسابی دودویی عملوندهایی از انواع عددی توکار متفاوت داشته باشد، عملوندی که نوع «باریک‌تری» دارد به نوع عملوند دیگر گسترش می‌یابد:"

msgid "If both arguments are complex numbers, no conversion is performed;"

msgstr "اگر هر دو آرگومان عدد مختلط باشند، هیچ تبدیلی انجام نمی‌شود؛"

msgid "if either argument is a complex or a floating-point number, the other is converted to a floating-point number;"

msgstr "اگر هر یک از آرگومان‌ها عددی مختلط یا ممیز شناور باشد، دیگری به عدد ممیز شناور تبدیل می‌شود؛"

msgid "otherwise, both must be integers and no conversion is necessary."

msgstr "در غیر این صورت، هر دو باید عدد صحیح باشند و هیچ تبدیلی لازم نیست."

msgid "Arithmetic with complex and real operands is defined by the usual mathematical formula, for example::"

msgstr "محاسبات با عملوندهای مختلط و حقیقی بر اساس فرمول ریاضی معمول تعریف می‌شود، برای مثال::"

msgid ""

msgstr ""

msgid "A comparison between numbers of different types behaves as though the exact values of those numbers were being compared. [2]_"

msgstr "مقایسه میان اعداد از انواع مختلف چنان رفتار می‌کند که گویی مقادیر دقیق آن اعداد در حال مقایسه هستند. [2]_"

msgid "All numeric types (except complex) support the following operations (for priorities of the operations, see :ref:`operator-summary`):"

msgstr "همه انواع عددی (به جز مختلط) از عملیات زیر پشتیبانی می‌کنند (برای اولویت‌های این عملیات، به :ref:`operator-summary` مراجعه کنید):"

msgid "Full documentation"

msgstr "مستندات کامل"

msgid "``x + y``"

msgstr "``x + y``"

msgid "sum of *x* and *y*"

msgstr "مجموع *x* و *y*"

msgid "``x - y``"

msgstr "``x - y``"

msgid "difference of *x* and *y*"

msgstr "تفاضل *x* و *y*"

msgid "``x * y``"

msgstr "``x * y``"

msgid "product of *x* and *y*"

msgstr "حاصل‌ضرب *x* و *y*"

msgid "``x / y``"

msgstr "``x / y``"

msgid "quotient of *x* and *y*"

msgstr "خارج قسمت *x* و *y*"

msgid "``x // y``"

msgstr "``x // y``"

msgid "floored quotient of *x* and *y*"

msgstr "خارج‌قسمت کف‌شده‌ی *x* و *y*"

msgid "\\(1)\\(2)"

msgstr "\\(1)\\(2)"

msgid "``x % y``"

msgstr "``x % y``"

msgid "remainder of ``x / y``"

msgstr "باقیمانده‌ی ``x / y``"

msgid "``-x``"

msgstr "``-x``"

msgid "*x* negated"

msgstr "*x* منفی‌شده"

msgid "``+x``"

msgstr "``+x``"

msgid "*x* unchanged"

msgstr "*x* بدون تغییر"

msgid "``abs(x)``"

msgstr "``abs(x)``"

msgid "absolute value or magnitude of *x*"

msgstr "قدر مطلق یا اندازه‌ی *x*"

msgid ":func:`abs`"

msgstr ":func:`abs`"

msgid "``int(x)``"

msgstr "``int(x)``"

msgid "*x* converted to integer"

msgstr "*x* تبدیل‌شده به عدد صحیح"

msgid "\\(3)\\(6)"

msgstr "\\(3)\\(6)"

msgid ":func:`int`"

msgstr ":func:`int`"

msgid "``float(x)``"

msgstr "``float(x)``"

msgid "*x* converted to floating point"

msgstr "*x* تبدیل‌شده به ممیز شناور"

msgid "\\(4)\\(6)"

msgstr "\\(4)\\(6)"

msgid ":func:`float`"

msgstr ":func:`float`"

msgid "``complex(re, im)``"

msgstr "``complex(re, im)``"

msgid "a complex number with real part *re*, imaginary part *im*. *im* defaults to zero."

msgstr "عدد مختلطی با بخش حقیقی *re* و بخش موهومی *im*. مقدار پیش‌فرض *im* صفر است."

msgid "\\(6)"

msgstr "\\(6)"

msgid ":func:`complex`"

msgstr ":func:`complex`"

msgid "``c.conjugate()``"

msgstr "``c.conjugate()``"

msgid "conjugate of the complex number *c*"

msgstr "مزدوج عدد مختلط *c*"

msgid "``divmod(x, y)``"

msgstr "``divmod(x, y)``"

msgid "the pair ``(x // y, x % y)``"

msgstr "جفت ``(x // y, x % y)``"

msgid ":func:`divmod`"

msgstr ":func:`divmod`"

msgid "``pow(x, y)``"

msgstr "``pow(x, y)``"

msgid "*x* to the power *y*"

msgstr "*x* به توان *y*"

msgid "\\(5)"

msgstr "\\(5)"

msgid ":func:`pow`"

msgstr ":func:`pow`"

msgid "``x ** y``"

msgstr "``x ** y``"

msgid "Also referred to as integer division. For operands of type :class:`int`, the result has type :class:`int`. For operands of type :class:`float`, the result has type :class:`float`. In general, the result is a whole integer, though the result's type is not necessarily :class:`int`. The result is always rounded towards minus infinity: ``1//2`` is ``0``, ``(-1)//2`` is ``-1``, ``1//(-2)`` is ``-1``, and ``(-1)//(-2)`` is ``0``."

msgstr "همچنین به آن تقسیم عدد صحیح نیز گفته می‌شود. برای عملوندهایی از نوع :class:`int`، نتیجه از نوع :class:`int` است. برای عملوندهایی از نوع :class:`float`، نتیجه از نوع :class:`float` است. در حالت کلی، نتیجه یک عدد صحیح کامل است، هرچند نوع نتیجه لزوماً :class:`int` نیست. نتیجه همیشه به سمت منفی بی‌نهایت گرد می‌شود: ``1//2`` برابر با ``0`` است، ``(-1)//2`` برابر با ``-1`` است، ``1//(-2)`` برابر با ``-1`` است و ``(-1)//(-2)`` برابر با ``0`` است."

msgid "Not for complex numbers. Instead convert to floats using :func:`abs` if appropriate."

msgstr "برای اعداد مختلط کاربرد ندارد. در عوض، در صورت مناسب بودن، با استفاده از :func:`abs` آن‌ها را به اعداد اعشاری تبدیل کنید."

msgid "Conversion from :class:`float` to :class:`int` truncates, discarding the fractional part. See functions :func:`math.floor` and :func:`math.ceil` for alternative conversions."

msgstr "تبدیل از :class:`float` به :class:`int` به روش قطع انجام می‌شود و بخش اعشاری را حذف می‌کند. برای تبدیل‌های جایگزین، توابع :func:`math.floor` و :func:`math.ceil` را ببینید."

msgid "float also accepts the strings \"nan\" and \"inf\" with an optional prefix \"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity."

msgstr "float همچنین رشته‌های \"nan\" و \"inf\" را با پیشوند اختیاری \"+\" یا \"-\" برای عدد نیست (NaN) و بی‌نهایت مثبت یا منفی می‌پذیرد."

msgid "Python defines ``pow(0, 0)`` and ``0 ** 0`` to be ``1``, as is common for programming languages."

msgstr "پایتون ``pow(0, 0)`` و ``0 ** 0`` را برابر با ``1`` تعریف می‌کند، همان‌گونه که در زبان‌های برنامه‌نویسی رایج است."

msgid "The numeric literals accepted include the digits ``0`` to ``9`` or any Unicode equivalent (code points with the ``Nd`` property)."

msgstr "مقادیر لفظی عددی (numeric literals) پذیرفته‌شده شامل رقم‌های ``0`` تا ``9`` یا هر معادل یونیکدی آن‌ها هستند (نقطه‌های کد (code points) دارای ویژگی ``Nd``)."

msgid "See `the Unicode Standard <https://unicode.org/Public/UNIDATA/extracted/DerivedNumericType.txt>`_ for a complete list of code points with the ``Nd`` property."

msgstr "برای فهرست کامل نقطه‌های کد دارای ویژگی ``Nd`` به `استاندارد یونیکد <https://unicode.org/Public/UNIDATA/extracted/DerivedNumericType.txt>`_ مراجعه کنید."

msgid "All :class:`numbers.Real` types (:class:`int` and :class:`float`) also include the following operations:"

msgstr "همه‌ی انواع :class:`numbers.Real` (:class:`int` و :class:`float`) همچنین عملیات زیر را نیز شامل می‌شوند:"

msgid ":func:`math.trunc(\\ x) <math.trunc>`"

msgstr ":func:`math.trunc(\\ x) <math.trunc>`"

msgid "*x* truncated to :class:`~numbers.Integral`"

msgstr "*x* قطع‌شده به :class:`~numbers.Integral`"

msgid ":func:`round(x[, n]) <round>`"

msgstr ":func:`round(x[, n]) <round>`"

msgid "*x* rounded to *n* digits, rounding half to even. If *n* is omitted, it defaults to 0."

msgstr "*x* گرد شده به *n* رقم، با گرد کردن نیم به زوج. اگر *n* حذف شود، به طور پیش‌فرض ۰ است."

msgid ":func:`math.floor(\\ x) <math.floor>`"

msgstr ":func:`math.floor(\\ x) <math.floor>`"

msgid "the greatest :class:`~numbers.Integral` <= *x*"

msgstr "بزرگ‌ترین :class:`~numbers.Integral` <= *x*"

msgid ":func:`math.ceil(x) <math.ceil>`"

msgstr ":func:`math.ceil(x) <math.ceil>`"

msgid "the least :class:`~numbers.Integral` >= *x*"

msgstr "کوچک‌ترین :class:`~numbers.Integral` بزرگ‌تر یا مساوی *x*"

msgid "For additional numeric operations see the :mod:`math` and :mod:`cmath` modules."

msgstr "برای عملیات عددی بیشتر، ماژول‌های :mod:`math` و :mod:`cmath` را ببینید."

msgid "Bitwise Operations on Integer Types"

msgstr "عملیات بیتی روی نوع‌های عدد صحیح"

msgid "Bitwise operations only make sense for integers. The result of bitwise operations is calculated as though carried out in two's complement with an infinite number of sign bits."

msgstr "عملیات بیتی تنها برای اعداد صحیح معنا دارند. نتیجه‌ی عملیات بیتی چنان محاسبه می‌شود که گویی در مکمل دو و با تعداد نامتناهی بیت علامت انجام شده است."

msgid "The priorities of the binary bitwise operations are all lower than the numeric operations and higher than the comparisons; the unary operation ``~`` has the same priority as the other unary numeric operations (``+`` and ``-``)."

msgstr "اولویت تمام عملگرهای بیتی دودویی از عملیات عددی پایین‌تر و از مقایسه‌ها بالاتر است؛ عملگر یکانی ``~`` اولویتی برابر با سایر عملگرهای عددی یکانی (``+`` و ``-``) دارد."

msgid "This table lists the bitwise operations sorted in ascending priority:"

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

msgid "``x | y``"

msgstr "``x | y``"

msgid "bitwise :dfn:`or` of *x* and *y*"

msgstr ":dfn:`یا (or)` بیتیِ *x* و *y*"

msgid "\\(4)"

msgstr "\\(4)"

msgid "``x ^ y``"

msgstr "``x ^ y``"

msgid "bitwise :dfn:`exclusive or` of *x* and *y*"

msgstr ":dfn:`یای انحصاری بیتی (exclusive or)` *x* و *y*"

msgid "``x & y``"

msgstr "``x & y``"

msgid "bitwise :dfn:`and` of *x* and *y*"

msgstr ":dfn:`و (and)` بیتیِ *x* و *y*"

msgid "``x << n``"

msgstr "``x << n``"

msgid "*x* shifted left by *n* bits"

msgstr "*x* به اندازه‌ی *n* بیت به چپ منتقل شده است"

msgid "(1)(2)"

msgstr "(1)(2)"

msgid "``x >> n``"

msgstr "``x >> n``"

msgid "*x* shifted right by *n* bits"

msgstr "*x* به اندازه‌ی *n* بیت به سمت راست منتقل شده"

msgid "(1)(3)"

msgstr "(1)(3)"

msgid "``~x``"

msgstr "``~x``"

msgid "the bits of *x* inverted"

msgstr "بیت‌های *x* وارونه‌شده"

msgid "Negative shift counts are illegal and cause a :exc:`ValueError` to be raised."

msgstr "شمارش‌های انتقال (shift) منفی غیرمجاز هستند و باعث می‌شوند که یک :exc:`ValueError` پرتاب شود."

msgid "A left shift by *n* bits is equivalent to multiplication by ``pow(2, n)``."

msgstr "انتقال به چپ به اندازه‌ی *n* بیت معادل ضرب در ``pow(2, n)`` است."

msgid "A right shift by *n* bits is equivalent to floor division by ``pow(2, n)``."

msgstr "یک انتقال به راست به اندازه‌ی *n* بیت معادل تقسیم کف بر ``pow(2, n)`` است."

msgid "Performing these calculations with at least one extra sign extension bit in a finite two's complement representation (a working bit-width of ``1 + max(x.bit_length(), y.bit_length())`` or more) is sufficient to get the same result as if there were an infinite number of sign bits."

msgstr "انجام این محاسبات با دست‌کم یک بیت اضافی برای بسط علامت در یک نمایش متناهی مکمل دو (پهنای بیت کاری ``1 + max(x.bit_length(), y.bit_length())`` یا بیشتر) برای به‌دست‌آوردن همان نتیجه‌ای که گویی تعداد بی‌نهایتی بیت علامت وجود دارد، کافی است."

msgid "Additional Methods on Integer Types"

msgstr "متدهای اضافی روی انواع عدد صحیح"

msgid "The int type implements the :class:`numbers.Integral` :term:`abstract base class`. In addition, it provides a few more methods:"

msgstr "نوع int :class:`numbers.Integral`، یعنی :term:`کلاس پایه انتزاعی <abstract base class>`، را پیاده‌سازی می‌کند. علاوه بر این، چند متد دیگر نیز ارائه می‌دهد:"

msgid "Return the number of bits necessary to represent an integer in binary, excluding the sign and leading zeros::"

msgstr "بازگرداندن تعداد بیت‌های لازم برای نمایش یک عدد صحیح در مبنای دو، بدون احتساب علامت و صفرهای ابتدایی::"

msgid ""

msgstr ""

msgid "More precisely, if ``x`` is nonzero, then ``x.bit_length()`` is the unique positive integer ``k`` such that ``2**(k-1) <= abs(x) < 2**k``. Equivalently, when ``abs(x)`` is small enough to have a correctly rounded logarithm, then ``k = 1 + int(log(abs(x), 2))``. If ``x`` is zero, then ``x.bit_length()`` returns ``0``."

msgstr "دقیق‌تر بگوییم، اگر ``x`` ناصفر باشد، آنگاه ``x.bit_length()`` تنها عدد صحیح مثبت ``k`` است که ``2**(k-1) <= abs(x) < 2**k``. به بیان معادل، وقتی ``abs(x)`` به اندازه کافی کوچک باشد که لگاریتم آن به‌درستی گرد شود، آنگاه ``k = 1 + int(log(abs(x), 2))``. اگر ``x`` صفر باشد، آنگاه ``x.bit_length()`` مقدار ``0`` را برمی‌گرداند."

msgid "Equivalent to::"

msgstr "معادل است با::"

msgid ""

msgstr ""

msgid "Return the number of ones in the binary representation of the absolute value of the integer. This is also known as the population count. Example::"

msgstr "تعداد یک‌ها در نمایش دودویی قدر مطلق عدد صحیح را بازمی‌گرداند. این عمل با نام شمارش جمعیت (population count) نیز شناخته می‌شود. مثال::"

msgid ""

msgstr ""

msgid ""

msgstr ""

msgid "Return an array of bytes representing an integer."

msgstr "آرایه‌ای از بایت‌ها را برمی‌گرداند که یک عدد صحیح را نمایش می‌دهد."

msgid "The integer is represented using *length* bytes, and defaults to 1. An :exc:`OverflowError` is raised if the integer is not representable with the given number of bytes."

msgstr "عدد صحیح با استفاده از *length* بایت نمایش داده می‌شود و پیش‌فرض آن ۱ است. اگر عدد صحیح با تعداد بایت‌های داده‌شده قابل نمایش نباشد، یک :exc:`OverflowError` پرتاب می‌شود."

msgid "The *byteorder* argument determines the byte order used to represent the integer, and defaults to ``\"big\"``. If *byteorder* is ``\"big\"``, the most significant byte is at the beginning of the byte array. If *byteorder* is ``\"little\"``, the most significant byte is at the end of the byte array."

msgstr "آرگومان *byteorder* ترتیب بایت مورد استفاده برای نمایش عدد صحیح را تعیین می‌کند و پیش‌فرض آن ``\"big\"`` است. اگر *byteorder* برابر با ``\"big\"`` باشد، پرارزش‌ترین بایت در ابتدای آرایه بایتی قرار می‌گیرد. اگر *byteorder* برابر با ``\"little\"`` باشد، پرارزش‌ترین بایت در انتهای آرایه بایتی قرار می‌گیرد."

msgid "The *signed* argument determines whether two's complement is used to represent the integer. If *signed* is ``False`` and a negative integer is given, an :exc:`OverflowError` is raised. The default value for *signed* is ``False``."

msgstr "آرگومان *signed* تعیین می‌کند که آیا از مکمل دو برای نمایش عدد صحیح استفاده می‌شود یا خیر. اگر *signed* برابر با ``False`` باشد و یک عدد صحیح منفی داده شود، استثنای :exc:`OverflowError` پرتاب می‌شود. مقدار پیش‌فرض برای *signed* برابر با ``False`` است."

msgid "The default values can be used to conveniently turn an integer into a single byte object::"

msgstr "می‌توان از مقادیر پیش‌فرض برای تبدیل راحتِ یک عدد صحیح به یک شیء بایت تک‌بایتی استفاده کرد::"

msgid ""

msgstr ""

msgid "However, when using the default arguments, don't try to convert a value greater than 255 or you'll get an :exc:`OverflowError`."

msgstr "با این حال، هنگام استفاده از آرگومان‌های پیش‌فرض، سعی نکنید مقداری بزرگ‌تر از ۲۵۵ را تبدیل کنید، در غیر این صورت یک :exc:`OverflowError` دریافت می‌کنید."

msgid ""

msgstr ""

msgid "Added default argument values for ``length`` and ``byteorder``."

msgstr "مقادیر پیش‌فرض برای آرگومان‌های ``length`` و ``byteorder`` افزوده شد."

msgid "Return the integer represented by the given array of bytes."

msgstr "عدد صحیح نمایش‌داده‌شده توسط آرایه‌ای از بایت‌های داده‌شده را بازمی‌گرداند."

msgid "The argument *bytes* must either be a :term:`bytes-like object` or an iterable producing bytes."

msgstr "آرگومان *bytes* باید یا یک :term:`bytes-like object` باشد یا یک پیمایش‌پذیر که بایت تولید می‌کند."

msgid "The *byteorder* argument determines the byte order used to represent the integer, and defaults to ``\"big\"``. If *byteorder* is ``\"big\"``, the most significant byte is at the beginning of the byte array. If *byteorder* is ``\"little\"``, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use :data:`sys.byteorder` as the byte order value."

msgstr "آرگومان *byteorder* ترتیب بایتی را که برای نمایش عدد صحیح به کار می‌رود تعیین می‌کند و پیش‌فرض آن ``\"big\"`` است. اگر *byteorder* برابر با ``\"big\"`` باشد، بااهمیت‌ترین بایت در ابتدای آرایه بایت قرار می‌گیرد. اگر *byteorder* برابر با ``\"little\"`` باشد، بااهمیت‌ترین بایت در انتهای آرایه بایت قرار می‌گیرد. برای درخواست ترتیب بایت بومی سیستم میزبان، از :data:`sys.byteorder` به‌عنوان مقدار ترتیب بایت استفاده کنید."

msgid "The *signed* argument indicates whether two's complement is used to represent the integer."

msgstr "آرگومان *signed* نشان می‌دهد که آیا از مکمل دو برای نمایش عدد صحیح استفاده می‌شود یا خیر."

msgid ""

msgstr ""

msgid "Added default argument value for ``byteorder``."

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

msgid "Return a pair of integers whose ratio is equal to the original integer and has a positive denominator. The integer ratio of integers (whole numbers) is always the integer as the numerator and ``1`` as the denominator."

msgstr "جفتی از اعداد صحیح را بازمی‌گرداند که نسبت آن با عدد صحیح اصلی برابر است و مخرجی مثبت دارد. نسبت صحیحِ اعداد صحیح (اعداد حسابی) همیشه خودِ عدد صحیح به‌عنوان صورت کسر و ``1`` به‌عنوان مخرج است."

msgid "Returns ``True``. Exists for duck type compatibility with :meth:`float.is_integer`."

msgstr "``True`` را برمی‌گرداند. برای سازگاری نوع‌دهی اردکی با :meth:`float.is_integer` وجود دارد."

msgid "Additional Methods on Float"

msgstr "متدهای اضافی روی Float"

msgid "The float type implements the :class:`numbers.Real` :term:`abstract base class`. float also has the following additional methods."

msgstr "نوع float، :term:`کلاس پایه انتزاعی <abstract base class>` :class:`numbers.Real` را پیاده‌سازی می‌کند. float همچنین متدهای اضافی زیر را دارد."

msgid "Class method to return a floating-point number constructed from a number *x*."

msgstr "متد کلاس برای برگرداندن یک عدد ممیز شناور که از یک عدد *x* ساخته شده است."

msgid "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 "اگر آرگومان یک عدد صحیح یا یک عدد ممیز شناور باشد، عددی ممیز شناور با همان مقدار (در حد دقت ممیز شناور پایتون) بازگردانده می‌شود. اگر آرگومان خارج از محدوده یک float پایتون باشد، استثنای :exc:`OverflowError` پرتاب می‌شود."

msgid "For a general Python object ``x``, ``float.from_number(x)`` delegates to ``x.__float__()``. If :meth:`~object.__float__` is not defined then it falls back to :meth:`~object.__index__`."

msgstr "برای یک شیء عمومی پایتون ``x``، ``float.from_number(x)`` کار را به ``x.__float__()`` واگذار می‌کند. اگر :meth:`~object.__float__` تعریف نشده باشد، آنگاه به :meth:`~object.__index__` رجوع می‌کند."

msgid "Return a pair of integers whose ratio is exactly equal to the original float. The ratio is in lowest terms and has a positive denominator. Raises :exc:`OverflowError` on infinities and a :exc:`ValueError` on NaNs."

msgstr "جفتی از اعداد صحیح برمی‌گرداند که نسبت آن‌ها دقیقاً برابر با عدد اعشاری اصلی است. این نسبت ساده‌شده است و مخرج آن مثبت است. برای بی‌نهایت‌ها استثنای :exc:`OverflowError` و برای NaNها استثنای :exc:`ValueError` پرتاب می‌کند."

msgid "Return ``True`` if the float instance is finite with integral value, and ``False`` otherwise::"

msgstr "اگر نمونه‌ی اعشاری متناهی باشد و مقدار صحیح داشته باشد، ``True`` و در غیر این صورت ``False`` برمی‌گرداند::"

msgid ""

msgstr ""

msgid "Two methods support conversion to and from hexadecimal strings. Since Python's floats are stored internally as binary numbers, converting a float to or from a *decimal* string usually involves a small rounding error. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers. This can be useful when debugging, and in numerical work."

msgstr "دو متد از تبدیل به و از رشته‌های مبنای شانزده پشتیبانی می‌کنند. چون مقادیر float پایتون به‌صورت داخلی به شکل اعداد دودویی ذخیره می‌شوند، تبدیل یک float به یک رشته‌ی *دهدهی* یا برعکس معمولاً با یک خطای کوچک گرد کردن همراه است. در مقابل، رشته‌های مبنای شانزده امکان نمایش و تعیین دقیق اعداد ممیز شناور را فراهم می‌کنند. این موضوع می‌تواند هنگام اشکال‌زدایی و در کارهای عددی مفید باشد."

msgid "Return a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading ``0x`` and a trailing ``p`` and exponent."

msgstr "نمایشی از یک عدد ممیز شناور را به‌صورت رشته‌ای در مبنای شانزده بازمی‌گرداند. برای اعداد ممیز شناور متناهی، این نمایش همیشه شامل یک ``0x`` در ابتدا و یک ``p`` و توان در انتها خواهد بود."

msgid "Class method to return the float represented by a hexadecimal string *s*. The string *s* may have leading and trailing whitespace."

msgstr "متد کلاس برای بازگرداندن عدد اعشاری که با رشته‌ی مبنای شانزده *s* نمایش داده می‌شود. رشته‌ی *s* می‌تواند فاصله‌های خالی در ابتدا و انتها داشته باشد."

msgid "Note that :meth:`float.hex` is an instance method, while :meth:`float.fromhex` is a class method."

msgstr "توجه داشته باشید که :meth:`float.hex` یک متد نمونه است، در حالی که :meth:`float.fromhex` یک متد کلاس است."

msgid "A hexadecimal string takes the form::"

msgstr "یک رشته مبنای شانزده به شکل زیر است::"

msgid "[sign] ['0x'] integer ['.' fraction] ['p' exponent]"

msgstr "[sign] ['0x'] integer ['.' fraction] ['p' exponent]"

msgid "where the optional ``sign`` may be either ``+`` or ``-``, ``integer`` and ``fraction`` are strings of hexadecimal digits, and ``exponent`` is a decimal integer with an optional leading sign. Case is not significant, and there must be at least one hexadecimal digit in either the integer or the fraction. This syntax is similar to the syntax specified in section 6.4.4.2 of the C99 standard, and also to the syntax used in Java 1.5 onwards. In particular, the output of :meth:`float.hex` is usable as a hexadecimal floating-point literal in C or Java code, and hexadecimal strings produced by C's ``%a`` format character or Java's ``Double.toHexString`` are accepted by :meth:`float.fromhex`."

msgstr "در اینجا ``sign`` اختیاری می‌تواند ``+`` یا ``-`` باشد. ``integer`` و ``fraction`` رشته‌هایی از ارقام مبنای شانزده هستند و ``exponent`` یک عدد صحیح دهدهی با یک علامت پیش‌روِ اختیاری است. بزرگی و کوچکی حروف اهمیتی ندارد و باید حداقل یک رقم مبنای شانزده در عدد صحیح یا کسر وجود داشته باشد. این سینتکس شبیه به سینتکسِ مشخص‌شده در بخش ۶.۴.۴.۲ از استاندارد C99 است و همچنین به سینتکسِ استفاده‌شده در جاوا ۱.۵ به بعد. به‌ویژه، خروجیِ :meth:`float.hex` به‌عنوان یک لفظیِ اعشاریِ مبنای شانزده در کد C یا جاوا قابل‌استفاده است و رشته‌های مبنای شانزده تولیدشده توسط نویسهِ قالب ``%a`` زبان C یا ``Double.toHexString`` جاوا توسط :meth:`float.fromhex` پذیرفته می‌شوند."

msgid "Note that the exponent is written in decimal rather than hexadecimal, and that it gives the power of 2 by which to multiply the coefficient. For example, the hexadecimal string ``0x3.a7p10`` represents the floating-point number ``(3 + 10./16 + 7./16**2) * 2.0**10``, or ``3740.0``::"

msgstr "توجه داشته باشید که توان به‌صورت مبنای ده و نه مبنای شانزده نوشته می‌شود، و اینکه این توان، توانی از ۲ را مشخص می‌کند که در آن ضریب ضرب می‌شود. برای مثال، رشته‌ی مبنای شانزده ``0x3.a7p10`` عدد ممیز شناور ``(3 + 10./16 + 7./16**2) * 2.0**10`` یا همان ``3740.0`` را بازنمایی می‌کند::"

msgid ""

msgstr ""

msgid "Applying the reverse conversion to ``3740.0`` gives a different hexadecimal string representing the same number::"

msgstr "اعمال تبدیل معکوس روی ``3740.0`` رشته‌ای دیگر با مبنای شانزده به دست می‌دهد که همان عدد را نمایش می‌دهد::"

msgid ""

msgstr ""

msgid "Additional Methods on Complex"

msgstr "متدهای اضافی روی اعداد مختلط"

msgid "The :class:`!complex` type implements the :class:`numbers.Complex` :term:`abstract base class`. :class:`!complex` also has the following additional methods."

msgstr "نوع :class:`!complex` :term:`کلاس پایه انتزاعی <abstract base class>` :class:`numbers.Complex` را پیاده‌سازی می‌کند. :class:`!complex` همچنین متدهای اضافی زیر را نیز دارد."

msgid "Class method to convert a number to a complex number."

msgstr "متد کلاس برای تبدیل یک عدد به یک عدد مختلط."

msgid "For a general Python object ``x``, ``complex.from_number(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 "برای یک شیء عمومی پایتون ``x``، ``complex.from_number(x)`` به ``x.__complex__()`` واگذاری می‌کند. اگر :meth:`~object.__complex__` تعریف نشده باشد، آنگاه به :meth:`~object.__float__` روی می‌آورد. اگر :meth:`!__float__` تعریف نشده باشد، آنگاه به :meth:`~object.__index__` روی می‌آورد."

msgid "Hashing of numeric types"

msgstr "درهم‌سازی انواع عددی"

msgid "For numbers ``x`` and ``y``, possibly of different types, it's a requirement that ``hash(x) == hash(y)`` whenever ``x == y`` (see the :meth:`~object.__hash__` method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including :class:`int`, :class:`float`, :class:`decimal.Decimal` and :class:`fractions.Fraction`) Python's hash for numeric types is based on a single mathematical function that's defined for any rational number, and hence applies to all instances of :class:`int` and :class:`fractions.Fraction`, and all finite instances of :class:`float` and :class:`decimal.Decimal`. Essentially, this function is given by reduction modulo ``P`` for a fixed prime ``P``. The value of ``P`` is made available to Python as the :attr:`~sys.hash_info.modulus` attribute of :data:`sys.hash_info`."

msgstr "برای اعداد ``x`` و ``y`` که ممکن است از نوع‌های مختلف باشند، الزامی وجود دارد مبنی بر اینکه هرگاه ``x == y`` باشد، ``hash(x) == hash(y)`` نیز برقرار باشد (برای جزئیات بیشتر، مستندات متد :meth:`~object.__hash__` را ببینید). برای سهولت پیاده‌سازی و کارایی در میان نوع‌های عددی گوناگون (از جمله :class:`int`، :class:`float`، :class:`decimal.Decimal` و :class:`fractions.Fraction`) هش پایتون برای نوع‌های عددی بر پایه یک تابع ریاضی واحد استوار است که برای هر عدد گویا تعریف شده و بنابراین بر همه نمونه‌های :class:`int` و :class:`fractions.Fraction` و همه نمونه‌های متناهی :class:`float` و :class:`decimal.Decimal` اعمال می‌شود. در اصل، این تابع به‌صورت کاهش به پیمانه‌ی ``P`` برای یک عدد اول ثابت ``P`` داده می‌شود. مقدار ``P`` به‌عنوان ویژگی :attr:`~sys.hash_info.modulus` از :data:`sys.hash_info` در اختیار پایتون قرار می‌گیرد."

msgid "Currently, the prime used is ``P = 2**31 - 1`` on machines with 32-bit C longs and ``P = 2**61 - 1`` on machines with 64-bit C longs."

msgstr "در حال حاضر، عدد اول استفاده‌شده روی ماشین‌هایی که نوع long زبان C آن‌ها ۳۲ بیتی است، ``P = 2**31 - 1`` و روی ماشین‌هایی که نوع long زبان C آن‌ها ۶۴ بیتی است، ``P = 2**61 - 1`` می‌باشد."

msgid "Here are the rules in detail:"

msgstr "در اینجا قواعد به تفصیل آمده است:"

msgid "If ``x = m / n`` is a nonnegative rational number and ``n`` is not divisible by ``P``, define ``hash(x)`` as ``m * invmod(n, P) % P``, where ``invmod(n, P)`` gives the inverse of ``n`` modulo ``P``."

msgstr "اگر ``x = m / n`` یک عدد گویای نامنفی باشد و ``n`` بر ``P`` بخش‌پذیر نباشد، ``hash(x)`` را به صورت ``m * invmod(n, P) % P`` تعریف کنید، که در آن ``invmod(n, P)`` وارون ``n`` به پیمانه ``P`` را می‌دهد."

msgid "If ``x = m / n`` is a nonnegative rational number and ``n`` is divisible by ``P`` (but ``m`` is not) then ``n`` has no inverse modulo ``P`` and the rule above doesn't apply; in this case define ``hash(x)`` to be the constant value ``sys.hash_info.inf``."

msgstr "اگر ``x = m / n`` یک عدد گویای نامنفی باشد و ``n`` بر ``P`` بخش‌پذیر باشد (اما ``m`` چنین نباشد)، آنگاه ``n`` وارونی به پیمانه ``P`` ندارد و قاعده‌ی بالا اعمال نمی‌شود؛ در این حالت ``hash(x)`` را برابر مقدار ثابت ``sys.hash_info.inf`` تعریف کنید."

msgid "If ``x = m / n`` is a negative rational number define ``hash(x)`` as ``-hash(-x)``. If the resulting hash is ``-1``, replace it with ``-2``."

msgstr "اگر ``x = m / n`` یک عدد گویای منفی باشد، ``hash(x)`` را به‌صورت ``-hash(-x)`` تعریف کنید. اگر هش حاصل ``-1`` باشد، آن را با ``-2`` جایگزین کنید."

msgid "The particular values ``sys.hash_info.inf`` and ``-sys.hash_info.inf`` are used as hash values for positive infinity or negative infinity (respectively)."

msgstr "مقادیر خاص ``sys.hash_info.inf`` و ``-sys.hash_info.inf`` به‌ترتیب به‌عنوان مقادیر هش برای بی‌نهایت مثبت یا بی‌نهایت منفی استفاده می‌شوند."

msgid "For a :class:`complex` number ``z``, the hash values of the real and imaginary parts are combined by computing ``hash(z.real) + sys.hash_info.imag * hash(z.imag)``, reduced modulo ``2**sys.hash_info.width`` so that it lies in ``range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))``. Again, if the result is ``-1``, it's replaced with ``-2``."

msgstr "برای یک عدد :class:`complex` مانند ``z``، مقادیر هش بخش حقیقی و بخش موهومی با محاسبه‌ی ``hash(z.real) + sys.hash_info.imag * hash(z.imag)`` ترکیب می‌شوند و نتیجه به پیمانه‌ی ``2**sys.hash_info.width`` کاهش می‌یابد تا در ``range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))`` قرار گیرد. باز هم، اگر نتیجه ``-1`` باشد، با ``-2`` جایگزین می‌شود."

msgid "To clarify the above rules, here's some example Python code, equivalent to the built-in hash, for computing the hash of a rational number, :class:`float`, or :class:`complex`::"

msgstr "برای روشن شدن قواعد بالا، در اینجا نمونه‌ای از کد پایتون آمده است که معادل hash توکار بوده و برای محاسبه‌ی هش یک عدد گویا، :class:`float` یا :class:`complex` به کار می‌رود::"

msgid ""

msgstr ""

msgid "Boolean Type - :class:`bool`"

msgstr "نوع بولی - :class:`bool`"

msgid "Booleans represent truth values. The :class:`bool` type has exactly two constant instances: ``True`` and ``False``."

msgstr "بولی‌ها مقادیر درستی را نشان می‌دهند. نوع :class:`bool` دقیقاً دو نمونه‌ی ثابت دارد: ``True`` و ``False``."

msgid "The built-in function :func:`bool` converts any value to a boolean, if the value can be interpreted as a truth value (see section :ref:`truth` above)."

msgstr "تابع توکار :func:`bool` هر مقداری را به یک مقدار بولی تبدیل می‌کند، اگر بتوان آن مقدار را به‌عنوان یک مقدار درستی تفسیر کرد (بخش :ref:`صدق <truth>` در بالا را ببینید)."

msgid "For logical operations, use the :ref:`boolean operators <boolean>` ``and``, ``or`` and ``not``. When applying the bitwise operators ``&``, ``|``, ``^`` to two booleans, they return a bool equivalent to the logical operations \"and\", \"or\", \"xor\". However, the logical operators ``and``, ``or`` and ``!=`` should be preferred over ``&``, ``|`` and ``^``."

msgstr "برای عملیات منطقی، از :ref:`عملگرهای بولی <boolean>` ``and``، ``or`` و ``not`` استفاده کنید. هنگامی که عملگرهای بیتی ``&``، ``|`` و ``^`` را روی دو مقدار بولی اعمال می‌کنید، آن‌ها یک bool معادل عملیات منطقی «and»، «or» و «xor» برمی‌گردانند. با این حال، بهتر است عملگرهای منطقی ``and``، ``or`` و ``!=`` را به ``&``، ``|`` و ``^`` ترجیح دهید."

msgid "The use of the bitwise inversion operator ``~`` is deprecated and will raise an error in Python 3.16."

msgstr "استفاده از عملگر وارون‌سازی بیتی ``~`` منسوخ شده است و در Python 3.16 خطایی پرتاب خواهد کرد."

msgid ":class:`bool` is a subclass of :class:`int` (see :ref:`typesnumeric`). In many numeric contexts, ``False`` and ``True`` behave like the integers 0 and 1, respectively. However, relying on this is discouraged; explicitly convert using :func:`int` instead."

msgstr ":class:`bool` زیرکلاسی از :class:`int` است (به :ref:`typesnumeric` مراجعه کنید). در بسیاری از زمینه‌های عددی، ``False`` و ``True`` مانند اعداد صحیح ۰ و ۱ رفتار می‌کنند. با این حال، تکیه بر این موضوع توصیه نمی‌شود؛ به جای آن، صریحاً با استفاده از :func:`int` تبدیل کنید."

msgid "Iterator Types"

msgstr "انواع پیمایش‌گر"

msgid "Python supports a concept of iteration over containers. This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration. Sequences, described below in more detail, always support the iteration methods."

msgstr "پایتون از مفهومی به نام پیمایش روی ظرف‌ها (containers) پشتیبانی می‌کند. این مفهوم با استفاده از دو متد متمایز پیاده‌سازی می‌شود؛ از این متدها استفاده می‌شود تا کلاس‌های تعریف‌شده توسط کاربر بتوانند از پیمایش پشتیبانی کنند. دنباله‌ها، که در ادامه با جزئیات بیشتری توضیح داده می‌شوند، همواره از متدهای تکرار پشتیبانی می‌کنند."

msgid "One method needs to be defined for container objects to provide :term:`iterable` support:"

msgstr "برای آنکه اشیاء ظرف بتوانند پشتیبانی از :term:`پیمایش‌پذیر <iterable>` را فراهم کنند، باید یک متد تعریف شود:"

msgid "Return an :term:`iterator` object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types. (An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal.) This method corresponds to the :c:member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects in the Python/C API."

msgstr "یک شیء :term:`پیمایش‌گر <iterator>` بازمی‌گرداند. این شیء موظف است از پروتکل پیمایش‌گری که در ادامه شرح داده شده است پشتیبانی کند. اگر یک ظرف از انواع مختلف تکرار پشتیبانی می‌کند، می‌توان متدهای اضافی‌ای ارائه داد که به‌طور خاص برای آن انواع تکرار، پیمایش‌گر درخواست کنند. (نمونه‌ای از شیءای که از چند شکل پیمایش پشتیبانی می‌کند، ساختاری درختی است که هم پیمایش عرضی (breadth-first) و هم پیمایش عمقی (depth-first) را پشتیبانی می‌کند.) این متد متناظر با جایگاه :c:member:`~PyTypeObject.tp_iter` در ساختار نوع اشیاء پایتون در Python/C API است."

msgid "The iterator objects themselves are required to support the following two methods, which together form the :dfn:`iterator protocol`:"

msgstr "خود اشیاء پیمایش‌گر ملزم به پشتیبانی از دو متد زیر هستند که در مجموع :dfn:`پروتکل پیمایش‌گر (iterator protocol)` را تشکیل می‌دهند:"

msgid "Return the :term:`iterator` object itself. This is required to allow both containers and iterators to be used with the :keyword:`for` and :keyword:`in` statements. This method corresponds to the :c:member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects in the Python/C API."

msgstr "خودِ شیء :term:`پیمایش‌گر <iterator>` را بازمی‌گرداند. این امر برای آن ضروری است که بتوان هم از ظرف‌ها و هم از پیمایش‌گرها همراه با دستورهای :keyword:`for` و :keyword:`in` استفاده کرد. این متد متناظر با جایگاه :c:member:`~PyTypeObject.tp_iter` از ساختار نوع اشیاء پایتون در Python/C API است."

msgid "Return the next item from the :term:`iterator`. If there are no further items, raise the :exc:`StopIteration` exception. This method corresponds to the :c:member:`~PyTypeObject.tp_iternext` slot of the type structure for Python objects in the Python/C API."

msgstr "آیتم بعدی را از :term:`پیمایش‌گر <iterator>` برگردانید. اگر آیتم‌های بیشتری وجود نداشته باشند، استثنای :exc:`StopIteration` را پرتاب کنید. این متد متناظر با جایگاه :c:member:`~PyTypeObject.tp_iternext` در ساختار نوع اشیاء پایتون در API پایتون/C است."

msgid "Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The specific types are not important beyond their implementation of the iterator protocol."

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

msgid "Once an iterator's :meth:`~iterator.__next__` method raises :exc:`StopIteration`, it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken."

msgstr "به‌محض اینکه متد :meth:`~iterator.__next__` یک پیمایش‌گر استثنای :exc:`StopIteration` را پرتاب کند، باید به انجام همین کار در فراخوانی‌های بعدی ادامه دهد. پیاده‌سازی‌هایی که از این ویژگی پیروی نمی‌کنند، معیوب تلقی می‌شوند."

msgid "Generator Types"

msgstr "انواع تولیدگر"

msgid "Python's :term:`generator`\\s provide a convenient way to implement the iterator protocol. If a container object's :meth:`~object.__iter__` method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the :meth:`~iterator.__iter__` and :meth:`~generator.__next__` methods. More information about generators can be found in :ref:`the documentation for the yield expression <yieldexpr>`."

msgstr ":term:`تولیدگرهای <generator>` پایتون راهی مناسب برای پیاده‌سازی پروتکل پیمایش‌گر فراهم می‌کنند. اگر متد :meth:`~object.__iter__` یک شیء ظرف به‌صورت یک تولیدگر پیاده‌سازی شود، به‌طور خودکار یک شیء پیمایش‌گر (از نظر فنی، یک شیء تولیدگر) بازمی‌گرداند که متدهای :meth:`~iterator.__iter__` و :meth:`~generator.__next__` را فراهم می‌کند. اطلاعات بیشتری درباره تولیدگرها می‌توانید در :ref:`مستندات عبارت yield <yieldexpr>` بیابید."

msgid "Sequence Types --- :class:`list`, :class:`tuple`, :class:`range`"

msgstr "انواع دنباله --- :class:`list`، :class:`tuple`، :class:`range`"

msgid "There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of :ref:`binary data <binaryseq>` and :ref:`text strings <textseq>` are described in dedicated sections."

msgstr "سه نوع دنباله‌ی پایه وجود دارد: فهرست‌ها، تاپل‌ها و اشیای range. انواع دنباله‌ی دیگری که برای پردازش :ref:`داده‌های دودویی <binaryseq>` و :ref:`رشته‌های متنی <textseq>` طراحی شده‌اند، در بخش‌های اختصاصی توضیح داده شده‌اند."

msgid "Common Sequence Operations"

msgstr "عملیات‌های رایج دنباله‌ها"

msgid "The operations in the following table are supported by most sequence types, both mutable and immutable. The :class:`collections.abc.Sequence` ABC is provided to make it easier to correctly implement these operations on custom sequence types."

msgstr "عملیات‌های جدول زیر توسط بیشتر نوع‌های دنباله، هم تغییرپذیر و هم تغییرناپذیر، پشتیبانی می‌شوند. کلاس پایه انتزاعی (ABC) :class:`collections.abc.Sequence` فراهم شده است تا پیاده‌سازی صحیح این عملیات‌ها روی نوع‌های دنباله سفارشی آسان‌تر شود."

msgid "This table lists the sequence operations sorted in ascending priority. In the table, *s* and *t* are sequences of the same type, *n*, *i*, *j* and *k* are integers and *x* is an arbitrary object that meets any type and value restrictions imposed by *s*."

msgstr "این جدول عملیات دنباله را به ترتیب صعودی اولویت فهرست می‌کند. در این جدول، *s* و *t* دنباله‌هایی از یک نوع هستند، *n*، *i*، *j* و *k* اعداد صحیح هستند و *x* شیء دلخواهی است که هر محدودیت نوع و مقدار اعمال‌شده توسط *s* را برآورده می‌کند."

msgid "The ``in`` and ``not in`` operations have the same priorities as the comparison operations. The ``+`` (concatenation) and ``*`` (repetition) operations have the same priority as the corresponding numeric operations. [3]_"

msgstr "عملیات‌های ``in`` و ``not in`` همان اولویت عملیات مقایسه را دارند. عملیات‌های ``+`` (الحاق) و ``*`` (تکرار) همان اولویت عملیات عددی متناظر را دارند. [3]_"

msgid "See :ref:`time-complexity` for the costs of the various sequence operations."

msgstr "برای هزینه‌های عملیات‌های مختلف دنباله، به :ref:`time-complexity` مراجعه کنید."

msgid "``x in s``"

msgstr "``x in s``"

msgid "``True`` if an item of *s* is equal to *x*, else ``False``"

msgstr "اگر یکی از آیتم‌های *s* برابر با *x* باشد، ``True``؛ در غیر این صورت ``False``"

msgid "``x not in s``"

msgstr "``x not in s``"

msgid "``False`` if an item of *s* is equal to *x*, else ``True``"

msgstr "اگر یکی از آیتم‌های *s* با *x* برابر باشد، ``False``؛ در غیر این صورت ``True``"

msgid "``s + t``"

msgstr "``s + t``"

msgid "the concatenation of *s* and *t*"

msgstr "الحاق *s* و *t*"

msgid "(6)(7)"

msgstr "(6)(7)"

msgid "``s * n`` or ``n * s``"

msgstr "``s * n`` یا ``n * s``"

msgid "equivalent to adding *s* to itself *n* times"

msgstr "معادل افزودن *s* به خودش *n* بار است"

msgid "(2)(7)"

msgstr "(2)(7)"

msgid "``s[i]``"

msgstr "``s[i]``"

msgid "*i*\\ th item of *s*, origin 0"

msgstr "*i*\\ امین آیتم *s*، مبدأ ۰"

msgid "(3)(8)"

msgstr "(3)(8)"

msgid "``s[i:j]``"

msgstr "``s[i:j]``"

msgid "slice of *s* from *i* to *j*"

msgstr "اسلایسی از *s* از *i* تا *j*"

msgid "(3)(4)"

msgstr "(3)(4)"

msgid "``s[i:j:k]``"

msgstr "``s[i:j:k]``"

msgid "slice of *s* from *i* to *j* with step *k*"

msgstr "اسلایسی از *s* از *i* تا *j* با گام *k*"

msgid "(3)(5)"

msgstr "(3)(5)"

msgid "``len(s)``"

msgstr "``len(s)``"

msgid "length of *s*"

msgstr "طول *s*"

msgid "``min(s)``"

msgstr "``min(s)``"

msgid "smallest item of *s*"

msgstr "کوچک‌ترین آیتم *s*"

msgid "``max(s)``"

msgstr "``max(s)``"

msgid "largest item of *s*"

msgstr "بزرگ‌ترین آیتم *s*"

msgid "Sequences of the same type also support comparisons. In particular, tuples and lists are compared lexicographically by comparing corresponding elements. This means that to compare equal, every element must compare equal and the two sequences must be of the same type and have the same length. (For full details see :ref:`comparisons` in the language reference.)"

msgstr "دنباله‌هایی از یک نوع نیز از مقایسه پشتیبانی می‌کنند. به‌طور خاص، تاپل‌ها و فهرست‌ها با مقایسه‌ی المان‌های متناظر، به‌صورت لغت‌نامه‌ای مقایسه می‌شوند. این بدان معناست که برای برابر بودن در مقایسه، هر المان باید در مقایسه برابر باشد و دو دنباله باید از یک نوع بوده و طول یکسانی داشته باشند. (برای جزئیات کامل به :ref:`مقایسه‌ها <comparisons>` در مرجع زبان رجوع کنید.)"