introduction.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:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-07-25 12:59+0330\n"
"PO-Revision-Date: 2026-08-13 08:51+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/revisto/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

#: ../../tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "معرفی غیررسمی پایتون"

#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"در مثال‌های زیر، ورودی و خروجی با وجود یا نبود اعلان‌ها (:term:`>>>` و "
":term:`...`) از یکدیگر متمایز می‌شوند: برای تکرار مثال، باید هر چیزی را که "
"پس از اعلان ظاهر می‌شود، زمانی که اعلان نمایش داده می‌شود، تایپ کنید؛ خط‌هایی "
"که با اعلان شروع نمی‌شوند، خروجی مفسر هستند. توجه کنید که یک اعلان ثانویه که "
"در یک مثال به‌تنهایی در یک خط قرار دارد، به این معنی است که باید یک خط خالی "
"تایپ کنید؛ این مورد برای پایان دادن به یک دستور چندخطی استفاده می‌شود."

#: ../../tutorial/introduction.rst:16
msgid ""
"You can use the \"Copy\" button (it appears in the upper-right corner when "
"hovering over or tapping a code example), which strips prompts and omits "
"output, to copy and paste the input lines into your interpreter."
msgstr ""
"می‌توانید از دکمهٔ \"Copy\" استفاده کنید (این دکمه هنگام قرار گرفتن نشانگر روی "
"یک مثال کد یا لمس کردن آن، در گوشهٔ بالا-راست ظاهر می‌شود) که اعلان‌ها را حذف "
"می‌کند و خروجی را کنار می‌گذارد، تا خط‌های ورودی را کپی کرده و در مفسر خود "
"جای‌گذاری کنید."

#: ../../tutorial/introduction.rst:22
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line.  A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal.  A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"بسیاری از مثال‌های موجود در این راهنما، حتی آن‌هایی که در اعلان تعاملی وارد "
"شده‌اند، شامل توضیح‌ها هستند. توضیح‌ها در پایتون با نویسهٔ علامت هش، یعنی ``#``، "
"شروع می‌شوند و تا انتهای خط فیزیکی ادامه دارند. یک توضیح می‌تواند در ابتدای یک "
"خط یا پس از فاصله‌های سفید یا کد ظاهر شود، اما نمی‌تواند درون یک رشتهٔ متنی "
"قرار بگیرد. یک نویسهٔ هش درون یک رشتهٔ متنی فقط همان نویسهٔ هش است. از آنجا که "
"توضیح‌ها برای روشن کردن کد هستند و توسط پایتون تفسیر نمی‌شوند، هنگام تایپ "
"مثال‌ها می‌توان آن‌ها را حذف کرد."

#: ../../tutorial/introduction.rst:30
msgid "Some examples::"
msgstr "چند مثال::"

#: ../../tutorial/introduction.rst:32
msgid ""
"# this is the first comment\n"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""
msgstr ""
"# this is the first comment\n"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""

#: ../../tutorial/introduction.rst:41
msgid "Using Python as a Calculator"
msgstr "استفاده از پایتون به‌عنوان ماشین‌حساب"

#: ../../tutorial/introduction.rst:43
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr ""
"بیایید چند دستور سادهٔ پایتون را امتحان کنیم. مفسر را اجرا کنید و منتظر اعلان "
"اصلی، یعنی ``>>>``، بمانید. (نباید زمان زیادی طول بکشد.)"

#: ../../tutorial/introduction.rst:50
msgid "Numbers"
msgstr "اعداد"

#: ../../tutorial/introduction.rst:52
msgid ""
"The interpreter acts as a simple calculator: you can type an expression into "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; "
"parentheses (``()``) can be used for grouping. For example::"
msgstr ""
"مفسر مانند یک ماشین‌حساب ساده عمل می‌کند: می‌توانید یک عبارت را در آن تایپ کنید "
"و مقدار آن را نمایش خواهد داد. نحو عبارت‌ها ساده است: عملگرهای ``+``، ``-``، "
"``*`` و ``/`` را می‌توان برای انجام محاسبات استفاده کرد؛ پرانتزها (``()``) "
"نیز برای گروه‌بندی استفاده می‌شوند. برای مثال::"

#: ../../tutorial/introduction.rst:58
msgid ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # division always returns a floating-point number\n"
"1.6"
msgstr ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # تقسیم همیشه یک عدد ممیز شناور برمی‌گرداند\n"
"1.6"

#: ../../tutorial/introduction.rst:67
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have "
"type :class:`float`.  We will see more about numeric types later in the "
"tutorial."
msgstr ""
"اعداد صحیح (برای مثال ``2``، ``4``، ``20``) دارای نوع :class:`int` هستند و "
"اعدادی که بخش اعشاری دارند (برای مثال ``5.0``، ``1.6``) دارای "
"نوع :class:`float` هستند. در ادامهٔ این آموزش دربارهٔ انواع عددی بیشتر خواهیم "
"دید."

#: ../../tutorial/introduction.rst:71
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
"تقسیم (``/``) همیشه یک مقدار اعشاری برمی‌گرداند. برای انجام :term:`floor "
"division` و دریافت یک نتیجهٔ صحیح می‌توانید از عملگر ``//`` استفاده کنید؛ برای "
"محاسبهٔ باقی‌مانده می‌توانید از ``%`` استفاده کنید::"

#: ../../tutorial/introduction.rst:75
msgid ""
">>> 17 / 3  # classic division returns a float\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # floor division discards the fractional part\n"
"5\n"
">>> 17 % 3  # the % operator returns the remainder of the division\n"
"2\n"
">>> 5 * 3 + 2  # floored quotient * divisor + remainder\n"
"17"
msgstr ""
">>> 17 / 3  # تقسیم معمولی یک عدد اعشاری برمی‌گرداند\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # تقسیم صحیح، بخش اعشاری را حذف می‌کند\n"
"5\n"
">>> 17 % 3  # عملگر % باقی‌ماندهٔ تقسیم را برمی‌گرداند\n"
"2\n"
">>> 5 * 3 + 2  # خارج‌قسمتِ تقسیم صحیح × مقسوم‌علیه + باقی‌مانده\n"
"17"

#: ../../tutorial/introduction.rst:85
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"در پایتون، امکان استفاده از عملگر ``**`` برای محاسبهٔ توان‌ها وجود دارد [#]_::"

#: ../../tutorial/introduction.rst:87
msgid ""
">>> 5 ** 2  # 5 squared\n"
"25\n"
">>> 2 ** 7  # 2 to the power of 7\n"
"128"
msgstr ""
">>> 5 ** 2  #۵ به توان ۲\n"
"25\n"
">>> 2 ** 7  # ۲ به توان ۷\n"
"128"

#: ../../tutorial/introduction.rst:92
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"علامت مساوی (``=``) برای اختصاص دادن یک مقدار به یک متغیر استفاده می‌شود. پس "
"از آن، پیش از اعلان تعاملی بعدی هیچ نتیجه‌ای نمایش داده نمی‌شود::"

#: ../../tutorial/introduction.rst:95
msgid ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"
msgstr ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"

#: ../../tutorial/introduction.rst:100
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"اگر یک متغیر «تعریف» نشده باشد (مقداری به آن اختصاص داده نشده باشد)، تلاش "
"برای استفاده از آن باعث ایجاد خطا خواهد شد::"

#: ../../tutorial/introduction.rst:103
msgid ""
">>> n  # try to access an undefined variable\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"
msgstr ""
">>> n  # تلاش برای استفاده از یک متغیر که تعریف نشده است\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"

#: ../../tutorial/introduction.rst:108
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"پشتیبانی کامل از اعداد اعشاری وجود دارد؛ عملگرهایی که عملوندهایی با نوع‌های "
"مختلف دارند، عملوند صحیح را به عدد اعشاری تبدیل می‌کنند::"

#: ../../tutorial/introduction.rst:111
msgid ""
">>> 4 * 3.75 - 1\n"
"14.0"
msgstr ""
">>> 4 * 3.75 - 1\n"
"14.0"

#: ../../tutorial/introduction.rst:114
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"در حالت تعاملی، آخرین عبارتی که چاپ شده است به متغیر ``_`` اختصاص داده "
"می‌شود. این یعنی هنگامی که از پایتون به‌عنوان یک ماشین‌حساب رومیزی استفاده "
"می‌کنید، ادامه دادن محاسبات تا حدی آسان‌تر می‌شود، برای مثال::"

#: ../../tutorial/introduction.rst:118
msgid ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"
msgstr ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"

#: ../../tutorial/introduction.rst:127
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"این متغیر باید توسط کاربر فقط برای خواندن در نظر گرفته شود. به‌صورت صریح "
"مقداری به آن اختصاص ندهید --- با این کار یک متغیر محلی مستقل با همان نام "
"ایجاد می‌کنید که متغیر داخلی را با رفتار ویژهٔ آن پنهان می‌کند."

#: ../../tutorial/introduction.rst:131
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` "
"and :class:`~fractions.Fraction`. Python also has built-in support "
"for :ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` "
"suffix to indicate the imaginary part (e.g. ``3+5j``)."
msgstr ""
"علاوه بر :class:`int` و :class:`float`، پایتون از انواع دیگر اعداد نیز "
"پشتیبانی می‌کند، مانند :class:`~decimal.Decimal` "
"و :class:`~fractions.Fraction`. پایتون همچنین پشتیبانی داخلی از :ref:`اعداد "
"مختلط <typesnumeric>` دارد و از پسوند ``j`` یا ``J`` برای مشخص کردن بخش "
"موهومی استفاده می‌کند (برای مثال ``3+5j``)."

#: ../../tutorial/introduction.rst:141
msgid "Text"
msgstr "متن"

#: ../../tutorial/introduction.rst:143
msgid ""
"Python can manipulate text (represented by type :class:`str`, so-called "
"\"strings\") as well as numbers.  This includes characters \"``!``\", words "
"\"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. "
"\"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double "
"quotes (``\"...\"``) with the same result [#]_."
msgstr ""
"پایتون می‌تواند متن (که توسط نوع :class:`str` نمایش داده می‌شود و به آن «رشته» "
"گفته می‌شود) را نیز مانند اعداد پردازش کند. این شامل نویسه‌های \"``!``\"، "
"واژه‌های \"``rabbit``\"، نام‌ها \"``Paris``\"، جمله‌های \"``Got your back.``\"، "
"و مواردی مانند \"``Yay! :)``\" است. این موارد را می‌توان درون نقل‌قول تکی "
"(``'...'``) یا نقل‌قول دوتایی (``\"...\"``) قرار داد و نتیجه یکسان خواهد بود "
"[#]_."

#: ../../tutorial/introduction.rst:149
msgid ""
">>> 'spam eggs'  # single quotes\n"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # double quotes\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # digits and numerals enclosed in quotes are also strings\n"
"'1975'"
msgstr ""
">>> 'spam eggs'  # علامت نقل‌قول تکی\n"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # علامت نقل‌قول دوتایی\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # رقم‌ها و عددهایی که داخل کوتیشن قرار می‌گیرند نیز رشته هستند\n"
"'1975'"

#: ../../tutorial/introduction.rst:158
msgid ""
"To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. "
"Alternatively, we can use the other type of quotation marks::"
msgstr ""
"برای قرار دادن یک نقل‌قول درون یک نقل‌قول، باید آن را با قرار دادن ``\\`` پیش "
"از آن، «escape» کنیم. همچنین می‌توانیم از نوع دیگر علامت‌های نقل‌قول استفاده "
"کنیم::"

#: ../../tutorial/introduction.rst:161
msgid ""
">>> 'doesn\\'t'  # use \\' to escape the single quote...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...or use double quotes instead\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"
msgstr ""
">>> 'doesn\\'t'  # برای فرار دادن علامت نقل‌قول تکی، از \\' استفاده کنید...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...یا به‌جای آن از کوتیشن دوتایی استفاده کنید\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"

#: ../../tutorial/introduction.rst:172
msgid ""
"In the Python shell, the string definition and output string can look "
"different.  The :func:`print` function produces a more readable output, by "
"omitting the enclosing quotes and by printing escaped and special "
"characters::"
msgstr ""
"در پوستهٔ پایتون، تعریف رشته و رشتهٔ خروجی ممکن است متفاوت به نظر برسند. "
"تابع :func:`print` خروجی خواناتری تولید می‌کند، زیرا نقل‌قول‌های احاطه‌کننده را "
"حذف می‌کند و نویسه‌های escape‌شده و ویژه را چاپ می‌کند::"

#: ../../tutorial/introduction.rst:176
msgid ""
">>> s = 'First line.\\nSecond line.'  # \\n means newline\n"
">>> s  # without print(), special characters are included in the string\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # with print(), special characters are interpreted, so \\n "
"produces new line\n"
"First line.\n"
"Second line."
msgstr ""
">>> s = 'First line.\\nSecond line.'  # \\n نشان‌دهندهٔ رفتن به خط بعد است\n"
">>> s  # بدون print()، نویسه‌های ویژه در رشته نمایش داده می‌شوند\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # با print()، نویسه‌های ویژه تفسیر می‌شوند، بنابراین \\n یک خط "
"جدید ایجاد می‌کند\n"
"First line.\n"
"Second line."

#: ../../tutorial/introduction.rst:183
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"اگر نمی‌خواهید نویسه‌هایی که با ``\\`` پیش از آن‌ها آمده است به‌عنوان نویسه‌های "
"ویژه تفسیر شوند، می‌توانید با افزودن ``r`` پیش از اولین علامت نقل‌قول، از "
"*رشته‌های خام* استفاده کنید::"

#: ../../tutorial/introduction.rst:187
msgid ""
">>> print('C:\\this\\name')  # here \\t means tab, \\n means newline\n"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # note the r before the quote\n"
"C:\\this\\name"
msgstr ""
">>> print('C:\\this\\name')  # در اینجا \\t نشان‌دهندهٔ تب و \\n نشان‌دهندهٔ خط "
"جدید است\n"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # به حرف r قبل از کوتیشن توجه کنید\n"
"C:\\this\\name"

#: ../../tutorial/introduction.rst:193
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"
"raw-string-backslash>` for more information and workarounds."
msgstr ""
"یک نکتهٔ ظریف دربارهٔ رشته‌های خام وجود دارد: یک رشتهٔ خام نمی‌تواند با تعداد "
"فردی از نویسه‌های ``\\`` پایان یابد؛ برای اطلاعات بیشتر و راه‌حل‌های جایگزین، "
"به :ref:`ورودی پرسش‌های متداول <faq-programming-raw-string-backslash>` مراجعه "
"کنید."

#: ../../tutorial/introduction.rst:198
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``.  End-of-line characters are "
"automatically included in the string, but it's possible to prevent this by "
"adding a ``\\`` at the end of the line.  In the following example, the "
"initial newline is not included::"
msgstr ""
"رشته‌های متنی می‌توانند چندین خط را دربر بگیرند. یک روش استفاده از نقل‌قول‌های "
"سه‌تایی است: ``\"\"\"...\"\"\"`` یا ``'''...'''``. نویسه‌های پایان خط به‌صورت "
"خودکار در رشته قرار می‌گیرند، اما می‌توان با افزودن یک ``\\`` در انتهای خط از "
"این کار جلوگیری کرد. در مثال زیر، خط جدید ابتدایی در رشته قرار نمی‌گیرد::"

#: ../../tutorial/introduction.rst:204
msgid ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"
msgstr ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"

#: ../../tutorial/introduction.rst:215
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"رشته‌ها را می‌توان با عملگر ``+`` به یکدیگر متصل (چسباند) کرد و با ``*`` تکرار "
"کرد::"

#: ../../tutorial/introduction.rst:218
msgid ""
">>> # 3 times 'un', followed by 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"
msgstr ""
">>># سه بار رشتهٔ «un»، به دنبال آن رشتهٔ «ium»\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"

#: ../../tutorial/introduction.rst:222
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"دو یا چند *رشتهٔ متنی* (یعنی مواردی که بین علامت‌های نقل‌قول قرار گرفته‌اند) که "
"در کنار یکدیگر قرار دارند، به‌صورت خودکار به هم متصل می‌شوند. ::"

#: ../../tutorial/introduction.rst:225
msgid ""
">>> 'Py' 'thon'\n"
"'Python'"
msgstr ""
">>> 'Py' 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:228
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"این قابلیت به‌ویژه زمانی مفید است که بخواهید رشته‌های طولانی را شکسته و در چند "
"خط بنویسید::"

#: ../../tutorial/introduction.rst:230
msgid ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"
msgstr ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"

#: ../../tutorial/introduction.rst:235
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"البته این فقط برای دو رشتهٔ متنی ثابت کار می‌کند، نه برای متغیرها یا عبارت‌ها::"

#: ../../tutorial/introduction.rst:237
msgid ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # can't concatenate a variable and a string literal\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # نمی‌توان یک متغیر و یک رشتهٔ متنی را به هم الحاق کرد\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

#: ../../tutorial/introduction.rst:249
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"اگر می‌خواهید متغیرها یا یک متغیر و یک رشتهٔ متنی ثابت را به هم متصل کنید، از "
"``+`` استفاده کنید::"

#: ../../tutorial/introduction.rst:251
msgid ""
">>> prefix + 'thon'\n"
"'Python'"
msgstr ""
">>> prefix + 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:254
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"رشته‌ها را می‌توان *نمایه‌گذاری* (زیرنویس‌گذاری) کرد؛ به‌طوری که اولین نویسه "
"دارای نمایهٔ 0 است. نوع جداگانه‌ای برای نویسه وجود ندارد؛ یک نویسه در واقع فقط "
"رشته‌ای با اندازهٔ یک است::"

#: ../../tutorial/introduction.rst:258
msgid ""
">>> word = 'Python'\n"
">>> word[0]  # character in position 0\n"
"'P'\n"
">>> word[5]  # character in position 5\n"
"'n'"
msgstr ""
">>> word = 'Python'\n"
">>> word[0]  # نویسه در موقعیت ۰\n"
"'P'\n"
">>> word[5]  # نویسه در موقعیت ۵\n"
"'n'"

#: ../../tutorial/introduction.rst:264
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"نمایه‌ها همچنین می‌توانند اعداد منفی باشند تا شمارش از سمت راست آغاز شود::"

#: ../../tutorial/introduction.rst:266
msgid ""
">>> word[-1]  # last character\n"
"'n'\n"
">>> word[-2]  # second-last character\n"
"'o'\n"
">>> word[-6]\n"
"'P'"
msgstr ""
">>> word[-1]  # نویسه آخر\n"
"'n'\n"
">>> word[-2]  # نویسه یکی مانده به آخر\n"
"'o'\n"
">>> word[-6]\n"
"'P'"

#: ../../tutorial/introduction.rst:273
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "توجه کنید که چون ‎-0 همان 0 است، نمایه‌های منفی از ‎-1 شروع می‌شوند."

#: ../../tutorial/introduction.rst:275
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain a "
"substring::"
msgstr ""
"علاوه بر نمایه‌گذاری، *برش‌دهی* نیز پشتیبانی می‌شود. در حالی که نمایه‌گذاری برای "
"به‌دست آوردن نویسه‌های جداگانه استفاده می‌شود، *برش‌دهی* به شما اجازه می‌دهد یک "
"زیررشته به‌دست آورید::"

#: ../../tutorial/introduction.rst:278
msgid ""
">>> word[0:2]  # characters from position 0 (included) to 2 (excluded)\n"
"'Py'\n"
">>> word[2:5]  # characters from position 2 (included) to 5 (excluded)\n"
"'tho'"
msgstr ""
">>> word[0:2]  # نویسه‌ها از موقعیت ۰ تا قبل از موقعیت ۲\n"
"'Py'\n"
">>> word[2:5]  # نویسه‌ها از موقعیت ۲ تا قبل از موقعیت ۵\n"
"'tho'"

#: ../../tutorial/introduction.rst:283
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"نمایه‌های برش مقدارهای پیش‌فرض مفیدی دارند؛ اگر نمایهٔ اول حذف شود، مقدار "
"پیش‌فرض آن صفر است و اگر نمایهٔ دوم حذف شود، مقدار پیش‌فرض آن اندازهٔ رشته‌ای است "
"که در حال برش خوردن است. ::"

#: ../../tutorial/introduction.rst:286
msgid ""
">>> word[:2]   # character from the beginning to position 2 (excluded)\n"
"'Py'\n"
">>> word[4:]   # characters from position 4 (included) to the end\n"
"'on'\n"
">>> word[-2:]  # characters from the second-last (included) to the end\n"
"'on'"
msgstr ""
">>> word[:2]   # نویسه‌ها از ابتدای رشته تا قبل از موقعیت ۲\n"
"'Py'\n"
">>> word[4:]   # نویسه‌ها از موقعیت ۴ به بعد تا انتهای رشته\n"
"'on'\n"
">>> word[-2:]  # نویسه‌ها از دومین نویسهٔ آخر به بعد تا انتهای رشته\n"
"'on'"

#: ../../tutorial/introduction.rst:293
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"توجه کنید که نقطهٔ شروع همیشه شامل می‌شود و نقطهٔ پایان همیشه حذف می‌شود. این "
"موضوع تضمین می‌کند که ``s[:i] + s[i:]`` همیشه برابر با ``s`` باشد::"

#: ../../tutorial/introduction.rst:296
msgid ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"
msgstr ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"

#: ../../tutorial/introduction.rst:301
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"یک روش برای به خاطر سپردن نحوهٔ کار برش‌ها این است که تصور کنید نمایه‌ها به "
"*بین* نویسه‌ها اشاره می‌کنند، به‌طوری که لبهٔ سمت چپ اولین نویسه شمارهٔ 0 دارد. "
"سپس لبهٔ سمت راست آخرین نویسهٔ یک رشته با *n* نویسه، دارای نمایهٔ *n* است؛ برای "
"مثال::"

#: ../../tutorial/introduction.rst:306
msgid ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"
msgstr ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"

#: ../../tutorial/introduction.rst:312
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"ردیف اول اعداد، موقعیت نمایه‌های 0...6 در رشته را نشان می‌دهد؛ ردیف دوم "
"نمایه‌های منفی متناظر را نشان می‌دهد. برش از *i* تا *j* شامل تمام نویسه‌هایی "
"است که بین لبه‌های مشخص‌شده با *i* و *j* قرار دارند."

#: ../../tutorial/introduction.rst:317
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"برای نمایه‌های غیرمنفی، طول یک برش برابر با تفاوت بین نمایه‌ها است، به شرطی که "
"هر دو در محدوده باشند. برای مثال، طول ``word[1:3]`` برابر با 2 است."

#: ../../tutorial/introduction.rst:321
msgid "Attempting to use an index that is too large will result in an error::"
msgstr ""
"تلاش برای استفاده از نمایه‌ای که بیش از حد بزرگ است، باعث ایجاد خطا خواهد شد::"

#: ../../tutorial/introduction.rst:323
msgid ""
">>> word[42]  # the word only has 6 characters\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"
msgstr ""
">>> word[42]  # این کلمه فقط ۶ نویسه دارد\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"

#: ../../tutorial/introduction.rst:328
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"بااین‌حال، نمایه‌های برش خارج از محدوده هنگام استفاده برای برش‌دهی به‌صورت "
"مناسبی مدیریت می‌شوند::"

#: ../../tutorial/introduction.rst:331
msgid ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"
msgstr ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"

#: ../../tutorial/introduction.rst:336
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"رشته‌های پایتون قابل تغییر نیستند --- آن‌ها :term:`immutable` هستند. بنابراین، "
"اختصاص دادن مقدار به یک موقعیت نمایه‌گذاری‌شده در رشته باعث ایجاد خطا می‌شود::"

#: ../../tutorial/introduction.rst:339
msgid ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"
msgstr ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"

#: ../../tutorial/introduction.rst:348
msgid "If you need a different string, you should create a new one::"
msgstr "اگر به یک رشتهٔ متفاوت نیاز دارید، باید یک رشتهٔ جدید ایجاد کنید::"

#: ../../tutorial/introduction.rst:350
msgid ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"
msgstr ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"

#: ../../tutorial/introduction.rst:355
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "تابع داخلی :func:`len` طول یک رشته را برمی‌گرداند::"

#: ../../tutorial/introduction.rst:357
msgid ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"
msgstr ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"

#: ../../tutorial/introduction.rst:364
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:365
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"رشته‌ها نمونه‌هایی از *انواع دنباله‌ای* (*sequence types*) هستند و از عملیات "
"مشترکی که این نوع‌ها پشتیبانی می‌کنند، پشتیبانی می‌کنند."

#: ../../tutorial/introduction.rst:368
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:369
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr "رشته‌ها تعداد زیادی متد برای تبدیل‌های پایه و جستجو ارائه می‌دهند."

#: ../../tutorial/introduction.rst:372
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:373
msgid "String literals that have embedded expressions."
msgstr "رشته‌های متنی ثابتی که شامل عبارت‌های جاسازی‌شده هستند."

#: ../../tutorial/introduction.rst:375
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:376
msgid "Information about string formatting with :meth:`str.format`."
msgstr "اطلاعات دربارهٔ قالب‌بندی رشته‌ها با :meth:`str.format`."

#: ../../tutorial/introduction.rst:378
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:379
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"عملیات قالب‌بندی قدیمی که زمانی فراخوانی می‌شوند که رشته‌ها عملوند سمت چپ عملگر "
"``%`` باشند، در اینجا با جزئیات بیشتری توضیح داده شده‌اند."

#: ../../tutorial/introduction.rst:386
msgid "Lists"
msgstr "لیست‌ها"

#: ../../tutorial/introduction.rst:388
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values.  The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets.  Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"پایتون تعدادی نوع دادهٔ *مرکب* دارد که برای گروه‌بندی مقدارهای دیگر استفاده "
"می‌شوند. انعطاف‌پذیرترین آن‌ها *فهرست* (*list*) است که می‌توان آن را به‌صورت "
"فهرستی از مقدارهای جداشده با ویرگول (آیتم‌ها) در میان کروشه‌ها نوشت. فهرست‌ها "
"ممکن است شامل آیتم‌هایی از نوع‌های مختلف باشند، اما معمولاً همهٔ آیتم‌ها یک نوع "
"یکسان دارند. ::"

#: ../../tutorial/introduction.rst:393
msgid ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"
msgstr ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"

#: ../../tutorial/introduction.rst:397
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"مانند رشته‌ها (و تمام نوع‌های داخلی دیگر :term:`sequence`)، فهرست‌ها را می‌توان "
"نمایه‌گذاری و برش داد::"

#: ../../tutorial/introduction.rst:400
msgid ""
">>> squares[0]  # indexing returns the item\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # slicing returns a new list\n"
"[9, 16, 25]"
msgstr ""
">>> squares[0]  # اندیس‌گذاری، عنصر را برمی‌گرداند\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # برش‌زدن، یک لیست جدید برمی‌گرداند\n"
"[9, 16, 25]"

#: ../../tutorial/introduction.rst:407
msgid "Lists also support operations like concatenation::"
msgstr "فهرست‌ها همچنین از عملیاتی مانند الحاق پشتیبانی می‌کنند::"

#: ../../tutorial/introduction.rst:409
msgid ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
msgstr ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

#: ../../tutorial/introduction.rst:412
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"برخلاف رشته‌ها که :term:`immutable` هستند، فهرست‌ها یک نوع :term:`mutable` "
"هستند؛ یعنی امکان تغییر محتوای آن‌ها وجود دارد::"

#: ../../tutorial/introduction.rst:415
msgid ""
">>> cubes = [1, 8, 27, 65, 125]  # something's wrong here\n"
">>> 4 ** 3  # the cube of 4 is 64, not 65!\n"
"64\n"
">>> cubes[3] = 64  # replace the wrong value\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"
msgstr ""
">>> cubes = [1, 8, 27, 65, 125]  # یک چیزی اینجا اشتباه است\n"
">>> 4 ** 3  # توان سومِ ۴ برابر ۶۴ است، نه ۶۵!\n"
"64\n"
">>> cubes[3] = 64  # جایگزین کردن مقدار اشتباه\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"

#: ../../tutorial/introduction.rst:422
msgid ""
"You can also add new items at the end of the list, by using "
"the :meth:`list.append` *method* (we will see more about methods later)::"
msgstr ""
"همچنین می‌توانید با استفاده از *متد* :meth:`list.append` آیتم‌های جدیدی را به "
"انتهای فهرست اضافه کنید (در ادامه دربارهٔ متدها بیشتر خواهیم دید)::"

#: ../../tutorial/introduction.rst:425
msgid ""
">>> cubes.append(216)  # add the cube of 6\n"
">>> cubes.append(7 ** 3)  # and the cube of 7\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"
msgstr ""
">>> cubes.append(216)  # توان سوم ۶ را اضافه کنید\n"
">>> cubes.append(7 ** 3)  # و همچنین توان سوم ۷\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"

#: ../../tutorial/introduction.rst:430
msgid ""
"Simple assignment in Python never copies data. When you assign a list to a "
"variable, the variable refers to the *existing list*. Any changes you make "