From cd1d64e76e25beedb17bfbe20d47e3892462f9d1 Mon Sep 17 00:00:00 2001
From: Sepehr Rasouli <sepehrrasouli06@gmail.com>
Date: Thu, 13 Aug 2026 08:52:17 +0330
Subject: [PATCH 1/2] Translate tutorial/introduction.po

---
 tutorial/introduction.po | 462 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 437 insertions(+), 25 deletions(-)

diff --git a/tutorial/introduction.po b/tutorial/introduction.po
index 4dfd5c264..f486bc96e 100644
--- a/tutorial/introduction.po
+++ b/tutorial/introduction.po
@@ -12,7 +12,7 @@ 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: 2021-06-28 01:50+0000\n"
+"PO-Revision-Date: 2026-08-13 08:51+0330\n"
 "Last-Translator: Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025\n"
 "Language-Team: Persian (https://app.transifex.com/python-doc/teams/5390/"
 "fa/)\n"
@@ -21,10 +21,11 @@ msgstr ""
 "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 ""
+msgstr "معرفی غیررسمی پایتون"
 
 #: ../../tutorial/introduction.rst:7
 msgid ""
@@ -35,6 +36,12 @@ msgid ""
 "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 ""
@@ -42,6 +49,10 @@ msgid ""
 "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 ""
@@ -53,10 +64,17 @@ msgid ""
 "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 ""
+msgstr "چند مثال::"
 
 #: ../../tutorial/introduction.rst:32
 msgid ""
@@ -65,20 +83,26 @@ msgid ""
 "          # ... 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 ""
+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 ""
+msgstr "اعداد"
 
 #: ../../tutorial/introduction.rst:52
 msgid ""
@@ -87,6 +111,10 @@ msgid ""
 "operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; "
 "parentheses (``()``) can be used for grouping. For example::"
 msgstr ""
+"مفسر مانند یک ماشین‌حساب ساده عمل می‌کند: می‌توانید یک عبارت را در آن تایپ کنید "
+"و مقدار آن را نمایش خواهد داد. نحو عبارت‌ها ساده است: عملگرهای ``+``، ``-``، "
+"``*`` و ``/`` را می‌توان برای انجام محاسبات استفاده کرد؛ پرانتزها (``()``) "
+"نیز برای گروه‌بندی استفاده می‌شوند. برای مثال::"
 
 #: ../../tutorial/introduction.rst:58
 msgid ""
@@ -99,6 +127,14 @@ msgid ""
 ">>> 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 ""
@@ -107,6 +143,10 @@ msgid ""
 "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 ""
@@ -114,6 +154,9 @@ msgid ""
 "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 ""
@@ -127,12 +170,22 @@ msgid ""
 ">>> 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 ""
@@ -141,12 +194,18 @@ msgid ""
 ">>> 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 ""
@@ -155,12 +214,18 @@ msgid ""
 ">>> 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 ""
@@ -169,18 +234,26 @@ msgid ""
 "  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 ""
@@ -188,6 +261,9 @@ msgid ""
 "``_``.  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 ""
@@ -200,6 +276,14 @@ msgid ""
 ">>> 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 ""
@@ -207,6 +291,9 @@ msgid ""
 "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 ""
@@ -216,10 +303,15 @@ msgid ""
 "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 ""
+msgstr "متن"
 
 #: ../../tutorial/introduction.rst:143
 msgid ""
@@ -229,6 +321,12 @@ msgid ""
 "\"``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 ""
@@ -239,12 +337,21 @@ msgid ""
 ">>> '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 ""
@@ -259,6 +366,16 @@ msgid ""
 ">>> '\"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 ""
@@ -267,6 +384,9 @@ msgid ""
 "omitting the enclosing quotes and by printing escaped and special "
 "characters::"
 msgstr ""
+"در پوستهٔ پایتون، تعریف رشته و رشتهٔ خروجی ممکن است متفاوت به نظر برسند. "
+"تابع :func:`print` خروجی خواناتری تولید می‌کند، زیرا نقل‌قول‌های احاطه‌کننده را "
+"حذف می‌کند و نویسه‌های escape‌شده و ویژه را چاپ می‌کند::"
 
 #: ../../tutorial/introduction.rst:176
 msgid ""
@@ -278,6 +398,13 @@ msgid ""
 "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 ""
@@ -285,6 +412,9 @@ msgid ""
 "characters, you can use *raw strings* by adding an ``r`` before the first "
 "quote::"
 msgstr ""
+"اگر نمی‌خواهید نویسه‌هایی که با ``\\`` پیش از آن‌ها آمده است به‌عنوان نویسه‌های "
+"ویژه تفسیر شوند، می‌توانید با افزودن ``r`` پیش از اولین علامت نقل‌قول، از "
+"*رشته‌های خام* استفاده کنید::"
 
 #: ../../tutorial/introduction.rst:187
 msgid ""
@@ -294,6 +424,12 @@ msgid ""
 ">>> 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 ""
@@ -301,6 +437,10 @@ msgid ""
 "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 ""
@@ -310,6 +450,10 @@ msgid ""
 "adding a ``\\`` at the end of the line.  In the following example, the "
 "initial newline is not included::"
 msgstr ""
+"رشته‌های متنی می‌توانند چندین خط را دربر بگیرند. یک روش استفاده از نقل‌قول‌های "
+"سه‌تایی است: ``\"\"\"...\"\"\"`` یا ``'''...'''``. نویسه‌های پایان خط به‌صورت "
+"خودکار در رشته قرار می‌گیرند، اما می‌توان با افزودن یک ``\\`` در انتهای خط از "
+"این کار جلوگیری کرد. در مثال زیر، خط جدید ابتدایی در رشته قرار نمی‌گیرد::"
 
 #: ../../tutorial/introduction.rst:204
 msgid ""
@@ -324,12 +468,24 @@ msgid ""
 "\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 ""
@@ -337,23 +493,32 @@ msgid ""
 ">>> 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 ""
@@ -362,11 +527,16 @@ msgid ""
 ">>> 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 ""
@@ -382,17 +552,32 @@ msgid ""
 "               ^^^^^\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 ""
@@ -400,6 +585,9 @@ msgid ""
 "index 0. There is no separate character type; a character is simply a string "
 "of size one::"
 msgstr ""
+"رشته‌ها را می‌توان *نمایه‌گذاری* (زیرنویس‌گذاری) کرد؛ به‌طوری که اولین نویسه "
+"دارای نمایهٔ 0 است. نوع جداگانه‌ای برای نویسه وجود ندارد؛ یک نویسه در واقع فقط "
+"رشته‌ای با اندازهٔ یک است::"
 
 #: ../../tutorial/introduction.rst:258
 msgid ""
@@ -409,11 +597,17 @@ msgid ""
 ">>> 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 ""
@@ -424,10 +618,16 @@ msgid ""
 ">>> 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 ""
+msgstr "توجه کنید که چون ‎-0 همان 0 است، نمایه‌های منفی از ‎-1 شروع می‌شوند."
 
 #: ../../tutorial/introduction.rst:275
 msgid ""
@@ -435,6 +635,9 @@ msgid ""
 "used to obtain individual characters, *slicing* allows you to obtain a "
 "substring::"
 msgstr ""
+"علاوه بر نمایه‌گذاری، *برش‌دهی* نیز پشتیبانی می‌شود. در حالی که نمایه‌گذاری برای "
+"به‌دست آوردن نویسه‌های جداگانه استفاده می‌شود، *برش‌دهی* به شما اجازه می‌دهد یک "
+"زیررشته به‌دست آورید::"
 
 #: ../../tutorial/introduction.rst:278
 msgid ""
@@ -443,12 +646,19 @@ msgid ""
 ">>> 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 ""
@@ -459,12 +669,20 @@ msgid ""
 ">>> 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 ""
@@ -473,6 +691,10 @@ msgid ""
 ">>> 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 ""
@@ -481,6 +703,10 @@ msgid ""
 "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 ""
@@ -490,6 +716,11 @@ msgid ""
 " 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 ""
@@ -498,6 +729,9 @@ msgid ""
 "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 ""
@@ -505,10 +739,13 @@ msgid ""
 "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 ""
@@ -517,12 +754,18 @@ msgid ""
 "  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 ""
@@ -531,12 +774,18 @@ msgid ""
 ">>> 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 ""
@@ -549,10 +798,18 @@ msgid ""
 "  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 ""
+msgstr "اگر به یک رشتهٔ متفاوت نیاز دارید، باید یک رشتهٔ جدید ایجاد کنید::"
 
 #: ../../tutorial/introduction.rst:350
 msgid ""
@@ -561,10 +818,14 @@ msgid ""
 ">>> 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 ""
+msgstr "تابع داخلی :func:`len` طول یک رشته را برمی‌گرداند::"
 
 #: ../../tutorial/introduction.rst:357
 msgid ""
@@ -572,56 +833,63 @@ msgid ""
 ">>> len(s)\n"
 "34"
 msgstr ""
+">>> s = 'supercalifragilisticexpialidocious'\n"
+">>> len(s)\n"
+"34"
 
 #: ../../tutorial/introduction.rst:364
 msgid ":ref:`textseq`"
-msgstr ""
+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 ""
+msgstr ":ref:`string-methods`"
 
 #: ../../tutorial/introduction.rst:369
 msgid ""
 "Strings support a large number of methods for basic transformations and "
 "searching."
-msgstr ""
+msgstr "رشته‌ها تعداد زیادی متد برای تبدیل‌های پایه و جستجو ارائه می‌دهند."
 
 #: ../../tutorial/introduction.rst:372
 msgid ":ref:`f-strings`"
-msgstr ""
+msgstr ":ref:`f-strings`"
 
 #: ../../tutorial/introduction.rst:373
 msgid "String literals that have embedded expressions."
-msgstr ""
+msgstr "رشته‌های متنی ثابتی که شامل عبارت‌های جاسازی‌شده هستند."
 
 #: ../../tutorial/introduction.rst:375
 msgid ":ref:`formatstrings`"
-msgstr ""
+msgstr ":ref:`formatstrings`"
 
 #: ../../tutorial/introduction.rst:376
 msgid "Information about string formatting with :meth:`str.format`."
-msgstr ""
+msgstr "اطلاعات دربارهٔ قالب‌بندی رشته‌ها با :meth:`str.format`."
 
 #: ../../tutorial/introduction.rst:378
 msgid ":ref:`old-string-formatting`"
-msgstr ""
+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 ""
+msgstr "لیست‌ها"
 
 #: ../../tutorial/introduction.rst:388
 msgid ""
@@ -630,6 +898,11 @@ msgid ""
 "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 ""
@@ -637,12 +910,17 @@ msgid ""
 ">>> 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 ""
@@ -653,22 +931,32 @@ msgid ""
 ">>> 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 ""
+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 ""
@@ -679,12 +967,20 @@ msgid ""
 ">>> 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 ""
@@ -693,6 +989,10 @@ msgid ""
 ">>> 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 ""
@@ -701,6 +1001,10 @@ msgid ""
 "to the list through one variable will be seen through all other variables "
 "that refer to it.::"
 msgstr ""
+"انتساب ساده در پایتون هرگز داده‌ها را کپی نمی‌کند. هنگامی که یک فهرست را به یک "
+"متغیر اختصاص می‌دهید، متغیر به *فهرست موجود* اشاره می‌کند. هر تغییری که از "
+"طریق یک متغیر در فهرست ایجاد کنید، از طریق تمام متغیرهای دیگری که به آن "
+"اشاره می‌کنند نیز دیده خواهد شد.::"
 
 #: ../../tutorial/introduction.rst:435
 msgid ""
@@ -712,6 +1016,13 @@ msgid ""
 ">>> rgb\n"
 "[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
 msgstr ""
+">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
+">>> rgba = rgb\n"
+">>> id(rgb) == id(rgba)  # هر دو به یک شیء اشاره می‌کنند\n"
+"True\n"
+">>> rgba.append(\"Alph\")\n"
+">>> rgb\n"
+"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
 
 #: ../../tutorial/introduction.rst:443
 msgid ""
@@ -719,6 +1030,8 @@ msgid ""
 "This means that the following slice returns a :ref:`shallow copy "
 "<shallow_vs_deep_copy>` of the list::"
 msgstr ""
+"تمام عملیات برش یک فهرست جدید شامل عناصر درخواست‌شده برمی‌گردانند. این یعنی "
+"برش زیر یک :ref:`کپی سطحی <shallow_vs_deep_copy>` از فهرست ایجاد می‌کند::"
 
 #: ../../tutorial/introduction.rst:447
 msgid ""
@@ -729,12 +1042,20 @@ msgid ""
 ">>> rgba\n"
 "[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
 msgstr ""
+">>> correct_rgba = rgba[:]\n"
+">>> correct_rgba[-1] = \"Alpha\"\n"
+">>> correct_rgba\n"
+"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
+">>> rgba\n"
+"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
 
 #: ../../tutorial/introduction.rst:454
 msgid ""
 "Assignment to slices is also possible, and this can even change the size of "
 "the list or clear it entirely::"
 msgstr ""
+"انتساب به برش‌ها نیز امکان‌پذیر است و حتی می‌تواند اندازهٔ فهرست را تغییر دهد یا "
+"آن را به‌طور کامل خالی کند::"
 
 #: ../../tutorial/introduction.rst:457
 msgid ""
@@ -754,10 +1075,25 @@ msgid ""
 ">>> letters\n"
 "[]"
 msgstr ""
+">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
+">>> letters\n"
+"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
+">>> # جایگزین کردن بعضی از مقادیر\n"
+">>> letters[2:5] = ['C', 'D', 'E']\n"
+">>> letters\n"
+"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
+">>> # حالا آن‌ها را حذف می‌کنیم\n"
+">>> letters[2:5] = []\n"
+">>> letters\n"
+"['a', 'b', 'f', 'g']\n"
+">>> # خالی کردن لیست با جایگزین کردن همهٔ عناصر آن با یک لیست خالی\n"
+">>> letters[:] = []\n"
+">>> letters\n"
+"[]"
 
 #: ../../tutorial/introduction.rst:473
 msgid "The built-in function :func:`len` also applies to lists::"
-msgstr ""
+msgstr "تابع داخلی :func:`len` برای فهرست‌ها نیز کاربرد دارد::"
 
 #: ../../tutorial/introduction.rst:475
 msgid ""
@@ -765,12 +1101,17 @@ msgid ""
 ">>> len(letters)\n"
 "4"
 msgstr ""
+">>> letters = ['a', 'b', 'c', 'd']\n"
+">>> len(letters)\n"
+"4"
 
 #: ../../tutorial/introduction.rst:479
 msgid ""
 "It is possible to nest lists (create lists containing other lists), for "
 "example::"
 msgstr ""
+"امکان تو در تو کردن فهرست‌ها وجود دارد (ایجاد فهرست‌هایی که شامل فهرست‌های دیگر "
+"هستند)، برای مثال::"
 
 #: ../../tutorial/introduction.rst:482
 msgid ""
@@ -784,10 +1125,19 @@ msgid ""
 ">>> x[0][1]\n"
 "'b'"
 msgstr ""
+">>> a = ['a', 'b', 'c']\n"
+">>> n = [1, 2, 3]\n"
+">>> x = [a, n]\n"
+">>> x\n"
+"[['a', 'b', 'c'], [1, 2, 3]]\n"
+">>> x[0]\n"
+"['a', 'b', 'c']\n"
+">>> x[0][1]\n"
+"'b'"
 
 #: ../../tutorial/introduction.rst:495
 msgid "First Steps Towards Programming"
-msgstr ""
+msgstr "قدم های اول به سوی برنامه‌نویسی"
 
 #: ../../tutorial/introduction.rst:497
 msgid ""
@@ -796,6 +1146,9 @@ msgid ""
 "`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ as "
 "follows::"
 msgstr ""
+"البته، می‌توانیم از پایتون برای کارهای پیچیده‌تری از جمع کردن دو و دو استفاده "
+"کنیم. برای نمونه، می‌توانیم یک زیررشتهٔ ابتدایی از `دنبالهٔ فیبوناچی <https://"
+"en.wikipedia.org/wiki/Fibonacci_sequence>`_ را به شکل زیر بنویسیم::"
 
 #: ../../tutorial/introduction.rst:502
 msgid ""
@@ -814,10 +1167,24 @@ msgid ""
 "5\n"
 "8"
 msgstr ""
+">>> # سری فیبوناچی:\n"
+">>> # جمع دو عنصر، عنصر بعدی را تعیین میکند\n"
+">>> a, b = 0, 1\n"
+">>> while a < 10:\n"
+"...     print(a)\n"
+"...     a, b = b, a+b\n"
+"...\n"
+"0\n"
+"1\n"
+"1\n"
+"2\n"
+"3\n"
+"5\n"
+"8"
 
 #: ../../tutorial/introduction.rst:517
 msgid "This example introduces several new features."
-msgstr ""
+msgstr "این مثال چندین قابلیت جدید را معرفی می‌کند."
 
 #: ../../tutorial/introduction.rst:519
 msgid ""
@@ -827,6 +1194,11 @@ msgid ""
 "all evaluated first before any of the assignments take place.  The right-"
 "hand side expressions are evaluated  from the left to the right."
 msgstr ""
+"خط اول شامل یک *انتساب چندگانه* است: متغیرهای ``a`` و ``b`` به‌صورت هم‌زمان "
+"مقدارهای جدید 0 و 1 را دریافت می‌کنند. در خط آخر نیز دوباره از این ویژگی "
+"استفاده شده است و نشان می‌دهد که تمام عبارت‌های سمت راست ابتدا ارزیابی می‌شوند، "
+"پیش از آنکه هر یک از انتساب‌ها انجام شود. عبارت‌های سمت راست از چپ به راست "
+"ارزیابی می‌شوند."
 
 #: ../../tutorial/introduction.rst:525
 msgid ""
@@ -839,6 +1211,14 @@ msgid ""
 "than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
 "to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
 msgstr ""
+"حلقهٔ :keyword:`while` تا زمانی اجرا می‌شود که شرط (در اینجا: ``a < 10``) درست "
+"باقی بماند. در پایتون، مانند C، هر مقدار صحیح غیرصفر درست (*true*) است؛ صفر "
+"نادرست (*false*) است. شرط همچنین می‌تواند یک مقدار رشته‌ای یا فهرست باشد، در "
+"واقع هر دنباله‌ای؛ هر چیزی که طول غیرصفر داشته باشد درست است و دنباله‌های خالی "
+"نادرست هستند. آزمایشی که در مثال استفاده شده است یک مقایسهٔ ساده است. "
+"عملگرهای استاندارد مقایسه مانند C نوشته می‌شوند: ``<`` (کوچک‌تر از)، ``>`` "
+"(بزرگ‌تر از)، ``==`` (برابر با)، ``<=`` (کوچک‌تر یا برابر با)، ``>=`` (بزرگ‌تر "
+"یا برابر با) و ``!=`` (نابرابر با)."
 
 #: ../../tutorial/introduction.rst:534
 msgid ""
@@ -851,6 +1231,14 @@ msgid ""
 "(since the parser cannot guess when you have typed the last line).  Note "
 "that each line within a basic block must be indented by the same amount."
 msgstr ""
+"*بدنه* حلقه *تورفته* است: تورفتگی روش پایتون برای گروه‌بندی دستورهاست. در "
+"اعلان تعاملی، باید برای هر خط تورفته یک تب یا چند فاصله تایپ کنید. در عمل، "
+"ورودی‌های پیچیده‌تر پایتون را با یک ویرایشگر متن آماده خواهید کرد؛ تمام "
+"ویرایشگرهای متن مناسب قابلیت تورفتگی خودکار دارند. هنگامی که یک دستور مرکب "
+"به‌صورت تعاملی وارد می‌شود، باید پس از آن یک خط خالی قرار گیرد تا پایان آن "
+"مشخص شود (زیرا تجزیه‌کننده نمی‌تواند حدس بزند که آخرین خط را چه زمانی "
+"نوشته‌اید). توجه کنید که هر خط درون یک بلوک پایه باید به یک اندازه تورفته "
+"باشد."
 
 #: ../../tutorial/introduction.rst:543
 msgid ""
@@ -861,6 +1249,12 @@ msgid ""
 "without quotes, and a space is inserted between items, so you can format "
 "things nicely, like this::"
 msgstr ""
+"تابع :func:`print` مقدار آرگومان(هایی) را که دریافت می‌کند می‌نویسد. این تابع "
+"با نوشتن مستقیم عبارتی که می‌خواهید نمایش دهید (مانند مثال‌های قبلی ماشین‌حساب) "
+"تفاوت دارد، زیرا آرگومان‌های متعدد، مقدارهای اعشاری و رشته‌ها را به شکل "
+"متفاوتی مدیریت می‌کند. رشته‌ها بدون علامت نقل‌قول چاپ می‌شوند و بین آیتم‌ها یک "
+"فاصله قرار می‌گیرد، بنابراین می‌توانید خروجی را به شکل مناسبی قالب‌بندی کنید، "
+"مانند این::"
 
 #: ../../tutorial/introduction.rst:550
 msgid ""
@@ -868,12 +1262,17 @@ msgid ""
 ">>> print('The value of i is', i)\n"
 "The value of i is 65536"
 msgstr ""
+">>> i = 256*256\n"
+">>> print('The value of i is', i)\n"
+"The value of i is 65536"
 
 #: ../../tutorial/introduction.rst:554
 msgid ""
 "The keyword argument *end* can be used to avoid the newline after the "
 "output, or end the output with a different string::"
 msgstr ""
+"آرگومان کلیدی *end* می‌تواند برای جلوگیری از ایجاد خط جدید پس از خروجی، یا "
+"پایان دادن خروجی با یک رشتهٔ متفاوت استفاده شود::"
 
 #: ../../tutorial/introduction.rst:557
 msgid ""
@@ -884,10 +1283,16 @@ msgid ""
 "...\n"
 "0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
 msgstr ""
+">>> a, b = 0, 1\n"
+">>> while a < 1000:\n"
+"...     print(a, end=',')\n"
+"...     a, b = b, a+b\n"
+"...\n"
+"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
 
 #: ../../tutorial/introduction.rst:566
 msgid "Footnotes"
-msgstr ""
+msgstr "پانویس‌ها"
 
 #: ../../tutorial/introduction.rst:567
 msgid ""
@@ -895,6 +1300,9 @@ msgid ""
 "as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you "
 "can use ``(-3)**2``."
 msgstr ""
+"از آنجا که ``**`` تقدم بیشتری نسبت به ``-`` دارد، عبارت ``-3**2`` به‌صورت ``-"
+"(3**2)`` تفسیر می‌شود و در نتیجه مقدار ``-9`` را تولید می‌کند. برای جلوگیری از "
+"این موضوع و به‌دست آوردن ``9``، می‌توانید از ``(-3)**2`` استفاده کنید."
 
 #: ../../tutorial/introduction.rst:571
 msgid ""
@@ -903,11 +1311,15 @@ msgid ""
 "only difference between the two is that within single quotes you don't need "
 "to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
 msgstr ""
+"برخلاف زبان‌های دیگر، نویسه‌های ویژه‌ای مانند ``\\n`` در هر دو نوع نقل‌قول تکی "
+"(``'...'``) و نقل‌قول دوتایی (``\"...\"``) معنای یکسانی دارند. تنها تفاوت بین "
+"این دو این است که درون نقل‌قول‌های تکی نیازی به escape کردن ``\"`` ندارید (اما "
+"باید ``\\'`` را escape کنید) و برعکس."
 
 #: ../../tutorial/introduction.rst:20
 msgid "# (hash)"
-msgstr ""
+msgstr "# (hash)"
 
 #: ../../tutorial/introduction.rst:20
 msgid "comment"
-msgstr ""
+msgstr "comment"

From 9c263d8e058854926aaa67c5e73a932484b0a0a9 Mon Sep 17 00:00:00 2001
From: Sepehr Rasouli <sepehrrasouli06@gmail.com>
Date: Thu, 13 Aug 2026 09:01:15 +0330
Subject: [PATCH 2/2] Fix problematic backtick

---
 tutorial/introduction.po | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tutorial/introduction.po b/tutorial/introduction.po
index f486bc96e..097e5d54c 100644
--- a/tutorial/introduction.po
+++ b/tutorial/introduction.po
@@ -36,8 +36,8 @@ msgid ""
 "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:`...`) از یکدیگر متمایز می‌شوند: برای تکرار مثال، باید هر چیزی را که "
+"در مثال‌های زیر، ورودی و خروجی با وجود یا نبود اعلان‌ها (:term:`>>>` و "
+":term:`...`) از یکدیگر متمایز می‌شوند: برای تکرار مثال، باید هر چیزی را که "
 "پس از اعلان ظاهر می‌شود، زمانی که اعلان نمایش داده می‌شود، تایپ کنید؛ خط‌هایی "
 "که با اعلان شروع نمی‌شوند، خروجی مفسر هستند. توجه کنید که یک اعلان ثانویه که "
 "در یک مثال به‌تنهایی در یک خط قرار دارد، به این معنی است که باید یک خط خالی "