# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2024-10-29 21:40+0100\n"

"PO-Revision-Date: 2023-12-05 16:21+0100\n"

"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\n"

"Language-Team: FRENCH <traductions@lists.afpy.org>\n"

"Language: fr\n"

"MIME-Version: 1.0\n"

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

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

"X-Generator: Poedit 2.4.2\n"

#: reference/datamodel.rst:6

msgid "Data model"

msgstr "Modèle de données"

#: reference/datamodel.rst:12

msgid "Objects, values and types"

msgstr "Objets, valeurs et types"

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

"En Python, les données sont représentées sous forme :dfn:`d'objets`. Toutes "

"les données d'un programme Python sont représentées par des objets ou par "

"des relations entre les objets (dans un certain sens, et en conformité avec "

"le modèle de Von Neumann d'« ordinateur à programme enregistré », le code "

"est aussi représenté par des objets)."

#: reference/datamodel.rst:35

#, fuzzy

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

"Chaque objet possède un identifiant, un type et une valeur. *L'identifiant* "

"d'un objet ne change jamais après sa création ; vous pouvez vous le "

"représenter comme l'adresse de l'objet en mémoire. L'opérateur :keyword:`is` "

"compare les identifiants de deux objets ; la fonction :func:`id` renvoie un "

"entier représentant cet identifiant."

#: reference/datamodel.rst:42

msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."

msgstr "en CPython, ``id(x)`` est l'adresse mémoire où est stocké ``x``."

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

"Le type de l'objet détermine les opérations que l'on peut appliquer à "

"l'objet (par exemple, « a-t-il une longueur ? ») et définit aussi les "

"valeurs possibles pour les objets de ce type. La fonction :func:`type` "

"renvoie le type de l'objet (qui est lui-même un objet). Comme l'identifiant, "

"le :dfn:`type` d'un objet ne peut pas être modifié [#]_."

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

"La *valeur* de certains objets peut changer. Les objets dont la valeur peut "

"changer sont dits mutables ; les objets dont la valeur est définitivement "

"fixée à leur création sont dits *immuables* (*immutable* en anglais). La "

"valeur d'un objet conteneur immuable qui contient une référence vers un "

"objet mutable peut varier lorsque la valeur de l'objet mutable change ; "

"cependant, le conteneur est quand même considéré comme immuable parce que "

"l'ensemble des objets qu'il contient ne peut pas être modifié. Ainsi, "

"l'immuabilité n'est pas strictement équivalente au fait d'avoir une valeur "

"non modifiable, c'est plus subtil. La muabilité d'un objet est définie par "

"son type ; par exemple, les nombres, les chaînes de caractères et les *n*-"

"uplets sont immuables alors que les dictionnaires et les listes sont "

"mutables."

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

"Un objet n'est jamais explicitement détruit ; cependant, lorsqu'il ne peut "

"plus être atteint, il a vocation à être supprimé par le ramasse-miettes "

"(*garbage-collector* en anglais). L'implémentation peut retarder cette "

"opération ou même ne pas la faire du tout — la façon dont fonctionne le "

"ramasse-miette est particulière à chaque implémentation, l'important étant "

"qu'il ne supprime pas d'objet qui peut encore être atteint."

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

"CPython utilise aujourd'hui un mécanisme de compteur de références avec une "

"détection, en temps différé et optionnelle, des cycles d'objets. Ce "

"mécanisme supprime la plupart des objets dès qu'ils ne sont plus accessibles "

"mais il ne garantit pas la suppression des objets où il existe des "

"références circulaires. Consultez la documentation du module :mod:`gc` pour "

"tout ce qui concerne la suppression des cycles. D'autres implémentations "

"agissent différemment et CPython pourrait évoluer. Ne vous reposez pas sur "

"la finalisation immédiate des objets devenus inaccessibles (ainsi, vous "

"devez toujours fermer les fichiers explicitement)."

#: reference/datamodel.rst:82

#, fuzzy

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

"Notez que si vous utilisez les fonctionnalités de débogage ou de trace de "

"l'implémentation, il est possible que des références qui seraient "

"normalement supprimées soient toujours présentes. Notez aussi que capturer "

"une exception avec l'instruction :keyword:`try`…\\ :keyword:`except` peut "

"conserver des objets en vie."

#: reference/datamodel.rst:87

#, fuzzy

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

"Certains objets font référence à des ressources « externes » telles que des "

"fichiers ouverts ou des fenêtres. Ces objets libèrent ces ressources au "

"moment où ils sont supprimés, mais comme le ramasse-miettes ne garantit pas "

"qu'il supprime tous les objets, ces objets fournissent également un moyen "

"explicite de libérer la ressource externe, généralement sous la forme d'une "

"méthode :meth:`close`. Nous incitons fortement les programmeurs à fermer "

"explicitement de tels objets. Les instructions :keyword:`try`…\\ :keyword:"

"`finally` et :keyword:`with` sont très pratiques pour cela."

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

"Certains objets contiennent des références à d'autres objets ; on les "

"appelle *conteneurs*. Comme exemples de conteneurs, nous pouvons citer les "

"*n*-uplets, les listes et les dictionnaires. Les références sont parties "

"intégrantes de la valeur d'un conteneur. Dans la plupart des cas, lorsque "

"nous parlons de la valeur d'un conteneur, nous parlons des valeurs, pas des "

"identifiants des objets contenus ; cependant, lorsque nous parlons de la "

"muabilité d'un conteneur, seuls les identifiants des objets immédiatement "

"contenus sont concernés. Ainsi, si un conteneur immuable (comme un *n*-"

"uplet) contient une référence à un objet mutable, sa valeur change si cet "

"objet mutable est modifié."

#: reference/datamodel.rst:106

#, fuzzy

msgid ""

"Types affect almost all aspects of object behavior. Even the importance of "

"object identity is affected in some sense: for immutable types, operations "

"that compute new values may actually return a reference to any existing "

"object with the same type and value, while for mutable objects this is not "

"allowed. For example, after ``a = 1; b = 1``, *a* and *b* may or may not "

"refer to the same object with the value one, depending on the "

"implementation. This is because :class:`int` is an immutable type, so the "

"reference to ``1`` can be reused. This behaviour depends on the "

"implementation used, so should not be relied upon, but is something to be "

"aware of when making use of object identity tests. However, after ``c = []; "

"d = []``, *c* and *d* are guaranteed to refer to two different, unique, "

"newly created empty lists. (Note that ``e = f = []`` assigns the *same* "

"object to both *e* and *f*.)"

msgstr ""

"Presque tous les comportements d'un objet dépendent du type de l'objet. Même "

"son identifiant est concerné dans un certain sens : pour les types "

"immuables, les opérations qui calculent de nouvelles valeurs peuvent en fait "

"renvoyer une référence à n'importe quel objet existant avec le même type et "

"la même valeur, alors que pour les objets mutables cela n'est pas autorisé. "

"Par exemple, après ``a = 1 ; b = 1``, ``a`` et ``b`` peuvent ou non se "

"référer au même objet avec la valeur un, en fonction de l'implémentation. "

"Mais après ``c = [] ; d = []``, il est garanti que ``c`` et ``d`` font "

"référence à deux listes vides distinctes nouvellement créées. Notez que ``c "

"= d = []`` attribue le même objet à ``c`` et ``d``."

#: reference/datamodel.rst:124

msgid "The standard type hierarchy"

msgstr "Hiérarchie des types standards"

#: reference/datamodel.rst:133

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

"Vous trouvez ci-dessous une liste des types natifs de Python. Des modules "

"d'extension (écrits en C, Java ou d'autres langages) peuvent définir des "

"types supplémentaires. Les futures versions de Python pourront ajouter des "

"types à cette hiérarchie (par exemple les nombres rationnels, des tableaux "

"d'entiers stockés efficacement, etc.), bien que de tels ajouts se trouvent "

"souvent plutôt dans la bibliothèque standard."

#: reference/datamodel.rst:144

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

"Quelques descriptions des types ci-dessous contiennent un paragraphe listant "

"des « attributs spéciaux ». Ces attributs donnent accès à l'implémentation "

"et n'ont, en général, pas vocation à être utilisés. Leur définition peut "

"changer dans le futur."

#: reference/datamodel.rst:152

msgid "None"

msgstr "``None``"

#: reference/datamodel.rst:154

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

"Ce type ne possède qu'une seule valeur. Il n'existe qu'un seul objet avec "

"cette valeur. Vous accédez à cet objet avec le nom natif ``None``. Il est "

"utilisé pour signifier l'absence de valeur dans de nombreux cas, par exemple "

"pour des fonctions qui ne renvoient rien explicitement. Sa valeur booléenne "

"est fausse."

#: reference/datamodel.rst:163

msgid "NotImplemented"

msgstr "NotImplemented"

#: reference/datamodel.rst:165

#, fuzzy

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name :data:`NotImplemented`. "

"Numeric methods and rich comparison methods should return this value if they "

"do not implement the operation for the operands provided. (The interpreter "

"will then try the reflected operation, or some other fallback, depending on "

"the operator.) It should not be evaluated in a boolean context."

msgstr ""

"Ce type ne possède qu'une seule valeur. Il n'existe qu'un seul objet avec "

"cette valeur. Vous accédez à cet objet avec le nom natif ``NotImplemented``. "

"Les méthodes numériques et les comparaisons riches doivent renvoyer cette "

"valeur si elles n'implémentent pas l'opération pour les opérandes fournis "

"(l'interpréteur essaie alors l'opération en permutant les opérandes ou tout "

"autre stratégie de contournement, en fonction de l'opérateur). Il ne doit "

"pas être évalué dans un contexte booléen."

#: reference/datamodel.rst:172

msgid "See :ref:`implementing-the-arithmetic-operations` for more details."

msgstr ""

"Consultez :ref:`implementing-the-arithmetic-operations` pour davantage de "

"détails."

# Pas de majuscule car suit un ':' dans le rendu.

#: reference/datamodel.rst:176

#, fuzzy

msgid ""

"Evaluating :data:`NotImplemented` in a boolean context is deprecated. While "

"it currently evaluates as true, it will emit a :exc:`DeprecationWarning`. It "

"will raise a :exc:`TypeError` in a future version of Python."

msgstr ""

"évaluer ``NotImplemented`` dans un contexte booléen est obsolète. Python "

"l'évalue aujourd'hui à ``True`` mais émet un :exc:`DeprecationWarning`. Il "

"lèvera une :exc:`TypeError` dans une version ultérieure de Python."

#: reference/datamodel.rst:184

msgid "Ellipsis"

msgstr "Ellipse"

#: reference/datamodel.rst:188

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

"Ce type ne possède qu'une seule valeur. Il n'existe qu'un seul objet avec "

"cette valeur. Vous accédez à cet objet avec le littéral ``...`` ou le nom "

"natif ``Ellipsis``. Sa valeur booléenne est vraie."

#: reference/datamodel.rst:194

msgid ":class:`numbers.Number`"

msgstr ":class:`numbers.Number`"

#: reference/datamodel.rst:198

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

"Ces objets sont créés par les littéraux numériques et renvoyés en tant que "

"résultats par les opérateurs et les fonctions arithmétiques natives. Les "

"objets numériques sont immuables ; une fois créés, leur valeur ne change "

"pas. Les nombres Python sont bien sûr très fortement corrélés aux nombres "

"mathématiques mais ils sont soumis aux limitations des représentations "

"numériques par les ordinateurs."

#: reference/datamodel.rst:204

msgid ""

"The string representations of the numeric classes, computed by :meth:"

"`~object.__repr__` and :meth:`~object.__str__`, have the following "

"properties:"

msgstr ""

"Les représentations sous forme de chaînes de caractères des objets "

"numériques, produites par :meth:`~object.__repr__` et :meth:`~object."

"__str__`, ont les propriétés suivantes :"

#: reference/datamodel.rst:208

msgid ""

"They are valid numeric literals which, when passed to their class "

"constructor, produce an object having the value of the original numeric."

msgstr ""

"Ce sont des littéraux numériques valides qui, s'ils sont passés au "

"constructeur de leur classe, produisent un objet qui a la valeur numérique "

"de l'objet d'origine."

#: reference/datamodel.rst:212

msgid "The representation is in base 10, when possible."

msgstr "La représentation est en base 10, si possible."

#: reference/datamodel.rst:214

msgid ""

"Leading zeros, possibly excepting a single zero before a decimal point, are "

"not shown."

msgstr ""

"Les zéros en tête, sauf en ce qui concerne un zéro seul avant la virgule "

"(représentée par un point en Python conformément à la convention anglo-"

"saxonne), ne sont pas affichés."

#: reference/datamodel.rst:217

msgid ""

"Trailing zeros, possibly excepting a single zero after a decimal point, are "

"not shown."

msgstr ""

"Les zéros en fin, sauf en ce qui concerne un zéro seul après la virgule, ne "

"sont pas affichés."

#: reference/datamodel.rst:220

msgid "A sign is shown only when the number is negative."

msgstr "Le signe n'est affiché que lorsque le nombre est négatif."

#: reference/datamodel.rst:222

#, fuzzy

msgid ""

"Python distinguishes between integers, floating-point numbers, and complex "

"numbers:"

msgstr ""

"Python distingue les entiers, les nombres à virgule flottante et les nombres "

"complexes :"

#: reference/datamodel.rst:227

msgid ":class:`numbers.Integral`"

msgstr ":class:`numbers.Integral`"

#: reference/datamodel.rst:231

msgid ""

"These represent elements from the mathematical set of integers (positive and "

"negative)."

msgstr ""

"Ils représentent des éléments de l'ensemble mathématique des entiers "

"(positifs ou négatifs)."

#: reference/datamodel.rst:237

msgid ""

"The rules for integer representation are intended to give the most "

"meaningful interpretation of shift and mask operations involving negative "

"integers."

msgstr ""

"Les règles pour la représentation des entiers ont pour objet de donner "

"l'interprétation la plus naturelle pour les opérations de décalage et "

"masquage qui impliquent des entiers négatifs."

#: reference/datamodel.rst:240

msgid "There are two types of integers:"

msgstr "Il existe deux types d'entiers :"

#: reference/datamodel.rst:242

msgid "Integers (:class:`int`)"

msgstr "Entiers (:class:`int`)"

#: reference/datamodel.rst:243

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

"Ils représentent les nombres, sans limite de taille, sous réserve de pouvoir "

"être stockés en mémoire (virtuelle). Afin de pouvoir effectuer des décalages "

"et appliquer des masques, on considère qu'ils ont une représentation "

"binaire. Les nombres négatifs sont représentés comme une variante du "

"complément à 2, qui donne l'illusion d'une chaîne infinie de bits de signe "

"s'étendant vers la gauche."

#: reference/datamodel.rst:249

msgid "Booleans (:class:`bool`)"

msgstr "Booléens (:class:`bool`)"

#: reference/datamodel.rst:255

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

"Ils représentent les valeurs *faux* et *vrai*. Deux objets, ``False`` et "

"``True``, sont les seuls objets booléens. Le type booléen est un sous-type "

"du type entier et les valeurs booléennes se comportent comme les valeurs 0 "

"(pour ``False``) et 1 (pour ``True``) dans presque tous les contextes. "

"L'exception concerne la conversion en chaîne de caractères où ``\"False\"`` "

"et ``\"True\"`` sont renvoyées."

#: reference/datamodel.rst:263

msgid ":class:`numbers.Real` (:class:`float`)"

msgstr ":class:`numbers.Real` (:class:`float`)"

#: reference/datamodel.rst:271

#, fuzzy

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

"Ils représentent les nombres à virgule flottante en double précision, tels "

"que manipulés directement par la machine. Vous dépendez donc de "

"l'architecture machine sous-jacente (et de l'implémentation C ou Java) pour "

"les intervalles gérés et le traitement des débordements. Python ne gère pas "

"les nombres à virgule flottante en précision simple ; les gains en puissance "

"de calcul et mémoire, qui sont généralement la raison de l'utilisation des "

"nombres en simple précision, sont annihilés par le fait que Python encapsule "

"de toute façon ces nombres dans des objets. Il n'y a donc aucune raison de "

"compliquer le langage avec deux types de nombres à virgule flottante."

#: reference/datamodel.rst:281

msgid ":class:`numbers.Complex` (:class:`complex`)"

msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: reference/datamodel.rst:287

#, fuzzy

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

"Ils représentent les nombres complexes, sous la forme d'un couple de nombres "

"à virgule flottante en double précision, tels que manipulés directement par "

"la machine. Les mêmes restrictions s'appliquent que pour les nombres à "

"virgule flottante. La partie réelle et la partie imaginaire d'un nombre "

"complexe ``z`` peuvent être demandées par les attributs en lecture seule ``z."

"real`` et ``z.imag``."

#: reference/datamodel.rst:294

msgid "Sequences"

msgstr "Séquences"

#: reference/datamodel.rst:303

#, fuzzy

msgid ""

"These represent finite ordered sets indexed by non-negative numbers. The "

"built-in function :func:`len` returns the number of items of a sequence. "

"When the length of a sequence is *n*, the index set contains the numbers 0, "

"1, ..., *n*-1. Item *i* of sequence *a* is selected by ``a[i]``. Some "

"sequences, including built-in sequences, interpret negative subscripts by "

"adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, the "

"second to last item of sequence a with length ``n``."

msgstr ""

"Ils représentent des ensembles de taille finie indicés par des entiers "

"positifs ou nuls. La fonction native :func:`len` renvoie le nombre "

"d'éléments de la séquence. Quand la longueur d'une séquence est *n*, "

"l'ensemble des indices contient les entiers 0, 1, …, *n-1*. On accède à "

"l'élément d'indice *i* de la séquence *a* par ``a[i]``."

#: reference/datamodel.rst:313

#, fuzzy

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. The comment above about negative indexes also "

"applies to negative slice positions."

msgstr ""

"Les séquences peuvent aussi être découpées en tranches (*slicing* en "

"anglais) : ``a[i:j]`` sélectionne tous les éléments d'indice *k* tel que *i* "

"``<=`` *k* ``<`` *j*. Quand on l'utilise dans une expression, la tranche est "

"du même type que la séquence. Ceci veut dire que l'ensemble des indices de "

"la tranche est renuméroté de manière à partir de 0."

#: reference/datamodel.rst:318

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

"Quelques séquences gèrent le « découpage étendu » (*extended slicing* en "

"anglais) avec un troisième paramètre : ``a[i:j:k]`` sélectionne tous les "

"éléments de *a* d'indice *x* où ``x = i + n*k``, avec *n* ``>=`` ``0`` et "

"*i* ``<=`` *x* ``<`` *j*."

#: reference/datamodel.rst:322

msgid "Sequences are distinguished according to their mutability:"

msgstr "Les séquences se différencient en fonction de leur muabilité :"

#: reference/datamodel.rst:326

msgid "Immutable sequences"

msgstr "Séquences immuables"

#: reference/datamodel.rst:332

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

"Un objet de type de séquence immuable ne peut pas être modifié une fois "

"qu'il a été créé. Si l'objet contient des références à d'autres objets, ces "

"autres objets peuvent être mutables et peuvent être modifiés ; cependant, "

"les objets directement référencés par un objet immuable ne peuvent pas être "

"modifiés."

#: reference/datamodel.rst:337

msgid "The following types are immutable sequences:"

msgstr "Les types suivants sont des séquences immuables :"

#: reference/datamodel.rst:342

msgid "Strings"

msgstr "Chaînes de caractères"

#: reference/datamodel.rst:350

#, fuzzy

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:expr:`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 ""

"Une chaîne de caractères (*string* en anglais) est une séquence de valeurs "

"qui représentent des caractères Unicode. Tout caractère dont le code est "

"dans l'intervalle ``U+0000 - U+10FFFF`` peut être représenté dans une "

"chaîne. Python ne possède pas de type :c:type:`char` ; à la place, chaque "

"caractère Unicode dans la chaîne est représenté par un objet chaîne de "

"longueur ``1``. La fonction native :func:`ord` convertit un caractère "

"Unicode de la représentation en chaîne vers un entier dans l'intervalle ``0 "

"- 10FFFF`` ; la fonction :func:`chr` convertit un entier de l'intervalle ``0 "

"- 10FFFF`` vers l'objet chaîne de longueur ``1`` correspondant. :meth:`str."

"encode` peut être utilisée pour convertir un objet :class:`str` vers :class:"

"`bytes` selon l'encodage spécifié et :meth:`bytes.decode` effectue "

"l'opération inverse."

#: reference/datamodel.rst:362

msgid "Tuples"

msgstr "*n*-uplets (*tuples* en anglais)"

#: reference/datamodel.rst:368

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

"Les éléments d'un *n*-uplet peuvent être n'importe quel objet Python. Les "

"*n*-uplets de deux éléments ou plus sont formés par une liste d'expressions "

"dont les éléments sont séparés par des virgules. Un *n*-uplet composé d'un "

"seul élément (un « singleton ») est formé en suffixant une expression avec "

"une virgule (une expression en tant que telle ne crée pas un *n*-uplet car "

"les parenthèses doivent rester disponibles pour grouper les expressions). Un "

"*n*-uplet vide est formé à l'aide d'une paire de parenthèses vide."

#: reference/datamodel.rst:375

msgid "Bytes"

msgstr "Chaînes d'octets (ou *bytes*)"

#: reference/datamodel.rst:378

#, fuzzy

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 :func:`bytes` constructor can be used to create "

"bytes objects. Also, bytes objects can be decoded to strings via the :meth:"

"`~bytes.decode` method."

msgstr ""

"Les objets *bytes* sont des tableaux immuables. Les éléments sont des octets "

"(donc composés de 8 bits), représentés par des entiers dans l'intervalle 0 à "

"255 inclus. Les littéraux *bytes* (tels que ``b'abc'``) et la fonction "

"native constructeur :func:`bytes()` peuvent être utilisés pour créer des "

"objets *bytes*. Aussi, un objet *bytes* peut être décodé vers une chaîne "

"*via* la méthode :meth:`~bytes.decode`."

#: reference/datamodel.rst:386

msgid "Mutable sequences"

msgstr "Séquences mutables"

#: reference/datamodel.rst:395

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

"Les séquences mutables peuvent être modifiées après leur création. Les "

"notations de tranches et de sous-ensembles peuvent être utilisées en tant "

"que cibles d'une affectation ou de l'instruction :keyword:`del` "

"(suppression)."

#: reference/datamodel.rst:403

#, fuzzy

msgid ""

"The :mod:`collections` and :mod:`array` module provide additional examples "

"of mutable sequence types."

msgstr ""

"Le module d'extension :mod:`array` fournit un autre exemple de type de "

"séquence mutable, de même que le module :mod:`collections`."

#: reference/datamodel.rst:406

msgid "There are currently two intrinsic mutable sequence types:"

msgstr "Il existe aujourd'hui deux types intrinsèques de séquences mutables :"

#: reference/datamodel.rst:408

msgid "Lists"

msgstr "Listes"

#: reference/datamodel.rst:411

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

"N'importe quel objet Python peut être élément d'une liste. Les listes sont "

"créées en plaçant entre crochets une liste d'expressions dont les éléments "

"sont séparés par des virgules (notez que les listes de longueur 0 ou 1 ne "

"sont pas des cas particuliers)."

#: reference/datamodel.rst:415

msgid "Byte Arrays"

msgstr "Tableaux d'octets"

#: reference/datamodel.rst:418

msgid ""

"A bytearray object is a mutable array. They are created by the built-in :"

"func:`bytearray` constructor. Aside from being mutable (and hence "

"unhashable), byte arrays otherwise provide the same interface and "

"functionality as immutable :class:`bytes` objects."

msgstr ""

"Un objet *bytearray* est un tableau mutable. Il est créé par la fonction "

"native constructeur :func:`bytearray`. À part la propriété d'être mutable "

"(et donc de ne pas pouvoir calculer son empreinte par hachage), un tableau "

"d'octets possède la même interface et les mêmes fonctionnalités qu'un objet "

"immuable :class:`bytes`."

#: reference/datamodel.rst:425

msgid "Set types"

msgstr "Ensembles"

#: reference/datamodel.rst:431

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

"Ils représentent les ensembles d'objets, non ordonnés, finis et dont les "

"éléments sont uniques. Tels quels, ils ne peuvent pas être indicés. "

"Cependant, il est possible d'itérer dessus et la fonction native :func:`len` "

"renvoie le nombre d'éléments de l'ensemble. Les utilisations classiques des "

"ensembles sont les tests d'appartenance rapides, la suppression de doublons "

"dans une séquence et le calcul d'opérations mathématiques telles que "

"l'intersection, l'union, la différence et le complémentaire."

#: reference/datamodel.rst:438

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

"Pour les éléments des ensembles, les mêmes règles concernant l'immuabilité "

"s'appliquent que pour les clés de dictionnaires. Notez que les types "

"numériques obéissent aux règles normales pour les comparaisons numériques : "

"si deux nombres sont égaux (pour l'opération de comparaison, par exemple "

"``1`` et ``1.0``), un seul élément est conservé dans l'ensemble."

#: reference/datamodel.rst:443

msgid "There are currently two intrinsic set types:"

msgstr "Actuellement, il existe deux types d'ensembles natifs :"

#: reference/datamodel.rst:446

msgid "Sets"

msgstr "Ensembles"

#: reference/datamodel.rst:449

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

"Ils représentent les ensembles mutables. Un ensemble est créé par la "

"fonction native constructeur :func:`set` et peut être modifié par la suite à "

"l'aide de différentes méthodes, par exemple :meth:`~set.add`."

#: reference/datamodel.rst:454

msgid "Frozen sets"

msgstr "Ensembles figés"

#: reference/datamodel.rst:457

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

"Ils représentent les ensembles immuables. Ils sont créés par la fonction "

"native constructeur :func:`frozenset`. Comme un ensemble figé est immuable "

"et :term:`hachable`, il peut être utilisé comme élément d'un autre ensemble "

"ou comme clé de dictionnaire."

#: reference/datamodel.rst:464

msgid "Mappings"

msgstr "Tableaux de correspondances"

#: reference/datamodel.rst:471

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

"Ils représentent les ensembles finis d'objets indicés par des ensembles "

"index arbitraires. La notation ``a[k]`` sélectionne l'élément indicé par "

"``k`` dans le tableau de correspondances ``a`` ; elle peut être utilisée "

"dans des expressions, comme cible d'une affectation ou avec l'instruction :"

"keyword:`del`. La fonction native :func:`len` renvoie le nombre d'éléments "

"du tableau de correspondances."

#: reference/datamodel.rst:477

msgid "There is currently a single intrinsic mapping type:"

msgstr ""

"Il n'existe actuellement qu'un seul type natif pour les tableaux de "

"correspondances :"

#: reference/datamodel.rst:481

msgid "Dictionaries"

msgstr "Dictionnaires"

#: reference/datamodel.rst:485

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

"Ils représentent les ensembles finis d'objets indicés par des valeurs "

"presque arbitraires. Les seuls types de valeurs non reconnus comme clés sont "

"les valeurs contenant des listes, des dictionnaires ou les autres types "

"mutables qui sont comparés par valeur plutôt que par l'identifiant de "

"l'objet. La raison de cette limitation est qu'une implémentation efficace de "

"dictionnaire requiert que l'empreinte par hachage des clés reste constante "

"dans le temps. Les types numériques obéissent aux règles normales pour les "

"comparaisons numériques : si deux nombres sont égaux pour l'opération de "

"comparaison, par exemple ``1`` et ``1.0``, alors ces deux nombres peuvent "

"être utilisés indifféremment pour désigner la même entrée du dictionnaire."

#: reference/datamodel.rst:494

msgid ""

"Dictionaries preserve insertion order, meaning that keys will be produced in "

"the same order they were added sequentially over the dictionary. Replacing "

"an existing key does not change the order, however removing a key and re-"

"inserting it will add it to the end instead of keeping its old place."

msgstr ""

"Les dictionnaires préservent l’ordre d’insertion, ce qui signifie que les "

"clés sont renvoyées séquentiellement dans le même ordre que celui de "

"l’insertion. Remplacer une clé existante ne change pas l’ordre. Par contre, "

"la retirer puis la réinsérer la met à la fin et non à sa précédente position."

#: reference/datamodel.rst:499

#, fuzzy

msgid ""

"Dictionaries are mutable; they can be created by the ``{}`` notation (see "

"section :ref:`dict`)."

msgstr ""

"Les dictionnaires sont mutables : ils peuvent être créés par la notation "

"``{…}`` (reportez-vous à la section :ref:`dict`)."

#: reference/datamodel.rst:506

msgid ""

"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "

"examples of mapping types, as does the :mod:`collections` module."

msgstr ""

"Les modules d'extensions :mod:`dbm.ndbm` et :mod:`dbm.gnu` apportent "

"d'autres exemples de types tableaux de correspondances, de même que le "

"module :mod:`collections`."

# suit un :

#: reference/datamodel.rst:510

msgid ""

"Dictionaries did not preserve insertion order in versions of Python before "

"3.6. In CPython 3.6, insertion order was preserved, but it was considered an "

"implementation detail at that time rather than a language guarantee."

msgstr ""

"les dictionnaires ne conservaient pas l’ordre d’insertion dans les versions "

"antérieures à Python 3.6. Dans CPython 3.6, l’ordre d’insertion était déjà "

"conservé, mais considéré comme un détail d’implémentation et non comme une "

"garantie du langage."

#: reference/datamodel.rst:517

msgid "Callable types"

msgstr "Types appelables"

#: reference/datamodel.rst:525

msgid ""

"These are the types to which the function call operation (see section :ref:"

"`calls`) can be applied:"

msgstr ""

"Ce sont les types sur lesquels on peut faire un appel de fonction (lisez la "

"section :ref:`calls`) :"

#: reference/datamodel.rst:532

msgid "User-defined functions"

msgstr "Fonctions définies par l'utilisateur"

#: reference/datamodel.rst:539

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

"Un objet fonction définie par l'utilisateur (mais ce n'est pas forcément "

"l'utilisateur courant qui a défini cette fonction) est créé par la "

"définition d'une fonction (voir la section :ref:`function`). Il doit être "

"appelé avec une liste d'arguments contenant le même nombre d'éléments que la "

"liste des paramètres formels de la fonction."

#: reference/datamodel.rst:1367 reference/datamodel.rst:1562

#, fuzzy

msgid "Special read-only attributes"

msgstr "Attributs spéciaux :"

#: reference/datamodel.rst:589 reference/datamodel.rst:1156

msgid "Attribute"

msgstr "Attribut"

#: reference/datamodel.rst:590 reference/datamodel.rst:1157

msgid "Meaning"

msgstr "Signification"

#: reference/datamodel.rst:559

#, fuzzy

msgid ""

"A reference to the :class:`dictionary <dict>` that holds the function's :ref:"

"`global variables <naming>` -- the global namespace of the module in which "

"the function was defined."

msgstr ""

"Référence pointant vers le dictionnaire contenant les variables globales de "

"la fonction — l'espace de noms global du module dans lequel la fonction est "

"définie."

#: reference/datamodel.rst:564

#, fuzzy

msgid ""

"``None`` or a :class:`tuple` of cells that contain bindings for the "

"function's free variables."

msgstr ""

"``None`` ou *n*-uplet de cellules qui contient un lien pour chaque variable "

"libre de la fonction. Voir ci-dessous pour les informations relatives à "

"l'attribut ``cell_contents``."

#: reference/datamodel.rst:567

msgid ""

"A cell object has the attribute ``cell_contents``. This can be used to get "

"the value of the cell, as well as set the value."

msgstr ""

"Un objet cellule possède un attribut ``cell_contents``. Il peut être utilisé "

"pour obtenir la valeur de la cellule et pour en définir la valeur."

#: reference/datamodel.rst:1599

#, fuzzy

msgid "Special writable attributes"

msgstr "Attributs spéciaux :"

#: reference/datamodel.rst:584

#, fuzzy

msgid "Most of these attributes check the type of the assigned value:"

msgstr ""

"La plupart des attributs étiquetés « Accessible en écriture » vérifient le "

"type de la valeur qu'on leur affecte."

#: reference/datamodel.rst:593

#, fuzzy

msgid "The function's documentation string, or ``None`` if unavailable."

msgstr ""

"Chaîne de documentation du module (*docstring* en anglais), ou ``None`` si "

"le module n'en a pas."

#: reference/datamodel.rst:596

msgid ""

"The function's name. See also: :attr:`__name__ attributes <definition."

"__name__>`."

msgstr ""

#: reference/datamodel.rst:600

msgid ""

"The function's :term:`qualified name`. See also: :attr:`__qualname__ "

"attributes <definition.__qualname__>`."

msgstr ""

#: reference/datamodel.rst:606

msgid ""

"The name of the module the function was defined in, or ``None`` if "

"unavailable."

msgstr ""

"Nom du module où la fonction est définie ou ``None`` si ce nom n'est pas "

"disponible."

#: reference/datamodel.rst:610

#, fuzzy

msgid ""

"A :class:`tuple` containing default :term:`parameter` values for those "

"parameters that have defaults, or ``None`` if no parameters have a default "

"value."

msgstr ""

"*N*-uplet contenant les valeurs des arguments par défaut pour ceux qui en "

"sont dotés ou ``None`` si aucun argument n'a de valeur par défaut."

#: reference/datamodel.rst:615

#, fuzzy

msgid ""

"The :ref:`code object <code-objects>` representing the compiled function "

"body."

msgstr "Objet code représentant le corps de la fonction compilée."

#: reference/datamodel.rst:619

#, fuzzy

msgid ""

"The namespace supporting arbitrary function attributes. See also: :attr:"

"`__dict__ attributes <object.__dict__>`."

msgstr "Espace de nommage accueillant les attributs de la fonction."

#: reference/datamodel.rst:623

#, fuzzy