bisect.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Danial Behzadi <dani.behzi@ubuntu.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Revisto <theRevisto@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-16 12:56+0000\n"
"PO-Revision-Date: 2021-06-28 00:56+0000\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"

msgid ":mod:`!bisect` --- Array bisection algorithm"
msgstr ":mod:`!bisect` --- الگوریتم دو نیمه‌سازی آرایه"

msgid "**Source code:** :source:`Lib/bisect.py`"
msgstr "**کد منبع:** :source:`Lib/bisect.py`"

msgid "This module provides support for maintaining a list in sorted order without having to sort the list after each insertion.  For long lists of items with expensive comparison operations, this can be an improvement over linear searches or frequent resorting."
msgstr "این ماژول پشتیبانی از نگهداری یک فهرست به ترتیب مرتب‌شده بدون نیاز به مرتب‌سازی فهرست پس از هر درج را فراهم می‌کند. برای فهرست‌های طولانی از آیتم‌هایی با عملیات مقایسه پرهزینه، این می‌تواند بهبودی نسبت به جست‌وجوهای خطی یا مرتب‌سازی مجدد مکرر باشد."

msgid "The module is called :mod:`!bisect` because it uses a basic bisection algorithm to do its work.  Unlike other bisection tools that search for a specific value, the functions in this module are designed to locate an insertion point. Accordingly, the functions never call an :meth:`~object.__eq__` method to determine whether a value has been found.  Instead, the functions only call the :meth:`~object.__lt__` method and will return an insertion point between values in an array."
msgstr "این ماژول :mod:`!bisect` نامیده می‌شود، زیرا برای انجام کار خود از یک الگوریتم ساده‌ی دو نیم‌سازی (bisection) استفاده می‌کند. برخلاف سایر ابزارهای دو نیم‌سازی که به دنبال یک مقدار مشخص می‌گردند، توابع این ماژول برای یافتن یک نقطه‌ی درج طراحی شده‌اند. بر همین اساس، این توابع هرگز متد :meth:`~object.__eq__` را برای تعیین اینکه آیا مقداری پیدا شده است فراخوانی نمی‌کنند. در عوض، توابع فقط متد :meth:`~object.__lt__` را فراخوانی می‌کنند و یک نقطه‌ی درج بین مقادیر یک آرایه برمی‌گردانند."

msgid "The functions in this module are not thread-safe. If multiple threads concurrently use :mod:`!bisect` functions on the same sequence, this may result in undefined behaviour. Likewise, if the provided sequence is mutated by a different thread while a :mod:`!bisect` function is operating on it, the result is undefined. For example, using :py:func:`~bisect.insort_left` on the same list from multiple threads may result in the list becoming unsorted."
msgstr "توابع این ماژول نخ‌ایمن نیستند. اگر چندین نخ به‌طور همزمان از توابع :mod:`!bisect` روی یک دنباله استفاده کنند، ممکن است منجر به رفتار تعریف‌نشده شود. به همین ترتیب، اگر در حین کار یک تابع :mod:`!bisect` روی دنباله ارائه‌شده، آن دنباله توسط نخ دیگری تغییر کند، نتیجه تعریف‌نشده است. برای مثال، استفاده از :py:func:`~bisect.insort_left` روی یک فهرست مشترک از چندین نخ ممکن است باعث شود فهرست نامرتب شود."

msgid "The following functions are provided:"
msgstr "توابع زیر ارائه شده‌اند:"

msgid "Locate the insertion point for *x* in *a* to maintain sorted order. The parameters *lo* and *hi* may be used to specify a subset of the list which should be considered; by default the entire list is used.  If *x* is already present in *a*, the insertion point will be before (to the left of) any existing entries.  The return value is suitable for use as the first parameter to ``list.insert()`` assuming that *a* is already sorted."
msgstr "نقطه درج برای *x* در *a* را برای حفظ ترتیب مرتب‌شده پیدا کنید. می‌توانید از پارامترهای *lo* و *hi* برای مشخص کردن زیرمجموعه‌ای از فهرست که باید در نظر گرفته شود استفاده کنید؛ به‌طور پیش‌فرض، از کل فهرست استفاده می‌شود. اگر *x* از قبل در *a* موجود باشد، نقطه درج پیش از (در سمت چپ) هر ورودی موجود خواهد بود. مقدار برگشتی برای استفاده به‌عنوان اولین پارامتر ``list.insert()`` مناسب است، با فرض اینکه *a* از قبل مرتب‌شده باشد."

msgid "The returned insertion point *ip* partitions the array *a* into two slices such that ``all(elem < x for elem in a[lo : ip])`` is true for the left slice and ``all(elem >= x for elem in a[ip : hi])`` is true for the right slice."
msgstr "نقطه درج بازگشتی *ip* آرایه *a* را به دو اسلایس تقسیم می‌کند، به‌گونه‌ای که ``all(elem < x for elem in a[lo : ip])`` برای اسلایس چپ درست است و ``all(elem >= x for elem in a[ip : hi])`` برای اسلایس راست درست است."

msgid "*key* specifies a :term:`key function` of one argument that is used to extract a comparison key from each element in the array.  To support searching complex records, the key function is not applied to the *x* value."
msgstr "*key* یک :term:`تابع کلید <key function>` با یک آرگومان را تعیین می‌کند که برای استخراج یک کلید مقایسه از هر عنصر آرایه استفاده می‌شود. برای پشتیبانی از جستجوی رکوردهای پیچیده، تابع کلید بر مقدار *x* اعمال نمی‌شود."

msgid "If *key* is ``None``, the elements are compared directly and no key function is called."
msgstr "اگر *key* برابر ``None`` باشد، عناصر به‌طور مستقیم مقایسه می‌شوند و هیچ تابع کلیدی فراخوانی نمی‌شود."

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

msgid "Similar to :py:func:`~bisect.bisect_left`, but returns an insertion point which comes after (to the right of) any existing entries of *x* in *a*."
msgstr "مشابه :py:func:`~bisect.bisect_left`، اما نقطه درجی را برمی‌گرداند که پس از (در سمت راست) هر آیتم موجود از *x* در *a* قرار دارد."

msgid "The returned insertion point *ip* partitions the array *a* into two slices such that ``all(elem <= x for elem in a[lo : ip])`` is true for the left slice and ``all(elem > x for elem in a[ip : hi])`` is true for the right slice."
msgstr "نقطه‌ی درج برگردانده‌شده *ip* آرایه *a* را به دو اسلایس تقسیم می‌کند، به‌طوری که ``all(elem <= x for elem in a[lo : ip])`` برای اسلایس چپ درست است و ``all(elem > x for elem in a[ip : hi])`` برای اسلایس راست درست است."

msgid "Insert *x* in *a* in sorted order."
msgstr "*x* را در *a* با ترتیب مرتب‌شده درج کنید."

msgid "This function first runs :py:func:`~bisect.bisect_left` to locate an insertion point. Next, it runs the :meth:`~sequence.insert` method on *a* to insert *x* at the appropriate position to maintain sort order."
msgstr "این تابع ابتدا :py:func:`~bisect.bisect_left` را برای یافتن محل درج اجرا می‌کند. سپس، متد :meth:`~sequence.insert` را روی *a* اجرا می‌کند تا *x* را در جایگاه مناسب برای حفظ ترتیب مرتب‌سازی درج کند."

msgid "To support inserting records in a table, the *key* function (if any) is applied to *x* for the search step but not for the insertion step."
msgstr "برای پشتیبانی از درج رکوردها در یک جدول، تابع *key* (در صورت وجود) برای مرحله جست‌وجو به *x* اعمال می‌شود، اما برای مرحله درج اعمال نمی‌شود."

msgid "Keep in mind that the *O*\\ (log *n*) search is dominated by the slow *O*\\ (*n*) insertion step."
msgstr "در نظر داشته باشید که جستجوی *O*\\ (log *n*) تحت‌الشعاع گام کند درج *O*\\ (*n*) قرار می‌گیرد."

msgid "Similar to :py:func:`~bisect.insort_left`, but inserting *x* in *a* after any existing entries of *x*."
msgstr "مشابه :py:func:`~bisect.insort_left`، اما *x* را پس از هر آیتم موجود از *x* در *a* درج می‌کند."

msgid "This function first runs :py:func:`~bisect.bisect_right` to locate an insertion point. Next, it runs the :meth:`~sequence.insert` method on *a* to insert *x* at the appropriate position to maintain sort order."
msgstr "این تابع ابتدا :py:func:`~bisect.bisect_right` را برای یافتن نقطه درج اجرا می‌کند. سپس، متد :meth:`~sequence.insert` را روی *a* اجرا می‌کند تا *x* را در جایگاه مناسب برای حفظ ترتیب مرتب‌سازی درج کند."

msgid "Performance Notes"
msgstr "یادداشت‌های عملکرد"

msgid "When writing time sensitive code using *bisect()* and *insort()*, keep these thoughts in mind:"
msgstr "هنگام نوشتن کد حساس به زمان با استفاده از *bisect()* و *insort()*، این نکات را در نظر داشته باشید:"

msgid "Bisection is effective for searching ranges of values. For locating specific values, dictionaries are more performant."
msgstr "جستجوی دودویی برای جستجوی بازه‌هایی از مقادیر مؤثر است. برای یافتن مقادیر مشخص، دیکشنری‌ها کارآمدتر هستند."

msgid "The *insort()* functions are *O*\\ (*n*) because the logarithmic search step is dominated by the linear time insertion step."
msgstr "توابع *insort()* از مرتبه‌ی *O*\\ (*n*) هستند، زیرا مرحله‌ی جستجوی لگاریتمی تحت سلطه‌ی مرحله‌ی درج با زمان خطی است."

msgid "The search functions are stateless and discard key function results after they are used.  Consequently, if the search functions are used in a loop, the key function may be called again and again on the same array elements. If the key function isn't fast, consider wrapping it with :py:deco:`functools.cache` to avoid duplicate computations.  Alternatively, consider searching an array of precomputed keys to locate the insertion point (as shown in the examples section below)."
msgstr "توابع جستجو فاقد وضعیت هستند و نتایج تابع کلید را پس از استفاده دور می‌اندازند. در نتیجه، اگر از توابع جستجو در یک حلقه استفاده شود، ممکن است تابع کلید بارها و بارها برای همان عناصر آرایه فراخوانی شود. اگر تابع کلید سریع نیست، استفاده از :py:deco:`functools.cache` به‌عنوان پوشش برای آن را در نظر بگیرید تا از محاسبات تکراری اجتناب شود. به‌عنوان جایگزین، در نظر بگیرید که در یک آرایه از کلیدهای از پیش محاسبه‌شده جستجو کنید تا نقطه درج را بیابید (همان‌طور که در بخش مثال‌های زیر نشان داده شده است)."

msgid "`Sorted Collections <https://grantjenks.com/docs/sortedcollections/>`_ is a high performance module that uses *bisect* to managed sorted collections of data."
msgstr "`Sorted Collections <https://grantjenks.com/docs/sortedcollections/>`_ یک ماژول با کارایی بالا است که از *bisect* برای مدیریت مجموعه‌های مرتب‌شده از داده استفاده می‌کند."

msgid "The `SortedCollection recipe <https://code.activestate.com/recipes/577197-sortedcollection/>`_ uses bisect to build a full-featured collection class with straight-forward search methods and support for a key-function.  The keys are precomputed to save unnecessary calls to the key function during searches."
msgstr "`SortedCollection recipe <https://code.activestate.com/recipes/577197-sortedcollection/>`_ از bisect برای ساختن یک کلاس مجموعه با امکانات کامل، همراه با متدهای جستجوی ساده و مستقیم و پشتیبانی از تابع کلید استفاده می‌کند. کلیدها از پیش محاسبه می‌شوند تا از فراخوانی‌های غیرضروری تابع کلید در حین جستجوها جلوگیری شود."

msgid "Searching Sorted Lists"
msgstr "جستجو در فهرست‌های مرتب‌شده"

msgid "The above `bisect functions`_ are useful for finding insertion points but can be tricky or awkward to use for common searching tasks. The following five functions show how to transform them into the standard lookups for sorted lists::"
msgstr "توابع `bisect functions`_ فوق برای یافتن نقاط درج مفید هستند، اما ممکن است استفاده از آن‌ها برای کارهای جستجوی رایج دشوار یا نامناسب باشد. پنج تابع زیر نشان می‌دهند که چگونه می‌توان آن‌ها را به جستجوهای استاندارد برای فهرست‌های مرتب تبدیل کرد::"

msgid ""
"def index(a, x):\n"
"    'Locate the leftmost value exactly equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a) and a[i] == x:\n"
"        return i\n"
"    raise ValueError\n"
"\n"
"def find_lt(a, x):\n"
"    'Find rightmost value less than x'\n"
"    i = bisect_left(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_le(a, x):\n"
"    'Find rightmost value less than or equal to x'\n"
"    i = bisect_right(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_gt(a, x):\n"
"    'Find leftmost value greater than x'\n"
"    i = bisect_right(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError\n"
"\n"
"def find_ge(a, x):\n"
"    'Find leftmost item greater than or equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError"
msgstr ""
"def index(a, x):\n"
"    'Locate the leftmost value exactly equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a) and a[i] == x:\n"
"        return i\n"
"    raise ValueError\n"
"\n"
"def find_lt(a, x):\n"
"    'Find rightmost value less than x'\n"
"    i = bisect_left(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_le(a, x):\n"
"    'Find rightmost value less than or equal to x'\n"
"    i = bisect_right(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_gt(a, x):\n"
"    'Find leftmost value greater than x'\n"
"    i = bisect_right(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError\n"
"\n"
"def find_ge(a, x):\n"
"    'Find leftmost item greater than or equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError"

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

msgid "The :py:func:`~bisect.bisect` function can be useful for numeric table lookups. This example uses :py:func:`~bisect.bisect` to look up a letter grade for an exam score (say) based on a set of ordered numeric breakpoints: 90 and up is an 'A', 80 to 89 is a 'B', and so on::"
msgstr "تابع :py:func:`~bisect.bisect` می‌تواند برای جستجو در جدول‌های عددی مفید باشد. این مثال از :py:func:`~bisect.bisect` برای جستجوی نمره‌ی الفبایی یک نمره‌ی امتحان (مثلاً) بر اساس مجموعه‌ای از نقاط شکست عددی مرتب‌شده استفاده می‌کند: ۹۰ به بالا 'A' است، ۸۰ تا ۸۹ 'B' است، و به همین ترتیب::"

msgid ""
">>> def grade(score):\n"
"...     i = bisect([60, 70, 80, 90], score)\n"
"...     return \"FDCBA\"[i]\n"
"...\n"
">>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]\n"
"['F', 'A', 'C', 'C', 'B', 'A', 'A']"
msgstr ""
">>> def grade(score):\n"
"...     i = bisect([60, 70, 80, 90], score)\n"
"...     return \"FDCBA\"[i]\n"
"...\n"
">>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]\n"
"['F', 'A', 'C', 'C', 'B', 'A', 'A']"

msgid "The :py:func:`~bisect.bisect` and :py:func:`~bisect.insort` functions also work with lists of tuples.  The *key* argument can serve to extract the field used for ordering records in a table::"
msgstr "توابع :py:func:`~bisect.bisect` و :py:func:`~bisect.insort` همچنین با فهرست‌هایی از تاپل‌ها کار می‌کنند. آرگومان *key* می‌تواند برای استخراج فیلدی که برای مرتب‌سازی رکوردها در یک جدول استفاده می‌شود، به‌کار رود::"

msgid ""
">>> from collections import namedtuple\n"
">>> from operator import attrgetter\n"
">>> from bisect import bisect, insort\n"
">>> from pprint import pprint\n"
"\n"
">>> Movie = namedtuple('Movie', ('name', 'released', 'director'))\n"
"\n"
">>> movies = [\n"
"...     Movie('Jaws', 1975, 'Spielberg'),\n"
"...     Movie('Titanic', 1997, 'Cameron'),\n"
"...     Movie('The Birds', 1963, 'Hitchcock'),\n"
"...     Movie('Aliens', 1986, 'Cameron')\n"
"... ]\n"
"\n"
">>> # Find the first movie released after 1960\n"
">>> by_year = attrgetter('released')\n"
">>> movies.sort(key=by_year)\n"
">>> movies[bisect(movies, 1960, key=by_year)]\n"
"Movie(name='The Birds', released=1963, director='Hitchcock')\n"
"\n"
">>> # Insert a movie while maintaining sort order\n"
">>> romance = Movie('Love Story', 1970, 'Hiller')\n"
">>> insort(movies, romance, key=by_year)\n"
">>> pprint(movies)\n"
"[Movie(name='The Birds', released=1963, director='Hitchcock'),\n"
" Movie(name='Love Story', released=1970, director='Hiller'),\n"
" Movie(name='Jaws', released=1975, director='Spielberg'),\n"
" Movie(name='Aliens', released=1986, director='Cameron'),\n"
" Movie(name='Titanic', released=1997, director='Cameron')]"
msgstr ""
">>> from collections import namedtuple\n"
">>> from operator import attrgetter\n"
">>> from bisect import bisect, insort\n"
">>> from pprint import pprint\n"
"\n"
">>> Movie = namedtuple('Movie', ('name', 'released', 'director'))\n"
"\n"
">>> movies = [\n"
"...     Movie('Jaws', 1975, 'Spielberg'),\n"
"...     Movie('Titanic', 1997, 'Cameron'),\n"
"...     Movie('The Birds', 1963, 'Hitchcock'),\n"
"...     Movie('Aliens', 1986, 'Cameron')\n"
"... ]\n"
"\n"
">>> # Find the first movie released after 1960\n"
">>> by_year = attrgetter('released')\n"
">>> movies.sort(key=by_year)\n"
">>> movies[bisect(movies, 1960, key=by_year)]\n"
"Movie(name='The Birds', released=1963, director='Hitchcock')\n"
"\n"
">>> # Insert a movie while maintaining sort order\n"
">>> romance = Movie('Love Story', 1970, 'Hiller')\n"
">>> insort(movies, romance, key=by_year)\n"
">>> pprint(movies)\n"
"[Movie(name='The Birds', released=1963, director='Hitchcock'),\n"
" Movie(name='Love Story', released=1970, director='Hiller'),\n"
" Movie(name='Jaws', released=1975, director='Spielberg'),\n"
" Movie(name='Aliens', released=1986, director='Cameron'),\n"
" Movie(name='Titanic', released=1997, director='Cameron')]"

msgid "If the key function is expensive, it is possible to avoid repeated function calls by searching a list of precomputed keys to find the index of a record::"
msgstr "اگر تابع کلید پرهزینه باشد، می‌توان با جستجو در فهرستی از کلیدهای از پیش محاسبه‌شده برای یافتن اندیس یک رکورد، از فراخوانی‌های مکرر تابع اجتناب کرد::"

msgid ""
">>> data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)]\n"
">>> data.sort(key=lambda r: r[1])       # Or use operator.itemgetter(1).\n"
">>> keys = [r[1] for r in data]         # Precompute a list of keys.\n"
">>> data[bisect_left(keys, 0)]\n"
"('black', 0)\n"
">>> data[bisect_left(keys, 1)]\n"
"('blue', 1)\n"
">>> data[bisect_left(keys, 5)]\n"
"('red', 5)\n"
">>> data[bisect_left(keys, 8)]\n"
"('yellow', 8)"
msgstr ""
">>> data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)]\n"
">>> data.sort(key=lambda r: r[1])       # Or use operator.itemgetter(1).\n"
">>> keys = [r[1] for r in data]         # Precompute a list of keys.\n"
">>> data[bisect_left(keys, 0)]\n"
"('black', 0)\n"
">>> data[bisect_left(keys, 1)]\n"
"('blue', 1)\n"
">>> data[bisect_left(keys, 5)]\n"
"('red', 5)\n"
">>> data[bisect_left(keys, 8)]\n"
"('yellow', 8)"