# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-04-02 22:11+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/reference/datamodel.rst:6 msgid "Data model" msgstr "" #: ../Doc/reference/datamodel.rst:12 msgid "Objects, values and types" msgstr "" #: ../Doc/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. (In a " "sense, and in conformance to Von Neumann's model of a \"stored program " "computer,\" code is also represented by objects.)" msgstr "" #: ../Doc/reference/datamodel.rst:35 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 "" #: ../Doc/reference/datamodel.rst:42 msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored." msgstr "" #: ../Doc/reference/datamodel.rst:44 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 "" #: ../Doc/reference/datamodel.rst:50 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 "" #: ../Doc/reference/datamodel.rst:65 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 "" #: ../Doc/reference/datamodel.rst:73 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 "" #: ../Doc/reference/datamodel.rst:82 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 "" #: ../Doc/reference/datamodel.rst:87 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 "" #: ../Doc/reference/datamodel.rst:97 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 "" #: ../Doc/reference/datamodel.rst:106 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. E.g., 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, but " "after ``c = []; d = []``, ``c`` and ``d`` are guaranteed to refer to two " "different, unique, newly created empty lists. (Note that ``c = d = []`` " "assigns the same object to both ``c`` and ``d``.)" msgstr "" #: ../Doc/reference/datamodel.rst:120 msgid "The standard type hierarchy" msgstr "" #: ../Doc/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 "" #: ../Doc/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 "" #: ../Doc/reference/datamodel.rst:150 msgid "None" msgstr "" #: ../Doc/reference/datamodel.rst:147 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 "" #: ../Doc/reference/datamodel.rst:165 msgid "NotImplemented" msgstr "" #: ../Doc/reference/datamodel.rst:155 msgid "" "This type has a single value. There is a single object with this value. " "This object is accessed through the built-in name ``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.) Its truth value is true." msgstr "" #: ../Doc/reference/datamodel.rst:162 msgid "See :ref:`implementing-the-arithmetic-operations` for more details." msgstr "" #: ../Doc/reference/datamodel.rst:172 msgid "Ellipsis" msgstr "" #: ../Doc/reference/datamodel.rst:170 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 "" #: ../Doc/reference/datamodel.rst:242 msgid ":class:`numbers.Number`" msgstr "" #: ../Doc/reference/datamodel.rst:177 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 "" #: ../Doc/reference/datamodel.rst:183 msgid "" "Python distinguishes between integers, floating point numbers, and complex " "numbers:" msgstr "" #: ../Doc/reference/datamodel.rst:217 msgid ":class:`numbers.Integral`" msgstr "" #: ../Doc/reference/datamodel.rst:189 msgid "" "These represent elements from the mathematical set of integers (positive and " "negative)." msgstr "" #: ../Doc/reference/datamodel.rst:192 msgid "There are two types of integers:" msgstr "" #: ../Doc/reference/datamodel.rst:194 msgid "Integers (:class:`int`)" msgstr "" #: ../Doc/reference/datamodel.rst:196 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 "" #: ../Doc/reference/datamodel.rst:212 msgid "Booleans (:class:`bool`)" msgstr "" #: ../Doc/reference/datamodel.rst:208 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 "" #: ../Doc/reference/datamodel.rst:216 msgid "" "The rules for integer representation are intended to give the most " "meaningful interpretation of shift and mask operations involving negative " "integers." msgstr "" #: ../Doc/reference/datamodel.rst:232 msgid ":class:`numbers.Real` (:class:`float`)" msgstr "" #: ../Doc/reference/datamodel.rst:226 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 "" #: ../Doc/reference/datamodel.rst:242 msgid ":class:`numbers.Complex` (:class:`complex`)" msgstr "" #: ../Doc/reference/datamodel.rst:239 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 "" #: ../Doc/reference/datamodel.rst:359 msgid "Sequences" msgstr "" #: ../Doc/reference/datamodel.rst:252 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]``." msgstr "" #: ../Doc/reference/datamodel.rst:259 msgid "" "Sequences also support slicing: ``a[i:j]`` selects all items with index *k* " "such that *i* ``<=`` *k* ``<`` *j*. When used as an expression, a slice is " "a sequence of the same type. This implies that the index set is renumbered " "so that it starts at 0." msgstr "" #: ../Doc/reference/datamodel.rst:264 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 "" #: ../Doc/reference/datamodel.rst:268 msgid "Sequences are distinguished according to their mutability:" msgstr "" #: ../Doc/reference/datamodel.rst:325 msgid "Immutable sequences" msgstr "" #: ../Doc/reference/datamodel.rst:275 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 "" #: ../Doc/reference/datamodel.rst:280 msgid "The following types are immutable sequences:" msgstr "" #: ../Doc/reference/datamodel.rst:303 msgid "Strings" msgstr "Les chaînes de caractères" #: ../Doc/reference/datamodel.rst:293 msgid "" "A string is a sequence of values that represent Unicode code points. All the " "code points in the range ``U+0000 - U+10FFFF`` can be represented in a " "string. Python doesn't have a :c:type:`char` type; instead, every code " "point in the string is represented as a string object with length ``1``. " "The built-in function :func:`ord` converts a code point from its string form " "to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer " "in the range ``0 - 10FFFF`` 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 "" #: ../Doc/reference/datamodel.rst:316 msgid "Tuples" msgstr "Tuples" #: ../Doc/reference/datamodel.rst:311 msgid "" "The items of a 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 "" #: ../Doc/reference/datamodel.rst:325 msgid "Bytes" msgstr "Bytes" #: ../Doc/reference/datamodel.rst:321 msgid "" "A 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 function :func:`bytes` can be used to construct " "bytes objects. Also, bytes objects can be decoded to strings via the :meth:" "`~bytes.decode` method." msgstr "" #: ../Doc/reference/datamodel.rst:359 msgid "Mutable sequences" msgstr "" #: ../Doc/reference/datamodel.rst:335 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 "" #: ../Doc/reference/datamodel.rst:339 msgid "There are currently two intrinsic mutable sequence types:" msgstr "" #: ../Doc/reference/datamodel.rst:346 msgid "Lists" msgstr "Les listes" #: ../Doc/reference/datamodel.rst:344 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 "" #: ../Doc/reference/datamodel.rst:354 msgid "Byte Arrays" msgstr "" #: ../Doc/reference/datamodel.rst:351 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 bytes objects." msgstr "" #: ../Doc/reference/datamodel.rst:358 msgid "" "The extension module :mod:`array` provides an additional example of a " "mutable sequence type, as does the :mod:`collections` module." msgstr "" #: ../Doc/reference/datamodel.rst:393 msgid "Set types" msgstr "" #: ../Doc/reference/datamodel.rst:366 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 "" #: ../Doc/reference/datamodel.rst:373 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 "" #: ../Doc/reference/datamodel.rst:378 msgid "There are currently two intrinsic set types:" msgstr "" #: ../Doc/reference/datamodel.rst:385 msgid "Sets" msgstr "Les ensembles" #: ../Doc/reference/datamodel.rst:383 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 "" #: ../Doc/reference/datamodel.rst:393 msgid "Frozen sets" msgstr "" #: ../Doc/reference/datamodel.rst:390 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 "" #: ../Doc/reference/datamodel.rst:430 msgid "Mappings" msgstr "" #: ../Doc/reference/datamodel.rst:401 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 "" #: ../Doc/reference/datamodel.rst:407 msgid "There is currently a single intrinsic mapping type:" msgstr "" #: ../Doc/reference/datamodel.rst:430 msgid "Dictionaries" msgstr "Dictionnaires" #: ../Doc/reference/datamodel.rst:412 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 "" #: ../Doc/reference/datamodel.rst:421 msgid "" "Dictionaries are mutable; they can be created by the ``{...}`` notation (see " "section :ref:`dict`)." msgstr "" #: ../Doc/reference/datamodel.rst:428 msgid "" "The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional " "examples of mapping types, as does the :mod:`collections` module." msgstr "" #: ../Doc/reference/datamodel.rst:686 msgid "Callable types" msgstr "" #: ../Doc/reference/datamodel.rst:439 msgid "" "These are the types to which the function call operation (see section :ref:" "`calls`) can be applied:" msgstr "" #: ../Doc/reference/datamodel.rst:534 msgid "User-defined functions" msgstr "" #: ../Doc/reference/datamodel.rst:448 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 "" #: ../Doc/reference/datamodel.rst:453 msgid "Special attributes:" msgstr "" #: ../Doc/reference/datamodel.rst:471 msgid "Attribute" msgstr "Attribut" #: ../Doc/reference/datamodel.rst:471 msgid "Meaning" msgstr "Signification" #: ../Doc/reference/datamodel.rst:473 msgid ":attr:`__doc__`" msgstr "" #: ../Doc/reference/datamodel.rst:473 msgid "" "The function's documentation string, or ``None`` if unavailable; not " "inherited by subclasses" msgstr "" #: ../Doc/reference/datamodel.rst:473 ../Doc/reference/datamodel.rst:478 #: ../Doc/reference/datamodel.rst:481 ../Doc/reference/datamodel.rst:486 #: ../Doc/reference/datamodel.rst:490 ../Doc/reference/datamodel.rst:496 #: ../Doc/reference/datamodel.rst:506 ../Doc/reference/datamodel.rst:514 #: ../Doc/reference/datamodel.rst:521 msgid "Writable" msgstr "" #: ../Doc/reference/datamodel.rst:478 msgid ":attr:`~definition.\\ __name__`" msgstr "" #: ../Doc/reference/datamodel.rst:478 msgid "The function's name" msgstr "" #: ../Doc/reference/datamodel.rst:481 msgid ":attr:`~definition.\\ __qualname__`" msgstr "" #: ../Doc/reference/datamodel.rst:481 msgid "The function's :term:`qualified name`" msgstr "" #: ../Doc/reference/datamodel.rst:486 msgid ":attr:`__module__`" msgstr "" #: ../Doc/reference/datamodel.rst:486 msgid "" "The name of the module the function was defined in, or ``None`` if " "unavailable." msgstr "" #: ../Doc/reference/datamodel.rst:490 msgid ":attr:`__defaults__`" msgstr "" #: ../Doc/reference/datamodel.rst:490 msgid "" "A tuple containing default argument values for those arguments that have " "defaults, or ``None`` if no arguments have a default value" msgstr "" #: ../Doc/reference/datamodel.rst:496 msgid ":attr:`__code__`" msgstr "" #: ../Doc/reference/datamodel.rst:496 msgid "The code object representing the compiled function body." msgstr "" #: ../Doc/reference/datamodel.rst:499 msgid ":attr:`__globals__`" msgstr "" #: ../Doc/reference/datamodel.rst:499 msgid "" "A reference to the dictionary that holds the function's global variables --- " "the global namespace of the module in which the function was defined." msgstr "" #: ../Doc/reference/datamodel.rst:499 ../Doc/reference/datamodel.rst:510 msgid "Read-only" msgstr "" #: ../Doc/reference/datamodel.rst:506 msgid ":attr:`~object.__dict__`" msgstr "" #: ../Doc/reference/datamodel.rst:506 msgid "The namespace supporting arbitrary function attributes." msgstr "" #: ../Doc/reference/datamodel.rst:510 msgid ":attr:`__closure__`" msgstr "" #: ../Doc/reference/datamodel.rst:510 msgid "" "``None`` or a tuple of cells that contain bindings for the function's free " "variables." msgstr "" #: ../Doc/reference/datamodel.rst:514 msgid ":attr:`__annotations__`" msgstr "" #: ../Doc/reference/datamodel.rst:514 msgid "" "A dict containing annotations of parameters. The keys of the dict are the " "parameter names, and ``'return'`` for the return annotation, if provided." msgstr "" #: ../Doc/reference/datamodel.rst:521 msgid ":attr:`__kwdefaults__`" msgstr "" #: ../Doc/reference/datamodel.rst:521 msgid "A dict containing defaults for keyword-only parameters." msgstr "" #: ../Doc/reference/datamodel.rst:525 msgid "" "Most of the attributes labelled \"Writable\" check the type of the assigned " "value." msgstr "" #: ../Doc/reference/datamodel.rst:527 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. *Note that " "the current implementation only supports function attributes on user-defined " "functions. Function attributes on built-in functions may be supported in the " "future.*" msgstr "" #: ../Doc/reference/datamodel.rst:533 msgid "" "Additional information about a function's definition can be retrieved from " "its code object; see the description of internal types below." msgstr "" #: ../Doc/reference/datamodel.rst:603 msgid "Instance methods" msgstr "" #: ../Doc/reference/datamodel.rst:542 msgid "" "An instance method object combines a class, a class instance and any " "callable object (normally a user-defined function)." msgstr "" #: ../Doc/reference/datamodel.rst:552 msgid "" "Special read-only attributes: :attr:`__self__` is the class instance " "object, :attr:`__func__` is the function object; :attr:`__doc__` is the " "method's documentation (same as ``__func__.__doc__``); :attr:`~definition." "__name__` is the method name (same as ``__func__.__name__``); :attr:" "`__module__` is the name of the module the method was defined in, or " "``None`` if unavailable." msgstr "" #: ../Doc/reference/datamodel.rst:558 msgid "" "Methods also support accessing (but not setting) the arbitrary function " "attributes on the underlying function object." msgstr "" #: ../Doc/reference/datamodel.rst:561 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 function object or a class method object." msgstr "" #: ../Doc/reference/datamodel.rst:565 msgid "" "When an instance method object is created by retrieving a user-defined " "function object from a class via one of its instances, its :attr:`__self__` " "attribute is the instance, and the method object is said to be bound. The " "new method's :attr:`__func__` attribute is the original function object." msgstr "" #: ../Doc/reference/datamodel.rst:571 msgid "" "When a user-defined method object is created by retrieving another method " "object from a class or instance, the behaviour is the same as for a function " "object, except that the :attr:`__func__` attribute of the new instance is " "not the original method object but its :attr:`__func__` attribute." msgstr "" #: ../Doc/reference/datamodel.rst:577 msgid "" "When an instance method object is created by retrieving a class method " "object from a class or instance, its :attr:`__self__` attribute is the class " "itself, and its :attr:`__func__` attribute is the function object underlying " "the class method." msgstr "" #: ../Doc/reference/datamodel.rst:582 msgid "" "When an instance method object is called, the underlying function (:attr:" "`__func__`) is called, inserting the class instance (:attr:`__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 "" #: ../Doc/reference/datamodel.rst:589 msgid "" "When an instance method object is derived from a class method object, the " "\"class instance\" stored in :attr:`__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 "" #: ../Doc/reference/datamodel.rst:594 msgid "" "Note that the transformation from function object to instance method object " "happens each time the attribute is retrieved from the instance. In some " "cases, a fruitful optimization is to assign the attribute to a local " "variable and call that local variable. Also notice that this transformation " "only happens for user-defined functions; other callable objects (and all non-" "callable objects) are retrieved without transformation. It is also " "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 "" #: ../Doc/reference/datamodel.rst:618 msgid "Generator functions" msgstr "" #: ../Doc/reference/datamodel.rst:610 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 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 "" #: ../Doc/reference/datamodel.rst:628 msgid "Coroutine functions" msgstr "" #: ../Doc/reference/datamodel.rst:624 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 "" #: ../Doc/reference/datamodel.rst:647 msgid "Asynchronous generator functions" msgstr "" #: ../Doc/reference/datamodel.rst:635 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 asynchronous iterator " "object which can be used in an :keyword:`async for` statement to execute the " "body of the function." msgstr "" #: ../Doc/reference/datamodel.rst:641 msgid "" "Calling the asynchronous iterator's :meth:`aiterator.__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 "" #: ../Doc/reference/datamodel.rst:662 msgid "Built-in functions" msgstr "Fonctions Natives" #: ../Doc/reference/datamodel.rst:655 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: :attr:`__doc__` " "is the function's documentation string, or ``None`` if unavailable; :attr:" "`~definition.__name__` is the function's name; :attr:`__self__` is set to " "``None`` (but see the next item); :attr:`__module__` is the name of the " "module the function was defined in or ``None`` if unavailable." msgstr "" #: ../Doc/reference/datamodel.rst:674 msgid "Built-in methods" msgstr "" #: ../Doc/reference/datamodel.rst:670 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*." msgstr "" #: ../Doc/reference/datamodel.rst:681 msgid "Classes" msgstr "Classes" #: ../Doc/reference/datamodel.rst:677 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:`__new__`. The arguments of the call are passed to :meth:" "`__new__` and, in the typical case, to :meth:`__init__` to initialize the " "new instance." msgstr "" #: ../Doc/reference/datamodel.rst:686 msgid "Class Instances" msgstr "" #: ../Doc/reference/datamodel.rst:684 msgid "" "Instances of arbitrary classes can be made callable by defining a :meth:" "`__call__` method in their class." msgstr "" #: ../Doc/reference/datamodel.rst:736 msgid "Modules" msgstr "Modules" #: ../Doc/reference/datamodel.rst:693 msgid "" "Modules are a basic organizational unit of Python code, and are created by " "the :ref:`import system ` as invoked either by the :keyword:" "`import` statement (see :keyword:`import`), or by calling functions such as :" "func:`importlib.import_module` and built-in :func:`__import__`. A module " "object has a namespace implemented by a dictionary object (this is the " "dictionary referenced by the ``__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 "" #: ../Doc/reference/datamodel.rst:705 msgid "" "Attribute assignment updates the module's namespace dictionary, e.g., ``m.x " "= 1`` is equivalent to ``m.__dict__[\"x\"] = 1``." msgstr "" #: ../Doc/reference/datamodel.rst:715 msgid "" "Predefined (writable) attributes: :attr:`__name__` is the module's name; :" "attr:`__doc__` is the module's documentation string, or ``None`` if " "unavailable; :attr:`__annotations__` (optional) is a dictionary containing :" "term:`variable annotations ` collected during module " "body execution; :attr:`__file__` is the pathname of the file from which the " "module was loaded, if it was loaded from a file. The :attr:`__file__` " "attribute may be missing for certain types of modules, such as C modules " "that are statically linked into the interpreter; for extension modules " "loaded dynamically from a shared library, it is the pathname of the shared " "library file." msgstr "" #: ../Doc/reference/datamodel.rst:728 msgid "" "Special read-only attribute: :attr:`~object.__dict__` is the module's " "namespace as a dictionary object." msgstr "" #: ../Doc/reference/datamodel.rst:733 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 "" #: ../Doc/reference/datamodel.rst:795 msgid "Custom classes" msgstr "" #: ../Doc/reference/datamodel.rst:739 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 in the documentation accompanying the 2.3 release at https://www." "python.org/download/releases/2.3/mro/." msgstr "" #: ../Doc/reference/datamodel.rst:763 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:`__self__` attributes is :class:`C`. When it would yield a static " "method 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 "" #: ../Doc/reference/datamodel.rst:773 msgid "" "Class attribute assignments update the class's dictionary, never the " "dictionary of a base class." msgstr "" #: ../Doc/reference/datamodel.rst:778 msgid "" "A class object can be called (see above) to yield a class instance (see " "below)." msgstr "" #: ../Doc/reference/datamodel.rst:788 msgid "" "Special attributes: :attr:`~definition.__name__` is the class name; :attr:" "`__module__` is the module name in which the class was defined; :attr:" "`~object.__dict__` is the dictionary containing the class's namespace; :attr:" "`~class.__bases__` is a tuple containing the base classes, in the order of " "their occurrence in the base class list; :attr:`__doc__` is the class's " "documentation string, or ``None`` if undefined; :attr:`__annotations__` " "(optional) is a dictionary containing :term:`variable annotations ` collected during class body execution." msgstr "" #: ../Doc/reference/datamodel.rst:838 msgid "Class instances" msgstr "" #: ../Doc/reference/datamodel.rst:804 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:`__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:`__getattr__` " "method, that is called to satisfy the lookup." msgstr "" #: ../Doc/reference/datamodel.rst:820 msgid "" "Attribute assignments and deletions update the instance's dictionary, never " "a class's dictionary. If the class has a :meth:`__setattr__` or :meth:" "`__delattr__` method, this is called instead of updating the instance " "dictionary directly." msgstr "" #: ../Doc/reference/datamodel.rst:830 msgid "" "Class instances can pretend to be numbers, sequences, or mappings if they " "have methods with certain special names. See section :ref:`specialnames`." msgstr "" #: ../Doc/reference/datamodel.rst:837 msgid "" "Special attributes: :attr:`~object.__dict__` is the attribute dictionary; :" "attr:`~instance.__class__` is the instance's class." msgstr "" #: ../Doc/reference/datamodel.rst:864 msgid "I/O objects (also known as file objects)" msgstr "" #: ../Doc/reference/datamodel.rst:854 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 "" #: ../Doc/reference/datamodel.rst:860 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 "" #: ../Doc/reference/datamodel.rst:1070 msgid "Internal types" msgstr "" #: ../Doc/reference/datamodel.rst:871 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 "" #: ../Doc/reference/datamodel.rst:939 msgid "Code objects" msgstr "Objets Code" #: ../Doc/reference/datamodel.rst:878 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 "" #: ../Doc/reference/datamodel.rst:903 msgid "" "Special read-only attributes: :attr:`co_name` gives the function name; :attr:" "`co_argcount` is the number of positional arguments (including arguments " "with default values); :attr:`co_nlocals` is the number of local variables " "used by the function (including arguments); :attr:`co_varnames` is a tuple " "containing the names of the local variables (starting with the argument " "names); :attr:`co_cellvars` is a tuple containing the names of local " "variables that are referenced by nested functions; :attr:`co_freevars` is a " "tuple containing the names of free variables; :attr:`co_code` is a string " "representing the sequence of bytecode instructions; :attr:`co_consts` is a " "tuple containing the literals used by the bytecode; :attr:`co_names` is a " "tuple containing the names used by the bytecode; :attr:`co_filename` is the " "filename from which the code was compiled; :attr:`co_firstlineno` is the " "first line number of the function; :attr:`co_lnotab` is a string encoding " "the mapping from bytecode offsets to line numbers (for details see the " "source code of the interpreter); :attr:`co_stacksize` is the required stack " "size (including local variables); :attr:`co_flags` is an integer encoding a " "number of flags for the interpreter." msgstr "" #: ../Doc/reference/datamodel.rst:922 msgid "" "The following flag bits are defined for :attr:`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." msgstr "" #: ../Doc/reference/datamodel.rst:928 msgid "" "Future feature declarations (``from __future__ import division``) also use " "bits in :attr:`co_flags` to indicate whether a code object was compiled with " "a particular feature enabled: bit ``0x2000`` is set if the function was " "compiled with future division enabled; bits ``0x10`` and ``0x1000`` were " "used in earlier versions of Python." msgstr "" #: ../Doc/reference/datamodel.rst:934 msgid "Other bits in :attr:`co_flags` are reserved for internal use." msgstr "" #: ../Doc/reference/datamodel.rst:938 msgid "" "If a code object represents a function, the first item in :attr:`co_consts` " "is the documentation string of the function, or ``None`` if undefined." msgstr "" #: ../Doc/reference/datamodel.rst:988 msgid "Frame objects" msgstr "" #: ../Doc/reference/datamodel.rst:946 msgid "" "Frame objects represent execution frames. They may occur in traceback " "objects (see below)." msgstr "" #: ../Doc/reference/datamodel.rst:957 msgid "" "Special read-only attributes: :attr:`f_back` is to the previous stack frame " "(towards the caller), or ``None`` if this is the bottom stack frame; :attr:" "`f_code` is the code object being executed in this frame; :attr:`f_locals` " "is the dictionary used to look up local variables; :attr:`f_globals` is used " "for global variables; :attr:`f_builtins` is used for built-in (intrinsic) " "names; :attr:`f_lasti` gives the precise instruction (this is an index into " "the bytecode string of the code object)." msgstr "" #: ../Doc/reference/datamodel.rst:969 msgid "" "Special writable attributes: :attr:`f_trace`, if not ``None``, is a function " "called at the start of each source code line (this is used by the " "debugger); :attr:`f_lineno` is 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 f_lineno." msgstr "" #: ../Doc/reference/datamodel.rst:976 msgid "Frame objects support one method:" msgstr "" #: ../Doc/reference/datamodel.rst:980 msgid "" "This method clears all references to local variables held by the frame. " "Also, if the frame belonged to a generator, the generator is finalized. " "This helps break reference cycles involving frame objects (for example when " "catching an exception and storing its traceback for later use)." msgstr "" #: ../Doc/reference/datamodel.rst:986 msgid ":exc:`RuntimeError` is raised if the frame is currently executing." msgstr "" #: ../Doc/reference/datamodel.rst:1026 msgid "Traceback objects" msgstr "" #: ../Doc/reference/datamodel.rst:1001 msgid "" "Traceback objects represent a stack trace of an exception. A traceback " "object is created when an exception occurs. 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 ``sys.exc_info()``. 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 ``sys.last_traceback``." msgstr "" #: ../Doc/reference/datamodel.rst:1019 msgid "" "Special read-only attributes: :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; :attr:`tb_frame` points to the execution frame of the " "current level; :attr:`tb_lineno` gives the line number where the exception " "occurred; :attr:`tb_lasti` indicates the precise instruction. The line " "number and last instruction in the traceback may differ from the line number " "of its frame object if the exception occurred in a :keyword:`try` statement " "with no matching except clause or with a finally clause." msgstr "" #: ../Doc/reference/datamodel.rst:1052 msgid "Slice objects" msgstr "" #: ../Doc/reference/datamodel.rst:1031 msgid "" "Slice objects are used to represent slices for :meth:`__getitem__` methods. " "They are also created by the built-in :func:`slice` function." msgstr "" #: ../Doc/reference/datamodel.rst:1039 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 "" #: ../Doc/reference/datamodel.rst:1043 msgid "Slice objects support one method:" msgstr "" #: ../Doc/reference/datamodel.rst:1047 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 "" #: ../Doc/reference/datamodel.rst:1062 msgid "Static method objects" msgstr "" #: ../Doc/reference/datamodel.rst:1055 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 not themselves " "callable, although the objects they wrap usually are. Static method objects " "are created by the built-in :func:`staticmethod` constructor." msgstr "" #: ../Doc/reference/datamodel.rst:1070 msgid "Class method objects" msgstr "" #: ../Doc/reference/datamodel.rst:1065 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 \"User-defined methods\". Class method " "objects are created by the built-in :func:`classmethod` constructor." msgstr "" #: ../Doc/reference/datamodel.rst:1075 msgid "Special method names" msgstr "" #: ../Doc/reference/datamodel.rst:1081 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:" "`__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 "" #: ../Doc/reference/datamodel.rst:1091 msgid "" "Setting a special method to ``None`` indicates that the corresponding " "operation is not available. For example, if a class sets :meth:`__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:" "`__getitem__`). [#]_" msgstr "" #: ../Doc/reference/datamodel.rst:1097 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 :class:`~xml.dom.NodeList` interface in " "the W3C's Document Object Model.)" msgstr "" #: ../Doc/reference/datamodel.rst:1108 msgid "Basic customization" msgstr "" #: ../Doc/reference/datamodel.rst:1114 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 "" #: ../Doc/reference/datamodel.rst:1121 msgid "" "Typical implementations create a new instance of the class by invoking the " "superclass's :meth:`__new__` method using ``super(currentclass, cls)." "__new__(cls[, ...])`` with appropriate arguments and then modifying the " "newly-created instance as necessary before returning it." msgstr "" #: ../Doc/reference/datamodel.rst:1126 msgid "" "If :meth:`__new__` 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 :meth:`__new__`." msgstr "" #: ../Doc/reference/datamodel.rst:1131 msgid "" "If :meth:`__new__` does not return an instance of *cls*, then the new " "instance's :meth:`__init__` method will not be invoked." msgstr "" #: ../Doc/reference/datamodel.rst:1134 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 "" #: ../Doc/reference/datamodel.rst:1143 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: ``BaseClass.__init__(self, [args...])``." msgstr "" #: ../Doc/reference/datamodel.rst:1150 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 "" #: ../Doc/reference/datamodel.rst:1162 msgid "" "Called when the instance is about to be destroyed. This is also called 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. Note that it is " "possible (though not recommended!) for the :meth:`__del__` method to " "postpone destruction of the instance by creating a new reference to it. It " "may then be called at a later time when this new reference is deleted. It " "is not guaranteed that :meth:`__del__` methods are called for objects that " "still exist when the interpreter exits." msgstr "" #: ../Doc/reference/datamodel.rst:1174 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. Some common situations that may " "prevent the reference count of an object from going to zero include: " "circular references between objects (e.g., a doubly-linked list or a tree " "data structure with parent and child pointers); a reference to the object on " "the stack frame of a function that caught an exception (the traceback stored " "in ``sys.exc_info()[2]`` keeps the stack frame alive); or a reference to the " "object on the stack frame that raised an unhandled exception in interactive " "mode (the traceback stored in ``sys.last_traceback`` keeps the stack frame " "alive). The first situation can only be remedied by explicitly breaking the " "cycles; the second can be resolved by freeing the reference to the traceback " "object when it is no longer useful, and the third can be resolved by storing " "``None`` in ``sys.last_traceback``. Circular references which are garbage " "are detected and cleaned up when the cyclic garbage collector is enabled " "(it's on by default). Refer to the documentation for the :mod:`gc` module " "for more information about this topic." msgstr "" #: ../Doc/reference/datamodel.rst:1196 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. Also, when :meth:`__del__` is " "invoked in response to a module being deleted (e.g., when execution of the " "program is done), other globals referenced by the :meth:`__del__` method may " "already have been deleted or in the process of being torn down (e.g. the " "import machinery shutting down). For this reason, :meth:`__del__` methods " "should do the absolute minimum needed to maintain external invariants. " "Starting with version 1.5, 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 "" #: ../Doc/reference/datamodel.rst:1217 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 "" #: ../Doc/reference/datamodel.rst:1226 msgid "" "This is typically used for debugging, so it is important that the " "representation is information-rich and unambiguous." msgstr "" #: ../Doc/reference/datamodel.rst:1237 msgid "" "Called by :func:`str(object) ` and the built-in functions :func:" "`format` and :func:`print` to compute the \"informal\" or nicely printable " "string representation of an object. The return value must be a :ref:`string " "` object." msgstr "" #: ../Doc/reference/datamodel.rst:1242 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 "" #: ../Doc/reference/datamodel.rst:1246 msgid "" "The default implementation defined by the built-in type :class:`object` " "calls :meth:`object.__repr__`." msgstr "" #: ../Doc/reference/datamodel.rst:1256 msgid "" "Called by :func:`bytes` to compute a byte-string representation of an " "object. This should return a ``bytes`` object." msgstr "" #: ../Doc/reference/datamodel.rst:1267 msgid "" "Called by the :func:`format` built-in function, and by extension, evaluation " "of :ref:`formatted string literals ` 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 "" #: ../Doc/reference/datamodel.rst:1277 msgid "" "See :ref:`formatspec` for a description of the standard formatting syntax." msgstr "" #: ../Doc/reference/datamodel.rst:1279 msgid "The return value must be a string object." msgstr "" #: ../Doc/reference/datamodel.rst:1281 msgid "" "The __format__ method of ``object`` itself raises a :exc:`TypeError` if " "passed any non-empty string." msgstr "" #: ../Doc/reference/datamodel.rst:1297 msgid "" "These are the so-called \"rich comparison\" methods. The correspondence " "between operator symbols and method names is as follows: ``xy`` calls ``x.__gt__(y)``, and ``x>=y`` " "calls ``x.__ge__(y)``." msgstr "" #: ../Doc/reference/datamodel.rst:1303 msgid "" "A rich comparison method may return the singleton ``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 "" #: ../Doc/reference/datamodel.rst:1310 msgid "" "By default, :meth:`__ne__` delegates to :meth:`__eq__` and inverts the " "result unless it is ``NotImplemented``. There are no other implied " "relationships among the comparison operators, for example, the truth of " "``(x.__hash__``." msgstr "" #: ../Doc/reference/datamodel.rst:1384 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.Hashable)`` call." msgstr "" #: ../Doc/reference/datamodel.rst:1393 msgid "" "By default, the :meth:`__hash__` values of str, bytes and datetime 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 "" #: ../Doc/reference/datamodel.rst:1398 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^2) complexity. See http://www.ocert.org/advisories/" "ocert-2011-003.html for details." msgstr "" #: ../Doc/reference/datamodel.rst:1403 msgid "" "Changing hash values affects the iteration order of dicts, sets and other " "mappings. Python has never made guarantees about this ordering (and it " "typically varies between 32-bit and 64-bit builds)." msgstr "" #: ../Doc/reference/datamodel.rst:1407 msgid "See also :envvar:`PYTHONHASHSEED`." msgstr "Voir aussi :envvar:`PYTHONHASHSEED`." #: ../Doc/reference/datamodel.rst:1409 msgid "Hash randomization is enabled by default." msgstr "" #: ../Doc/reference/datamodel.rst:1417 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:`__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__`, all its instances are considered true." msgstr "" #: ../Doc/reference/datamodel.rst:1428 msgid "Customizing attribute access" msgstr "" #: ../Doc/reference/datamodel.rst:1430 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 "" #: ../Doc/reference/datamodel.rst:1438 msgid "" "Called when an attribute lookup has not found the attribute in the usual " "places (i.e. it is not an instance attribute nor is it found in the class " "tree for ``self``). ``name`` is the attribute name. This method should " "return the (computed) attribute value or raise an :exc:`AttributeError` " "exception." msgstr "" #: ../Doc/reference/datamodel.rst:1443 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 fake 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 "" #: ../Doc/reference/datamodel.rst:1456 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 "" #: ../Doc/reference/datamodel.rst:1467 msgid "" "This method may still be bypassed when looking up special methods as the " "result of implicit invocation via language syntax or built-in functions. " "See :ref:`special-lookup`." msgstr "" #: ../Doc/reference/datamodel.rst:1474 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 "" #: ../Doc/reference/datamodel.rst:1478 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 "" #: ../Doc/reference/datamodel.rst:1485 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 "" #: ../Doc/reference/datamodel.rst:1491 msgid "" "Called when :func:`dir` is called on the object. A sequence must be " "returned. :func:`dir` converts the returned sequence to a list and sorts it." msgstr "" #: ../Doc/reference/datamodel.rst:1498 msgid "Implementing Descriptors" msgstr "" #: ../Doc/reference/datamodel.rst:1500 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__`." msgstr "" #: ../Doc/reference/datamodel.rst:1510 msgid "" "Called to get the attribute of the owner class (class attribute access) or " "of an instance of that class (instance attribute access). *owner* is always " "the owner class, while *instance* is the instance that the attribute was " "accessed through, or ``None`` when the attribute is accessed through the " "*owner*. This method should return the (computed) attribute value or raise " "an :exc:`AttributeError` exception." msgstr "" #: ../Doc/reference/datamodel.rst:1520 msgid "" "Called to set the attribute on an instance *instance* of the owner class to " "a new value, *value*." msgstr "" #: ../Doc/reference/datamodel.rst:1526 msgid "" "Called to delete the attribute on an instance *instance* of the owner class." msgstr "" #: ../Doc/reference/datamodel.rst:1531 msgid "" "Called at the time the owning class *owner* is created. The descriptor has " "been assigned to *name*." msgstr "" #: ../Doc/reference/datamodel.rst:1537 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 "" #: ../Doc/reference/datamodel.rst:1548 msgid "Invoking Descriptors" msgstr "" #: ../Doc/reference/datamodel.rst:1550 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:`__get__`, :meth:`__set__`, and :meth:`__delete__`. If any " "of those methods are defined for an object, it is said to be a descriptor." msgstr "" #: ../Doc/reference/datamodel.rst:1555 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 "" #: ../Doc/reference/datamodel.rst:1560 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 "" #: ../Doc/reference/datamodel.rst:1565 msgid "" "The starting point for descriptor invocation is a binding, ``a.x``. How the " "arguments are assembled depends on ``a``:" msgstr "" #: ../Doc/reference/datamodel.rst:1570 msgid "Direct Call" msgstr "" #: ../Doc/reference/datamodel.rst:1569 msgid "" "The simplest and least common call is when user code directly invokes a " "descriptor method: ``x.__get__(a)``." msgstr "" #: ../Doc/reference/datamodel.rst:1574 msgid "Instance Binding" msgstr "" #: ../Doc/reference/datamodel.rst:1573 msgid "" "If binding to an object instance, ``a.x`` is transformed into the call: " "``type(a).__dict__['x'].__get__(a, type(a))``." msgstr "" #: ../Doc/reference/datamodel.rst:1578 msgid "Class Binding" msgstr "" #: ../Doc/reference/datamodel.rst:1577 msgid "" "If binding to a class, ``A.x`` is transformed into the call: ``A." "__dict__['x'].__get__(None, A)``." msgstr "" #: ../Doc/reference/datamodel.rst:1584 msgid "Super Binding" msgstr "" #: ../Doc/reference/datamodel.rst:1581 msgid "" "If ``a`` is an instance of :class:`super`, then the binding ``super(B, obj)." "m()`` searches ``obj.__class__.__mro__`` for the base class ``A`` " "immediately preceding ``B`` and then invokes the descriptor with the call: " "``A.__dict__['m'].__get__(obj, obj.__class__)``." msgstr "" #: ../Doc/reference/datamodel.rst:1586 msgid "" "For instance bindings, the precedence of descriptor invocation depends on " "the which descriptor methods are defined. A descriptor can define any " "combination of :meth:`__get__`, :meth:`__set__` and :meth:`__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:`__set__` and :meth:`__get__` " "defined always override a redefinition in an instance dictionary. In " "contrast, non-data descriptors can be overridden by instances." msgstr "" #: ../Doc/reference/datamodel.rst:1599 msgid "" "Python methods (including :func:`staticmethod` and :func:`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 "" #: ../Doc/reference/datamodel.rst:1604 msgid "" "The :func:`property` function is implemented as a data descriptor. " "Accordingly, instances cannot override the behavior of a property." msgstr "" #: ../Doc/reference/datamodel.rst:1611 msgid "__slots__" msgstr "__slots__" #: ../Doc/reference/datamodel.rst:1613 msgid "" "By default, instances of classes have a dictionary for attribute storage. " "This wastes space for objects having very few instance variables. The space " "consumption can become acute when creating large numbers of instances." msgstr "" #: ../Doc/reference/datamodel.rst:1617 msgid "" "The default can be overridden by defining *__slots__* in a class definition. " "The *__slots__* declaration takes a sequence of instance variables and " "reserves just enough space in each instance to hold a value for each " "variable. Space is saved because *__dict__* is not created for each " "instance." msgstr "" #: ../Doc/reference/datamodel.rst:1625 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 *__dict__* " "and *__weakref__* for each instance." msgstr "" #: ../Doc/reference/datamodel.rst:1632 msgid "Notes on using *__slots__*" msgstr "" #: ../Doc/reference/datamodel.rst:1634 msgid "" "When inheriting from a class without *__slots__*, the *__dict__* attribute " "of that class will always be accessible, so a *__slots__* definition in the " "subclass is meaningless." msgstr "" #: ../Doc/reference/datamodel.rst:1638 msgid "" "Without a *__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 "" #: ../Doc/reference/datamodel.rst:1644 msgid "" "Without a *__weakref__* variable for each instance, classes defining " "*__slots__* do not support weak references to its instances. If weak " "reference support is needed, then add ``'__weakref__'`` to the sequence of " "strings in the *__slots__* declaration." msgstr "" #: ../Doc/reference/datamodel.rst:1649 msgid "" "*__slots__* are implemented at the class level by creating descriptors (:ref:" "`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 "" #: ../Doc/reference/datamodel.rst:1655 msgid "" "The action of a *__slots__* declaration is limited to the class where it is " "defined. As a result, subclasses will have a *__dict__* unless they also " "define *__slots__* (which must only contain names of any *additional* slots)." msgstr "" #: ../Doc/reference/datamodel.rst:1659 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 "" #: ../Doc/reference/datamodel.rst:1664 msgid "" "Nonempty *__slots__* does not work for classes derived from \"variable-length" "\" built-in types such as :class:`int`, :class:`bytes` and :class:`tuple`." msgstr "" #: ../Doc/reference/datamodel.rst:1667 msgid "" "Any non-string iterable may be assigned to *__slots__*. Mappings may also be " "used; however, in the future, special meaning may be assigned to the values " "corresponding to each key." msgstr "" #: ../Doc/reference/datamodel.rst:1671 msgid "" "*__class__* assignment works only if both classes have the same *__slots__*." msgstr "" #: ../Doc/reference/datamodel.rst:1677 msgid "Customizing class creation" msgstr "" #: ../Doc/reference/datamodel.rst:1679 msgid "" "Whenever a class inherits from another class, *__init_subclass__* is called " "on that 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 "" #: ../Doc/reference/datamodel.rst:1688 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 "" #: ../Doc/reference/datamodel.rst:1692 msgid "" "Keyword arguments which are given to a new class are passed to the parent's " "class ``__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 "" #: ../Doc/reference/datamodel.rst:1706 msgid "" "The default implementation ``object.__init_subclass__`` does nothing, but " "raises an error if it is called with any arguments." msgstr "" #: ../Doc/reference/datamodel.rst:1711 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 "" #: ../Doc/reference/datamodel.rst:1722 msgid "Metaclasses" msgstr "" #: ../Doc/reference/datamodel.rst:1728 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 "" #: ../Doc/reference/datamodel.rst:1732 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 "" #: ../Doc/reference/datamodel.rst:1746 msgid "" "Any other keyword arguments that are specified in the class definition are " "passed through to all metaclass operations described below." msgstr "" #: ../Doc/reference/datamodel.rst:1749 msgid "When a class definition is executed, the following steps occur:" msgstr "" #: ../Doc/reference/datamodel.rst:1751 msgid "the appropriate metaclass is determined" msgstr "" #: ../Doc/reference/datamodel.rst:1752 msgid "the class namespace is prepared" msgstr "" #: ../Doc/reference/datamodel.rst:1753 msgid "the class body is executed" msgstr "" #: ../Doc/reference/datamodel.rst:1754 msgid "the class object is created" msgstr "" #: ../Doc/reference/datamodel.rst:1757 msgid "Determining the appropriate metaclass" msgstr "" #: ../Doc/reference/datamodel.rst:1761 msgid "" "The appropriate metaclass for a class definition is determined as follows:" msgstr "" #: ../Doc/reference/datamodel.rst:1763 msgid "" "if no bases and no explicit metaclass are given, then :func:`type` is used" msgstr "" #: ../Doc/reference/datamodel.rst:1764 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 "" #: ../Doc/reference/datamodel.rst:1766 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 "" #: ../Doc/reference/datamodel.rst:1769 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 "" #: ../Doc/reference/datamodel.rst:1779 msgid "Preparing the class namespace" msgstr "" #: ../Doc/reference/datamodel.rst:1784 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)." msgstr "" #: ../Doc/reference/datamodel.rst:1789 msgid "" "If the metaclass has no ``__prepare__`` attribute, then the class namespace " "is initialised as an empty ordered mapping." msgstr "" #: ../Doc/reference/datamodel.rst:1794 msgid ":pep:`3115` - Metaclasses in Python 3000" msgstr "" #: ../Doc/reference/datamodel.rst:1795 msgid "Introduced the ``__prepare__`` namespace hook" msgstr "" #: ../Doc/reference/datamodel.rst:1799 msgid "Executing the class body" msgstr "" #: ../Doc/reference/datamodel.rst:1804 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 "" #: ../Doc/reference/datamodel.rst:1810 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 "" #: ../Doc/reference/datamodel.rst:1819 msgid "Creating the class object" msgstr "" #: ../Doc/reference/datamodel.rst:1826 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 "" #: ../Doc/reference/datamodel.rst:1831 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 "" #: ../Doc/reference/datamodel.rst:1841 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:" "`DeprecationWarning` in Python 3.6, and a :exc:`RuntimeWarning` in the " "future." msgstr "" #: ../Doc/reference/datamodel.rst:1848 msgid "" "When using the default metaclass :class:`type`, or any metaclass that " "ultimately calls ``type.__new__``, the following additional customisation " "steps are invoked after creating the class object:" msgstr "" #: ../Doc/reference/datamodel.rst:1852 msgid "" "first, ``type.__new__`` collects all of the descriptors in the class " "namespace that define a :meth:`~object.__set_name__` method;" msgstr "" #: ../Doc/reference/datamodel.rst:1854 msgid "" "second, all of these ``__set_name__`` methods are called with the class " "being defined and the assigned name of that particular descriptor; and" msgstr "" #: ../Doc/reference/datamodel.rst:1856 msgid "" "finally, the :meth:`~object.__init_subclass__` hook is called on the " "immediate parent of the new class in its method resolution order." msgstr "" #: ../Doc/reference/datamodel.rst:1859 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 "" #: ../Doc/reference/datamodel.rst:1863 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:`~object.__dict__` attribute of the class object." msgstr "" #: ../Doc/reference/datamodel.rst:1870 msgid ":pep:`3135` - New super" msgstr "" #: ../Doc/reference/datamodel.rst:1871 msgid "Describes the implicit ``__class__`` closure reference" msgstr "" #: ../Doc/reference/datamodel.rst:1875 msgid "Metaclass example" msgstr "" #: ../Doc/reference/datamodel.rst:1877 msgid "" "The potential uses for metaclasses are boundless. Some ideas that have been " "explored include logging, interface checking, automatic delegation, " "automatic property creation, proxies, frameworks, and automatic resource " "locking/synchronization." msgstr "" #: ../Doc/reference/datamodel.rst:1882 msgid "" "Here is an example of a metaclass that uses an :class:`collections." "OrderedDict` to remember the order that class variables are defined::" msgstr "" #: ../Doc/reference/datamodel.rst:1905 msgid "" "When the class definition for *A* gets executed, the process begins with " "calling the metaclass's :meth:`__prepare__` method which returns an empty :" "class:`collections.OrderedDict`. That mapping records the methods and " "attributes of *A* as they are defined within the body of the class " "statement. Once those definitions are executed, the ordered dictionary is " "fully populated and the metaclass's :meth:`__new__` method gets invoked. " "That method builds the new type and it saves the ordered dictionary keys in " "an attribute called ``members``." msgstr "" #: ../Doc/reference/datamodel.rst:1916 msgid "Customizing instance and subclass checks" msgstr "" #: ../Doc/reference/datamodel.rst:1918 msgid "" "The following methods are used to override the default behavior of the :func:" "`isinstance` and :func:`issubclass` built-in functions." msgstr "" #: ../Doc/reference/datamodel.rst:1921 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 "" #: ../Doc/reference/datamodel.rst:1928 msgid "" "Return true if *instance* should be considered a (direct or indirect) " "instance of *class*. If defined, called to implement ``isinstance(instance, " "class)``." msgstr "" #: ../Doc/reference/datamodel.rst:1935 msgid "" "Return true if *subclass* should be considered a (direct or indirect) " "subclass of *class*. If defined, called to implement ``issubclass(subclass, " "class)``." msgstr "" #: ../Doc/reference/datamodel.rst:1940 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 "" #: ../Doc/reference/datamodel.rst:1951 msgid ":pep:`3119` - Introducing Abstract Base Classes" msgstr "" #: ../Doc/reference/datamodel.rst:1948 msgid "" "Includes the specification for customizing :func:`isinstance` and :func:" "`issubclass` behavior through :meth:`~class.__instancecheck__` and :meth:" "`~class.__subclasscheck__`, with motivation for this functionality in the " "context of adding Abstract Base Classes (see the :mod:`abc` module) to the " "language." msgstr "" #: ../Doc/reference/datamodel.rst:1958 msgid "Emulating callable objects" msgstr "" #: ../Doc/reference/datamodel.rst:1965 msgid "" "Called when the instance is \"called\" as a function; if this method is " "defined, ``x(arg1, arg2, ...)`` is a shorthand for ``x.__call__(arg1, " "arg2, ...)``." msgstr "" #: ../Doc/reference/datamodel.rst:1972 msgid "Emulating container types" msgstr "" #: ../Doc/reference/datamodel.rst:1974 msgid "" "The following methods can be defined to implement container objects. " "Containers usually are sequences (such as lists or tuples) or mappings (like " "dictionaries), 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 " "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 dictionary objects. The :mod:`collections` module " "provides a :class:`~collections.abc.MutableMapping` abstract base class to " "help create those methods from a base set of :meth:`__getitem__`, :meth:" "`__setitem__`, :meth:`__delitem__`, and :meth:`keys`. Mutable sequences " "should provide methods :meth:`append`, :meth:`count`, :meth:`index`, :meth:" "`extend`, :meth:`insert`, :meth:`pop`, :meth:`remove`, :meth:`reverse` and :" "meth:`sort`, like Python standard list objects. Finally, sequence types " "should implement addition (meaning concatenation) and multiplication " "(meaning repetition) by defining the methods :meth:`__add__`, :meth:" "`__radd__`, :meth:`__iadd__`, :meth:`__mul__`, :meth:`__rmul__` and :meth:" "`__imul__` described below; they should not define other numerical " "operators. It is recommended that both mappings and sequences implement " "the :meth:`__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:`__iter__` method to " "allow efficient iteration through the container; for mappings, :meth:" "`__iter__` should be the same as :meth:`keys`; for sequences, it should " "iterate through the values." msgstr "" #: ../Doc/reference/datamodel.rst:2009 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:`__bool__` method and whose :meth:`__len__` method returns " "zero is considered to be false in a Boolean context." msgstr "" #: ../Doc/reference/datamodel.rst:2017 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. This method is purely an " "optimization and is never required for correctness." msgstr "" #: ../Doc/reference/datamodel.rst:2026 msgid "" "Slicing is done exclusively with the following three methods. A call like ::" msgstr "" #: ../Doc/reference/datamodel.rst:2030 msgid "is translated to ::" msgstr "" #: ../Doc/reference/datamodel.rst:2034 msgid "and so forth. Missing slice items are always filled in with ``None``." msgstr "" #: ../Doc/reference/datamodel.rst:2041 msgid "" "Called to implement evaluation of ``self[key]``. For sequence types, the " "accepted keys should be integers and slice objects. Note that the special " "interpretation of negative indexes (if the class wishes to emulate a " "sequence type) is up to the :meth:`__getitem__` method. If *key* is of an " "inappropriate type, :exc:`TypeError` may be raised; if of a value outside " "the set of indexes for the sequence (after any special interpretation of " "negative values), :exc:`IndexError` should be raised. For mapping types, if " "*key* is missing (not in the container), :exc:`KeyError` should be raised." msgstr "" #: ../Doc/reference/datamodel.rst:2052 msgid "" ":keyword:`for` loops expect that an :exc:`IndexError` will be raised for " "illegal indexes to allow proper detection of the end of the sequence." msgstr "" #: ../Doc/reference/datamodel.rst:2058 msgid "" "Called by :class:`dict`\\ .\\ :meth:`__getitem__` to implement ``self[key]`` " "for dict subclasses when key is not in the dictionary." msgstr "" #: ../Doc/reference/datamodel.rst:2064 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 "" #: ../Doc/reference/datamodel.rst:2073 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 "" #: ../Doc/reference/datamodel.rst:2082 msgid "" "This method is called when an 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 "" #: ../Doc/reference/datamodel.rst:2086 msgid "" "Iterator objects also need to implement this method; they are required to " "return themselves. For more information on iterator objects, see :ref:" "`typeiter`." msgstr "" #: ../Doc/reference/datamodel.rst:2092 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 "" #: ../Doc/reference/datamodel.rst:2096 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 "" #: ../Doc/reference/datamodel.rst:2103 msgid "" "The membership test operators (:keyword:`in` and :keyword:`not in`) are " "normally implemented as an iteration through a sequence. However, container " "objects can supply the following special method with a more efficient " "implementation, which also does not require the object be a sequence." msgstr "" #: ../Doc/reference/datamodel.rst:2110 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 "" #: ../Doc/reference/datamodel.rst:2114 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 `." msgstr "" #: ../Doc/reference/datamodel.rst:2123 msgid "Emulating numeric types" msgstr "" #: ../Doc/reference/datamodel.rst:2125 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 "" #: ../Doc/reference/datamodel.rst:2151 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, ``x.__add__(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 ternary " "version of the built-in :func:`pow` function is to be supported." msgstr "" #: ../Doc/reference/datamodel.rst:2162 msgid "" "If one of those methods does not support the operation with the supplied " "arguments, it should return ``NotImplemented``." msgstr "" #: ../Doc/reference/datamodel.rst:2185 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 left operand does not " "support the corresponding operation [#]_ and the operands are of different " "types. [#]_ For instance, to evaluate the expression ``x - y``, where *y* is " "an instance of a class that has an :meth:`__rsub__` method, ``y." "__rsub__(x)`` is called if ``x.__sub__(y)`` returns *NotImplemented*." msgstr "" #: ../Doc/reference/datamodel.rst:2196 msgid "" "Note that ternary :func:`pow` will not try calling :meth:`__rpow__` (the " "coercion rules would become too complicated)." msgstr "" #: ../Doc/reference/datamodel.rst:2201 msgid "" "If the right operand's type is a subclass of the left operand's type and " "that subclass provides 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 "" #: ../Doc/reference/datamodel.rst:2221 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, 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)`` . Otherwise, ``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 "" #: ../Doc/reference/datamodel.rst:2242 msgid "" "Called to implement the unary arithmetic operations (``-``, ``+``, :func:" "`abs` and ``~``)." msgstr "" #: ../Doc/reference/datamodel.rst:2257 msgid "" "Called to implement the built-in functions :func:`complex`, :func:`int`, :" "func:`float` and :func:`round`. Should return a value of the appropriate " "type." msgstr "" #: ../Doc/reference/datamodel.rst:2264 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 "" #: ../Doc/reference/datamodel.rst:2272 msgid "" "In order to have a coherent integer type class, when :meth:`__index__` is " "defined :meth:`__int__` should also be defined, and both should return the " "same value." msgstr "" #: ../Doc/reference/datamodel.rst:2280 msgid "With Statement Context Managers" msgstr "" #: ../Doc/reference/datamodel.rst:2282 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 "" #: ../Doc/reference/datamodel.rst:2293 msgid "" "Typical uses of context managers include saving and restoring various kinds " "of global state, locking and unlocking resources, closing opened files, etc." msgstr "" #: ../Doc/reference/datamodel.rst:2296 msgid "" "For more information on context managers, see :ref:`typecontextmanager`." msgstr "" #: ../Doc/reference/datamodel.rst:2301 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 "" #: ../Doc/reference/datamodel.rst:2308 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 "" #: ../Doc/reference/datamodel.rst:2312 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 "" #: ../Doc/reference/datamodel.rst:2316 msgid "" "Note that :meth:`__exit__` methods should not reraise the passed-in " "exception; this is the caller's responsibility." msgstr "" #: ../Doc/reference/datamodel.rst:2323 msgid ":pep:`343` - The \"with\" statement" msgstr "" #: ../Doc/reference/datamodel.rst:2323 msgid "" "The specification, background, and examples for the Python :keyword:`with` " "statement." msgstr "" #: ../Doc/reference/datamodel.rst:2330 msgid "Special method lookup" msgstr "" #: ../Doc/reference/datamodel.rst:2332 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 "" #: ../Doc/reference/datamodel.rst:2347 msgid "" "The rationale behind this behaviour lies with a number of special methods " "such as :meth:`__hash__` and :meth:`__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 "" #: ../Doc/reference/datamodel.rst:2360 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 "" #: ../Doc/reference/datamodel.rst:2369 msgid "" "In addition to bypassing any instance attributes in the interest of " "correctness, implicit special method lookup generally also bypasses the :" "meth:`__getattribute__` method even of the object's metaclass::" msgstr "" #: ../Doc/reference/datamodel.rst:2395 msgid "" "Bypassing the :meth:`__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 "" #: ../Doc/reference/datamodel.rst:2406 msgid "Coroutines" msgstr "Coroutines" #: ../Doc/reference/datamodel.rst:2410 msgid "Awaitable Objects" msgstr "" #: ../Doc/reference/datamodel.rst:2412 msgid "" "An :term:`awaitable` object generally implements an :meth:`__await__` " "method. :term:`Coroutine` objects returned from :keyword:`async def` " "functions are awaitable." msgstr "" #: ../Doc/reference/datamodel.rst:2418 msgid "" "The :term:`generator iterator` objects returned from generators decorated " "with :func:`types.coroutine` or :func:`asyncio.coroutine` are also " "awaitable, but they do not implement :meth:`__await__`." msgstr "" #: ../Doc/reference/datamodel.rst:2424 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." msgstr "" #: ../Doc/reference/datamodel.rst:2430 msgid ":pep:`492` for additional information about awaitable objects." msgstr "" #: ../Doc/reference/datamodel.rst:2436 msgid "Coroutine Objects" msgstr "" #: ../Doc/reference/datamodel.rst:2438 msgid "" ":term:`Coroutine` objects are :term:`awaitable` objects. A coroutine's " "execution can be controlled by calling :meth:`__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 "" #: ../Doc/reference/datamodel.rst:2446 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 "" #: ../Doc/reference/datamodel.rst:2450 msgid "It is a :exc:`RuntimeError` to await on a coroutine more than once." msgstr "" #: ../Doc/reference/datamodel.rst:2456 msgid "" "Starts or resumes execution of the coroutine. If *value* is ``None``, this " "is equivalent to advancing the iterator returned by :meth:`__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 "" #: ../Doc/reference/datamodel.rst:2466 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:`__await__` return value, described above. If the exception is not " "caught in the coroutine, it propagates back to the caller." msgstr "" #: ../Doc/reference/datamodel.rst:2477 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 "" #: ../Doc/reference/datamodel.rst:2485 msgid "" "Coroutine objects are automatically closed using the above process when they " "are about to be destroyed." msgstr "" #: ../Doc/reference/datamodel.rst:2491 msgid "Asynchronous Iterators" msgstr "" #: ../Doc/reference/datamodel.rst:2493 msgid "" "An *asynchronous iterable* is able to call asynchronous code in its " "``__aiter__`` implementation, and an *asynchronous iterator* can call " "asynchronous code in its ``__anext__`` method." msgstr "" #: ../Doc/reference/datamodel.rst:2497 msgid "" "Asynchronous iterators can be used in an :keyword:`async for` statement." msgstr "" #: ../Doc/reference/datamodel.rst:2501 msgid "Must return an *asynchronous iterator* object." msgstr "" #: ../Doc/reference/datamodel.rst:2505 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 "" #: ../Doc/reference/datamodel.rst:2508 msgid "An example of an asynchronous iterable object::" msgstr "" #: ../Doc/reference/datamodel.rst:2527 msgid "" "Starting with CPython 3.5.2, ``__aiter__`` can directly return :term:" "`asynchronous iterators `. Returning an :term:" "`awaitable` object will result in a :exc:`PendingDeprecationWarning`." msgstr "" #: ../Doc/reference/datamodel.rst:2533 msgid "" "The recommended way of writing backwards compatible code in CPython 3.5.x is " "to continue returning awaitables from ``__aiter__``. If you want to avoid " "the PendingDeprecationWarning and keep the code backwards compatible, the " "following decorator can be used::" msgstr "" #: ../Doc/reference/datamodel.rst:2552 msgid "Example::" msgstr "Exemples ::" #: ../Doc/reference/datamodel.rst:2563 msgid "" "Starting with CPython 3.6, the :exc:`PendingDeprecationWarning` will be " "replaced with the :exc:`DeprecationWarning`. In CPython 3.7, returning an " "awaitable from ``__aiter__`` will result in a :exc:`RuntimeError`." msgstr "" #: ../Doc/reference/datamodel.rst:2570 msgid "Asynchronous Context Managers" msgstr "" #: ../Doc/reference/datamodel.rst:2572 msgid "" "An *asynchronous context manager* is a *context manager* that is able to " "suspend execution in its ``__aenter__`` and ``__aexit__`` methods." msgstr "" #: ../Doc/reference/datamodel.rst:2575 msgid "" "Asynchronous context managers can be used in an :keyword:`async with` " "statement." msgstr "" #: ../Doc/reference/datamodel.rst:2579 msgid "" "This method is semantically similar to the :meth:`__enter__`, with only " "difference that it must return an *awaitable*." msgstr "" #: ../Doc/reference/datamodel.rst:2584 msgid "" "This method is semantically similar to the :meth:`__exit__`, with only " "difference that it must return an *awaitable*." msgstr "" #: ../Doc/reference/datamodel.rst:2587 msgid "An example of an asynchronous context manager class::" msgstr "" #: ../Doc/reference/datamodel.rst:2600 msgid "Footnotes" msgstr "Notes" #: ../Doc/reference/datamodel.rst:2601 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 "" #: ../Doc/reference/datamodel.rst:2605 msgid "" "The :meth:`__hash__`, :meth:`__iter__`, :meth:`__reversed__`, and :meth:" "`__contains__` 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 "" #: ../Doc/reference/datamodel.rst:2610 msgid "" "\"Does not support\" here means that the class has no such method, or the " "method returns ``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 "" #: ../Doc/reference/datamodel.rst:2616 msgid "" "For operands of the same type, it is assumed that if the non-reflected " "method (such as :meth:`__add__`) fails the operation is not supported, which " "is why the reflected method is not called." msgstr ""