datamodel.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2026.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-04-18 10:29+0700\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language: vi\n"
"Language-Team: vi <LL@li.org>\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.18.0\n"

#: ../../reference/datamodel.rst:6
msgid "Data model"
msgstr ""

#: ../../reference/datamodel.rst:12
msgid "Objects, values and types"
msgstr ""

#: ../../reference/datamodel.rst:18
msgid ""
":dfn:`Objects` are Python's abstraction for data.  All data in a Python "
"program is represented by objects or by relations between objects. Even "
"code is represented by objects."
msgstr ""

#: ../../reference/datamodel.rst:31
msgid ""
"Every object has an identity, a type and a value.  An object's *identity*"
" never changes once it has been created; you may think of it as the "
"object's address in memory.  The :keyword:`is` operator compares the "
"identity of two objects; the :func:`id` function returns an integer "
"representing its identity."
msgstr ""

#: ../../reference/datamodel.rst:38
msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."
msgstr ""

#: ../../reference/datamodel.rst:40
msgid ""
"An object's type determines the operations that the object supports "
"(e.g., \"does it have a length?\") and also defines the possible values "
"for objects of that type.  The :func:`type` function returns an object's "
"type (which is an object itself).  Like its identity, an object's "
":dfn:`type` is also unchangeable. [#]_"
msgstr ""

#: ../../reference/datamodel.rst:46
msgid ""
"The *value* of some objects can change.  Objects whose value can change "
"are said to be *mutable*; objects whose value is unchangeable once they "
"are created are called *immutable*. (The value of an immutable container "
"object that contains a reference to a mutable object can change when the "
"latter's value is changed; however the container is still considered "
"immutable, because the collection of objects it contains cannot be "
"changed.  So, immutability is not strictly the same as having an "
"unchangeable value, it is more subtle.) An object's mutability is "
"determined by its type; for instance, numbers, strings and tuples are "
"immutable, while dictionaries and lists are mutable."
msgstr ""

#: ../../reference/datamodel.rst:61
msgid ""
"Objects are never explicitly destroyed; however, when they become "
"unreachable they may be garbage-collected.  An implementation is allowed "
"to postpone garbage collection or omit it altogether --- it is a matter "
"of implementation quality how garbage collection is implemented, as long "
"as no objects are collected that are still reachable."
msgstr ""

#: ../../reference/datamodel.rst:69
msgid ""
"CPython currently uses a reference-counting scheme with (optional) "
"delayed detection of cyclically linked garbage, which collects most "
"objects as soon as they become unreachable, but is not guaranteed to "
"collect garbage containing circular references.  See the documentation of"
" the :mod:`gc` module for information on controlling the collection of "
"cyclic garbage. Other implementations act differently and CPython may "
"change. Do not depend on immediate finalization of objects when they "
"become unreachable (so you should always close files explicitly)."
msgstr ""

#: ../../reference/datamodel.rst:78
msgid ""
"Note that the use of the implementation's tracing or debugging facilities"
" may keep objects alive that would normally be collectable. Also note "
"that catching an exception with a :keyword:`try`...\\ :keyword:`except` "
"statement may keep objects alive."
msgstr ""

#: ../../reference/datamodel.rst:83
msgid ""
"Some objects contain references to \"external\" resources such as open "
"files or windows.  It is understood that these resources are freed when "
"the object is garbage-collected, but since garbage collection is not "
"guaranteed to happen, such objects also provide an explicit way to "
"release the external resource, usually a :meth:`!close` method. Programs "
"are strongly recommended to explicitly close such objects.  The "
":keyword:`try`...\\ :keyword:`finally` statement and the :keyword:`with` "
"statement provide convenient ways to do this."
msgstr ""

#: ../../reference/datamodel.rst:93
msgid ""
"Some objects contain references to other objects; these are called "
"*containers*. Examples of containers are tuples, lists and dictionaries."
"  The references are part of a container's value.  In most cases, when we"
" talk about the value of a container, we imply the values, not the "
"identities of the contained objects; however, when we talk about the "
"mutability of a container, only the identities of the immediately "
"contained objects are implied.  So, if an immutable container (like a "
"tuple) contains a reference to a mutable object, its value changes if "
"that mutable object is changed."
msgstr ""

#: ../../reference/datamodel.rst:102
msgid ""
"Types affect almost all aspects of object behavior.  Even the importance "
"of object identity is affected in some sense: for immutable types, "
"operations that compute new values may actually return a reference to any"
" existing object with the same type and value, while for mutable objects "
"this is not allowed. For example, after ``a = 1; b = 1``, *a* and *b* may"
" or may not refer to the same object with the value one, depending on the"
" implementation. This is because :class:`int` is an immutable type, so "
"the reference to ``1`` can be reused. This behaviour depends on the "
"implementation used, so should not be relied upon, but is something to be"
" aware of when making use of object identity tests. However, after ``c = "
"[]; d = []``, *c* and *d* are guaranteed to refer to two different, "
"unique, newly created empty lists. (Note that ``e = f = []`` assigns the "
"*same* object to both *e* and *f*.)"
msgstr ""

#: ../../reference/datamodel.rst:120
msgid "The standard type hierarchy"
msgstr ""

#: ../../reference/datamodel.rst:129
msgid ""
"Below is a list of the types that are built into Python.  Extension "
"modules (written in C, Java, or other languages, depending on the "
"implementation) can define additional types.  Future versions of Python "
"may add types to the type hierarchy (e.g., rational numbers, efficiently "
"stored arrays of integers, etc.), although such additions will often be "
"provided via the standard library instead."
msgstr ""

#: ../../reference/datamodel.rst:140
msgid ""
"Some of the type descriptions below contain a paragraph listing 'special "
"attributes.'  These are attributes that provide access to the "
"implementation and are not intended for general use.  Their definition "
"may change in the future."
msgstr ""

#: ../../reference/datamodel.rst:146 ../../reference/datamodel.rst:148
msgid "None"
msgstr ""

#: ../../reference/datamodel.rst:150
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name ``None``. It is used to"
" signify the absence of a value in many situations, e.g., it is returned "
"from functions that don't explicitly return anything. Its truth value is "
"false."
msgstr ""

#: ../../reference/datamodel.rst:157 ../../reference/datamodel.rst:159
msgid "NotImplemented"
msgstr ""

#: ../../reference/datamodel.rst:161
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name :data:`NotImplemented`."
" Numeric methods and rich comparison methods should return this value if "
"they do not implement the operation for the operands provided.  (The "
"interpreter will then try the reflected operation, or some other "
"fallback, depending on the operator.)  It should not be evaluated in a "
"boolean context."
msgstr ""

#: ../../reference/datamodel.rst:168
msgid "See :ref:`implementing-the-arithmetic-operations` for more details."
msgstr ""

#: ../../reference/datamodel.rst:172
msgid "Evaluating :data:`NotImplemented` in a boolean context was deprecated."
msgstr ""

#: ../../reference/datamodel.rst:175
msgid ""
"Evaluating :data:`NotImplemented` in a boolean context now raises a "
":exc:`TypeError`. It previously evaluated to :const:`True` and emitted a "
":exc:`DeprecationWarning` since Python 3.9."
msgstr ""

#: ../../reference/datamodel.rst:182 ../../reference/datamodel.rst:183
msgid "Ellipsis"
msgstr ""

#: ../../reference/datamodel.rst:187
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the literal ``...`` or the built-in name "
"``Ellipsis``.  Its truth value is true."
msgstr ""

#: ../../reference/datamodel.rst:193
msgid ":class:`numbers.Number`"
msgstr ""

#: ../../reference/datamodel.rst:197
msgid ""
"These are created by numeric literals and returned as results by "
"arithmetic operators and arithmetic built-in functions.  Numeric objects "
"are immutable; once created their value never changes.  Python numbers "
"are of course strongly related to mathematical numbers, but subject to "
"the limitations of numerical representation in computers."
msgstr ""

#: ../../reference/datamodel.rst:203
msgid ""
"The string representations of the numeric classes, computed by "
":meth:`~object.__repr__` and :meth:`~object.__str__`, have the following "
"properties:"
msgstr ""

#: ../../reference/datamodel.rst:207
msgid ""
"They are valid numeric literals which, when passed to their class "
"constructor, produce an object having the value of the original numeric."
msgstr ""

#: ../../reference/datamodel.rst:211
msgid "The representation is in base 10, when possible."
msgstr ""

#: ../../reference/datamodel.rst:213
msgid ""
"Leading zeros, possibly excepting a single zero before a decimal point, "
"are not shown."
msgstr ""

#: ../../reference/datamodel.rst:216
msgid ""
"Trailing zeros, possibly excepting a single zero after a decimal point, "
"are not shown."
msgstr ""

#: ../../reference/datamodel.rst:219
msgid "A sign is shown only when the number is negative."
msgstr ""

#: ../../reference/datamodel.rst:221
msgid ""
"Python distinguishes between integers, floating-point numbers, and "
"complex numbers:"
msgstr ""

#: ../../reference/datamodel.rst:226
msgid ":class:`numbers.Integral`"
msgstr ""

#: ../../reference/datamodel.rst:230
msgid ""
"These represent elements from the mathematical set of integers (positive "
"and negative)."
msgstr ""

#: ../../reference/datamodel.rst:236
msgid ""
"The rules for integer representation are intended to give the most "
"meaningful interpretation of shift and mask operations involving negative"
" integers."
msgstr ""

#: ../../reference/datamodel.rst:239
msgid "There are two types of integers:"
msgstr ""

#: ../../reference/datamodel.rst:241
msgid "Integers (:class:`int`)"
msgstr ""

#: ../../reference/datamodel.rst:242
msgid ""
"These represent numbers in an unlimited range, subject to available "
"(virtual) memory only.  For the purpose of shift and mask operations, a "
"binary representation is assumed, and negative numbers are represented in"
" a variant of 2's complement which gives the illusion of an infinite "
"string of sign bits extending to the left."
msgstr ""

#: ../../reference/datamodel.rst:248
msgid "Booleans (:class:`bool`)"
msgstr ""

#: ../../reference/datamodel.rst:254
msgid ""
"These represent the truth values False and True.  The two objects "
"representing the values ``False`` and ``True`` are the only Boolean "
"objects. The Boolean type is a subtype of the integer type, and Boolean "
"values behave like the values 0 and 1, respectively, in almost all "
"contexts, the exception being that when converted to a string, the "
"strings ``\"False\"`` or ``\"True\"`` are returned, respectively."
msgstr ""

#: ../../reference/datamodel.rst:264
msgid ":class:`numbers.Real` (:class:`float`)"
msgstr ""

#: ../../reference/datamodel.rst:272
msgid ""
"These represent machine-level double precision floating-point numbers. "
"You are at the mercy of the underlying machine architecture (and C or "
"Java implementation) for the accepted range and handling of overflow. "
"Python does not support single-precision floating-point numbers; the "
"savings in processor and memory usage that are usually the reason for "
"using these are dwarfed by the overhead of using objects in Python, so "
"there is no reason to complicate the language with two kinds of floating-"
"point numbers."
msgstr ""

#: ../../reference/datamodel.rst:282
msgid ":class:`numbers.Complex` (:class:`complex`)"
msgstr ""

#: ../../reference/datamodel.rst:288
msgid ""
"These represent complex numbers as a pair of machine-level double "
"precision floating-point numbers.  The same caveats apply as for "
"floating-point numbers. The real and imaginary parts of a complex number "
"``z`` can be retrieved through the read-only attributes ``z.real`` and "
"``z.imag``."
msgstr ""

#: ../../reference/datamodel.rst:296
msgid "Sequences"
msgstr ""

#: ../../reference/datamodel.rst:305
msgid ""
"These represent finite ordered sets indexed by non-negative numbers. The "
"built-in function :func:`len` returns the number of items of a sequence. "
"When the length of a sequence is *n*, the index set contains the numbers "
"0, 1, ..., *n*-1.  Item *i* of sequence *a* is selected by ``a[i]``. Some"
" sequences, including built-in sequences, interpret negative subscripts "
"by adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, "
"the second to last item of sequence a with length ``n``."
msgstr ""

#: ../../reference/datamodel.rst:313
msgid ""
"The resulting value must be a nonnegative integer less than the number of"
" items in the sequence. If it is not, an :exc:`IndexError` is raised."
msgstr ""

#: ../../reference/datamodel.rst:322
msgid ""
"Sequences also support slicing: ``a[start:stop]`` selects all items with "
"index *k* such that *start* ``<=`` *k* ``<`` *stop*.  When used as an "
"expression, a slice is a sequence of the same type. The comment above "
"about negative subscripts also applies to negative slice positions. Note "
"that no error is raised if a slice position is less than zero or larger "
"than the length of the sequence."
msgstr ""

#: ../../reference/datamodel.rst:329
msgid ""
"If *start* is missing or :data:`None`, slicing behaves as if *start* was "
"zero. If *stop* is missing or ``None``, slicing behaves as if *stop* was "
"equal to the length of the sequence."
msgstr ""

#: ../../reference/datamodel.rst:333
msgid ""
"Some sequences also support \"extended slicing\" with a third \"step\" "
"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x"
" = i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."
msgstr ""

#: ../../reference/datamodel.rst:337
msgid "Sequences are distinguished according to their mutability:"
msgstr ""

#: ../../reference/datamodel.rst:341
msgid "Immutable sequences"
msgstr ""

#: ../../reference/datamodel.rst:347
msgid ""
"An object of an immutable sequence type cannot change once it is created."
"  (If the object contains references to other objects, these other "
"objects may be mutable and may be changed; however, the collection of "
"objects directly referenced by an immutable object cannot change.)"
msgstr ""

#: ../../reference/datamodel.rst:352
msgid "The following types are immutable sequences:"
msgstr ""

#: ../../reference/datamodel.rst:357
msgid "Strings"
msgstr ""

#: ../../reference/datamodel.rst:365
msgid ""
"A string (:class:`str`) is a sequence of values that represent "
":dfn:`characters`, or more formally, *Unicode code points*. All the code "
"points in the range ``0`` to ``0x10FFFF`` can be represented in a string."
msgstr ""

#: ../../reference/datamodel.rst:370
msgid ""
"Python doesn't have a dedicated *character* type. Instead, every code "
"point in the string is represented as a string object with length ``1``."
msgstr ""

#: ../../reference/datamodel.rst:374
msgid ""
"The built-in function :func:`ord` converts a code point from its string "
"form to an integer in the range ``0`` to ``0x10FFFF``; :func:`chr` "
"converts an integer in the range ``0`` to ``0x10FFFF`` to the "
"corresponding length ``1`` string object. :meth:`str.encode` can be used "
"to convert a :class:`str` to :class:`bytes` using the given text "
"encoding, and :meth:`bytes.decode` can be used to achieve the opposite."
msgstr ""

#: ../../reference/datamodel.rst:382
msgid "Tuples"
msgstr ""

#: ../../reference/datamodel.rst:388
msgid ""
"The items of a :class:`tuple` are arbitrary Python objects. Tuples of two"
" or more items are formed by comma-separated lists of expressions.  A "
"tuple of one item (a 'singleton') can be formed by affixing a comma to an"
" expression (an expression by itself does not create a tuple, since "
"parentheses must be usable for grouping of expressions).  An empty tuple "
"can be formed by an empty pair of parentheses."
msgstr ""

#: ../../reference/datamodel.rst:395
msgid "Bytes"
msgstr ""

#: ../../reference/datamodel.rst:398
msgid ""
"A :class:`bytes` object is an immutable array.  The items are 8-bit "
"bytes, represented by integers in the range 0 <= x < 256.  Bytes literals"
" (like ``b'abc'``) and the built-in :func:`bytes` constructor can be used"
" to create bytes objects.  Also, bytes objects can be decoded to strings "
"via the :meth:`~bytes.decode` method."
msgstr ""

#: ../../reference/datamodel.rst:406
msgid "Mutable sequences"
msgstr ""

#: ../../reference/datamodel.rst:415
msgid ""
"Mutable sequences can be changed after they are created.  The "
"subscription and slicing notations can be used as the target of "
"assignment and :keyword:`del` (delete) statements."
msgstr ""

#: ../../reference/datamodel.rst:423
msgid ""
"The :mod:`collections` and :mod:`array` module provide additional "
"examples of mutable sequence types."
msgstr ""

#: ../../reference/datamodel.rst:426
msgid "There are currently two intrinsic mutable sequence types:"
msgstr ""

#: ../../reference/datamodel.rst:428
msgid "Lists"
msgstr ""

#: ../../reference/datamodel.rst:431
msgid ""
"The items of a list are arbitrary Python objects.  Lists are formed by "
"placing a comma-separated list of expressions in square brackets. (Note "
"that there are no special cases needed to form lists of length 0 or 1.)"
msgstr ""

#: ../../reference/datamodel.rst:435
msgid "Byte Arrays"
msgstr ""

#: ../../reference/datamodel.rst:438
msgid ""
"A bytearray object is a mutable array. They are created by the built-in "
":func:`bytearray` constructor.  Aside from being mutable (and hence "
"unhashable), byte arrays otherwise provide the same interface and "
"functionality as immutable :class:`bytes` objects."
msgstr ""

#: ../../reference/datamodel.rst:445
msgid "Set types"
msgstr ""

#: ../../reference/datamodel.rst:451
msgid ""
"These represent unordered, finite sets of unique, immutable objects. As "
"such, they cannot be indexed by any subscript. However, they can be "
"iterated over, and the built-in function :func:`len` returns the number "
"of items in a set. Common uses for sets are fast membership testing, "
"removing duplicates from a sequence, and computing mathematical "
"operations such as intersection, union, difference, and symmetric "
"difference."
msgstr ""

#: ../../reference/datamodel.rst:458
msgid ""
"For set elements, the same immutability rules apply as for dictionary "
"keys. Note that numeric types obey the normal rules for numeric "
"comparison: if two numbers compare equal (e.g., ``1`` and ``1.0``), only "
"one of them can be contained in a set."
msgstr ""

#: ../../reference/datamodel.rst:463
msgid "There are currently two intrinsic set types:"
msgstr ""

#: ../../reference/datamodel.rst:466
msgid "Sets"
msgstr ""

#: ../../reference/datamodel.rst:469
msgid ""
"These represent a mutable set. They are created by the built-in "
":func:`set` constructor and can be modified afterwards by several "
"methods, such as :meth:`~set.add`."
msgstr ""

#: ../../reference/datamodel.rst:474
msgid "Frozen sets"
msgstr ""

#: ../../reference/datamodel.rst:477
msgid ""
"These represent an immutable set.  They are created by the built-in "
":func:`frozenset` constructor.  As a frozenset is immutable and "
":term:`hashable`, it can be used again as an element of another set, or "
"as a dictionary key."
msgstr ""

#: ../../reference/datamodel.rst:486
msgid "Mappings"
msgstr ""

#: ../../reference/datamodel.rst:493
msgid ""
"These represent finite sets of objects indexed by arbitrary index sets. "
"The subscript notation ``a[k]`` selects the item indexed by ``k`` from "
"the mapping ``a``; this can be used in expressions and as the target of "
"assignments or :keyword:`del` statements. The built-in function "
":func:`len` returns the number of items in a mapping."
msgstr ""

#: ../../reference/datamodel.rst:499
msgid "There is currently a single intrinsic mapping type:"
msgstr ""

#: ../../reference/datamodel.rst:503
msgid "Dictionaries"
msgstr ""

#: ../../reference/datamodel.rst:507
msgid ""
"These represent finite sets of objects indexed by nearly arbitrary "
"values.  The only types of values not acceptable as keys are values "
"containing lists or dictionaries or other mutable types that are compared"
" by value rather than by object identity, the reason being that the "
"efficient implementation of dictionaries requires a key's hash value to "
"remain constant. Numeric types used for keys obey the normal rules for "
"numeric comparison: if two numbers compare equal (e.g., ``1`` and "
"``1.0``) then they can be used interchangeably to index the same "
"dictionary entry."
msgstr ""

#: ../../reference/datamodel.rst:516
msgid ""
"Dictionaries preserve insertion order, meaning that keys will be produced"
" in the same order they were added sequentially over the dictionary. "
"Replacing an existing key does not change the order, however removing a "
"key and re-inserting it will add it to the end instead of keeping its old"
" place."
msgstr ""

#: ../../reference/datamodel.rst:521
#, python-brace-format
msgid ""
"Dictionaries are mutable; they can be created by the ``{}`` notation (see"
" section :ref:`dict`)."
msgstr ""

#: ../../reference/datamodel.rst:528
msgid ""
"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide "
"additional examples of mapping types, as does the :mod:`collections` "
"module."
msgstr ""

#: ../../reference/datamodel.rst:532
msgid ""
"Dictionaries did not preserve insertion order in versions of Python "
"before 3.6. In CPython 3.6, insertion order was preserved, but it was "
"considered an implementation detail at that time rather than a language "
"guarantee."
msgstr ""

#: ../../reference/datamodel.rst:539
msgid "Callable types"
msgstr ""

#: ../../reference/datamodel.rst:547
msgid ""
"These are the types to which the function call operation (see section "
":ref:`calls`) can be applied:"
msgstr ""

#: ../../reference/datamodel.rst:554
msgid "User-defined functions"
msgstr ""

#: ../../reference/datamodel.rst:561
msgid ""
"A user-defined function object is created by a function definition (see "
"section :ref:`function`).  It should be called with an argument list "
"containing the same number of items as the function's formal parameter "
"list."
msgstr ""

#: ../../reference/datamodel.rst:567 ../../reference/datamodel.rst:1491
#: ../../reference/datamodel.rst:1692
msgid "Special read-only attributes"
msgstr ""

#: ../../reference/datamodel.rst:578 ../../reference/datamodel.rst:620
#: ../../reference/datamodel.rst:1223
msgid "Attribute"
msgstr ""

#: ../../reference/datamodel.rst:579 ../../reference/datamodel.rst:621
#: ../../reference/datamodel.rst:1224
msgid "Meaning"
msgstr ""

#: ../../reference/datamodel.rst:582
msgid ""
"A reference to the :class:`dictionary <dict>` that holds the function's "
"builtins namespace."
msgstr ""

#: ../../reference/datamodel.rst:588
msgid ""
"A reference to the :class:`dictionary <dict>` that holds the function's "
":ref:`global variables <naming>` -- the global namespace of the module in"
" which the function was defined."
msgstr ""

#: ../../reference/datamodel.rst:593
msgid ""
"``None`` or a :class:`tuple` of cells that contain bindings for the names"
" specified in the :attr:`~codeobject.co_freevars` attribute of the "
"function's :attr:`code object <function.__code__>`."
msgstr ""

#: ../../reference/datamodel.rst:597
msgid ""
"A cell object has the attribute ``cell_contents``. This can be used to "
"get the value of the cell, as well as set the value."
msgstr ""

#: ../../reference/datamodel.rst:601 ../../reference/datamodel.rst:1740
msgid "Special writable attributes"
msgstr ""

#: ../../reference/datamodel.rst:615
msgid "Most of these attributes check the type of the assigned value:"
msgstr ""

#: ../../reference/datamodel.rst:624
msgid "The function's documentation string, or ``None`` if unavailable."
msgstr ""

#: ../../reference/datamodel.rst:627
msgid ""
"The function's name. See also: :attr:`__name__ attributes "
"<definition.__name__>`."
msgstr ""

#: ../../reference/datamodel.rst:631
msgid ""
"The function's :term:`qualified name`. See also: :attr:`__qualname__ "
"attributes <definition.__qualname__>`."
msgstr ""

#: ../../reference/datamodel.rst:637
msgid ""
"The name of the module the function was defined in, or ``None`` if "
"unavailable."
msgstr ""

#: ../../reference/datamodel.rst:641
msgid ""
"A :class:`tuple` containing default :term:`parameter` values for those "
"parameters that have defaults, or ``None`` if no parameters have a "
"default value."
msgstr ""

#: ../../reference/datamodel.rst:646
msgid ""
"The :ref:`code object <code-objects>` representing the compiled function "
"body."
msgstr ""

#: ../../reference/datamodel.rst:650
msgid ""
"The namespace supporting arbitrary function attributes. See also: "
":attr:`__dict__ attributes <object.__dict__>`."
msgstr ""

#: ../../reference/datamodel.rst:654
msgid ""
"A :class:`dictionary <dict>` containing annotations of :term:`parameters "
"<parameter>`. The keys of the dictionary are the parameter names, and "
"``'return'`` for the return annotation, if provided. See also: "
":attr:`object.__annotations__`."
msgstr ""

#: ../../reference/datamodel.rst:660 ../../reference/datamodel.rst:1129
#: ../../reference/datamodel.rst:1281
msgid ""
"Annotations are now :ref:`lazily evaluated <lazy-evaluation>`. See "
":pep:`649`."
msgstr ""

#: ../../reference/datamodel.rst:665
msgid ""
"The :term:`annotate function` for this function, or ``None`` if the "
"function has no annotations. See :attr:`object.__annotate__`."
msgstr ""

#: ../../reference/datamodel.rst:671
msgid ""
"A :class:`dictionary <dict>` containing defaults for keyword-only "
":term:`parameters <parameter>`."
msgstr ""

#: ../../reference/datamodel.rst:675
msgid ""
"A :class:`tuple` containing the :ref:`type parameters <type-params>` of a"
" :ref:`generic function <generic-functions>`."
msgstr ""

#: ../../reference/datamodel.rst:680
msgid ""
"Function objects also support getting and setting arbitrary attributes, "
"which can be used, for example, to attach metadata to functions.  Regular"
" attribute dot-notation is used to get and set such attributes."
msgstr ""

#: ../../reference/datamodel.rst:686
msgid ""
"CPython's current implementation only supports function attributes on "
"user-defined functions. Function attributes on :ref:`built-in functions "
"<builtin-functions>` may be supported in the future."
msgstr ""

#: ../../reference/datamodel.rst:691
msgid ""
"Additional information about a function's definition can be retrieved "
"from its :ref:`code object <code-objects>` (accessible via the "
":attr:`~function.__code__` attribute)."
msgstr ""

#: ../../reference/datamodel.rst:699
msgid "Instance methods"
msgstr ""

#: ../../reference/datamodel.rst:706
msgid ""
"An instance method object combines a class, a class instance and any "
"callable object (normally a user-defined function)."
msgstr ""

#: ../../reference/datamodel.rst:716 ../../reference/datamodel.rst:1836
msgid "Special read-only attributes:"
msgstr ""

#: ../../reference/datamodel.rst:721
msgid ""
"Refers to the class instance object to which the method is :ref:`bound "
"<method-binding>`"
msgstr ""

#: ../../reference/datamodel.rst:725
msgid "Refers to the original :ref:`function object <user-defined-funcs>`"
msgstr ""

#: ../../reference/datamodel.rst:728
msgid ""
"The method's documentation (same as :attr:`method.__func__.__doc__ "
"<function.__doc__>`). A :class:`string <str>` if the original function "
"had a docstring, else ``None``."
msgstr ""

#: ../../reference/datamodel.rst:734
msgid ""
"The name of the method (same as :attr:`method.__func__.__name__ "
"<function.__name__>`)"
msgstr ""

#: ../../reference/datamodel.rst:738
msgid ""
"The name of the module the method was defined in, or ``None`` if "
"unavailable."
msgstr ""

#: ../../reference/datamodel.rst:741
msgid ""
"Methods also support accessing (but not setting) the arbitrary function "
"attributes on the underlying :ref:`function object <user-defined-funcs>`."
msgstr ""

#: ../../reference/datamodel.rst:744
msgid ""
"User-defined method objects may be created when getting an attribute of a"
" class (perhaps via an instance of that class), if that attribute is a "
"user-defined :ref:`function object <user-defined-funcs>` or a "
":class:`classmethod` object."
msgstr ""

#: ../../reference/datamodel.rst:751
msgid ""
"When an instance method object is created by retrieving a user-defined "
":ref:`function object <user-defined-funcs>` from a class via one of its "
"instances, its :attr:`~method.__self__` attribute is the instance, and "
"the method object is said to be *bound*.  The new method's "
":attr:`~method.__func__` attribute is the original function object."
msgstr ""

#: ../../reference/datamodel.rst:757
msgid ""
"When an instance method object is created by retrieving a "
":class:`classmethod` object from a class or instance, its "
":attr:`~method.__self__` attribute is the class itself, and its "
":attr:`~method.__func__` attribute is the function object underlying the "
"class method."
msgstr ""

#: ../../reference/datamodel.rst:762
msgid ""
"When an instance method object is called, the underlying function "
"(:attr:`~method.__func__`) is called, inserting the class instance "
"(:attr:`~method.__self__`) in front of the argument list.  For instance, "
"when :class:`!C` is a class which contains a definition for a function "
":meth:`!f`, and ``x`` is an instance of :class:`!C`, calling ``x.f(1)`` "
"is equivalent to calling ``C.f(x, 1)``."
msgstr ""

#: ../../reference/datamodel.rst:769
msgid ""
"When an instance method object is derived from a :class:`classmethod` "
"object, the \"class instance\" stored in :attr:`~method.__self__` will "
"actually be the class itself, so that calling either ``x.f(1)`` or "
"``C.f(1)`` is equivalent to calling ``f(C,1)`` where ``f`` is the "
"underlying function."
msgstr ""

#: ../../reference/datamodel.rst:774
msgid ""
"It is important to note that user-defined functions which are attributes "
"of a class instance are not converted to bound methods; this *only* "
"happens when the function is an attribute of the class."
msgstr ""

#: ../../reference/datamodel.rst:781
msgid "Generator functions"
msgstr ""

#: ../../reference/datamodel.rst:787
msgid ""
"A function or method which uses the :keyword:`yield` statement (see "
"section :ref:`yield`) is called a :dfn:`generator function`.  Such a "
"function, when called, always returns an :term:`iterator` object which "
"can be used to execute the body of the function:  calling the iterator's "
":meth:`iterator.__next__` method will cause the function to execute until"
" it provides a value using the :keyword:`!yield` statement.  When the "
"function executes a :keyword:`return` statement or falls off the end, a "
":exc:`StopIteration` exception is raised and the iterator will have "
"reached the end of the set of values to be returned."
msgstr ""

#: ../../reference/datamodel.rst:799
msgid "Coroutine functions"
msgstr ""

#: ../../reference/datamodel.rst:804
msgid ""
"A function or method which is defined using :keyword:`async def` is "
"called a :dfn:`coroutine function`.  Such a function, when called, "
"returns a :term:`coroutine` object.  It may contain :keyword:`await` "
"expressions, as well as :keyword:`async with` and :keyword:`async for` "
"statements. See also the :ref:`coroutine-objects` section."
msgstr ""

#: ../../reference/datamodel.rst:812
msgid "Asynchronous generator functions"
msgstr ""

#: ../../reference/datamodel.rst:818
msgid ""
"A function or method which is defined using :keyword:`async def` and "
"which uses the :keyword:`yield` statement is called a :dfn:`asynchronous "
"generator function`.  Such a function, when called, returns an "
":term:`asynchronous iterator` object which can be used in an "
":keyword:`async for` statement to execute the body of the function."
msgstr ""

#: ../../reference/datamodel.rst:824
msgid ""
"Calling the asynchronous iterator's :meth:`aiterator.__anext__ "
"<object.__anext__>` method will return an :term:`awaitable` which when "
"awaited will execute until it provides a value using the :keyword:`yield`"
" expression.  When the function executes an empty :keyword:`return` "
"statement or falls off the end, a :exc:`StopAsyncIteration` exception is "
"raised and the asynchronous iterator will have reached the end of the set"
" of values to be yielded."
msgstr ""

#: ../../reference/datamodel.rst:837
msgid "Built-in functions"
msgstr ""

#: ../../reference/datamodel.rst:844
msgid ""
"A built-in function object is a wrapper around a C function.  Examples of"
" built-in functions are :func:`len` and :func:`math.sin` (:mod:`math` is "
"a standard built-in module). The number and type of the arguments are "
"determined by the C function. Special read-only attributes:"
msgstr ""

#: ../../reference/datamodel.rst:849
msgid ""
":attr:`!__doc__` is the function's documentation string, or ``None`` if "
"unavailable. See :attr:`function.__doc__`."
msgstr ""

#: ../../reference/datamodel.rst:851
msgid ":attr:`!__name__` is the function's name. See :attr:`function.__name__`."
msgstr ""

#: ../../reference/datamodel.rst:852
msgid ":attr:`!__self__` is set to ``None`` (but see the next item)."
msgstr ""

#: ../../reference/datamodel.rst:853
msgid ""
":attr:`!__module__` is the name of the module the function was defined in"
" or ``None`` if unavailable. See :attr:`function.__module__`."
msgstr ""

#: ../../reference/datamodel.rst:861
msgid "Built-in methods"
msgstr ""

#: ../../reference/datamodel.rst:868
msgid ""
"This is really a different disguise of a built-in function, this time "
"containing an object passed to the C function as an implicit extra "
"argument.  An example of a built-in method is ``alist.append()``, "
"assuming *alist* is a list object. In this case, the special read-only "
"attribute :attr:`!__self__` is set to the object denoted by *alist*. (The"
" attribute has the same semantics as it does with :attr:`other instance "
"methods <method.__self__>`.)"
msgstr ""

#: ../../reference/datamodel.rst:878
msgid "Classes"
msgstr ""

#: ../../reference/datamodel.rst:880
msgid ""
"Classes are callable.  These objects normally act as factories for new "
"instances of themselves, but variations are possible for class types that"
" override :meth:`~object.__new__`.  The arguments of the call are passed "
"to :meth:`!__new__` and, in the typical case, to :meth:`~object.__init__`"
" to initialize the new instance."
msgstr ""

#: ../../reference/datamodel.rst:888
msgid "Class Instances"
msgstr ""

#: ../../reference/datamodel.rst:890
msgid ""
"Instances of arbitrary classes can be made callable by defining a "
":meth:`~object.__call__` method in their class."
msgstr ""

#: ../../reference/datamodel.rst:897
msgid "Modules"
msgstr ""

#: ../../reference/datamodel.rst:903
msgid ""
"Modules are a basic organizational unit of Python code, and are created "
"by the :ref:`import system <importsystem>` as invoked either by the "
":keyword:`import` statement, or by calling functions such as "
":func:`importlib.import_module` and built-in :func:`__import__`.  A "
"module object has a namespace implemented by a :class:`dictionary <dict>`"
" object (this is the dictionary referenced by the "
":attr:`~function.__globals__` attribute of functions defined in the "
"module).  Attribute references are translated to lookups in this "
"dictionary, e.g., ``m.x`` is equivalent to ``m.__dict__[\"x\"]``. A "
"module object does not contain the code object used to initialize the "
"module (since it isn't needed once the initialization is done)."
msgstr ""

#: ../../reference/datamodel.rst:916
msgid ""
"Attribute assignment updates the module's namespace dictionary, e.g., "
"``m.x = 1`` is equivalent to ``m.__dict__[\"x\"] = 1``."
msgstr ""

#: ../../reference/datamodel.rst:935
msgid "Import-related attributes on module objects"
msgstr ""

#: ../../reference/datamodel.rst:937
msgid ""
"Module objects have the following attributes that relate to the "
":ref:`import system <importsystem>`. When a module is created using the "
"machinery associated with the import system, these attributes are filled "
"in based on the module's :term:`spec <module spec>`, before the "
":term:`loader` executes and loads the module."
msgstr ""

#: ../../reference/datamodel.rst:943
msgid ""
"To create a module dynamically rather than using the import system, it's "
"recommended to use :func:`importlib.util.module_from_spec`, which will "
"set the various import-controlled attributes to appropriate values. It's "
"also possible to use the :class:`types.ModuleType` constructor to create "
"modules directly, but this technique is more error-prone, as most "
"attributes must be manually set on the module object after it has been "
"created when using this approach."
msgstr ""

#: ../../reference/datamodel.rst:953
msgid ""
"With the exception of :attr:`~module.__name__`, it is **strongly** "
"recommended that you rely on :attr:`~module.__spec__` and its attributes "
"instead of any of the other individual attributes listed in this "
"subsection. Note that updating an attribute on :attr:`!__spec__` will not"
" update the corresponding attribute on the module itself:"
msgstr ""

#: ../../reference/datamodel.rst:959
msgid ""
">>> import typing\n"
">>> typing.__name__, typing.__spec__.name\n"
"('typing', 'typing')\n"
">>> typing.__spec__.name = 'spelling'\n"
">>> typing.__name__, typing.__spec__.name\n"
"('typing', 'spelling')\n"
">>> typing.__name__ = 'keyboard_smashing'\n"
">>> typing.__name__, typing.__spec__.name\n"
"('keyboard_smashing', 'spelling')"
msgstr ""

#: ../../reference/datamodel.rst:973
msgid ""
"The name used to uniquely identify the module in the import system. For a"
" directly executed module, this will be set to ``\"__main__\"``."
msgstr ""

#: ../../reference/datamodel.rst:976
msgid ""
"This attribute must be set to the fully qualified name of the module. It "
"is expected to match the value of :attr:`module.__spec__.name "
"<importlib.machinery.ModuleSpec.name>`."
msgstr ""

#: ../../reference/datamodel.rst:982
msgid "A record of the module's import-system-related state."
msgstr ""

#: ../../reference/datamodel.rst:984
msgid ""
"Set to the :class:`module spec <importlib.machinery.ModuleSpec>` that was"
" used when importing the module. See :ref:`module-specs` for more "
"details."
msgstr ""

#: ../../reference/datamodel.rst:991
msgid "The :term:`package` a module belongs to."
msgstr ""

#: ../../reference/datamodel.rst:993
msgid ""
"If the module is top-level (that is, not a part of any specific package) "
"then the attribute should be set to ``''`` (the empty string). Otherwise,"
" it should be set to the name of the module's package (which can be equal"
" to :attr:`module.__name__` if the module itself is a package). See "
":pep:`366` for further details."
msgstr ""

#: ../../reference/datamodel.rst:999
msgid ""
"This attribute is used instead of :attr:`~module.__name__` to calculate "
"explicit relative imports for main modules. It defaults to ``None`` for "
"modules created dynamically using the :class:`types.ModuleType` "
"constructor; use :func:`importlib.util.module_from_spec` instead to "
"ensure the attribute is set to a :class:`str`."
msgstr ""

#: ../../reference/datamodel.rst:1005
msgid ""
"It is **strongly** recommended that you use :attr:`module.__spec__.parent"
" <importlib.machinery.ModuleSpec.parent>` instead of "
":attr:`!module.__package__`. :attr:`__package__` is now only used as a "
"fallback if :attr:`!__spec__.parent` is not set, and this fallback path "
"is deprecated."
msgstr ""

#: ../../reference/datamodel.rst:1011 ../../reference/datamodel.rst:1052
msgid ""
"This attribute now defaults to ``None`` for modules created dynamically "
"using the :class:`types.ModuleType` constructor. Previously the attribute"
" was optional."
msgstr ""

#: ../../reference/datamodel.rst:1016
msgid ""
"The value of :attr:`!__package__` is expected to be the same as "
":attr:`__spec__.parent <importlib.machinery.ModuleSpec.parent>`. "
":attr:`__package__` is now only used as a fallback during import "
"resolution if :attr:`!__spec__.parent` is not defined."
msgstr ""

#: ../../reference/datamodel.rst:1022
msgid ""
":exc:`ImportWarning` is raised if an import resolution falls back to "
":attr:`!__package__` instead of :attr:`__spec__.parent "
"<importlib.machinery.ModuleSpec.parent>`."
msgstr ""

#: ../../reference/datamodel.rst:1027
msgid ""
"Raise :exc:`DeprecationWarning` instead of :exc:`ImportWarning` when "
"falling back to :attr:`!__package__` during import resolution."
msgstr ""

#: ../../reference/datamodel.rst:1031
msgid ""
":attr:`!__package__` will cease to be set or taken into consideration by "
"the import system or standard library."
msgstr ""

#: ../../reference/datamodel.rst:1037
msgid ""
"The :term:`loader` object that the import machinery used to load the "
"module."
msgstr ""

#: ../../reference/datamodel.rst:1039
msgid ""
"This attribute is mostly useful for introspection, but can be used for "
"additional loader-specific functionality, for example getting data "
"associated with a loader."
msgstr ""

#: ../../reference/datamodel.rst:1043
msgid ""
":attr:`!__loader__` defaults to ``None`` for modules created dynamically "
"using the :class:`types.ModuleType` constructor; use "
":func:`importlib.util.module_from_spec` instead to ensure the attribute "
"is set to a :term:`loader` object."
msgstr ""

#: ../../reference/datamodel.rst:1048
msgid ""
"It is **strongly** recommended that you use :attr:`module.__spec__.loader"
" <importlib.machinery.ModuleSpec.loader>` instead of "
":attr:`!module.__loader__`."
msgstr ""

#: ../../reference/datamodel.rst:1057
msgid ""
"Setting :attr:`!__loader__` on a module while failing to set "
":attr:`!__spec__.loader` is deprecated. In Python 3.16, "
":attr:`!__loader__` will cease to be set or taken into consideration by "
"the import system or the standard library."
msgstr ""

#: ../../reference/datamodel.rst:1065
msgid ""
"A (possibly empty) :term:`sequence` of strings enumerating the locations "
"where the package's submodules will be found. Non-package modules should "
"not have a :attr:`!__path__` attribute. See :ref:`package-path-rules` for"
" more details."
msgstr ""

#: ../../reference/datamodel.rst:1070
msgid ""
"It is **strongly** recommended that you use "
":attr:`module.__spec__.submodule_search_locations "
"<importlib.machinery.ModuleSpec.submodule_search_locations>` instead of "
":attr:`!module.__path__`."
msgstr ""

#: ../../reference/datamodel.rst:1077
msgid ""
":attr:`!__file__` and :attr:`!__cached__` are both optional attributes "
"that may or may not be set. Both attributes should be a :class:`str` when"
" they are available."
msgstr ""

#: ../../reference/datamodel.rst:1081
msgid ""
":attr:`!__file__` indicates the pathname of the file from which the "
"module was loaded (if loaded from a file), or the pathname of the shared "
"library file for extension modules loaded dynamically from a shared "
"library. It might be missing for certain types of modules, such as C "
"modules that are statically linked into the interpreter, and the "
":ref:`import system <importsystem>` may opt to leave it unset if it has "
"no semantic meaning (for example, a module loaded from a database)."
msgstr ""

#: ../../reference/datamodel.rst:1089
msgid ""
"If :attr:`!__file__` is set then the :attr:`!__cached__` attribute might "
"also be set,  which is the path to any compiled version of the code (for "
"example, a byte-compiled file). The file does not need to exist to set "
"this attribute; the path can simply point to where the compiled file "
"*would* exist (see :pep:`3147`)."
msgstr ""

#: ../../reference/datamodel.rst:1095
msgid ""
"Note that :attr:`!__cached__` may be set even if :attr:`!__file__` is not"
" set.  However, that scenario is quite atypical.  Ultimately, the "
":term:`loader` is what makes use of the module spec provided by the "
":term:`finder` (from which :attr:`!__file__` and :attr:`!__cached__` are "
"derived).  So if a loader can load from a cached module but otherwise "
"does not load from a file, that atypical scenario may be appropriate."
msgstr ""

#: ../../reference/datamodel.rst:1102
msgid ""
"It is **strongly** recommended that you use :attr:`module.__spec__.cached"
" <importlib.machinery.ModuleSpec.cached>` instead of "
":attr:`!module.__cached__`."
msgstr ""

#: ../../reference/datamodel.rst:1106
msgid ""
"Setting :attr:`!__cached__` on a module while failing to set "
":attr:`!__spec__.cached` is deprecated. In Python 3.15, "
":attr:`!__cached__` will cease to be set or taken into consideration by "
"the import system or standard library."
msgstr ""

#: ../../reference/datamodel.rst:1113
msgid "Other writable attributes on module objects"
msgstr ""

#: ../../reference/datamodel.rst:1115
msgid ""
"As well as the import-related attributes listed above, module objects "
"also have the following writable attributes:"
msgstr ""

#: ../../reference/datamodel.rst:1120
msgid ""
"The module's documentation string, or ``None`` if unavailable. See also: "
":attr:`__doc__ attributes <definition.__doc__>`."
msgstr ""

#: ../../reference/datamodel.rst:1125
msgid ""
"A dictionary containing :term:`variable annotations <variable "
"annotation>` collected during module body execution.  For best practices "
"on working with :attr:`!__annotations__`, see :mod:`annotationlib`."
msgstr ""

#: ../../reference/datamodel.rst:1135
msgid ""
"The :term:`annotate function` for this module, or ``None`` if the module "
"has no annotations. See also: :attr:`~object.__annotate__` attributes."
msgstr ""

#: ../../reference/datamodel.rst:1141
msgid "Module dictionaries"
msgstr ""

#: ../../reference/datamodel.rst:1143
msgid "Module objects also have the following special read-only attribute:"
msgstr ""

#: ../../reference/datamodel.rst:1148
msgid ""
"The module's namespace as a dictionary object. Uniquely among the "
"attributes listed here, :attr:`!__dict__` cannot be accessed as a global "
"variable from within a module; it can only be accessed as an attribute on"
" module objects."
msgstr ""

#: ../../reference/datamodel.rst:1154
msgid ""
"Because of the way CPython clears module dictionaries, the module "
"dictionary will be cleared when the module falls out of scope even if the"
" dictionary still has live references.  To avoid this, copy the "
"dictionary or keep the module around while using its dictionary directly."
msgstr ""

#: ../../reference/datamodel.rst:1163
msgid "Custom classes"
msgstr ""

#: ../../reference/datamodel.rst:1165
msgid ""
"Custom class types are typically created by class definitions (see "
"section :ref:`class`).  A class has a namespace implemented by a "
"dictionary object. Class attribute references are translated to lookups "
"in this dictionary, e.g., ``C.x`` is translated to ``C.__dict__[\"x\"]`` "
"(although there are a number of hooks which allow for other means of "
"locating attributes). When the attribute name is not found there, the "
"attribute search continues in the base classes. This search of the base "
"classes uses the C3 method resolution order which behaves correctly even "
"in the presence of 'diamond' inheritance structures where there are "
"multiple inheritance paths leading back to a common ancestor. Additional "
"details on the C3 MRO used by Python can be found at "
":ref:`python_2.3_mro`."
msgstr ""

#: ../../reference/datamodel.rst:1186
msgid ""
"When a class attribute reference (for class :class:`!C`, say) would yield"
" a class method object, it is transformed into an instance method object "
"whose :attr:`~method.__self__` attribute is :class:`!C`. When it would "
"yield a :class:`staticmethod` object, it is transformed into the object "
"wrapped by the static method object. See section :ref:`descriptors` for "
"another way in which attributes retrieved from a class may differ from "
"those actually contained in its :attr:`~object.__dict__`."
msgstr ""

#: ../../reference/datamodel.rst:1197
msgid ""
"Class attribute assignments update the class's dictionary, never the "
"dictionary of a base class."
msgstr ""

#: ../../reference/datamodel.rst:1202
msgid ""
"A class object can be called (see above) to yield a class instance (see "
"below)."
msgstr ""

#: ../../reference/datamodel.rst:1205 ../../reference/datamodel.rst:1381
msgid "Special attributes"
msgstr ""

#: ../../reference/datamodel.rst:1227
msgid ""
"The class's name. See also: :attr:`__name__ attributes "
"<definition.__name__>`."
msgstr ""

#: ../../reference/datamodel.rst:1231
msgid ""
"The class's :term:`qualified name`. See also: :attr:`__qualname__ "
"attributes <definition.__qualname__>`."
msgstr ""

#: ../../reference/datamodel.rst:1235
msgid "The name of the module in which the class was defined."
msgstr ""

#: ../../reference/datamodel.rst:1238
msgid ""
"A :class:`mapping proxy <types.MappingProxyType>` providing a read-only "
"view of the class's namespace. See also: :attr:`__dict__ attributes "
"<object.__dict__>`."
msgstr ""

#: ../../reference/datamodel.rst:1243
msgid ""
"A :class:`tuple` containing the class's bases. In most cases, for a class"
" defined as ``class X(A, B, C)``, ``X.__bases__`` will be exactly equal "
"to ``(A, B, C)``."
msgstr ""

#: ../../reference/datamodel.rst:1250
msgid ""
"The single base class in the inheritance chain that is responsible for "
"the memory layout of instances. This attribute corresponds to "
":c:member:`~PyTypeObject.tp_base` at the C level."
msgstr ""

#: ../../reference/datamodel.rst:1255
msgid ""
"The class's documentation string, or ``None`` if undefined. Not inherited"
" by subclasses."
msgstr ""

#: ../../reference/datamodel.rst:1259
msgid ""
"A dictionary containing :term:`variable annotations <variable "
"annotation>` collected during class body execution. See also: "
":attr:`__annotations__ attributes <object.__annotations__>`."
msgstr ""

#: ../../reference/datamodel.rst:1264
msgid ""
"For best practices on working with :attr:`~object.__annotations__`, "
"please see :mod:`annotationlib`. Use "
":func:`annotationlib.get_annotations` instead of accessing this attribute"
" directly."
msgstr ""

#: ../../reference/datamodel.rst:1271
msgid ""
"Accessing the :attr:`!__annotations__` attribute directly on a class "
"object may return annotations for the wrong class, specifically in "
"certain cases where the class, its base class, or a metaclass is defined "
"under ``from __future__ import annotations``. See :pep:`749 "
"<749#pep749-metaclasses>` for details."
msgstr ""

#: ../../reference/datamodel.rst:1277
msgid ""
"This attribute does not exist on certain builtin classes. On user-defined"
" classes without ``__annotations__``, it is an empty dictionary."
msgstr ""

#: ../../reference/datamodel.rst:1286
msgid ""
"The :term:`annotate function` for this class, or ``None`` if the class "
"has no annotations. See also: :attr:`__annotate__ attributes "
"<object.__annotate__>`."
msgstr ""

#: ../../reference/datamodel.rst:1293
msgid ""
"A :class:`tuple` containing the :ref:`type parameters <type-params>` of a"
" :ref:`generic class <generic-classes>`."
msgstr ""

#: ../../reference/datamodel.rst:1299
msgid ""
"A :class:`tuple` containing names of attributes of this class which are "
"assigned through ``self.X`` from any function in its body."
msgstr ""

#: ../../reference/datamodel.rst:1305
msgid ""
"The line number of the first line of the class definition, including "
"decorators. Setting the :attr:`~type.__module__` attribute removes the "
":attr:`!__firstlineno__` item from the type's dictionary."
msgstr ""

#: ../../reference/datamodel.rst:1313
msgid ""
"The :class:`tuple` of classes that are considered when looking for base "
"classes during method resolution."
msgstr ""

#: ../../reference/datamodel.rst:1318
msgid "Special methods"
msgstr ""

#: ../../reference/datamodel.rst:1320
msgid ""
"In addition to the special attributes described above, all Python classes"
" also have the following two methods available:"
msgstr ""

#: ../../reference/datamodel.rst:1325
msgid ""
"This method can be overridden by a metaclass to customize the method "
"resolution order for its instances.  It is called at class instantiation,"
" and its result is stored in :attr:`~type.__mro__`."
msgstr ""

#: ../../reference/datamodel.rst:1331
msgid ""
"Each class keeps a list of weak references to its immediate subclasses. "
"This method returns a list of all those references still alive. The list "
"is in definition order. Example:"
msgstr ""

#: ../../reference/datamodel.rst:1335
msgid ""
">>> class A: pass\n"
">>> class B(A): pass\n"
">>> A.__subclasses__()\n"
"[<class 'B'>]"
msgstr ""

#: ../../reference/datamodel.rst:1343
msgid "Class instances"
msgstr ""

#: ../../reference/datamodel.rst:1351
msgid ""
"A class instance is created by calling a class object (see above).  A "
"class instance has a namespace implemented as a dictionary which is the "
"first place in which attribute references are searched.  When an "
"attribute is not found there, and the instance's class has an attribute "
"by that name, the search continues with the class attributes.  If a class"
" attribute is found that is a user-defined function object, it is "
"transformed into an instance method object whose :attr:`~method.__self__`"
" attribute is the instance.  Static method and class method objects are "
"also transformed; see above under \"Classes\".  See section "
":ref:`descriptors` for another way in which attributes of a class "
"retrieved via its instances may differ from the objects actually stored "
"in the class's :attr:`~object.__dict__`.  If no class attribute is found,"
" and the object's class has a :meth:`~object.__getattr__` method, that is"
" called to satisfy the lookup."
msgstr ""

#: ../../reference/datamodel.rst:1367
msgid ""
"Attribute assignments and deletions update the instance's dictionary, "
"never a class's dictionary.  If the class has a "
":meth:`~object.__setattr__` or :meth:`~object.__delattr__` method, this "
"is called instead of updating the instance dictionary directly."
msgstr ""

#: ../../reference/datamodel.rst:1377
msgid ""
"Class instances can pretend to be numbers, sequences, or mappings if they"
" have methods with certain special names.  See section "
":ref:`specialnames`."
msgstr ""

#: ../../reference/datamodel.rst:1389
msgid "The class to which a class instance belongs."
msgstr ""

#: ../../reference/datamodel.rst:1393
msgid ""
"A dictionary or other mapping object used to store an object's (writable)"
" attributes. Not all instances have a :attr:`!__dict__` attribute; see "
"the section on :ref:`slots` for more details."
msgstr ""

#: ../../reference/datamodel.rst:1399
msgid "I/O objects (also known as file objects)"
msgstr ""

#: ../../reference/datamodel.rst:1414
msgid ""
"A :term:`file object` represents an open file.  Various shortcuts are "
"available to create file objects: the :func:`open` built-in function, and"
" also :func:`os.popen`, :func:`os.fdopen`, and the "
":meth:`~socket.socket.makefile` method of socket objects (and perhaps by "
"other functions or methods provided by extension modules)."
msgstr ""

#: ../../reference/datamodel.rst:1420
msgid ""
"File objects implement common methods, listed below, to simplify usage in"
" generic code. They are expected to be :ref:`context-managers`."
msgstr ""

#: ../../reference/datamodel.rst:1423
msgid ""
"The objects ``sys.stdin``, ``sys.stdout`` and ``sys.stderr`` are "
"initialized to file objects corresponding to the interpreter's standard "
"input, output and error streams; they are all open in text mode and "
"therefore follow the interface defined by the :class:`io.TextIOBase` "
"abstract class."
msgstr ""

#: ../../reference/datamodel.rst:1431
msgid ""
"Retrieve up to *size* data from the file. As a convenience if *size* is "
"unspecified or -1 retrieve all data available."
msgstr ""

#: ../../reference/datamodel.rst:1436
msgid "Store *data* to the file."
msgstr ""

#: ../../reference/datamodel.rst:1440
msgid "Flush any buffers and close the underlying file."
msgstr ""

#: ../../reference/datamodel.rst:1444
msgid "Internal types"
msgstr ""

#: ../../reference/datamodel.rst:1450
msgid ""
"A few types used internally by the interpreter are exposed to the user. "
"Their definitions may change with future versions of the interpreter, but"
" they are mentioned here for completeness."
msgstr ""

#: ../../reference/datamodel.rst:1458
msgid "Code objects"
msgstr ""

#: ../../reference/datamodel.rst:1462
msgid ""
"Code objects represent *byte-compiled* executable Python code, or "
":term:`bytecode`. The difference between a code object and a function "
"object is that the function object contains an explicit reference to the "
"function's globals (the module in which it was defined), while a code "
"object contains no context; also the default argument values are stored "
"in the function object, not in the code object (because they represent "
"values calculated at run-time).  Unlike function objects, code objects "
"are immutable and contain no references (directly or indirectly) to "
"mutable objects."
msgstr ""

#: ../../reference/datamodel.rst:1496
msgid "The function name"
msgstr ""

#: ../../reference/datamodel.rst:1499
msgid "The fully qualified function name"
msgstr ""

#: ../../reference/datamodel.rst:1504
msgid ""
"The total number of positional :term:`parameters <parameter>` (including "
"positional-only parameters and parameters with default values) that the "
"function has"
msgstr ""

#: ../../reference/datamodel.rst:1509
msgid ""
"The number of positional-only :term:`parameters <parameter>` (including "
"arguments with default values) that the function has"
msgstr ""

#: ../../reference/datamodel.rst:1513
msgid ""
"The number of keyword-only :term:`parameters <parameter>` (including "
"arguments with default values) that the function has"
msgstr ""

#: ../../reference/datamodel.rst:1517
msgid ""
"The number of :ref:`local variables <naming>` used by the function "
"(including parameters)"
msgstr ""

#: ../../reference/datamodel.rst:1521
msgid ""
"A :class:`tuple` containing the names of the local variables in the "
"function (starting with the parameter names)"
msgstr ""

#: ../../reference/datamodel.rst:1525
msgid ""
"A :class:`tuple` containing the names of :ref:`local variables <naming>` "
"that are referenced from at least one :term:`nested scope` inside the "
"function"
msgstr ""

#: ../../reference/datamodel.rst:1529
msgid ""
"A :class:`tuple` containing the names of :term:`free (closure) variables "
"<closure variable>` that a :term:`nested scope` references in an outer "
"scope. See also :attr:`function.__closure__`."
msgstr ""

#: ../../reference/datamodel.rst:1533
msgid "Note: references to global and builtin names are *not* included."
msgstr ""

#: ../../reference/datamodel.rst:1536
msgid ""
"A string representing the sequence of :term:`bytecode` instructions in "
"the function"
msgstr ""

#: ../../reference/datamodel.rst:1540
msgid ""
"A :class:`tuple` containing the literals used by the :term:`bytecode` in "
"the function"
msgstr ""

#: ../../reference/datamodel.rst:1544
msgid ""
"A :class:`tuple` containing the names used by the :term:`bytecode` in the"
" function"
msgstr ""

#: ../../reference/datamodel.rst:1548
msgid "The name of the file from which the code was compiled"
msgstr ""

#: ../../reference/datamodel.rst:1551
msgid "The line number of the first line of the function"
msgstr ""

#: ../../reference/datamodel.rst:1554
msgid ""
"A string encoding the mapping from :term:`bytecode` offsets to line "
"numbers. For details, see the source code of the interpreter."
msgstr ""

#: ../../reference/datamodel.rst:1557
msgid ""
"This attribute of code objects is deprecated, and may be removed in "
"Python 3.15."
msgstr ""

#: ../../reference/datamodel.rst:1562
msgid "The required stack size of the code object"
msgstr ""

#: ../../reference/datamodel.rst:1565
msgid "An :class:`integer <int>` encoding a number of flags for the interpreter."
msgstr ""

#: ../../reference/datamodel.rst:1570
msgid ""
"The following flag bits are defined for :attr:`~codeobject.co_flags`: bit"
" ``0x04`` is set if the function uses the ``*arguments`` syntax to accept"
" an arbitrary number of positional arguments; bit ``0x08`` is set if the "
"function uses the ``**keywords`` syntax to accept arbitrary keyword "
"arguments; bit ``0x20`` is set if the function is a generator. See :ref"
":`inspect-module-co-flags` for details on the semantics of each flags "
"that might be present."
msgstr ""

#: ../../reference/datamodel.rst:1578
msgid ""
"Future feature declarations (for example, ``from __future__ import "
"division``) also use bits in :attr:`~codeobject.co_flags` to indicate "
"whether a code object was compiled with a particular feature enabled. See"
" :attr:`~__future__._Feature.compiler_flag`."
msgstr ""

#: ../../reference/datamodel.rst:1582
msgid "Other bits in :attr:`~codeobject.co_flags` are reserved for internal use."
msgstr ""

#: ../../reference/datamodel.rst:1586
msgid ""
"If a code object represents a function and has a docstring, the "
":data:`~inspect.CO_HAS_DOCSTRING` bit is set in "
":attr:`~codeobject.co_flags` and the first item in "
":attr:`~codeobject.co_consts` is the docstring of the function."
msgstr ""

#: ../../reference/datamodel.rst:1592
msgid "Methods on code objects"
msgstr ""

#: ../../reference/datamodel.rst:1596
msgid ""
"Returns an iterable over the source code positions of each "
":term:`bytecode` instruction in the code object."
msgstr ""

#: ../../reference/datamodel.rst:1599
msgid ""
"The iterator returns :class:`tuple`\\s containing the ``(start_line, "
"end_line, start_column, end_column)``. The *i-th* tuple corresponds to "
"the position of the source code that compiled to the *i-th* code unit. "
"Column information is 0-indexed utf-8 byte offsets on the given source "
"line."
msgstr ""

#: ../../reference/datamodel.rst:1605
msgid ""
"This positional information can be missing. A non-exhaustive lists of "
"cases where this may happen:"
msgstr ""

#: ../../reference/datamodel.rst:1608
msgid "Running the interpreter with :option:`-X` ``no_debug_ranges``."
msgstr ""

#: ../../reference/datamodel.rst:1609
msgid "Loading a pyc file compiled while using :option:`-X` ``no_debug_ranges``."
msgstr ""

#: ../../reference/datamodel.rst:1610
msgid "Position tuples corresponding to artificial instructions."
msgstr ""

#: ../../reference/datamodel.rst:1611
msgid ""
"Line and column numbers that can't be represented due to implementation "
"specific limitations."
msgstr ""

#: ../../reference/datamodel.rst:1614
msgid "When this occurs, some or all of the tuple elements can be :const:`None`."
msgstr ""

#: ../../reference/datamodel.rst:1620
msgid ""
"This feature requires storing column positions in code objects which may "
"result in a small increase of disk usage of compiled Python files or "
"interpreter memory usage. To avoid storing the extra information and/or "
"deactivate printing the extra traceback information, the :option:`-X` "
"``no_debug_ranges`` command line flag or the "
":envvar:`PYTHONNODEBUGRANGES` environment variable can be used."
msgstr ""

#: ../../reference/datamodel.rst:1629
msgid ""
"Returns an iterator that yields information about successive ranges of "
":term:`bytecode`\\s. Each item yielded is a ``(start, end, lineno)`` "
":class:`tuple`:"
msgstr ""

#: ../../reference/datamodel.rst:1633
msgid ""
"``start`` (an :class:`int`) represents the offset (inclusive) of the "
"start of the :term:`bytecode` range"
msgstr ""

#: ../../reference/datamodel.rst:1635
msgid ""
"``end`` (an :class:`int`) represents the offset (exclusive) of the end of"
" the :term:`bytecode` range"
msgstr ""

#: ../../reference/datamodel.rst:1637
msgid ""
"``lineno`` is an :class:`int` representing the line number of the "
":term:`bytecode` range, or ``None`` if the bytecodes in the given range "
"have no line number"
msgstr ""

#: ../../reference/datamodel.rst:1641
msgid "The items yielded will have the following properties:"
msgstr ""

#: ../../reference/datamodel.rst:1643
msgid "The first range yielded will have a ``start`` of 0."
msgstr ""

#: ../../reference/datamodel.rst:1644
msgid ""
"The ``(start, end)`` ranges will be non-decreasing and consecutive. That "
"is, for any pair of :class:`tuple`\\s, the ``start`` of the second will "
"be equal to the ``end`` of the first."
msgstr ""

#: ../../reference/datamodel.rst:1647
msgid "No range will be backwards: ``end >= start`` for all triples."
msgstr ""

#: ../../reference/datamodel.rst:1648
msgid ""
"The last :class:`tuple` yielded will have ``end`` equal to the size of "
"the :term:`bytecode`."
msgstr ""

#: ../../reference/datamodel.rst:1651
msgid ""
"Zero-width ranges, where ``start == end``, are allowed. Zero-width ranges"
" are used for lines that are present in the source code, but have been "
"eliminated by the :term:`bytecode` compiler."
msgstr ""

#: ../../reference/datamodel.rst:1659
msgid ":pep:`626` - Precise line numbers for debugging and other tools."
msgstr ""

#: ../../reference/datamodel.rst:1660
msgid "The PEP that introduced the :meth:`!co_lines` method."
msgstr ""

#: ../../reference/datamodel.rst:1664
msgid "Return a copy of the code object with new values for the specified fields."
msgstr ""

#: ../../reference/datamodel.rst:1666
msgid ""
"Code objects are also supported by the generic function "
":func:`copy.replace`."
msgstr ""

#: ../../reference/datamodel.rst:1674
msgid "Frame objects"
msgstr ""

#: ../../reference/datamodel.rst:1678
msgid ""
"Frame objects represent execution frames.  They may occur in "
":ref:`traceback objects <traceback-objects>`, and are also passed to "
"registered trace functions."
msgstr ""

#: ../../reference/datamodel.rst:1697
msgid ""
"Points to the previous stack frame (towards the caller), or ``None`` if "
"this is the bottom stack frame"
msgstr ""

#: ../../reference/datamodel.rst:1701
msgid ""
"The :ref:`code object <code-objects>` being executed in this frame. "
"Accessing this attribute raises an :ref:`auditing event <auditing>` "
"``object.__getattr__`` with arguments ``obj`` and ``\"f_code\"``."
msgstr ""

#: ../../reference/datamodel.rst:1706
msgid ""
"The mapping used by the frame to look up :ref:`local variables <naming>`."
" If the frame refers to an :term:`optimized scope`, this may return a "
"write-through proxy object."
msgstr ""

#: ../../reference/datamodel.rst:1711
msgid "Return a proxy for optimized scopes."
msgstr ""

#: ../../reference/datamodel.rst:1715
msgid ""
"The dictionary used by the frame to look up :ref:`global variables "
"<naming>`"
msgstr ""

#: ../../reference/datamodel.rst:1719
msgid ""
"The dictionary used by the frame to look up :ref:`built-in (intrinsic) "
"names <naming>`"
msgstr ""

#: ../../reference/datamodel.rst:1723
msgid ""
"The \"precise instruction\" of the frame object (this is an index into "
"the :term:`bytecode` string of the :ref:`code object <code-objects>`)"
msgstr ""

#: ../../reference/datamodel.rst:1728
msgid ""
"The :term:`generator` or :term:`coroutine` object that owns this frame, "
"or ``None`` if the frame is a normal function."
msgstr ""

#: ../../reference/datamodel.rst:1745
msgid ""
"If not ``None``, this is a function called for various events during code"
" execution (this is used by debuggers). Normally an event is triggered "
"for each new source line (see :attr:`~frame.f_trace_lines`)."
msgstr ""

#: ../../reference/datamodel.rst:1750
msgid ""
"Set this attribute to :const:`False` to disable triggering a tracing "
"event for each source line."
msgstr ""

#: ../../reference/datamodel.rst:1754
msgid ""
"Set this attribute to :const:`True` to allow per-opcode events to be "
"requested. Note that this may lead to undefined interpreter behaviour if "
"exceptions raised by the trace function escape to the function being "
"traced."
msgstr ""

#: ../../reference/datamodel.rst:1760
msgid ""
"The current line number of the frame -- writing to this from within a "
"trace function jumps to the given line (only for the bottom-most frame)."
"  A debugger can implement a Jump command (aka Set Next Statement) by "
"writing to this attribute."
msgstr ""

#: ../../reference/datamodel.rst:1766
msgid "Frame object methods"
msgstr ""

#: ../../reference/datamodel.rst:1768
msgid "Frame objects support one method:"
msgstr ""

#: ../../reference/datamodel.rst:1772
msgid ""
"This method clears all references to :ref:`local variables <naming>` held"
" by the frame.  Also, if the frame belonged to a :term:`generator`, the "
"generator is finalized.  This helps break reference cycles involving "
"frame objects (for example when catching an :ref:`exception <bltin-"
"exceptions>` and storing its :ref:`traceback <traceback-objects>` for "
"later use)."
msgstr ""

#: ../../reference/datamodel.rst:1778
msgid ""
":exc:`RuntimeError` is raised if the frame is currently executing or "
"suspended."
msgstr ""

#: ../../reference/datamodel.rst:1783
msgid ""
"Attempting to clear a suspended frame raises :exc:`RuntimeError` (as has "
"always been the case for executing frames)."
msgstr ""

#: ../../reference/datamodel.rst:1791
msgid "Traceback objects"
msgstr ""

#: ../../reference/datamodel.rst:1804
msgid ""
"Traceback objects represent the stack trace of an :ref:`exception <tut-"
"errors>`. A traceback object is implicitly created when an exception "
"occurs, and may also be explicitly created by calling "
":class:`types.TracebackType`."
msgstr ""

#: ../../reference/datamodel.rst:1809
msgid "Traceback objects can now be explicitly instantiated from Python code."
msgstr ""

#: ../../reference/datamodel.rst:1812
msgid ""
"For implicitly created tracebacks, when the search for an exception "
"handler unwinds the execution stack, at each unwound level a traceback "
"object is inserted in front of the current traceback.  When an exception "
"handler is entered, the stack trace is made available to the program. "
"(See section :ref:`try`.) It is accessible as the third item of the tuple"
" returned by :func:`sys.exc_info`, and as the "
":attr:`~BaseException.__traceback__` attribute of the caught exception."
msgstr ""

#: ../../reference/datamodel.rst:1821
msgid ""
"When the program contains no suitable handler, the stack trace is written"
" (nicely formatted) to the standard error stream; if the interpreter is "
"interactive, it is also made available to the user as "
":data:`sys.last_traceback`."
msgstr ""

#: ../../reference/datamodel.rst:1826
msgid ""
"For explicitly created tracebacks, it is up to the creator of the "
"traceback to determine how the :attr:`~traceback.tb_next` attributes "
"should be linked to form a full stack trace."
msgstr ""

#: ../../reference/datamodel.rst:1841
msgid "Points to the execution :ref:`frame <frame-objects>` of the current level."
msgstr ""

#: ../../reference/datamodel.rst:1844
msgid ""
"Accessing this attribute raises an :ref:`auditing event <auditing>` "
"``object.__getattr__`` with arguments ``obj`` and ``\"tb_frame\"``."
msgstr ""

#: ../../reference/datamodel.rst:1849
msgid "Gives the line number where the exception occurred"
msgstr ""

#: ../../reference/datamodel.rst:1852
msgid "Indicates the \"precise instruction\"."
msgstr ""

#: ../../reference/datamodel.rst:1854
msgid ""
"The line number and last instruction in the traceback may differ from the"
" line number of its :ref:`frame object <frame-objects>` if the exception "
"occurred in a :keyword:`try` statement with no matching except clause or "
"with a :keyword:`finally` clause."
msgstr ""

#: ../../reference/datamodel.rst:1865
msgid ""
"The special writable attribute :attr:`!tb_next` is the next level in the "
"stack trace (towards the frame where the exception occurred), or ``None``"
" if there is no next level."
msgstr ""

#: ../../reference/datamodel.rst:1869
msgid "This attribute is now writable"
msgstr ""

#: ../../reference/datamodel.rst:1874
msgid "Slice objects"
msgstr ""

#: ../../reference/datamodel.rst:1878
msgid ""
"Slice objects are used to represent slices for "
":meth:`~object.__getitem__` methods.  They are also created by the built-"
"in :func:`slice` function."
msgstr ""

#: ../../reference/datamodel.rst:1887
msgid ""
"Special read-only attributes: :attr:`~slice.start` is the lower bound; "
":attr:`~slice.stop` is the upper bound; :attr:`~slice.step` is the step "
"value; each is ``None`` if omitted.  These attributes can have any type."
msgstr ""

#: ../../reference/datamodel.rst:1891
msgid "Slice objects support one method:"
msgstr ""

#: ../../reference/datamodel.rst:1895
msgid ""
"This method takes a single integer argument *length* and computes "
"information about the slice that the slice object would describe if "
"applied to a sequence of *length* items.  It returns a tuple of three "
"integers; respectively these are the *start* and *stop* indices and the "
"*step* or stride length of the slice. Missing or out-of-bounds indices "
"are handled in a manner consistent with regular slices."
msgstr ""

#: ../../reference/datamodel.rst:1904
msgid "Static method objects"
msgstr ""

#: ../../reference/datamodel.rst:1906
msgid ""
"Static method objects provide a way of defeating the transformation of "
"function objects to method objects described above. A static method "
"object is a wrapper around any other object, usually a user-defined "
"method object. When a static method object is retrieved from a class or a"
" class instance, the object actually returned is the wrapped object, "
"which is not subject to any further transformation. Static method objects"
" are also callable. Static method objects are created by the built-in "
":func:`staticmethod` constructor."
msgstr ""

#: ../../reference/datamodel.rst:1916
msgid "Class method objects"
msgstr ""

#: ../../reference/datamodel.rst:1918
msgid ""
"A class method object, like a static method object, is a wrapper around "
"another object that alters the way in which that object is retrieved from"
" classes and class instances. The behaviour of class method objects upon "
"such retrieval is described above, under :ref:`\"instance methods\" "
"<instance-methods>`. Class method objects are created by the built-in "
":func:`classmethod` constructor."
msgstr ""

#: ../../reference/datamodel.rst:1928
msgid "Special method names"
msgstr ""

#: ../../reference/datamodel.rst:1934
msgid ""
"A class can implement certain operations that are invoked by special "
"syntax (such as arithmetic operations or subscripting and slicing) by "
"defining methods with special names. This is Python's approach to "
":dfn:`operator overloading`, allowing classes to define their own "
"behavior with respect to language operators.  For instance, if a class "
"defines a method named :meth:`~object.__getitem__`, and ``x`` is an "
"instance of this class, then ``x[i]`` is roughly equivalent to "
"``type(x).__getitem__(x, i)``.  Except where mentioned, attempts to "
"execute an operation raise an exception when no appropriate method is "
"defined (typically :exc:`AttributeError` or :exc:`TypeError`)."
msgstr ""

#: ../../reference/datamodel.rst:1945
msgid ""
"Setting a special method to ``None`` indicates that the corresponding "
"operation is not available.  For example, if a class sets "
":meth:`~object.__iter__` to ``None``, the class is not iterable, so "
"calling :func:`iter` on its instances will raise a :exc:`TypeError` "
"(without falling back to :meth:`~object.__getitem__`). [#]_"
msgstr ""

#: ../../reference/datamodel.rst:1951
msgid ""
"When implementing a class that emulates any built-in type, it is "
"important that the emulation only be implemented to the degree that it "
"makes sense for the object being modelled.  For example, some sequences "
"may work well with retrieval of individual elements, but extracting a "
"slice may not make sense. (One example of this is the :ref:`NodeList "
"<dom-nodelist-objects>` interface in the W3C's Document Object Model.)"
msgstr ""

#: ../../reference/datamodel.rst:1962
msgid "Basic customization"
msgstr ""

#: ../../reference/datamodel.rst:1968
msgid ""
"Called to create a new instance of class *cls*.  :meth:`__new__` is a "
"static method (special-cased so you need not declare it as such) that "
"takes the class of which an instance was requested as its first argument."
"  The remaining arguments are those passed to the object constructor "
"expression (the call to the class).  The return value of :meth:`__new__` "
"should be the new object instance (usually an instance of *cls*)."
msgstr ""

#: ../../reference/datamodel.rst:1975
msgid ""
"Typical implementations create a new instance of the class by invoking "
"the superclass's :meth:`__new__` method using ``super().__new__(cls[, "
"...])`` with appropriate arguments and then modifying the newly created "
"instance as necessary before returning it."
msgstr ""

#: ../../reference/datamodel.rst:1980
msgid ""
"If :meth:`__new__` is invoked during object construction and it returns "
"an instance of *cls*, then the new instance’s :meth:`__init__` method "
"will be invoked like ``__init__(self[, ...])``, where *self* is the new "
"instance and the remaining arguments are the same as were passed to the "
"object constructor."
msgstr ""

#: ../../reference/datamodel.rst:1985
msgid ""
"If :meth:`__new__` does not return an instance of *cls*, then the new "
"instance's :meth:`__init__` method will not be invoked."
msgstr ""

#: ../../reference/datamodel.rst:1988
msgid ""
":meth:`__new__` is intended mainly to allow subclasses of immutable types"
" (like int, str, or tuple) to customize instance creation.  It is also "
"commonly overridden in custom metaclasses in order to customize class "
"creation."
msgstr ""

#: ../../reference/datamodel.rst:1997
msgid ""
"Called after the instance has been created (by :meth:`__new__`), but "
"before it is returned to the caller.  The arguments are those passed to "
"the class constructor expression.  If a base class has an "
":meth:`__init__` method, the derived class's :meth:`__init__` method, if "
"any, must explicitly call it to ensure proper initialization of the base "
"class part of the instance; for example: ``super().__init__([args...])``."
msgstr ""

#: ../../reference/datamodel.rst:2004
msgid ""
"Because :meth:`__new__` and :meth:`__init__` work together in "
"constructing objects (:meth:`__new__` to create it, and :meth:`__init__` "
"to customize it), no non-``None`` value may be returned by "
":meth:`__init__`; doing so will cause a :exc:`TypeError` to be raised at "
"runtime."
msgstr ""

#: ../../reference/datamodel.rst:2017
msgid ""
"Called when the instance is about to be destroyed.  This is also called a"
" finalizer or (improperly) a destructor.  If a base class has a "
":meth:`__del__` method, the derived class's :meth:`__del__` method, if "
"any, must explicitly call it to ensure proper deletion of the base class "
"part of the instance."
msgstr ""

#: ../../reference/datamodel.rst:2023
msgid ""
"It is possible (though not recommended!) for the :meth:`__del__` method "
"to postpone destruction of the instance by creating a new reference to "
"it.  This is called object *resurrection*.  It is implementation-"
"dependent whether :meth:`__del__` is called a second time when a "
"resurrected object is about to be destroyed; the current :term:`CPython` "
"implementation only calls it once."
msgstr ""

#: ../../reference/datamodel.rst:2030
msgid ""
"It is not guaranteed that :meth:`__del__` methods are called for objects "
"that still exist when the interpreter exits. :class:`weakref.finalize` "
"provides a straightforward way to register a cleanup function to be "
"called when an object is garbage collected."
msgstr ""

#: ../../reference/datamodel.rst:2037
msgid ""
"``del x`` doesn't directly call ``x.__del__()`` --- the former decrements"
" the reference count for ``x`` by one, and the latter is only called when"
" ``x``'s reference count reaches zero."
msgstr ""

#: ../../reference/datamodel.rst:2042
msgid ""
"It is possible for a reference cycle to prevent the reference count of an"
" object from going to zero.  In this case, the cycle will be later "
"detected and deleted by the :term:`cyclic garbage collector <garbage "
"collection>`.  A common cause of reference cycles is when an exception "
"has been caught in a local variable.  The frame's locals then reference "
"the exception, which references its own traceback, which references the "
"locals of all frames caught in the traceback."
msgstr ""

#: ../../reference/datamodel.rst:2052
msgid "Documentation for the :mod:`gc` module."
msgstr ""

#: ../../reference/datamodel.rst:2056
msgid ""
"Due to the precarious circumstances under which :meth:`__del__` methods "
"are invoked, exceptions that occur during their execution are ignored, "
"and a warning is printed to ``sys.stderr`` instead.  In particular:"
msgstr ""

#: ../../reference/datamodel.rst:2060
msgid ""
":meth:`__del__` can be invoked when arbitrary code is being executed, "
"including from any arbitrary thread.  If :meth:`__del__` needs to take a "
"lock or invoke any other blocking resource, it may deadlock as the "
"resource may already be taken by the code that gets interrupted to "
"execute :meth:`__del__`."
msgstr ""

#: ../../reference/datamodel.rst:2066
msgid ""
":meth:`__del__` can be executed during interpreter shutdown.  As a "
"consequence, the global variables it needs to access (including other "
"modules) may already have been deleted or set to ``None``. Python "
"guarantees that globals whose name begins with a single underscore are "
"deleted from their module before other globals are deleted; if no other "
"references to such globals exist, this may help in assuring that imported"
" modules are still available at the time when the :meth:`__del__` method "
"is called."
msgstr ""

#: ../../reference/datamodel.rst:2081
msgid ""
"Called by the :func:`repr` built-in function to compute the \"official\" "
"string representation of an object.  If at all possible, this should look"
" like a valid Python expression that could be used to recreate an object "
"with the same value (given an appropriate environment).  If this is not "
"possible, a string of the form ``<...some useful description...>`` should"
" be returned. The return value must be a string object. If a class "
"defines :meth:`__repr__` but not :meth:`__str__`, then :meth:`__repr__` "
"is also used when an \"informal\" string representation of instances of "
"that class is required."
msgstr ""

#: ../../reference/datamodel.rst:2090
msgid ""
"This is typically used for debugging, so it is important that the "
"representation is information-rich and unambiguous. A default "
"implementation is provided by the :class:`object` class itself."
msgstr ""

#: ../../reference/datamodel.rst:2102
msgid ""
"Called by :func:`str(object) <str>`, the default :meth:`__format__` "
"implementation, and the built-in function :func:`print`, to compute the "
"\"informal\" or nicely printable string representation of an object.  The"
" return value must be a :ref:`str <textseq>` object."
msgstr ""

#: ../../reference/datamodel.rst:2107
msgid ""
"This method differs from :meth:`object.__repr__` in that there is no "
"expectation that :meth:`__str__` return a valid Python expression: a more"
" convenient or concise representation can be used."
msgstr ""

#: ../../reference/datamodel.rst:2111
msgid ""
"The default implementation defined by the built-in type :class:`object` "
"calls :meth:`object.__repr__`."
msgstr ""

#: ../../reference/datamodel.rst:2121
msgid ""
"Called by :ref:`bytes <func-bytes>` to compute a byte-string "
"representation of an object. This should return a :class:`bytes` object. "
"The :class:`object` class itself does not provide this method."
msgstr ""

#: ../../reference/datamodel.rst:2133
msgid ""
"Called by the :func:`format` built-in function, and by extension, "
"evaluation of :ref:`formatted string literals <f-strings>` and the "
":meth:`str.format` method, to produce a \"formatted\" string "
"representation of an object. The *format_spec* argument is a string that "
"contains a description of the formatting options desired. The "
"interpretation of the *format_spec* argument is up to the type "
"implementing :meth:`__format__`, however most classes will either "
"delegate formatting to one of the built-in types, or use a similar "
"formatting option syntax."
msgstr ""

#: ../../reference/datamodel.rst:2143
msgid "See :ref:`formatspec` for a description of the standard formatting syntax."
msgstr ""

#: ../../reference/datamodel.rst:2145
msgid "The return value must be a string object."
msgstr ""

#: ../../reference/datamodel.rst:2147
msgid ""
"The default implementation by the :class:`object` class should be given "
"an empty *format_spec* string. It delegates to :meth:`__str__`."
msgstr ""

#: ../../reference/datamodel.rst:2150
msgid ""
"The __format__ method of ``object`` itself raises a :exc:`TypeError` if "
"passed any non-empty string."
msgstr ""

#: ../../reference/datamodel.rst:2154
msgid ""
"``object.__format__(x, '')`` is now equivalent to ``str(x)`` rather than "
"``format(str(x), '')``."
msgstr ""

#: ../../reference/datamodel.rst:2170
msgid ""
"These are the so-called \"rich comparison\" methods. The correspondence "
"between operator symbols and method names is as follows: ``x<y`` calls "
"``x.__lt__(y)``, ``x<=y`` calls ``x.__le__(y)``, ``x==y`` calls "
"``x.__eq__(y)``, ``x!=y`` calls ``x.__ne__(y)``, ``x>y`` calls "
"``x.__gt__(y)``, and ``x>=y`` calls ``x.__ge__(y)``."
msgstr ""

#: ../../reference/datamodel.rst:2176
msgid ""
"A rich comparison method may return the singleton :data:`NotImplemented` "
"if it does not implement the operation for a given pair of arguments. By "
"convention, ``False`` and ``True`` are returned for a successful "
"comparison. However, these methods can return any value, so if the "
"comparison operator is used in a Boolean context (e.g., in the condition "
"of an ``if`` statement), Python will call :func:`bool` on the value to "
"determine if the result is true or false."
msgstr ""

#: ../../reference/datamodel.rst:2183
msgid ""
"By default, ``object`` implements :meth:`__eq__` by using ``is``, "
"returning :data:`NotImplemented` in the case of a false comparison: "
"``True if x is y else NotImplemented``. For :meth:`__ne__`, by default it"
" delegates to :meth:`__eq__` and inverts the result unless it is "
":data:`!NotImplemented`.  There are no other implied relationships among "
"the comparison operators or default implementations; for example, the "
"truth of ``(x<y or x==y)`` does not imply ``x<=y``. To automatically "
"generate ordering operations from a single root operation, see "
":func:`functools.total_ordering`."
msgstr ""

#: ../../reference/datamodel.rst:2192
msgid ""
"By default, the :class:`object` class provides implementations consistent"
" with :ref:`expressions-value-comparisons`: equality compares according "
"to object identity, and order comparisons raise :exc:`TypeError`. Each "
"default method may generate these results directly, but may also return "
":data:`NotImplemented`."
msgstr ""

#: ../../reference/datamodel.rst:2198
msgid ""
"See the paragraph on :meth:`__hash__` for some important notes on "
"creating :term:`hashable` objects which support custom comparison "
"operations and are usable as dictionary keys."
msgstr ""

#: ../../reference/datamodel.rst:2202
msgid ""
"There are no swapped-argument versions of these methods (to be used when "
"the left argument does not support the operation but the right argument "
"does); rather, :meth:`__lt__` and :meth:`__gt__` are each other's "
"reflection, :meth:`__le__` and :meth:`__ge__` are each other's "
"reflection, and :meth:`__eq__` and :meth:`__ne__` are their own "
"reflection. If the operands are of different types, and the right "
"operand's type is a direct or indirect subclass of the left operand's "
"type, the reflected method of the right operand has priority, otherwise "
"the left operand's method has priority.  Virtual subclassing is not "
"considered."
msgstr ""

#: ../../reference/datamodel.rst:2213
msgid ""
"When no appropriate method returns any value other than "
":data:`NotImplemented`, the ``==`` and ``!=`` operators will fall back to"
" ``is`` and ``is not``, respectively."
msgstr ""

#: ../../reference/datamodel.rst:2222
msgid ""
"Called by built-in function :func:`hash` and for operations on members of"
" hashed collections including :class:`set`, :class:`frozenset`, and "
":class:`dict`.  The ``__hash__()`` method should return an integer. The "
"only required property is that objects which compare equal have the same "
"hash value; it is advised to mix together the hash values of the "
"components of the object that also play a part in comparison of objects "
"by packing them into a tuple and hashing the tuple. Example::"
msgstr ""

#: ../../reference/datamodel.rst:2230
msgid ""
"def __hash__(self):\n"
"    return hash((self.name, self.nick, self.color))"
msgstr ""

#: ../../reference/datamodel.rst:2235
msgid ""
":func:`hash` truncates the value returned from an object's custom "
":meth:`__hash__` method to the size of a :c:type:`Py_ssize_t`.  This is "
"typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds.  If an "
"object's   :meth:`__hash__` must interoperate on builds of different bit "
"sizes, be sure to check the width on all supported builds.  An easy way "
"to do this is with ``python -c \"import sys; "
"print(sys.hash_info.width)\"``."
msgstr ""

#: ../../reference/datamodel.rst:2243
msgid ""
"If a class does not define an :meth:`__eq__` method it should not define "
"a :meth:`__hash__` operation either; if it defines :meth:`__eq__` but not"
" :meth:`__hash__`, its instances will not be usable as items in hashable "
"collections.  If a class defines mutable objects and implements an "
":meth:`__eq__` method, it should not implement :meth:`__hash__`, since "
"the implementation of :term:`hashable` collections requires that a key's "
"hash value is immutable (if the object's hash value changes, it will be "
"in the wrong hash bucket)."
msgstr ""

#: ../../reference/datamodel.rst:2252
msgid ""
"User-defined classes have :meth:`__eq__` and :meth:`__hash__` methods by "
"default (inherited from the :class:`object` class); with them, all "
"objects compare unequal (except with themselves) and ``x.__hash__()`` "
"returns an appropriate value such that ``x == y`` implies both that ``x "
"is y`` and ``hash(x) == hash(y)``."
msgstr ""

#: ../../reference/datamodel.rst:2257
msgid ""
"A class that overrides :meth:`__eq__` and does not define "
":meth:`__hash__` will have its :meth:`__hash__` implicitly set to "
"``None``.  When the :meth:`__hash__` method of a class is ``None``, "
"instances of the class will raise an appropriate :exc:`TypeError` when a "
"program attempts to retrieve their hash value, and will also be correctly"
" identified as unhashable when checking ``isinstance(obj, "
"collections.abc.Hashable)``."
msgstr ""

#: ../../reference/datamodel.rst:2264
msgid ""
"If a class that overrides :meth:`__eq__` needs to retain the "
"implementation of :meth:`__hash__` from a parent class, the interpreter "
"must be told this explicitly by setting ``__hash__ = "
"<ParentClass>.__hash__``."
msgstr ""

#: ../../reference/datamodel.rst:2268
msgid ""
"If a class that does not override :meth:`__eq__` wishes to suppress hash "
"support, it should include ``__hash__ = None`` in the class definition. A"
" class which defines its own :meth:`__hash__` that explicitly raises a "
":exc:`TypeError` would be incorrectly identified as hashable by an "
"``isinstance(obj, collections.abc.Hashable)`` call."
msgstr ""

#: ../../reference/datamodel.rst:2277
msgid ""
"By default, the :meth:`__hash__` values of str and bytes objects are "
"\"salted\" with an unpredictable random value.  Although they remain "
"constant within an individual Python process, they are not predictable "
"between repeated invocations of Python."
msgstr ""

#: ../../reference/datamodel.rst:2282
msgid ""
"This is intended to provide protection against a denial-of-service caused"
" by carefully chosen inputs that exploit the worst case performance of a "
"dict insertion, *O*\\ (*n*\\ :sup:`2`) complexity.  See "
"https://ocert.org/advisories/ocert-2011-003.html for details."
msgstr ""

#: ../../reference/datamodel.rst:2287
msgid ""
"Changing hash values affects the iteration order of sets. Python has "
"never made guarantees about this ordering (and it typically varies "
"between 32-bit and 64-bit builds)."
msgstr ""

#: ../../reference/datamodel.rst:2291
msgid "See also :envvar:`PYTHONHASHSEED`."
msgstr ""

#: ../../reference/datamodel.rst:2293
msgid "Hash randomization is enabled by default."
msgstr ""

#: ../../reference/datamodel.rst:2301
msgid ""
"Called to implement truth value testing and the built-in operation "
"``bool()``; should return ``False`` or ``True``.  When this method is not"
" defined, :meth:`~object.__len__` is called, if it is defined, and the "
"object is considered true if its result is nonzero.  If a class defines "
"neither :meth:`!__len__` nor :meth:`!__bool__` (which is true of the "
":class:`object` class itself), all its instances are considered true."
msgstr ""

#: ../../reference/datamodel.rst:2312
msgid "Customizing attribute access"
msgstr ""

#: ../../reference/datamodel.rst:2314
msgid ""
"The following methods can be defined to customize the meaning of "
"attribute access (use of, assignment to, or deletion of ``x.name``) for "
"class instances."
msgstr ""

#: ../../reference/datamodel.rst:2322
msgid ""
"Called when the default attribute access fails with an "
":exc:`AttributeError` (either :meth:`__getattribute__` raises an "
":exc:`AttributeError` because *name* is not an instance attribute or an "
"attribute in the class tree for ``self``; or :meth:`__get__` of a *name* "
"property raises :exc:`AttributeError`).  This method should either return"
" the (computed) attribute value or raise an :exc:`AttributeError` "
"exception. The :class:`object` class itself does not provide this method."
msgstr ""

#: ../../reference/datamodel.rst:2330
msgid ""
"Note that if the attribute is found through the normal mechanism, "
":meth:`__getattr__` is not called.  (This is an intentional asymmetry "
"between :meth:`__getattr__` and :meth:`__setattr__`.) This is done both "
"for efficiency reasons and because otherwise :meth:`__getattr__` would "
"have no way to access other attributes of the instance.  Note that at "
"least for instance variables, you can take total control by not inserting"
" any values in the instance attribute dictionary (but instead inserting "
"them in another object).  See the :meth:`__getattribute__` method below "
"for a way to actually get total control over attribute access."
msgstr ""

#: ../../reference/datamodel.rst:2343
msgid ""
"Called unconditionally to implement attribute accesses for instances of "
"the class. If the class also defines :meth:`__getattr__`, the latter will"
" not be called unless :meth:`__getattribute__` either calls it explicitly"
" or raises an :exc:`AttributeError`. This method should return the "
"(computed) attribute value or raise an :exc:`AttributeError` exception. "
"In order to avoid infinite recursion in this method, its implementation "
"should always call the base class method with the same name to access any"
" attributes it needs, for example, ``object.__getattribute__(self, "
"name)``."
msgstr ""

#: ../../reference/datamodel.rst:2354
msgid ""
"This method may still be bypassed when looking up special methods as the "
"result of implicit invocation via language syntax or :ref:`built-in "
"functions <builtin-functions>`. See :ref:`special-lookup`."
msgstr ""

#: ../../reference/datamodel.rst:2359 ../../reference/datamodel.rst:2361
msgid ""
"For certain sensitive attribute accesses, raises an :ref:`auditing event "
"<auditing>` ``object.__getattr__`` with arguments ``obj`` and ``name``."
msgstr ""

#: ../../reference/datamodel.rst:2368
msgid ""
"Called when an attribute assignment is attempted.  This is called instead"
" of the normal mechanism (i.e. store the value in the instance "
"dictionary). *name* is the attribute name, *value* is the value to be "
"assigned to it."
msgstr ""

#: ../../reference/datamodel.rst:2372
msgid ""
"If :meth:`__setattr__` wants to assign to an instance attribute, it "
"should call the base class method with the same name, for example, "
"``object.__setattr__(self, name, value)``."
msgstr ""

#: ../../reference/datamodel.rst:2376 ../../reference/datamodel.rst:2378
msgid ""
"For certain sensitive attribute assignments, raises an :ref:`auditing "
"event <auditing>` ``object.__setattr__`` with arguments ``obj``, "
"``name``, ``value``."
msgstr ""

#: ../../reference/datamodel.rst:2385
msgid ""
"Like :meth:`__setattr__` but for attribute deletion instead of "
"assignment.  This should only be implemented if ``del obj.name`` is "
"meaningful for the object."
msgstr ""

#: ../../reference/datamodel.rst:2388 ../../reference/datamodel.rst:2390
msgid ""
"For certain sensitive attribute deletions, raises an :ref:`auditing event"
" <auditing>` ``object.__delattr__`` with arguments ``obj`` and ``name``."
msgstr ""

#: ../../reference/datamodel.rst:2397
msgid ""
"Called when :func:`dir` is called on the object. An iterable must be "
"returned. :func:`dir` converts the returned iterable to a list and sorts "
"it."
msgstr ""

#: ../../reference/datamodel.rst:2402
msgid "Customizing module attribute access"
msgstr ""

#: ../../reference/datamodel.rst:2412
msgid ""
"Special names ``__getattr__`` and ``__dir__`` can be also used to "
"customize access to module attributes. The ``__getattr__`` function at "
"the module level should accept one argument which is the name of an "
"attribute and return the computed value or raise an "
":exc:`AttributeError`. If an attribute is not found on a module object "
"through the normal lookup, i.e. :meth:`object.__getattribute__`, then "
"``__getattr__`` is searched in the module ``__dict__`` before raising an "
":exc:`AttributeError`. If found, it is called with the attribute name and"
" the result is returned."
msgstr ""

#: ../../reference/datamodel.rst:2421
msgid ""
"The ``__dir__`` function should accept no arguments, and return an "
"iterable of strings that represents the names accessible on module. If "
"present, this function overrides the standard :func:`dir` search on a "
"module."
msgstr ""

#: ../../reference/datamodel.rst:2427
msgid ""
"For a more fine grained customization of the module behavior (setting "
"attributes, properties, etc.), one can set the ``__class__`` attribute of"
" a module object to a subclass of :class:`types.ModuleType`. For "
"example::"
msgstr ""

#: ../../reference/datamodel.rst:2431
#, python-brace-format
msgid ""
"import sys\n"
"from types import ModuleType\n"
"\n"
"class VerboseModule(ModuleType):\n"
"    def __repr__(self):\n"
"        return f'Verbose {self.__name__}'\n"
"\n"
"    def __setattr__(self, attr, value):\n"
"        print(f'Setting {attr}...')\n"
"        super().__setattr__(attr, value)\n"
"\n"
"sys.modules[__name__].__class__ = VerboseModule"
msgstr ""

#: ../../reference/datamodel.rst:2445
msgid ""
"Defining module ``__getattr__`` and setting module ``__class__`` only "
"affect lookups made using the attribute access syntax -- directly "
"accessing the module globals (whether by code within the module, or via a"
" reference to the module's globals dictionary) is unaffected."
msgstr ""

#: ../../reference/datamodel.rst:2450
msgid "``__class__`` module attribute is now writable."
msgstr ""

#: ../../reference/datamodel.rst:2453
msgid "``__getattr__`` and ``__dir__`` module attributes."
msgstr ""

#: ../../reference/datamodel.rst:2458
msgid ":pep:`562` - Module __getattr__ and __dir__"
msgstr ""

#: ../../reference/datamodel.rst:2459
msgid "Describes the ``__getattr__`` and ``__dir__`` functions on modules."
msgstr ""

#: ../../reference/datamodel.rst:2465
msgid "Implementing Descriptors"
msgstr ""

#: ../../reference/datamodel.rst:2467
msgid ""
"The following methods only apply when an instance of the class containing"
" the method (a so-called *descriptor* class) appears in an *owner* class "
"(the descriptor must be in either the owner's class dictionary or in the "
"class dictionary for one of its parents).  In the examples below, \"the "
"attribute\" refers to the attribute whose name is the key of the property"
" in the owner class' :attr:`~object.__dict__`.  The :class:`object` class"
" itself does not implement any of these protocols."
msgstr ""

#: ../../reference/datamodel.rst:2477
msgid ""
"Called to get the attribute of the owner class (class attribute access) "
"or of an instance of that class (instance attribute access). The optional"
" *owner* argument is the owner class, while *instance* is the instance "
"that the attribute was accessed through, or ``None`` when the attribute "
"is accessed through the *owner*."
msgstr ""

#: ../../reference/datamodel.rst:2483
msgid ""
"This method should return the computed attribute value or raise an "
":exc:`AttributeError` exception."
msgstr ""

#: ../../reference/datamodel.rst:2486
msgid ""
":PEP:`252` specifies that :meth:`__get__` is callable with one or two "
"arguments.  Python's own built-in descriptors support this specification;"
" however, it is likely that some third-party tools have descriptors that "
"require both arguments.  Python's own :meth:`__getattribute__` "
"implementation always passes in both arguments whether they are required "
"or not."
msgstr ""

#: ../../reference/datamodel.rst:2495
msgid ""
"Called to set the attribute on an instance *instance* of the owner class "
"to a new value, *value*."
msgstr ""

#: ../../reference/datamodel.rst:2498
msgid ""
"Note, adding :meth:`__set__` or :meth:`__delete__` changes the kind of "
"descriptor to a \"data descriptor\".  See :ref:`descriptor-invocation` "
"for more details."
msgstr ""

#: ../../reference/datamodel.rst:2504
msgid ""
"Called to delete the attribute on an instance *instance* of the owner "
"class."
msgstr ""

#: ../../reference/datamodel.rst:2506
msgid ""
"Instances of descriptors may also have the :attr:`!__objclass__` "
"attribute present:"
msgstr ""

#: ../../reference/datamodel.rst:2511
msgid ""
"The attribute :attr:`!__objclass__` is interpreted by the :mod:`inspect` "
"module as specifying the class where this object was defined (setting "
"this appropriately can assist in runtime introspection of dynamic class "
"attributes). For callables, it may indicate that an instance of the given"
" type (or a subclass) is expected or required as the first positional "
"argument (for example, CPython sets this attribute for unbound methods "
"that are implemented in C)."
msgstr ""

#: ../../reference/datamodel.rst:2522
msgid "Invoking Descriptors"
msgstr ""

#: ../../reference/datamodel.rst:2524
msgid ""
"In general, a descriptor is an object attribute with \"binding "
"behavior\", one whose attribute access has been overridden by methods in "
"the descriptor protocol:  :meth:`~object.__get__`, "
":meth:`~object.__set__`, and :meth:`~object.__delete__`. If any of those "
"methods are defined for an object, it is said to be a descriptor."
msgstr ""

#: ../../reference/datamodel.rst:2530
msgid ""
"The default behavior for attribute access is to get, set, or delete the "
"attribute from an object's dictionary. For instance, ``a.x`` has a lookup"
" chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``,"
" and continuing through the base classes of ``type(a)`` excluding "
"metaclasses."
msgstr ""

#: ../../reference/datamodel.rst:2535
msgid ""
"However, if the looked-up value is an object defining one of the "
"descriptor methods, then Python may override the default behavior and "
"invoke the descriptor method instead.  Where this occurs in the "
"precedence chain depends on which descriptor methods were defined and how"
" they were called."
msgstr ""

#: ../../reference/datamodel.rst:2540
msgid ""
"The starting point for descriptor invocation is a binding, ``a.x``. How "
"the arguments are assembled depends on ``a``:"
msgstr ""

#: ../../reference/datamodel.rst:2543
msgid "Direct Call"
msgstr ""

#: ../../reference/datamodel.rst:2544
msgid ""
"The simplest and least common call is when user code directly invokes a "
"descriptor method:    ``x.__get__(a)``."
msgstr ""

#: ../../reference/datamodel.rst:2547
msgid "Instance Binding"
msgstr ""

#: ../../reference/datamodel.rst:2548
msgid ""
"If binding to an object instance, ``a.x`` is transformed into the call: "
"``type(a).__dict__['x'].__get__(a, type(a))``."
msgstr ""

#: ../../reference/datamodel.rst:2551
msgid "Class Binding"
msgstr ""

#: ../../reference/datamodel.rst:2552
msgid ""
"If binding to a class, ``A.x`` is transformed into the call: "
"``A.__dict__['x'].__get__(None, A)``."
msgstr ""

#: ../../reference/datamodel.rst:2555
msgid "Super Binding"
msgstr ""

#: ../../reference/datamodel.rst:2556
msgid ""
"A dotted lookup such as ``super(A, a).x`` searches "
"``a.__class__.__mro__`` for a base class ``B`` following ``A`` and then "
"returns ``B.__dict__['x'].__get__(a, A)``.  If not a descriptor, ``x`` is"
" returned unchanged."
msgstr ""

#: ../../reference/datamodel.rst:2593
msgid ""
"For instance bindings, the precedence of descriptor invocation depends on"
" which descriptor methods are defined.  A descriptor can define any "
"combination of :meth:`~object.__get__`, :meth:`~object.__set__` and "
":meth:`~object.__delete__`.  If it does not define :meth:`!__get__`, then"
" accessing the attribute will return the descriptor object itself unless "
"there is a value in the object's instance dictionary.  If the descriptor "
"defines :meth:`!__set__` and/or :meth:`!__delete__`, it is a data "
"descriptor; if it defines neither, it is a non-data descriptor.  "
"Normally, data descriptors define both :meth:`!__get__` and "
":meth:`!__set__`, while non-data descriptors have just the "
":meth:`!__get__` method.  Data descriptors with :meth:`!__get__` and "
":meth:`!__set__` (and/or :meth:`!__delete__`) defined always override a "
"redefinition in an instance dictionary.  In contrast, non-data "
"descriptors can be overridden by instances."
msgstr ""

#: ../../reference/datamodel.rst:2608
msgid ""
"Python methods (including those decorated with :deco:`staticmethod` and "
":deco:`classmethod`) are implemented as non-data descriptors.  "
"Accordingly, instances can redefine and override methods.  This allows "
"individual instances to acquire behaviors that differ from other "
"instances of the same class."
msgstr ""

#: ../../reference/datamodel.rst:2614
msgid ""
"The :func:`property` function is implemented as a data descriptor. "
"Accordingly, instances cannot override the behavior of a property."
msgstr ""

#: ../../reference/datamodel.rst:2621
msgid "__slots__"
msgstr ""

#: ../../reference/datamodel.rst:2623
msgid ""
"*__slots__* allow us to explicitly declare data members (like properties)"
" and deny the creation of :attr:`~object.__dict__` and *__weakref__* "
"(unless explicitly declared in *__slots__* or available in a parent.)"
msgstr ""

#: ../../reference/datamodel.rst:2627
msgid ""
"The space saved over using :attr:`~object.__dict__` can be significant. "
"Attribute lookup speed can be significantly improved as well."
msgstr ""

#: ../../reference/datamodel.rst:2632
msgid ""
"This class variable can be assigned a string, iterable, or sequence of "
"strings with variable names used by instances.  *__slots__* reserves "
"space for the declared variables and prevents the automatic creation of "
":attr:`~object.__dict__` and *__weakref__* for each instance."
msgstr ""

#: ../../reference/datamodel.rst:2641
msgid "Notes on using *__slots__*:"
msgstr ""

#: ../../reference/datamodel.rst:2643
msgid ""
"When inheriting from a class without *__slots__*, the "
":attr:`~object.__dict__` and *__weakref__* attribute of the instances "
"will always be accessible."
msgstr ""

#: ../../reference/datamodel.rst:2647
msgid ""
"Without a :attr:`~object.__dict__` variable, instances cannot be assigned"
" new variables not listed in the *__slots__* definition.  Attempts to "
"assign to an unlisted variable name raises :exc:`AttributeError`. If "
"dynamic assignment of new variables is desired, then add ``'__dict__'`` "
"to the sequence of strings in the *__slots__* declaration."
msgstr ""

#: ../../reference/datamodel.rst:2654
msgid ""
"Without a *__weakref__* variable for each instance, classes defining "
"*__slots__* do not support :mod:`weak references <weakref>` to its "
"instances. If weak reference support is needed, then add "
"``'__weakref__'`` to the sequence of strings in the *__slots__* "
"declaration."
msgstr ""

#: ../../reference/datamodel.rst:2660
msgid ""
"*__slots__* are implemented at the class level by creating "
":ref:`descriptors <descriptors>` for each variable name.  As a result, "
"class attributes cannot be used to set default values for instance "
"variables defined by *__slots__*; otherwise, the class attribute would "
"overwrite the descriptor assignment."
msgstr ""

#: ../../reference/datamodel.rst:2666
msgid ""
"The action of a *__slots__* declaration is not limited to the class where"
" it is defined.  *__slots__* declared in parents are available in child "
"classes. However, instances of a child subclass will get a "
":attr:`~object.__dict__` and *__weakref__* unless the subclass also "
"defines *__slots__* (which should only contain names of any *additional* "
"slots)."
msgstr ""

#: ../../reference/datamodel.rst:2672
msgid ""
"If a class defines a slot also defined in a base class, the instance "
"variable defined by the base class slot is inaccessible (except by "
"retrieving its descriptor directly from the base class). This renders the"
" meaning of the program undefined.  In the future, a check may be added "
"to prevent this."
msgstr ""

#: ../../reference/datamodel.rst:2677
msgid ""
":exc:`TypeError` will be raised if nonempty *__slots__* are defined for a"
" class derived from a :c:member:`\"variable-length\" built-in type "
"<PyTypeObject.tp_itemsize>` such as :class:`int`, :class:`bytes`, and "
":class:`tuple`."
msgstr ""

#: ../../reference/datamodel.rst:2682
msgid "Any non-string :term:`iterable` may be assigned to *__slots__*."
msgstr ""

#: ../../reference/datamodel.rst:2684
msgid ""
"If a :class:`dictionary <dict>` is used to assign *__slots__*, the "
"dictionary keys will be used as the slot names. The values of the "
"dictionary can be used to provide per-attribute docstrings that will be "
"recognised by :func:`inspect.getdoc` and displayed in the output of "
":func:`help`."
msgstr ""

#: ../../reference/datamodel.rst:2689
msgid ""
":attr:`~object.__class__` assignment works only if both classes have the "
"same *__slots__*."
msgstr ""

#: ../../reference/datamodel.rst:2692
msgid ""
":ref:`Multiple inheritance <tut-multiple>` with multiple slotted parent "
"classes can be used, but only one parent is allowed to have attributes "
"created by slots (the other bases must have empty slot layouts) - "
"violations raise :exc:`TypeError`."
msgstr ""

#: ../../reference/datamodel.rst:2698
msgid ""
"If an :term:`iterator` is used for *__slots__* then a :term:`descriptor` "
"is created for each of the iterator's values. However, the *__slots__* "
"attribute will be an empty iterator."
msgstr ""

#: ../../reference/datamodel.rst:2706
msgid "Customizing class creation"
msgstr ""

#: ../../reference/datamodel.rst:2708
msgid ""
"Whenever a class inherits from another class, "
":meth:`~object.__init_subclass__` is called on the parent class. This "
"way, it is possible to write classes which change the behavior of "
"subclasses. This is closely related to class decorators, but where class "
"decorators only affect the specific class they're applied to, "
"``__init_subclass__`` solely applies to future subclasses of the class "
"defining the method."
msgstr ""

#: ../../reference/datamodel.rst:2717
msgid ""
"This method is called whenever the containing class is subclassed. *cls* "
"is then the new subclass. If defined as a normal instance method, this "
"method is implicitly converted to a class method."
msgstr ""

#: ../../reference/datamodel.rst:2721
msgid ""
"Keyword arguments which are given to a new class are passed to the parent"
" class's ``__init_subclass__``. For compatibility with other classes "
"using ``__init_subclass__``, one should take out the needed keyword "
"arguments and pass the others over to the base class, as in::"
msgstr ""

#: ../../reference/datamodel.rst:2727
msgid ""
"class Philosopher:\n"
"    def __init_subclass__(cls, /, default_name, **kwargs):\n"
"        super().__init_subclass__(**kwargs)\n"
"        cls.default_name = default_name\n"
"\n"
"class AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\n"
"    pass"
msgstr ""

#: ../../reference/datamodel.rst:2735
msgid ""
"The default implementation ``object.__init_subclass__`` does nothing, but"
" raises an error if it is called with any arguments."
msgstr ""

#: ../../reference/datamodel.rst:2740
msgid ""
"The metaclass hint ``metaclass`` is consumed by the rest of the type "
"machinery, and is never passed to ``__init_subclass__`` implementations. "
"The actual metaclass (rather than the explicit hint) can be accessed as "
"``type(cls)``."
msgstr ""

#: ../../reference/datamodel.rst:2748
msgid ""
"When a class is created, :meth:`!type.__new__` scans the class variables "
"and makes callbacks to those with a :meth:`~object.__set_name__` hook."
msgstr ""

#: ../../reference/datamodel.rst:2753
msgid ""
"Automatically called at the time the owning class *owner* is created. The"
" object has been assigned to *name* in that class::"
msgstr ""

#: ../../reference/datamodel.rst:2756
msgid ""
"class A:\n"
"    x = C()  # Automatically calls: x.__set_name__(A, 'x')"
msgstr ""

#: ../../reference/datamodel.rst:2759
msgid ""
"If the class variable is assigned after the class is created, "
":meth:`__set_name__` will not be called automatically. If needed, "
":meth:`__set_name__` can be called directly::"
msgstr ""

#: ../../reference/datamodel.rst:2763
msgid ""
"class A:\n"
"   pass\n"
"\n"
"c = C()\n"
"A.x = c                  # The hook is not called\n"
"c.__set_name__(A, 'x')   # Manually invoke the hook"
msgstr ""

#: ../../reference/datamodel.rst:2770
msgid "See :ref:`class-object-creation` for more details."
msgstr ""

#: ../../reference/datamodel.rst:2778
msgid "Metaclasses"
msgstr ""

#: ../../reference/datamodel.rst:2785
msgid ""
"By default, classes are constructed using :func:`type`. The class body is"
" executed in a new namespace and the class name is bound locally to the "
"result of ``type(name, bases, namespace)``."
msgstr ""

#: ../../reference/datamodel.rst:2789
msgid ""
"The class creation process can be customized by passing the ``metaclass``"
" keyword argument in the class definition line, or by inheriting from an "
"existing class that included such an argument. In the following example, "
"both ``MyClass`` and ``MySubclass`` are instances of ``Meta``::"
msgstr ""

#: ../../reference/datamodel.rst:2794
msgid ""
"class Meta(type):\n"
"    pass\n"
"\n"
"class MyClass(metaclass=Meta):\n"
"    pass\n"
"\n"
"class MySubclass(MyClass):\n"
"    pass"
msgstr ""

#: ../../reference/datamodel.rst:2803
msgid ""
"Any other keyword arguments that are specified in the class definition "
"are passed through to all metaclass operations described below."
msgstr ""

#: ../../reference/datamodel.rst:2806
msgid "When a class definition is executed, the following steps occur:"
msgstr ""

#: ../../reference/datamodel.rst:2808
msgid "MRO entries are resolved;"
msgstr ""

#: ../../reference/datamodel.rst:2809
msgid "the appropriate metaclass is determined;"
msgstr ""

#: ../../reference/datamodel.rst:2810
msgid "the class namespace is prepared;"
msgstr ""

#: ../../reference/datamodel.rst:2811
msgid "the class body is executed;"
msgstr ""

#: ../../reference/datamodel.rst:2812
msgid "the class object is created."
msgstr ""

#: ../../reference/datamodel.rst:2816
msgid "Resolving MRO entries"
msgstr ""

#: ../../reference/datamodel.rst:2820
msgid ""
"If a base that appears in a class definition is not an instance of "
":class:`type`, then an :meth:`!__mro_entries__` method is searched on the"
" base. If an :meth:`!__mro_entries__` method is found, the base is "
"substituted with the result of a call to :meth:`!__mro_entries__` when "
"creating the class. The method is called with the original bases tuple "
"passed to the *bases* parameter, and must return a tuple of classes that "
"will be used instead of the base. The returned tuple may be empty: in "
"these cases, the original base is ignored."
msgstr ""

#: ../../reference/datamodel.rst:2831
msgid ":func:`types.resolve_bases`"
msgstr ""

#: ../../reference/datamodel.rst:2832
msgid "Dynamically resolve bases that are not instances of :class:`type`."
msgstr ""

#: ../../reference/datamodel.rst:2834
msgid ":func:`types.get_original_bases`"
msgstr ""

#: ../../reference/datamodel.rst:2835
msgid ""
"Retrieve a class's \"original bases\" prior to modifications by "
":meth:`~object.__mro_entries__`."
msgstr ""

#: ../../reference/datamodel.rst:2838
msgid ":pep:`560`"
msgstr ""

#: ../../reference/datamodel.rst:2839
msgid "Core support for typing module and generic types."
msgstr ""

#: ../../reference/datamodel.rst:2843
msgid "Determining the appropriate metaclass"
msgstr ""

#: ../../reference/datamodel.rst:2847
msgid "The appropriate metaclass for a class definition is determined as follows:"
msgstr ""

#: ../../reference/datamodel.rst:2849
msgid ""
"if no bases and no explicit metaclass are given, then :func:`type` is "
"used;"
msgstr ""

#: ../../reference/datamodel.rst:2850
msgid ""
"if an explicit metaclass is given and it is *not* an instance of "
":func:`type`, then it is used directly as the metaclass;"
msgstr ""

#: ../../reference/datamodel.rst:2852
msgid ""
"if an instance of :func:`type` is given as the explicit metaclass, or "
"bases are defined, then the most derived metaclass is used."
msgstr ""

#: ../../reference/datamodel.rst:2855
msgid ""
"The most derived metaclass is selected from the explicitly specified "
"metaclass (if any) and the metaclasses (i.e. ``type(cls)``) of all "
"specified base classes. The most derived metaclass is one which is a "
"subtype of *all* of these candidate metaclasses. If none of the candidate"
" metaclasses meets that criterion, then the class definition will fail "
"with ``TypeError``."
msgstr ""

#: ../../reference/datamodel.rst:2865
msgid "Preparing the class namespace"
msgstr ""

#: ../../reference/datamodel.rst:2870
msgid ""
"Once the appropriate metaclass has been identified, then the class "
"namespace is prepared. If the metaclass has a ``__prepare__`` attribute, "
"it is called as ``namespace = metaclass.__prepare__(name, bases, "
"**kwds)`` (where the additional keyword arguments, if any, come from the "
"class definition). The ``__prepare__`` method should be implemented as a "
":func:`classmethod <classmethod>`. The namespace returned by "
"``__prepare__`` is passed in to ``__new__``, but when the final class "
"object is created the namespace is copied into a new ``dict``."
msgstr ""

#: ../../reference/datamodel.rst:2879
msgid ""
"If the metaclass has no ``__prepare__`` attribute, then the class "
"namespace is initialised as an empty ordered mapping."
msgstr ""

#: ../../reference/datamodel.rst:2884
msgid ":pep:`3115` - Metaclasses in Python 3000"
msgstr ""

#: ../../reference/datamodel.rst:2885
msgid "Introduced the ``__prepare__`` namespace hook"
msgstr ""

#: ../../reference/datamodel.rst:2889
msgid "Executing the class body"
msgstr ""

#: ../../reference/datamodel.rst:2894
msgid ""
"The class body is executed (approximately) as ``exec(body, globals(), "
"namespace)``. The key difference from a normal call to :func:`exec` is "
"that lexical scoping allows the class body (including any methods) to "
"reference names from the current and outer scopes when the class "
"definition occurs inside a function."
msgstr ""

#: ../../reference/datamodel.rst:2900
msgid ""
"However, even when the class definition occurs inside the function, "
"methods defined inside the class still cannot see names defined at the "
"class scope. Class variables must be accessed through the first parameter"
" of instance or class methods, or through the implicit lexically scoped "
"``__class__`` reference described in the next section."
msgstr ""

#: ../../reference/datamodel.rst:2909
msgid "Creating the class object"
msgstr ""

#: ../../reference/datamodel.rst:2916
msgid ""
"Once the class namespace has been populated by executing the class body, "
"the class object is created by calling ``metaclass(name, bases, "
"namespace, **kwds)`` (the additional keywords passed here are the same as"
" those passed to ``__prepare__``)."
msgstr ""

#: ../../reference/datamodel.rst:2921
msgid ""
"This class object is the one that will be referenced by the zero-argument"
" form of :func:`super`. ``__class__`` is an implicit closure reference "
"created by the compiler if any methods in a class body refer to either "
"``__class__`` or ``super``. This allows the zero argument form of "
":func:`super` to correctly identify the class being defined based on "
"lexical scoping, while the class or instance that was used to make the "
"current call is identified based on the first argument passed to the "
"method."
msgstr ""

#: ../../reference/datamodel.rst:2931
msgid ""
"In CPython 3.6 and later, the ``__class__`` cell is passed to the "
"metaclass as a ``__classcell__`` entry in the class namespace. If "
"present, this must be propagated up to the ``type.__new__`` call in order"
" for the class to be initialised correctly. Failing to do so will result "
"in a :exc:`RuntimeError` in Python 3.8."
msgstr ""

#: ../../reference/datamodel.rst:2937
msgid ""
"When using the default metaclass :class:`type`, or any metaclass that "
"ultimately calls ``type.__new__``, the following additional customization"
" steps are invoked after creating the class object:"
msgstr ""

#: ../../reference/datamodel.rst:2941
msgid ""
"The ``type.__new__`` method collects all of the attributes in the class "
"namespace that define a :meth:`~object.__set_name__` method;"
msgstr ""

#: ../../reference/datamodel.rst:2943
msgid ""
"Those ``__set_name__`` methods are called with the class being defined "
"and the assigned name of that particular attribute;"
msgstr ""

#: ../../reference/datamodel.rst:2945
msgid ""
"The :meth:`~object.__init_subclass__` hook is called on the immediate "
"parent of the new class in its method resolution order."
msgstr ""

#: ../../reference/datamodel.rst:2948
msgid ""
"After the class object is created, it is passed to the class decorators "
"included in the class definition (if any) and the resulting object is "
"bound in the local namespace as the defined class."
msgstr ""

#: ../../reference/datamodel.rst:2952
msgid ""
"When a new class is created by ``type.__new__``, the object provided as "
"the namespace parameter is copied to a new ordered mapping and the "
"original object is discarded. The new copy is wrapped in a read-only "
"proxy, which becomes the :attr:`~type.__dict__` attribute of the class "
"object."
msgstr ""

#: ../../reference/datamodel.rst:2959
msgid ":pep:`3135` - New super"
msgstr ""

#: ../../reference/datamodel.rst:2960
msgid "Describes the implicit ``__class__`` closure reference"
msgstr ""

#: ../../reference/datamodel.rst:2964
msgid "Uses for metaclasses"
msgstr ""

#: ../../reference/datamodel.rst:2966
msgid ""
"The potential uses for metaclasses are boundless. Some ideas that have "
"been explored include enum, logging, interface checking, automatic "
"delegation, automatic property creation, proxies, frameworks, and "
"automatic resource locking/synchronization."
msgstr ""

#: ../../reference/datamodel.rst:2973
msgid "Customizing instance and subclass checks"
msgstr ""

#: ../../reference/datamodel.rst:2975
msgid ""
"The following methods are used to override the default behavior of the "
":func:`isinstance` and :func:`issubclass` built-in functions."
msgstr ""

#: ../../reference/datamodel.rst:2978
msgid ""
"In particular, the metaclass :class:`abc.ABCMeta` implements these "
"methods in order to allow the addition of Abstract Base Classes (ABCs) as"
" \"virtual base classes\" to any class or type (including built-in "
"types), including other ABCs."
msgstr ""

#: ../../reference/datamodel.rst:2985
msgid ""
"Return true if *instance* should be considered a (direct or indirect) "
"instance of *class*. If defined, called to implement "
"``isinstance(instance, class)``."
msgstr ""

#: ../../reference/datamodel.rst:2992
msgid ""
"Return true if *subclass* should be considered a (direct or indirect) "
"subclass of *class*.  If defined, called to implement "
"``issubclass(subclass, class)``."
msgstr ""

#: ../../reference/datamodel.rst:2997
msgid ""
"Note that these methods are looked up on the type (metaclass) of a class."
"  They cannot be defined as class methods in the actual class.  This is "
"consistent with the lookup of special methods that are called on "
"instances, only in this case the instance is itself a class."
msgstr ""

#: ../../reference/datamodel.rst:3004
msgid ":pep:`3119` - Introducing Abstract Base Classes"
msgstr ""

#: ../../reference/datamodel.rst:3005
msgid ""
"Includes the specification for customizing :func:`isinstance` and "
":func:`issubclass` behavior through :meth:`~type.__instancecheck__` and "
":meth:`~type.__subclasscheck__`, with motivation for this functionality "
"in the context of adding Abstract Base Classes (see the :mod:`abc` "
"module) to the language."
msgstr ""

#: ../../reference/datamodel.rst:3013
msgid "Emulating generic types"
msgstr ""

#: ../../reference/datamodel.rst:3015
msgid ""
"When using :term:`type annotations<annotation>`, it is often useful to "
"*parameterize* a :term:`generic type` using Python's square-brackets "
"notation. For example, the annotation ``list[int]`` might be used to "
"signify a :class:`list` in which all the elements are of type "
":class:`int`."
msgstr ""

#: ../../reference/datamodel.rst:3022
msgid ":pep:`484` - Type Hints"
msgstr ""

#: ../../reference/datamodel.rst:3023
msgid "Introducing Python's framework for type annotations"
msgstr ""

#: ../../reference/datamodel.rst:3025
msgid ":ref:`Generic Alias Types<types-genericalias>`"
msgstr ""

#: ../../reference/datamodel.rst:3026
msgid "Documentation for objects representing parameterized generic classes"
msgstr ""

#: ../../reference/datamodel.rst:3028
msgid ""
":ref:`Generics`, :ref:`user-defined generics<user-defined-generics>` and "
":class:`typing.Generic`"
msgstr ""

#: ../../reference/datamodel.rst:3029
msgid ""
"Documentation on how to implement generic classes that can be "
"parameterized at runtime and understood by static type-checkers."
msgstr ""

#: ../../reference/datamodel.rst:3032
msgid ""
"A class can *generally* only be parameterized if it defines the special "
"class method ``__class_getitem__()``."
msgstr ""

#: ../../reference/datamodel.rst:3037
msgid ""
"Return an object representing the specialization of a generic class by "
"type arguments found in *key*."
msgstr ""

#: ../../reference/datamodel.rst:3040
msgid ""
"When defined on a class, ``__class_getitem__()`` is automatically a class"
" method. As such, there is no need for it to be decorated with "
":deco:`classmethod` when it is defined."
msgstr ""

#: ../../reference/datamodel.rst:3046
msgid "The purpose of *__class_getitem__*"
msgstr ""

#: ../../reference/datamodel.rst:3048
msgid ""
"The purpose of :meth:`~object.__class_getitem__` is to allow runtime "
"parameterization of standard-library generic classes in order to more "
"easily apply :term:`type hints<type hint>` to these classes."
msgstr ""

#: ../../reference/datamodel.rst:3052
msgid ""
"To implement custom generic classes that can be parameterized at runtime "
"and understood by static type-checkers, users should either inherit from "
"a standard library class that already implements "
":meth:`~object.__class_getitem__`, or inherit from "
":class:`typing.Generic`, which has its own implementation of "
"``__class_getitem__()``."
msgstr ""

#: ../../reference/datamodel.rst:3058
msgid ""
"Custom implementations of :meth:`~object.__class_getitem__` on classes "
"defined outside of the standard library may not be understood by third-"
"party type-checkers such as mypy. Using ``__class_getitem__()`` on any "
"class for purposes other than type hinting is discouraged."
msgstr ""

#: ../../reference/datamodel.rst:3068
msgid "*__class_getitem__* versus *__getitem__*"
msgstr ""

#: ../../reference/datamodel.rst:3070
msgid ""
"Usually, the :ref:`subscription<subscriptions>` of an object using square"
" brackets will call the :meth:`~object.__getitem__` instance method "
"defined on the object's class. However, if the object being subscribed is"
" itself a class, the class method :meth:`~object.__class_getitem__` may "
"be called instead. ``__class_getitem__()`` should return a "
":ref:`GenericAlias<types-genericalias>` object if it is properly defined."
msgstr ""

#: ../../reference/datamodel.rst:3077
msgid ""
"Presented with the :term:`expression` ``obj[x]``, the Python interpreter "
"follows something like the following process to decide whether "
":meth:`~object.__getitem__` or :meth:`~object.__class_getitem__` should "
"be called::"
msgstr ""

#: ../../reference/datamodel.rst:3082
#, python-brace-format
msgid ""
"from inspect import isclass\n"
"\n"
"def subscribe(obj, x):\n"
"    \"\"\"Return the result of the expression 'obj[x]'\"\"\"\n"
"\n"
"    class_of_obj = type(obj)\n"
"\n"
"    # If the class of obj defines __getitem__,\n"
"    # call class_of_obj.__getitem__(obj, x)\n"
"    if hasattr(class_of_obj, '__getitem__'):\n"
"        return class_of_obj.__getitem__(obj, x)\n"
"\n"
"    # Else, if obj is a class and defines __class_getitem__,\n"
"    # call obj.__class_getitem__(x)\n"
"    elif isclass(obj) and hasattr(obj, '__class_getitem__'):\n"
"        return obj.__class_getitem__(x)\n"
"\n"
"    # Else, raise an exception\n"
"    else:\n"
"        raise TypeError(\n"
"            f\"'{class_of_obj.__name__}' object is not subscriptable\"\n"
"        )"
msgstr ""

#: ../../reference/datamodel.rst:3105
msgid ""
"In Python, all classes are themselves instances of other classes. The "
"class of a class is known as that class's :term:`metaclass`, and most "
"classes have the :class:`type` class as their metaclass. :class:`type` "
"does not define :meth:`~object.__getitem__`, meaning that expressions "
"such as ``list[int]``, ``dict[str, float]`` and ``tuple[str, bytes]`` all"
" result in :meth:`~object.__class_getitem__` being called::"
msgstr ""

#: ../../reference/datamodel.rst:3112
msgid ""
">>> # list has class \"type\" as its metaclass, like most classes:\n"
">>> type(list)\n"
"<class 'type'>\n"
">>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)\n"
"True\n"
">>> # \"list[int]\" calls \"list.__class_getitem__(int)\"\n"
">>> list[int]\n"
"list[int]\n"
">>> # list.__class_getitem__ returns a GenericAlias object:\n"
">>> type(list[int])\n"
"<class 'types.GenericAlias'>"
msgstr ""

#: ../../reference/datamodel.rst:3124
msgid ""
"However, if a class has a custom metaclass that defines "
":meth:`~object.__getitem__`, subscribing the class may result in "
"different behaviour. An example of this can be found in the :mod:`enum` "
"module::"
msgstr ""

#: ../../reference/datamodel.rst:3128
msgid ""
">>> from enum import Enum\n"
">>> class Menu(Enum):\n"
"...     \"\"\"A breakfast menu\"\"\"\n"
"...     SPAM = 'spam'\n"
"...     BACON = 'bacon'\n"
"...\n"
">>> # Enum classes have a custom metaclass:\n"
">>> type(Menu)\n"
"<class 'enum.EnumMeta'>\n"
">>> # EnumMeta defines __getitem__,\n"
">>> # so __class_getitem__ is not called,\n"
">>> # and the result is not a GenericAlias object:\n"
">>> Menu['SPAM']\n"
"<Menu.SPAM: 'spam'>\n"
">>> type(Menu['SPAM'])\n"
"<enum 'Menu'>"
msgstr ""

#: ../../reference/datamodel.rst:3147
msgid ":pep:`560` - Core Support for typing module and generic types"
msgstr ""

#: ../../reference/datamodel.rst:3148
msgid ""
"Introducing :meth:`~object.__class_getitem__`, and outlining when a "
":ref:`subscription<subscriptions>` results in ``__class_getitem__()`` "
"being called instead of :meth:`~object.__getitem__`"
msgstr ""

#: ../../reference/datamodel.rst:3156
msgid "Emulating callable objects"
msgstr ""

#: ../../reference/datamodel.rst:3163
msgid ""
"Called when the instance is \"called\" as a function; if this method is "
"defined, ``x(arg1, arg2, ...)`` roughly translates to "
"``type(x).__call__(x, arg1, ...)``. The :class:`object` class itself does"
" not provide this method."
msgstr ""

#: ../../reference/datamodel.rst:3171
msgid "Emulating container types"
msgstr ""

#: ../../reference/datamodel.rst:3173
msgid ""
"The following methods can be defined to implement container objects. None"
" of them are provided by the :class:`object` class itself. Containers "
"usually are :term:`sequences <sequence>` (such as :class:`lists <list>` "
"or :class:`tuples <tuple>`) or :term:`mappings <mapping>` (like "
":term:`dictionaries <dictionary>`), but can represent other containers as"
" well.  The first set of methods is used either to emulate a sequence or "
"to emulate a mapping; the difference is that for a sequence, the "
"allowable keys should be the integers *k* for which ``0 <= k < N`` where "
"*N* is the length of the sequence, or :class:`slice` objects, which "
"define a range of items.  It is also recommended that mappings provide "
"the methods :meth:`!keys`, :meth:`!values`, :meth:`!items`, :meth:`!get`,"
" :meth:`!clear`, :meth:`!setdefault`, :meth:`!pop`, :meth:`!popitem`, "
":meth:`!copy`, and :meth:`!update` behaving similar to those for Python's"
" standard :class:`dictionary <dict>` objects.  The :mod:`collections.abc`"
" module provides a :class:`~collections.abc.MutableMapping` "
":term:`abstract base class` to help create those methods from a base set "
"of :meth:`~object.__getitem__`, :meth:`~object.__setitem__`, "
":meth:`~object.__delitem__`, and :meth:`!keys`."
msgstr ""

#: ../../reference/datamodel.rst:3192
msgid ""
"Mutable sequences should provide methods :meth:`~sequence.append`, "
":meth:`~sequence.clear`, :meth:`~sequence.count`, "
":meth:`~sequence.extend`, :meth:`~sequence.index`, "
":meth:`~sequence.insert`, :meth:`~sequence.pop`, "
":meth:`~sequence.remove`, and :meth:`~sequence.reverse`, like Python "
"standard :class:`list` objects. Finally, sequence types should implement "
"addition (meaning concatenation) and multiplication (meaning repetition) "
"by defining the methods :meth:`~object.__add__`, "
":meth:`~object.__radd__`, :meth:`~object.__iadd__`, "
":meth:`~object.__mul__`, :meth:`~object.__rmul__` and "
":meth:`~object.__imul__` described below; they should not define other "
"numerical operators."
msgstr ""

#: ../../reference/datamodel.rst:3204
msgid ""
"It is recommended that both mappings and sequences implement the "
":meth:`~object.__contains__` method to allow efficient use of the ``in`` "
"operator; for mappings, ``in`` should search the mapping's keys; for "
"sequences, it should search through the values.  It is further "
"recommended that both mappings and sequences implement the "
":meth:`~object.__iter__` method to allow efficient iteration through the "
"container; for mappings, :meth:`!__iter__` should iterate through the "
"object's keys; for sequences, it should iterate through the values."
msgstr ""

#: ../../reference/datamodel.rst:3219
msgid ""
"Called to implement the built-in function :func:`len`.  Should return the"
" length of the object, an integer ``>=`` 0.  Also, an object that doesn't"
" define a :meth:`~object.__bool__` method and whose :meth:`!__len__` "
"method returns zero is considered to be false in a Boolean context."
msgstr ""

#: ../../reference/datamodel.rst:3226
msgid ""
"In CPython, the length is required to be at most :data:`sys.maxsize`. If "
"the length is larger than :data:`!sys.maxsize` some features (such as "
":func:`len`) may raise :exc:`OverflowError`.  To prevent raising "
":exc:`!OverflowError` by truth value testing, an object must define a "
":meth:`~object.__bool__` method."
msgstr ""

#: ../../reference/datamodel.rst:3235
msgid ""
"Called to implement :func:`operator.length_hint`. Should return an "
"estimated length for the object (which may be greater or less than the "
"actual length). The length must be an integer ``>=`` 0. The return value "
"may also be :data:`NotImplemented`, which is treated the same as if the "
"``__length_hint__`` method didn't exist at all. This method is purely an "
"optimization and is never required for correctness."
msgstr ""

#: ../../reference/datamodel.rst:3247
msgid ""
"Called to implement *subscription*, that is, ``self[subscript]``. See "
":ref:`subscriptions` for details on the syntax."
msgstr ""

#: ../../reference/datamodel.rst:3250
msgid ""
"There are two types of built-in objects that support subscription via "
":meth:`!__getitem__`:"
msgstr ""

#: ../../reference/datamodel.rst:3253
msgid ""
"**sequences**, where *subscript* (also called :term:`index`) should be an"
" integer or a :class:`slice` object. See the :ref:`sequence documentation"
" <datamodel-sequences>` for the expected behavior, including handling "
":class:`slice` objects and negative indices."
msgstr ""

#: ../../reference/datamodel.rst:3257
msgid ""
"**mappings**, where *subscript* is also called the :term:`key`. See "
":ref:`mapping documentation <datamodel-mappings>` for the expected "
"behavior."
msgstr ""

#: ../../reference/datamodel.rst:3261
msgid ""
"If *subscript* is of an inappropriate type, :meth:`!__getitem__` should "
"raise :exc:`TypeError`. If *subscript* has an inappropriate value, "
":meth:`!__getitem__` should raise an :exc:`LookupError` or one of its "
"subclasses (:exc:`IndexError` for sequences; :exc:`KeyError` for "
"mappings)."
msgstr ""

#: ../../reference/datamodel.rst:3271
msgid ""
"Slicing is handled by :meth:`!__getitem__`, :meth:`~object.__setitem__`, "
"and :meth:`~object.__delitem__`. A call like ::"
msgstr ""

#: ../../reference/datamodel.rst:3275
msgid "a[1:2] = b"
msgstr ""

#: ../../reference/datamodel.rst:3277
msgid "is translated to ::"
msgstr ""

#: ../../reference/datamodel.rst:3279
msgid "a[slice(1, 2, None)] = b"
msgstr ""

#: ../../reference/datamodel.rst:3281
msgid "and so forth. Missing slice items are always filled in with ``None``."
msgstr ""

#: ../../reference/datamodel.rst:3285
msgid ""
"The sequence iteration protocol (used, for example, in :keyword:`for` "
"loops), expects that an :exc:`IndexError` will be raised for illegal "
"indexes to allow proper detection of the end of a sequence."
msgstr ""

#: ../../reference/datamodel.rst:3291
msgid ""
"When :ref:`subscripting <subscriptions>` a *class*, the special class "
"method :meth:`~object.__class_getitem__` may be called instead of "
":meth:`!__getitem__`. See :ref:`classgetitem-versus-getitem` for more "
"details."
msgstr ""

#: ../../reference/datamodel.rst:3299
msgid ""
"Called to implement assignment to ``self[key]``.  Same note as for "
":meth:`__getitem__`.  This should only be implemented for mappings if the"
" objects support changes to the values for keys, or if new keys can be "
"added, or for sequences if elements can be replaced.  The same exceptions"
" should be raised for improper *key* values as for the "
":meth:`__getitem__` method."
msgstr ""

#: ../../reference/datamodel.rst:3308
msgid ""
"Called to implement deletion of ``self[key]``.  Same note as for "
":meth:`__getitem__`.  This should only be implemented for mappings if the"
" objects support removal of keys, or for sequences if elements can be "
"removed from the sequence.  The same exceptions should be raised for "
"improper *key* values as for the :meth:`__getitem__` method."
msgstr ""

#: ../../reference/datamodel.rst:3317
msgid ""
"Called by :class:`dict`\\ .\\ :meth:`__getitem__` to implement "
"``self[key]`` for dict subclasses when key is not in the dictionary."
msgstr ""

#: ../../reference/datamodel.rst:3323
msgid ""
"This method is called when an :term:`iterator` is required for a "
"container. This method should return a new iterator object that can "
"iterate over all the objects in the container.  For mappings, it should "
"iterate over the keys of the container."
msgstr ""

#: ../../reference/datamodel.rst:3331
msgid ""
"Called (if present) by the :func:`reversed` built-in to implement reverse"
" iteration.  It should return a new iterator object that iterates over "
"all the objects in the container in reverse order."
msgstr ""

#: ../../reference/datamodel.rst:3335
msgid ""
"If the :meth:`__reversed__` method is not provided, the :func:`reversed` "
"built-in will fall back to using the sequence protocol (:meth:`__len__` "
"and :meth:`__getitem__`).  Objects that support the sequence protocol "
"should only provide :meth:`__reversed__` if they can provide an "
"implementation that is more efficient than the one provided by "
":func:`reversed`."
msgstr ""

#: ../../reference/datamodel.rst:3342
msgid ""
"The membership test operators (:keyword:`in` and :keyword:`not in`) are "
"normally implemented as an iteration through a container. However, "
"container objects can supply the following special method with a more "
"efficient implementation, which also does not require the object be "
"iterable."
msgstr ""

#: ../../reference/datamodel.rst:3349
msgid ""
"Called to implement membership test operators.  Should return true if "
"*item* is in *self*, false otherwise.  For mapping objects, this should "
"consider the keys of the mapping rather than the values or the key-item "
"pairs."
msgstr ""

#: ../../reference/datamodel.rst:3353
msgid ""
"For objects that don't define :meth:`__contains__`, the membership test "
"first tries iteration via :meth:`__iter__`, then the old sequence "
"iteration protocol via :meth:`__getitem__`, see :ref:`this section in the"
" language reference <membership-test-details>`."
msgstr ""

#: ../../reference/datamodel.rst:3362
msgid "Emulating numeric types"
msgstr ""

#: ../../reference/datamodel.rst:3364
msgid ""
"The following methods can be defined to emulate numeric objects. Methods "
"corresponding to operations that are not supported by the particular kind"
" of number implemented (e.g., bitwise operations for non-integral "
"numbers) should be left undefined."
msgstr ""

#: ../../reference/datamodel.rst:3390
msgid ""
"These methods are called to implement the binary arithmetic operations "
"(``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, "
":func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``).  For instance,"
" to evaluate the expression ``x + y``, where *x* is an instance of a "
"class that has an :meth:`__add__` method, ``type(x).__add__(x, y)`` is "
"called.  The :meth:`__divmod__` method should be the equivalent to using "
":meth:`__floordiv__` and :meth:`__mod__`; it should not be related to "
":meth:`__truediv__`.  Note that :meth:`__pow__` should be defined to "
"accept an optional third argument if the three-argument version of the "
"built-in :func:`pow` function is to be supported."
msgstr ""

#: ../../reference/datamodel.rst:3401
msgid ""
"If one of those methods does not support the operation with the supplied "
"arguments, it should return :data:`NotImplemented`."
msgstr ""

#: ../../reference/datamodel.rst:3424
msgid ""
"These methods are called to implement the binary arithmetic operations "
"(``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, "
":func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``) with reflected "
"(swapped) operands.  These functions are only called if the operands are "
"of different types, when the left operand does not support the "
"corresponding operation [#]_, or the right operand's class is derived "
"from the left operand's class. [#]_ For instance, to evaluate the "
"expression ``x - y``, where *y* is an instance of a class that has an "
":meth:`__rsub__` method, ``type(y).__rsub__(y, x)`` is called if "
"``type(x).__sub__(x, y)`` returns :data:`NotImplemented` or ``type(y)`` "
"is a subclass of ``type(x)``. [#]_"
msgstr ""

#: ../../reference/datamodel.rst:3435
msgid ""
"Note that :meth:`__rpow__` should be defined to accept an optional third "
"argument if the three-argument version of the built-in :func:`pow` "
"function is to be supported."
msgstr ""

#: ../../reference/datamodel.rst:3441
msgid ""
"Three-argument :func:`pow` now try calling :meth:`~object.__rpow__` if "
"necessary. Previously it was only called in two-argument :func:`!pow` and"
" the binary power operator."
msgstr ""

#: ../../reference/datamodel.rst:3447
msgid ""
"If the right operand's type is a subclass of the left operand's type and "
"that subclass provides a different implementation of the reflected method"
" for the operation, this method will be called before the left operand's "
"non-reflected method. This behavior allows subclasses to override their "
"ancestors' operations."
msgstr ""

#: ../../reference/datamodel.rst:3467
msgid ""
"These methods are called to implement the augmented arithmetic "
"assignments (``+=``, ``-=``, ``*=``, ``@=``, ``/=``, ``//=``, ``%=``, "
"``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``).  These methods should"
" attempt to do the operation in-place (modifying *self*) and return the "
"result (which could be, but does not have to be, *self*).  If a specific "
"method is not defined, or if that method returns :data:`NotImplemented`, "
"the augmented assignment falls back to the normal methods.  For instance,"
" if *x* is an instance of a class with an :meth:`__iadd__` method, ``x +="
" y`` is equivalent to ``x = x.__iadd__(y)`` . If :meth:`__iadd__` does "
"not exist, or if ``x.__iadd__(y)`` returns :data:`!NotImplemented`, "
"``x.__add__(y)`` and ``y.__radd__(x)`` are considered, as with the "
"evaluation of ``x + y``. In certain situations, augmented assignment can "
"result in unexpected errors (see :ref:`faq-augmented-assignment-tuple-"
"error`), but this behavior is in fact part of the data model."
msgstr ""

#: ../../reference/datamodel.rst:3490
msgid ""
"Called to implement the unary arithmetic operations (``-``, ``+``, "
":func:`abs` and ``~``)."
msgstr ""

#: ../../reference/datamodel.rst:3503
msgid ""
"Called to implement the built-in functions :func:`complex`, :func:`int` "
"and :func:`float`.  Should return a value of the appropriate type."
msgstr ""

#: ../../reference/datamodel.rst:3510
msgid ""
"Called to implement :func:`operator.index`, and whenever Python needs to "
"losslessly convert the numeric object to an integer object (such as in "
"slicing, or in the built-in :func:`bin`, :func:`hex` and :func:`oct` "
"functions). Presence of this method indicates that the numeric object is "
"an integer type.  Must return an integer."
msgstr ""

#: ../../reference/datamodel.rst:3516
msgid ""
"If :meth:`__int__`, :meth:`__float__` and :meth:`__complex__` are not "
"defined then corresponding built-in functions :func:`int`, :func:`float` "
"and :func:`complex` fall back to :meth:`__index__`."
msgstr ""

#: ../../reference/datamodel.rst:3528
msgid ""
"Called to implement the built-in function :func:`round` and :mod:`math` "
"functions :func:`~math.trunc`, :func:`~math.floor` and "
":func:`~math.ceil`. Unless *ndigits* is passed to :meth:`!__round__` all "
"these methods should return the value of the object truncated to an "
":class:`~numbers.Integral` (typically an :class:`int`)."
msgstr ""

#: ../../reference/datamodel.rst:3534
msgid ":func:`int` no longer delegates to the :meth:`~object.__trunc__` method."
msgstr ""

#: ../../reference/datamodel.rst:3541
msgid "With Statement Context Managers"
msgstr ""

#: ../../reference/datamodel.rst:3543
msgid ""
"A :dfn:`context manager` is an object that defines the runtime context to"
" be established when executing a :keyword:`with` statement. The context "
"manager handles the entry into, and the exit from, the desired runtime "
"context for the execution of the block of code.  Context managers are "
"normally invoked using the :keyword:`!with` statement (described in "
"section :ref:`with`), but can also be used by directly invoking their "
"methods."
msgstr ""

#: ../../reference/datamodel.rst:3554
msgid ""
"Typical uses of context managers include saving and restoring various "
"kinds of global state, locking and unlocking resources, closing opened "
"files, etc."
msgstr ""

#: ../../reference/datamodel.rst:3557
msgid ""
"For more information on context managers, see :ref:`typecontextmanager`. "
"The :class:`object` class itself does not provide the context manager "
"methods."
msgstr ""

#: ../../reference/datamodel.rst:3563
msgid ""
"Enter the runtime context related to this object. The :keyword:`with` "
"statement will bind this method's return value to the target(s) specified"
" in the :keyword:`!as` clause of the statement, if any."
msgstr ""

#: ../../reference/datamodel.rst:3570
msgid ""
"Exit the runtime context related to this object. The parameters describe "
"the exception that caused the context to be exited. If the context was "
"exited without an exception, all three arguments will be :const:`None`."
msgstr ""

#: ../../reference/datamodel.rst:3574
msgid ""
"If an exception is supplied, and the method wishes to suppress the "
"exception (i.e., prevent it from being propagated), it should return a "
"true value. Otherwise, the exception will be processed normally upon exit"
" from this method."
msgstr ""

#: ../../reference/datamodel.rst:3578
msgid ""
"Note that :meth:`~object.__exit__` methods should not reraise the passed-"
"in exception; this is the caller's responsibility."
msgstr ""

#: ../../reference/datamodel.rst:3584
msgid ":pep:`343` - The \"with\" statement"
msgstr ""

#: ../../reference/datamodel.rst:3585
msgid ""
"The specification, background, and examples for the Python "
":keyword:`with` statement."
msgstr ""

#: ../../reference/datamodel.rst:3592
msgid "Customizing positional arguments in class pattern matching"
msgstr ""

#: ../../reference/datamodel.rst:3594
msgid ""
"When using a class name in a pattern, positional arguments in the pattern"
" are not allowed by default, i.e. ``case MyClass(x, y)`` is typically "
"invalid without special support in ``MyClass``. To be able to use that "
"kind of pattern, the class needs to define a *__match_args__* attribute."
msgstr ""

#: ../../reference/datamodel.rst:3601
msgid ""
"This class variable can be assigned a tuple of strings. When this class "
"is used in a class pattern with positional arguments, each positional "
"argument will be converted into a keyword argument, using the "
"corresponding value in *__match_args__* as the keyword. The absence of "
"this attribute is equivalent to setting it to ``()``."
msgstr ""

#: ../../reference/datamodel.rst:3607
msgid ""
"For example, if ``MyClass.__match_args__`` is ``(\"left\", \"center\", "
"\"right\")`` that means that ``case MyClass(x, y)`` is equivalent to "
"``case MyClass(left=x, center=y)``. Note that the number of arguments in "
"the pattern must be smaller than or equal to the number of elements in "
"*__match_args__*; if it is larger, the pattern match attempt will raise a"
" :exc:`TypeError`."
msgstr ""

#: ../../reference/datamodel.rst:3617
msgid ":pep:`634` - Structural Pattern Matching"
msgstr ""

#: ../../reference/datamodel.rst:3618
msgid "The specification for the Python ``match`` statement."
msgstr ""

#: ../../reference/datamodel.rst:3624
msgid "Emulating buffer types"
msgstr ""

#: ../../reference/datamodel.rst:3626
msgid ""
"The :ref:`buffer protocol <bufferobjects>` provides a way for Python "
"objects to expose efficient access to a low-level memory array. This "
"protocol is implemented by builtin types such as :class:`bytes` and "
":class:`memoryview`, and third-party libraries may define additional "
"buffer types."
msgstr ""

#: ../../reference/datamodel.rst:3631
msgid ""
"While buffer types are usually implemented in C, it is also possible to "
"implement the protocol in Python."
msgstr ""

#: ../../reference/datamodel.rst:3636
msgid ""
"Called when a buffer is requested from *self* (for example, by the "
":class:`memoryview` constructor). The *flags* argument is an integer "
"representing the kind of buffer requested, affecting for example whether "
"the returned buffer is read-only or writable. "
":class:`inspect.BufferFlags` provides a convenient way to interpret the "
"flags. The method must return a :class:`memoryview` object."
msgstr ""

#: ../../reference/datamodel.rst:3643
msgid ""
"**Thread safety:** In :term:`free-threaded <free threading>` Python, "
"implementations must manage any internal export counter using atomic "
"operations. The method must be safe to call concurrently from multiple "
"threads, and the returned buffer's underlying data must remain valid "
"until the corresponding :meth:`~object.__release_buffer__` call "
"completes. See :ref:`thread-safety-memoryview` for details."
msgstr ""

#: ../../reference/datamodel.rst:3652
msgid ""
"Called when a buffer is no longer needed. The *buffer* argument is a "
":class:`memoryview` object that was previously returned by "
":meth:`~object.__buffer__`. The method must release any resources "
"associated with the buffer. This method should return ``None``."
msgstr ""

#: ../../reference/datamodel.rst:3657
msgid ""
"**Thread safety:** In :term:`free-threaded <free threading>` Python, any "
"export counter decrement must use atomic operations. Resource cleanup "
"must be thread-safe, as the final release may race with concurrent "
"releases from other threads."
msgstr ""

#: ../../reference/datamodel.rst:3662
msgid ""
"Buffer objects that do not need to perform any cleanup are not required "
"to implement this method."
msgstr ""

#: ../../reference/datamodel.rst:3669
msgid ":pep:`688` - Making the buffer protocol accessible in Python"
msgstr ""

#: ../../reference/datamodel.rst:3670
msgid "Introduces the Python ``__buffer__`` and ``__release_buffer__`` methods."
msgstr ""

#: ../../reference/datamodel.rst:3672
msgid ":class:`collections.abc.Buffer`"
msgstr ""

#: ../../reference/datamodel.rst:3673
msgid "ABC for buffer types."
msgstr ""

#: ../../reference/datamodel.rst:3676
msgid "Annotations"
msgstr ""

#: ../../reference/datamodel.rst:3678
msgid ""
"Functions, classes, and modules may contain :term:`annotations "
"<annotation>`, which are a way to associate information (usually "
":term:`type hints <type hint>`) with a symbol."
msgstr ""

#: ../../reference/datamodel.rst:3684
msgid ""
"This attribute contains the annotations for an object. It is :ref:`lazily"
" evaluated <lazy-evaluation>`, so accessing the attribute may execute "
"arbitrary code and raise exceptions. If evaluation is successful, the "
"attribute is set to a dictionary mapping from variable names to "
"annotations."
msgstr ""

#: ../../reference/datamodel.rst:3689
msgid "Annotations are now lazily evaluated."
msgstr ""

#: ../../reference/datamodel.rst:3694
msgid ""
"An :term:`annotate function`. Returns a new dictionary object mapping "
"attribute/parameter names to their annotation values."
msgstr ""

#: ../../reference/datamodel.rst:3697
msgid ""
"Takes a format parameter specifying the format in which annotations "
"values should be provided. It must be a member of the "
":class:`annotationlib.Format` enum, or an integer with a value "
"corresponding to a member of the enum."
msgstr ""

#: ../../reference/datamodel.rst:3701
msgid ""
"If an annotate function doesn't support the requested format, it must "
"raise :exc:`NotImplementedError`. Annotate functions must always support "
":attr:`~annotationlib.Format.VALUE` format; they must not raise "
":exc:`NotImplementedError()` when called with this format."
msgstr ""

#: ../../reference/datamodel.rst:3706
msgid ""
"When called with  :attr:`~annotationlib.Format.VALUE` format, an annotate"
" function may raise :exc:`NameError`; it must not raise :exc:`!NameError`"
" when called requesting any other format."
msgstr ""

#: ../../reference/datamodel.rst:3709
msgid ""
"If an object does not have any annotations, :attr:`~object.__annotate__` "
"should preferably be set to ``None`` (it can’t be deleted), rather than "
"set to a function that returns an empty dict."
msgstr ""

#: ../../reference/datamodel.rst:3716
msgid ":pep:`649` --- Deferred evaluation of annotation using descriptors"
msgstr ""

#: ../../reference/datamodel.rst:3717
msgid ""
"Introduces lazy evaluation of annotations and the ``__annotate__`` "
"function."
msgstr ""

#: ../../reference/datamodel.rst:3723
msgid "Special method lookup"
msgstr ""

#: ../../reference/datamodel.rst:3725
msgid ""
"For custom classes, implicit invocations of special methods are only "
"guaranteed to work correctly if defined on an object's type, not in the "
"object's instance dictionary.  That behaviour is the reason why the "
"following code raises an exception::"
msgstr ""

#: ../../reference/datamodel.rst:3730
msgid ""
">>> class C:\n"
"...     pass\n"
"...\n"
">>> c = C()\n"
">>> c.__len__ = lambda: 5\n"
">>> len(c)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: object of type 'C' has no len()"
msgstr ""

#: ../../reference/datamodel.rst:3740
msgid ""
"The rationale behind this behaviour lies with a number of special methods"
" such as :meth:`~object.__hash__` and :meth:`~object.__repr__` that are "
"implemented by all objects, including type objects. If the implicit "
"lookup of these methods used the conventional lookup process, they would "
"fail when invoked on the type object itself::"
msgstr ""

#: ../../reference/datamodel.rst:3747
msgid ""
">>> 1 .__hash__() == hash(1)\n"
"True\n"
">>> int.__hash__() == hash(int)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: descriptor '__hash__' of 'int' object needs an argument"
msgstr ""

#: ../../reference/datamodel.rst:3754
msgid ""
"Incorrectly attempting to invoke an unbound method of a class in this way"
" is sometimes referred to as 'metaclass confusion', and is avoided by "
"bypassing the instance when looking up special methods::"
msgstr ""

#: ../../reference/datamodel.rst:3758
msgid ""
">>> type(1).__hash__(1) == hash(1)\n"
"True\n"
">>> type(int).__hash__(int) == hash(int)\n"
"True"
msgstr ""

#: ../../reference/datamodel.rst:3763
msgid ""
"In addition to bypassing any instance attributes in the interest of "
"correctness, implicit special method lookup generally also bypasses the "
":meth:`~object.__getattribute__` method even of the object's metaclass::"
msgstr ""

#: ../../reference/datamodel.rst:3767
msgid ""
">>> class Meta(type):\n"
"...     def __getattribute__(*args):\n"
"...         print(\"Metaclass getattribute invoked\")\n"
"...         return type.__getattribute__(*args)\n"
"...\n"
">>> class C(object, metaclass=Meta):\n"
"...     def __len__(self):\n"
"...         return 10\n"
"...     def __getattribute__(*args):\n"
"...         print(\"Class getattribute invoked\")\n"
"...         return object.__getattribute__(*args)\n"
"...\n"
">>> c = C()\n"
">>> c.__len__()                 # Explicit lookup via instance\n"
"Class getattribute invoked\n"
"10\n"
">>> type(c).__len__(c)          # Explicit lookup via type\n"
"Metaclass getattribute invoked\n"
"10\n"
">>> len(c)                      # Implicit lookup\n"
"10"
msgstr ""

#: ../../reference/datamodel.rst:3789
msgid ""
"Bypassing the :meth:`~object.__getattribute__` machinery in this fashion "
"provides significant scope for speed optimisations within the "
"interpreter, at the cost of some flexibility in the handling of special "
"methods (the special method *must* be set on the class object itself in "
"order to be consistently invoked by the interpreter)."
msgstr ""

#: ../../reference/datamodel.rst:3800
msgid "Coroutines"
msgstr ""

#: ../../reference/datamodel.rst:3804
msgid "Awaitable Objects"
msgstr ""

#: ../../reference/datamodel.rst:3806
msgid ""
"An :term:`awaitable` object generally implements an "
":meth:`~object.__await__` method. :term:`Coroutine objects <coroutine>` "
"returned from :keyword:`async def` functions are awaitable."
msgstr ""

#: ../../reference/datamodel.rst:3812
msgid ""
"The :term:`generator iterator` objects returned from generators decorated"
" with :func:`types.coroutine` are also awaitable, but they do not "
"implement :meth:`~object.__await__`."
msgstr ""

#: ../../reference/datamodel.rst:3818
msgid ""
"Must return an :term:`iterator`.  Should be used to implement "
":term:`awaitable` objects.  For instance, :class:`asyncio.Future` "
"implements this method to be compatible with the :keyword:`await` "
"expression. The :class:`object` class itself is not awaitable and does "
"not provide this method."
msgstr ""

#: ../../reference/datamodel.rst:3826
msgid ""
"The language doesn't place any restriction on the type or value of the "
"objects yielded by the iterator returned by ``__await__``, as this is "
"specific to the implementation of the asynchronous execution framework "
"(e.g. :mod:`asyncio`) that will be managing the :term:`awaitable` object."
msgstr ""

#: ../../reference/datamodel.rst:3834
msgid ":pep:`492` for additional information about awaitable objects."
msgstr ""

#: ../../reference/datamodel.rst:3840
msgid "Coroutine Objects"
msgstr ""

#: ../../reference/datamodel.rst:3842
msgid ""
":term:`Coroutine objects <coroutine>` are :term:`awaitable` objects. A "
"coroutine's execution can be controlled by calling "
":meth:`~object.__await__` and iterating over the result.  When the "
"coroutine has finished executing and returns, the iterator raises "
":exc:`StopIteration`, and the exception's :attr:`~StopIteration.value` "
"attribute holds the return value.  If the coroutine raises an exception, "
"it is propagated by the iterator.  Coroutines should not directly raise "
"unhandled :exc:`StopIteration` exceptions."
msgstr ""

#: ../../reference/datamodel.rst:3850
msgid ""
"Coroutines also have the methods listed below, which are analogous to "
"those of generators (see :ref:`generator-methods`).  However, unlike "
"generators, coroutines do not directly support iteration."
msgstr ""

#: ../../reference/datamodel.rst:3854
msgid "It is a :exc:`RuntimeError` to await on a coroutine more than once."
msgstr ""

#: ../../reference/datamodel.rst:3860
msgid ""
"Starts or resumes execution of the coroutine.  If *value* is ``None``, "
"this is equivalent to advancing the iterator returned by "
":meth:`~object.__await__`.  If *value* is not ``None``, this method "
"delegates to the :meth:`~generator.send` method of the iterator that "
"caused the coroutine to suspend.  The result (return value, "
":exc:`StopIteration`, or other exception) is the same as when iterating "
"over the :meth:`!__await__` return value, described above."
msgstr ""

#: ../../reference/datamodel.rst:3871
msgid ""
"Raises the specified exception in the coroutine.  This method delegates "
"to the :meth:`~generator.throw` method of the iterator that caused the "
"coroutine to suspend, if it has such a method.  Otherwise, the exception "
"is raised at the suspension point.  The result (return value, "
":exc:`StopIteration`, or other exception) is the same as when iterating "
"over the :meth:`~object.__await__` return value, described above.  If the"
" exception is not caught in the coroutine, it propagates back to the "
"caller."
msgstr ""

#: ../../reference/datamodel.rst:3882
msgid ""
"The second signature \\(type\\[, value\\[, traceback\\]\\]\\) is "
"deprecated and may be removed in a future version of Python."
msgstr ""

#: ../../reference/datamodel.rst:3887
msgid ""
"Causes the coroutine to clean itself up and exit.  If the coroutine is "
"suspended, this method first delegates to the :meth:`~generator.close` "
"method of the iterator that caused the coroutine to suspend, if it has "
"such a method.  Then it raises :exc:`GeneratorExit` at the suspension "
"point, causing the coroutine to immediately clean itself up. Finally, the"
" coroutine is marked as having finished executing, even if it was never "
"started."
msgstr ""

#: ../../reference/datamodel.rst:3895
msgid ""
"Coroutine objects are automatically closed using the above process when "
"they are about to be destroyed."
msgstr ""

#: ../../reference/datamodel.rst:3901
msgid "Asynchronous Iterators"
msgstr ""

#: ../../reference/datamodel.rst:3903
msgid ""
"An *asynchronous iterator* can call asynchronous code in its "
"``__anext__`` method."
msgstr ""

#: ../../reference/datamodel.rst:3906
msgid "Asynchronous iterators can be used in an :keyword:`async for` statement."
msgstr ""

#: ../../reference/datamodel.rst:3908 ../../reference/datamodel.rst:3957
msgid "The :class:`object` class itself does not provide these methods."
msgstr ""

#: ../../reference/datamodel.rst:3913
msgid "Must return an *asynchronous iterator* object."
msgstr ""

#: ../../reference/datamodel.rst:3917
msgid ""
"Must return an *awaitable* resulting in a next value of the iterator.  "
"Should raise a :exc:`StopAsyncIteration` error when the iteration is "
"over."
msgstr ""

#: ../../reference/datamodel.rst:3920
msgid "An example of an asynchronous iterable object::"
msgstr ""

#: ../../reference/datamodel.rst:3922
msgid ""
"class Reader:\n"
"    async def readline(self):\n"
"        ...\n"
"\n"
"    def __aiter__(self):\n"
"        return self\n"
"\n"
"    async def __anext__(self):\n"
"        val = await self.readline()\n"
"        if val == b'':\n"
"            raise StopAsyncIteration\n"
"        return val"
msgstr ""

#: ../../reference/datamodel.rst:3937
msgid ""
"Prior to Python 3.7, :meth:`~object.__aiter__` could return an "
"*awaitable* that would resolve to an :term:`asynchronous iterator "
"<asynchronous iterator>`."
msgstr ""

#: ../../reference/datamodel.rst:3942
msgid ""
"Starting with Python 3.7, :meth:`~object.__aiter__` must return an "
"asynchronous iterator object.  Returning anything else will result in a "
":exc:`TypeError` error."
msgstr ""

#: ../../reference/datamodel.rst:3950
msgid "Asynchronous Context Managers"
msgstr ""

#: ../../reference/datamodel.rst:3952
msgid ""
"An *asynchronous context manager* is a *context manager* that is able to "
"suspend execution in its ``__aenter__`` and ``__aexit__`` methods."
msgstr ""

#: ../../reference/datamodel.rst:3955
msgid ""
"Asynchronous context managers can be used in an :keyword:`async with` "
"statement."
msgstr ""

#: ../../reference/datamodel.rst:3961
msgid ""
"Semantically similar to :meth:`~object.__enter__`, the only difference "
"being that it must return an *awaitable*."
msgstr ""

#: ../../reference/datamodel.rst:3966
msgid ""
"Semantically similar to :meth:`~object.__exit__`, the only difference "
"being that it must return an *awaitable*."
msgstr ""

#: ../../reference/datamodel.rst:3969
msgid "An example of an asynchronous context manager class::"
msgstr ""

#: ../../reference/datamodel.rst:3971
msgid ""
"class AsyncContextManager:\n"
"    async def __aenter__(self):\n"
"        await log('entering context')\n"
"\n"
"    async def __aexit__(self, exc_type, exc, tb):\n"
"        await log('exiting context')"
msgstr ""

#: ../../reference/datamodel.rst:3982
msgid "Footnotes"
msgstr ""

#: ../../reference/datamodel.rst:3983
msgid ""
"It *is* possible in some cases to change an object's type, under certain "
"controlled conditions. It generally isn't a good idea though, since it "
"can lead to some very strange behaviour if it is handled incorrectly."
msgstr ""

#: ../../reference/datamodel.rst:3987
msgid ""
"The :meth:`~object.__hash__`, :meth:`~object.__iter__`, "
":meth:`~object.__reversed__`, :meth:`~object.__contains__`, "
":meth:`~object.__class_getitem__` and :meth:`~os.PathLike.__fspath__` "
"methods have special handling for this. Others will still raise a "
":exc:`TypeError`, but may do so by relying on the behavior that ``None`` "
"is not callable."
msgstr ""

#: ../../reference/datamodel.rst:3994
msgid ""
"\"Does not support\" here means that the class has no such method, or the"
" method returns :data:`NotImplemented`.  Do not set the method to "
"``None`` if you want to force fallback to the right operand's reflected "
"method—that will instead have the opposite effect of explicitly "
"*blocking* such fallback."
msgstr ""

#: ../../reference/datamodel.rst:4000
msgid ""
"For operands of the same type, it is assumed that if the non-reflected "
"method (such as :meth:`~object.__add__`) fails then the operation is not "
"supported, which is why the reflected method is not called."
msgstr ""

#: ../../reference/datamodel.rst:4004
msgid ""
"If the right operand's type is a subclass of the left operand's type, the"
" reflected method having precedence allows subclasses to override their "
"ancestors' operations."
msgstr ""

#: ../../reference/datamodel.rst:14 ../../reference/datamodel.rst:148
#: ../../reference/datamodel.rst:159 ../../reference/datamodel.rst:183
#: ../../reference/datamodel.rst:195 ../../reference/datamodel.rst:228
#: ../../reference/datamodel.rst:249 ../../reference/datamodel.rst:266
#: ../../reference/datamodel.rst:284 ../../reference/datamodel.rst:298
#: ../../reference/datamodel.rst:343 ../../reference/datamodel.rst:383
#: ../../reference/datamodel.rst:408 ../../reference/datamodel.rst:429
#: ../../reference/datamodel.rst:447 ../../reference/datamodel.rst:467
#: ../../reference/datamodel.rst:475 ../../reference/datamodel.rst:488
#: ../../reference/datamodel.rst:505 ../../reference/datamodel.rst:541
#: ../../reference/datamodel.rst:556 ../../reference/datamodel.rst:701
#: ../../reference/datamodel.rst:839 ../../reference/datamodel.rst:863
#: ../../reference/datamodel.rst:899 ../../reference/datamodel.rst:1177
#: ../../reference/datamodel.rst:1345 ../../reference/datamodel.rst:1372
#: ../../reference/datamodel.rst:1460 ../../reference/datamodel.rst:1568
#: ../../reference/datamodel.rst:1676 ../../reference/datamodel.rst:1793
#: ../../reference/datamodel.rst:2218 ../../reference/datamodel.rst:3267
msgid "object"
msgstr ""

#: ../../reference/datamodel.rst:14 ../../reference/datamodel.rst:122
msgid "data"
msgstr ""

#: ../../reference/datamodel.rst:22 ../../reference/datamodel.rst:298
#: ../../reference/datamodel.rst:358 ../../reference/datamodel.rst:447
#: ../../reference/datamodel.rst:488 ../../reference/datamodel.rst:839
#: ../../reference/datamodel.rst:1401 ../../reference/datamodel.rst:1876
#: ../../reference/datamodel.rst:2119 ../../reference/datamodel.rst:2125
#: ../../reference/datamodel.rst:2218 ../../reference/datamodel.rst:2780
#: ../../reference/datamodel.rst:3215 ../../reference/datamodel.rst:3385
#: ../../reference/datamodel.rst:3420 ../../reference/datamodel.rst:3488
#: ../../reference/datamodel.rst:3498 ../../reference/datamodel.rst:3526
msgid "built-in function"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "id"
msgstr ""

#: ../../reference/datamodel.rst:22 ../../reference/datamodel.rst:122
#: ../../reference/datamodel.rst:2780
msgid "type"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "identity of an object"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "value of an object"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "type of an object"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "mutable object"
msgstr ""

#: ../../reference/datamodel.rst:22
msgid "immutable object"
msgstr ""

#: ../../reference/datamodel.rst:56
msgid "garbage collection"
msgstr ""

#: ../../reference/datamodel.rst:56
msgid "reference counting"
msgstr ""

#: ../../reference/datamodel.rst:56
msgid "unreachable object"
msgstr ""

#: ../../reference/datamodel.rst:91 ../../reference/datamodel.rst:1177
msgid "container"
msgstr ""

#: ../../reference/datamodel.rst:122
msgid "hierarchy"
msgstr ""

#: ../../reference/datamodel.rst:122
msgid "extension"
msgstr ""

#: ../../reference/datamodel.rst:122 ../../reference/datamodel.rst:420
#: ../../reference/datamodel.rst:421 ../../reference/datamodel.rst:524
#: ../../reference/datamodel.rst:899 ../../reference/datamodel.rst:919
#: ../../reference/datamodel.rst:1401
msgid "module"
msgstr ""

#: ../../reference/datamodel.rst:122 ../../reference/datamodel.rst:266
#: ../../reference/datamodel.rst:839
msgid "C"
msgstr ""

#: ../../reference/datamodel.rst:122 ../../reference/datamodel.rst:266
#: ../../reference/datamodel.rst:839
msgid "language"
msgstr ""

#: ../../reference/datamodel.rst:135 ../../reference/datamodel.rst:1177
#: ../../reference/datamodel.rst:1195 ../../reference/datamodel.rst:1345
#: ../../reference/datamodel.rst:1365
msgid "attribute"
msgstr ""

#: ../../reference/datamodel.rst:135
msgid "special"
msgstr ""

#: ../../reference/datamodel.rst:135
msgid "generic"
msgstr ""

#: ../../reference/datamodel.rst:183
msgid "..."
msgstr ""

#: ../../reference/datamodel.rst:183
msgid "ellipsis literal"
msgstr ""

#: ../../reference/datamodel.rst:195 ../../reference/datamodel.rst:1372
msgid "numeric"
msgstr ""

#: ../../reference/datamodel.rst:228 ../../reference/datamodel.rst:234
msgid "integer"
msgstr ""

#: ../../reference/datamodel.rst:234
msgid "representation"
msgstr ""

#: ../../reference/datamodel.rst:249
msgid "Boolean"
msgstr ""

#: ../../reference/datamodel.rst:249
msgid "False"
msgstr ""

#: ../../reference/datamodel.rst:249
msgid "True"
msgstr ""

#: ../../reference/datamodel.rst:266
msgid "floating-point"
msgstr ""

#: ../../reference/datamodel.rst:266 ../../reference/datamodel.rst:284
msgid "number"
msgstr ""

#: ../../reference/datamodel.rst:266
msgid "Java"
msgstr ""

#: ../../reference/datamodel.rst:284 ../../reference/datamodel.rst:3498
msgid "complex"
msgstr ""

#: ../../reference/datamodel.rst:298 ../../reference/datamodel.rst:447
#: ../../reference/datamodel.rst:488 ../../reference/datamodel.rst:3215
msgid "len"
msgstr ""

#: ../../reference/datamodel.rst:298 ../../reference/datamodel.rst:1372
msgid "sequence"
msgstr ""

#: ../../reference/datamodel.rst:298
msgid "index operation"
msgstr ""

#: ../../reference/datamodel.rst:298
msgid "item selection"
msgstr ""

#: ../../reference/datamodel.rst:298 ../../reference/datamodel.rst:408
#: ../../reference/datamodel.rst:488
msgid "subscription"
msgstr ""

#: ../../reference/datamodel.rst:316 ../../reference/datamodel.rst:408
msgid "slicing"
msgstr ""

#: ../../reference/datamodel.rst:316 ../../reference/datamodel.rst:1882
msgid "start (slice object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:316 ../../reference/datamodel.rst:1882
msgid "stop (slice object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:316 ../../reference/datamodel.rst:1882
msgid "step (slice object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:343
msgid "immutable sequence"
msgstr ""

#: ../../reference/datamodel.rst:343
msgid "immutable"
msgstr ""

#: ../../reference/datamodel.rst:354 ../../reference/datamodel.rst:358
#: ../../reference/datamodel.rst:2094 ../../reference/datamodel.rst:2125
msgid "string"
msgstr ""

#: ../../reference/datamodel.rst:354
msgid "immutable sequences"
msgstr ""

#: ../../reference/datamodel.rst:358
msgid "chr"
msgstr ""

#: ../../reference/datamodel.rst:358
msgid "ord"
msgstr ""

#: ../../reference/datamodel.rst:358
msgid "character"
msgstr ""

#: ../../reference/datamodel.rst:358
msgid "item"
msgstr ""

#: ../../reference/datamodel.rst:358
msgid "Unicode"
msgstr ""

#: ../../reference/datamodel.rst:383
msgid "tuple"
msgstr ""

#: ../../reference/datamodel.rst:383
msgid "singleton"
msgstr ""

#: ../../reference/datamodel.rst:383
msgid "empty"
msgstr ""

#: ../../reference/datamodel.rst:396 ../../reference/datamodel.rst:2119
msgid "bytes"
msgstr ""

#: ../../reference/datamodel.rst:396
msgid "byte"
msgstr ""

#: ../../reference/datamodel.rst:408
msgid "mutable sequence"
msgstr ""

#: ../../reference/datamodel.rst:408
msgid "mutable"
msgstr ""

#: ../../reference/datamodel.rst:408 ../../reference/datamodel.rst:1195
#: ../../reference/datamodel.rst:1365
msgid "assignment"
msgstr ""

#: ../../reference/datamodel.rst:408 ../../reference/datamodel.rst:899
#: ../../reference/datamodel.rst:1830 ../../reference/datamodel.rst:2012
#: ../../reference/datamodel.rst:3550
msgid "statement"
msgstr ""

#: ../../reference/datamodel.rst:420
msgid "array"
msgstr ""

#: ../../reference/datamodel.rst:421
msgid "collections"
msgstr ""

#: ../../reference/datamodel.rst:429
msgid "list"
msgstr ""

#: ../../reference/datamodel.rst:436
msgid "bytearray"
msgstr ""

#: ../../reference/datamodel.rst:447
msgid "set type"
msgstr ""

#: ../../reference/datamodel.rst:467
msgid "set"
msgstr ""

#: ../../reference/datamodel.rst:475
msgid "frozenset"
msgstr ""

#: ../../reference/datamodel.rst:488 ../../reference/datamodel.rst:1372
msgid "mapping"
msgstr ""

#: ../../reference/datamodel.rst:505 ../../reference/datamodel.rst:1177
#: ../../reference/datamodel.rst:2218
msgid "dictionary"
msgstr ""

#: ../../reference/datamodel.rst:524
msgid "dbm.ndbm"
msgstr ""

#: ../../reference/datamodel.rst:524
msgid "dbm.gnu"
msgstr ""

#: ../../reference/datamodel.rst:541
msgid "callable"
msgstr ""

#: ../../reference/datamodel.rst:541 ../../reference/datamodel.rst:556
#: ../../reference/datamodel.rst:783 ../../reference/datamodel.rst:801
#: ../../reference/datamodel.rst:814 ../../reference/datamodel.rst:839
msgid "function"
msgstr ""

#: ../../reference/datamodel.rst:541 ../../reference/datamodel.rst:1177
#: ../../reference/datamodel.rst:1200 ../../reference/datamodel.rst:3161
msgid "call"
msgstr ""

#: ../../reference/datamodel.rst:541
msgid "invocation"
msgstr ""

#: ../../reference/datamodel.rst:541
msgid "argument"
msgstr ""

#: ../../reference/datamodel.rst:556 ../../reference/datamodel.rst:701
msgid "user-defined"
msgstr ""

#: ../../reference/datamodel.rst:556
msgid "user-defined function"
msgstr ""

#: ../../reference/datamodel.rst:569
msgid "__builtins__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:569
msgid "__closure__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:569
msgid "__globals__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:569
msgid "global"
msgstr ""

#: ../../reference/datamodel.rst:569 ../../reference/datamodel.rst:919
msgid "namespace"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__doc__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__name__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__module__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__dict__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__defaults__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__code__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__annotations__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__annotate__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__kwdefaults__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:603
msgid "__type_params__ (function attribute)"
msgstr ""

#: ../../reference/datamodel.rst:701 ../../reference/datamodel.rst:863
msgid "method"
msgstr ""

#: ../../reference/datamodel.rst:701
msgid "user-defined method"
msgstr ""

#: ../../reference/datamodel.rst:709
msgid "__func__ (method attribute)"
msgstr ""

#: ../../reference/datamodel.rst:709
msgid "__self__ (method attribute)"
msgstr ""

#: ../../reference/datamodel.rst:709
msgid "__doc__ (method attribute)"
msgstr ""

#: ../../reference/datamodel.rst:709
msgid "__name__ (method attribute)"
msgstr ""

#: ../../reference/datamodel.rst:709
msgid "__module__ (method attribute)"
msgstr ""

#: ../../reference/datamodel.rst:783 ../../reference/datamodel.rst:1568
msgid "generator"
msgstr ""

#: ../../reference/datamodel.rst:783
msgid "iterator"
msgstr ""

#: ../../reference/datamodel.rst:801 ../../reference/datamodel.rst:3796
msgid "coroutine"
msgstr ""

#: ../../reference/datamodel.rst:814
msgid "asynchronous generator"
msgstr ""

#: ../../reference/datamodel.rst:814
msgid "asynchronous iterator"
msgstr ""

#: ../../reference/datamodel.rst:863
msgid "built-in method"
msgstr ""

#: ../../reference/datamodel.rst:863
msgid "built-in"
msgstr ""

#: ../../reference/datamodel.rst:899
msgid "import"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__name__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__spec__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__package__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__loader__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__path__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__file__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__cached__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__doc__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__annotations__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:919
msgid "__annotate__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1145
msgid "__dict__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1177 ../../reference/datamodel.rst:1195
#: ../../reference/datamodel.rst:1345 ../../reference/datamodel.rst:1995
#: ../../reference/datamodel.rst:2891
msgid "class"
msgstr ""

#: ../../reference/datamodel.rst:1177 ../../reference/datamodel.rst:1345
#: ../../reference/datamodel.rst:1365
msgid "class instance"
msgstr ""

#: ../../reference/datamodel.rst:1177 ../../reference/datamodel.rst:1345
#: ../../reference/datamodel.rst:3161
msgid "instance"
msgstr ""

#: ../../reference/datamodel.rst:1177 ../../reference/datamodel.rst:1200
msgid "class object"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__name__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__module__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__dict__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__bases__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__base__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__doc__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__annotations__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__annotate__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__type_params__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__static_attributes__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1207
msgid "__firstlineno__ (class attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1383
msgid "__dict__ (instance attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1383
msgid "__class__ (instance attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "open"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "io"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "popen() (in module os)"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "makefile() (socket method)"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "sys.stdin"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "sys.stdout"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "sys.stderr"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "stdio"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "stdin (in module sys)"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "stdout (in module sys)"
msgstr ""

#: ../../reference/datamodel.rst:1401
msgid "stderr (in module sys)"
msgstr ""

#: ../../reference/datamodel.rst:1446
msgid "internal type"
msgstr ""

#: ../../reference/datamodel.rst:1446
msgid "types, internal"
msgstr ""

#: ../../reference/datamodel.rst:1460
msgid "bytecode"
msgstr ""

#: ../../reference/datamodel.rst:1460
msgid "code"
msgstr ""

#: ../../reference/datamodel.rst:1460
msgid "code object"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_argcount (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_posonlyargcount (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_kwonlyargcount (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_code (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_consts (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_filename (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_firstlineno (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_flags (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_lnotab (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_name (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_names (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_nlocals (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_stacksize (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_varnames (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_cellvars (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_freevars (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1471
msgid "co_qualname (code object attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1584
msgid "documentation string"
msgstr ""

#: ../../reference/datamodel.rst:1676
msgid "frame"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_back (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_code (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_globals (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_locals (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_lasti (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_builtins (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1682
msgid "f_generator (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1733
msgid "f_trace (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1733
msgid "f_trace_lines (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1733
msgid "f_trace_opcodes (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1733
msgid "f_lineno (frame attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "traceback"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "stack"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "trace"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "exception"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "handler"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "execution"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "exc_info (in module sys)"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "last_traceback (in module sys)"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "sys.exc_info"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "sys.exception"
msgstr ""

#: ../../reference/datamodel.rst:1793
msgid "sys.last_traceback"
msgstr ""

#: ../../reference/datamodel.rst:1830
msgid "tb_frame (traceback attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1830
msgid "tb_lineno (traceback attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1830
msgid "tb_lasti (traceback attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1830
msgid "try"
msgstr ""

#: ../../reference/datamodel.rst:1860
msgid "tb_next (traceback attribute)"
msgstr ""

#: ../../reference/datamodel.rst:1876 ../../reference/datamodel.rst:3267
msgid "slice"
msgstr ""

#: ../../reference/datamodel.rst:1930
msgid "operator"
msgstr ""

#: ../../reference/datamodel.rst:1930
msgid "overloading"
msgstr ""

#: ../../reference/datamodel.rst:1930
msgid "__getitem__() (mapping object method)"
msgstr ""

#: ../../reference/datamodel.rst:1966
msgid "subclassing"
msgstr ""

#: ../../reference/datamodel.rst:1966
msgid "immutable types"
msgstr ""

#: ../../reference/datamodel.rst:1995
msgid "constructor"
msgstr ""

#: ../../reference/datamodel.rst:2012
msgid "destructor"
msgstr ""

#: ../../reference/datamodel.rst:2012
msgid "finalizer"
msgstr ""

#: ../../reference/datamodel.rst:2012
msgid "del"
msgstr ""

#: ../../reference/datamodel.rst:2076
msgid "repr() (built-in function)"
msgstr ""

#: ../../reference/datamodel.rst:2076
msgid "__repr__() (object method)"
msgstr ""

#: ../../reference/datamodel.rst:2094
msgid "__str__() (object method)"
msgstr ""

#: ../../reference/datamodel.rst:2094
msgid "format() (built-in function)"
msgstr ""

#: ../../reference/datamodel.rst:2094
msgid "print() (built-in function)"
msgstr ""

#: ../../reference/datamodel.rst:2125
msgid "__format__() (object method)"
msgstr ""

#: ../../reference/datamodel.rst:2125
msgid "conversion"
msgstr ""

#: ../../reference/datamodel.rst:2125
msgid "print"
msgstr ""

#: ../../reference/datamodel.rst:2167
msgid "comparisons"
msgstr ""

#: ../../reference/datamodel.rst:2218
msgid "hash"
msgstr ""

#: ../../reference/datamodel.rst:2299
msgid "__len__() (mapping object method)"
msgstr ""

#: ../../reference/datamodel.rst:2404
msgid "__getattr__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:2404
msgid "__dir__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:2404
msgid "__class__ (module attribute)"
msgstr ""

#: ../../reference/datamodel.rst:2780
msgid "metaclass"
msgstr ""

#: ../../reference/datamodel.rst:2780
msgid "= (equals)"
msgstr ""

#: ../../reference/datamodel.rst:2780
msgid "class definition"
msgstr ""

#: ../../reference/datamodel.rst:2844
msgid "metaclass hint"
msgstr ""

#: ../../reference/datamodel.rst:2867
msgid "__prepare__ (metaclass method)"
msgstr ""

#: ../../reference/datamodel.rst:2891
msgid "body"
msgstr ""

#: ../../reference/datamodel.rst:2911
msgid "__class__ (method cell)"
msgstr ""

#: ../../reference/datamodel.rst:2911
msgid "__classcell__ (class namespace entry)"
msgstr ""

#: ../../reference/datamodel.rst:3215
msgid "__bool__() (object method)"
msgstr ""

#: ../../reference/datamodel.rst:3385 ../../reference/datamodel.rst:3420
msgid "divmod"
msgstr ""

#: ../../reference/datamodel.rst:3385 ../../reference/datamodel.rst:3420
msgid "pow"
msgstr ""

#: ../../reference/datamodel.rst:3488
msgid "abs"
msgstr ""

#: ../../reference/datamodel.rst:3498
msgid "int"
msgstr ""

#: ../../reference/datamodel.rst:3498
msgid "float"
msgstr ""

#: ../../reference/datamodel.rst:3526
msgid "round"
msgstr ""

#: ../../reference/datamodel.rst:3550
msgid "with"
msgstr ""

#: ../../reference/datamodel.rst:3550
msgid "context manager"
msgstr ""