time-complexity.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-01 14:41+0330\n"
"PO-Revision-Date: 2026-09-19 20:08+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"

msgid "Time complexity of operations on built-in types"
msgstr "پیچیدگی زمانی عملیات‌ها روی انواع توکار"

msgid "This page documents the time complexity of various operations on built-in types in CPython. Other Python implementations may have different performance characteristics. Additionally, the listed costs assume exact built-in types, as instances of subclasses may have different costs."
msgstr "این صفحه پیچیدگی زمانی عملیات‌های مختلف روی انواع توکار در سی‌پایتون را مستند می‌کند. پیاده‌سازی‌های دیگر پایتون ممکن است ویژگی‌های عملکردی متفاوتی داشته باشند. علاوه بر این، هزینه‌های لیست‌شده انواع توکار دقیق را فرض می‌کنند، زیرا نمونه‌های زیرکلاس‌ها ممکن است هزینه‌های متفاوتی داشته باشند."

msgid "We use |big O notation|_ to describe how the running time of an operation grows with the size of its inputs. Unless stated otherwise, *n* denotes the number of elements currently in the container, and *k* is the value of a numeric parameter, such as an index or a repeat count."
msgstr "ما از |big O notation|_ برای توصیف نحوه رشد زمان اجرای یک عملیات با اندازه ورودی‌های آن استفاده می‌کنیم. مگر اینکه خلاف آن ذکر شده باشد، *n* تعداد المان‌های فعلی در ظرف را نشان می‌دهد، و *k* مقدار یک پارامتر عددی است، مانند یک اندیس یا تعداد تکرار."

msgid ":class:`!list`"
msgstr ":class:`!list`"

msgid "Lists are mutable sequences; for more detail on the implementation see :ref:`how-are-lists-implemented`. The largest costs come from growing beyond the current allocation size (because everything must move), or from inserting or deleting somewhere near the beginning (because everything after that must move). If you need to add or remove at both ends, consider using a :class:`collections.deque` instead."
msgstr "فهرست‌ها دنباله‌های تغییرپذیر هستند؛ برای جزئیات بیشتر در مورد پیاده‌سازی به :ref:`how-are-lists-implemented` مراجعه کنید. بزرگترین هزینه‌ها ناشی از رشد فراتر از اندازه تخصیص فعلی است (چون همه چیز باید جابجا شود)، یا از درج یا حذف در جایی نزدیک به ابتدا (چون همه چیز بعد از آن باید جابجا شود). اگر نیاز به اضافه یا حذف در هر دو طرف دارید، به جای آن از :class:`collections.deque` استفاده کنید."

msgid "Operation"
msgstr "عملیات"

msgid "Complexity"
msgstr "پیچیدگی"

msgid "Copy (``l.copy()``)"
msgstr "کپی (``l.copy()``)"

msgid "*O*\\ (*n*)"
msgstr "*O*\\ (*n*)"

msgid "Append (``l.append(x)``) [1]_"
msgstr "افزودن (``l.append(x)``) [1]_"

msgid "*O*\\ (1)"
msgstr "*O*\\ (1)"

msgid "Pop (``l.pop(k)``) [1]_ [2]_"
msgstr "حذف (``l.pop(k)``) [1]_ [2]_"

msgid "*O*\\ (*n* - *k*)"
msgstr "*O*\\ (*n* - *k*)"

msgid "Insert (``l.insert(k, x)``) [1]_ [2]_"
msgstr "درج (``l.insert(k, x)``) [1]_ [2]_"

msgid "Get item (``l[k]``)"
msgstr "دریافت آیتم (``l[k]``)"

msgid "Set item (``l[k] = x``)"
msgstr "تنظیم آیتم (``l[k] = x``)"

msgid "Delete item (``del l[k]``) [2]_"
msgstr "حذف آیتم (``del l[k]``) [2]_"

msgid "Iteration"
msgstr "پیمایش"

msgid "Get slice (``l[i:j]``)"
msgstr "دریافت اسلایس (``l[i:j]``)"

msgid "*O*\\ (*j* - *i*)"
msgstr "*O*\\ (*j* - *i*)"

msgid "Set slice (``l[i:j] = t``) [1]_"
msgstr "تنظیم اسلایس (``l[i:j] = t``) [1]_"

msgid "*O*\\ (*j* - *i*) if len(*t*) == *j* - *i*, otherwise *O*\\ (*n* - *i* + len(*t*))"
msgstr "*O*\\ (*j* - *i*) اگر len(*t*) == *j* - *i*، در غیر این صورت *O*\\ (*n* - *i* + len(*t*))"

msgid "Delete slice (``del l[i:j]``)"
msgstr "حذف اسلایس (``del l[i:j]``)"

msgid "*O*\\ (*n* - *i*)"
msgstr "*O*\\ (*n* - *i*)"

msgid "Extend (``l.extend(t)``) [1]_ [3]_"
msgstr "گسترش (``l.extend(t)``) [1]_ [3]_"

msgid "*O*\\ (len(*t*))"
msgstr "*O*\\ (len(*t*))"

msgid "Sort (``l.sort()``) [4]_"
msgstr "مرتب‌سازی (``l.sort()``) [4]_"

msgid "*O*\\ (*n* log *n*)"
msgstr "*O*\\ (*n* log *n*)"

msgid "Concatenate (``l1 + l2``)"
msgstr "الحاق (``l1 + l2``)"

msgid "*O*\\ (len(*l1*) + len(*l2*))"
msgstr "*O*\\ (len(*l1*) + len(*l2*))"

msgid "Multiply (``l * k``)"
msgstr "ضرب (``l * k``)"

msgid "*O*\\ (*nk*)"
msgstr "*O*\\ (*nk*)"

msgid "``x in l``"
msgstr "``x in l``"

msgid "``min(l)``, ``max(l)``"
msgstr "``min(l)``, ``max(l)``"

msgid "Get length (``len(l)``) [5]_"
msgstr "بدست آوردن طول (``len(l)``) [5]_"

msgid ":class:`!tuple`"
msgstr ":class:`!tuple`"

msgid "A :class:`tuple` is an :term:`immutable` sequence. Because a tuple can never change, there are no insertion or deletion costs, and making a copy simply returns the same object, so is constant time (*O*\\ (1))."
msgstr "یک :class:`tuple` یک :term:`تغییرناپذیر <immutable>` دنباله است. از آنجا که یک تاپل هرگز تغییر نمی‌کند، هزینه‌ی درج یا حذف وجود ندارد، و ایجاد یک کپی صرفاً همان شیء را بازمی‌گرداند، بنابراین زمان ثابت است (*O*\\ (1))."

msgid "Copy (``tuple(t)``)"
msgstr "کپی (``tuple(t)``)"

msgid "Get item (``t[k]``)"
msgstr "دریافت آیتم (``t[k]``)"

msgid "Get slice (``t[i:j]``)"
msgstr "دریافت اسلایس (``t[i:j]``)"

msgid "Concatenate (``t1 + t2``)"
msgstr "الحاق (``t1 + t2``)"

msgid "*O*\\ (len(*t1*) + len(*t2*))"
msgstr "*O*\\ (len(*t1*) + len(*t2*))"

msgid "Multiply (``t * k``)"
msgstr "ضرب (``t * k``)"

msgid "``x in t``"
msgstr "``x in t``"

msgid "``min(t)``, ``max(t)``"
msgstr "``min(t)``, ``max(t)``"

msgid "Get length (``len(t)``) [5]_"
msgstr "دریافت طول (``len(t)``) [5]_"

msgid ":class:`!dict`, :class:`!frozendict`"
msgstr ":class:`!dict`, :class:`!frozendict`"

msgid "The times listed for dict objects are average-case times, as they assume the hash function for the objects is sufficiently robust to make collisions uncommon. They also assume the keys are well-distributed among the set of possible keys. In the worst case, when every key hashes to the same value, each of the *O*\\ (1) operations below instead takes *O*\\ (*n*) time. They also assume that hashing and comparing a key is *O*\\ (1). For more detail on the implementation, see :ref:`how-are-dictionaries-implemented`."
msgstr "زمان‌های فهرست‌شده برای شیء‌ها dict زمان‌های حالت‌میانگین هستند، زیرا آن‌ها فرض می‌کنند که تابع هش برای شیء‌ها به‌قدر کافی قوی است تا تصادفات را کم کند. آن‌ها همچنین فرض می‌کنند که کلیدها در میان مجموعه‌ی کلیدهای ممکن به‌خوبی توزیع شده‌اند. در بدترین حالت، وقتی هر کلید به یک مقدار هش می‌شود، هر یک از عملیات‌های *O*\\ (1) در زیر در عوض زمان *O*\\ (*n*) می‌طلبد. آن‌ها همچنین فرض می‌کنند که هش کردن و مقایسه یک کلید *O*\\ (1) است. برای جزئیات بیشتر در مورد پیاده‌سازی، به :ref:`how-are-dictionaries-implemented` مراجعه کنید."

msgid "A :class:`frozendict` is immutable, so it does not support setting, deleting, or updating items. The other operations below apply to it at the same costs."
msgstr "یک :class:`frozendict` تغییرناپذیر است، بنابراین تنظیم، حذف یا به‌روزرسانی آیتم‌ها را پشتیبانی نمی‌کند. سایر عملیات زیر با همان هزینه‌ها روی آن اعمال می‌شوند."

msgid "``key in d``"
msgstr "``key in d``"

msgid "Copy (``d.copy()``) [6]_ [7]_"
msgstr "کپی (``d.copy()``) [6]_ [7]_"

msgid "Get item (``d[key]``, ``d.get(key)``)"
msgstr "دریافت آیتم (``d[key]``, ``d.get(key)``)"

msgid "Set item (``d[key] = value``) [1]_"
msgstr "تنظیم آیتم (``d[key] = value``) [1]_"

msgid "Delete item (``del d[key]``, ``d.pop(key)``)"
msgstr "حذف آیتم (``del d[key]``, ``d.pop(key)``)"

msgid "Update (``d.update(t)``, ``d |= t``) [1]_ [3]_ [7]_"
msgstr "به‌روزرسانی (``d.update(t)``, ``d |= t``) [1]_ [3]_ [7]_"

msgid "Iteration [7]_"
msgstr "پیمایش [7]_"

msgid "Get length (``len(d)``) [5]_"
msgstr "دریافت طول (``len(d)``) [5]_"

msgid ":class:`!set`, :class:`!frozenset`"
msgstr ":class:`!set`, :class:`!frozenset`"

msgid "See :class:`dict` as the :class:`set` and :class:`frozenset` implementations are similar, and the same caveats apply. In the worst case, *O*\\ (1) operations instead take *O*\\ (*n*) time, and operations that look up every element degrade accordingly."
msgstr "از :class:`dict` ببینید زیرا پیاده‌سازی‌های :class:`set` و :class:`frozenset` مشابه هستند، و همان احتیاط‌ها اعمال می‌شوند. در بدترین حالت، عملیات‌های *O*\\ (1) به جای آن زمان *O*\\ (*n*) می‌برند، و عملیات‌هایی که به جستجوی هر المان می‌پردازند به‌طوری مشابه کاهش می‌یابند."

msgid "A :class:`frozenset` is :term:`immutable`, so it does not support adding, discarding, or the in-place update operations. The others below apply to it at the same costs."
msgstr "یک :class:`frozenset` :term:`تغییرناپذیر <immutable>` است، بنابراین از افزودن، حذف، یا عملیات‌های به‌روزرسانی درجا پشتیبانی نمی‌کند. موارد دیگر در پایین با همان هزینه‌ها بر آن اعمال می‌شوند."

msgid "``x in s``"
msgstr "``x in s``"

msgid "Copy (``s.copy()``) [6]_ [7]_"
msgstr "کپی (``s.copy()``) [6]_ [7]_"

msgid "Add (``s.add(x)``) [1]_"
msgstr "افزودن (``s.add(x)``) [1]_"

msgid "Discard (``s.discard(x)``, ``s.remove(x)``)"
msgstr "حذف (``s.discard(x)``, ``s.remove(x)``)"

msgid "Union (``s1 | s2``, ``s1.union(s2)``) [7]_"
msgstr "اتحاد (``s1 | s2``, ``s1.union(s2)``) [7]_"

msgid "*O*\\ (len(*s1*) + len(*s2*))"
msgstr "*O*\\ (len(*s1*) + len(*s2*))"

msgid "Update (``s1 |= s2``, ``s1.update(s2)``) [1]_ [7]_"
msgstr "به‌روزرسانی (``s1 |= s2``, ``s1.update(s2)``) [1]_ [7]_"

msgid "*O*\\ (len(*s2*))"
msgstr "*O*\\ (len(*s2*))"

msgid "Intersection (``s1 & s2``, ``s1.intersection(s2)``) [7]_ [8]_"
msgstr "تقاطع (``s1 & s2``, ``s1.intersection(s2)``) [7]_ [8]_"

msgid "*O*\\ (min(len(*s1*), len(*s2*)))"
msgstr "*O*\\ (min(len(*s1*), len(*s2*)))"

msgid "Intersection update (``s1 &= s2``, ``s1.intersection_update(s2)``) [1]_ [7]_ [8]_"
msgstr "به‌روزرسانی تقاطع (``s1 &= s2``, ``s1.intersection_update(s2)``) [1]_ [7]_ [8]_"

msgid "Difference (``s1 - s2``, ``s1.difference(s2)``) [7]_ [9]_"
msgstr "تفاضل (``s1 - s2``, ``s1.difference(s2)``) [7]_ [9]_"

msgid "*O*\\ (len(*s1*))"
msgstr "*O*\\ (len(*s1*))"

msgid "Difference update (``s1 -= s2``, ``s1.difference_update(s2)``) [1]_ [7]_ [8]_"
msgstr "به‌روزرسانی تفاضل (``s1 -= s2``, ``s1.difference_update(s2)``) [1]_ [7]_ [8]_"

msgid "Symmetric difference (``s1 ^ s2``, ``s1.symmetric_difference(s2)``) [7]_"
msgstr "تفاضل متقارن (``s1 ^ s2``, ``s1.symmetric_difference(s2)``) [7]_"

msgid "Symmetric difference update (``s1 ^= s2``, ``s1.symmetric_difference_update(s2)``) [1]_ [7]_"
msgstr "به‌روزرسانی تفاضل متقارن (``s1 ^= s2``, ``s1.symmetric_difference_update(s2)``) [1]_ [7]_"

msgid "Get length (``len(s)``) [5]_"
msgstr "دریافت طول (``len(s)``) [5]_"

msgid ":class:`!str`, :class:`!bytes`, :class:`!bytearray`"
msgstr ":class:`!str`, :class:`!bytes`, :class:`!bytearray`"

msgid ":class:`str` and :class:`bytes` objects are immutable sequences of characters and bytes, respectively. As with tuples, copying one returns the original object. A :class:`bytearray` is mutable, and additionally supports the mutating operations of :class:`list` (except :meth:`!sort`), at the same costs. However, deleting at the front with ``del`` (``del b[0]``, ``del b[:k]``) only advances the start of the buffer instead of moving the remaining bytes, and is amortized *O*\\ (1)."
msgstr ":class:`str` و :class:`bytes` به‌ترتیب دنباله‌های تغییرناپذیری از نویسه‌ها و بایت‌ها هستند. مانند تاپل‌ها، کپی کردن یکی از آن‌ها همان شیء اصلی را برمی‌گرداند. :class:`bytearray` تغییرپذیر است و علاوه بر این، عملیات تغییر‌دهنده‌ی :class:`list` (به‌جز :meth:`!sort`) را با همان هزینه‌ها پشتیبانی می‌کند. بااین‌حال، حذف از ابتدای آن با ``del`` (``del b[0]``، ``del b[:k]``) فقط ابتدای بافر را جلو می‌برد، به‌جای اینکه بایت‌های باقی‌مانده را جابه‌جا کند، و پیچیدگی آن به‌طور سرشکن *O*\\ (1) است."

msgid "Get item (``s[k]``)"
msgstr "دریافت آیتم (``s[k]``)"

msgid "Get slice (``s[i:j]``)"
msgstr "دریافت اسلایس (``s[i:j]``)"

msgid "Concatenate (``s + t``) [10]_"
msgstr "الحاق (``s + t``) [10]_"

msgid "*O*\\ (len(*s*) + len(*t*))"
msgstr "*O*\\\\ (len(*s*) + len(*t*))"

msgid "Multiply (``s * k``)"
msgstr "ضرب (``s * k``)"

msgid "Substring search (``x in s``, ``s.find(x)``, ``s.index(x)``) [11]_"
msgstr "جستجوی زیررشته (``x in s``، ``s.find(x)``، ``s.index(x)``) [11]_"

msgid "Reverse substring search (``s.rfind(x)``, ``s.rindex(x)``) [11]_ [12]_"
msgstr "جستجوی معکوس زیررشته (``s.rfind(x)``، ``s.rindex(x)``) [11]_ [12]_"

msgid "*O*\\ (*n* × len(*x*))"
msgstr "*O*\\\\ (*n* × len(*x*))"

msgid "Encode or decode [13]_"
msgstr "کدگذاری یا کدگشایی [13]_"

msgid ":class:`!memoryview`"
msgstr ":class:`!memoryview`"

msgid ":class:`memoryview` objects allow Python code to access the internal data of an object that supports the :ref:`buffer protocol <bufferobjects>` without copying. In particular, slicing a memory view returns a new view onto the same buffer."
msgstr "شیء‌های :class:`memoryview` به کد پایتون اجازه می‌دهند تا به داده‌های درونی یک شیء که از :ref:`پروتکل بافر <bufferobjects>` پشتیبانی می‌کند، بدون کپی کردن دسترسی پیدا کنند. به‌ویژه، برش یک نمای حافظه یک نما جدید بر روی همان بافر را برمی‌گرداند."

msgid "Create (``memoryview(obj)``)"
msgstr "ساخت (``memoryview(obj)``)"

msgid "Get item (``v[k]``)"
msgstr "دریافت آیتم (``v[k]``)"

msgid "Get slice (``v[i:j]``)"
msgstr "دریافت اسلایس (``v[i:j]``)"

msgid "Index (``v.index(x)``) [11]_ [14]_"
msgstr "اندیس (``v.index(x)``) [11]_ [14]_"

msgid "Count (``v.count(x)``) [14]_"
msgstr "شمارش (``v.count(x)``) [14]_"

msgid "Convert to bytes (``v.tobytes()``, ``bytes(v)``)"
msgstr "تبدیل به بایت‌ها (``v.tobytes()``, ``bytes(v)``)"

msgid "Get length (``len(v)``) [5]_"
msgstr "دریافت طول (``len(v)``) [5]_"

msgid ":class:`!range`"
msgstr ":class:`!range`"

msgid "A :class:`range` object computes its items on demand from its *start*, *stop* and *step* values, so most operations do not depend on the length of the range."
msgstr "یک شیء :class:`range` آیتم‌های خود را به‌صورت تقاضا‌محور از مقادیر *start*، *stop* و *step* محاسبه می‌کند، بنابراین اکثر عملیات به طول محدوده وابسته نیستند."

msgid "Get item (``r[k]``)"
msgstr "دریافت آیتم (``r[k]``)"

msgid "Get slice (``r[i:j]``)"
msgstr "دریافت اسلایس (``r[i:j]``)"

msgid "``x in r`` [15]_"
msgstr "``x in r`` [15]_"

msgid "Index and count (``r.index(x)``, ``r.count(x)``) [15]_"
msgstr "اندیس و شمارش (``r.index(x)``، ``r.count(x)``) [15]_"

msgid "``min(r)``, ``max(r)``"
msgstr "``min(r)``، ``max(r)``"

msgid "Get length (``len(r)``) [5]_"
msgstr "دریافت طول (``len(r)``) [5]_"

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

msgid "Amortized. An individual operation may occasionally be *O*\\ (*n*) when the underlying storage is resized, but this cost is spread over many operations, depending on the history of the container."
msgstr "سرشکن‌شده. یک عملیات منفرد گاه‌به‌گاه ممکن است *O*\\ (*n*) باشد وقتی ذخیره‌سازی زیرین تغییر اندازه می‌دهد، اما این هزینه بر روی بسیاری از عملیات پخش می‌شود، بسته به تاریخچه‌ی ظرف."

msgid "Popping or deleting the element at index *k* of a list of size *n* shifts all elements after *k* one slot to the left, moving *n* - *k* - 1 elements; inserting at index *k* shifts the elements from *k* onwards one slot to the right, moving *n* - *k* elements. The worst case is index 0, where the whole rest of the list has to be moved; the average case, an index in the middle of the list, takes *O*\\ (*n*/2) = *O*\\ (*n*) operations; and operating at the end of the list moves nothing and is *O*\\ (1)."
msgstr "حذف یا پاپ کردن المان در اندیس *k* از یک فهرست با اندازه *n* باعث می‌شود تمام المان‌های بعد از *k* یک جایگاه به چپ جابجا شوند، که *n* - *k* - ۱ المان را جابجا می‌کند؛ درج در اندیس *k* المان‌های از *k* به بعد را یک جایگاه به راست جابجا می‌کند، که *n* - *k* المان را جابجا می‌کند. بدترین حالت اندیس ۰ است، جایی که کل بقیه‌ی فهرست باید جابجا شود؛ حالت میانگین، یک اندیس در میان فهرست، *O*\\ (*n*/2) = *O*\\ (*n*) عملیات را می‌گیرد؛ و عملیات در انتهای فهرست هیچ‌چیز را جابجا نمی‌کند و *O*\\ (1) است."

msgid "Plus the cost of iterating over *t*, which may be expensive for an arbitrary iterable."
msgstr "علاوه بر هزینه‌ی پیمایش بر روی *t*، که برای یک پیمایش‌پذیر دلخواه می‌تواند پرهزینه باشد."

msgid "This is the worst case scenario. Sorting is adaptive and input that is already sorted or reverse-sorted takes only *O*\\ (*n*) comparisons. See :source:`Objects/listsort.txt` for more information."
msgstr "این بدترین حالت است. مرتب‌سازی سازگار است و ورودی که از قبل مرتب یا برعکس‌مرتب شده باشد، تنها *O*\\ (*n*) مقایسه می‌طلبد. برای اطلاعات بیشتر به :source:`Objects/listsort.txt` مراجعه کنید."

msgid "The number of elements is stored in the object, so ``len()`` does not need to count them."
msgstr "تعداد المان‌ها در شیء ذخیره شده است، بنابراین ``len()`` نیازی به شمارش آن‌ها ندارد."

msgid "Copying a :class:`frozendict` or a :class:`frozenset` is *O*\\ (1) as it returns the original object."
msgstr "کپی کردن یک :class:`frozendict` یا :class:`frozenset` از مرتبه‌ی *O*\\ (1) است؛ زیرا شیء اصلی را برمی‌گرداند."

msgid "These operations scan the container's internal hash table, which is not shrunk when elements are removed. After removing most elements, they still take time proportional to the container's former size, until a later insertion triggers a resize."
msgstr "این عملیات‌ها جدول هش داخلی ظرف را اسکن می‌کنند، که وقتی المان‌ها حذف می‌شوند کوچک نمی‌شود. پس از حذف اکثر المان‌ها، آن‌ها همچنان زمان متناسب با اندازه‌ی قبلی ظرف را می‌طلبد، تا زمانی که یک درج بعدی باعث تغییر اندازه شود."

msgid "*O*\\ (len(*t*)) if *t* is not a set."
msgstr "*O*\\ (len(*t*)) اگر *t* یک مجموعه نباشد."

msgid "*O*\\ (len(*s*) + len(*t*)) if *t* is not a set."
msgstr "*O*\\ (len(*s*) + len(*t*)) اگر *t* یک مجموعه نباشد."

msgid "Each concatenation builds a new object, so building a string by concatenating many pieces in a loop is quadratic in the total length. See the :ref:`note on concatenating immutable sequences <typesseq-repeated-concatenation>` for alternatives."
msgstr "هر الحاق یک شیء جدید می‌سازد، بنابراین ساخت یک رشته با الحاق قطعات زیاد در یک حلقه از مرتبه درجه دوم نسبت به طول کل است. به :ref:`یادداشت درباره الحاق توالی‌های غیرقابل‌تغییر <typesseq-repeated-concatenation>` برای گزینه‌های جایگزین مراجعه کنید."

msgid "With *start* and *end* arguments, *n* is the length of the region searched rather than of *s*, and unlike slicing nothing is copied."
msgstr "با آرگومان‌های *start* و *end*، *n* طول منطقه‌ی جستجو شده است نه طول *s*، و برخلاف برش‌گیری هیچ‌چیز کپی نمی‌شود."

msgid "This is the worst case. Reverse searches are *O*\\ (*n*) on typical input. Forward searches instead use a more elaborate algorithm with a linear worst case, described in :source:`Objects/stringlib/stringlib_find_two_way_notes.txt`."
msgstr "این بدترین حالت است. جستجوهای معکوس بر روی ورودی معمولی *O*\\ (*n*) هستند. جستجوهای رو به جلو در عوض از یک الگوریتم پیچیده‌تر با بدترین حالت خطی استفاده می‌کنند، که در :source:`Objects/stringlib/stringlib_find_two_way_notes.txt` توصیف شده است."

msgid "This assumes a codec that does a constant amount of work per character."
msgstr "این یک کُدک را فرض می‌کند که برای هر نویسه مقدار ثابتی از کار انجام می‌دهد."

msgid "These unpack and compare each element individually, so they are much slower than the equivalent :class:`bytes` methods."
msgstr "این‌ها هر المان را به‌صورت جداگانه باز می‌کنند و مقایسه می‌کنند، بنابراین بسیار کندتر از متدهای معادل :class:`bytes` هستند."

msgid "Assuming :class:`int` or :class:`bool` arguments. For other types, the range is searched like any other sequence in *O*\\ (*n*) time."
msgstr "با فرض آرگومان‌های :class:`int` یا :class:`bool`. برای سایر نوع‌ها، محدوده مانند هر دنباله‌ی دیگر در زمان *O*\\ (*n*) جستجو می‌شود."

#~ msgid ":class:`!dict`"
#~ msgstr ":class:`!dict`"

#~ msgid "Copy (``d.copy()``) [7]_"
#~ msgstr "کپی (``d.copy()``) [7]_"