inputoutput.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
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# invincible627 <fatemehzahra810@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-10-06 20:25+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid "Input and output"
msgstr "ورودی و خروجی"

msgid "There are several ways to present the output of a program; data can be printed in a human-readable form, or written to a file for future use. This chapter will discuss some of the possibilities."
msgstr "روش‌های گوناگونی برای نمایش خروجی یک برنامه وجود دارد؛ داده‌ها را می‌توان به‌صورت قابل‌خواندن برای انسان چاپ کرد، یا برای استفاده‌ی بعدی در یک پرونده نوشت. این فصل به بررسی برخی از این امکانات می‌پردازد."

msgid "Fancier output formatting"
msgstr "قالب‌بندی پیشرفته‌تر خروجی"

msgid "So far we've encountered two ways of writing values: *expression statements* and the :func:`print` function.  (A third way is using the :meth:`~io.TextIOBase.write` method of file objects; the standard output file can be referenced as ``sys.stdout``. See the Library Reference for more information on this.)"
msgstr "تا اینجا با دو روش برای نوشتن مقادیر آشنا شده‌ایم: *عبارت‌های دستوری* (expression statements) و تابع :func:`print`. (روش سوم استفاده از متد :meth:`~io.TextIOBase.write` اشیاء پرونده است؛ پرونده خروجی استاندارد را می‌توان با ``sys.stdout`` ارجاع داد. برای اطلاعات بیشتر به مرجع کتابخانه مراجعه کنید.)"

msgid "Often you'll want more control over the formatting of your output than simply printing space-separated values. There are several ways to format output."
msgstr "اغلب، کنترل بیشتری بر قالب‌بندی خروجی خود می‌خواهید تا صرفاً چاپ مقادیر با فاصله از هم. روش‌های گوناگونی برای قالب‌بندی خروجی وجود دارد."

msgid "To use :ref:`formatted string literals <tut-f-strings>`, begin a string with ``f`` or ``F`` before the opening quotation mark or triple quotation mark. Inside this string, you can write a Python expression between ``{`` and ``}`` characters that can refer to variables or literal values."
msgstr "برای استفاده از :ref:`مقادیر لفظی رشته‌ای قالبی <tut-f-strings>`، یک رشته را با ``f`` یا ``F`` قبل از علامت نقل‌قول یا نقل‌قول سه‌گانه آغاز کنید. درون این رشته، می‌توانید یک عبارت پایتون را بیننویسه‌های ``{`` و ``}`` بنویسید که می‌تواند به متغیرها یا مقادیر لفظی ارجاع دهد."

msgid ""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"
msgstr ""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"

msgid "The :meth:`str.format` method of strings requires more manual effort.  You'll still use ``{`` and ``}`` to mark where a variable will be substituted and can provide detailed formatting directives, but you'll also need to provide the information to be formatted. In the following code block there are two examples of how to format variables:"
msgstr "متد :meth:`str.format` رشته‌ها نیازمند تلاش دستی بیشتری است.  هنوز از ``{`` و ``}`` برای مشخص کردن جایی که یک متغیر جایگزین می‌شود استفاده می‌کنید و می‌توانید دایرکتیوهای دقیق قالب‌بندی ارائه دهید، اما همچنین نیاز دارید اطلاعاتی که قرار است قالب‌بندی شوند را ارائه دهید. در بلوک کد زیر دو مثال از نحوه‌ی قالب‌بندی متغیرها آورده شده است:"

msgid ""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes  49.67%'"
msgstr ""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes  49.67%'"

msgid "Notice how the ``yes_votes`` are padded with spaces and a negative sign only for negative numbers. The example also prints ``percentage`` multiplied by 100, with 2 decimal places and followed by a percent sign (see :ref:`formatspec` for details)."
msgstr "توجه کنید که چگونه ``yes_votes`` با فاصله پر می‌شود و علامت منفی فقط برای اعداد منفی است. مثال همچنین ``percentage`` را ضرب‌شده در ۱۰۰، با ۲ رقم اعشار و به دنبال آن علامت درصد چاپ می‌کند (برای جزئیات به :ref:`formatspec` مراجعه کنید)."

msgid "Finally, you can do all the string handling yourself by using string slicing and concatenation operations to create any layout you can imagine.  The string type has some methods that perform useful operations for padding strings to a given column width."
msgstr "در نهایت، می‌توانید تمام کارهای مربوط به رشته را خودتان با استفاده از اسلایس رشته و عملیات الحاق انجام دهید تا هر چیدمانی که تصور می‌کنید را ایجاد کنید.  نوع رشته دارای متدهایی است که عملیات مفیدی برای پر کردن رشته‌ها تا پهنای ستون مشخصی انجام می‌دهند."

msgid "When you don't need fancy output but just want a quick display of some variables for debugging purposes, you can convert any value to a string with the :func:`repr` or :func:`str` functions."
msgstr "وقتی به خروجی پیشرفته‌ای نیاز ندارید و فقط می‌خواهید نمایش سریعی از برخی متغیرها را برای اهداف اشکال‌زدایی داشته باشید، می‌توانید هر مقداری را با توابع :func:`repr` یا :func:`str` به رشته تبدیل کنید."

msgid "The :func:`str` function is meant to return representations of values which are fairly human-readable, while :func:`repr` is meant to generate representations which can be read by the interpreter (or will force a :exc:`SyntaxError` if there is no equivalent syntax).  For objects which don't have a particular representation for human consumption, :func:`str` will return the same value as :func:`repr`.  Many values, such as numbers or structures like lists and dictionaries, have the same representation using either function.  Strings, in particular, have two distinct representations."
msgstr "تابع :func:`str` برای بازگرداندن نمایشی از مقادیر طراحی شده است که تا حدی قابل‌خواندن برای انسان باشد، در حالی که :func:`repr` برای تولید نمایشی طراحی شده که توسط مفسر قابل خواندن باشد (یا اگر معادل نحوی وجود نداشته باشد، یک :exc:`SyntaxError` پرتاب می‌کند).  برای اشیایی که نمایش خاصی برای مصرف انسان ندارند، :func:`str` همان مقدار :func:`repr` را بازمی‌گرداند.  بسیاری از مقادیر، مانند اعداد یا ساختارهایی مانند فهرست‌ها و دیکشنری‌ها، با استفاده از هر دو تابع نمایش یکسانی دارند.  به‌ویژه رشته‌ها، دو نمایش متمایز دارند."

msgid "Some examples::"
msgstr "چند مثال::"

msgid ""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"\"'Hello, world.'\"\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # The repr() of a string adds string quotes and backslashes:\n"
">>> hello = 'hello, world\\n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world\\n'\n"
">>> # The argument to repr() may be any Python object:\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"\"(32.5, 40000, ('spam', 'eggs'))\""
msgstr ""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"\"'Hello, world.'\"\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # The repr() of a string adds string quotes and backslashes:\n"
">>> hello = 'hello, world\\n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world\\n'\n"
">>> # The argument to repr() may be any Python object:\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"\"(32.5, 40000, ('spam', 'eggs'))\""

msgid "The :mod:`string` module contains support for a simple templating approach based upon regular expressions, via :class:`string.Template`. This offers yet another way to substitute values into strings, using placeholders like ``$x`` and replacing them with values from a dictionary. This syntax is easy to use, although it offers much less control for formatting."
msgstr "ماژول :mod:`string` شامل پشتیبانی از یک رویکرد ساده‌ی قالب‌بندی (templating) است که بر اساس عبارت‌های باقاعده (regular expressions) و از طریق :class:`string.Template` کار می‌کند. این روشی دیگر برای جایگزینی مقادیر در رشته‌ها ارائه می‌دهد، با استفاده از جای‌نگهدارهایی (placeholders) مانند ``$x`` و جایگزینی آن‌ها با مقادیر یک دیکشنری. این سینتکس (سینتکس) آسان است، اگرچه کنترل بسیار کمتری برای قالب‌بندی ارائه می‌دهد."

msgid "Formatted string literals"
msgstr "مقادیر لفظی رشته‌ای قالب‌بندی‌شده"

msgid ":ref:`Formatted string literals <f-strings>` (also called f-strings for short) let you include the value of Python expressions inside a string by prefixing the string with ``f`` or ``F`` and writing expressions as ``{expression}``."
msgstr ":ref:`مقادیر لفظی رشته‌ای قالبی <f-strings>` (که به‌طور خلاصه f-strings نیز نامیده می‌شوند) به شما اجازه می‌دهند که مقدار عبارت‌های پایتون را درون یک رشته با پیشوندگذاری رشته با ``f`` یا ``F`` و نوشتن عبارت‌ها به صورت ``{expression}`` بگنجانید."

msgid "An optional format specifier can follow the expression. This allows greater control over how the value is formatted. The following example rounds pi to three places after the decimal::"
msgstr "یک مشخص‌کننده‌ی قالب اختیاری می‌تواند پس از عبارت بیاید. این امکان کنترل بیشتری بر نحوه‌ی قالب‌بندی مقدار فراهم می‌کند. مثال زیر، عدد پی (pi) را تا سه رقم اعشار گرد می‌کند::"

msgid ""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."
msgstr ""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."

msgid "Passing an integer after the ``':'`` will cause that field to be a minimum number of characters wide.  This is useful for making columns line up. ::"
msgstr "گذراندن یک عدد صحیح بعد از ``':'`` باعث می‌شود که آن فیلد حداقل به آن اندازه نویسه عرض داشته باشد.  این برای هم‌تراز کردن ستون‌ها مفید است. ::"

msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"...     print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd     ==>       4127\n"
"Jack       ==>       4098\n"
"Dcab       ==>       7678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"...     print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd     ==>       4127\n"
"Jack       ==>       4098\n"
"Dcab       ==>       7678"

msgid "Other modifiers can be used to convert the value before it is formatted. ``'!a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` applies :func:`repr`::"
msgstr "اصلاح‌کننده‌های دیگری را می‌توان برای تبدیل مقدار قبل از قالب‌بندی استفاده کرد. ``'!a'`` تابع :func:`ascii` را اعمال می‌کند، ``'!s'`` تابع :func:`str` را، و ``'!r'`` تابع :func:`repr` را اعمال می‌کند::"

msgid ""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."
msgstr ""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."

msgid "The ``=`` specifier can be used to expand an expression to the text of the expression, an equal sign, then the representation of the evaluated expression:"
msgstr "مشخص‌کننده‌ی ``=`` را می‌توان برای گسترش یک عبارت به متن خود عبارت، یک علامت مساوی، و سپس نمایش عبارت ارزیابی‌شده استفاده کرد:"

msgid "See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more information on the ``=`` specifier. For a reference on these format specifications, see the reference guide for the :ref:`formatspec`."
msgstr "برای اطلاعات بیشتر درباره‌ی مشخص‌کننده‌ی ``=``، به :ref:`عبارات خودمستند <bpo-36817-whatsnew>` مراجعه کنید. برای مرجعی در مورد این مشخصات قالب‌بندی، به راهنمای مرجع برای :ref:`formatspec` مراجعه کنید."

msgid "The string format() method"
msgstr "متد format() رشته"

msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr "استفاده‌ی پایه از متد :meth:`str.format` به این شکل است::"

msgid ""
">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"
"We are the knights who say \"Ni!\""
msgstr ""
">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"
"We are the knights who say \"Ni!\""

msgid "The brackets and characters within them (called format fields) are replaced with the objects passed into the :meth:`str.format` method.  A number in the brackets can be used to refer to the position of the object passed into the :meth:`str.format` method. ::"
msgstr "براکت‌ها و نویسه‌های داخل آن‌ها (که فیلدهای قالب نامیده می‌شوند) با اشیاء ارسال‌شده به متد :meth:`str.format` جایگزین می‌شوند.  از یک عدد درون براکت‌ها می‌توان برای اشاره به جایگاه شیء ارسال‌شده به متد :meth:`str.format` استفاده کرد. ::"

msgid ""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"
msgstr ""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"

msgid "If keyword arguments are used in the :meth:`str.format` method, their values are referred to by using the name of the argument. ::"
msgstr "اگر از آرگومان‌های کلیدواژه‌ای در متد :meth:`str.format` استفاده شود، مقادیر آن‌ها با استفاده از نام آرگومان ارجاع داده می‌شوند. ::"

msgid ""
">>> print('This {food} is {adjective}.'.format(\n"
"...       food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."
msgstr ""
">>> print('This {food} is {adjective}.'.format(\n"
"...       food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."

msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr "آرگومان‌های جایگاهی و کلیدواژه‌ای را می‌توان به‌طور دلخواه ترکیب کرد::"

msgid ""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"...                                                    other='Georg'))\n"
"The story of Bill, Manfred, and Georg."
msgstr ""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"...                                                    other='Georg'))\n"
"The story of Bill, Manfred, and Georg."

msgid "If you have a really long format string that you don't want to split up, it would be nice if you could reference the variables to be formatted by name instead of by position.  This can be done by simply passing the dict and using square brackets ``'[]'`` to access the keys. ::"
msgstr "اگر یک رشته‌ی قالبی واقعاً طولانی دارید که نمی‌خواهید آن را تقسیم کنید، خوب می‌شد اگر می‌توانستید به متغیرهایی که قرار است قالب‌بندی شوند با نام ارجاع دهید، نه با جایگاه.  این کار را می‌توان با ارسال دیکشنری و استفاده از براکت‌های مربعی ``'[]'`` برای دسترسی به کلیدها انجام داد. ::"

msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"...       'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"...       'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgid "This could also be done by passing the ``table`` dictionary as keyword arguments with the ``**`` notation. ::"
msgstr "این کار را همچنین می‌توان با ارسال دیکشنری ``table`` به‌عنوان آرگومان‌های کلیدواژه‌ای با نماد ``**`` انجام داد. ::"

msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgid "This is particularly useful in combination with the built-in function :func:`vars`, which returns a dictionary containing all local variables::"
msgstr "این به‌ویژه در ترکیب با تابع توکار :func:`vars` مفید است، که یک دیکشنری شامل همه‌ی متغیرهای محلی بازمی‌گرداند::"

msgid ""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."
msgstr ""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

msgid "As an example, the following lines produce a tidily aligned set of columns giving integers and their squares and cubes::"
msgstr "به‌عنوان مثال، سطرهای زیر مجموعه‌ای از ستون‌های مرتب و هم‌تراز تولید می‌کنند که اعداد صحیح و مربع و مکعب آن‌ها را نشان می‌دهد::"

msgid ""
">>> for x in range(1, 11):\n"
"...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""
">>> for x in range(1, 11):\n"
"...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"

msgid "For a complete overview of string formatting with :meth:`str.format`, see :ref:`formatstrings`."
msgstr "برای دریافت نمای کلی کامل از قالب‌بندی رشته با :meth:`str.format`، به :ref:`formatstrings` مراجعه کنید."

msgid "Manual string formatting"
msgstr "قالب‌بندی دستی رشته"

msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "در اینجا همان جدول مربع‌ها و مکعب‌ها، به‌صورت دستی قالب‌بندی شده است::"

msgid ""
">>> for x in range(1, 11):\n"
"...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"...     # Note use of 'end' on previous line\n"
"...     print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""
">>> for x in range(1, 11):\n"
"...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"...     # Note use of 'end' on previous line\n"
"...     print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"

msgid "(Note that the one space between each column was added by the way :func:`print` works: it always adds spaces between its arguments.)"
msgstr "(توجه داشته باشید که یک فاصله بین هر ستون توسط نحوه‌ی کار تابع :func:`print` اضافه شده است: این تابع همیشه بین آرگومان‌های خود فاصله اضافه می‌کند.)"

msgid "The :meth:`str.rjust` method of string objects right-justifies a string in a field of a given width by padding it with spaces on the left. There are similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do not write anything, they just return a new string. If the input string is too long, they don't truncate it, but return it unchanged; this will mess up your column lay-out but that's usually better than the alternative, which would be lying about a value. (If you really want truncation you can always add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr "متد :meth:`str.rjust` از اشیاء رشته، یک رشته را در یک فیلد با عرض مشخص، با پر کردن آن با فاصله از سمت چپ، راست‌چین می‌کند. روش‌های مشابهی :meth:`str.ljust` و :meth:`str.center` نیز وجود دارند. این متدها هیچ چیزی نمی‌نویسند، فقط یک رشته‌ی جدید بازمی‌گردانند. اگر رشته‌ی ورودی خیلی طولانی باشد، آن را کوتاه نمی‌کنند، بلکه آن را بدون تغییر بازمی‌گردانند؛ این کار چیدمان ستون‌های شما را به هم می‌ریزد، اما این معمولاً بهتر از حالت جایگزین است، که دروغ گفتن درباره‌ی یک مقدار است. (اگر واقعاً کوتاه‌سازی می‌خواهید، همیشه می‌توانید یک عملیات اسلایس اضافه کنید، مانند ``x.ljust(n)[:n]``.)"

msgid "There is another method, :meth:`str.zfill`, which pads a numeric string on the left with zeros.  It understands about plus and minus signs::"
msgstr "روش دیگری نیز وجود دارد، :meth:`str.zfill`، که یک رشته‌ی عددی را در سمت چپ با صفر پر می‌کند. این روش، علائم مثبت و منفی را نیز در نظر می‌گیرد::"

msgid ""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"
msgstr ""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"

msgid "Old string formatting"
msgstr "قالب‌بندی قدیمی رشته‌ها"

msgid "The % operator (modulo) can also be used for string formatting. Given ``format % values`` (where *format* is a string), ``%`` conversion specifications in *format* are replaced with zero or more elements of *values*. This operation is commonly known as string interpolation. For example::"
msgstr "عملگر % (باقیمانده) نیز می‌تواند برای قالب‌بندی رشته استفاده شود. با فرض ``format % values`` (که در آن *format* یک رشته است)، مشخصات تبدیل ``%`` در *format* با صفر یا چند عنصر از *values* جایگزین می‌شوند. این عملیات معمولاً به عنوان درون‌یابی رشته (string interpolation) شناخته می‌شود. برای مثال::"

msgid ""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."
msgstr ""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."

msgid "More information can be found in the :ref:`old-string-formatting` section."
msgstr "اطلاعات بیشتر می‌تواند در بخش :ref:`old-string-formatting` پیدا شود."

msgid "Reading and writing files"
msgstr "خواندن و نوشتن پرونده‌ها"

msgid ":func:`open` returns a :term:`file object`, and is most commonly used with two positional arguments: ``open(filename, mode)``"
msgstr ":func:`open` یک :term:`شیء پرونده <file object>` برمی‌گرداند و معمولاً با دو آرگومان جایگاهی استفاده می‌شود: ``open(filename, mode)``"

msgid ">>> f = open('workfile', 'w')"
msgstr ">>> f = open('workfile', 'w')"

msgid "The first argument is a string containing the filename.  The second argument is another string containing a few characters describing the way in which the file will be used.  *mode* can be ``'r'`` when the file will only be read, ``'w'`` for only writing (an existing file with the same name will be erased), and ``'a'`` opens the file for appending; any data written to the file is automatically added to the end.  ``'r+'`` opens the file for both reading and writing. The *mode* argument is optional; ``'r'`` will be assumed if it's omitted."
msgstr "آرگومان اول رشته‌ای است که نام پرونده را در بر دارد.  آرگومان دوم رشته‌ی دیگری است که شامل چند نویسه است و نحوه‌ی استفاده از پرونده را توضیح می‌دهد.  *mode* می‌تواند ``'r'`` باشد زمانی که پرونده فقط خوانده می‌شود، ``'w'`` برای فقط نوشتن (یک پرونده موجود با همان نام حذف خواهد شد)، و ``'a'`` پرونده را برای افزودن (append) باز می‌کند؛ هر داده‌ای که در پرونده نوشته شود به‌طور خودکار به انتهای آن اضافه می‌شود.  ``'r+'`` پرونده را هم برای خواندن و هم برای نوشتن باز می‌کند. آرگومان *mode* اختیاری است؛ اگر حذف شود، ``'r'`` در نظر گرفته می‌شود."

msgid "Normally, files are opened in :dfn:`text mode`, that means, you read and write strings from and to the file, which are encoded in a specific *encoding*. If *encoding* is not specified, the default is UTF-8 (see :func:`open`). Appending a ``'b'`` to the mode opens the file in :dfn:`binary mode`. Binary mode data is read and written as :class:`bytes` objects. You can not specify *encoding* when opening file in binary mode."
msgstr "به‌طور معمول، پرونده‌ها در :dfn:`حالت متنی` باز می‌شوند؛ یعنی رشته‌ها را از پرونده می‌خوانید و رشته‌ها را در پرونده می‌نویسید که با یک *encoding* مشخص کدگذاری شده‌اند. اگر *encoding* مشخص نشده باشد، مقدار پیش‌فرض UTF-8 است (به :func:`open` مراجعه کنید). افزودن ``'b'`` به حالت، پرونده را در :dfn:`حالت دودویی` باز می‌کند. داده‌ها در حالت دودویی به‌صورت شیءهای :class:`bytes` خوانده و نوشته می‌شوند. هنگام بازکردن پرونده در حالت دودویی، نمی‌توانید *encoding* را مشخص کنید."

msgid "In text mode, the default when reading is to convert platform-specific line endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When writing in text mode, the default is to convert occurrences of ``\\n`` back to platform-specific line endings.  This behind-the-scenes modification to file data is fine for text files, but will corrupt binary data like that in :file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when reading and writing such files."
msgstr "در حالت متنی، حالت پیش‌فرض هنگام خواندن، تبدیل پایان‌سطرهای ویژه‌ی هر سیستم‌عامل (``\\n`` در یونیکس، ``\\r\\n`` در ویندوز) به فقط ``\\n`` است.  هنگام نوشتن در حالت متنی، حالت پیش‌فرض تبدیل ``\\n`` به پایان‌سطرهای ویژه‌ی هر سیستم‌عامل است.  این تغییرات پشت‌صحنه در داده‌های پرونده برای پرونده‌های متنی خوب است، اما داده‌های دودویی مانند پرونده‌های :file:`JPEG` یا :file:`EXE` را خراب می‌کند.  هنگام خواندن و نوشتن چنین پرونده‌هایی بسیار دقت کنید که از حالت دودویی استفاده کنید."

msgid "It is good practice to use the :keyword:`with` keyword when dealing with file objects.  The advantage is that the file is properly closed after its suite finishes, even if an exception is raised at some point.  Using :keyword:`!with` is also much shorter than writing equivalent :keyword:`try`\\ -\\ :keyword:`finally` blocks::"
msgstr "استفاده از کلیدواژه‌ی :keyword:`with` هنگام کار با اشیاء پرونده، یک روش خوب است.  مزیت آن این است که پرونده پس از پایان بدنه خود به‌درستی بسته می‌شود، حتی اگر در جایی استثنا ایجاد شود.  استفاده از :keyword:`!with` همچنین بسیار کوتاه‌تر از نوشتن بلوک‌های معادل :keyword:`try`\\ -\\ :keyword:`finally` است::"

msgid ""
">>> with open('workfile') as f:\n"
"...     read_data = f.read()\n"
"\n"
">>> # We can check that the file has been automatically closed.\n"
">>> f.closed\n"
"True"
msgstr ""
">>> with open('workfile') as f:\n"
"...     read_data = f.read()\n"
"\n"
">>> # We can check that the file has been automatically closed.\n"
">>> f.closed\n"
"True"

msgid "If you're not using the :keyword:`with` keyword, then you should call ``f.close()`` to close the file and immediately free up any system resources used by it."
msgstr "اگر از کلیدواژه‌ی :keyword:`with` استفاده نمی‌کنید، باید ``f.close()`` را فراخوانی کنید تا پرونده بسته شود و هر گونه منابع سیستمی که توسط آن استفاده می‌شود، بلافاصله آزاد شوند."

msgid "Calling ``f.write()`` without using the :keyword:`!with` keyword or calling ``f.close()`` **might** result in the arguments of ``f.write()`` not being completely written to the disk, even if the program exits successfully."
msgstr "فراخوانی ``f.write()`` بدون استفاده از کلیدواژه‌ی :keyword:`!with` یا فراخوانی ``f.close()`` **ممکن است** باعث شود که آرگومان‌های ``f.write()`` به‌طور کامل روی دیسک نوشته نشوند، حتی اگر برنامه با موفقیت خارج شود."

msgid "After a file object is closed, either by a :keyword:`with` statement or by calling ``f.close()``, attempts to use the file object will automatically fail. ::"
msgstr "پس از بسته شدن یک شیء پرونده، چه توسط دستور :keyword:`with` و چه با فراخوانی ``f.close()``، تلاش برای استفاده از شیء پرونده به‌طور خودکار با شکست مواجه می‌شود. ::"

msgid ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ValueError: I/O operation on closed file."
msgstr ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ValueError: I/O operation on closed file."

msgid "Methods of file objects"
msgstr "متدهای اشیاء پرونده"

msgid "The rest of the examples in this section will assume that a file object called ``f`` has already been created."
msgstr "بقیه‌ی مثال‌های این بخش فرض می‌کنند که یک شیء پرونده به نام ``f`` قبلاً ایجاد شده است."

msgid "To read a file's contents, call ``f.read(size)``, which reads some quantity of data and returns it as a string (in text mode) or bytes object (in binary mode). *size* is an optional numeric argument.  When *size* is omitted or negative, the entire contents of the file will be read and returned; it's your problem if the file is twice as large as your machine's memory. Otherwise, at most *size* characters (in text mode) or *size* bytes (in binary mode) are read and returned. If the end of the file has been reached, ``f.read()`` will return an empty string (``''``).  ::"
msgstr "برای خواندن محتویات یک پرونده، ``f.read(size)`` را فراخوانی کنید، که مقدار مشخصی از داده را خوانده و آن را به صورت یک رشته (در حالت متنی) یا یک شیء bytes (در حالت دودویی) بازمی‌گرداند. *size* یک آرگومان عددی اختیاری است.  وقتی *size* حذف شود یا منفی باشد، تمام محتویات پرونده خوانده شده و بازگردانده می‌شود؛ اگر پرونده دو برابر حافظه‌ی دستگاه شما باشد، این مشکل شماست. در غیر این صورت، حداکثر *size* نویسه (در حالت متنی) یا *size* بایت (در حالت دودویی) خوانده و بازگردانده می‌شوند. اگر به پایان پرونده رسیده باشد، ``f.read()`` یک رشته‌ی خالی (``''``) بازمی‌گرداند.  ::"

msgid ""
">>> f.read()\n"
"'This is the entire file.\\n'\n"
">>> f.read()\n"
"''"
msgstr ""
">>> f.read()\n"
"'This is the entire file.\\n'\n"
">>> f.read()\n"
"''"

msgid "``f.readline()`` reads a single line from the file; a newline character (``\\n``) is left at the end of the string, and is only omitted on the last line of the file if the file doesn't end in a newline.  This makes the return value unambiguous; if ``f.readline()`` returns an empty string, the end of the file has been reached, while a blank line is represented by ``'\\n'``, a string containing only a single newline.  ::"
msgstr "``f.readline()`` یک سطر از پرونده را می‌خواند؛ یک نویسه‌ی سطر جدید (``\\n``) در انتهای رشته باقی می‌ماند، و فقط در آخرین سطر پرونده حذف می‌شود اگر پرونده با یک سطر جدید پایان نیابد.  این باعث می‌شود که مقدار بازگشتی بدون ابهام باشد؛ اگر ``f.readline()`` یک رشته‌ی خالی بازگرداند، به پایان پرونده رسیده‌ایم، در حالی که یک سطر خالی با ``'\\n'``، یعنی یک رشته که فقط شامل یک سطر جدید است، نشان داده می‌شود.  ::"

msgid ""
">>> f.readline()\n"
"'This is the first line of the file.\\n'\n"
">>> f.readline()\n"
"'Second line of the file\\n'\n"
">>> f.readline()\n"
"''"
msgstr ""
">>> f.readline()\n"
"'This is the first line of the file.\\n'\n"
">>> f.readline()\n"
"'Second line of the file\\n'\n"
">>> f.readline()\n"
"''"

msgid "For reading lines from a file, you can loop over the file object. This is memory efficient, fast, and leads to simple code::"
msgstr "برای خواندن سطرها از یک پرونده، می‌توانید روی خود شیء پرونده حلقه بزنید. این روش کارآمد از نظر حافظه، سریع است و به کد ساده‌ای منجر می‌شود::"

msgid ""
">>> for line in f:\n"
"...     print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"
msgstr ""
">>> for line in f:\n"
"...     print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"

msgid "If you want to read all the lines of a file in a list you can also use ``list(f)`` or ``f.readlines()``."
msgstr "اگر می‌خواهید تمام سطرهای یک پرونده را در یک فهرست بخوانید، می‌توانید از ``list(f)`` یا ``f.readlines()`` نیز استفاده کنید."

msgid "``f.write(string)`` writes the contents of *string* to the file, returning the number of characters written. ::"
msgstr "``f.write(string)`` محتویات *string* را در پرونده می‌نویسد و تعداد نویسه‌های نوشته‌شده را بازمی‌گرداند. ::"

msgid ""
">>> f.write('This is a test\\n')\n"
"15"
msgstr ""
">>> f.write('This is a test\\n')\n"
"15"

msgid "Other types of objects need to be converted -- either to a string (in text mode) or a bytes object (in binary mode) -- before writing them::"
msgstr "انواع دیگر اشیاء باید تبدیل شوند -- یا به یک رشته (در حالت متنی) یا به یک شیء bytes (در حالت دودویی) -- قبل از نوشتن آن‌ها::"

msgid ""
">>> value = ('the answer', 42)\n"
">>> s = str(value)  # convert the tuple to string\n"
">>> f.write(s)\n"
"18"
msgstr ""
">>> value = ('the answer', 42)\n"
">>> s = str(value)  # convert the tuple to string\n"
">>> f.write(s)\n"
"18"

msgid "``f.tell()`` returns an integer giving the file object's current position in the file represented as number of bytes from the beginning of the file when in binary mode and an opaque number when in text mode."
msgstr "``f.tell()`` یک عدد صحیح بازمی‌گرداند که موقعیت جاری شیء پرونده را در پرونده نشان می‌دهد، که در حالت دودویی به صورت تعداد بایت‌ها از ابتدای پرونده و در حالت متنی به صورت یک عدد مبهم است."

msgid "To change the file object's position, use ``f.seek(offset, whence)``.  The position is computed from adding *offset* to a reference point; the reference point is selected by the *whence* argument.  A *whence* value of 0 measures from the beginning of the file, 1 uses the current file position, and 2 uses the end of the file as the reference point.  *whence* can be omitted and defaults to 0, using the beginning of the file as the reference point. ::"
msgstr "برای تغییر موقعیت شیء پرونده، از ``f.seek(offset, whence)`` استفاده کنید.  موقعیت با افزودن *offset* به یک نقطه‌ی مرجع محاسبه می‌شود؛ نقطه‌ی مرجع توسط آرگومان *whence* انتخاب می‌شود.  مقدار *whence* برابر با 0 از ابتدای پرونده اندازه‌گیری می‌کند، 1 از موقعیت جاری پرونده استفاده می‌کند، و 2 از پایان پرونده به عنوان نقطه‌ی مرجع استفاده می‌کند.  *whence* را می‌توان حذف کرد و مقدار پیش‌فرض آن 0 است، یعنی از ابتدای پرونده به‌عنوان نقطه‌ی مرجع استفاده می‌کند. ::"

msgid ""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5)      # Go to the 6th byte in the file\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2)  # Go to the 3rd byte before the end\n"
"13\n"
">>> f.read(1)\n"
"b'd'"
msgstr ""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5)      # Go to the 6th byte in the file\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2)  # Go to the 3rd byte before the end\n"
"13\n"
">>> f.read(1)\n"
"b'd'"

msgid "In text files (those opened without a ``b`` in the mode string), only seeks relative to the beginning of the file are allowed (the exception being seeking to the very file end with ``seek(0, 2)``) and the only valid *offset* values are those returned from the ``f.tell()``, or zero. Any other *offset* value produces undefined behaviour."
msgstr "در پرونده‌های متنی (آنهایی که بدون ``b`` در رشته‌ی حالت باز شده‌اند)، فقط مکان‌یابی‌های نسبت به ابتدای پرونده مجاز هستند (به جز مکان‌یابی به پایان پرونده با ``seek(0, 2)``) و تنها مقادیر معتبر *offset* مقادیری هستند که از ``f.tell()`` بازگردانده می‌شوند، یا صفر. هر مقدار *offset* دیگر رفتار تعریف‌نشده‌ای ایجاد می‌کند."

msgid "File objects have some additional methods, such as :meth:`~io.IOBase.isatty` and :meth:`~io.IOBase.truncate` which are less frequently used; consult the Library Reference for a complete guide to file objects."
msgstr "اشیاء پرونده دارای متدهای اضافی دیگری نیز هستند، مانند :meth:`~io.IOBase.isatty` و :meth:`~io.IOBase.truncate` که کمتر استفاده می‌شوند؛ برای راهنمای کامل اشیاء پرونده به مرجع کتابخانه مراجعه کنید."

msgid "Saving structured data with :mod:`json`"
msgstr "ذخیره‌سازی داده‌های ساختاریافته با :mod:`json`"

msgid "Strings can easily be written to and read from a file.  Numbers take a bit more effort, since the :meth:`~io.TextIOBase.read` method only returns strings, which will have to be passed to a function like :func:`int`, which takes a string like ``'123'`` and returns its numeric value 123.  When you want to save more complex data types like nested lists and dictionaries, parsing and serializing by hand becomes complicated."
msgstr "رشته‌ها را به‌راحتی می‌توان در پرونده نوشت و از آن خواند.  اعداد کمی بیشتر تلاش نیاز دارند، زیرا متد :meth:`~io.TextIOBase.read` فقط رشته‌ها را بازمی‌گرداند، که باید به تابعی مانند :func:`int` داده شوند، که یک رشته مانند ``'123'`` را گرفته و مقدار عددی آن، یعنی 123، را بازمی‌گرداند.  وقتی می‌خواهید انواع داده‌ی پیچیده‌تر مانند فهرست‌های تو در تو و دیکشنری‌ها را ذخیره کنید، تجزیه و سریال‌سازی دستی پیچیده می‌شود."

msgid "Rather than having users constantly writing and debugging code to save complicated data types to files, Python allows you to use the popular data interchange format called `JSON (JavaScript Object Notation) <https://json.org>`_.  The standard module called :mod:`json` can take Python data hierarchies, and convert them to string representations; this process is called :dfn:`serializing`.  Reconstructing the data from the string representation is called :dfn:`deserializing`.  Between serializing and deserializing, the string representing the object may have been stored in a file or data, or sent over a network connection to some distant machine."
msgstr "به جای اینکه کاربران دائماً کد بنویسند و دیباگ کنند تا انواع داده‌ی پیچیده را در پرونده‌ها ذخیره کنند، پایتون به شما اجازه می‌دهد از فرمت محبوب تبادل داده به نام `JSON (JavaScript Object Notation) <https://json.org>`_ استفاده کنید.  ماژول استاندارد :mod:`json` می‌تواند سلسله‌مراتب داده‌های پایتون را گرفته و آن‌ها را به نمایش‌های رشته‌ای تبدیل کند؛ این فرآیند :dfn:`serializing` نامیده می‌شود.  بازسازی داده از نمایش رشته‌ای :dfn:`deserializing` نامیده می‌شود.  بین سریال‌سازی و سریال‌زدایی، رشته‌ای که شیء را نمایش می‌دهد ممکن است در یک پرونده یا داده ذخیره شده باشد، یا از طریق اتصال شبکه به ماشینی دور فرستاده شده باشد."

msgid "The JSON format is commonly used by modern applications to allow for data exchange.  Many programmers are already familiar with it, which makes it a good choice for interoperability."
msgstr "فرمت JSON معمولاً توسط برنامه‌های مدرن برای تبادل داده استفاده می‌شود.  بسیاری از برنامه‌نویسان از قبل با آن آشنا هستند، که این موضوع آن را به انتخابی خوب برای قابلیت‌عملیات‌پذیری (interoperability) تبدیل می‌کند."

msgid "If you have an object ``x``, you can view its JSON string representation with a simple line of code::"
msgstr "اگر یک شیء ``x`` دارید، می‌توانید نمایش رشته‌ای JSON آن را با یک خط کد ساده مشاهده کنید::"

msgid ""
">>> import json\n"
">>> x = [1, 'simple', 'list']\n"
">>> json.dumps(x)\n"
"'[1, \"simple\", \"list\"]'"
msgstr ""
">>> import json\n"
">>> x = [1, 'simple', 'list']\n"
">>> json.dumps(x)\n"
"'[1, \"simple\", \"list\"]'"

msgid "Another variant of the :func:`~json.dumps` function, called :func:`~json.dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is a :term:`text file` object opened for writing, we can do this::"
msgstr "گونه‌ی دیگری از تابع :func:`~json.dumps`، به نام :func:`~json.dump`، به‌سادگی شیء را در یک :term:`پرونده متنی <text file>` سریال‌سازی می‌کند. بنابراین اگر ``f`` یک شیء :term:`پرونده متنی <text file>` است که برای نوشتن باز شده، می‌توانیم این کار را انجام دهیم::"

msgid "json.dump(x, f)"
msgstr "json.dump(x, f)"

msgid "To decode the object again, if ``f`` is a :term:`binary file` or :term:`text file` object which has been opened for reading::"
msgstr "برای کدگشایی مجدد شیء، اگر ``f`` یک شیء :term:`پرونده دودویی <binary file>` یا :term:`پرونده متنی <text file>` است که برای خواندن باز شده است::"

msgid "x = json.load(f)"
msgstr "x = json.load(f)"

msgid "JSON files must be encoded in UTF-8, the default encoding for :term:`text files <text file>`."
msgstr "پرونده‌های JSON باید با رمزگذاری UTF-8 که رمزگذاری پیش‌فرض برای :term:`پرونده‌های متنی <text file>` است، رمزگذاری شوند."

msgid "This simple serialization technique can handle lists and dictionaries, but serializing arbitrary class instances in JSON requires a bit of extra effort. The reference for the :mod:`json` module contains an explanation of this."
msgstr "این تکنیک ساده‌ی سریال‌سازی می‌تواند فهرست‌ها و دیکشنری‌ها را مدیریت کند، اما سریال‌سازی نمونه‌های دلخواه از کلاس‌ها در JSON نیازمند کمی تلاش اضافی است. مرجع ماژول :mod:`json` شامل توضیحاتی در مورد این موضوع است."

msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - ماژول پیکل"

msgid "Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the serialization of arbitrarily complex Python objects.  As such, it is specific to Python and cannot be used to communicate with applications written in other languages.  It is also insecure by default: deserializing pickle data coming from an untrusted source can execute arbitrary code, if the data was crafted by a skilled attacker."
msgstr "برخلاف :ref:`JSON <tut-json>`، *pickle* پروتکلی است که امکان سریال‌سازی اشیاء پایتون با پیچیدگی دلخواه را فراهم می‌کند.  بنابراین، اختصاصی پایتون است و نمی‌توان از آن برای ارتباط با برنامه‌های نوشته‌شده به زبان‌های دیگر استفاده کرد.  همچنین به‌طور پیش‌فرض ناامن است: سریال‌زدایی داده‌های pickle که از یک منبع غیرقابل‌اعتماد می‌آیند، می‌تواند کد دلخواه را اجرا کند، اگر داده توسط یک مهاجم ماهر ساخته شده باشد."

msgid "formatted string literal"
msgstr "لفظی رشته‌ای قالبی"

msgid "interpolated string literal"
msgstr "لفظی رشته‌ای درون‌یابی‌شده"

msgid "string"
msgstr "رشته"

msgid "formatted literal"
msgstr "لفظی قالبی"

msgid "interpolated literal"
msgstr "لفظی درون‌یابی‌شده"

msgid "f-string"
msgstr "f-string"

msgid "fstring"
msgstr "fstring"

msgid "built-in function"
msgstr "تابع توکار"

msgid "open"
msgstr "open"

msgid "object"
msgstr "شیء"

msgid "file"
msgstr "پرونده"

msgid "module"
msgstr "ماژول"

msgid "json"
msgstr "json"

#~ msgid "Formatted String Literals"
#~ msgstr "مقادیر لفظی رشته‌ای قالبی"