forked from AFPy/python-docs-fr
sed -i 's/\([^m]\)muable/\1mutable/' *.po */*.po (#258)
Closes #123 Reviewed-on: AFPy/python-docs-fr#258 Reviewed-by: Christophe Nanteuil <christophenan@noreply.localhost> Co-authored-by: Julien Palard <julien@palard.fr> Co-committed-by: Julien Palard <julien@palard.fr>
This commit is contained in:
parent
89b8c9f5c2
commit
d5e2f003e5
|
|
@ -604,7 +604,7 @@ list comprehension liste en compréhension (liste en intension est
|
|||
little-endian, big-endian `petit-boutiste, gros-boutiste
|
||||
<https://fr.wikipedia.org/wiki/Endianness>`_
|
||||
mixin type type de mélange
|
||||
mutable muable
|
||||
mutable `mutable <https://git.afpy.org/AFPy/python-docs-fr/issues/123>`_
|
||||
namespace espace de nommage
|
||||
(sauf pour le XML où c'est espace de noms)
|
||||
parameter paramètre
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ msgstr ""
|
|||
"Néanmoins, quand une structure :c:type:`Py_buffer` est en cours de "
|
||||
"remplissage, le tampon sous-jacent est verrouillé pour permettre à "
|
||||
"l'appelant d'utiliser le tampon par la suite, même à l'intérieur d'un bloc :"
|
||||
"c:type:`Py_BEGIN_ALLOW_THREADS`, sans risques de voir des données muables se "
|
||||
"c:type:`Py_BEGIN_ALLOW_THREADS`, sans risques de voir des données mutables se "
|
||||
"faire redimensionner ou supprimer. En conséquence, **il vous appartient "
|
||||
"d'appeler** :c:func:`PyBuffer_Release` après avoir terminé de traiter les "
|
||||
"données (ou après une interruption prématurée du traitement de ces données)."
|
||||
|
|
@ -229,7 +229,7 @@ msgid ""
|
|||
"null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "
|
||||
"encoding."
|
||||
msgstr ""
|
||||
"La même chose que ``s*``, mais n'accepte pas les objets muables. Le résultat "
|
||||
"La même chose que ``s*``, mais n'accepte pas les objets mutables. Le résultat "
|
||||
"est stocké dans deux variables C, la première est un pointeur vers une "
|
||||
"chaîne de caractères C, la seconde contient sa taille. La chaîne de "
|
||||
"caractères peut contenir des octets NULL. Les objets Unicode sont convertis "
|
||||
|
|
@ -1373,7 +1373,7 @@ msgstr ""
|
|||
#~ "d'octets <bytes-like object>` en lecture seule, et définissent un "
|
||||
#~ "pointeur à la place d'une structure tampon. Ils fonctionnent en vérifiant "
|
||||
#~ "que le champ :c:member:`PyBufferProcs.bf_releasebuffer` de l'objet est "
|
||||
#~ "*NULL*, ce qui n'autorise pas les objets muables tels que :class:"
|
||||
#~ "*NULL*, ce qui n'autorise pas les objets mutables tels que :class:"
|
||||
#~ "`bytearray`."
|
||||
|
||||
#~ msgid ""
|
||||
|
|
|
|||
2
dict
2
dict
|
|
@ -122,8 +122,6 @@ mersenne
|
|||
mertz
|
||||
Monty
|
||||
muabilité
|
||||
muable
|
||||
muables
|
||||
multiensemble
|
||||
multiensembles
|
||||
mutex
|
||||
|
|
|
|||
|
|
@ -820,7 +820,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Les *n*-uplets sont immuables, ce qui signifie que lorsqu'un *n*-uplet a été "
|
||||
"créé, vous ne pouvez remplacer aucun de ses éléments par une nouvelle "
|
||||
"valeur. Les listes sont muables, ce qui signifie que vous pouvez toujours "
|
||||
"valeur. Les listes sont mutables, ce qui signifie que vous pouvez toujours "
|
||||
"modifier les éléments d'une liste. Seuls des éléments immuables peuvent être "
|
||||
"utilisés comme clés de dictionnaires, et donc de ``tuple`` et ``list`` seul "
|
||||
"des *n*-uplets peuvent être utilisés comme clés."
|
||||
|
|
@ -922,7 +922,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"L'implémentation de la table de hachage des dictionnaires utilise une valeur "
|
||||
"de hachage calculée à partir de la valeur de la clé pour trouver la clé elle-"
|
||||
"même. Si la clé était un objet muable, sa valeur peut changer, et donc son "
|
||||
"même. Si la clé était un objet mutable, sa valeur peut changer, et donc son "
|
||||
"hachage pourrait également changer. Mais toute personne modifiant l'objet "
|
||||
"clé ne peut pas dire qu'elle a été utilisée comme une clé de dictionnaire. "
|
||||
"Il ne peut déplacer l'entrée dans le dictionnaire. Ainsi, lorsque vous "
|
||||
|
|
@ -975,7 +975,7 @@ msgid ""
|
|||
"copying code would run into an infinite loop."
|
||||
msgstr ""
|
||||
"Faire une copie lors de l'utilisation d'une liste en tant que clé. Cela ne "
|
||||
"fonctionne pas puisque la liste, étant un objet muable, pourrait contenir "
|
||||
"fonctionne pas puisque la liste, étant un objet mutable, pourrait contenir "
|
||||
"une référence à elle-même ou avoir une boucle infinie au niveau du code "
|
||||
"copié."
|
||||
|
||||
|
|
|
|||
|
|
@ -798,7 +798,7 @@ msgstr ""
|
|||
msgid ""
|
||||
"Lists are :term:`mutable`, which means that you can change their content."
|
||||
msgstr ""
|
||||
"Les listes sont des :term:`muable`, ce qui signifie que leur contenu peut "
|
||||
"Les listes sont des :term:`mutable`, ce qui signifie que leur contenu peut "
|
||||
"être modifié."
|
||||
|
||||
#: faq/programming.rst:457
|
||||
|
|
@ -807,7 +807,7 @@ msgid ""
|
|||
"has changed from ``[]`` to ``[10]``. Since both the variables refer to the "
|
||||
"same object, using either name accesses the modified value ``[10]``."
|
||||
msgstr ""
|
||||
"Après l'appel de :meth:`~list.append`, le contenu de l'objet muable est "
|
||||
"Après l'appel de :meth:`~list.append`, le contenu de l'objet mutable est "
|
||||
"passé de ``[]`` à ``[10]``. Vu que les deux variables font référence au même "
|
||||
"objet, il est possible d'accéder à la valeur modifiée ``[10]`` avec chacun "
|
||||
"des noms."
|
||||
|
|
@ -881,7 +881,7 @@ msgid ""
|
|||
"etc.), we can use some specific operations to mutate it and all the "
|
||||
"variables that refer to it will see the change."
|
||||
msgstr ""
|
||||
"Il est possible d'appliquer des opérations qui modifient un objet muable (:"
|
||||
"Il est possible d'appliquer des opérations qui modifient un objet mutable (:"
|
||||
"class:`list`, :class:`dict`, :class:`set`, etc.) et toutes les variables qui "
|
||||
"y font référence verront le changement."
|
||||
|
||||
|
|
@ -942,7 +942,7 @@ msgstr ""
|
|||
|
||||
#: faq/programming.rst:532
|
||||
msgid "By passing a mutable (changeable in-place) object::"
|
||||
msgstr "En passant un objet muable (modifiable sur place) ::"
|
||||
msgstr "En passant un objet mutable (modifiable sur place) ::"
|
||||
|
||||
#: faq/programming.rst:543
|
||||
msgid "By passing in a dictionary that gets mutated::"
|
||||
|
|
@ -2060,7 +2060,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Ceci est dû à la combinaison de deux facteurs : le fait que les opérateurs "
|
||||
"d'affectation incrémentaux sont des opérateurs d'*affectation* et à la "
|
||||
"différence entre les objets muables et immuables en Python."
|
||||
"différence entre les objets mutables et immuables en Python."
|
||||
|
||||
#: faq/programming.rst:1352
|
||||
msgid ""
|
||||
|
|
@ -2070,7 +2070,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Cette discussion est valable, en général, quand des opérateurs d'affectation "
|
||||
"incrémentale sont appliqués aux éléments d'un *n*-uplet qui pointe sur des "
|
||||
"objets muables, mais on prendra ``list`` et ``+=`` comme exemple."
|
||||
"objets mutables, mais on prendra ``list`` et ``+=`` comme exemple."
|
||||
|
||||
#: faq/programming.rst:1356
|
||||
msgid "If you wrote::"
|
||||
|
|
@ -2167,7 +2167,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"L'appel à :meth:`!__iadd__` réussit et la liste est étendue, mais bien que "
|
||||
"``result`` pointe sur le même objet que ``a_tuple[0]``, l'affectation finale "
|
||||
"échoue car les *n*-uplets ne sont pas muables."
|
||||
"échoue car les *n*-uplets ne sont pas mutables."
|
||||
|
||||
#: faq/programming.rst:1433
|
||||
msgid ""
|
||||
|
|
@ -2811,7 +2811,7 @@ msgstr ""
|
|||
#: faq/programming.rst:1871
|
||||
msgid "Likewise, new instances of mutable containers are never identical::"
|
||||
msgstr ""
|
||||
"De même, deux instances fraîchement créées d'un type de conteneurs muables "
|
||||
"De même, deux instances fraîchement créées d'un type de conteneurs mutables "
|
||||
"ne sont jamais identiques ::"
|
||||
|
||||
#: faq/programming.rst:1878
|
||||
|
|
|
|||
|
|
@ -1388,7 +1388,7 @@ msgid ""
|
|||
"value is derived from their :func:`id`."
|
||||
msgstr ""
|
||||
"La plupart des types immuables natifs de Python sont hachables, mais les "
|
||||
"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas ; "
|
||||
"conteneurs mutables (comme les listes ou les dictionnaires) ne le sont pas ; "
|
||||
"les conteneurs immuables (comme les n-uplets ou les ensembles figés) ne sont "
|
||||
"hachables que si leurs éléments sont hachables. Les instances de classes "
|
||||
"définies par les utilisateurs sont hachables par défaut. Elles sont toutes "
|
||||
|
|
@ -1841,7 +1841,7 @@ msgstr ""
|
|||
"Conteneur permettant de rechercher des éléments à partir de clés et "
|
||||
"implémentant les méthodes spécifiées dans les classes mères abstraites des :"
|
||||
"class:`tableaux de correspondances <collections.abc.Mapping>` (immuables) "
|
||||
"ou :class:`tableaux de correspondances muables <collections.abc."
|
||||
"ou :class:`tableaux de correspondances mutables <collections.abc."
|
||||
"MutableMapping>` (voir les :ref:`classes mères abstraites <collections-"
|
||||
"abstract-base-classes>`). Les classes suivantes sont des exemples de "
|
||||
"tableaux de correspondances : :class:`dict`, :class:`collections."
|
||||
|
|
@ -1977,14 +1977,14 @@ msgstr "Voir :term:`ordre de résolution des méthodes`."
|
|||
|
||||
#: glossary.rst:814
|
||||
msgid "mutable"
|
||||
msgstr "muable"
|
||||
msgstr "mutable"
|
||||
|
||||
#: glossary.rst:816
|
||||
msgid ""
|
||||
"Mutable objects can change their value but keep their :func:`id`. See also :"
|
||||
"term:`immutable`."
|
||||
msgstr ""
|
||||
"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. "
|
||||
"Un objet mutable peut changer de valeur tout en gardant le même :func:`id`. "
|
||||
"Voir aussi :term:`immuable`."
|
||||
|
||||
#: glossary.rst:818
|
||||
|
|
|
|||
|
|
@ -526,7 +526,7 @@ msgstr ""
|
|||
|
||||
#: library/collections.abc.rst:260
|
||||
msgid "ABCs for read-only and mutable :term:`sequences <sequence>`."
|
||||
msgstr "ABC pour les :term:`séquences <sequence>` immuables et muables."
|
||||
msgstr "ABC pour les :term:`séquences <sequence>` immuables et mutables."
|
||||
|
||||
#: library/collections.abc.rst:262
|
||||
msgid ""
|
||||
|
|
@ -553,13 +553,13 @@ msgstr ""
|
|||
|
||||
#: library/collections.abc.rst:278
|
||||
msgid "ABCs for read-only and mutable sets."
|
||||
msgstr "ABC pour les ensembles immuables et muables."
|
||||
msgstr "ABC pour les ensembles immuables et mutables."
|
||||
|
||||
#: library/collections.abc.rst:283
|
||||
msgid "ABCs for read-only and mutable :term:`mappings <mapping>`."
|
||||
msgstr ""
|
||||
"ABC pour les :term:`tables de correspondances <mapping>` immuables et "
|
||||
"muables."
|
||||
"mutables."
|
||||
|
||||
#: library/collections.abc.rst:290
|
||||
msgid ""
|
||||
|
|
|
|||
|
|
@ -1436,7 +1436,7 @@ msgid ""
|
|||
"See :meth:`types.SimpleNamespace` for a mutable namespace based on an "
|
||||
"underlying dictionary instead of a tuple."
|
||||
msgstr ""
|
||||
"Voir :meth:`types.SimpleNamespace` pour un espace de nommage muable basé sur "
|
||||
"Voir :meth:`types.SimpleNamespace` pour un espace de nommage mutable basé sur "
|
||||
"un dictionnaire sous-jacent à la place d'un *n*-uplet."
|
||||
|
||||
#: library/collections.rst:1075
|
||||
|
|
@ -1753,7 +1753,7 @@ msgid ""
|
|||
"In addition to supporting the methods and operations of mutable sequences, :"
|
||||
"class:`UserList` instances provide the following attribute:"
|
||||
msgstr ""
|
||||
"En plus de gérer les méthodes et opérations des séquences muables, les "
|
||||
"En plus de gérer les méthodes et opérations des séquences mutables, les "
|
||||
"instances de :class:`UserList` possèdent l'attribut suivant :"
|
||||
|
||||
#: library/collections.rst:1351
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Les instructions d'affectation en Python ne copient pas les objets, elles "
|
||||
"créent des liens entre la cible et l'objet. Concernant les collections qui "
|
||||
"sont muables ou contiennent des éléments muables, une copie est parfois "
|
||||
"sont mutables ou contiennent des éléments mutables, une copie est parfois "
|
||||
"nécessaire, pour pouvoir modifier une copie sans modifier l'autre. Ce module "
|
||||
"met à disposition des opérations de copie génériques superficielle et "
|
||||
"récursive (comme expliqué ci-dessous)."
|
||||
|
|
|
|||
|
|
@ -551,7 +551,7 @@ msgstr ""
|
|||
msgid ""
|
||||
"Since these types are mutable, their value can also be changed afterwards::"
|
||||
msgstr ""
|
||||
"Ces types étant des muables, leur valeur peut aussi être modifiée après "
|
||||
"Ces types étant des mutables, leur valeur peut aussi être modifiée après "
|
||||
"coup ::"
|
||||
|
||||
#: library/ctypes.rst:291
|
||||
|
|
|
|||
|
|
@ -484,7 +484,7 @@ msgstr ""
|
|||
"*default_factory* : s'il est fourni, ce doit être un objet appelable sans "
|
||||
"argument. Il est alors appelé à chaque fois qu'il faut une valeur par défaut "
|
||||
"pour le champ. Ceci permet, entre autres choses, de définir des champs dont "
|
||||
"les valeurs par défaut sont muables. Une erreur se produit si *default* et "
|
||||
"les valeurs par défaut sont mutables. Une erreur se produit si *default* et "
|
||||
"*default_factory* sont donnés tous les deux."
|
||||
|
||||
#: library/dataclasses.rst:258
|
||||
|
|
@ -1161,7 +1161,7 @@ msgstr ""
|
|||
|
||||
#: library/dataclasses.rst:691
|
||||
msgid "Mutable default values"
|
||||
msgstr "Valeurs par défaut muables"
|
||||
msgstr "Valeurs par défaut mutables"
|
||||
|
||||
#: library/dataclasses.rst:693
|
||||
msgid ""
|
||||
|
|
@ -1216,7 +1216,7 @@ msgid ""
|
|||
"Using default factory functions is a way to create new instances of mutable "
|
||||
"types as default values for fields::"
|
||||
msgstr ""
|
||||
"Pour qu'un champ d'un type muable soit par défaut initialisé à un nouvel "
|
||||
"Pour qu'un champ d'un type mutable soit par défaut initialisé à un nouvel "
|
||||
"objet pour chaque instance, utilisez une fonction de fabrique ::"
|
||||
|
||||
# suit un ':'
|
||||
|
|
|
|||
|
|
@ -573,7 +573,7 @@ msgid ""
|
|||
"as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
|
||||
msgstr ""
|
||||
"Renvoie un nouveau tableau d'octets. La classe :class:`bytearray` est une "
|
||||
"séquence muable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède "
|
||||
"séquence mutable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède "
|
||||
"la plupart des méthodes des séquences variables, décrites dans :ref:"
|
||||
"`typesseq-mutable`, ainsi que la plupart des méthodes de la classe :class:"
|
||||
"`bytes`, voir :ref:`bytes-methods`."
|
||||
|
|
@ -2031,7 +2031,7 @@ msgid ""
|
|||
"type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
|
||||
msgstr ""
|
||||
"Contrairement aux apparences, :class:`list` n'est pas une fonction mais un "
|
||||
"type séquentiel muable, comme décrit dans :ref:`typesseq-list` et :ref:"
|
||||
"type séquentiel mutable, comme décrit dans :ref:`typesseq-list` et :ref:"
|
||||
"`typesseq`."
|
||||
|
||||
#: library/functions.rst:1029
|
||||
|
|
|
|||
|
|
@ -1403,7 +1403,7 @@ msgid ""
|
|||
"explicitly bound arguments. Changes in :attr:`arguments` will reflect in :"
|
||||
"attr:`args` and :attr:`kwargs`."
|
||||
msgstr ""
|
||||
"Une correspondance muable entre les noms de paramètres et les valeurs des "
|
||||
"Une correspondance mutable entre les noms de paramètres et les valeurs des "
|
||||
"arguments. Contient seulement les arguments liés explicitement. Les "
|
||||
"changements dans :attr:`arguments` sont reflétés dans :attr:`args` et :attr:"
|
||||
"`kwargs`."
|
||||
|
|
|
|||
|
|
@ -312,7 +312,7 @@ msgid ""
|
|||
"support the dynamic creation of new :class:`ShareableList` instances via "
|
||||
"slicing."
|
||||
msgstr ""
|
||||
"Construit un objet muable compatible avec le type liste dont toutes les "
|
||||
"Construit un objet mutable compatible avec le type liste dont toutes les "
|
||||
"valeurs sont stockées dans un bloc de mémoire partagée. Ceci limite le type "
|
||||
"des valeurs pouvant être stockées aux types natifs ``int``, ``float``, "
|
||||
"``bool``, ``str`` (de moins de 10 Mo chacune), ``bytes`` (de moins de 10 Mo "
|
||||
|
|
|
|||
|
|
@ -1779,7 +1779,7 @@ msgid ""
|
|||
"move on to the next buffer in the sequence to hold the rest of the data."
|
||||
msgstr ""
|
||||
"Lit depuis un descripteur de fichier *fd*, à la position *offset* dans des :"
|
||||
"term:`objets bytes-compatibles <bytes-like object>` muables *buffers*, sans "
|
||||
"term:`objets bytes-compatibles <bytes-like object>` mutables *buffers*, sans "
|
||||
"modifier la position dans le fichier. Les données sont transférées dans "
|
||||
"chaque tampon, jusqu'à ce qu'il soit plein, tour à tour."
|
||||
|
||||
|
|
@ -2132,7 +2132,7 @@ msgid ""
|
|||
"rest of the data."
|
||||
msgstr ""
|
||||
"Lit depuis un descripteur de fichier *fd* dans une séquence d':term:`objets "
|
||||
"bytes-compatibles <bytes-like object>` muables : *buffers*. Les données sont "
|
||||
"bytes-compatibles <bytes-like object>` mutables : *buffers*. Les données sont "
|
||||
"transférées dans chaque tampon, jusqu'à ce qu'il soit plein, tour à tour."
|
||||
|
||||
#: library/os.rst:1560
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ msgstr ""
|
|||
"pointent dessus, depuis différents endroits dans la hiérarchie sérialisée. "
|
||||
"Le module :mod:`pickle` repère ces partages et ne stocke ces objets qu'une "
|
||||
"seule fois. Les objets partagés restent ainsi partagés, ce qui peut être "
|
||||
"très important pour les objets muables."
|
||||
"très important pour les objets mutables."
|
||||
|
||||
#: library/pickle.rst:72
|
||||
msgid ""
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ msgid ""
|
|||
"mutated)."
|
||||
msgstr ""
|
||||
"À cause de la sémantique de Python, une étagère ne peut pas savoir "
|
||||
"lorsqu'une entrée muable de dictionnaire persistant est modifiée. Par défaut "
|
||||
"lorsqu'une entrée mutable de dictionnaire persistant est modifiée. Par défaut "
|
||||
"les objets modifiés sont écrits *seulement* lorsqu'ils sont assignés à une "
|
||||
"étagère (voir :ref:`shelve-example`). Si le paramètre optionnel *writeback* "
|
||||
"est mis à ``True``, toutes les entrées déjà accédées sont aussi mises en "
|
||||
|
|
@ -244,7 +244,7 @@ msgstr ""
|
|||
"Si le paramètre *writeback* est ``True``, l'objet garde en cache toutes les "
|
||||
"entrées accédées et les écrit dans le *dict* aux moments de synchronisation "
|
||||
"et de fermeture. Cela permet des opérations naturelles sur les entrées "
|
||||
"muables, mais peut consommer beaucoup plus de mémoire et rendre les temps de "
|
||||
"mutables, mais peut consommer beaucoup plus de mémoire et rendre les temps de "
|
||||
"synchronisation et de fermeture très longs."
|
||||
|
||||
#: library/shelve.rst:132
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ msgid ""
|
|||
"rearrange their members in place, and don't return a specific item, never "
|
||||
"return the collection instance itself but ``None``."
|
||||
msgstr ""
|
||||
"Certaines classes de collection sont muables. Les méthodes qui ajoutent, "
|
||||
"Certaines classes de collection sont mutables. Les méthodes qui ajoutent, "
|
||||
"retirent, ou réorganisent leurs éléments sur place, et qui ne renvoient pas "
|
||||
"un élément spécifique, ne renvoient jamais l'instance de la collection elle-"
|
||||
"même, mais ``None``."
|
||||
|
|
@ -1726,7 +1726,7 @@ msgstr ""
|
|||
"si vous concaténez des :class:`bytes`, vous pouvez aussi utiliser :meth:"
|
||||
"`bytes.join` ou :class:`io.BytesIO`, ou vous pouvez faire les concaténations "
|
||||
"sur place avec un objet :class:`bytearray`. Les objets :class:`bytearray` "
|
||||
"sont muables et ont un mécanisme de sur-allocation efficace ;"
|
||||
"sont mutables et ont un mécanisme de sur-allocation efficace ;"
|
||||
|
||||
# énumération
|
||||
#: library/stdtypes.rst:1050
|
||||
|
|
@ -1779,7 +1779,7 @@ msgid ""
|
|||
"`hash` built-in."
|
||||
msgstr ""
|
||||
"La seule opération que les types de séquences immuables implémentent et qui "
|
||||
"n'est pas implémentée par les types de séquences muables est la fonction "
|
||||
"n'est pas implémentée par les types de séquences mutables est la fonction "
|
||||
"native :func:`hash`."
|
||||
|
||||
#: library/stdtypes.rst:1083
|
||||
|
|
@ -1802,7 +1802,7 @@ msgstr ""
|
|||
|
||||
#: library/stdtypes.rst:1094
|
||||
msgid "Mutable Sequence Types"
|
||||
msgstr "Types de séquences muables"
|
||||
msgstr "Types de séquences mutables"
|
||||
|
||||
#: library/stdtypes.rst:1101
|
||||
msgid ""
|
||||
|
|
@ -1811,7 +1811,7 @@ msgid ""
|
|||
"easier to correctly implement these operations on custom sequence types."
|
||||
msgstr ""
|
||||
"Les opérations dans le tableau ci-dessous sont définies sur les types de "
|
||||
"séquences muables. La classe mère abstraite :class:`collections.abc."
|
||||
"séquences mutables. La classe mère abstraite :class:`collections.abc."
|
||||
"MutableSequence` est prévue pour faciliter l'implémentation correcte de ces "
|
||||
"opérations sur les types de séquences personnalisées."
|
||||
|
||||
|
|
@ -1823,7 +1823,7 @@ msgid ""
|
|||
"integers that meet the value restriction ``0 <= x <= 255``)."
|
||||
msgstr ""
|
||||
"Dans le tableau ci-dessosus, *s* est une instance d'un type de séquence "
|
||||
"muable, *t* est un objet itérable et *x* est un objet arbitraire qui répond "
|
||||
"mutable, *t* est un objet itérable et *x* est un objet arbitraire qui répond "
|
||||
"à toutes les restrictions de type et de valeur imposées par *s* (par "
|
||||
"exemple, :class:`bytearray` accepte uniquement des nombres entiers qui "
|
||||
"répondent à la restriction de la valeur ``0 <= x <= 255``)."
|
||||
|
|
@ -1986,7 +1986,7 @@ msgid ""
|
|||
"classes provide it."
|
||||
msgstr ""
|
||||
":meth:`clear` et :meth:`!copy` sont incluses pour la compatibilité avec les "
|
||||
"interfaces des conteneurs muables qui ne gèrent pas les opérations de "
|
||||
"interfaces des conteneurs mutables qui ne gèrent pas les opérations de "
|
||||
"découpage (comme :class:`dict` et :class:`set`). :meth:`!copy` ne fait pas "
|
||||
"partie des classes mères abstraites (*ABC*) de :class:`collections.abc."
|
||||
"MutableSequence`, mais la plupart des classes implémentées gérant des "
|
||||
|
|
@ -2019,7 +2019,7 @@ msgid ""
|
|||
"homogeneous items (where the precise degree of similarity will vary by "
|
||||
"application)."
|
||||
msgstr ""
|
||||
"Les listes sont des séquences muables, généralement utilisées pour stocker "
|
||||
"Les listes sont des séquences mutables, généralement utilisées pour stocker "
|
||||
"des collections d'éléments homogènes (le degré de similitude varie selon "
|
||||
"l'usage)."
|
||||
|
||||
|
|
@ -2085,7 +2085,7 @@ msgid ""
|
|||
"additional method:"
|
||||
msgstr ""
|
||||
"Les listes gèrent toutes les opérations des séquences :ref:`communes "
|
||||
"<typesseq-common>` et :ref:`muables <typesseq-mutable>`. Les listes "
|
||||
"<typesseq-common>` et :ref:`mutables <typesseq-mutable>`. Les listes "
|
||||
"fournissent également la méthode supplémentaire suivante :"
|
||||
|
||||
#: library/stdtypes.rst:1249
|
||||
|
|
@ -2554,7 +2554,7 @@ msgid ""
|
|||
"StringIO` can be used to efficiently construct strings from multiple "
|
||||
"fragments."
|
||||
msgstr ""
|
||||
"Il n'y a aucun type de chaîne muable, mais :meth:`str.join` ou :class:`io."
|
||||
"Il n'y a aucun type de chaîne mutable, mais :meth:`str.join` ou :class:`io."
|
||||
"StringIO` peuvent être utilisées pour construire efficacement des chaînes à "
|
||||
"partir de plusieurs fragments."
|
||||
|
||||
|
|
@ -4362,7 +4362,7 @@ msgid ""
|
|||
":class:`bytearray` objects are a mutable counterpart to :class:`bytes` "
|
||||
"objects."
|
||||
msgstr ""
|
||||
"Les objets :class:`bytearray` sont l'équivalent muable des objets :class:"
|
||||
"Les objets :class:`bytearray` sont l'équivalent mutable des objets :class:"
|
||||
"`bytes`."
|
||||
|
||||
#: library/stdtypes.rst:2599
|
||||
|
|
@ -4404,8 +4404,8 @@ msgid ""
|
|||
"mutable>` sequence operations in addition to the common bytes and bytearray "
|
||||
"operations described in :ref:`bytes-methods`."
|
||||
msgstr ""
|
||||
"Comme les *bytearray* sont muables, ils prennent en charge les opérations de "
|
||||
"séquences :ref:`muables <typesseq-mutable>` en plus des opérations communes "
|
||||
"Comme les *bytearray* sont mutables, ils prennent en charge les opérations de "
|
||||
"séquences :ref:`mutables <typesseq-mutable>` en plus des opérations communes "
|
||||
"de *bytes* et *bytearray* décrites dans :ref:`bytes-methods`."
|
||||
|
||||
#: library/stdtypes.rst:2611
|
||||
|
|
@ -5894,9 +5894,9 @@ msgid ""
|
|||
"of another set."
|
||||
msgstr ""
|
||||
"Il existe actuellement deux types natifs pour les ensembles, :class:`set` "
|
||||
"et :class:`frozenset`. Le type :class:`set` est muable — son contenu peut "
|
||||
"et :class:`frozenset`. Le type :class:`set` est mutable — son contenu peut "
|
||||
"changer en utilisant des méthodes comme :meth:`~set.add` et :meth:`~set."
|
||||
"remove`. Puisqu'il est muable, il n'a pas de valeur de hachage et ne peut "
|
||||
"remove`. Puisqu'il est mutable, il n'a pas de valeur de hachage et ne peut "
|
||||
"donc pas être utilisé ni comme clé de dictionnaire ni comme élément d'un "
|
||||
"autre ensemble. Le type :class:`frozenset` est immuable et :term:`hachable "
|
||||
"<hashable>` — son contenu ne peut être modifié après sa création, il peut "
|
||||
|
|
@ -6218,7 +6218,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Un objet :term:`tableau de correspondances <mapping>` (*mapping*) fait "
|
||||
"correspondre des valeurs :term:`hachables <hashable>` à des objets "
|
||||
"arbitraires. Les tableaux de correspondances sont des objets muables. Il "
|
||||
"arbitraires. Les tableaux de correspondances sont des objets mutables. Il "
|
||||
"n'existe pour le moment qu'un type de tableau de correspondances standard, "
|
||||
"le :dfn:`dictionary`. (Pour les autres conteneurs, voir les types natifs :"
|
||||
"class:`liste <list>`, :class:`ensemble <set>` et :class:`n-uplet <tuple>`, "
|
||||
|
|
@ -6234,7 +6234,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Les clés d'un dictionnaire sont *presque* des données arbitraires. Les "
|
||||
"valeurs qui ne sont pas :term:`hachables <hashable>`, c'est-à-dire les "
|
||||
"valeurs contenant des listes, dictionnaires ou autres types muables (qui "
|
||||
"valeurs contenant des listes, dictionnaires ou autres types mutables (qui "
|
||||
"sont comparés à l'aide de leurs valeurs plutôt que par l'identité de "
|
||||
"l'objet) ne peuvent pas être utilisées comme clés. Des valeurs qui sont "
|
||||
"considérées égales lors d'une comparaison (comme ``1``, ``1.0`` et ``True``) "
|
||||
|
|
@ -8781,7 +8781,7 @@ msgstr ""
|
|||
#: library/stdtypes.rst:1461
|
||||
#, fuzzy
|
||||
msgid "text sequence type"
|
||||
msgstr "Types de séquences muables"
|
||||
msgstr "Types de séquences mutables"
|
||||
|
||||
#: library/stdtypes.rst:1510 library/stdtypes.rst:1528
|
||||
#, fuzzy
|
||||
|
|
@ -8872,7 +8872,7 @@ msgstr ""
|
|||
#: library/stdtypes.rst:2458
|
||||
#, fuzzy
|
||||
msgid "binary sequence types"
|
||||
msgstr "Types de séquences muables"
|
||||
msgstr "Types de séquences mutables"
|
||||
|
||||
#: library/stdtypes.rst:2466
|
||||
#, fuzzy
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ msgstr ""
|
|||
"Project-Id-Version: Python 3\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"POT-Creation-Date: 2023-07-23 14:38+0200\n"
|
||||
"PO-Revision-Date: 2022-11-20 21:56+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"
|
||||
|
|
@ -82,17 +82,17 @@ msgid ""
|
|||
"lists are mutable."
|
||||
msgstr ""
|
||||
"La *valeur* de certains objets peut changer. Les objets dont la valeur peut "
|
||||
"changer sont dits *muables* (*mutable* en anglais) ; 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 muable peut varier lorsque la valeur de "
|
||||
"l'objet muable 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 muables."
|
||||
"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 ""
|
||||
|
|
@ -182,8 +182,8 @@ msgstr ""
|
|||
"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 muable, sa valeur change si cet "
|
||||
"objet muable est modifié."
|
||||
"uplet) contient une référence à un objet mutable, sa valeur change si cet "
|
||||
"objet mutable est modifié."
|
||||
|
||||
#: reference/datamodel.rst:106
|
||||
msgid ""
|
||||
|
|
@ -201,7 +201,7 @@ msgstr ""
|
|||
"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 muables cela n'est pas autorisé. "
|
||||
"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 "
|
||||
|
|
@ -545,8 +545,8 @@ msgid ""
|
|||
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 muables et peuvent être modifiés ; cependant, les "
|
||||
"objets directement référencés par un objet immuable ne peuvent pas être "
|
||||
"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:304
|
||||
|
|
@ -626,7 +626,7 @@ msgstr ""
|
|||
|
||||
#: reference/datamodel.rst:383
|
||||
msgid "Mutable sequences"
|
||||
msgstr "Séquences muables"
|
||||
msgstr "Séquences mutables"
|
||||
|
||||
#: reference/datamodel.rst:359
|
||||
msgid ""
|
||||
|
|
@ -634,14 +634,14 @@ msgid ""
|
|||
"and slicing notations can be used as the target of assignment and :keyword:"
|
||||
"`del` (delete) statements."
|
||||
msgstr ""
|
||||
"Les séquences muables peuvent être modifiées après leur création. Les "
|
||||
"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:363
|
||||
msgid "There are currently two intrinsic mutable sequence types:"
|
||||
msgstr "Il existe aujourd'hui deux types intrinsèques de séquences muables :"
|
||||
msgstr "Il existe aujourd'hui deux types intrinsèques de séquences mutables :"
|
||||
|
||||
#: reference/datamodel.rst:370
|
||||
msgid "Lists"
|
||||
|
|
@ -669,9 +669,9 @@ msgid ""
|
|||
"unhashable), byte arrays otherwise provide the same interface and "
|
||||
"functionality as immutable :class:`bytes` objects."
|
||||
msgstr ""
|
||||
"Un objet *bytearray* est un tableau muable. Il est créé par la fonction "
|
||||
"native constructeur :func:`bytearray`. À part la propriété d'être muable (et "
|
||||
"donc de ne pas pouvoir calculer son empreinte par hachage), un tableau "
|
||||
"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`."
|
||||
|
||||
|
|
@ -681,7 +681,7 @@ msgid ""
|
|||
"mutable sequence type, as does the :mod:`collections` module."
|
||||
msgstr ""
|
||||
"Le module d'extension :mod:`array` fournit un autre exemple de type de "
|
||||
"séquence muable, de même que le module :mod:`collections`."
|
||||
"séquence mutable, de même que le module :mod:`collections`."
|
||||
|
||||
#: reference/datamodel.rst:417
|
||||
msgid "Set types"
|
||||
|
|
@ -731,9 +731,9 @@ msgid ""
|
|||
"constructor and can be modified afterwards by several methods, such as :meth:"
|
||||
"`~set.add`."
|
||||
msgstr ""
|
||||
"Ils représentent les ensembles muables. 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`."
|
||||
"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:417
|
||||
msgid "Frozen sets"
|
||||
|
|
@ -793,7 +793,7 @@ 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 "
|
||||
"muables qui sont comparés par valeur plutôt que par l'identifiant de "
|
||||
"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 "
|
||||
|
|
@ -818,8 +818,8 @@ msgid ""
|
|||
"Dictionaries are mutable; they can be created by the ``{...}`` notation (see "
|
||||
"section :ref:`dict`)."
|
||||
msgstr ""
|
||||
"Les dictionnaires sont muables : ils peuvent être créés par la notation ``{…}"
|
||||
"`` (reportez-vous à la section :ref:`dict`)."
|
||||
"Les dictionnaires sont mutables : ils peuvent être créés par la notation "
|
||||
"``{…}`` (reportez-vous à la section :ref:`dict`)."
|
||||
|
||||
#: reference/datamodel.rst:457
|
||||
msgid ""
|
||||
|
|
@ -1686,7 +1686,7 @@ msgstr ""
|
|||
"dans l'objet code (parce que ce sont des valeurs calculées au moment de "
|
||||
"l'exécution). Contrairement aux objets fonctions, les objets codes sont "
|
||||
"immuables et ne contiennent aucune référence (directe ou indirecte) à des "
|
||||
"objets muables."
|
||||
"objets mutables."
|
||||
|
||||
#: reference/datamodel.rst:975
|
||||
#, fuzzy
|
||||
|
|
@ -4286,7 +4286,7 @@ msgstr ""
|
|||
"abc.MutableMapping` pour aider à la création de ces méthodes à partir d'un "
|
||||
"ensemble de base composé de :meth:`~object.__getitem__`, :meth:`~object."
|
||||
"__setitem__`, :meth:`~object.__delitem__` et :meth:`keys`. Les séquences "
|
||||
"muables doivent fournir les méthodes :meth:`append`, :meth:`count`, :meth:"
|
||||
"mutables doivent fournir les méthodes :meth:`append`, :meth:`count`, :meth:"
|
||||
"`index`, :meth:`extend`, :meth:`insert`, :meth:`pop`, :meth:`remove`, :meth:"
|
||||
"`reverse` et :meth:`sort`, comme les objets :class:`listes <list>` standards "
|
||||
"de Python. Enfin, les types séquences doivent implémenter l'addition (dans "
|
||||
|
|
|
|||
|
|
@ -425,7 +425,7 @@ msgid ""
|
|||
"supplied, the set is constructed from the elements resulting from the "
|
||||
"comprehension."
|
||||
msgstr ""
|
||||
"Un agencement d'ensemble produit un nouvel objet ensemble muable, le contenu "
|
||||
"Un agencement d'ensemble produit un nouvel objet ensemble mutable, le contenu "
|
||||
"étant spécifié soit par une séquence d'expression, soit par une "
|
||||
"compréhension. Quand une liste (dont les éléments sont séparés par des "
|
||||
"virgules) est fournie, ses éléments sont évalués de la gauche vers la droite "
|
||||
|
|
@ -520,7 +520,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"Les restrictions relatives aux types des clés sont données dans la section :"
|
||||
"ref:`types` (pour résumer, le type de la clé doit être :term:`hachable "
|
||||
"<hashable>`, ce qui exclut tous les objets muables). Les collisions entre "
|
||||
"<hashable>`, ce qui exclut tous les objets mutables). Les collisions entre "
|
||||
"les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui "
|
||||
"apparaît le plus à droite dans l'agencement) stockée prévaut pour une clé "
|
||||
"donnée."
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ msgid ""
|
|||
"attributes or items of mutable objects:"
|
||||
msgstr ""
|
||||
"Les assignations sont utilisées pour lier ou relier des noms à des valeurs "
|
||||
"et modifier des attributs ou des éléments d'objets muables :"
|
||||
"et modifier des attributs ou des éléments d'objets mutables :"
|
||||
|
||||
#: reference/simple_stmts.rst:96
|
||||
msgid ""
|
||||
|
|
@ -111,8 +111,8 @@ msgid ""
|
|||
"section :ref:`types`)."
|
||||
msgstr ""
|
||||
"Une assignation est définie récursivement en fonction de la forme de la "
|
||||
"cible (une liste). Quand la cible est une partie d'un objet muable (une "
|
||||
"référence à un attribut, une sélection ou une tranche), l'objet muable doit "
|
||||
"cible (une liste). Quand la cible est une partie d'un objet mutable (une "
|
||||
"référence à un attribut, une sélection ou une tranche), l'objet mutable doit "
|
||||
"effectuer l'assignation au final et décider de sa validité, voire lever une "
|
||||
"exception si l'assignation n'est pas acceptable. Les règles suivies par les "
|
||||
"différents types et les exceptions levées sont données dans les définitions "
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ msgstr ""
|
|||
"pas au premier coup d'œil en Python et il peut être ignoré tant qu'on "
|
||||
"travaille avec des types de base immuables (nombres, chaînes, *n*-uplets). "
|
||||
"Cependant, les alias peuvent produire des effets surprenants sur la "
|
||||
"sémantique d'un code Python mettant en jeu des objets muables comme les "
|
||||
"sémantique d'un code Python mettant en jeu des objets mutables comme les "
|
||||
"listes, les dictionnaires et la plupart des autres types. En général, leur "
|
||||
"utilisation est bénéfique au programme car les alias se comportent, d'un "
|
||||
"certain point de vue, comme des pointeurs. Par exemple, transmettre un objet "
|
||||
|
|
@ -771,7 +771,7 @@ msgid ""
|
|||
"by all *Dog* instances::"
|
||||
msgstr ""
|
||||
"Comme nous l'avons vu dans :ref:`tut-object`, les données partagées :term:"
|
||||
"`muable <muable>` (telles que les listes, dictionnaires, etc.) peuvent avoir "
|
||||
"`mutable <muable>` (telles que les listes, dictionnaires, etc.) peuvent avoir "
|
||||
"des effets surprenants. Par exemple, la liste *tricks* dans le code suivant "
|
||||
"ne devrait pas être utilisée en tant que variable de classe car, dans ce "
|
||||
"cas, une seule liste est partagée par toutes les instances de *Dog* ::"
|
||||
|
|
|
|||
|
|
@ -772,7 +772,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"**Avertissement important :** la valeur par défaut n'est évaluée qu'une "
|
||||
"seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
|
||||
"objet muable tel qu'une liste, un dictionnaire ou des instances de la "
|
||||
"objet mutable tel qu'une liste, un dictionnaire ou des instances de la "
|
||||
"plupart des classes. Par exemple, la fonction suivante accumule les "
|
||||
"arguments qui lui sont passés au fil des appels successifs ::"
|
||||
|
||||
|
|
@ -1422,7 +1422,7 @@ msgid ""
|
|||
"to it (items inserted into a list)."
|
||||
msgstr ""
|
||||
"En fait, *appels par référence d'objets* serait sans doute une description "
|
||||
"plus juste dans la mesure où, si un objet muable est passé en argument, "
|
||||
"plus juste dans la mesure où, si un objet mutable est passé en argument, "
|
||||
"l'appelant verra toutes les modifications qui lui auront été apportées par "
|
||||
"l'appelé (insertion d'éléments dans une liste…)."
|
||||
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ msgstr ""
|
|||
"Vous avez probablement remarqué que les méthodes qui ne font que modifier la "
|
||||
"liste, comme ``insert``, ``remove`` ou ``sort``, n'affichent pas de valeur "
|
||||
"de retour (elles renvoient ``None``) [#]_. C'est un principe respecté par "
|
||||
"toutes les structures de données muables en Python."
|
||||
"toutes les structures de données mutables en Python."
|
||||
|
||||
#: tutorial/datastructures.rst:128
|
||||
msgid ""
|
||||
|
|
@ -424,7 +424,7 @@ msgstr ""
|
|||
"celles-ci sont souvent nécessaires (notamment lorsqu'un *n*-uplet fait "
|
||||
"partie d'une expression plus longue). Il n'est pas possible d'affecter de "
|
||||
"valeur à un élément d'un *n*-uplet ; par contre, il est en revanche possible "
|
||||
"de créer des *n*-uplets contenant des objets muables, comme des listes."
|
||||
"de créer des *n*-uplets contenant des objets mutables, comme des listes."
|
||||
|
||||
#: tutorial/datastructures.rst:408
|
||||
msgid ""
|
||||
|
|
@ -442,7 +442,7 @@ msgstr ""
|
|||
"séquences hétérogènes d'éléments auxquelles on accède par "
|
||||
"« dissociation » (*unpacking* en anglais, voir plus loin) ou par indice (ou "
|
||||
"même par attribut dans le cas des :func:`namedtuples <collections."
|
||||
"namedtuple>`). Les listes sont souvent :term:`muables <muable>` et "
|
||||
"namedtuple>`). Les listes sont souvent :term:`mutables <muable>` et "
|
||||
"contiennent des éléments généralement homogènes auxquels on accède en "
|
||||
"itérant sur la liste."
|
||||
|
||||
|
|
@ -555,7 +555,7 @@ msgstr ""
|
|||
"n'importe quel type immuable ; les chaînes de caractères et les nombres "
|
||||
"peuvent toujours être des clés. Des *n*-uplets peuvent être utilisés comme "
|
||||
"clés s'ils ne contiennent que des chaînes, des nombres ou des *n*-uplets ; "
|
||||
"si un *n*-uplet contient un objet muable, de façon directe ou indirecte, il "
|
||||
"si un *n*-uplet contient un objet mutable, de façon directe ou indirecte, il "
|
||||
"ne peut pas être utilisé comme une clé. Vous ne pouvez pas utiliser des "
|
||||
"listes comme clés, car les listes peuvent être modifiées en place en "
|
||||
"utilisant des affectations par position, par tranches ou via des méthodes "
|
||||
|
|
|
|||
|
|
@ -528,7 +528,7 @@ msgid ""
|
|||
"type, i.e. it is possible to change their content::"
|
||||
msgstr ""
|
||||
"Mais à la différence des chaînes qui sont :term:`immuables <immutable>`, les "
|
||||
"listes sont :term:`muables <mutable>` : il est possible de modifier leur "
|
||||
"listes sont :term:`mutables <mutable>` : il est possible de modifier leur "
|
||||
"contenu ::"
|
||||
|
||||
#: tutorial/introduction.rst:430
|
||||
|
|
|
|||
|
|
@ -3105,7 +3105,7 @@ msgstr ""
|
|||
"Les objets ``Literal`` lèvent maintenant une exception :exc:`TypeError` lors "
|
||||
"des comparaisons d'égalités si n'importe quel de leurs paramètres n'est pas :"
|
||||
"term:`immuable <immutable>`. Prenez-note que déclarer un ``Literal`` avec un "
|
||||
"paramètre muable ne lève pas une erreur ::"
|
||||
"paramètre mutable ne lève pas une erreur ::"
|
||||
|
||||
#: whatsnew/3.9.rst:1519
|
||||
msgid "(Contributed by Yurii Karabas in :issue:`42345`.)"
|
||||
|
|
|
|||
Loading…
Reference in New Issue