"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-10-01 14:41+0330\n"

"PO-Revision-Date: 2026-09-13 19:29+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 "Classes"

msgstr "کلاس‌ها"

msgid "Classes provide a means of bundling data and functionality together. Creating a new class creates a new *type* of object, allowing new *instances* of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state."

msgstr "کلاس‌ها وسیله‌ای را برای بسته‌بندی کردن داده و عملکرد با هم فراهم می‌کنند. ایجاد یک کلاس جدید، نوع جدیدی ایجاد می‌کند که اجازه می‌دهد انواع جدیدی از آن نوع ساخته شود. هر نمونه از کلاس می‌تواند صفاتی داشته باشد که به آن متصل شده‌اند تا وضعیت آن را حفظ کنند. نمونه‌های کلاس می‌توانند همچنین متدهایی (که توسط کلاس تعریف شده‌اند) داشته باشند تا وضعیت آن را تغییر دهند."

msgid "Compared with other programming languages, Python's class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation."

msgstr "در مقایسه با دیگر زبانهای برنامه‌نویسی، مکانیزم کلاس در پایتون کلاس‌ها را با حداقل قواعد و معناشناسی جدید اضافه می‌کند. این مکانیزم ترکیبی از مکانیزم‌های کلاسی است که در C++ و Modula-3 یافت می‌شود. کلاس‌های پایتون تمام ویژگی‌های استاندارد برنامه‌نویسی شیءگرا را فراهم می‌کنند: مکانیزم ارث بری کلاس‌ها اجازه می‌دهد کلاس‌های پایه‌ی متعددی داشته باشید، یک کلاس مشتق می‌تواند هر یک از متدهای کلاس‌های پایه‌ی خود را بازنویسی کند و یک متد می‌تواند متدی از کلاس پایه با همان نام را فراخوانی کند. اشیاء می‌توانند حاوی مقادیر و انواع داده‌ای دلخواه باشند. همان‌طور که برای ماژول‌ها صادق است، کلاس‌ها نیز از طبیعت پویا در پایتون برخوردارند: آن‌ها در ران‌تایم ایجاد می‌شوند و می‌توانند پس از ایجاد بیشتر تغییر داده شوند."

msgid "In C++ terminology, normally class members (including the data members) are *public* (except see below :ref:`tut-private`), and all member functions are *virtual*. As in Modula-3, there are no shorthands for referencing the object's members from its methods: the method function is declared with an explicit first argument representing the object, which is provided implicitly by the call. As in Smalltalk, classes themselves are objects. This provides semantics for importing and renaming. Unlike C++ and Modula-3, built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax (arithmetic operators, subscripting etc.) can be redefined for class instances."

msgstr "در اصطلاحات C++، معمولاً اعضای کلاس (از جمله اعضای داده) *public* هستند (به جز موردی که در پایین :ref:`tut-private` ذکر شده است)، و تمامی توابع عضو مجازیهستند. همان‌طور که در Modula-3، هیچ میانبرهایی برای ارجاع به اعضای شیء از متدهای آن وجود ندارد: تابع متد با یک آرگومان اول صریح که نمایانگر شیء است، اعلام می‌شود که این آرگومان به صورت ضمنی توسط فراخوانی فراهم می‌شود. همان‌طور که در Smalltalk، خود کلاس‌ها اشیاء هستند. این ویژگی معناشناسی برای وارد کردن و تغییر نام را فراهم می‌آورد. برخلاف C++ و Modula-3، نوع‌های توکار می‌توانند به‌عنوان کلاس‌های پایه برای توسعه توسط کاربر استفاده شوند. همچنین، مانند C++، بیشتر عملگرهای توکار با نحوی خاص (عملگرهای ریاضی، زیرنویسی و غیره) می‌توانند برای نمونه‌های کلاس بازتعریف شوند."

msgid "(Lacking universally accepted terminology to talk about classes, I will make occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, since its object-oriented semantics are closer to those of Python than C++, but I expect that few readers have heard of it.)"

msgstr "(با نبود اصطلاحات پذیرفته شده همگانی برای صحبت درباره‌ی کلاس‌ها، گاهی از اصطلاحات Smalltalk و C++ استفاده خواهم کرد. من از اصطلاحات Modula-3 استفاده می‌کردم، چون معنای شیء‌گرای آن به پایتون نزدیک‌تر از C++ است، اما انتظار دارم که تعداد کمی از خوانندگان با آن آشنا باشند.)"

msgid "A Word About Names and Objects"

msgstr "سخنی درباره‌ی نام‌ها و اشیاء"

msgid "Objects have individuality, and multiple names (in multiple scopes) can be bound to the same object. This is known as aliasing in other languages. This is usually not appreciated on a first glance at Python, and can be safely ignored when dealing with immutable basic types (numbers, strings, tuples). However, aliasing has a possibly surprising effect on the semantics of Python code involving mutable objects such as lists, dictionaries, and most other types. This is usually used to the benefit of the program, since aliases behave like pointers in some respects. For example, passing an object is cheap since only a pointer is passed by the implementation; and if a function modifies an object passed as an argument, the caller will see the change --- this eliminates the need for two different argument passing mechanisms as in Pascal."

msgstr "اشیاء هویت فردی دارند و چندین نام (در چندین محدوده) می‌توانند به یک شیء مشخص متصل شوند. این در زبانهای دیگر با نام «اسم‌های مستعار» شناخته می‌شود. این ویژگی معمولاً در نگاه اول به پایتون چندان جلب توجه نمی‌کند و هنگام کار با انواع پایه‌ی تغییرناپذیر (اعداد، رشته‌ها، تاپل‌ها) می‌توان آن را نادیده گرفت. با این حال، نام‌های مستعار می‌توانند تأثیری شگفت‌آور بر معناشناسی کد پایتونی داشته باشند، به‌ویژه هنگامی که با اشیاء تغییرپذیر مانند فهرستها، دیکشنری‌ها و بیشتر انواع دیگر سروکار داریم. این ویژگی معمولاً به سود برنامه تمام می‌شود، چون نام‌های مستعار از برخی جهات مانند اشاره‌گرها رفتار می‌کنند. برای مثال، ارسال یک شیء به‌عنوان آرگومان ارزان است، چون پیاده‌سازی فقط یک اشاره‌گر را ارسال می‌کند؛ و اگر تابعی شیء‌ای را که به‌عنوان آرگومان دریافت کرده تغییر دهد، فراخواننده تغییر را مشاهده خواهد کرد --- این کار نیاز به دو مکانیزم متفاوت برای ارسال آرگومان (مانند آنچه در پاسکال وجود دارد) را از بین می‌برد."

msgid "Python Scopes and Namespaces"

msgstr "محدوده‌ها و فضای نام‌ها در پایتون"

msgid "Before introducing classes, I first have to tell you something about Python's scope rules. Class definitions play some neat tricks with namespaces, and you need to know how scopes and namespaces work to fully understand what's going on. Incidentally, knowledge about this subject is useful for any advanced Python programmer."

msgstr "قبل از معرفی کلاس‌ها، ابتدا باید چیزی درباره‌ی قوانین محدوده در پایتون به شما بگویم. تعریف کلاس‌ها چند ترفند جالب با فضاهای نام انجام می‌دهد و برای اینکه به‌طور کامل متوجه شوید چه می‌گذرد، باید بدانید که محدوده‌ها و فضاهای نام چگونه کار می‌کنند. ضمناً، آگاهی از این موضوع برای هر برنامه‌نویس پیشرفته‌ی پایتون مفید است."

msgid "Let's begin with some definitions."

msgstr "بیایید با چند تعریف شروع کنیم."

msgid "A *namespace* is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that's normally not noticeable in any way (except for performance), and it may change in the future. Examples of namespaces are: the set of built-in names (containing functions such as :func:`abs`, and built-in exception names); the global names in a module; and the local names in a function invocation. In a sense the set of attributes of an object also form a namespace. The important thing to know about namespaces is that there is absolutely no relation between names in different namespaces; for instance, two different modules may both define a function ``maximize`` without confusion --- users of the modules must prefix it with the module name."

msgstr "«فضای نام» *namespace* نگاشتی است از نام‌ها به اشیا. بیشتر فضای نام‌ها در حال حاضر به‌صورت دیکشنری‌های پایتون پیاده‌سازی شده‌اند، اما معمولاً این موضوع (به جز در بازدهی قابل مشاهده نیست و ممکن است در آینده تغییر کند. مثالهایی از فضای نام عبارت‌اند از: مجموعه نام‌های توکار (که شامل توابعی مثل :func:`abs` و نام‌های استثنائات توکار است)؛ نام‌های سراسری در یک ماژول؛ و نام‌های محلی در یک فراخوانی تابع. به نوعی، مجموعه صفات «attributes» یک شیء نیز یک فضای نام را تشکیل می‌دهد. نکته‌ی مهم درباره‌ی فضای نام‌ها این است که هیچ ارتباطی بین نام‌ها در فضای نام‌های مختلف وجود ندارد؛ برای مثال، دو ماژول مختلف می‌توانند هر دو تابعی با نام ``maximize`` تعریف کنند بدون اینکه ابهامی پیش بیاید — استفاده‌کنندگان از ماژول‌ها باید نام ماژول را به‌عنوان پیشوند بیاورند."

msgid "By the way, I use the word *attribute* for any name following a dot --- for example, in the expression ``z.real``, ``real`` is an attribute of the object ``z``. Strictly speaking, references to names in modules are attribute references: in the expression ``modname.funcname``, ``modname`` is a module object and ``funcname`` is an attribute of it. In this case there happens to be a straightforward mapping between the module's attributes and the global names defined in the module: they share the same namespace! [#]_"

msgstr "به‌هرحال، من واژه‌ی *ویژگی* «*attribute*» را برای هر نامی که بعد از یک نقطه بیاید به کار می‌برم — برای مثال، در عبارت ``z.real``, ``real`` یک ویژگی شیء ``z`` است. از نظر دقیق‌تر، ارجاع به نام‌ها در ماژول‌ها نیز نوعی ارجاع به ویژگی محسوب می‌شود: در عبارت ``modname.funcname``, ``modname`` یک شیء ماژول است و ``funcname`` یکی از ویژگی‌های آن است. در این حالت، نگاشتی ساده و مستقیم بین ویژگی‌های ماژول و نام‌های سراسری تعریف‌شده در آن وجود دارد: هر دو یک فضای نام (namespace) را به اشتراک می‌گذارند! [#]_"

msgid "Attributes may be read-only or writable. In the latter case, assignment to attributes is possible. Module attributes are writable: you can write ``modname.the_answer = 42``. Writable attributes may also be deleted with the :keyword:`del` statement. For example, ``del modname.the_answer`` will remove the attribute :attr:`!the_answer` from the object named by ``modname``."

msgstr "ویژگی‌ها ممکن است فقط خواندنی یا قابل نوشتن باشند. در حالت دوم، اختصاص دادن به ویژگی‌ها ممکن است. ویژگی‌های ماژول قابل نوشتن هستند: می‌توانید ``modname.the_answer = 42`` را بنویسید. ویژگی‌های قابل نوشتن را می‌توان با دستور :keyword:`del` نیز حذف کرد. به‌عنوان مثال، ``del modname.the_answer`` ویژگی :attr:`!the_answer` را از شی‌ءای که توسط ``modname`` نامگذاری شده است حذف خواهد کرد."

msgid "Namespaces are created at different moments and have different lifetimes. The namespace containing the built-in names is created when the Python interpreter starts up, and is never deleted. The global namespace for a module is created when the module definition is read in; normally, module namespaces also last until the interpreter quits. The statements executed by the top-level invocation of the interpreter, either read from a script file or interactively, are considered part of a module called :mod:`__main__`, so they have their own global namespace. (The built-in names actually also live in a module; this is called :mod:`builtins`.)"

msgstr "فضاهای نام در لحظات مختلف ایجاد می‌شوند و دارای طول عمرهای متفاوتی هستند. فضای نام که شامل نام‌های توکار است، زمانی که مفسر پایتون شروع به کار می‌کند ایجاد می‌شود و هرگز حذف نمی‌شود. فضای نام عمومی برای یک ماژول زمانی که تعریف ماژول خوانده می‌شود ایجاد می‌گردد؛ به‌طور معمول، فضاهای نام ماژول نیز تا زمانی که مفسر پایان یابد باقی می‌مانند. دستوراتی که توسط اجرای سطح بالای مفسر، یا از فایل اسکریپت خوانده شده یا به‌طور تعاملی اجرا می‌شوند، به‌عنوان بخشی از ماژولی به نام :mod:`__main__` در نظر گرفته می‌شوند، بنابراین آن‌ها فضای نام عمومی خود را دارند. (نام‌های درون‌ساخت نیز در واقع در یک ماژول قرار دارند؛ این ماژول :mod:`builtins` نامیده می‌شود.)"

msgid "The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function. (Actually, forgetting would be a better way to describe what actually happens.) Of course, recursive invocations each have their own local namespace."

msgstr "فضای نام محلی برای یک تابع زمانی ایجاد می‌شود که تابع فراخوانی شود و زمانی که تابع بازمی‌گردد یا استثناای پرتاب می‌کند که در درون تابع مدیریت نمی‌شود، حذف می‌گردد. (در واقع، «فراموش شدن» توصیف بهتری برای چیزی است که واقعاً اتفاق می‌افتد.) البته، هر فراخوانی بازگشتی، فضای نام محلی خودش را دارد."

msgid "A *scope* is a textual region of a Python program where a namespace is directly accessible. \"Directly accessible\" here means that an unqualified reference to a name attempts to find the name in the namespace."

msgstr "یک *محدوده* یک ناحیه‌ی متنی از یک برنامه‌ی پایتون است که در آن یک فضای نام «namespace» به‌طور مستقیم قابل دستیابی است. \"به‌طور مستقیم قابل دستیابی\" در اینجا به این معنی است که یک ارجاع بدون صلاحیت به یک نام تلاش می‌کند تا نام «name» را در فضای نام «namespace» پیدا کند."

msgid "Although scopes are determined statically, they are used dynamically. At any time during execution, there are 3 or 4 nested scopes whose namespaces are directly accessible:"

msgstr "اگرچه محدوده‌ها به‌صورت ایستا تعیین می‌شوند، اما به‌صورت پویا مورد استفاده قرار می‌گیرند. در هر زمان حین اجرا، ۳ یا ۴ محدوده‌ی تو در تو وجود دارند که فضاهای نام آن‌ها مستقیماً قابل دسترسی هستند:"

msgid "the innermost scope, which is searched first, contains the local names"

msgstr "درونی‌ترین محدوده، که ابتدا جست‌وجو می‌شود، شامل نام‌های محلی است"

msgid "the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contain non-local, but also non-global names"

msgstr "محدوده‌های هر تابع محاط‌شونده، که جست‌وجو از نزدیک‌ترین محدوده‌ی محاط‌شونده آغاز می‌شود، شامل نام‌های غیرمحلی و همچنین غیرسراسری هستند"

msgid "the next-to-last scope contains the current module's global names"

msgstr "محدوده‌ی قبل از آخر شامل نام‌های عمومی ماژول جاری است"

msgid "the outermost scope (searched last) is the namespace containing built-in names"

msgstr "بیرونی‌ترین محدوده (که آخر از همه جست‌وجو می‌شود) فضای نامی است که شامل نام‌های توکار است"

msgid "If a name is declared global, then all references and assignments go directly to the next-to-last scope containing the module's global names. To rebind variables found outside of the innermost scope, the :keyword:`nonlocal` statement can be used; if not declared nonlocal, those variables are read-only (an attempt to write to such a variable will simply create a *new* local variable in the innermost scope, leaving the identically named outer variable unchanged)."

msgstr "اگر یک نام به‌عنوان سراسری اعلام شود، تمام ارجاعها و تخصیص‌ها مستقیماً به محدوده‌ی یکی‌مانده‌به‌آخر که شامل نام‌های سراسری ماژول است، می‌روند. برای اتصال مجدد متغیرهایی که در خارج از درونی‌ترین محدوده یافت می‌شوند، می‌توان از دستور :keyword:`nonlocal` استفاده کرد؛ اگر به‌عنوان nonlocal اعلام نشوند، آن متغیرها فقط‌خواندنی هستند (تلاش برای نوشتن در چنین متغیری، صرفاً یک متغیر محلی *جدید* در درونی‌ترین محدوده ایجاد می‌کند و متغیر بیرونی با همان نام را بدون تغییر باقی می‌گذارد)."

msgid "Usually, the local scope references the local names of the (textually) current function. Outside functions, the local scope references the same namespace as the global scope: the module's namespace. Class definitions place yet another namespace in the local scope."

msgstr "معمولاً، محدوده‌ی محلی به نام‌های محلی تابع جاری (از نظر متنی) ارجاع می‌دهد. در خارج از توابع، محدوده‌ی محلی به همان فضای نامی ارجاع می‌دهد که محدوده‌ی سراسری به آن ارجاع می‌دهد: فضای نام ماژول. تعاریف کلاس‌ها، فضای نام دیگری را در محدوده‌ی محلی قرار می‌دهند."

msgid "It is important to realize that scopes are determined textually: the global scope of a function defined in a module is that module's namespace, no matter from where or by what alias the function is called. On the other hand, the actual search for names is done dynamically, at run time --- however, the language definition is evolving towards static name resolution, at \"compile\" time, so don't rely on dynamic name resolution! (In fact, local variables are already determined statically.)"

msgstr "درک این نکته مهم است که محدوده‌ها به‌صورت متنی (بر اساس جایگاه در کد) تعیین می‌شوند: محدوده‌ی سراسری تابعی که در یک ماژول تعریف شده است، همان فضای نام آن ماژول است، فرقی نمی‌کند که تابع از کجا یا با چه نام مستعاری فراخوانی شود. از سوی دیگر، جست‌وجوی واقعی برای نام‌ها به‌صورت پویا (داینامیک) و در زمان اجرا انجام می‌شود --- با این حال، تعریف زبان به سمت و سوی حلِ ایستا (استاتیک) نام‌ها در زمان «کامپایل» پیش می‌رود، پس به حلِ پویای نام‌ها اعتماد نکنید! (در واقع، متغیرهای محلی از قبل به‌صورت ایستا تعیین می‌شوند.)"

msgid "A special quirk of Python is that -- if no :keyword:`global` or :keyword:`nonlocal` statement is in effect -- assignments to names always go into the innermost scope. Assignments do not copy data --- they just bind names to objects. The same is true for deletions: the statement ``del x`` removes the binding of ``x`` from the namespace referenced by the local scope. In fact, all operations that introduce new names use the local scope: in particular, :keyword:`import` statements and function definitions bind the module or function name in the local scope."

msgstr "یک ویژگی خاص پایتون این است که --- اگر دستور :keyword:`global` یا :keyword:`nonlocal` فعال نباشد --- تخصیص‌های (مقداردهی‌های) نام‌ها همیشه به درونی‌ترین محدوده (محلی‌ترین) می‌روند. تخصیص‌ها داده‌ها را کپی نمی‌کنند --- بلکه فقط نام‌ها را به اشیاء متصل می‌کنند. همین موضوع در مورد حذف‌ها نیز صادق است: دستور ``del x`` اتصال ``x`` را از فضای نامی که توسط محدوده‌ی محلی ارجاع داده شده است، حذف می‌کند. در واقع، تمام عملیاتی که نام‌های جدیدی معرفی می‌کنند از محدوده‌ی محلی استفاده می‌کنند: به‌ویژه، دستورات :keyword:`import` و تعاریف توابع، نام ماژول یا تابع را در محدوده‌ی محلی مقید می‌کنند."

msgid "The :keyword:`global` statement can be used to indicate that particular variables live in the global scope and should be rebound there; the :keyword:`nonlocal` statement indicates that particular variables live in an enclosing scope and should be rebound there."

msgstr "از دستور :keyword:`global` می‌توان برای نشان دادن این استفاده کرد که متغیرهای خاصی در محدوده‌ی سراسری قرار دارند و باید در همان محدوده دوباره متصل شوند؛ دستور :keyword:`nonlocal` نشان می‌دهد که متغیرهای خاصی در یک محدوده‌ی محاط‌شونده قرار دارند و باید در آن محدوده دوباره متصل شوند."

msgid "Scopes and Namespaces Example"

msgstr "مثال محدوده‌ها و فضای نام‌ها"

msgid "This is an example demonstrating how to reference the different scopes and namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect variable binding::"

msgstr "این مثالی است که نحوه‌ی ارجاع به محدوده‌ها و فضای نام‌های مختلف، و تأثیر دستورات :keyword:`global` و :keyword:`nonlocal` بر اتصال متغیرها را نشان می‌دهد::"

msgid ""

msgstr ""

msgid "The output of the example code is:"

msgstr "خروجی کد مثال:"

msgid ""

msgstr ""

msgid "Note how the *local* assignment (which is default) didn't change *scope_test*\\'s binding of *spam*. The :keyword:`nonlocal` assignment changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment changed the module-level binding."

msgstr "توجه کنید که تخصیص *محلی* (که به‌صورت پیش‌فرض است)، اتصال *spam* را در *scope_test* تغییر نداد. تخصیص :keyword:`nonlocal`، اتصال *spam* را در *scope_test* تغییر داد، و تخصیص :keyword:`global`، اتصال را در سطح ماژول تغییر داد."

msgid "You can also see that there was no previous binding for *spam* before the :keyword:`global` assignment."

msgstr "همچنین می‌توانید ببینید که قبل از تخصیص :keyword:`global`، هیچ اتصال قبلی برای *spam* وجود نداشت."

msgid "A First Look at Classes"

msgstr "در نگاه اول به کلاس‌ها"

msgid "Classes introduce a little bit of new syntax, three new object types, and some new semantics."

msgstr "کلاس‌ها کمی سینتکس جدید، سه نوع شیء جدید، و مفاهیم معنایی جدیدی را معرفی می‌کنند."

msgid "Class Definition Syntax"

msgstr "قواعد تعریف کلاس"

msgid "The simplest form of class definition looks like this::"

msgstr "ساده‌ترین شکل تعریف کلاس به این صورت است:"

msgid ""

msgstr ""

msgid "Class definitions, like function definitions (:keyword:`def` statements) must be executed before they have any effect. (You could conceivably place a class definition in a branch of an :keyword:`if` statement, or inside a function.)"

msgstr "تعاریف کلاس‌ها، مانند تعاریف توابع (دستورات :keyword:`def`)، باید قبل از اینکه تأثیری داشته باشند، اجرا شوند. (به‌طور تئوری می‌توانید یک تعریف کلاس را در یک شاخه از دستور :keyword:`if` یا داخل یک تابع قرار دهید.)"

msgid "In practice, the statements inside a class definition will usually be function definitions, but other statements are allowed, and sometimes useful --- we'll come back to this later. The function definitions inside a class normally have a peculiar form of argument list, dictated by the calling conventions for methods --- again, this is explained later."

msgstr "در عمل، دستورات داخل یک تعریف کلاس معمولاً تعاریف توابع هستند، اما دستورات دیگری نیز مجاز هستند و گاهی مفیدند --- بعداً به این موضوع بازخواهیم گشت. تعاریف توابع داخل یک کلاس معمولاً دارای شکل خاصی از فهرست آرگومان‌ها هستند که توسط قراردادهای فراخوانی برای متدها تعیین می‌شود --- باز هم، این موضوع بعداً توضیح داده می‌شود."

msgid "When a class definition is entered, a new namespace is created, and used as the local scope --- thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here."

msgstr "هنگامی که یک تعریف کلاس وارد می‌شود، یک فضای نام جدید ایجاد شده و به‌عنوان محدوده‌ی محلی استفاده می‌شود --- بنابراین، تمام تخصیص‌ها به متغیرهای محلی به این فضای نام جدید می‌روند. به‌ویژه، تعاریف توابع، نام تابع جدید را در اینجا مقید می‌کنند."

msgid "When a class definition is left normally (via the end), a *class object* is created. This is basically a wrapper around the contents of the namespace created by the class definition; we'll learn more about class objects in the next section. The original local scope (the one in effect just before the class definition was entered) is reinstated, and the class object is bound here to the class name given in the class definition header (:class:`!ClassName` in the example)."

msgstr "هنگامی که یک تعریف کلاس به‌طور عادی (با رسیدن به انتها) ترک می‌شود، یک *شیء کلاس* ایجاد می‌شود. این در اصل یک پوسته پیرامون محتویات فضای نامی است که توسط تعریف کلاس ایجاد شده است؛ در بخش بعدی بیشتر درباره‌ی اشیاء کلاس خواهیم آموخت. محدوده‌ی محلی اصلی (همان محدوده‌ای که درست قبل از ورود به تعریف کلاس فعال بود) بازیابی می‌شود، و شیء کلاس در اینجا به نام کلاسی که در سرآیند کلاس تعریف شده است، متصل می‌شود (:class:`!ClassName` در مثال)."

msgid "Class Objects"

msgstr "اشیاء کلاس"

msgid "Class objects support two kinds of operations: attribute references and instantiation."

msgstr "اشیاء کلاس از دو نوع عملیات پشتیبانی می‌کنند: ارجاع به ویژگی‌ها و نمونه‌سازی."

msgid "*Attribute references* use the standard syntax used for all attribute references in Python: ``obj.name``. Valid attribute names are all the names that were in the class's namespace when the class object was created. So, if the class definition looked like this::"

msgstr "*ارجاع به ویژگی‌ها* از همان دستور زبان استاندارد که برای همه‌ی ارجاعها به ویژگی‌ها در پایتون استفاده می‌شود، پیروی می‌کند: ``obj.name``. نام‌های ویژگی معتبر، همه‌ی نام‌هایی هستند که در هنگام ایجاد شیء کلاس، در فضای نام آن کلاس وجود داشته‌اند. بنابراین، اگر تعریف کلاس به این شکل بود::"

msgid ""

msgstr ""

msgid "then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, returning an integer and a function object, respectively. Class attributes can also be assigned to, so you can change the value of ``MyClass.i`` by assignment. :attr:`~type.__doc__` is also a valid attribute, returning the docstring belonging to the class: ``\"A simple example class\"``."

msgstr "سپس ``MyClass.i`` و ``MyClass.f`` ارجاعهای ویژگی معتبری هستند که به‌ترتیب یک عدد صحیح و یک شیء تابع را برمی‌گردانند. به ویژگی‌های کلاس نیز می‌توان مقدار داد، بنابراین می‌توانید مقدار ``MyClass.i`` را با تخصیص (مقداردهی) تغییر دهید. :attr:`~type.__doc__` نیز یک ویژگی معتبر است که رشته‌ی مستند متعلق به کلاس را برمی‌گرداند: ``\"A simple example class\"``."

msgid "Class *instantiation* uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class)::"

msgstr "*نمونه‌سازی* کلاس از نماد توابع استفاده می‌کند. فقط تصور کنید که شیء کلاس، یک تابع بدون پارامتر است که یک نمونه‌ی جدید از کلاس را برمی‌گرداند. برای مثال (با فرض کلاس بالا)::"

msgid "x = MyClass()"

msgstr "x = MyClass()"

msgid "creates a new *instance* of the class and assigns this object to the local variable ``x``."

msgstr "یک *نمونه* جدید از کلاس ایجاد می‌کند و این شیء را به متغیر محلی ``x`` تخصیص می‌دهد."

msgid "The instantiation operation (\"calling\" a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named :meth:`~object.__init__`, like this::"

msgstr "عملیات نمونه‌سازی (که «فراخوانی» یک شیء کلاس است) یک شیء خالی ایجاد می‌کند. بسیاری از کلاس‌ها ترجیح می‌دهند اشیایی با نمونه‌هایی ایجاد کنند که به یک حالت اولیه‌ی خاص سفارشی‌سازی شده‌اند. بنابراین، یک کلاس ممکن است یک متد ویژه به نام :meth:`~object.__init__` تعریف کند، مانند این::"

msgid ""

msgstr ""

msgid "When a class defines an :meth:`~object.__init__` method, class instantiation automatically invokes :meth:`!__init__` for the newly created class instance. So in this example, a new, initialized instance can be obtained by::"

msgstr "وقتی یک کلاس یک متد :meth:`~object.__init__` تعریف می‌کند، نمونه‌سازی کلاس به‌طور خودکار :meth:`!__init__` را برای نمونه‌ی تازه‌ایجادشده‌ی کلاس فراخوانی می‌کند. بنابراین در این مثال، می‌توان یک نمونه‌ی جدید و مقداردهی‌شده را با دستور زیر به‌دست آورد::"

msgid "Of course, the :meth:`~object.__init__` method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to :meth:`!__init__`. For example, ::"

msgstr "البته، متد :meth:`~object.__init__` می‌تواند برای انعطاف‌پذیری بیشتر، آرگومان‌هایی داشته باشد. در این صورت، آرگومان‌هایی که به عملگر نمونه‌سازی کلاس داده می‌شوند، به :meth:`!__init__` منتقل می‌شوند. برای مثال، ::"

msgid ""

msgstr ""

msgid "Instance Objects"

msgstr "اشیاء نمونه"

msgid "Now what can we do with instance objects? The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods."

msgstr "حالا با اشیاء نمونه چه کاری می‌توانیم انجام دهیم؟ تنها عملیاتی که اشیاء نمونه می‌فهمند، ارجاع به ویژگی‌هااست. دو نوع نام ویژگی معتبر وجود دارد: ویژگی‌های داده (data attributes) و متدها (methods)."

msgid "*Data attributes* correspond to \"instance variables\" in Smalltalk, and to \"data members\" in C++. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. For example, if ``x`` is the instance of :class:`!MyClass` created above, the following piece of code will print the value ``16``, without leaving a trace::"

msgstr "*ویژگی‌های داده* معادل «متغیرهای نمونه» در زبان اسمالتاک و «عضوهای داده» در ++C هستند. ویژگی‌های داده نیازی به اعلام ندارند؛ مانند متغیرهای محلی، هنگامی که برای اولین بار به آنها مقدار داده می‌شود، به‌وجود می‌آیند. برای مثال، اگر ``x`` نمونه‌ای از :class:`!MyClass` باشد که در بالا ایجاد شده است، قطعه کد زیر مقدار ``16`` را چاپ می‌کند، بدون اینکه هیچ اثری از خود بر جای بگذارد::"

msgid ""

msgstr ""

msgid "The other kind of instance attribute reference is a *method*. A method is a function that \"belongs to\" an object."

msgstr "نوع دیگر ارجاع به ویژگی نمونه، *متد* است. متد، تابعی است که «به» یک شیء تعلق دارد."

msgid "Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances. So in our example, ``x.f`` is a valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as ``MyClass.f`` --- it is a *method object*, not a function object."

msgstr "نام‌های متد معتبر یک شیء نمونه به کلاس آن بستگی دارد. طبق تعریف، تمام ویژگی‌های یک کلاس که شیء تابع هستند، متدهای متناظر با نمونه‌های آن را تعریف می‌کنند. بنابراین در مثال ما، ``x.f`` یک ارجاع متد معتبر است، زیرا ``MyClass.f`` یک تابع است، اما ``x.i`` معتبر نیست، زیرا ``MyClass.i`` تابع نیست. اما ``x.f`` با ``MyClass.f`` یکسان نیست --- بلکه یک *شیء متد* است، نه یک شیء تابع."

msgid "Method Objects"

msgstr "متد اشیاء"

msgid "Usually, a method is called right after it is bound::"

msgstr "معمولاً، یک متد بلافاصله پس از اتصال فراخوانی می‌شود::"

msgid "x.f()"

msgstr "x.f()"

msgid "If ``x = MyClass()``, as above, this will return the string ``'hello world'``. However, it is not necessary to call a method right away: ``x.f`` is a method object, and can be stored away and called at a later time. For example::"

msgstr "اگر ``x = MyClass()``، همان‌طور که در بالا ذکر شد، این (فراخوانی) رشته‌ی ``'hello world'`` را برمی‌گرداند. با این حال، لزومی ندارد که یک متد بلافاصله فراخوانی شود: ``x.f`` یک شیء متد است و می‌توان آن را ذخیره کرده و در زمان دیگری فراخوانی کرد. برای مثال::"

msgid ""

msgstr ""

msgid "will continue to print ``hello world`` until the end of time."

msgstr "تا پایان زمان به چاپ ``hello world`` ادامه می‌دهد."

msgid "What exactly happens when a method is called? You may have noticed that ``x.f()`` was called without an argument above, even though the function definition for :meth:`!f` specified an argument. What happened to the argument? Surely Python raises an exception when a function that requires an argument is called without any --- even if the argument isn't actually used..."

msgstr "دقیقاً وقتی یک متد فراخوانی می‌شود، چه اتفاقی می‌افتد؟ احتمالاً متوجه شده‌اید که ``x.f()`` در بالا بدون هیچ آرگومانی فراخوانی شد، حتی اگر تعریف تابع :meth:`!f` یک آرگومان را مشخص کرده بود. چه بر سر آن آرگومان آمد؟ مسلماً پایتون وقتی یک تابع که به آرگومان نیاز دارد، بدون هیچ آرگومانی فراخوانی می‌شود، یک استثنا ایجاد می‌کند --- حتی اگر آن آرگومان واقعاً استفاده نشود..."

msgid "Actually, you may have guessed the answer: the special thing about methods is that the instance object is passed as the first argument of the function. In our example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``. In general, calling a method with a list of *n* arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method's instance object before the first argument."

msgstr "در واقع، شاید پاسخ را حدس زده باشید: نکته‌ی ویژه در مورد متدها این است که شیء نمونه به‌عنوان اولین آرگومان تابع ارسال می‌شود. در مثال ما، فراخوانی ``x.f()`` دقیقاً معادل ``MyClass.f(x)`` است. به طور کلی، فراخوانی یک متد با فهرستی از *n* آرگومان معادل فراخوانی تابع متناظر با فهرست آرگومانی است که با قرار دادن شیء نمونه‌ی متد قبل از اولین آرگومان ایجاد می‌شود."

msgid "In general, methods work as follows. When a non-data attribute of an instance is referenced, the instance's class is searched. If the name denotes a valid class attribute that is a function object, references to both the instance object and the function object are packed into a method object. When the method object is called with an argument list, a new argument list is constructed from the instance object and the argument list, and the function object is called with this new argument list."

msgstr "به طور کلی، متدها به صورت زیر کار می‌کنند. هنگامی که به یک ویژگی غیرداده‌ای از یک نمونه ارجاع داده می‌شود، کلاس آن نمونه جست‌وجو می‌شود. اگر آن نام نشان‌دهنده‌ی یک ویژگی کلاس معتبر باشد که یک شیء تابع است، ارجاعات به هر دو شیء نمونه و شیء تابع در یک شیء متد بسته‌بندی می‌شوند. هنگامی که شیء متد با یک فهرست آرگومان فراخوانی می‌شود، یک فهرست آرگومان جدید از شیء نمونه و فهرست آرگومان ساخته می‌شود و شیء تابع با این فهرست آرگومان جدید فراخوانی می‌شود."

msgid "Class and Instance Variables"

msgstr "کلاس و متغیرهای نمونه"

msgid "Generally speaking, instance variables are for data unique to each instance and class variables are for attributes and methods shared by all instances of the class::"

msgstr "به‌طور کلی، متغیرهای نمونه برای داده‌هایی هستند که مختص به هر نمونه و متغیرهای کلاس برای ویژگی‌ها و متدهایی هستند که بین همه‌ی نمونه‌ها از آن کلاس مشترک هستند::"

msgid ""

msgstr ""

msgid "As discussed in :ref:`tut-object`, shared data can have possibly surprising effects involving :term:`mutable` objects such as lists and dictionaries. For example, the *tricks* list in the following code should not be used as a class variable because just a single list would be shared by all *Dog* instances::"

msgstr "همان‌طور که در :ref:`tut-object` بحث شد، داده‌های مشترک می‌توانند تأثیرات شگفت‌آوری بر روی اشیاء :term:`تغییرپذیر <mutable>` مانند فهرستها و دیکشنری‌ها داشته باشند. برای مثال، فهرست *tricks* در کد زیر نباید به‌عنوان یک متغیر کلاس استفاده شود، زیرا فقط یک فهرست واحد بین همه‌ی نمونه‌های *Dog* مشترک خواهد بود::"

msgid ""

msgstr ""

msgid "Correct design of the class should use an instance variable instead::"

msgstr "طراحی صحیح کلاس باید به جای آن از یک متغیر نمونه استفاده کند::"

msgid ""

msgstr ""

msgid "Random Remarks"

msgstr "نکات پراکنده"

msgid "If the same attribute name occurs in both an instance and in a class, then attribute lookup prioritizes the instance::"

msgstr "اگر نام ویژگی مشابهی هم در یک نمونه و هم در یک کلاس وجود داشته باشد، آنگاه جست‌وجوی ویژگی، نمونه را اولویت‌بندی می‌کند::"

msgid ""

msgstr ""

msgid "Data attributes may be referenced by methods as well as by ordinary users (\"clients\") of an object. In other words, classes are not usable to implement pure abstract data types. In fact, nothing in Python makes it possible to enforce data hiding --- it is all based upon convention. (On the other hand, the Python implementation, written in C, can completely hide implementation details and control access to an object if necessary; this can be used by extensions to Python written in C.)"

msgstr "ویژگی‌های داده ممکن است هم توسط متدها و هم توسط کاربران عادی (\"clients\") یک شیء ارجاع داده شوند. به عبارت دیگر، کلاس‌ها برای پیاده‌سازی انواع داده‌ی انتزاعی خالص قابل استفاده نیستند. در واقع، هیچ چیزی در پایتون امکان اعمال پنهان‌سازی داده را فراهم نمی‌کند --- همه‌چیز بر اساس قرارداد است. (از سوی دیگر، پیاده‌سازی پایتون که به زبان C نوشته شده است، می‌تواند جزئیات پیاده‌سازی را کاملاً پنهان کند و در صورت نیاز دسترسی به یک شیء را کنترل کند؛ این قابلیت می‌تواند توسط افزونه‌های پایتون که به زبان C نوشته می‌شوند، استفاده شود.)"

msgid "Clients should use data attributes with care --- clients may mess up invariants maintained by the methods by stamping on their data attributes. Note that clients may add data attributes of their own to an instance object without affecting the validity of the methods, as long as name conflicts are avoided --- again, a naming convention can save a lot of headaches here."

msgstr "کاربران (clients) باید با احتیاط از ویژگی‌های داده استفاده کنند --- کاربران ممکن است ناورداهای حفظ‌شده توسط متدها را با دستکاری در ویژگی‌های داده‌شان به هم بریزند. توجه داشته باشید که کاربران ممکن است ویژگی‌های داده‌ی خود را به یک شیء نمونه اضافه کنند بدون اینکه بر صحت متدها تأثیر بگذارند، تا زمانی که تداخل نام‌ها اجتناب شود --- باز هم، یک قرارداد نام‌گذاری می‌تواند از بسیاری از سردرگمی‌ها در اینجا جلوگیری کند."

msgid "There is no shorthand for referencing data attributes (or other methods!) from within methods. I find that this actually increases the readability of methods: there is no chance of confusing local variables and instance variables when glancing through a method."

msgstr "هیچ گونه میان‌بری برای ارجاع به ویژگی‌های داده (یا سایر متدها!) از درون متدها وجود ندارد. به نظر من، این موضوع در واقع خوانایی متدها را افزایش می‌دهد: هیچ شانسی برای اشتباه گرفتن متغیرهای محلی و متغیرهای نمونه هنگام مرور سریع یک متد وجود ندارد."

msgid "Often, the first argument of a method is called ``self``. This is nothing more than a convention: the name ``self`` has absolutely no special meaning to Python. Note, however, that by not following the convention your code may be less readable to other Python programmers, and it is also conceivable that a *class browser* program might be written that relies upon such a convention."

msgstr "معمولاً، اولین آرگومان یک متد ``self`` نامیده می‌شود. این چیزی بیش از یک قرارداد نیست: نام ``self`` هیچ معنی خاصی برای پایتون ندارد. با این حال، توجه داشته باشید که با رعایت نکردن این قرارداد، کد شما ممکن است برای سایر برنامه‌نویسان پایتون کمتر خوانا باشد، و همچنین قابل‌تصور است که یک برنامه *مرورگر کلاس* (class browser) نوشته شود که به چنین قراردادی وابسته باشد."

msgid "Any function object that is a class attribute defines a method for instances of that class. It is not necessary that the function definition is textually enclosed in the class definition: assigning a function object to a local variable in the class is also ok. For example::"

msgstr "هر شیء تابعی که یک ویژگی کلاس باشد، یک متد برای نمونه‌های آن کلاس تعریف می‌کند. لازم نیست که تعریف تابع لزوماً درون تعریف کلاس قرار داشته باشد: اختصاص یک شیء تابع به یک متغیر محلی در کلاس نیز مجاز است. برای مثال::"

msgid ""

msgstr ""

msgid "Now ``f``, ``g`` and ``h`` are all attributes of class :class:`!C` that refer to function objects, and consequently they are all methods of instances of :class:`!C` --- ``h`` being exactly equivalent to ``g``. Note that this practice usually only serves to confuse the reader of a program."

msgstr "اکنون ``f``، ``g`` و ``h`` همگی ویژگی‌های کلاس :class:`!C` هستند که به اشیاء تابع اشاره دارند، و در نتیجه همگی متدهایی از نمونه‌های :class:`!C` هستند --- ``h`` دقیقاً معادل ``g`` است. توجه داشته باشید که این روش معمولاً فقط باعث سردرگمی خواننده‌ی برنامه می‌شود."

msgid "Methods may call other methods by using method attributes of the ``self`` argument::"

msgstr "متدها می‌توانند سایر متدها را با استفاده از ویژگی‌های متد آرگومان ``self`` فراخوانی کنند::"

msgid ""

msgstr ""

msgid "Methods may reference global names in the same way as ordinary functions. The global scope associated with a method is the module containing its definition. (A class is never used as a global scope.) While one rarely encounters a good reason for using global data in a method, there are many legitimate uses of the global scope: for one thing, functions and modules imported into the global scope can be used by methods, as well as functions and classes defined in it. Usually, the class containing the method is itself defined in this global scope, and in the next section we'll find some good reasons why a method would want to reference its own class."

msgstr "متدها ممکن است به نام‌های سراسری به همان روشی که توابع معمولی اشاره می‌کنند، ارجاع دهند. محدوده‌ی سراسری مرتبط با یک متد، ماژولی است که شامل تعریف آن است. (یک کلاس هرگز به‌عنوان محدوده‌ی سراسری استفاده نمی‌شود.) اگرچه به ندرت دلیل خوبی برای استفاده از داده‌های سراسری در یک متد یافت می‌شود، اما کاربردهای مشروع زیادی برای محدوده‌ی سراسری وجود دارد: برای یک چیز، توابع و ماژول‌هایی که به محدوده‌ی سراسری ایمپورت شده‌اند، می‌توانند توسط متدها استفاده شوند، همچنین توابع و کلاس‌های تعریف‌شده در آن. معمولاً، کلاسی که شامل متد است، خود در این محدوده‌ی سراسری تعریف می‌شود، و در بخش بعدی دلایل خوبی خواهیم یافت که چرا یک متد ممکن است بخواهد به کلاس خودش ارجاع دهد."

msgid "Each value is an object, and therefore has a *class* (also called its *type*). It is stored as ``object.__class__``."

msgstr "هر مقدار یک شیء است، و بنابراین دارای یک *کلاس* (که به آن *تایپ* نیز گفته می‌شود) می‌باشد. این مقدار به‌صورت ``object.__class__`` ذخیره می‌شود."

msgid "Inheritance"

msgstr "ارث‌بری"

msgid "Of course, a language feature would not be worthy of the name \"class\" without supporting inheritance. The syntax for a derived class definition looks like this::"

msgstr "مسلماً، یک ویژگی زبانی بدون پشتیبانی از ارث‌بری، شایسته‌ی نام «کلاس» نخواهد بود. سینتکس تعریف یک کلاس مشتق‌شده (derived class) به این شکل است::"

msgid ""

msgstr ""

msgid "The name :class:`!BaseClassName` must be defined in a namespace accessible from the scope containing the derived class definition. In place of a base class name, other arbitrary expressions are also allowed. This can be useful, for example, when the base class is defined in another module::"

msgstr "نام :class:`!BaseClassName` باید در فضای نامی تعریف شده باشد که از محدوده‌ای که شامل تعریف کلاس مشتق‌شده است، قابل دسترسی باشد. به جای نام کلاس پایه، سایر عبارت‌های دلخواه نیز مجاز هستند. این می‌تواند مفید باشد، برای مثال، زمانی که کلاس پایه در ماژول دیگری تعریف شده است::"

msgid "class DerivedClassName(modname.BaseClassName):"

msgstr "class DerivedClassName(modname.BaseClassName):"

msgid "Execution of a derived class definition proceeds the same as for a base class. When the class object is constructed, the base class is remembered. This is used for resolving attribute references: if a requested attribute is not found in the class, the search proceeds to look in the base class. This rule is applied recursively if the base class itself is derived from some other class."

msgstr "اجرای تعریف یک کلاس مشتق‌شده به همان شیوه‌ای است که برای یک کلاس پایه انجام می‌شود. هنگامی که شیء کلاس ساخته می‌شود، کلاس پایه به خاطر سپرده می‌شود. این (اطلاعات) برای حل کردن ارجاعات به ویژگی‌ها استفاده می‌شود: اگر ویژگی درخواستی در کلاس یافت نشود، جست‌وجو در کلاس پایه ادامه می‌یابد. این قاعده به‌صورت بازگشتی اعمال می‌شود اگر خود کلاس پایه از کلاس دیگری مشتق شده باشد."

msgid "There's nothing special about instantiation of derived classes: ``DerivedClassName()`` creates a new instance of the class. Method references are resolved as follows: the corresponding class attribute is searched, descending down the chain of base classes if necessary, and the method reference is valid if this yields a function object."

msgstr "هیچ نکته‌ی خاصی درباره‌ی نمونه‌سازی کلاس‌های مشتق‌شده وجود ندارد: ``DerivedClassName()`` یک نمونه‌ی جدید از کلاس ایجاد می‌کند. ارجاعهای متد به‌صورت زیر حل می‌شوند: ویژگی کلاس متناظر جست‌وجو می‌شود، در صورت لزوم در زنجیره‌ی کلاس‌های پایه به پایین می‌رود، و ارجاع متد در صورتی معتبر است که این جست‌وجو به یک شیء تابع منجر شود."

msgid "Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overrides it. (For C++ programmers: all methods in Python are effectively ``virtual``.)"

msgstr "کلاس‌های مشتق‌شده ممکن است متدهای کلاس‌های پایه‌ی خود را بازنویسی کنند. از آنجایی که متدها هنگام فراخوانی سایر متدهای همان شیء، امتیاز ویژه‌ای ندارند، یک متد از یک کلاس پایه که متد دیگری را که در همان کلاس پایه تعریف شده فراخوانی می‌کند، ممکن است در نهایت متدی از یک کلاس مشتق‌شده را فراخوانی کند که آن را بازنویسی کرده است. (برای برنامه‌نویسان C++: تمام متدها در پایتون به‌طور مؤثر ``virtual`` هستند.)"

msgid "An overriding method in a derived class may in fact want to extend rather than simply replace the base class method of the same name. There is a simple way to call the base class method directly: just call ``BaseClassName.methodname(self, arguments)``. This is occasionally useful to clients as well. (Note that this only works if the base class is accessible as ``BaseClassName`` in the global scope.)"

msgstr "یک متد بازنویسی‌شده در یک کلاس مشتق‌شده ممکن است در واقع بخواهد به جای اینکه صرفاً متد کلاس پایه را با همین نام جایگزین کند، آن را گسترش دهد. یک راه ساده برای فراخوانی مستقیم متد کلاس پایه وجود دارد: فقط ``BaseClassName.methodname(self, arguments)`` را فراخوانی کنید. این روش گاهی برای کاربران (clients) نیز مفید است. (توجه داشته باشید که این روش تنها زمانی کار می‌کند که کلاس پایه به‌عنوان ``BaseClassName`` در محدوده‌ی سراسری (global scope) قابل دسترسی باشد.)"

msgid "Python has two built-in functions that work with inheritance:"

msgstr "پایتون دو تابع توکار دارد که با ارث‌بری کار می‌کنند:"

msgid "Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` will be ``True`` only if ``obj.__class__`` is :class:`int` or some class derived from :class:`int`."

msgstr "برای بررسی نوع یک نمونه (instance) از :func:`isinstance` استفاده کنید: ``isinstance(obj, int)`` تنها زمانی ``True`` خواهد بود که ``obj.__class__`` از نوع :class:`int` باشد یا کلاسی که از :class:`int` مشتق شده باشد."

msgid "Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` is ``True`` since :class:`bool` is a subclass of :class:`int`. However, ``issubclass(float, int)`` is ``False`` since :class:`float` is not a subclass of :class:`int`."

msgstr "برای بررسی ارث‌بری کلاس‌ها از :func:`issubclass` استفاده کنید: ``issubclass(bool, int)`` مقدار ``True`` است چون :class:`bool` زیرکلاسی از :class:`int` است. با این حال، ``issubclass(float, int)`` مقدار ``False`` است چون :class:`float` زیرکلاسی از :class:`int` نیست."

msgid "Multiple Inheritance"

msgstr "ارث‌بری چندگانه"

msgid "Python supports a form of multiple inheritance as well. A class definition with multiple base classes looks like this::"

msgstr "پایتون همچنین از نوعی ارث‌بری چندگانه پشتیبانی می‌کند. تعریف یک کلاس با چندین کلاس پایه به این شکل است::"

msgid ""

msgstr ""

msgid "For most purposes, in the simplest cases, you can think of the search for attributes inherited from a parent class as depth-first, left-to-right, not searching twice in the same class where there is an overlap in the hierarchy. Thus, if an attribute is not found in :class:`!DerivedClassName`, it is searched for in :class:`!Base1`, then (recursively) in the base classes of :class:`!Base1`, and if it was not found there, it was searched for in :class:`!Base2`, and so on."

msgstr "برای بیشتر کاربردها، در ساده‌ترین موارد، می‌توانید جست‌وجو برای ویژگی‌های به‌ارث‌برده‌شده از یک کلاس والد را به‌صورت عمق‌اول، چپ‌به‌راست، بدون جست‌وجوی دوباره در همان کلاس در جایی که همپوشانی در سلسله‌مراتب وجود دارد، در نظر بگیرید. بنابراین، اگر ویژگی‌ای در :class:`!DerivedClassName` یافت نشد، در :class:`!Base1` جست‌وجو می‌شود، سپس (به‌صورت بازگشتی) در کلاس‌های پایه‌ی :class:`!Base1`، و اگر در آنجا یافت نشد، در :class:`!Base2` جست‌وجو می‌شود، و به همین ترتیب."

msgid "In fact, it is slightly more complex than that; the method resolution order changes dynamically to support cooperative calls to :func:`super`. This approach is known in some other multiple-inheritance languages as call-next-method and is more powerful than the super call found in single-inheritance languages."

msgstr "در واقع، این موضوع کمی پیچیده‌تر از این است؛ ترتیب حل متد به‌صورت پویا تغییر می‌کند تا از فراخوانی‌های مشارکتی به :func:`super` پشتیبانی کند. این رویکرد در برخی دیگر از زبانهای دارای ارث‌بری چندگانه با نام call-next-method شناخته می‌شود و از فراخوانی super موجود در زبانهای دارای ارث‌بری تکی قدرتمندتر است."

msgid "Dynamic ordering is necessary because all cases of multiple inheritance exhibit one or more diamond relationships (where at least one of the parent classes can be accessed through multiple paths from the bottommost class). For example, all classes inherit from :class:`object`, so any case of multiple inheritance provides more than one path to reach :class:`object`. To keep the base classes from being accessed more than once, the dynamic algorithm linearizes the search order in a way that preserves the left-to-right ordering specified in each class, that calls each parent only once, and that is monotonic (meaning that a class can be subclassed without affecting the precedence order of its parents). Taken together, these properties make it possible to design reliable and extensible classes with multiple inheritance. For more detail, see :ref:`python_2.3_mro`."

msgstr "ترتیب‌دهی پویا ضروری است زیرا همه‌ی موارد ارث‌بری چندگانه دارای یک یا چند رابطه‌ی الماسی هستند (جایی که حداقل یکی از کلاس‌های والد از طریق چندین مسیر از پایین‌ترین کلاس قابل دسترسی است). برای مثال، همه‌ی کلاس‌ها از :class:`object` ارث‌بری می‌کنند، بنابراین هر موردی از ارث‌بری چندگانه بیش از یک مسیر برای رسیدن به :class:`object` فراهم می‌کند. برای جلوگیری از دسترسی بیش از یک بار به کلاس‌های پایه، الگوریتم پویا ترتیب جست‌وجو را به‌گونه‌ای خطی‌سازی می‌کند که ترتیب چپ‌به‌راست مشخص‌شده در هر کلاس را حفظ کند، که هر والد را فقط یک بار فراخوانی می‌کند، و یکنواخت است (به این معنی که یک کلاس می‌تواند زیرکلاس داشته باشد بدون اینکه بر ترتیب اولویت والدین آن تأثیر بگذارد). این ویژگی‌ها در کنار هم، طراحی کلاس‌های قابل اعتماد و قابل توسعه با ارث‌بری چندگانه را ممکن می‌سازند. برای جزئیات بیشتر، به :ref:`python_2.3_mro` مراجعه کنید."

msgid "In some cases multiple inheritance is not allowed; see :ref:`multiple-inheritance` for details."

msgstr "در برخی موارد وراثت چندگانه مجاز نیست؛ برای جزئیات به :ref:`multiple-inheritance` مراجعه کنید."

msgid "Private Variables"

msgstr "متغیرهای خصوصی"

msgid "\"Private\" instance variables that cannot be accessed except from inside an object don't exist in Python. However, there is a convention that is followed by most Python code: a name prefixed with an underscore (e.g. ``_spam``) should be treated as a non-public part of the API (whether it is a function, a method or a data member). It should be considered an implementation detail and subject to change without notice."

msgstr "متغیرهای نمونه‌ای «خصوصی» که جز از درون یک شیء قابل دسترسی نیستند، در پایتون وجود ندارند. با این حال، یک قرارداد وجود دارد که توسط بیشتر کدهای پایتون دنبال می‌شود: یک نام که با زیرخط آغاز می‌شود (مثلاً ``_spam``) باید به‌عنوان بخشی غیرعمومی از API در نظر گرفته شود (خواه یک تابع، یک متد یا یک عضو داده باشد). باید به‌عنوان یک جزئیات پیاده‌سازی در نظر گرفته شود و ممکن است بدون اطلاع‌رسانی تغییر کند."

msgid "Since there is a valid use-case for class-private members (namely to avoid name clashes of names with names defined by subclasses), there is limited support for such a mechanism, called :dfn:`name mangling`. Any identifier of the form ``__spam`` (at least two leading underscores, at most one trailing underscore) is textually replaced with ``_classname__spam``, where ``classname`` is the current class name with leading underscore(s) stripped. This mangling is done without regard to the syntactic position of the identifier, as long as it occurs within the definition of a class."

msgstr "از آنجا که یک مورد استفاده‌ی معتبر برای اعضای خصوصی کلاس وجود دارد (به‌ویژه برای جلوگیری از برخورد نام‌ها با نام‌های تعریف‌شده توسط زیرکلاس‌ها)، پشتیبانی محدودی برای چنین مکانیزمی، به نام :dfn:`name mangling` (دستکاری نام) وجود دارد. هر شناسه‌ای به شکل ``__spam`` (حداقل دو زیرخط در ابتدا، حداکثر یک زیرخط در انتها) به‌صورت متنی با ``_classname__spam`` جایگزین می‌شود، که در آن ``classname`` نام کلاس جاری است با زیرسطرهای ابتدایی حذف‌شده. این دستکاری بدون در نظر گرفتن جایگاه نحوی شناسه انجام می‌شود، تا زمانی که درون تعریف یک کلاس رخ دهد."

msgid "The :ref:`private name mangling specifications <private-name-mangling>` for details and special cases."

msgstr "برای جزئیات و موارد خاص، به :ref:`مشخصات دستکاری نام‌های خصوصی <private-name-mangling>` مراجعه کنید."

msgid "Name mangling is helpful for letting subclasses override methods without breaking intraclass method calls. For example::"

msgstr "دستکاری نام برای این مفید است که به زیرکلاس‌ها اجازه دهد متدها را بدون شکستن فراخوانی‌های متد درون‌کلاسی بازنویسی کنند. برای مثال::"

msgid ""

msgstr ""

msgid "The above example would work even if ``MappingSubclass`` were to introduce a ``__update`` identifier since it is replaced with ``_Mapping__update`` in the ``Mapping`` class and ``_MappingSubclass__update`` in the ``MappingSubclass`` class respectively."

msgstr "مثال بالا حتی اگر ``MappingSubclass`` یک شناسه‌ی ``__update`` معرفی کند، کار خواهد کرد زیرا این شناسه به ترتیب در کلاس ``Mapping`` با ``_Mapping__update`` و در کلاس ``MappingSubclass`` با ``_MappingSubclass__update`` جایگزین می‌شود."

msgid "Note that the mangling rules are designed mostly to avoid accidents; it still is possible to access or modify a variable that is considered private. This can even be useful in special circumstances, such as in the debugger."

msgstr "توجه داشته باشید که قوانین دستکاری نام بیشتر برای جلوگیری از اشتباهات طراحی شده‌اند؛ همچنان دسترسی یا تغییر یک متغیر که خصوصی در نظر گرفته می‌شود، ممکن است. این حتی می‌تواند در شرایط خاص، مانند اشکال‌زدایی، مفید باشد."

msgid "Notice that code passed to ``exec()`` or ``eval()`` does not consider the classname of the invoking class to be the current class; this is similar to the effect of the ``global`` statement, the effect of which is likewise restricted to code that is byte-compiled together. The same restriction applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when referencing ``__dict__`` directly."

msgstr "توجه داشته باشید که کد ارسال‌شده به ``exec()`` یا ``eval()`` نام کلاس کلاس فراخوان‌کننده را به‌عنوان کلاس جاری در نظر نمی‌گیرد؛ این مشابه تأثیر دستور ``global`` است که تأثیر آن نیز به همین ترتیب به کدی که با هم بایت‌کامپایل می‌شوند، محدود است. همین محدودیت برای ``getattr()``، ``setattr()`` و ``delattr()`` نیز اعمال می‌شود، همچنین زمانی که به طور مستقیم به ``__dict__`` ارجاع داده می‌شود."

msgid "Odds and Ends"

msgstr "نکات متفرقه"

msgid "Sometimes it is useful to have a data type similar to the Pascal \"record\" or C \"struct\", bundling together a few named data items. The idiomatic approach is to use :mod:`dataclasses` for this purpose::"

msgstr "گاهی اوقات داشتن یک نوع داده مشابه «رکورد» در پاسکال یا «ساختار» در C مفید است، که چندین آیتم داده‌ی نام‌دار را کنار هم بسته‌بندی می‌کند. روش استاندارد برای این کار استفاده از :mod:`dataclasses` است::"

msgid ""

msgstr ""

msgid ""

msgstr ""

msgid "A piece of Python code that expects a particular abstract data type can often be passed a class that emulates the methods of that data type instead. For instance, if you have a function that formats some data from a file object, you can define a class with methods :meth:`~io.TextIOBase.read` and :meth:`~io.TextIOBase.readline` that get the data from a string buffer instead, and pass it as an argument."

msgstr "یک قطعه کد پایتون که انتظار یک نوع داده‌ی انتزاعی خاص را دارد، اغلب می‌تواند به جای آن، یک کلاس دریافت کند که متدهای آن نوع داده را شبیه‌سازی می‌کند. برای مثال، اگر تابعی دارید که داده‌هایی را از یک شیء فایل قالب‌بندی می‌کند، می‌توانید کلاسی تعریف کنید با متدهای :meth:`~io.TextIOBase.read` و :meth:`~io.TextIOBase.readline` که داده‌ها را از یک بافر رشته‌ای دریافت می‌کنند، و آن را به‌عنوان آرگومان به تابع ارسال کنید."

msgid ":ref:`Instance method objects <instance-methods>` have attributes, too: :attr:`m.__self__ <method.__self__>` is the instance object with the method :meth:`!m`, and :attr:`m.__func__ <method.__func__>` is the :ref:`function object <user-defined-funcs>` corresponding to the method."

msgstr ":ref:`اشیاء متد نمونه <instance-methods>` نیز ویژگی‌هایی دارند: :attr:`m.__self__ <method.__self__>` شیء نمونه‌ای است که متد :meth:`!m` به آن تعلق دارد، و :attr:`m.__func__ <method.__func__>` همان :ref:`شیء تابع <user-defined-funcs>` متناظر با آن متد است."

msgid "Iterators"

msgstr "پیمایش‌گرها"

msgid "By now you have probably noticed that most container objects can be looped over using a :keyword:`for` statement::"

msgstr "تا اینجا احتمالاً متوجه شده‌اید که می‌توان روی بیشتر اشیاء ظرف با استفاده از دستور :keyword:`for` حلقه زد::"

msgid ""

msgstr ""

msgid "This style of access is clear, concise, and convenient. The use of iterators pervades and unifies Python. Behind the scenes, the :keyword:`for` statement calls :func:`iter` on the container object. The function returns an iterator object that defines the method :meth:`~iterator.__next__` which accesses elements in the container one at a time. When there are no more elements, :meth:`~iterator.__next__` raises a :exc:`StopIteration` exception which tells the :keyword:`!for` loop to terminate. You can call the :meth:`~iterator.__next__` method using the :func:`next` built-in function; this example shows how it all works::"

msgstr "این سبک دسترسی واضح، مختصر و راحت است. استفاده از پیمایش‌گرها در همه‌جا نفوذ کرده و پایتون را یکپارچه می‌کنند. در پشت صحنه، دستور :keyword:`for` تابع :func:`iter` را روی شیء ظرف فراخوانی می‌کند. این تابع یک شیء پیمایش‌گر برمی‌گرداند که متد :meth:`~iterator.__next__` را تعریف می‌کند که به المان‌ها در ظرف یکی یکی دسترسی پیدا می‌کند. وقتی المان‌ها تمام شوند، :meth:`~iterator.__next__` یک استثنای :exc:`StopIteration` ایجاد می‌کند که به حلقه‌ی :keyword:`!for` می‌گوید پایان یابد. می‌توانید متد :meth:`~iterator.__next__` را با استفاده از تابع توکار :func:`next` فراخوانی کنید؛ این مثال نشان می‌دهد که چگونه همه‌چیز کار می‌کند::"

msgid ""

msgstr ""

msgid "Having seen the mechanics behind the iterator protocol, it is easy to add iterator behavior to your classes. Define an :meth:`~container.__iter__` method which returns an object with a :meth:`~iterator.__next__` method. If the class defines :meth:`!__next__`, then :meth:`!__iter__` can just return ``self``::"

msgstr "حالا که با سازوکار پشت پروتکل پیمایش‌گر آشنا شدید، اضافه کردن رفتار پیمایش‌گر به کلاس‌هایتان آسان است. یک متد :meth:`~container.__iter__` تعریف کنید که یک شیء با متد :meth:`~iterator.__next__` برمی‌گرداند. اگر کلاس :meth:`!__next__` را تعریف کرده باشد، آنگاه :meth:`!__iter__` می‌تواند فقط ``self`` را برگرداند::"

msgid ""

msgstr ""

msgid ""

msgstr ""

msgid "Generators"

msgstr "تولیدگر"

msgid ":term:`Generators <generator>` are a simple and powerful tool for creating iterators. They are written like regular functions but use the :keyword:`yield` statement whenever they want to return data. Each time :func:`next` is called on it, the generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create::"

msgstr ":term:`تولیدگر <generator>` یک ابزار ساده و قدرتمند برای ایجاد پیمایش‌گرها هستند. آن‌ها مانند توابع عادی نوشته می‌شوند اما هر زمان که می‌خواهند داده‌ای را بازگردانند از دستور :keyword:`yield` استفاده می‌کنند. هر بار که :func:`next` بر روی آن فراخوانی می‌شود، تولیدگر از جایی که متوقف شده ادامه می‌یابد (تمام مقادیر داده‌ها و اینکه آخرین دستور اجرا شده چه بوده را به خاطر می‌آورد). یک مثال نشان می‌دهد که ایجاد تولیدگرها می‌تواند به طرز باورنکردنی ساده باشد::"

msgid ""

msgstr ""

msgid ""

msgstr ""

msgid "Anything that can be done with generators can also be done with class-based iterators as described in the previous section. What makes generators so compact is that the :meth:`~iterator.__iter__` and :meth:`~generator.__next__` methods are created automatically."

msgstr "هر چیزی که با تولیدگرها قابل انجام است، می‌تواند با استفاده از پیمایش‌گرهای مبتنی بر کلاس نیز انجام شود، همانطور که در بخش قبلی توضیح داده شد. آنچه تولیدگرها را فشرده می‌کند، این است که روش‌های :meth:`~iterator.__iter__` و :meth:`~generator.__next__` به‌طور خودکار ایجاد می‌شوند."

msgid "Another key feature is that the local variables and execution state are automatically saved between calls. This made the function easier to write and much more clear than an approach using instance variables like ``self.index`` and ``self.data``."

msgstr "یکی دیگر از ویژگی‌های اصلی این است که متغیرهای محلی و وضعیت اجرا به‌طور خودکار بین فراخوانی‌ها ذخیره می‌شوند. این امر نوشتن تابع را آسان‌تر و خیلی واضح‌تر از رویکردی که از متغیرهای نمونه‌ای مانند ``self.index`` و ``self.data`` استفاده می‌کند، کرده است."

msgid "In addition to automatic method creation and saving program state, when generators terminate, they automatically raise :exc:`StopIteration`. In combination, these features make it easy to create iterators with no more effort than writing a regular function."

msgstr "علاوه بر ایجاد خودکار متدها و ذخیره سازی وضعیت برنامه، زمانی که تولیدگرها خاتمه می‌یابند، به‌طور خودکار :exc:`StopIteration` را ایجاد می‌کنند. این ویژگی‌ها به صورت ترکیبی، ساختن پیمایش‌گرها را به همان سادگی نوشتن یک تابع عادی امکان پذیر می‌سازند."

msgid "Generator Expressions"

msgstr "عبارات تولیدگر"

msgid "Some simple generators can be coded succinctly as expressions using a syntax similar to list comprehensions but with parentheses instead of square brackets. These expressions are designed for situations where the generator is used right away by an enclosing function. Generator expressions are more compact but less versatile than full generator definitions and tend to be more memory friendly than equivalent list comprehensions."

msgstr "برخی از تولیدگرهای ساده را می‌توان به‌صورت مختصر به‌عنوان عبارت کدنویسی کرد، با استفاده از یک سینتکس مشابه درک‌فهرستها اما با پرانتز به جای کروشه‌ی باز. این عبارت‌ها برای شرایطی طراحی شده‌اند که تولیدگر بلافاصله توسط یک تابع محاط‌شونده استفاده می‌شود. عبارت‌های تولیدگر فشرده‌تر هستند اما نسبت به تعاریف کامل تولیدگر، انعطاف‌پذیری کمتری دارند و معمولاً نسبت به درک‌فهرستهای معادل، با حافظه سازگارتر هستند."

msgid "Examples::"

msgstr "مثالها::"

msgid ""

msgstr ""

msgid "In most cases, generator expressions must be wrapped in parentheses. As a special case, however, when provided as the sole argument to a function (as in the examples involving ``sum``, ``set``, ``max``, and ``list`` above), the generator expression does not need to be wrapped in an additional set of parentheses. That is to say, the following two pieces of code are semantically equivalent::"

msgstr "در بیشتر موارد، عبارت‌های تولیدگر باید داخل پرانتز قرار گیرند. با این حال، به عنوان یک مورد خاص، هنگامی که به عنوان تنها آرگومان یک تابع ارائه می‌شوند (همانند مثال‌های شامل ``sum``، ``set``، ``max`` و ``list`` در بالا)، عبارت تولیدگر نیازی به قرار گرفتن در یک مجموعه پرانتز اضافی ندارد. به عبارت دیگر، دو قطعه کد زیر از نظر معنایی معادل هستند::"

msgid ""

msgstr ""

msgid "as are the following::"

msgstr "همچنین موارد زیر::"

msgid ""

msgstr ""

msgid "Footnotes"