# 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 Feyzabadi Farahani, 2025

# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025

# AmirHossein SAMIMI, 2025

# khosro azimi, 2025

# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026

# invincible627 <fatemehzahra810@gmail.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-08-18 04:30+0000\n"

"PO-Revision-Date: 2026-08-15 07:15+0330\n"

"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"

"Language-Team: Persian (https://github.com/revisto/python-docs-fa/)\n"

"Language: fa\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

"X-Generator: Poedit 3.6\n"

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

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 "یک *دامنه* «*scope*» یک ناحیه‌ی متنی از یک برنامه‌ی پایتون است که در آن یک فضای نام «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 ""

"def scope_test():\n"

" def do_local():\n"

" spam = \"local spam\"\n"

"\n"

" def do_nonlocal():\n"

" nonlocal spam\n"

" spam = \"nonlocal spam\"\n"

"\n"

" def do_global():\n"

" global spam\n"

" spam = \"global spam\"\n"

"\n"

" spam = \"test spam\"\n"

" do_local()\n"

" print(\"After local assignment:\", spam)\n"

" do_nonlocal()\n"

" print(\"After nonlocal assignment:\", spam)\n"

" do_global()\n"

" print(\"After global assignment:\", spam)\n"

"\n"

"scope_test()\n"

"print(\"In global scope:\", spam)"

msgstr ""

"def scope_test():\n"

" def do_local():\n"

" spam = \"local spam\"\n"

"\n"

" def do_nonlocal():\n"

" nonlocal spam\n"

" spam = \"nonlocal spam\"\n"

"\n"

" def do_global():\n"

" global spam\n"

" spam = \"global spam\"\n"

"\n"

" spam = \"test spam\"\n"

" do_local()\n"

" print(\"After local assignment:\", spam)\n"

" do_nonlocal()\n"

" print(\"After nonlocal assignment:\", spam)\n"

" do_global()\n"

" print(\"After global assignment:\", spam)\n"

"\n"

"scope_test()\n"

"print(\"In global scope:\", spam)"

msgid "The output of the example code is:"

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

msgid ""

"After local assignment: test spam\n"

"After nonlocal assignment: nonlocal spam\n"

"After global assignment: nonlocal spam\n"

"In global scope: global spam"

msgstr ""

"After local assignment: test spam\n"

"After nonlocal assignment: nonlocal spam\n"

"After global assignment: nonlocal spam\n"

"In global scope: global spam"

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 ""

"class ClassName:\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

msgstr ""

"class ClassName:\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

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 "هنگامی که یک تعریف کلاس به‌طور عادی (با رسیدن به انتها) ترک می‌شود، یک *شیء کلاس* ایجاد می‌شود. این در اصل یک پوسته (wrapper) پیرامون محتویات فضای نامی است که توسط تعریف کلاس ایجاد شده است؛ در بخش بعدی بیشتر درباره‌ی اشیاء کلاس خواهیم آموخت. محدوده‌ی محلی اصلی (همان محدوده‌ای که درست قبل از ورود به تعریف کلاس فعال بود) بازیابی می‌شود، و شیء کلاس در اینجا به نام کلاسی که در سرآیند تعریف کلاس داده شده است، متصل می‌شود (: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 ""

"class MyClass:\n"

" \"\"\"A simple example class\"\"\"\n"

" i = 12345\n"

"\n"

" def f(self):\n"

" return 'hello world'"

msgstr ""

"class MyClass:\n"

" \"\"\"A simple example class\"\"\"\n"

" i = 12345\n"

"\n"

" def f(self):\n"

" return 'hello world'"

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__` نیز یک ویژگی معتبر است که رشته‌ی مستند (docstring) متعلق به کلاس را برمی‌گرداند: ``\"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 ""

"def __init__(self):\n"

" self.data = []"

msgstr ""

"def __init__(self):\n"

" self.data = []"

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 ""

">>> class Complex:\n"

"... def __init__(self, realpart, imagpart):\n"

"... self.r = realpart\n"

"... self.i = imagpart\n"

"...\n"

">>> x = Complex(3.0, -4.5)\n"

">>> x.r, x.i\n"

"(3.0, -4.5)"

msgstr ""

">>> class Complex:\n"

"... def __init__(self, realpart, imagpart):\n"

"... self.r = realpart\n"

"... self.i = imagpart\n"

"...\n"

">>> x = Complex(3.0, -4.5)\n"

">>> x.r, x.i\n"

"(3.0, -4.5)"

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 "حالا با اشیاء نمونه چه کاری می‌توانیم انجام دهیم؟ تنها عملیاتی که اشیاء نمونه می‌فهمند، ارجاع به ویژگیها (attribute references) است. دو نوع نام ویژگی معتبر وجود دارد: ویژگیهای داده (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 ""

"x.counter = 1\n"

"while x.counter < 10:\n"

" x.counter = x.counter * 2\n"

"print(x.counter)\n"

"del x.counter"

msgstr ""

"x.counter = 1\n"

"while x.counter < 10:\n"

" x.counter = x.counter * 2\n"

"print(x.counter)\n"

"del x.counter"

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 ""

"xf = x.f\n"

"while True:\n"

" print(xf())"

msgstr ""

"xf = x.f\n"

"while True:\n"

" print(xf())"

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 ""

"class Dog:\n"

"\n"

" kind = 'canine' # class variable shared by all instances\n"

"\n"

" def __init__(self, name):\n"

" self.name = name # instance variable unique to each instance\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.kind # shared by all dogs\n"

"'canine'\n"

">>> e.kind # shared by all dogs\n"

"'canine'\n"

">>> d.name # unique to d\n"

"'Fido'\n"

">>> e.name # unique to e\n"

"'Buddy'"

msgstr ""

"class Dog:\n"

"\n"

" kind = 'canine' # متغیر کلاسی که بین همهٔ نمونه‌ها مشترک است\n"

"\n"

" def __init__(self, name):\n"

" self.name = name # متغیر نمونه که برای هر نمونه یکتا است\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.kind # بین همهٔ سگ‌ها مشترک است\n"

"'canine'\n"

">>> e.kind # بین همهٔ سگ‌ها مشترک است\n"

"'canine'\n"

">>> d.name # مخصوص d است\n"

"'Fido'\n"

">>> e.name # مخصوص e است\n"

"'Buddy'"

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 ""

"class Dog:\n"

"\n"

" tricks = [] # mistaken use of a class variable\n"

"\n"

" def __init__(self, name):\n"

" self.name = name\n"

"\n"

" def add_trick(self, trick):\n"

" self.tricks.append(trick)\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.add_trick('roll over')\n"

">>> e.add_trick('play dead')\n"

">>> d.tricks # unexpectedly shared by all dogs\n"

"['roll over', 'play dead']"

msgstr ""

"class Dog:\n"

"\n"

" tricks = [] # استفادهٔ اشتباه از یک متغیر کلاسی\n"

"\n"

" def __init__(self, name):\n"

" self.name = name\n"

"\n"

" def add_trick(self, trick):\n"

" self.tricks.append(trick)\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.add_trick('roll over')\n"

">>> e.add_trick('play dead')\n"

">>> d.tricks # به‌طور غیرمنتظره بین همهٔ سگ‌ها مشترک است\n"

"['roll over', 'play dead']"

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

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

msgid ""

"class Dog:\n"

"\n"

" def __init__(self, name):\n"

" self.name = name\n"

" self.tricks = [] # creates a new empty list for each dog\n"

"\n"

" def add_trick(self, trick):\n"

" self.tricks.append(trick)\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.add_trick('roll over')\n"

">>> e.add_trick('play dead')\n"

">>> d.tricks\n"

"['roll over']\n"

">>> e.tricks\n"

"['play dead']"

msgstr ""

"class Dog:\n"

"\n"

" def __init__(self, name):\n"

" self.name = name\n"

" self.tricks = [] # برای هر سگ، یک فهرست خالی جدید ایجاد می‌کند\n"

"\n"

" def add_trick(self, trick):\n"

" self.tricks.append(trick)\n"

"\n"

">>> d = Dog('Fido')\n"

">>> e = Dog('Buddy')\n"

">>> d.add_trick('roll over')\n"

">>> e.add_trick('play dead')\n"

">>> d.tricks\n"

"['roll over']\n"

">>> e.tricks\n"

"['play dead']"

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 ""

">>> class Warehouse:\n"

"... purpose = 'storage'\n"

"... region = 'west'\n"

"...\n"

">>> w1 = Warehouse()\n"

">>> print(w1.purpose, w1.region)\n"

"storage west\n"

">>> w2 = Warehouse()\n"

">>> w2.region = 'east'\n"

">>> print(w2.purpose, w2.region)\n"

"storage east"

msgstr ""

">>> class Warehouse:\n"

"... purpose = 'storage'\n"

"... region = 'west'\n"

"...\n"

">>> w1 = Warehouse()\n"

">>> print(w1.purpose, w1.region)\n"

"storage west\n"

">>> w2 = Warehouse()\n"

">>> w2.region = 'east'\n"

">>> print(w2.purpose, w2.region)\n"

"storage east"

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 ""

"# Function defined outside the class\n"

"def f1(self, x, y):\n"

" return min(x, x+y)\n"

"\n"

"class C:\n"

" f = f1\n"

"\n"

" def g(self):\n"

" return 'hello world'\n"

"\n"

" h = g"

msgstr ""

"# تابع بیرون از کلاس تعریف شده است\n"

"def f1(self, x, y):\n"

" return min(x, x+y)\n"

"\n"

"class C:\n"

" f = f1\n"

"\n"

" def g(self):\n"

" return 'hello world'\n"

"\n"

" h = g"

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 ""

"class Bag:\n"

" def __init__(self):\n"

" self.data = []\n"

"\n"

" def add(self, x):\n"

" self.data.append(x)\n"

"\n"

" def addtwice(self, x):\n"

" self.add(x)\n"

" self.add(x)"

msgstr ""

"class Bag:\n"

" def __init__(self):\n"

" self.data = []\n"

"\n"

" def add(self, x):\n"

" self.data.append(x)\n"

"\n"

" def addtwice(self, x):\n"

" self.add(x)\n"

" self.add(x)"

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 ""

"class DerivedClassName(BaseClassName):\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

msgstr ""

"class DerivedClassName(BaseClassName):\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

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 ""

"class DerivedClassName(Base1, Base2, Base3):\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

msgstr ""

"class DerivedClassName(Base1, Base2, Base3):\n"

" <statement-1>\n"

" .\n"

" .\n"

" .\n"

" <statement-N>"

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 "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 ""

"class Mapping:\n"

" def __init__(self, iterable):\n"

" self.items_list = []\n"

" self.__update(iterable)\n"

"\n"

" def update(self, iterable):\n"

" for item in iterable:\n"

" self.items_list.append(item)\n"

"\n"

" __update = update # private copy of original update() method\n"

"\n"

"class MappingSubclass(Mapping):\n"

"\n"

" def update(self, keys, values):\n"

" # provides new signature for update()\n"

" # but does not break __init__()\n"

" for item in zip(keys, values):\n"

" self.items_list.append(item)"

msgstr ""

"class Mapping:\n"

" def __init__(self, iterable):\n"

" self.items_list = []\n"

" self.__update(iterable)\n"

"\n"

" def update(self, iterable):\n"

" for item in iterable:\n"

" self.items_list.append(item)\n"

"\n"

" __update = update # نسخهٔ خصوصی از متد اصلی update()\n"

"\n"

"class MappingSubclass(Mapping):\n"

"\n"

" def update(self, keys, values):\n"

" # امضای جدیدی برای update() فراهم می‌کند\n"

" # اما __init__ را خراب نمی‌کند\n"

" for item in zip(keys, values):\n"

" self.items_list.append(item)"

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 ""

"from dataclasses import dataclass\n"

"\n"

"@dataclass\n"

"class Employee:\n"

" name: str\n"

" dept: str\n"

" salary: int"

msgstr ""

"from dataclasses import dataclass\n"

"\n"

"@dataclass\n"

"class Employee:\n"

" name: str\n"

" dept: str\n"

" salary: int"

msgid ""

">>> john = Employee('john', 'computer lab', 1000)\n"

">>> john.dept\n"

"'computer lab'\n"

">>> john.salary\n"

"1000"

msgstr ""

">>> john = Employee('john', 'computer lab', 1000)\n"

">>> john.dept\n"

"'computer lab'\n"

">>> john.salary\n"

"1000"

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 ""

"for element in [1, 2, 3]:\n"

" print(element)\n"

"for element in (1, 2, 3):\n"

" print(element)\n"

"for key in {'one':1, 'two':2}:\n"

" print(key)\n"

"for char in \"123\":\n"

" print(char)\n"

"for line in open(\"myfile.txt\"):\n"

" print(line, end='')"

msgstr ""

"for element in [1, 2, 3]:\n"

" print(element)\n"

"for element in (1, 2, 3):\n"

" print(element)\n"

"for key in {'one':1, 'two':2}:\n"

" print(key)\n"

"for char in \"123\":\n"

" print(char)\n"

"for line in open(\"myfile.txt\"):\n"

" print(line, end='')"

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 ""

">>> s = 'abc'\n"

">>> it = iter(s)\n"

">>> it\n"

"<str_iterator object at 0x10c90e650>\n"

">>> next(it)\n"

"'a'\n"

">>> next(it)\n"

"'b'\n"

">>> next(it)\n"

"'c'\n"

">>> next(it)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" next(it)\n"

"StopIteration"

msgstr ""

">>> s = 'abc'\n"

">>> it = iter(s)\n"

">>> it\n"

"<str_iterator object at 0x10c90e650>\n"

">>> next(it)\n"

"'a'\n"

">>> next(it)\n"

"'b'\n"

">>> next(it)\n"

"'c'\n"

">>> next(it)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" next(it)\n"

"StopIteration"

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 ""

"class Reverse:\n"

" \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n"

" def __init__(self, data):\n"

" self.data = data\n"

" self.index = len(data)\n"

"\n"

" def __iter__(self):\n"

" return self\n"

"\n"

" def __next__(self):\n"

" if self.index == 0:\n"

" raise StopIteration\n"

" self.index = self.index - 1\n"

" return self.data[self.index]"

msgstr ""

"class Reverse:\n"

" \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n"

" def __init__(self, data):\n"

" self.data = data\n"

" self.index = len(data)\n"

"\n"

" def __iter__(self):\n"

" return self\n"

"\n"

" def __next__(self):\n"

" if self.index == 0:\n"

" raise StopIteration\n"

" self.index = self.index - 1\n"

" return self.data[self.index]"

msgid ""

">>> rev = Reverse('spam')\n"

">>> iter(rev)\n"

"<__main__.Reverse object at 0x00A1DB50>\n"

">>> for char in rev:\n"

"... print(char)\n"

"...\n"

"m\n"

"a\n"

"p\n"

"s"

msgstr ""

">>> rev = Reverse('spam')\n"

">>> iter(rev)\n"

"<__main__.Reverse object at 0x00A1DB50>\n"

">>> for char in rev:\n"

"... print(char)\n"

"...\n"

"m\n"

"a\n"

"p\n"

"s"

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

msgid ""

"def reverse(data):\n"

" for index in range(len(data)-1, -1, -1):\n"

" yield data[index]"

msgstr ""

"def reverse(data):\n"

" for index in range(len(data)-1, -1, -1):\n"

" yield data[index]"

msgid ""

">>> for char in reverse('golf'):\n"

"... print(char)\n"

"...\n"

"f\n"

"l\n"

"o\n"

"g"

msgstr ""

">>> for char in reverse('golf'):\n"

"... print(char)\n"

"...\n"

"f\n"

"l\n"

"o\n"

"g"

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 ""

">>> sum(i*i for i in range(10)) # sum of squares\n"

"285\n"

"\n"

">>> xvec = [10, 20, 30]\n"

">>> yvec = [7, 5, 3]\n"

">>> sum(x*y for x,y in zip(xvec, yvec)) # dot product\n"

"260\n"

"\n"

">>> unique_words = set(word for line in page for word in line.split())\n"

"\n"

">>> valedictorian = max((student.gpa, student.name) for student in graduates)\n"

"\n"

">>> data = 'golf'\n"

">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"

"['f', 'l', 'o', 'g']"

msgstr ""

">>> sum(i*i for i in range(10)) # مجموع مربع‌ها\n"

"285\n"

"\n"

">>> xvec = [10, 20, 30]\n"

">>> yvec = [7, 5, 3]\n"

">>> sum(x*y for x,y in zip(xvec, yvec)) # حاصل‌ضرب داخلی\n"

"260"

msgid "Footnotes"

msgstr "پاورقی‌ها"

msgid "Except for one thing. Module objects have a secret read-only attribute called :attr:`~object.__dict__` which returns the dictionary used to implement the module's namespace; the name ``__dict__`` is an attribute but not a global name. Obviously, using this violates the abstraction of namespace implementation, and should be restricted to things like post-mortem debuggers."

msgstr "به جز یک مورد. اشیاء ماژول یک ویژگی مخفی فقط‌خواندنی دارند به نام :attr:`~object.__dict__` که دیکشنری مورد استفاده برای پیاده‌سازی فضای نام ماژول را برمی‌گرداند؛ نام ``__dict__`` یک ویژگی است اما یک نام سراسری نیست. بدیهی است که استفاده از این ویژگی، انتزاع پیاده‌سازی فضای نام را نقض می‌کند و باید به مواردی مانند اشکال‌زدای پس‌ازمرگ محدود شود."

msgid "object"

msgstr "شیء"

msgid "method"

msgstr "متد"

msgid "name"

msgstr "اسم"

msgid "mangling"

msgstr "دستکاری نام"